@@ -40,8 +40,14 @@ use serde::{Deserialize, Serialize};
40
40
#[ cfg( feature = "visitor" ) ]
41
41
use sqlparser_derive:: { Visit , VisitMut } ;
42
42
43
- use crate :: keywords:: Keyword ;
44
- use crate :: tokenizer:: { Span , Token } ;
43
+ use crate :: {
44
+ display_utils:: SpaceOrNewline ,
45
+ tokenizer:: { Span , Token } ,
46
+ } ;
47
+ use crate :: {
48
+ display_utils:: { Indent , NewLine } ,
49
+ keywords:: Keyword ,
50
+ } ;
45
51
46
52
pub use self :: data_type:: {
47
53
ArrayElemTypeDef , BinaryLength , CharLengthUnits , CharacterLength , DataType , EnumMember ,
@@ -134,9 +140,9 @@ where
134
140
fn fmt ( & self , f : & mut fmt:: Formatter ) -> fmt:: Result {
135
141
let mut delim = "" ;
136
142
for t in self . slice {
137
- write ! ( f , "{ delim}" ) ?;
143
+ f . write_str ( delim) ?;
138
144
delim = self . sep ;
139
- write ! ( f , "{t}" ) ?;
145
+ t . fmt ( f ) ?;
140
146
}
141
147
Ok ( ( ) )
142
148
}
@@ -628,7 +634,12 @@ pub struct CaseWhen {
628
634
629
635
impl fmt:: Display for CaseWhen {
630
636
fn fmt ( & self , f : & mut fmt:: Formatter ) -> fmt:: Result {
631
- write ! ( f, "WHEN {} THEN {}" , self . condition, self . result)
637
+ f. write_str ( "WHEN " ) ?;
638
+ self . condition . fmt ( f) ?;
639
+ f. write_str ( " THEN" ) ?;
640
+ SpaceOrNewline . fmt ( f) ?;
641
+ Indent ( & self . result ) . fmt ( f) ?;
642
+ Ok ( ( ) )
632
643
}
633
644
}
634
645
@@ -1662,23 +1673,29 @@ impl fmt::Display for Expr {
1662
1673
write ! ( f, "{data_type}" ) ?;
1663
1674
write ! ( f, " {value}" )
1664
1675
}
1665
- Expr :: Function ( fun) => write ! ( f , "{fun}" ) ,
1676
+ Expr :: Function ( fun) => fun . fmt ( f ) ,
1666
1677
Expr :: Case {
1667
1678
operand,
1668
1679
conditions,
1669
1680
else_result,
1670
1681
} => {
1671
- write ! ( f , "CASE" ) ?;
1682
+ f . write_str ( "CASE" ) ?;
1672
1683
if let Some ( operand) = operand {
1673
- write ! ( f, " {operand}" ) ?;
1684
+ f. write_str ( " " ) ?;
1685
+ operand. fmt ( f) ?;
1674
1686
}
1675
1687
for when in conditions {
1676
- write ! ( f, " {when}" ) ?;
1688
+ SpaceOrNewline . fmt ( f) ?;
1689
+ Indent ( when) . fmt ( f) ?;
1677
1690
}
1678
1691
if let Some ( else_result) = else_result {
1679
- write ! ( f, " ELSE {else_result}" ) ?;
1692
+ SpaceOrNewline . fmt ( f) ?;
1693
+ Indent ( "ELSE" ) . fmt ( f) ?;
1694
+ SpaceOrNewline . fmt ( f) ?;
1695
+ Indent ( Indent ( else_result) ) . fmt ( f) ?;
1680
1696
}
1681
- write ! ( f, " END" )
1697
+ SpaceOrNewline . fmt ( f) ?;
1698
+ f. write_str ( "END" )
1682
1699
}
1683
1700
Expr :: Exists { subquery, negated } => write ! (
1684
1701
f,
@@ -1867,8 +1884,14 @@ pub enum WindowType {
1867
1884
impl Display for WindowType {
1868
1885
fn fmt ( & self , f : & mut fmt:: Formatter < ' _ > ) -> fmt:: Result {
1869
1886
match self {
1870
- WindowType :: WindowSpec ( spec) => write ! ( f, "({})" , spec) ,
1871
- WindowType :: NamedWindow ( name) => write ! ( f, "{}" , name) ,
1887
+ WindowType :: WindowSpec ( spec) => {
1888
+ f. write_str ( "(" ) ?;
1889
+ NewLine . fmt ( f) ?;
1890
+ Indent ( spec) . fmt ( f) ?;
1891
+ NewLine . fmt ( f) ?;
1892
+ f. write_str ( ")" )
1893
+ }
1894
+ WindowType :: NamedWindow ( name) => name. fmt ( f) ,
1872
1895
}
1873
1896
}
1874
1897
}
@@ -1896,27 +1919,36 @@ pub struct WindowSpec {
1896
1919
1897
1920
impl fmt:: Display for WindowSpec {
1898
1921
fn fmt ( & self , f : & mut fmt:: Formatter ) -> fmt:: Result {
1899
- let mut delim = "" ;
1922
+ let mut is_first = true ;
1900
1923
if let Some ( window_name) = & self . window_name {
1901
- delim = " " ;
1924
+ if !is_first {
1925
+ SpaceOrNewline . fmt ( f) ?;
1926
+ }
1927
+ is_first = false ;
1902
1928
write ! ( f, "{window_name}" ) ?;
1903
1929
}
1904
1930
if !self . partition_by . is_empty ( ) {
1905
- f. write_str ( delim) ?;
1906
- delim = " " ;
1931
+ if !is_first {
1932
+ SpaceOrNewline . fmt ( f) ?;
1933
+ }
1934
+ is_first = false ;
1907
1935
write ! (
1908
1936
f,
1909
1937
"PARTITION BY {}" ,
1910
1938
display_comma_separated( & self . partition_by)
1911
1939
) ?;
1912
1940
}
1913
1941
if !self . order_by . is_empty ( ) {
1914
- f. write_str ( delim) ?;
1915
- delim = " " ;
1942
+ if !is_first {
1943
+ SpaceOrNewline . fmt ( f) ?;
1944
+ }
1945
+ is_first = false ;
1916
1946
write ! ( f, "ORDER BY {}" , display_comma_separated( & self . order_by) ) ?;
1917
1947
}
1918
1948
if let Some ( window_frame) = & self . window_frame {
1919
- f. write_str ( delim) ?;
1949
+ if !is_first {
1950
+ SpaceOrNewline . fmt ( f) ?;
1951
+ }
1920
1952
if let Some ( end_bound) = & window_frame. end_bound {
1921
1953
write ! (
1922
1954
f,
@@ -4204,6 +4236,28 @@ impl fmt::Display for RaisErrorOption {
4204
4236
}
4205
4237
4206
4238
impl fmt:: Display for Statement {
4239
+ /// Formats a SQL statement with support for pretty printing.
4240
+ ///
4241
+ /// When using the alternate flag (`{:#}`), the statement will be formatted with proper
4242
+ /// indentation and line breaks. For example:
4243
+ ///
4244
+ /// ```
4245
+ /// # use sqlparser::dialect::GenericDialect;
4246
+ /// # use sqlparser::parser::Parser;
4247
+ /// let sql = "SELECT a, b FROM table_1";
4248
+ /// let ast = Parser::parse_sql(&GenericDialect, sql).unwrap();
4249
+ ///
4250
+ /// // Regular formatting
4251
+ /// assert_eq!(format!("{}", ast[0]), "SELECT a, b FROM table_1");
4252
+ ///
4253
+ /// // Pretty printing
4254
+ /// assert_eq!(format!("{:#}", ast[0]),
4255
+ /// r#"SELECT
4256
+ /// a,
4257
+ /// b
4258
+ /// FROM
4259
+ /// table_1"#);
4260
+ /// ```
4207
4261
// Clippy thinks this function is too complicated, but it is painful to
4208
4262
// split up without extracting structs for each `Statement` variant.
4209
4263
#[ allow( clippy:: cognitive_complexity) ]
@@ -4219,7 +4273,8 @@ impl fmt::Display for Statement {
4219
4273
} => {
4220
4274
write ! ( f, "FLUSH" ) ?;
4221
4275
if let Some ( location) = location {
4222
- write ! ( f, " {location}" ) ?;
4276
+ f. write_str ( " " ) ?;
4277
+ location. fmt ( f) ?;
4223
4278
}
4224
4279
write ! ( f, " {object_type}" ) ?;
4225
4280
@@ -4301,7 +4356,7 @@ impl fmt::Display for Statement {
4301
4356
4302
4357
write ! ( f, "{statement}" )
4303
4358
}
4304
- Statement :: Query ( s) => write ! ( f , "{s}" ) ,
4359
+ Statement :: Query ( s) => s . fmt ( f ) ,
4305
4360
Statement :: Declare { stmts } => {
4306
4361
write ! ( f, "DECLARE " ) ?;
4307
4362
write ! ( f, "{}" , display_separated( stmts, "; " ) )
@@ -7056,7 +7111,8 @@ impl fmt::Display for Function {
7056
7111
}
7057
7112
7058
7113
if let Some ( o) = & self . over {
7059
- write ! ( f, " OVER {o}" ) ?;
7114
+ f. write_str ( " OVER " ) ?;
7115
+ o. fmt ( f) ?;
7060
7116
}
7061
7117
7062
7118
if self . uses_odbc_syntax {
0 commit comments