schema_sql_generator/common/
generator_context.rs1use 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#[derive(Clone, Default)]
17pub struct BufferSink(Rc<RefCell<Vec<u8>>>);
18
19impl BufferSink {
20 pub fn new() -> Self {
21 Self::default()
22 }
23
24 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 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 pub fn for_model_with_target_version(
73 database_model: Rc<DatabaseModel>,
74 database_type: DatabaseType,
75 target_version: u32,
76 ) -> Self {
77 let boolean_mode = database_model.boolean_mode();
78 let writer = Rc::new(RefCell::new(PrintWriter::new(Box::new(Vec::<u8>::new()))));
79 let mut options = GenerateOptions::new(database_model, writer);
80 options.boolean_mode = boolean_mode;
81 apply_target_version(&mut options, database_type, target_version);
82 let settings = SqlGeneratorSettings::new(database_type, &options);
83 let sql_writer = SqlWriter::new(options.writer.clone());
84 Self::new(settings, sql_writer)
85 }
86
87 pub fn for_model_with_buffer(
92 database_model: Rc<DatabaseModel>,
93 database_type: DatabaseType,
94 ) -> (Self, BufferSink) {
95 Self::for_model_with_buffer_and_target_version(database_model, database_type, 0)
96 }
97
98 pub fn for_model_with_buffer_and_target_version(
101 database_model: Rc<DatabaseModel>,
102 database_type: DatabaseType,
103 target_version: u32,
104 ) -> (Self, BufferSink) {
105 let boolean_mode = database_model.boolean_mode();
106 let buffer = BufferSink::new();
107 let writer = Rc::new(RefCell::new(PrintWriter::new_auto_flush(Box::new(
108 buffer.clone(),
109 ))));
110 let mut options = GenerateOptions::new(database_model, writer);
111 options.boolean_mode = boolean_mode;
112 apply_target_version(&mut options, database_type, target_version);
113 let settings = SqlGeneratorSettings::new(database_type, &options);
114 let sql_writer = SqlWriter::new(options.writer.clone());
115 (Self::new(settings, sql_writer), buffer)
116 }
117
118 pub fn settings(&self) -> &SqlGeneratorSettings {
119 &self.settings
120 }
121
122 pub fn shared_settings(&self) -> Rc<SqlGeneratorSettings> {
123 Rc::clone(&self.settings)
124 }
125
126 pub fn writer(&self) -> Rc<RefCell<SqlWriter>> {
127 Rc::clone(&self.writer)
128 }
129
130 pub fn with_writer<F>(&self, f: F)
131 where
132 F: FnOnce(&mut SqlWriter),
133 {
134 let mut writer = self.writer.borrow_mut();
135 f(&mut writer);
136 }
137}
138
139fn apply_target_version(
143 options: &mut GenerateOptions,
144 database_type: DatabaseType,
145 target_version: u32,
146) {
147 match database_type {
148 DatabaseType::Postgresql => options.target_postgres_version = target_version,
149 DatabaseType::SqlServer => options.target_sqlserver_version = target_version,
150 DatabaseType::Sqlite => {}
151 }
152}