Trait 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 dialect(&self) -> TypeId { ... }
    fn is_delimited_identifier_start(&self, ch: char) -> bool { ... }
    fn identifier_quote_style(&self, _identifier: &str) -> Option<char> { ... }
    fn is_proper_identifier_inside_quotes(
        &self,
        _chars: Peekable<Chars<'_>>,
    ) -> bool { ... }
    fn is_custom_operator_part(&self, _ch: char) -> bool { ... }
    fn supports_string_literal_backslash_escape(&self) -> bool { ... }
    fn supports_unicode_string_literal(&self) -> bool { ... }
    fn supports_filter_during_aggregation(&self) -> bool { ... }
    fn supports_window_clause_named_window_reference(&self) -> bool { ... }
    fn supports_within_after_array_aggregation(&self) -> bool { ... }
    fn supports_group_by_expr(&self) -> bool { ... }
    fn supports_connect_by(&self) -> bool { ... }
    fn supports_match_recognize(&self) -> bool { ... }
    fn supports_in_empty_list(&self) -> bool { ... }
    fn supports_start_transaction_modifier(&self) -> bool { ... }
    fn supports_named_fn_args_with_eq_operator(&self) -> bool { ... }
    fn supports_numeric_prefix(&self) -> bool { ... }
    fn supports_window_function_null_treatment_arg(&self) -> bool { ... }
    fn supports_dictionary_syntax(&self) -> bool { ... }
    fn support_map_literal_syntax(&self) -> bool { ... }
    fn supports_lambda_functions(&self) -> bool { ... }
    fn supports_parenthesized_set_variables(&self) -> bool { ... }
    fn supports_select_wildcard_except(&self) -> bool { ... }
    fn convert_type_before_value(&self) -> bool { ... }
    fn supports_triple_quoted_string(&self) -> bool { ... }
    fn parse_prefix(
        &self,
        _parser: &mut Parser<'_>,
    ) -> Option<Result<Expr, ParserError>> { ... }
    fn supports_trailing_commas(&self) -> bool { ... }
    fn supports_projection_trailing_commas(&self) -> bool { ... }
    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 get_next_precedence_default(
        &self,
        parser: &Parser<'_>,
    ) -> Result<u8, ParserError> { ... }
    fn parse_statement(
        &self,
        _parser: &mut Parser<'_>,
    ) -> Option<Result<Statement, ParserError>> { ... }
    fn prec_value(&self, prec: Precedence) -> u8 { ... }
    fn prec_unknown(&self) -> u8 { ... }
    fn describe_requires_table_keyword(&self) -> bool { ... }
    fn allow_extract_custom(&self) -> bool { ... }
    fn allow_extract_single_quotes(&self) -> bool { ... }
    fn supports_create_index_with_clause(&self) -> bool { ... }
    fn require_interval_qualifier(&self) -> bool { ... }
}

Encapsulates the differences between SQL implementations.

SQL Dialects

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

GenericDialect is the most permissive dialect, and parses the union of all the other dialects, when there is no ambiguity. However, it does not currently allow CREATE TABLE statements without types specified for all columns; use SQLiteDialect if you require that.

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 dialect(&self) -> TypeId

Determine the TypeId of this dialect.

By default, return the same TypeId as Any::type_id. Can be overridden by dialects that behave like other dialects (for example when wrapping a dialect).

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 identifier_quote_style(&self, _identifier: &str) -> Option<char>

Return the character used to quote identifiers.

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

Determine if quoted characters are proper for identifier

fn is_custom_operator_part(&self, _ch: char) -> bool

Most dialects do not have custom operators. Override this method to provide custom operators.

fn supports_string_literal_backslash_escape(&self) -> bool

Determine if the dialect supports escaping characters via ’' in string literals.

Some dialects like BigQuery and Snowflake support this while others like Postgres do not. Such that the following is accepted by the former but rejected by the latter.

SELECT 'ab\'cd';

Conversely, such dialects reject the following statement which otherwise would be valid in the other dialects.

SELECT '\';

fn supports_unicode_string_literal(&self) -> bool

Determine if the dialect supports string literals with U& prefix. This is used to specify Unicode code points in string literals. For example, in PostgreSQL, the following is a valid string literal:

SELECT U&'\0061\0062\0063';

This is equivalent to the string literal 'abc'. See

• Postgres docs
• H2 docs

fn supports_filter_during_aggregation(&self) -> bool

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

fn supports_window_clause_named_window_reference(&self) -> bool

Returns true if the dialect supports referencing another named window within a window clause declaration.

Example

SELECT * FROM mytable
WINDOW mynamed_window AS another_named_window

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 supports_connect_by(&self) -> bool

Returns true if the dialect supports CONNECT BY.

fn supports_match_recognize(&self) -> bool

Returns true if the dialect supports the MATCH_RECOGNIZE operation.

fn supports_in_empty_list(&self) -> bool

Returns true if the dialect supports (NOT) IN () expressions

fn supports_start_transaction_modifier(&self) -> bool

Returns true if the dialect supports BEGIN {DEFERRED | IMMEDIATE | EXCLUSIVE} [TRANSACTION] statements

fn supports_named_fn_args_with_eq_operator(&self) -> bool

Returns true if the dialect supports named arguments of the form FUN(a = ‘1’, b = ‘2’).

fn supports_numeric_prefix(&self) -> bool

Returns true if the dialect supports identifiers starting with a numeric prefix such as tables named 59901_user_login

fn supports_window_function_null_treatment_arg(&self) -> bool

Returns true if the dialects supports specifying null treatment as part of a window function’s parameter list as opposed to after the parameter list.

i.e The following syntax returns true

FIRST_VALUE(a IGNORE NULLS) OVER ()

while the following syntax returns false

FIRST_VALUE(a) IGNORE NULLS OVER ()

fn supports_dictionary_syntax(&self) -> bool

Returns true if the dialect supports defining structs or objects using a syntax like {'x': 1, 'y': 2, 'z': 3}.

fn support_map_literal_syntax(&self) -> bool

Returns true if the dialect supports defining object using the syntax like Map {1: 10, 2: 20}.

fn supports_lambda_functions(&self) -> bool

Returns true if the dialect supports lambda functions, for example:

SELECT transform(array(1, 2, 3), x -> x + 1); -- returns [2,3,4]

fn supports_parenthesized_set_variables(&self) -> bool

Returns true if the dialect supports multiple variable assignment using parentheses in a SET variable declaration.

SET (variable[, ...]) = (expression[, ...]);

fn supports_select_wildcard_except(&self) -> bool

Returns true if the dialect supports an EXCEPT clause following a wildcard in a select list.

For example

SELECT * EXCEPT order_id FROM orders;

fn convert_type_before_value(&self) -> bool

Returns true if the dialect has a CONVERT function which accepts a type first and an expression second, e.g. CONVERT(varchar, 1)

fn supports_triple_quoted_string(&self) -> bool

Returns true if the dialect supports triple quoted string e.g. """abc"""

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

Dialect-specific prefix parser override

fn supports_trailing_commas(&self) -> bool

Does the dialect support trailing commas around the query?

fn supports_projection_trailing_commas(&self) -> bool

Does the dialect support trailing commas in the projection list?

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

Dialect-specific infix parser override

This method is called to parse the next infix expression.

If None is returned, falls back to the default behavior.

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

Dialect-specific precedence override

This method is called to get the precedence of the next token.

If None is returned, falls back to the default behavior.

fn get_next_precedence_default( &self, parser: &Parser<'_>, ) -> Result<u8, ParserError>

Get the precedence of the next token, looking at the full token stream.

A higher number => higher precedence

See Self::get_next_precedence to override the behavior for just the next token.

The default implementation is used for many dialects, but can be overridden to provide dialect-specific behavior.

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

Dialect-specific statement parser override

This method is called to parse the next statement.

If None is returned, falls back to the default behavior.

fn prec_value(&self, prec: Precedence) -> u8

Decide the lexical Precedence of operators.

Uses (APPROXIMATELY) https://www.postgresql.org/docs/7.0/operators.htm#AEN2026 as a reference

fn prec_unknown(&self) -> u8

Returns the precedence when the precedence is otherwise unknown

fn describe_requires_table_keyword(&self) -> bool

Returns true if this dialect requires the TABLE keyword after DESCRIBE

Defaults to false.

If true, the following statement is valid: DESCRIBE TABLE my_table If false, the following statements are valid: DESCRIBE my_table and DESCRIBE table

fn allow_extract_custom(&self) -> bool

Returns true if this dialect allows the EXTRACT function to words other than Keyword.

fn allow_extract_single_quotes(&self) -> bool

Returns true if this dialect allows the EXTRACT function to use single quotes in the part being extracted.

fn supports_create_index_with_clause(&self) -> bool

Does the dialect support with clause in create index statement? e.g. CREATE INDEX idx ON t WITH (key = value, key2)

fn require_interval_qualifier(&self) -> bool

Whether INTERVAL expressions require units (called “qualifiers” in the ANSI SQL spec) to be specified, e.g. INTERVAL 1 DAY vs INTERVAL 1.

Expressions within intervals (e.g. INTERVAL '1' + '1' DAY) are only allowed when units are required.

See https://github.com/sqlparser-rs/sqlparser-rs/pull/1398 for more information.

When true:

• INTERVAL '1' DAY is VALID
• INTERVAL 1 + 1 DAY is VALID
• INTERVAL '1' + '1' DAY is VALID
• INTERVAL '1' is INVALID

When false:

• INTERVAL '1' is VALID
• INTERVAL '1' DAY is VALID — unit is not required, but still allowed
• INTERVAL 1 + 1 DAY is INVALID

Implementations

impl dyn Dialect

pub fn is<T>(&self) -> bool

where T: Dialect,

Implementors

impl Dialect for AnsiDialect

impl Dialect for BigQueryDialect

impl Dialect for ClickHouseDialect

impl Dialect for DatabricksDialect

impl Dialect for DuckDbDialect

impl Dialect for GenericDialect

impl Dialect for HiveDialect

impl Dialect for MsSqlDialect

impl Dialect for MySqlDialect

impl Dialect for PostgreSqlDialect

impl Dialect for RedshiftSqlDialect

impl Dialect for SQLiteDialect

impl Dialect for SnowflakeDialect