Struct PostgreSqlDialect 

pub struct PostgreSqlDialect {}

A Dialect for PostgreSQL

Trait Implementations

impl Clone for PostgreSqlDialect

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for PostgreSqlDialect

impl Debug for PostgreSqlDialect

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

Formats the value using the given formatter.

impl Default for PostgreSqlDialect

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for PostgreSqlDialect

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Dialect for PostgreSqlDialect

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

See https://www.postgresql.org/docs/current/sql-createoperator.html

fn supports_explain_with_utility_options(&self) -> bool

see https://www.postgresql.org/docs/current/sql-explain.html

fn supports_listen_notify(&self) -> bool

see https://www.postgresql.org/docs/current/sql-listen.html see https://www.postgresql.org/docs/current/sql-unlisten.html see https://www.postgresql.org/docs/current/sql-notify.html

fn supports_exclude_constraint(&self) -> bool

see https://www.postgresql.org/docs/current/sql-createtable.html#SQL-CREATETABLE-EXCLUDE

fn supports_factorial_operator(&self) -> bool

see https://www.postgresql.org/docs/13/functions-math.html

fn supports_comment_on(&self) -> bool

see https://www.postgresql.org/docs/current/sql-comment.html

fn supports_load_extension(&self) -> bool

See https://www.postgresql.org/docs/current/sql-load.html

fn supports_named_fn_args_with_colon_operator(&self) -> bool

See https://www.postgresql.org/docs/current/functions-json.html

Required to support the colon in:

SELECT json_object('a': 'b')

fn supports_named_fn_args_with_expr_name(&self) -> bool

See https://www.postgresql.org/docs/current/functions-json.html

Required to support the label in:

SELECT json_object('label': 'value')

fn supports_empty_projections(&self) -> bool

Return true if the dialect supports empty projections in SELECT statements

Example

SELECT from table_name

fn supports_array_typedef_with_brackets(&self) -> bool

See: https://www.postgresql.org/docs/current/arrays.html#ARRAYS-DECLARATION

fn supports_left_associative_joins_without_parens(&self) -> bool

PostgreSQL supports right-deep join chains: t0 JOIN t1 JOIN t2 ON c1 ON c2 See: https://www.postgresql.org/docs/current/queries-table-expressions.html#QUERIES-JOIN

fn supports_notnull_operator(&self) -> bool

Postgres supports NOTNULL as an alias for IS NOT NULL See: https://www.postgresql.org/docs/17/functions-comparison.html

fn supports_interval_options(&self) -> bool

Postgres supports optional field and precision options for INTERVAL data type.

fn supports_comment_optimizer_hint(&self) -> bool

Postgres supports query optimizer hints via the pg_hint_plan extension, using the same comment-prefixed-with-+ syntax as MySQL and Oracle.

See https://github.com/ossc-db/pg_hint_plan

fn supports_do_statement(&self) -> bool

Returns true if this dialect supports PostgreSQL anonymous DO blocks.

fn is_select_item_alias( &self, explicit: bool, keyword: &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 identifier_quote_style(&self, _identifier: &str) -> Option<char>

Return the character used to quote identifiers.

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_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_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 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 is_table_alias(&self, kw: &Keyword, _parser: &mut Parser<'_>) -> bool

Returns true if the specified keyword should be parsed as a table factor alias. See keywords::RESERVED_FOR_TABLE_ALIAS

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

Dialect-specific precedence override

fn supports_filter_during_aggregation(&self) -> bool

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

fn supports_group_by_expr(&self) -> bool

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

fn supports_alter_user_as_alter_role(&self) -> bool

Returns true if the dialect treats ALTER USER as a synonym for ALTER ROLE.

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

Decide the lexical Precedence of operators.

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

Returns true if the dialect supports << and >> shift operators.

fn supports_nested_comments(&self) -> bool

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

fn supports_string_escape_constant(&self) -> bool

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

fn supports_numeric_literal_underscores(&self) -> bool

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

fn supports_geometric_types(&self) -> bool

Returns true if the dialect supports geometric types.

fn supports_order_by_using_operator(&self) -> bool

Returns true if the dialect supports PostgreSQL-style ordering operators: ORDER BY expr USING <operator>.

fn supports_set_names(&self) -> bool

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

fn supports_set_schema(&self) -> bool

Returns true if the dialect supports SET [SESSION | LOCAL] SCHEMA 'name'.

fn supports_reset_time_zone(&self) -> bool

Returns true if the dialect supports RESET TIME ZONE.

fn supports_alter_column_type_using(&self) -> bool

Returns true if the dialect supports the USING clause in an ALTER COLUMN statement. Example:

fn supports_insert_table_alias(&self) -> bool

Returns true if this dialect supports INSERT INTO t [[AS] alias] ....

fn supports_create_table_like_parenthesized(&self) -> bool

Returns true if the dialect supports specifying which table to copy the schema from inside parenthesis.

fn supports_select_wildcard_with_alias(&self) -> bool

Returns true if this dialect supports aliasing a wildcard select item.

fn supports_comma_separated_trim(&self) -> bool

Returns true if the dialect supports the two-argument comma-separated form of the TRIM function: TRIM(expr, characters).

fn supports_xml_expressions(&self) -> bool

Returns true if the dialect supports XML-related expressions such as xml '<foo/>' typed strings, XML functions like XMLCONCAT, XMLELEMENT, etc.

fn supports_aliased_function_args(&self) -> bool

Returns true if the dialect supports aliased function arguments, e.g. XMLFOREST(a AS x) in PostgreSQL.

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

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

fn supports_national_string_literal(&self) -> bool

Does the dialect tokenize N'...' as a national string literal?

fn ignores_wildcard_escapes(&self) -> bool

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

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

Returns true if the dialect supports PARTITION BY appearing after ORDER BY in a CREATE TABLE statement (in addition to the standard placement before ORDER BY).

fn supports_array_join_syntax(&self) -> bool

Returns true if the dialect supports ClickHouse-style ARRAY JOIN / LEFT ARRAY JOIN / INNER ARRAY JOIN syntax for unnesting arrays inline.

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

Returns true if the dialect supports a join specification on CROSS 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_in_unparenthesized_expr(&self) -> bool

Returns true if the dialect supports a bare expression as the right-hand side of IN, without a parenthesized list — as in x IN 'a'.

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

Returns true if a period directly after an identifier starts a tuple element access such as t.1, instead of the number .1.

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

Returns true if the dialect supports the LAMBDA keyword spelling of 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_update_order_by(&self) -> bool

Returns true if the dialect supports ORDER BY in UPDATE statements.

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

Does the dialect support the APPROXIMATE PERCENTILE_DISC function syntax? See https://docs.aws.amazon.com/redshift/latest/dg/r_APPROXIMATE_PERCENTILE_DISC.html

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

Returns true if the dialect supports concatenating of string literal Example: SELECT 'Hello ' "world" => SELECT 'Hello world'

fn supports_string_literal_concatenation_with_newline(&self) -> bool

Returns true if the dialect supports concatenating string literals with a newline. For example, the following statement would return true:

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

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

fn supports_pipe_operator(&self) -> bool

Return true if the dialect supports pipe operator.

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

Returns true if the dialect supports an exclude option following a wildcard in the projection section. For example: SELECT * EXCLUDE col1 FROM tbl.

fn supports_select_exclude(&self) -> bool

Returns true if the dialect supports an exclude option as the last item in the projection section, not necessarily after a wildcard. For example: SELECT *, c1, c2 EXCLUDE c3 FROM tbl

fn supports_create_table_multi_schema_info_sources(&self) -> bool

Returns true if the dialect supports specifying multiple options in a CREATE TABLE statement for the structure of the new table. For example: CREATE TABLE t (a INT, b INT) AS SELECT 1 AS b, 2 AS a

fn supports_select_modifiers(&self) -> bool

Returns true if the dialect supports MySQL-specific SELECT modifiers like HIGH_PRIORITY, STRAIGHT_JOIN, SQL_SMALL_RESULT, etc.

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

Dialect-specific infix parser 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_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 supports_extract_comma_syntax(&self) -> bool

Returns true if this dialect supports the EXTRACT function with a comma separator instead of FROM.

fn supports_subquery_as_function_arg(&self) -> bool

Returns true if this dialect supports a subquery passed to a function as the only argument without enclosing parentheses.

fn supports_create_view_comment_syntax(&self) -> bool

Returns true if this dialect supports the COMMENT clause in CREATE VIEW statements using the COMMENT = 'comment' syntax.

fn supports_data_type_collation(&self) -> bool

Returns true if a data type can carry a collation, including inside a nested type such as MAP<STRING COLLATE UTF8_BINARY, STRING>.

fn supports_array_typedef_without_element_type(&self) -> bool

Returns true if this dialect supports the ARRAY type without specifying an element type.

fn supports_array_typedef_with_parentheses(&self) -> bool

Returns true if this dialect supports the ARRAY(element_type) syntax.

fn supports_array_element_not_null(&self) -> bool

Returns true if this dialect supports NOT NULL on an element type in an ARRAY(element_type) definition.

fn supports_map_typedef_with_parentheses(&self) -> bool

Returns true if this dialect supports the MAP(key_type, value_type) syntax.

fn supports_map_value_not_null(&self) -> bool

Returns true if this dialect supports NOT NULL on the value type in a MAP(key_type, value_type) definition.

fn supports_parens_around_table_factor(&self) -> bool

Returns true if this dialect supports extra parentheses around lone table names or derived tables in the FROM clause.

fn supports_values_as_table_factor(&self) -> bool

Returns true if this dialect supports VALUES as a table factor without requiring parentheses around the entire clause.

fn supports_dollar_placeholder(&self) -> bool

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

fn supports_dollar_as_money_prefix(&self) -> bool

Returns true if this dialect supports $ as a prefix for money literals e.g. SELECT $123.45 (SQL Server)

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

Returns true if the dialect supports ASC and DESC in column definitions e.g. CREATE TABLE t (a INT ASC, b INT DESC);

fn supports_string_literal_column_names(&self) -> bool

Returns true if the dialect allows string literals as column names in CREATE TABLE. SQLite’s grammar rule nm ::= id | STRING | JOIN_KW permits this.

fn supports_multiline_comment_hints(&self) -> bool

Returns true if the dialect supports optimizer hints in multiline comments e.g. /*!50110 KEY_BLOCK_SIZE = 1024*/

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

Returns true if the dialect supports the LOAD DATA 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_create_table_select(&self) -> bool

Returns true if the dialect supports the CREATE TABLE SELECT statement

fn supports_create_proc_syntax(&self) -> bool

Returns true if this dialect supports PROC as an abbreviation for PROCEDURE in a CREATE statement.

fn supports_leading_comma_before_table_options(&self) -> bool

Returns true if the dialect accepts a comma-separated list of table-level options placed between the table name and the column-list parenthesis, e.g.

fn supports_partiql(&self) -> bool

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

fn supports_unpivot_expr(&self) -> bool

Returns true if the dialect supports object-unpivot table factors in the FROM clause.

fn supports_constraint_keyword_without_name(&self) -> bool

Returns true if the dialect supports the CONSTRAINT keyword without a name in table constraint definitions.

fn supports_key_column_option(&self) -> bool

Returns true if the dialect supports the KEY keyword as part of column-level constraints in a CREATE TABLE statement.

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 get_reserved_grantees_types(&self) -> &[GranteesType]

Returns grantee types that should be treated as identifiers

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

Does the dialect support table queries 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_table_factor(&self, kw: &Keyword, _parser: &mut Parser<'_>) -> bool

Returns true if the specified keyword should be parsed as a table factor identifier. See keywords::RESERVED_FOR_TABLE_FACTOR

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

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

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

Returns true if the dialect supports space-separated column options in a CREATE TABLE statement. For example:

fn supports_comma_separated_drop_column_list(&self) -> bool

Returns true if the dialect supports ALTER TABLE tbl DROP COLUMN c1, ..., cn

fn supports_alter_column_position(&self) -> bool

Returns true if the dialect supports a FIRST or AFTER col column position in ALTER TABLE ... ADD | CHANGE | MODIFY COLUMN. Example:

fn is_identifier_generating_function_name( &self, _ident: &Ident, _name_parts: &[ObjectNamePart], ) -> bool

Returns true if the dialect considers the specified ident as a function that returns an identifier. Typically used to generate identifiers programmatically.

fn supports_data_type_signed_suffix(&self) -> bool

Returns true if this dialect allows an optional SIGNED suffix after integer data types.

fn supports_semantic_view_table_factor(&self) -> bool

Returns true if the dialect supports SEMANTIC_VIEW() table functions.

fn supports_stages(&self) -> bool

Returns true if this dialect supports Snowflake-style stages in table factors (e.g. @stage).

fn supports_quote_delimited_string(&self) -> bool

Support quote delimited string literals, e.g. Q'{...}'

fn supports_double_ampersand_operator(&self) -> bool

Returns true if the dialect considers the && operator as a boolean AND operator.

fn supports_binary_kw_as_cast(&self) -> bool

Returns true if the dialect supports casting an expression to a binary type using the BINARY <expr> syntax.

fn supports_select_wildcard_replace(&self) -> bool

Returns true if this dialect supports the REPLACE option in a SELECT * wildcard expression.

fn supports_select_wildcard_ilike(&self) -> bool

Returns true if this dialect supports the ILIKE option in a SELECT * wildcard expression.

fn supports_select_wildcard_rename(&self) -> bool

Returns true if this dialect supports the RENAME option in a SELECT * wildcard expression.

fn supports_optimize_table(&self) -> bool

Returns true if this dialect supports the OPTIMIZE TABLE statement.

fn supports_install(&self) -> bool

Returns true if this dialect supports the INSTALL statement.

fn supports_detach(&self) -> bool

Returns true if this dialect supports the DETACH statement.

fn supports_prewhere(&self) -> bool

Returns true if this dialect supports the PREWHERE clause in SELECT statements.

fn supports_with_fill(&self) -> bool

Returns true if this dialect supports the WITH FILL clause in ORDER BY expressions.

fn supports_limit_by(&self) -> bool

Returns true if this dialect supports the LIMIT BY clause.

fn supports_interpolate(&self) -> bool

Returns true if this dialect supports the INTERPOLATE clause in ORDER BY expressions.

fn supports_settings(&self) -> bool

Returns true if this dialect supports the SETTINGS clause.

fn supports_table_partitions(&self) -> bool

Returns true if this dialect supports the PARTITION clause on a table factor, restricting a query to an explicit list of partitions.

fn supports_select_format(&self) -> bool

Returns true if this dialect supports the FORMAT clause in SELECT statements.

fn supports_cte_without_as(&self) -> bool

Returns true if the dialect supports the AS keyword being optional in a CTE definition. For example:

fn supports_select_item_multi_column_alias(&self) -> bool

Returns true if the dialect supports parenthesized multi-column aliases in SELECT items. For example:

fn supports_create_table_using(&self) -> bool

Returns true if the dialect supports USING <format> in CREATE TABLE.

fn supports_long_type_as_bigint(&self) -> bool

Returns true if the dialect treats LONG as an alias for BIGINT.

fn supports_map_literal_with_angle_brackets(&self) -> bool

Returns true if the dialect supports MAP<K, V> angle-bracket syntax for the MAP data type.

fn supports_double_eq_assignment(&self) -> bool

Returns true if the dialect accepts == as an alternative to = in UPDATE SET assignments.

fn supports_cast_empty_data_type_to_unspecified(&self) -> bool

Returns true if the dialect supports CAST(expr AS) with an empty type name.

impl Eq for PostgreSqlDialect

impl Hash for PostgreSqlDialect

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for PostgreSqlDialect

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl PartialEq for PostgreSqlDialect

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl PartialOrd for PostgreSqlDialect

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for PostgreSqlDialect

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for PostgreSqlDialect