Struct BigQueryDialect

pub struct BigQueryDialect;

A Dialect for Google Bigquery

Trait Implementations

impl Debug for BigQueryDialect

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

Formats the value using the given formatter.

impl Default for BigQueryDialect

fn default() -> BigQueryDialect

Returns the “default value” for a type.

impl Dialect for BigQueryDialect

fn supports_triple_quoted_string(&self) -> bool

See doc

fn supports_window_function_null_treatment_arg(&self) -> bool

See doc

fn supports_window_clause_named_window_reference(&self) -> bool

See doc

fn supports_parenthesized_set_variables(&self) -> bool

See doc

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

Does the dialect support trailing commas in the projection list?

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

fn supports_string_literal_backslash_escape(&self) -> bool

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

fn supports_select_wildcard_except(&self) -> bool

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

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

Return true if the dialect supports the STRUCT literal

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

Returns true if the dialect supports method calls, for example:

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

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

fn supports_empty_projections(&self) -> bool

Return true if the dialect supports empty projections in SELECT statements

fn supports_user_host_grantee(&self) -> bool

Does the dialect support MySQL-style 'user'@'host' grantee 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_statement( &self, _parser: &mut Parser<'_>, ) -> Option<Result<Statement, ParserError>>

Dialect-specific statement parser override

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

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]

See Self::supports_from_trailing_commas

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