Skip to main content

schema_sql_generator/common/
generator_context.rs

1use crate::common::generate_options::GenerateOptions;
2use crate::common::print_writer::PrintWriter;
3use crate::common::sql_generator_settings::SqlGeneratorSettings;
4use crate::common::sql_writer::SqlWriter;
5use schema_model::model::database_model::DatabaseModel;
6use schema_model::model::types::DatabaseType;
7use std::cell::RefCell;
8use std::io::Write as IoWrite;
9use std::rc::Rc;
10
11/// A `Write` sink backed by a shared, readable in-memory buffer - for callers (e.g. the
12/// migration generator) that need to invoke a generator method for its side-effecting writes
13/// (via `GeneratorContext::with_writer`) and then read back what it wrote, without a temp
14/// file. Mirrors the `SharedBuffer` test helper in `test_support.rs`, but is not
15/// `#[cfg(test)]` since production code outside this crate needs it too.
16#[derive(Clone, Default)]
17pub struct BufferSink(Rc<RefCell<Vec<u8>>>);
18
19impl BufferSink {
20    pub fn new() -> Self {
21        Self::default()
22    }
23
24    /// Returns and clears the buffer's contents, so a caller emitting several separate
25    /// chunks of generator output (e.g. one per table) can drain each chunk right after
26    /// producing it and keep the surrounding output in the right order.
27    pub fn take(&self) -> String {
28        let mut buf = self.0.borrow_mut();
29        String::from_utf8(std::mem::take(&mut *buf)).unwrap_or_default()
30    }
31}
32
33impl IoWrite for BufferSink {
34    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
35        self.0.borrow_mut().write(buf)
36    }
37
38    fn flush(&mut self) -> std::io::Result<()> {
39        self.0.borrow_mut().flush()
40    }
41}
42
43#[derive(Clone)]
44pub struct GeneratorContext {
45    settings: Rc<SqlGeneratorSettings>,
46    writer: Rc<RefCell<SqlWriter>>,
47}
48
49impl GeneratorContext {
50    pub fn new(settings: SqlGeneratorSettings, writer: SqlWriter) -> Self {
51        Self {
52            settings: Rc::new(settings),
53            writer: Rc::new(RefCell::new(writer)),
54        }
55    }
56
57    /// Builds a context from just a model and dialect, with an in-memory output sink -
58    /// for callers (e.g. `schema-migration-generator`) that only need to call column-level
59    /// generator methods (column type / check constraint rendering), not run a full
60    /// `CREATE TABLE` generation. `GenerateOptions::new`'s default `boolean_mode` is
61    /// `Native`, so it's overridden here from `database_model.boolean_mode()` - the model
62    /// always carries the real configured mode.
63    pub fn for_model(database_model: Rc<DatabaseModel>, database_type: DatabaseType) -> Self {
64        Self::for_model_with_target_version(database_model, database_type, 0)
65    }
66
67    /// Like `for_model`, but with a target dialect version (PostgreSQL major version, or SQL
68    /// Server product year) threaded through, for callers (e.g. `schema-migration-generator`)
69    /// that need version-gated column type SQL (e.g. `json_sql`) to match the dialect's own
70    /// `--postgresql-version`/`--sqlserver-version` target. `target_version` is interpreted
71    /// per-dialect and ignored for `DatabaseType::Sqlite`, which has no version-gated types.
72    pub fn for_model_with_target_version(database_model: Rc<DatabaseModel>, database_type: DatabaseType, target_version: u32) -> Self {
73        let boolean_mode = database_model.boolean_mode();
74        let writer = Rc::new(RefCell::new(PrintWriter::new(Box::new(Vec::<u8>::new()))));
75        let mut options = GenerateOptions::new(database_model, writer);
76        options.boolean_mode = boolean_mode;
77        apply_target_version(&mut options, database_type, target_version);
78        let settings = SqlGeneratorSettings::new(database_type, &options);
79        let sql_writer = SqlWriter::new(options.writer.clone());
80        Self::new(settings, sql_writer)
81    }
82
83    /// Like `for_model`, but with the in-memory sink exposed as a readable `BufferSink`
84    /// instead of a write-only, inaccessible `Vec<u8>` - for callers that need to invoke a
85    /// generator method (e.g. `TriggerGenerator::output_triggers_for_table`) for its
86    /// side-effecting writes and then read back what it produced.
87    pub fn for_model_with_buffer(database_model: Rc<DatabaseModel>, database_type: DatabaseType) -> (Self, BufferSink) {
88        Self::for_model_with_buffer_and_target_version(database_model, database_type, 0)
89    }
90
91    /// Like `for_model_with_buffer`, but with a target dialect version - see
92    /// `for_model_with_target_version`.
93    pub fn for_model_with_buffer_and_target_version(
94        database_model: Rc<DatabaseModel>,
95        database_type: DatabaseType,
96        target_version: u32,
97    ) -> (Self, BufferSink) {
98        let boolean_mode = database_model.boolean_mode();
99        let buffer = BufferSink::new();
100        let writer = Rc::new(RefCell::new(PrintWriter::new_auto_flush(Box::new(buffer.clone()))));
101        let mut options = GenerateOptions::new(database_model, writer);
102        options.boolean_mode = boolean_mode;
103        apply_target_version(&mut options, database_type, target_version);
104        let settings = SqlGeneratorSettings::new(database_type, &options);
105        let sql_writer = SqlWriter::new(options.writer.clone());
106        (Self::new(settings, sql_writer), buffer)
107    }
108
109    pub fn settings(&self) -> &SqlGeneratorSettings {
110        &self.settings
111    }
112
113    pub fn shared_settings(&self) -> Rc<SqlGeneratorSettings> {
114        Rc::clone(&self.settings)
115    }
116
117    pub fn writer(&self) -> Rc<RefCell<SqlWriter>> {
118        Rc::clone(&self.writer)
119    }
120
121    pub fn with_writer<F>(&self, f: F)
122    where
123        F: FnOnce(&mut SqlWriter),
124    {
125        let mut writer = self.writer.borrow_mut();
126        f(&mut writer);
127    }
128}
129
130/// `target_version` is a single dialect-agnostic knob (PostgreSQL major version, or SQL Server
131/// product year); route it to whichever `GenerateOptions` field the target dialect actually
132/// reads - SQLite has no version-gated types, so it's a no-op there.
133fn apply_target_version(options: &mut GenerateOptions, database_type: DatabaseType, target_version: u32) {
134    match database_type {
135        DatabaseType::Postgresql => options.target_postgres_version = target_version,
136        DatabaseType::SqlServer => options.target_sqlserver_version = target_version,
137        DatabaseType::Sqlite => {}
138    }
139}