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
44fn 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\nmodule Queries"
69 .to_string()
70 }
71
72 fn file_footer(&self) -> String {
73 "end".to_string()
74 }
75
76 fn generate_row_struct(
77 &self,
78 query_name: &str,
79 columns: &[ResolvedColumn],
80 ) -> Result<String, ScytheError> {
81 let struct_name = row_struct_name(query_name, &self.manifest.naming);
82 let fields = columns
83 .iter()
84 .map(|c| format!(":{}", c.field_name))
85 .collect::<Vec<_>>()
86 .join(", ");
87 let mut out = String::new();
88 let _ = writeln!(out, " {} = Data.define({})", struct_name, fields);
89 Ok(out)
90 }
91
92 fn generate_model_struct(
93 &self,
94 table_name: &str,
95 columns: &[ResolvedColumn],
96 ) -> Result<String, ScytheError> {
97 let name = to_pascal_case(table_name);
98 self.generate_row_struct(&name, columns)
99 }
100
101 fn generate_query_fn(
102 &self,
103 analyzed: &AnalyzedQuery,
104 struct_name: &str,
105 columns: &[ResolvedColumn],
106 params: &[ResolvedParam],
107 ) -> Result<String, ScytheError> {
108 let func_name = fn_name(&analyzed.name, &self.manifest.naming);
109 let sql = super::clean_sql_with_optional(
110 &analyzed.sql,
111 &analyzed.optional_params,
112 &analyzed.params,
113 );
114 let mut out = String::new();
115
116 let param_list = params
117 .iter()
118 .map(|p| p.field_name.clone())
119 .collect::<Vec<_>>()
120 .join(", ");
121 let sep = if param_list.is_empty() { "" } else { ", " };
122
123 let _ = writeln!(out, " def self.{}(client{}{})", func_name, sep, param_list);
124
125 let param_array = if params.is_empty() {
126 "[]".to_string()
127 } else {
128 format!(
129 "[{}]",
130 params
131 .iter()
132 .map(|p| p.field_name.clone())
133 .collect::<Vec<_>>()
134 .join(", ")
135 )
136 };
137
138 match &analyzed.command {
139 QueryCommand::One => {
140 let _ = writeln!(out, " stmt = client.prepare(\"{}\")", sql);
141 let _ = writeln!(
142 out,
143 " results = stmt.execute({})",
144 param_array.trim_start_matches('[').trim_end_matches(']')
145 );
146 let _ = writeln!(out, " row = results.first");
147 let _ = writeln!(out, " return nil if row.nil?");
148
149 let fields = columns
150 .iter()
151 .map(|c| {
152 let coercion = ruby_coercion(&c.neutral_type);
153 if c.nullable {
154 format!(
155 "{}: row[\"{}\"]&.then {{ |v| v{} }}",
156 c.field_name, c.name, coercion
157 )
158 } else {
159 format!("{}: row[\"{}\"]{}", c.field_name, c.name, coercion)
160 }
161 })
162 .collect::<Vec<_>>()
163 .join(", ");
164 let _ = writeln!(out, " {}.new({})", struct_name, fields);
165 }
166 QueryCommand::Batch => {
167 let batch_fn_name = format!("{}_batch", func_name);
168 let _ = writeln!(out, " def self.{}(client, items)", batch_fn_name);
169 let _ = writeln!(out, " stmt = client.prepare(\"{}\")", sql);
170 let _ = writeln!(out, " items.each do |item|");
171 if params.len() > 1 {
172 let _ = writeln!(out, " stmt.execute(*item)");
173 } else if params.len() == 1 {
174 let _ = writeln!(out, " stmt.execute(item)");
175 } else {
176 let _ = writeln!(out, " stmt.execute");
177 }
178 let _ = writeln!(out, " end");
179 let _ = write!(out, " end");
180 return Ok(out);
181 }
182 QueryCommand::Many => {
183 let _ = writeln!(out, " stmt = client.prepare(\"{}\")", sql);
184 let _ = writeln!(
185 out,
186 " results = stmt.execute({})",
187 param_array.trim_start_matches('[').trim_end_matches(']')
188 );
189 let _ = writeln!(out, " results.map do |row|");
190 let fields = columns
191 .iter()
192 .map(|c| {
193 let coercion = ruby_coercion(&c.neutral_type);
194 if c.nullable {
195 format!(
196 "{}: row[\"{}\"]&.then {{ |v| v{} }}",
197 c.field_name, c.name, coercion
198 )
199 } else {
200 format!("{}: row[\"{}\"]{}", c.field_name, c.name, coercion)
201 }
202 })
203 .collect::<Vec<_>>()
204 .join(", ");
205 let _ = writeln!(out, " {}.new({})", struct_name, fields);
206 let _ = writeln!(out, " end");
207 }
208 QueryCommand::Exec => {
209 let _ = writeln!(out, " stmt = client.prepare(\"{}\")", sql);
210 let _ = writeln!(
211 out,
212 " stmt.execute({})",
213 param_array.trim_start_matches('[').trim_end_matches(']')
214 );
215 let _ = writeln!(out, " nil");
216 }
217 QueryCommand::ExecResult | QueryCommand::ExecRows => {
218 let _ = writeln!(out, " stmt = client.prepare(\"{}\")", sql);
219 let _ = writeln!(
220 out,
221 " stmt.execute({})",
222 param_array.trim_start_matches('[').trim_end_matches(']')
223 );
224 let _ = writeln!(out, " client.affected_rows");
225 }
226 }
227
228 let _ = write!(out, " end");
229 Ok(out)
230 }
231
232 fn generate_enum_def(&self, enum_info: &EnumInfo) -> Result<String, ScytheError> {
233 let type_name = enum_type_name(&enum_info.sql_name, &self.manifest.naming);
234 let mut out = String::new();
235 let _ = writeln!(out, " module {}", type_name);
236 for value in &enum_info.values {
237 let variant = enum_variant_name(value, &self.manifest.naming);
238 let _ = writeln!(out, " {} = \"{}\"", variant, value);
239 }
240 let all_values = enum_info
241 .values
242 .iter()
243 .map(|v| enum_variant_name(v, &self.manifest.naming))
244 .collect::<Vec<_>>()
245 .join(", ");
246 let _ = writeln!(out, " ALL = [{}].freeze", all_values);
247 let _ = write!(out, " end");
248 Ok(out)
249 }
250
251 fn generate_composite_def(&self, composite: &CompositeInfo) -> Result<String, ScytheError> {
252 let name = to_pascal_case(&composite.sql_name);
253 let mut out = String::new();
254 if composite.fields.is_empty() {
255 let _ = writeln!(out, " {} = Data.define()", name);
256 } else {
257 let fields = composite
258 .fields
259 .iter()
260 .map(|f| format!(":{}", f.name))
261 .collect::<Vec<_>>()
262 .join(", ");
263 let _ = writeln!(out, " {} = Data.define({})", name, fields);
264 }
265 Ok(out)
266 }
267}