use scythe_backend::manifest::BackendManifest;
use scythe_backend::naming::{enum_type_name, enum_variant_name, fn_name, row_struct_name, to_pascal_case};
use std::fmt::Write;
use scythe_core::analyzer::{AnalyzedQuery, CompositeInfo, EnumInfo};
use scythe_core::errors::{ErrorCode, ScytheError};
use scythe_core::parser::QueryCommand;
use crate::backend_trait::{CodegenBackend, GroupedQueryFn, RbsGenerationContext, ResolvedColumn, ResolvedParam};
const DEFAULT_MANIFEST_TOML: &str = include_str!("../../manifests/ruby-oci8.toml");
pub struct RubyOci8Backend {
manifest: BackendManifest,
}
impl RubyOci8Backend {
pub fn new(engine: &str) -> Result<Self, ScytheError> {
match engine {
"oracle" => {}
_ => {
return Err(ScytheError::new(
ErrorCode::InvalidConfig,
format!("ruby-oci8 only supports Oracle, got engine '{}'", engine),
));
}
}
let manifest = super::parse_manifest(DEFAULT_MANIFEST_TOML)?;
Ok(Self { manifest })
}
}
impl CodegenBackend for RubyOci8Backend {
fn name(&self) -> &str {
"ruby-oci8"
}
fn manifest(&self) -> &scythe_backend::manifest::BackendManifest {
&self.manifest
}
fn manifest_mut(&mut self) -> &mut scythe_backend::manifest::BackendManifest {
&mut self.manifest
}
fn supported_engines(&self) -> &[&str] {
&["oracle"]
}
fn generate_rbs_file(&self, context: &RbsGenerationContext) -> Option<String> {
Some(super::ruby_rbs::generate_rbs_content(context, "OCI8", &self.manifest))
}
fn file_preamble(&self) -> String {
"# frozen_string_literal: true\n".to_string()
}
fn file_header(&self) -> String {
"require 'oci8'\n\nmodule Queries".to_string()
}
fn file_footer(&self) -> String {
"end".to_string()
}
fn generate_row_struct(&self, query_name: &str, columns: &[ResolvedColumn]) -> Result<String, ScytheError> {
let struct_name = row_struct_name(query_name, &self.manifest.naming);
let fields = columns
.iter()
.map(|c| format!(":{}", c.field_name))
.collect::<Vec<_>>()
.join(", ");
let mut out = String::new();
let _ = writeln!(out, " {} = Data.define({})", struct_name, fields);
Ok(out)
}
fn generate_model_struct(&self, table_name: &str, columns: &[ResolvedColumn]) -> Result<String, ScytheError> {
let name = to_pascal_case(table_name);
self.generate_row_struct(&name, columns)
}
fn generate_query_fn(
&self,
analyzed: &AnalyzedQuery,
struct_name: &str,
columns: &[ResolvedColumn],
params: &[ResolvedParam],
) -> Result<String, ScytheError> {
let func_name = fn_name(&analyzed.name, &self.manifest.naming);
let sql = super::rewrite_pg_placeholders(
&super::clean_sql_with_optional(&analyzed.sql, &analyzed.optional_params, &analyzed.params),
|n| format!(":{n}"),
);
let mut out = String::new();
let param_list = params
.iter()
.map(|p| p.field_name.clone())
.collect::<Vec<_>>()
.join(", ");
let sep = if param_list.is_empty() { "" } else { ", " };
if !matches!(analyzed.command, QueryCommand::Batch) {
let _ = writeln!(out, " def self.{}(conn{}{})", func_name, sep, param_list);
}
let bind_vars = if params.is_empty() {
String::new()
} else {
format!(
", {}",
params
.iter()
.map(|p| p.field_name.clone())
.collect::<Vec<_>>()
.join(", ")
)
};
let has_returning = sql.to_uppercase().contains("RETURNING");
match &analyzed.command {
QueryCommand::One | QueryCommand::Opt => {
if has_returning {
let _ = writeln!(out, " cursor = conn.parse(\"{}\")", {
let into_clause = columns
.iter()
.enumerate()
.map(|(i, _)| format!(":{}", params.len() + i + 1))
.collect::<Vec<_>>()
.join(", ");
format!("{} INTO {}", sql, into_clause)
});
for (i, p) in params.iter().enumerate() {
let _ = writeln!(out, " cursor.bind_param({}, {})", i + 1, p.field_name);
}
for (i, col) in columns.iter().enumerate() {
let ruby_type = match col.neutral_type.as_str() {
"int32" | "int64" => "Integer",
"float32" | "float64" | "decimal" => "Float",
"date" | "datetime" | "datetime_tz" | "time" | "time_tz" => "Time",
_ => "String",
};
let _ = writeln!(
out,
" cursor.bind_param({}, nil, {})",
params.len() + i + 1,
ruby_type
);
}
let _ = writeln!(out, " cursor.exec");
let fields = columns
.iter()
.enumerate()
.map(|(i, c)| format!("{}: cursor[{}]", c.field_name, params.len() + i + 1))
.collect::<Vec<_>>()
.join(", ");
let _ = writeln!(out, " {}.new({})", struct_name, fields);
} else {
let _ = writeln!(out, " cursor = conn.exec(\"{}\"{})", sql, bind_vars);
let _ = writeln!(out, " row = cursor.fetch");
let _ = writeln!(out, " return nil if row.nil?");
let fields = columns
.iter()
.enumerate()
.map(|(i, c)| format!("{}: row[{}]", c.field_name, i))
.collect::<Vec<_>>()
.join(", ");
let _ = writeln!(out, " {}.new({})", struct_name, fields);
}
}
QueryCommand::Many => {
let _ = writeln!(out, " cursor = conn.exec(\"{}\"{})", sql, bind_vars);
let _ = writeln!(out, " results = []");
let _ = writeln!(out, " while (row = cursor.fetch)");
let fields = columns
.iter()
.enumerate()
.map(|(i, c)| format!("{}: row[{}]", c.field_name, i))
.collect::<Vec<_>>()
.join(", ");
let _ = writeln!(out, " results << {}.new({})", struct_name, fields);
let _ = writeln!(out, " end");
let _ = writeln!(out, " results");
}
QueryCommand::Exec => {
let _ = writeln!(out, " conn.exec(\"{}\"{})", sql, bind_vars);
let _ = writeln!(out, " nil");
}
QueryCommand::ExecResult | QueryCommand::ExecRows => {
let _ = writeln!(out, " cursor = conn.exec(\"{}\"{})", sql, bind_vars);
let _ = writeln!(out, " cursor.row_count");
}
QueryCommand::Batch => {
let batch_fn_name = format!("{}_batch", func_name);
let _ = writeln!(out, " def self.{}(conn, items)", batch_fn_name);
let _ = writeln!(out, " items.each do |item|");
if params.len() > 1 {
let _ = writeln!(out, " conn.exec(\"{}\", *item)", sql);
} else if params.len() == 1 {
let _ = writeln!(out, " conn.exec(\"{}\", item)", sql);
} else {
let _ = writeln!(out, " conn.exec(\"{}\")", sql);
}
let _ = writeln!(out, " end");
let _ = write!(out, " end");
return Ok(out);
}
QueryCommand::Grouped => unreachable!("handled by generate_grouped_query_fn"),
}
let _ = write!(out, " end");
Ok(out)
}
fn generate_grouped_structs(
&self,
parent_struct_name: &str,
child_struct_name: &str,
parent_columns: &[ResolvedColumn],
child_columns: &[ResolvedColumn],
_key_column: &str,
) -> Result<String, ScytheError> {
Ok(super::ruby_rbs::generate_grouped_structs_ruby(
parent_struct_name,
child_struct_name,
parent_columns,
child_columns,
))
}
fn generate_grouped_query_fn(&self, request: &GroupedQueryFn<'_>) -> Result<String, ScytheError> {
let analyzed = request.analyzed;
let parent_struct_name = request.parent_struct_name;
let child_struct_name = request.child_struct_name;
let all_columns = request.all_columns;
let parent_columns = request.parent_columns;
let child_columns = request.child_columns;
let params = request.params;
let key_column = request.key_column;
let func_name = fn_name(&analyzed.name, &self.manifest.naming);
let sql = super::rewrite_pg_placeholders(
&super::clean_sql_with_optional(&analyzed.sql, &analyzed.optional_params, &analyzed.params),
|n| format!(":{n}"),
);
let param_list = params
.iter()
.map(|p| p.field_name.clone())
.collect::<Vec<_>>()
.join(", ");
let sep = if param_list.is_empty() { "" } else { ", " };
let bind_vars = if params.is_empty() {
String::new()
} else {
format!(
", {}",
params
.iter()
.map(|p| p.field_name.clone())
.collect::<Vec<_>>()
.join(", ")
)
};
let key_idx = all_columns.iter().position(|c| c.name == key_column).unwrap_or(0);
let mut out = String::new();
let _ = writeln!(out, " def self.{}(conn{}{})", func_name, sep, param_list);
let _ = writeln!(out, " cursor = conn.exec(\"{}\"{})", sql, bind_vars);
let _ = writeln!(out, " _index = {{}}");
let _ = writeln!(out, " _entries = []");
let _ = writeln!(out, " while (row = cursor.fetch)");
let _ = writeln!(out, " key = row[{}]", key_idx);
let _ = writeln!(out, " unless _index.key?(key)");
let _ = writeln!(out, " _index[key] = _entries.size");
let _ = writeln!(out, " _entries << {{");
for col in parent_columns {
let col_idx = all_columns.iter().position(|c| c.name == col.name).unwrap_or(0);
let _ = writeln!(out, " {}: row[{}],", col.field_name, col_idx);
}
let _ = writeln!(out, " children: []");
let _ = writeln!(out, " }}");
let _ = writeln!(out, " end");
let _ = writeln!(
out,
" _entries[_index[key]][:children] << {}.new(",
child_struct_name
);
for col in child_columns {
let col_idx = all_columns.iter().position(|c| c.name == col.name).unwrap_or(0);
let _ = writeln!(out, " {}: row[{}],", col.field_name, col_idx);
}
let _ = writeln!(out, " )");
let _ = writeln!(out, " end");
let _ = writeln!(out, " _entries.map {{ |e| {}.new(**e) }}", parent_struct_name);
let _ = write!(out, " end");
Ok(out)
}
fn generate_enum_def(&self, enum_info: &EnumInfo) -> Result<String, ScytheError> {
let type_name = enum_type_name(&enum_info.sql_name, &self.manifest.naming);
let mut out = String::new();
let _ = writeln!(out, " module {}", type_name);
for value in &enum_info.values {
let variant = enum_variant_name(value, &self.manifest.naming);
let _ = writeln!(out, " {} = \"{}\"", variant, value);
}
let all_values = enum_info
.values
.iter()
.map(|v| enum_variant_name(v, &self.manifest.naming))
.collect::<Vec<_>>()
.join(", ");
let _ = writeln!(out, " ALL = [{}].freeze", all_values);
let _ = write!(out, " end");
Ok(out)
}
fn generate_composite_def(&self, composite: &CompositeInfo) -> Result<String, ScytheError> {
let name = to_pascal_case(&composite.sql_name);
let mut out = String::new();
if composite.fields.is_empty() {
let _ = writeln!(out, " {} = Data.define()", name);
} else {
let fields = composite
.fields
.iter()
.map(|f| format!(":{}", f.name))
.collect::<Vec<_>>()
.join(", ");
let _ = writeln!(out, " {} = Data.define({})", name, fields);
}
Ok(out)
}
}
#[cfg(test)]
mod tests {
use super::*;
use scythe_core::analyzer::{AnalyzedColumn, AnalyzedQuery, GroupByConfig};
use scythe_core::parser::QueryCommand;
fn make_grouped_query() -> AnalyzedQuery {
let parent_cols = vec![
AnalyzedColumn {
name: "id".to_string(),
neutral_type: "int32".to_string(),
nullable: false,
..Default::default()
},
AnalyzedColumn {
name: "name".to_string(),
neutral_type: "string".to_string(),
nullable: false,
..Default::default()
},
AnalyzedColumn {
name: "email".to_string(),
neutral_type: "string".to_string(),
nullable: false,
..Default::default()
},
];
let child_cols = vec![
AnalyzedColumn {
name: "order_id".to_string(),
neutral_type: "int32".to_string(),
nullable: false,
..Default::default()
},
AnalyzedColumn {
name: "total".to_string(),
neutral_type: "decimal".to_string(),
nullable: true,
..Default::default()
},
AnalyzedColumn {
name: "order_date".to_string(),
neutral_type: "datetime".to_string(),
nullable: false,
..Default::default()
},
];
let all_cols = [parent_cols.clone(), child_cols.clone()].concat();
AnalyzedQuery::build(|aq| {
aq.name = "GetUsersWithOrders".to_string();
aq.command = QueryCommand::Grouped;
aq.sql = "SELECT u.id, u.name, u.email, o.id AS order_id, o.total, o.created_at AS order_date\nFROM users u\nJOIN orders o ON o.user_id = u.id".to_string();
aq.columns = all_cols;
aq.params = vec![];
aq.deprecated = None;
aq.source_table = None;
aq.composites = vec![];
aq.enums = vec![];
aq.optional_params = vec![];
aq.group_by = Some(GroupByConfig {
table: "users".to_string(),
key_column: "id".to_string(),
parent_columns: parent_cols,
child_columns: child_cols,
});
aq.custom = vec![];
})
}
#[test]
fn test_grouped_ruby_oci8_structs() {
let backend = RubyOci8Backend::new("oracle").unwrap();
let query = make_grouped_query();
let result = crate::generate_with_backend(&query, &backend).unwrap();
let row_struct = result.row_struct.as_deref().unwrap();
assert!(
row_struct.contains("GetUsersWithOrdersChildRow = Data.define(:order_id, :total, :order_date)"),
"missing child struct; got:\n{row_struct}"
);
assert!(
row_struct.contains("GetUsersWithOrdersRow = Data.define(:id, :name, :email, :children)"),
"missing parent struct; got:\n{row_struct}"
);
let child_pos = row_struct.find("GetUsersWithOrdersChildRow").unwrap();
let parent_pos = row_struct.find("GetUsersWithOrdersRow = Data.define").unwrap();
assert!(child_pos < parent_pos, "child struct must appear before parent struct");
}
#[test]
fn test_grouped_ruby_oci8_query_fn() {
let backend = RubyOci8Backend::new("oracle").unwrap();
let query = make_grouped_query();
let result = crate::generate_with_backend(&query, &backend).unwrap();
let query_fn = result.query_fn.as_deref().unwrap();
assert!(
query_fn.contains("def self.get_users_with_orders(conn)"),
"missing fn; got:\n{query_fn}"
);
assert!(
query_fn.contains("cursor = conn.exec("),
"must use conn.exec; got:\n{query_fn}"
);
assert!(
query_fn.contains("while (row = cursor.fetch)"),
"must use while-fetch; got:\n{query_fn}"
);
assert!(
query_fn.contains("key = row[0]"),
"must access key by index; got:\n{query_fn}"
);
assert!(query_fn.contains("_index = {}"), "must use _index; got:\n{query_fn}");
assert!(
query_fn.contains("GetUsersWithOrdersChildRow.new("),
"must construct child struct; got:\n{query_fn}"
);
assert!(
query_fn.contains("GetUsersWithOrdersRow.new(**e)"),
"must fold into parent; got:\n{query_fn}"
);
}
}