scythe_codegen/backends/
ruby_sqlite3.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, RbsGenerationContext, ResolvedColumn, ResolvedParam};
14
15const DEFAULT_MANIFEST_TOML: &str = include_str!("../../manifests/ruby-sqlite3.toml");
16
17pub struct RubySqlite3Backend {
18    manifest: BackendManifest,
19}
20
21impl RubySqlite3Backend {
22    pub fn new(engine: &str) -> Result<Self, ScytheError> {
23        match engine {
24            "sqlite" | "sqlite3" => {}
25            _ => {
26                return Err(ScytheError::new(
27                    ErrorCode::InternalError,
28                    format!("ruby-sqlite3 only supports SQLite, got engine '{}'", engine),
29                ));
30            }
31        }
32        let manifest_path = Path::new("backends/ruby-sqlite3/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 sqlite3.
45fn ruby_coercion(neutral_type: &str) -> &'static str {
46    match neutral_type {
47        "int16" | "int32" | "int64" => ".to_i",
48        "float32" | "float64" | "decimal" => ".to_f",
49        "bool" => " == 1",
50        _ => "",
51    }
52}
53
54impl CodegenBackend for RubySqlite3Backend {
55    fn name(&self) -> &str {
56        "ruby-sqlite3"
57    }
58
59    fn manifest(&self) -> &scythe_backend::manifest::BackendManifest {
60        &self.manifest
61    }
62
63    fn supported_engines(&self) -> &[&str] {
64        &["sqlite"]
65    }
66
67    fn generate_rbs_file(&self, context: &RbsGenerationContext) -> Option<String> {
68        Some(super::ruby_rbs::generate_rbs_content(
69            context,
70            "SQLite3::Database",
71        ))
72    }
73
74    fn file_header(&self) -> String {
75        "# frozen_string_literal: true\n\n# Auto-generated by scythe. Do not edit.\n\nmodule Queries"
76            .to_string()
77    }
78
79    fn file_footer(&self) -> String {
80        "end".to_string()
81    }
82
83    fn generate_row_struct(
84        &self,
85        query_name: &str,
86        columns: &[ResolvedColumn],
87    ) -> Result<String, ScytheError> {
88        let struct_name = row_struct_name(query_name, &self.manifest.naming);
89        let fields = columns
90            .iter()
91            .map(|c| format!(":{}", c.field_name))
92            .collect::<Vec<_>>()
93            .join(", ");
94        let mut out = String::new();
95        let _ = writeln!(out, "  {} = Data.define({})", struct_name, fields);
96        Ok(out)
97    }
98
99    fn generate_model_struct(
100        &self,
101        table_name: &str,
102        columns: &[ResolvedColumn],
103    ) -> Result<String, ScytheError> {
104        let name = to_pascal_case(table_name);
105        self.generate_row_struct(&name, columns)
106    }
107
108    fn generate_query_fn(
109        &self,
110        analyzed: &AnalyzedQuery,
111        struct_name: &str,
112        columns: &[ResolvedColumn],
113        params: &[ResolvedParam],
114    ) -> Result<String, ScytheError> {
115        let func_name = fn_name(&analyzed.name, &self.manifest.naming);
116        let sql = super::clean_sql_with_optional(
117            &analyzed.sql,
118            &analyzed.optional_params,
119            &analyzed.params,
120        );
121        let mut out = String::new();
122
123        let param_list = params
124            .iter()
125            .map(|p| p.field_name.clone())
126            .collect::<Vec<_>>()
127            .join(", ");
128        let sep = if param_list.is_empty() { "" } else { ", " };
129
130        let _ = writeln!(out, "  def self.{}(db{}{})", func_name, sep, param_list);
131
132        let param_array = if params.is_empty() {
133            "[]".to_string()
134        } else {
135            format!(
136                "[{}]",
137                params
138                    .iter()
139                    .map(|p| p.field_name.clone())
140                    .collect::<Vec<_>>()
141                    .join(", ")
142            )
143        };
144
145        match &analyzed.command {
146            QueryCommand::One => {
147                let _ = writeln!(
148                    out,
149                    "    row = db.get_first_row(\"{}\", {})",
150                    sql, param_array
151                );
152                let _ = writeln!(out, "    return nil if row.nil?");
153
154                let fields = columns
155                    .iter()
156                    .enumerate()
157                    .map(|(i, c)| {
158                        let coercion = ruby_coercion(&c.neutral_type);
159                        if c.nullable {
160                            format!("{}: row[{}]&.then {{ |v| v{} }}", c.field_name, i, coercion)
161                        } else {
162                            format!("{}: row[{}]{}", c.field_name, i, coercion)
163                        }
164                    })
165                    .collect::<Vec<_>>()
166                    .join(", ");
167                let _ = writeln!(out, "    {}.new({})", struct_name, fields);
168            }
169            QueryCommand::Batch => {
170                let batch_fn_name = format!("{}_batch", func_name);
171                let _ = writeln!(out, "  def self.{}(db, items)", batch_fn_name);
172                let _ = writeln!(out, "    db.transaction do");
173                let _ = writeln!(out, "      items.each do |item|");
174                if params.len() > 1 {
175                    let _ = writeln!(out, "        db.execute(\"{}\", item)", sql);
176                } else if params.len() == 1 {
177                    let _ = writeln!(out, "        db.execute(\"{}\", [item])", sql);
178                } else {
179                    let _ = writeln!(out, "        db.execute(\"{}\", [])", sql);
180                }
181                let _ = writeln!(out, "      end");
182                let _ = writeln!(out, "    end");
183                let _ = write!(out, "  end");
184                return Ok(out);
185            }
186            QueryCommand::Many => {
187                let _ = writeln!(out, "    rows = db.execute(\"{}\", {})", sql, param_array);
188                let _ = writeln!(out, "    rows.map do |row|");
189                let fields = columns
190                    .iter()
191                    .enumerate()
192                    .map(|(i, c)| {
193                        let coercion = ruby_coercion(&c.neutral_type);
194                        if c.nullable {
195                            format!("{}: row[{}]&.then {{ |v| v{} }}", c.field_name, i, coercion)
196                        } else {
197                            format!("{}: row[{}]{}", c.field_name, i, coercion)
198                        }
199                    })
200                    .collect::<Vec<_>>()
201                    .join(", ");
202                let _ = writeln!(out, "      {}.new({})", struct_name, fields);
203                let _ = writeln!(out, "    end");
204            }
205            QueryCommand::Exec => {
206                let _ = writeln!(out, "    db.execute(\"{}\", {})", sql, param_array);
207                let _ = writeln!(out, "    nil");
208            }
209            QueryCommand::ExecResult | QueryCommand::ExecRows => {
210                let _ = writeln!(out, "    db.execute(\"{}\", {})", sql, param_array);
211                let _ = writeln!(out, "    db.changes");
212            }
213            QueryCommand::Grouped => unreachable!("handled as Many in codegen"),
214        }
215
216        let _ = write!(out, "  end");
217        Ok(out)
218    }
219
220    fn generate_enum_def(&self, enum_info: &EnumInfo) -> Result<String, ScytheError> {
221        let type_name = enum_type_name(&enum_info.sql_name, &self.manifest.naming);
222        let mut out = String::new();
223        let _ = writeln!(out, "  module {}", type_name);
224        for value in &enum_info.values {
225            let variant = enum_variant_name(value, &self.manifest.naming);
226            let _ = writeln!(out, "    {} = \"{}\"", variant, value);
227        }
228        let all_values = enum_info
229            .values
230            .iter()
231            .map(|v| enum_variant_name(v, &self.manifest.naming))
232            .collect::<Vec<_>>()
233            .join(", ");
234        let _ = writeln!(out, "    ALL = [{}].freeze", all_values);
235        let _ = write!(out, "  end");
236        Ok(out)
237    }
238
239    fn generate_composite_def(&self, composite: &CompositeInfo) -> Result<String, ScytheError> {
240        let name = to_pascal_case(&composite.sql_name);
241        let mut out = String::new();
242        if composite.fields.is_empty() {
243            let _ = writeln!(out, "  {} = Data.define()", name);
244        } else {
245            let fields = composite
246                .fields
247                .iter()
248                .map(|f| format!(":{}", f.name))
249                .collect::<Vec<_>>()
250                .join(", ");
251            let _ = writeln!(out, "  {} = Data.define({})", name, fields);
252        }
253        Ok(out)
254    }
255}
scythe_codegen/backends/ruby_sqlite3.rs

scythe_codegen/backends/
ruby_sqlite3.rs
