use crate::common::generate_options::GenerateOptions;
use crate::common::print_writer::PrintWriter;
use crate::common::sql_generator_settings::SqlGeneratorSettings;
use crate::common::sql_writer::SqlWriter;
use schema_model::model::database_model::DatabaseModel;
use schema_model::model::types::DatabaseType;
use std::cell::RefCell;
use std::io::Write as IoWrite;
use std::rc::Rc;
#[derive(Clone, Default)]
pub struct BufferSink(Rc<RefCell<Vec<u8>>>);
impl BufferSink {
pub fn new() -> Self {
Self::default()
}
pub fn take(&self) -> String {
let mut buf = self.0.borrow_mut();
String::from_utf8(std::mem::take(&mut *buf)).unwrap_or_default()
}
}
impl IoWrite for BufferSink {
fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
self.0.borrow_mut().write(buf)
}
fn flush(&mut self) -> std::io::Result<()> {
self.0.borrow_mut().flush()
}
}
#[derive(Clone)]
pub struct GeneratorContext {
settings: Rc<SqlGeneratorSettings>,
writer: Rc<RefCell<SqlWriter>>,
}
impl GeneratorContext {
pub fn new(settings: SqlGeneratorSettings, writer: SqlWriter) -> Self {
Self {
settings: Rc::new(settings),
writer: Rc::new(RefCell::new(writer)),
}
}
pub fn for_model(database_model: Rc<DatabaseModel>, database_type: DatabaseType) -> Self {
Self::for_model_with_target_version(database_model, database_type, 0)
}
pub fn for_model_with_target_version(database_model: Rc<DatabaseModel>, database_type: DatabaseType, target_version: u32) -> Self {
let boolean_mode = database_model.boolean_mode();
let writer = Rc::new(RefCell::new(PrintWriter::new(Box::new(Vec::<u8>::new()))));
let mut options = GenerateOptions::new(database_model, writer);
options.boolean_mode = boolean_mode;
apply_target_version(&mut options, database_type, target_version);
let settings = SqlGeneratorSettings::new(database_type, &options);
let sql_writer = SqlWriter::new(options.writer.clone());
Self::new(settings, sql_writer)
}
pub fn for_model_with_buffer(database_model: Rc<DatabaseModel>, database_type: DatabaseType) -> (Self, BufferSink) {
Self::for_model_with_buffer_and_target_version(database_model, database_type, 0)
}
pub fn for_model_with_buffer_and_target_version(
database_model: Rc<DatabaseModel>,
database_type: DatabaseType,
target_version: u32,
) -> (Self, BufferSink) {
let boolean_mode = database_model.boolean_mode();
let buffer = BufferSink::new();
let writer = Rc::new(RefCell::new(PrintWriter::new_auto_flush(Box::new(buffer.clone()))));
let mut options = GenerateOptions::new(database_model, writer);
options.boolean_mode = boolean_mode;
apply_target_version(&mut options, database_type, target_version);
let settings = SqlGeneratorSettings::new(database_type, &options);
let sql_writer = SqlWriter::new(options.writer.clone());
(Self::new(settings, sql_writer), buffer)
}
pub fn settings(&self) -> &SqlGeneratorSettings {
&self.settings
}
pub fn shared_settings(&self) -> Rc<SqlGeneratorSettings> {
Rc::clone(&self.settings)
}
pub fn writer(&self) -> Rc<RefCell<SqlWriter>> {
Rc::clone(&self.writer)
}
pub fn with_writer<F>(&self, f: F)
where
F: FnOnce(&mut SqlWriter),
{
let mut writer = self.writer.borrow_mut();
f(&mut writer);
}
}
fn apply_target_version(options: &mut GenerateOptions, database_type: DatabaseType, target_version: u32) {
match database_type {
DatabaseType::Postgresql => options.target_postgres_version = target_version,
DatabaseType::SqlServer => options.target_sqlserver_version = target_version,
DatabaseType::Sqlite => {}
}
}