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 is_nested_delimited_identifier_start(&self, _ch: char) -> bool { ... }
    fn peek_nested_delimited_identifier_quotes(
        &self,
        _chars: Peekable<Chars<'_>>,
    ) -> Option<(char, Option<char>)> { ... }
    fn identifier_quote_style(&self, _identifier: &str) -> Option<char> { ... }
    fn is_custom_operator_part(&self, _ch: char) -> bool { ... }
    fn supports_string_literal_backslash_escape(&self) -> bool { ... }
    fn ignores_wildcard_escapes(&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_group_by_with_modifier(&self) -> bool { ... }
    fn supports_outer_join_operator(&self) -> bool { ... }
    fn supports_connect_by(&self) -> bool { ... }
    fn supports_execute_immediate(&self) -> bool { ... }
    fn supports_match_recognize(&self) -> bool { ... }
    fn supports_in_empty_list(&self) -> bool { ... }
    fn supports_start_transaction_modifier(&self) -> bool { ... }
    fn supports_end_transaction_modifier(&self) -> bool { ... }
    fn supports_named_fn_args_with_eq_operator(&self) -> bool { ... }
    fn supports_named_fn_args_with_colon_operator(&self) -> bool { ... }
    fn supports_named_fn_args_with_assignment_operator(&self) -> bool { ... }
    fn supports_named_fn_args_with_rarrow_operator(&self) -> bool { ... }
    fn supports_named_fn_args_with_expr_name(&self) -> bool { ... }
    fn supports_numeric_prefix(&self) -> bool { ... }
    fn supports_numeric_literal_underscores(&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_comma_separated_set_assignments(&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_limit_comma(&self) -> bool { ... }
    fn supports_projection_trailing_commas(&self) -> bool { ... }
    fn supports_from_trailing_commas(&self) -> bool { ... }
    fn supports_column_definition_trailing_commas(&self) -> bool { ... }
    fn supports_object_name_double_dot_notation(&self) -> bool { ... }
    fn supports_struct_literal(&self) -> bool { ... }
    fn supports_empty_projections(&self) -> bool { ... }
    fn supports_select_expr_star(&self) -> bool { ... }
    fn supports_from_first_select(&self) -> bool { ... }
    fn supports_user_host_grantee(&self) -> bool { ... }
    fn supports_match_against(&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 parse_column_option(
        &self,
        _parser: &mut Parser<'_>,
    ) -> Result<Option<Result<Option<ColumnOption>, ParserError>>, 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_dollar_placeholder(&self) -> bool { ... }
    fn supports_create_index_with_clause(&self) -> bool { ... }
    fn require_interval_qualifier(&self) -> bool { ... }
    fn supports_explain_with_utility_options(&self) -> bool { ... }
    fn supports_asc_desc_in_column_definition(&self) -> bool { ... }
    fn supports_factorial_operator(&self) -> bool { ... }
    fn supports_nested_comments(&self) -> bool { ... }
    fn supports_eq_alias_assignment(&self) -> bool { ... }
    fn supports_try_convert(&self) -> bool { ... }
    fn supports_bang_not_operator(&self) -> bool { ... }
    fn supports_listen_notify(&self) -> bool { ... }
    fn supports_load_data(&self) -> bool { ... }
    fn supports_load_extension(&self) -> bool { ... }
    fn supports_top_before_distinct(&self) -> bool { ... }
    fn supports_boolean_literals(&self) -> bool { ... }
    fn supports_show_like_before_in(&self) -> bool { ... }
    fn supports_comment_on(&self) -> bool { ... }
    fn supports_create_table_select(&self) -> bool { ... }
    fn supports_partiql(&self) -> bool { ... }
    fn is_reserved_for_identifier(&self, kw: Keyword) -> bool { ... }
    fn get_reserved_keywords_for_table_factor(&self) -> &[Keyword] { ... }
    fn get_reserved_keywords_for_select_item_operator(&self) -> &[Keyword] { ... }
    fn supports_table_sample_before_alias(&self) -> bool { ... }
    fn supports_insert_set(&self) -> bool { ... }
    fn supports_insert_table_function(&self) -> bool { ... }
    fn supports_insert_format(&self) -> bool { ... }
    fn supports_set_stmt_without_operator(&self) -> bool { ... }
    fn is_column_alias(&self, kw: &Keyword, _parser: &mut Parser<'_>) -> bool { ... }
    fn is_select_item_alias(
        &self,
        explicit: bool,
        kw: &Keyword,
        parser: &mut Parser<'_>,
    ) -> bool { ... }
    fn is_table_factor_alias(
        &self,
        explicit: bool,
        kw: &Keyword,
        _parser: &mut Parser<'_>,
    ) -> bool { ... }
    fn supports_timestamp_versioning(&self) -> bool { ... }
    fn supports_string_escape_constant(&self) -> bool { ... }
    fn supports_table_hints(&self) -> bool { ... }
    fn requires_single_line_comment_whitespace(&self) -> bool { ... }
    fn supports_array_typedef_with_brackets(&self) -> bool { ... }
    fn supports_geometric_types(&self) -> bool { ... }
    fn supports_order_by_all(&self) -> bool { ... }
    fn supports_set_names(&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 is_nested_delimited_identifier_start(&self, _ch: char) -> bool

Determine if a character starts a potential nested quoted identifier. Example: RedShift supports the following quote styles to all mean the same thing:

SELECT 1 AS foo;
SELECT 1 AS "foo";
SELECT 1 AS [foo];
SELECT 1 AS ["foo"];

fn peek_nested_delimited_identifier_quotes( &self, _chars: Peekable<Chars<'_>>, ) -> Option<(char, Option<char>)>

Only applicable whenever Self::is_nested_delimited_identifier_start returns true If the next sequence of tokens potentially represent a nested identifier, then this method returns a tuple containing the outer quote style, and if present, the inner (nested) quote style.

Example (Redshift):

`["foo"]` => Some(`[`, Some(`"`))
`[foo]` => Some(`[`, None)
`[0]` => None
`"foo"` => None

fn identifier_quote_style(&self, _identifier: &str) -> Option<char>

Return the character used to quote identifiers.

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

Determine whether the dialect strips the backslash when escaping LIKE wildcards (%, _).

MySQL has a special case when escaping single quoted strings which leaves these unescaped so they can be used in LIKE patterns without double-escaping (as is necessary in other escaping dialects, such as Snowflake). Generally, special characters have escaping rules causing them to be replaced with a different byte sequences (e.g. '\0' becoming the zero byte), and the default if an escaped character does not have a specific escaping rule is to strip the backslash (e.g. there is no rule for h, so '\h' = 'h'). MySQL’s special case for ignoring LIKE wildcard escapes is to not strip the backslash, so that '\%' = '\\%'. This applies to all string literals though, not just those used in LIKE patterns.

mysql> select '\_', hex('\\'), hex('_'), hex('\_');
+----+-----------+----------+-----------+
| \_ | hex('\\') | hex('_') | hex('\_') |
+----+-----------+----------+-----------+
| \_ | 5C        | 5F       | 5C5F      |
+----+-----------+----------+-----------+
1 row in set (0.00 sec)

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

Returns true if the dialects supports GROUP BY modifiers prefixed by a WITH keyword. Example: GROUP BY value WITH ROLLUP.

fn supports_outer_join_operator(&self) -> bool

Returns true if the dialect supports the (+) syntax for OUTER JOIN.

fn supports_connect_by(&self) -> bool

Returns true if the dialect supports CONNECT BY.

fn supports_execute_immediate(&self) -> bool

Returns true if the dialect supports EXECUTE IMMEDIATE statements.

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 | TRY | CATCH} [TRANSACTION] statements

fn supports_end_transaction_modifier(&self) -> bool

Returns true if the dialect supports END {TRY | CATCH} 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_named_fn_args_with_colon_operator(&self) -> bool

Returns true if the dialect supports named arguments of the form FUN(a : '1', b : '2').

fn supports_named_fn_args_with_assignment_operator(&self) -> bool

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

fn supports_named_fn_args_with_rarrow_operator(&self) -> bool

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

fn supports_named_fn_args_with_expr_name(&self) -> bool

Returns true if dialect supports argument name as arbitrary expression. e.g. FUN(LOWER('a'):'1', b:'2') Such function arguments are represented in the AST by the FunctionArg::ExprNamed variant, otherwise use the FunctionArg::Named variant (compatible reason).

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

Returns true if the dialect supports numbers containing underscores, e.g. 10_000_000

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

Returns true if the dialect supports multiple SET statements in a single statement.

SET variable = expression [, 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_limit_comma(&self) -> bool

Does the dialect support parsing LIMIT 1, 2 as LIMIT 2 OFFSET 1?

fn supports_projection_trailing_commas(&self) -> bool

Does the dialect support trailing commas in the projection list?

fn supports_from_trailing_commas(&self) -> bool

Returns true if the dialect supports trailing commas in the FROM clause of a SELECT statement. Example: SELECT 1 FROM T, U, LIMIT 1

fn supports_column_definition_trailing_commas(&self) -> bool

Returns true if the dialect supports trailing commas in the column definitions list of a CREATE statement. Example: CREATE TABLE T (x INT, y TEXT,)

fn supports_object_name_double_dot_notation(&self) -> bool

Returns true if the dialect supports double dot notation for object names

Example

SELECT * FROM db_name..table_name

fn supports_struct_literal(&self) -> bool

Return true if the dialect supports the STRUCT literal

Example

SELECT STRUCT(1 as one, 'foo' as foo, false)

fn supports_empty_projections(&self) -> bool

Return true if the dialect supports empty projections in SELECT statements

Example

SELECT from table_name

fn supports_select_expr_star(&self) -> bool

Return true if the dialect supports wildcard expansion on arbitrary expressions in projections.

Example:

SELECT STRUCT<STRING>('foo').* FROM T

fn supports_from_first_select(&self) -> bool

Return true if the dialect supports “FROM-first” selects.

Example:

FROM table
SELECT *

fn supports_user_host_grantee(&self) -> bool

Does the dialect support MySQL-style 'user'@'host' grantee syntax?

fn supports_match_against(&self) -> bool

Does the dialect support the MATCH() AGAINST() syntax?

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 parse_column_option( &self, _parser: &mut Parser<'_>, ) -> Result<Option<Result<Option<ColumnOption>, ParserError>>, ParserError>

Dialect-specific column option parser override

This method is called to parse the next column option.

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

Returns true if this dialect allows dollar placeholders e.g. SELECT $var (SQLite)

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

fn supports_explain_with_utility_options(&self) -> bool

fn supports_asc_desc_in_column_definition(&self) -> bool

fn supports_factorial_operator(&self) -> bool

Returns true if the dialect supports a! expressions

fn supports_nested_comments(&self) -> bool

Returns true if the dialect supports nested comments e.g. /* /* nested */ */

fn supports_eq_alias_assignment(&self) -> bool

Returns true if this dialect supports treating the equals operator = within a SelectItem as an alias assignment operator, rather than a boolean expression. For example: the following statements are equivalent for such a dialect:

 SELECT col_alias = col FROM tbl;
 SELECT col_alias AS col FROM tbl;

fn supports_try_convert(&self) -> bool

Returns true if this dialect supports the TRY_CONVERT function

fn supports_bang_not_operator(&self) -> bool

Returns true if the dialect supports !a syntax for boolean NOT expressions.

fn supports_listen_notify(&self) -> bool

Returns true if the dialect supports the LISTEN, UNLISTEN and NOTIFY statements

fn supports_load_data(&self) -> bool

Returns true if the dialect supports the LOAD DATA statement

fn supports_load_extension(&self) -> bool

Returns true if the dialect supports the LOAD extension statement

fn supports_top_before_distinct(&self) -> bool

Returns true if this dialect expects the TOP option before the ALL/DISTINCT options in a SELECT statement.

fn supports_boolean_literals(&self) -> bool

Returns true if the dialect supports boolean literals (true and false). For example, in MSSQL these are treated as identifiers rather than boolean literals.

fn supports_show_like_before_in(&self) -> bool

Returns true if this dialect supports the LIKE 'pattern' option in a SHOW statement before the IN option

fn supports_comment_on(&self) -> bool

Returns true if this dialect supports the COMMENT statement

fn supports_create_table_select(&self) -> bool

Returns true if the dialect supports the CREATE TABLE SELECT statement

fn supports_partiql(&self) -> bool

Returns true if the dialect supports PartiQL for querying semi-structured data https://partiql.org/index.html

fn is_reserved_for_identifier(&self, kw: Keyword) -> bool

Returns true if the specified keyword is reserved and cannot be used as an identifier without special handling like quoting.

fn get_reserved_keywords_for_table_factor(&self) -> &[Keyword]

Returns reserved keywords when looking to parse a TableFactor. See Self::supports_from_trailing_commas

fn get_reserved_keywords_for_select_item_operator(&self) -> &[Keyword]

Returns reserved keywords that may prefix a select item expression e.g. SELECT CONNECT_BY_ROOT name FROM Tbl2 (Snowflake)

fn supports_table_sample_before_alias(&self) -> bool

Returns true if this dialect supports the TABLESAMPLE option before the table alias option. For example:

Table sample before alias: SELECT * FROM tbl AS t TABLESAMPLE (10) Table sample after alias: SELECT * FROM tbl TABLESAMPLE (10) AS t

https://jakewheat.github.io/sql-overview/sql-2016-foundation-grammar.html#_7_6_table_reference

fn supports_insert_set(&self) -> bool

Returns true if this dialect supports the INSERT INTO ... SET col1 = 1, ... syntax.

MySQL: https://dev.mysql.com/doc/refman/8.4/en/insert.html

fn supports_insert_table_function(&self) -> bool

Does the dialect support table function in insertion?

fn supports_insert_format(&self) -> bool

Does the dialect support insert formats, e.g. INSERT INTO ... FORMAT <format>

fn supports_set_stmt_without_operator(&self) -> bool

Returns true if this dialect supports SET statements without an explicit assignment operator such as =. For example: SET SHOWPLAN_XML ON.

fn is_column_alias(&self, kw: &Keyword, _parser: &mut Parser<'_>) -> bool

Returns true if the specified keyword should be parsed as a column identifier. See keywords::RESERVED_FOR_COLUMN_ALIAS

fn is_select_item_alias( &self, explicit: bool, kw: &Keyword, parser: &mut Parser<'_>, ) -> bool

Returns true if the specified keyword should be parsed as a select item alias. When explicit is true, the keyword is preceded by an AS word. Parser is provided to enable looking ahead if needed.

fn is_table_factor_alias( &self, explicit: bool, kw: &Keyword, _parser: &mut Parser<'_>, ) -> bool

Returns true if the specified keyword should be parsed as a table factor alias. When explicit is true, the keyword is preceded by an AS word. Parser is provided to enable looking ahead if needed.

fn supports_timestamp_versioning(&self) -> bool

Returns true if this dialect supports querying historical table data by specifying which version of the data to query.

fn supports_string_escape_constant(&self) -> bool

Returns true if this dialect supports the E’…’ syntax for string literals

Postgres: https://www.postgresql.org/docs/current/sql-syntax-lexical.html#SQL-SYNTAX-STRINGS-ESCAPE

fn supports_table_hints(&self) -> bool

Returns true if the dialect supports the table hints in the FROM clause.

fn requires_single_line_comment_whitespace(&self) -> bool

Returns true if this dialect requires a whitespace character after -- to start a single line comment.

MySQL: https://dev.mysql.com/doc/refman/8.4/en/ansi-diff-comments.html e.g. UPDATE account SET balance=balance–1

fn supports_array_typedef_with_brackets(&self) -> bool

Returns true if the dialect supports array type definition with brackets with an optional size. For example: CREATE TABLE my_table (arr1 INT[], arr2 INT[3]) SELECT x::INT[]

fn supports_geometric_types(&self) -> bool

Returns true if the dialect supports geometric types.

Postgres: https://www.postgresql.org/docs/9.5/functions-geometry.html e.g. @@ circle ‘((0,0),10)’

fn supports_order_by_all(&self) -> bool

Returns true if the dialect supports ORDER BY ALL. ALL which means all columns of the SELECT clause.

For example: SELECT * FROM addresses ORDER BY ALL;.

fn supports_set_names(&self) -> bool

Returns true if the dialect supports SET NAMES <charset_name> [COLLATE <collation_name>].

• MySQL
• PostgreSQL

Note: Postgres doesn’t support the COLLATE clause, but we permissively parse it anyway.

Implementations

impl dyn Dialect

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

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