Trait gluesql::core::sqlparser::dialect::Dialect

pub trait Dialect: Debug + Any {
    // Required methods
    fn is_identifier_start(&self, ch: char) -> bool;
    fn is_identifier_part(&self, ch: char) -> bool;

    // Provided methods
    fn is_delimited_identifier_start(&self, ch: char) -> bool { ... }
    fn is_proper_identifier_inside_quotes(
        &self,
        _chars: Peekable<Chars<'_>>
    ) -> bool { ... }
    fn supports_filter_during_aggregation(&self) -> bool { ... }
    fn supports_within_after_array_aggregation(&self) -> bool { ... }
    fn supports_group_by_expr(&self) -> bool { ... }
    fn parse_prefix(
        &self,
        _parser: &mut Parser<'_>
    ) -> Option<Result<Expr, ParserError>> { ... }
    fn parse_infix(
        &self,
        _parser: &mut Parser<'_>,
        _expr: &Expr,
        _precedence: u8
    ) -> Option<Result<Expr, ParserError>> { ... }
    fn get_next_precedence(
        &self,
        _parser: &Parser<'_>
    ) -> Option<Result<u8, ParserError>> { ... }
    fn parse_statement(
        &self,
        _parser: &mut Parser<'_>
    ) -> Option<Result<Statement, ParserError>> { ... }
}
Expand description

Encapsulates the differences between SQL implementations.

SQL Dialects

SQL implementations deviatiate from one another, either due to custom extensions or various historical reasons. This trait encapsulates the parsing differences between dialects.

Examples

Most users create a Dialect directly, as shown on the module level documentation:

let dialect = AnsiDialect {};

It is also possible to dynamically create a Dialect from its name. For example:

let dialect = dialect_from_str("ansi").unwrap();

// Parsed dialect is an instance of `AnsiDialect`:
assert!(dialect.is::<AnsiDialect>());

Required Methods§

fn is_identifier_start(&self, ch: char) -> bool

Determine if a character is a valid start character for an unquoted identifier

fn is_identifier_part(&self, ch: char) -> bool

Determine if a character is a valid unquoted identifier character

Provided Methods§

fn is_delimited_identifier_start(&self, ch: char) -> bool

Determine if a character starts a quoted identifier. The default implementation, accepting “double quoted” ids is both ANSI-compliant and appropriate for most dialects (with the notable exception of MySQL, MS SQL, and sqlite). You can accept one of characters listed in Word::matching_end_quote here

fn is_proper_identifier_inside_quotes( &self, _chars: Peekable<Chars<'_>> ) -> bool

Determine if quoted characters are proper for identifier

fn supports_filter_during_aggregation(&self) -> bool

Does the dialect support FILTER (WHERE expr) for aggregate queries?

fn supports_within_after_array_aggregation(&self) -> bool

Returns true if the dialect supports ARRAY_AGG() [WITHIN GROUP (ORDER BY)] expressions. Otherwise, the dialect should expect an ORDER BY without the WITHIN GROUP clause, e.g. ANSI

fn supports_group_by_expr(&self) -> bool

Returns true if the dialects supports group sets, roll up, or cube expressions.

fn parse_prefix( &self, _parser: &mut Parser<'_> ) -> Option<Result<Expr, ParserError>>

Dialect-specific prefix parser override

fn parse_infix( &self, _parser: &mut Parser<'_>, _expr: &Expr, _precedence: u8 ) -> Option<Result<Expr, ParserError>>

Dialect-specific infix parser override

fn get_next_precedence( &self, _parser: &Parser<'_> ) -> Option<Result<u8, ParserError>>

Dialect-specific precedence override

fn parse_statement( &self, _parser: &mut Parser<'_> ) -> Option<Result<Statement, ParserError>>

Dialect-specific statement parser override

Implementations§

§

impl dyn Dialect

pub fn is<T>(&self) -> boolwhere T: Dialect,

Implementors§