banshee_format 0.2.3

PostgreSQL SQL formatter with sqlstyle and pgFormatter engines.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

//! Formatting rules for SQL.
//!
//! This module contains rules for how different SQL constructs should be formatted.

pub mod keywords;

use banshee_syntax::SyntaxKind;

/// Returns the keyword text for a syntax kind (for river alignment calculation).
pub fn keyword_text(kind: SyntaxKind) -> Option<&'static str> {
    keywords::keyword_text(kind)
}

/// Returns the river keyword for a clause (right-aligned keywords).
pub fn clause_keyword(kind: SyntaxKind) -> Option<&'static str> {
    match kind {
        SyntaxKind::SELECT_CLAUSE => Some("SELECT"),
        SyntaxKind::FROM_CLAUSE => Some("FROM"),
        SyntaxKind::WHERE_CLAUSE => Some("WHERE"),
        SyntaxKind::GROUP_BY_CLAUSE => Some("GROUP BY"),
        SyntaxKind::HAVING_CLAUSE => Some("HAVING"),
        SyntaxKind::ORDER_BY_CLAUSE => Some("ORDER BY"),
        SyntaxKind::LIMIT_CLAUSE => Some("LIMIT"),
        SyntaxKind::OFFSET_CLAUSE => Some("OFFSET"),
        SyntaxKind::WITH_CLAUSE => Some("WITH"),
        SyntaxKind::RETURNING_CLAUSE => Some("RETURNING"),
        SyntaxKind::SET_CLAUSE => Some("SET"),
        SyntaxKind::VALUES_CLAUSE => Some("VALUES"),
        SyntaxKind::USING_CLAUSE => Some("USING"),
        _ => None,
    }
}

/// Returns the join type keyword for formatting.
pub fn join_keyword(kind: SyntaxKind) -> Option<&'static str> {
    match kind {
        SyntaxKind::INNER_KW => Some("INNER JOIN"),
        SyntaxKind::LEFT_KW => Some("LEFT JOIN"),
        SyntaxKind::RIGHT_KW => Some("RIGHT JOIN"),
        SyntaxKind::FULL_KW => Some("FULL JOIN"),
        SyntaxKind::CROSS_KW => Some("CROSS JOIN"),
        SyntaxKind::NATURAL_KW => Some("NATURAL JOIN"),
        SyntaxKind::JOIN_KW => Some("JOIN"),
        _ => None,
    }
}

/// Returns true if the kind is a clause that starts a new line.
pub fn is_newline_clause(kind: SyntaxKind) -> bool {
    matches!(
        kind,
        SyntaxKind::SELECT_CLAUSE
            | SyntaxKind::FROM_CLAUSE
            | SyntaxKind::WHERE_CLAUSE
            | SyntaxKind::GROUP_BY_CLAUSE
            | SyntaxKind::HAVING_CLAUSE
            | SyntaxKind::ORDER_BY_CLAUSE
            | SyntaxKind::LIMIT_CLAUSE
            | SyntaxKind::OFFSET_CLAUSE
            | SyntaxKind::RETURNING_CLAUSE
            | SyntaxKind::SET_CLAUSE
            | SyntaxKind::VALUES_CLAUSE
            | SyntaxKind::USING_CLAUSE
    )
}

/// Returns true if the kind is a logical operator (AND/OR).
pub fn is_logical_operator(kind: SyntaxKind) -> bool {
    matches!(kind, SyntaxKind::AND_KW | SyntaxKind::OR_KW)
}

/// Returns the width needed for river alignment of a clause.
pub fn calculate_river_width(keywords: &[&str]) -> usize {
    keywords.iter().map(|k| k.len()).max().unwrap_or(0)
}

/// Standard SQL clause keywords for river width calculation.
pub const STANDARD_CLAUSE_KEYWORDS: &[&str] = &[
    "SELECT",
    "FROM",
    "WHERE",
    "GROUP BY",
    "HAVING",
    "ORDER BY",
    "LIMIT",
    "OFFSET",
    "WITH",
    "RETURNING",
    "SET",
    "VALUES",
    "USING",
    "LEFT JOIN",
    "RIGHT JOIN",
    "INNER JOIN",
    "FULL JOIN",
    "CROSS JOIN",
    "ON",
    "AND",
    "OR",
];

/// Returns the recommended river width for standard SQL formatting.
pub fn standard_river_width() -> usize {
    // "LEFT JOIN" is 9 chars, "RETURNING" is 9 chars, add 1 for padding
    10
}