scythe_codegen/backends/
ruby_mysql2.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};
8
9use scythe_core::analyzer::{AnalyzedQuery, CompositeInfo, EnumInfo};
10use scythe_core::errors::{ErrorCode, ScytheError};
11use scythe_core::parser::QueryCommand;
12
13use crate::backend_trait::{CodegenBackend, ResolvedColumn, ResolvedParam};
14
15const DEFAULT_MANIFEST_TOML: &str = include_str!("../../manifests/ruby-mysql2.toml");
16
17pub struct RubyMysql2Backend {
18    manifest: BackendManifest,
19}
20
21impl RubyMysql2Backend {
22    pub fn new(engine: &str) -> Result<Self, ScytheError> {
23        match engine {
24            "mysql" | "mariadb" => {}
25            _ => {
26                return Err(ScytheError::new(
27                    ErrorCode::InternalError,
28                    format!("ruby-mysql2 only supports MySQL, got engine '{}'", engine),
29                ));
30            }
31        }
32        let manifest_path = Path::new("backends/ruby-mysql2/manifest.toml");
33        let manifest = if manifest_path.exists() {
34            load_manifest(manifest_path)
35                .map_err(|e| ScytheError::new(ErrorCode::InternalError, format!("manifest: {e}")))?
36        } else {
37            toml::from_str(DEFAULT_MANIFEST_TOML)
38                .map_err(|e| ScytheError::new(ErrorCode::InternalError, format!("manifest: {e}")))?
39        };
40        Ok(Self { manifest })
41    }
42}
43
44/// Map a neutral type to a Ruby type coercion method for mysql2.
45fn ruby_coercion(neutral_type: &str) -> &'static str {
46    match neutral_type {
47        "int16" | "int32" | "int64" => ".to_i",
48        "float32" | "float64" => ".to_f",
49        "bool" => " == 1",
50        _ => "",
51    }
52}
53
54impl CodegenBackend for RubyMysql2Backend {
55    fn name(&self) -> &str {
56        "ruby-mysql2"
57    }
58
59    fn manifest(&self) -> &scythe_backend::manifest::BackendManifest {
60        &self.manifest
61    }
62
63    fn supported_engines(&self) -> &[&str] {
64        &["mysql"]
65    }
66
67    fn file_header(&self) -> String {
68        "# frozen_string_literal: true\n\n# Auto-generated by scythe. Do not edit.\n".to_string()
69    }
70
71    fn generate_row_struct(
72        &self,
73        query_name: &str,
74        columns: &[ResolvedColumn],
75    ) -> Result<String, ScytheError> {
76        let struct_name = row_struct_name(query_name, &self.manifest.naming);
77        let fields = columns
78            .iter()
79            .map(|c| format!(":{}", c.field_name))
80            .collect::<Vec<_>>()
81            .join(", ");
82        let mut out = String::new();
83        let _ = writeln!(out, "{} = Data.define({})", struct_name, fields);
84        Ok(out)
85    }
86
87    fn generate_model_struct(
88        &self,
89        table_name: &str,
90        columns: &[ResolvedColumn],
91    ) -> Result<String, ScytheError> {
92        let name = to_pascal_case(table_name);
93        self.generate_row_struct(&name, columns)
94    }
95
96    fn generate_query_fn(
97        &self,
98        analyzed: &AnalyzedQuery,
99        struct_name: &str,
100        columns: &[ResolvedColumn],
101        params: &[ResolvedParam],
102    ) -> Result<String, ScytheError> {
103        let func_name = fn_name(&analyzed.name, &self.manifest.naming);
104        let sql = super::clean_sql(&analyzed.sql);
105        let mut out = String::new();
106
107        let param_list = params
108            .iter()
109            .map(|p| p.field_name.clone())
110            .collect::<Vec<_>>()
111            .join(", ");
112        let sep = if param_list.is_empty() { "" } else { ", " };
113
114        let _ = writeln!(out, "def self.{}(client{}{})", func_name, sep, param_list);
115
116        let param_array = if params.is_empty() {
117            "[]".to_string()
118        } else {
119            format!(
120                "[{}]",
121                params
122                    .iter()
123                    .map(|p| p.field_name.clone())
124                    .collect::<Vec<_>>()
125                    .join(", ")
126            )
127        };
128
129        match &analyzed.command {
130            QueryCommand::One => {
131                let _ = writeln!(out, "  stmt = client.prepare(\"{}\")", sql);
132                let _ = writeln!(
133                    out,
134                    "  results = stmt.execute({})",
135                    param_array.trim_start_matches('[').trim_end_matches(']')
136                );
137                let _ = writeln!(out, "  row = results.first");
138                let _ = writeln!(out, "  return nil if row.nil?");
139
140                let fields = columns
141                    .iter()
142                    .map(|c| {
143                        let coercion = ruby_coercion(&c.neutral_type);
144                        if c.nullable {
145                            format!(
146                                "{}: row[\"{}\"]&.then {{ |v| v{} }}",
147                                c.field_name, c.name, coercion
148                            )
149                        } else {
150                            format!("{}: row[\"{}\"]{}", c.field_name, c.name, coercion)
151                        }
152                    })
153                    .collect::<Vec<_>>()
154                    .join(", ");
155                let _ = writeln!(out, "  {}.new({})", struct_name, fields);
156            }
157            QueryCommand::Many | QueryCommand::Batch => {
158                let _ = writeln!(out, "  stmt = client.prepare(\"{}\")", sql);
159                let _ = writeln!(
160                    out,
161                    "  results = stmt.execute({})",
162                    param_array.trim_start_matches('[').trim_end_matches(']')
163                );
164                let _ = writeln!(out, "  results.map do |row|");
165                let fields = columns
166                    .iter()
167                    .map(|c| {
168                        let coercion = ruby_coercion(&c.neutral_type);
169                        if c.nullable {
170                            format!(
171                                "{}: row[\"{}\"]&.then {{ |v| v{} }}",
172                                c.field_name, c.name, coercion
173                            )
174                        } else {
175                            format!("{}: row[\"{}\"]{}", c.field_name, c.name, coercion)
176                        }
177                    })
178                    .collect::<Vec<_>>()
179                    .join(", ");
180                let _ = writeln!(out, "    {}.new({})", struct_name, fields);
181                let _ = writeln!(out, "  end");
182            }
183            QueryCommand::Exec => {
184                let _ = writeln!(out, "  stmt = client.prepare(\"{}\")", sql);
185                let _ = writeln!(
186                    out,
187                    "  stmt.execute({})",
188                    param_array.trim_start_matches('[').trim_end_matches(']')
189                );
190                let _ = writeln!(out, "  nil");
191            }
192            QueryCommand::ExecResult | QueryCommand::ExecRows => {
193                let _ = writeln!(out, "  stmt = client.prepare(\"{}\")", sql);
194                let _ = writeln!(
195                    out,
196                    "  stmt.execute({})",
197                    param_array.trim_start_matches('[').trim_end_matches(']')
198                );
199                let _ = writeln!(out, "  stmt.affected_rows");
200            }
201        }
202
203        let _ = write!(out, "end");
204        Ok(out)
205    }
206
207    fn generate_enum_def(&self, enum_info: &EnumInfo) -> Result<String, ScytheError> {
208        let type_name = enum_type_name(&enum_info.sql_name, &self.manifest.naming);
209        let mut out = String::new();
210        let _ = writeln!(out, "module {}", type_name);
211        for value in &enum_info.values {
212            let variant = enum_variant_name(value, &self.manifest.naming);
213            let _ = writeln!(out, "  {} = \"{}\"", variant, value);
214        }
215        let all_values = enum_info
216            .values
217            .iter()
218            .map(|v| enum_variant_name(v, &self.manifest.naming))
219            .collect::<Vec<_>>()
220            .join(", ");
221        let _ = writeln!(out, "  ALL = [{}].freeze", all_values);
222        let _ = write!(out, "end");
223        Ok(out)
224    }
225
226    fn generate_composite_def(&self, composite: &CompositeInfo) -> Result<String, ScytheError> {
227        let name = to_pascal_case(&composite.sql_name);
228        let mut out = String::new();
229        if composite.fields.is_empty() {
230            let _ = writeln!(out, "{} = Data.define()", name);
231        } else {
232            let fields = composite
233                .fields
234                .iter()
235                .map(|f| format!(":{}", f.name))
236                .collect::<Vec<_>>()
237                .join(", ");
238            let _ = writeln!(out, "{} = Data.define({})", name, fields);
239        }
240        Ok(out)
241    }
242}
scythe_codegen/backends/ruby_mysql2.rs

scythe_codegen/backends/
ruby_mysql2.rs
