Struct SQLiteDialect

pub struct SQLiteDialect {}

A Dialect for SQLite

This dialect allows columns in a CREATE TABLE statement with no type specified, as in CREATE TABLE t1 (a). In the AST, these columns will have the data type Unspecified.

Trait Implementations

impl Debug for SQLiteDialect

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Dialect for SQLiteDialect

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_identifier_start(&self, ch: char) -> bool

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

fn supports_filter_during_aggregation(&self) -> bool

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

fn supports_start_transaction_modifier(&self) -> bool

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

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

Determine if a character is a valid unquoted identifier character

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

Dialect-specific statement parser override

fn supports_in_empty_list(&self) -> bool

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

fn supports_limit_comma(&self) -> bool

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

fn supports_asc_desc_in_column_definition(&self) -> bool

fn supports_dollar_placeholder(&self) -> bool

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

fn dialect(&self) -> TypeId

Determine the TypeId of this dialect.

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:

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.

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.

fn ignores_wildcard_escapes(&self) -> bool

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

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:

fn supports_window_clause_named_window_reference(&self) -> bool

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

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_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.

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:

fn supports_parenthesized_set_variables(&self) -> bool

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

fn supports_comma_separated_set_assignments(&self) -> bool

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

fn supports_select_wildcard_except(&self) -> bool

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

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 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

fn supports_struct_literal(&self) -> bool

Return true if the dialect supports the STRUCT literal

fn supports_empty_projections(&self) -> bool

Return true if the dialect supports empty projections in SELECT statements

fn supports_select_expr_star(&self) -> bool

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

fn supports_from_first_select(&self) -> bool

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

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

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

Dialect-specific precedence override

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

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

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

Dialect-specific column option parser override

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

Decide the lexical Precedence of operators.

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

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.

fn supports_explain_with_utility_options(&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:

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:

fn supports_insert_set(&self) -> bool

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

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

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.

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.

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.

fn supports_set_names(&self) -> bool

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