Skip to main content

schema_sql_generator/common/
sql_writer.rs

1use crate::common::print_writer::PrintWriter;
2use std::cell::RefCell;
3use std::rc::Rc;
4
5#[derive(Clone)]
6pub struct SqlWriter {
7    print_writer: Rc<RefCell<PrintWriter>>,
8}
9
10impl SqlWriter {
11    pub fn new(writer: Rc<RefCell<PrintWriter>>) -> Self {
12        Self {
13            print_writer: writer,
14        }
15    }
16
17    pub fn print(&mut self, text: &str) {
18        self.print_writer.borrow_mut().print(text)
19    }
20
21    pub fn println(&mut self, text: &str) {
22        self.print_writer.borrow_mut().println(text)
23    }
24
25    pub fn printf(&mut self, args: std::fmt::Arguments) {
26        self.print_writer.borrow_mut().printf(args)
27    }
28
29    pub fn newline(&mut self) {
30        self.print_writer.borrow_mut().newline()
31    }
32}
33
34#[macro_export]
35macro_rules! sql_print {
36    ($writer:expr, $($arg:tt)*) => {
37        $writer.printf(format_args!($($arg)*));
38    };
39}
40
41#[macro_export]
42macro_rules! sql_println {
43    ($writer:expr, $($arg:tt)*) => {
44        $writer.printf(format_args!($($arg)*));
45        $writer.newline();
46    };
47}
48
49#[macro_export]
50macro_rules! sql_newline {
51    ($writer:expr) => {
52        $writer.newline();
53    };
54}
55
56#[cfg(test)]
57mod tests {
58    use super::*;
59    use crate::common::test_support::SharedBuffer;
60
61    fn make_writer() -> (SqlWriter, SharedBuffer) {
62        let buffer = SharedBuffer::new();
63        let print_writer = PrintWriter::new_auto_flush(Box::new(buffer.clone()));
64        (SqlWriter::new(Rc::new(RefCell::new(print_writer))), buffer)
65    }
66
67    // `print`/`printf` don't auto-flush (only println/newline do; see PrintWriter), so an
68    // explicit flush is needed to observe their output through the underlying buffered writer.
69    fn flush(writer: &SqlWriter) {
70        writer.print_writer.borrow_mut().flush();
71    }
72
73    #[test]
74    fn print_writes_without_trailing_newline() {
75        let (mut writer, buffer) = make_writer();
76        writer.print("hello");
77        flush(&writer);
78        assert_eq!(buffer.contents(), "hello");
79    }
80
81    #[test]
82    fn println_appends_a_newline() {
83        let (mut writer, buffer) = make_writer();
84        writer.println("hello");
85        assert_eq!(buffer.contents(), "hello\n");
86    }
87
88    #[test]
89    fn newline_writes_a_bare_newline() {
90        let (mut writer, buffer) = make_writer();
91        writer.print("a");
92        writer.newline();
93        writer.print("b");
94        flush(&writer);
95        assert_eq!(buffer.contents(), "a\nb");
96    }
97
98    #[test]
99    fn printf_formats_arguments() {
100        let (mut writer, buffer) = make_writer();
101        writer.printf(format_args!("count = {}", 42));
102        flush(&writer);
103        assert_eq!(buffer.contents(), "count = 42");
104    }
105
106    #[test]
107    fn sql_print_macro_writes_without_newline() {
108        let (mut writer, buffer) = make_writer();
109        sql_print!(writer, "value {}", 1);
110        flush(&writer);
111        assert_eq!(buffer.contents(), "value 1");
112    }
113
114    #[test]
115    fn sql_println_macro_appends_newline() {
116        let (mut writer, buffer) = make_writer();
117        sql_println!(writer, "value {}", 1);
118        assert_eq!(buffer.contents(), "value 1\n");
119    }
120
121    #[test]
122    fn sql_newline_macro_writes_bare_newline() {
123        let (mut writer, buffer) = make_writer();
124        sql_print!(writer, "a");
125        sql_newline!(writer);
126        sql_print!(writer, "b");
127        flush(&writer);
128        assert_eq!(buffer.contents(), "a\nb");
129    }
130}