sqlglot 27.29.0__py3-none-any.whl → 28.4.0__py3-none-any.whl

sqlglot/dialects/exasol.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import typing as t
 
-from sqlglot import exp, generator, parser, tokens
+from sqlglot import exp, generator, parser, tokens, transforms
 from sqlglot.dialects.dialect import (
     Dialect,
     NormalizationStrategy,
@@ -12,13 +12,15 @@ from sqlglot.dialects.dialect import (
     rename_func,
     strposition_sql,
     timestrtotime_sql,
-    unit_to_str,
     timestamptrunc_sql,
     build_date_delta,
+    no_last_day_sql,
+    DATE_ADD_OR_SUB,
 )
 from sqlglot.generator import unsupported_args
 from sqlglot.helper import seq_get
 from sqlglot.tokens import TokenType
+from sqlglot.optimizer.scope import build_scope
 
 if t.TYPE_CHECKING:
     from sqlglot.dialects.dialect import DialectType
@@ -71,6 +73,200 @@ def _build_nullifzero(args: t.List) -> exp.If:
     return exp.If(this=cond, true=exp.Null(), false=seq_get(args, 0))
 
 
+# https://docs.exasol.com/db/latest/sql/select.htm#:~:text=If%20you%20have,local.x%3E10
+def _add_local_prefix_for_aliases(expression: exp.Expression) -> exp.Expression:
+    if isinstance(expression, exp.Select):
+        aliases: dict[str, bool] = {
+            alias.name: bool(alias.args.get("quoted"))
+            for sel in expression.selects
+            if isinstance(sel, exp.Alias) and (alias := sel.args.get("alias"))
+        }
+
+        table = expression.find(exp.Table)
+        table_ident = table.this if table else None
+
+        if (
+            table_ident
+            and table_ident.name.upper() == "LOCAL"
+            and not bool(table_ident.args.get("quoted"))
+        ):
+            table_ident.replace(exp.to_identifier(table_ident.name.upper(), quoted=True))
+
+        def prefix_local(node, visible_aliases: dict[str, bool]) -> exp.Expression:
+            if isinstance(node, exp.Column) and not node.table:
+                if node.name in visible_aliases:
+                    return exp.Column(
+                        this=exp.to_identifier(node.name, quoted=visible_aliases[node.name]),
+                        table=exp.to_identifier("LOCAL", quoted=False),
+                    )
+            return node
+
+        for key in ("where", "group", "having"):
+            if arg := expression.args.get(key):
+                expression.set(key, arg.transform(lambda node: prefix_local(node, aliases)))
+
+        seen_aliases: dict[str, bool] = {}
+        new_selects: list[exp.Expression] = []
+        for sel in expression.selects:
+            if isinstance(sel, exp.Alias):
+                inner = sel.this.transform(lambda node: prefix_local(node, seen_aliases))
+                sel.set("this", inner)
+
+                alias_node = sel.args.get("alias")
+
+                seen_aliases[sel.alias] = bool(alias_node and getattr(alias_node, "quoted", False))
+                new_selects.append(sel)
+            else:
+                new_selects.append(sel.transform(lambda node: prefix_local(node, seen_aliases)))
+        expression.set("expressions", new_selects)
+
+    return expression
+
+
+def _trunc_sql(self: Exasol.Generator, kind: str, expression: exp.DateTrunc) -> str:
+    unit = expression.text("unit")
+    node = expression.this.this if isinstance(expression.this, exp.Cast) else expression.this
+    expr_sql = self.sql(node)
+    if isinstance(node, exp.Literal) and node.is_string:
+        expr_sql = (
+            f"{kind} '{node.this.replace('T', ' ')}'"
+            if kind == "TIMESTAMP"
+            else f"DATE '{node.this}'"
+        )
+    return f"DATE_TRUNC('{unit}', {expr_sql})"
+
+
+def _date_trunc_sql(self: Exasol.Generator, expression: exp.DateTrunc) -> str:
+    return _trunc_sql(self, "DATE", expression)
+
+
+def _timestamp_trunc_sql(self: Exasol.Generator, expression: exp.DateTrunc) -> str:
+    return _trunc_sql(self, "TIMESTAMP", expression)
+
+
+def is_case_insensitive(node: exp.Expression) -> bool:
+    return isinstance(node, exp.Collate) and node.text("expression").upper() == "UTF8_LCASE"
+
+
+def _substring_index_sql(self: Exasol.Generator, expression: exp.SubstringIndex) -> str:
+    this = expression.this
+    delimiter = expression.args["delimiter"]
+    count_node = expression.args["count"]
+    count_sql = self.sql(expression, "count")
+    num = count_node.to_py() if count_node.is_number else 0
+
+    haystack_sql = self.sql(this)
+    if num == 0:
+        return self.func("SUBSTR", haystack_sql, "1", "0")
+
+    from_right = num < 0
+    direction = "-1" if from_right else "1"
+    occur = self.func("ABS", count_sql) if from_right else count_sql
+
+    delimiter_sql = self.sql(delimiter)
+
+    position = self.func(
+        "INSTR",
+        self.func("LOWER", haystack_sql) if is_case_insensitive(this) else haystack_sql,
+        self.func("LOWER", delimiter_sql) if is_case_insensitive(delimiter) else delimiter_sql,
+        direction,
+        occur,
+    )
+    nullable_pos = self.func("NULLIF", position, "0")
+
+    if from_right:
+        start = self.func(
+            "NVL", f"{nullable_pos} + {self.func('LENGTH', delimiter_sql)}", direction
+        )
+        return self.func("SUBSTR", haystack_sql, start)
+
+    length = self.func("NVL", f"{nullable_pos} - 1", self.func("LENGTH", haystack_sql))
+    return self.func("SUBSTR", haystack_sql, direction, length)
+
+
+# https://docs.exasol.com/db/latest/sql/select.htm#:~:text=The%20select_list%20defines%20the%20columns%20of%20the%20result%20table.%20If%20*%20is%20used%2C%20all%20columns%20are%20listed.%20You%20can%20use%20an%20expression%20like%20t.*%20to%20list%20all%20columns%20of%20the%20table%20t%2C%20the%20view%20t%2C%20or%20the%20object%20with%20the%20table%20alias%20t.
+def _qualify_unscoped_star(expression: exp.Expression) -> exp.Expression:
+    """
+    Exasol doesn't support a bare * alongside other select items, so we rewrite it
+    Rewrite: SELECT *, <other> FROM <Table>
+    Into: SELECT T.*, <other> FROM <Table> AS T
+    """
+
+    if not isinstance(expression, exp.Select):
+        return expression
+
+    select_expressions = expression.expressions or []
+
+    def is_bare_star(expr: exp.Expression) -> bool:
+        return isinstance(expr, exp.Star) and expr.this is None
+
+    has_other_expression = False
+    bare_star_expr: exp.Expression | None = None
+    for expr in select_expressions:
+        has_bare_star = is_bare_star(expr)
+        if has_bare_star and bare_star_expr is None:
+            bare_star_expr = expr
+        elif not has_bare_star:
+            has_other_expression = True
+        if bare_star_expr and has_other_expression:
+            break
+
+    if not (bare_star_expr and has_other_expression):
+        return expression
+
+    scope = build_scope(expression)
+
+    if not scope or not scope.selected_sources:
+        return expression
+
+    table_identifiers: list[exp.Identifier] = []
+
+    for source_name, (source_expr, _) in scope.selected_sources.items():
+        ident = (
+            source_expr.this.copy()
+            if isinstance(source_expr, exp.Table) and isinstance(source_expr.this, exp.Identifier)
+            else exp.to_identifier(source_name)
+        )
+        table_identifiers.append(ident)
+
+    qualified_star_columns = [
+        exp.Column(this=bare_star_expr.copy(), table=ident) for ident in table_identifiers
+    ]
+
+    new_select_expressions: list[exp.Expression] = []
+
+    for select_expr in select_expressions:
+        new_select_expressions.extend(qualified_star_columns) if is_bare_star(
+            select_expr
+        ) else new_select_expressions.append(select_expr)
+
+    expression.set("expressions", new_select_expressions)
+    return expression
+
+
+def _add_date_sql(self: Exasol.Generator, expression: DATE_ADD_OR_SUB) -> str:
+    interval = expression.expression if isinstance(expression.expression, exp.Interval) else None
+
+    unit = (
+        (interval.text("unit") or "DAY").upper()
+        if interval is not None
+        else (expression.text("unit") or "DAY").upper()
+    )
+
+    if unit not in DATE_UNITS:
+        self.unsupported(f"'{unit}' is not supported in Exasol.")
+        return self.function_fallback_sql(expression)
+
+    offset_expr: exp.Expression = expression.expression
+    if interval is not None:
+        offset_expr = interval.this
+
+    if isinstance(expression, exp.DateSub):
+        offset_expr = exp.Neg(this=offset_expr)
+
+    return self.func(f"ADD_{unit}S", expression.this, offset_expr)
+
+
 DATE_UNITS = {"DAY", "WEEK", "MONTH", "YEAR", "HOUR", "MINUTE", "SECOND"}
 
 
@@ -115,6 +311,7 @@ class Exasol(Dialect):
     }
 
     class Tokenizer(tokens.Tokenizer):
+        IDENTIFIERS = ['"', ("[", "]")]
         KEYWORDS = {
             **tokens.Tokenizer.KEYWORDS,
             "USER": TokenType.CURRENT_USER,
@@ -197,6 +394,24 @@ class Exasol(Dialect):
             **dict.fromkeys(("GROUP_CONCAT", "LISTAGG"), lambda self: self._parse_group_concat()),
         }
 
+        def _parse_column(self) -> t.Optional[exp.Expression]:
+            column = super()._parse_column()
+            if not isinstance(column, exp.Column):
+                return column
+            table_ident = column.args.get("table")
+            if (
+                isinstance(table_ident, exp.Identifier)
+                and table_ident.name.upper() == "LOCAL"
+                and not bool(table_ident.args.get("quoted"))
+            ):
+                column.set("table", None)
+            return column
+
+        ODBC_DATETIME_LITERALS = {
+            "d": exp.Date,
+            "ts": exp.Timestamp,
+        }
+
     class Generator(generator.Generator):
         # https://docs.exasol.com/db/latest/sql_references/data_types/datatypedetails.htm#StringDataType
         STRING_TYPE_MAPPING = {
@@ -250,10 +465,14 @@ class Exasol(Dialect):
             # https://docs.exasol.com/db/latest/sql_references/functions/alphabeticallistfunctions/bit_xor.htm
             exp.BitwiseXor: rename_func("BIT_XOR"),
             exp.DateDiff: _date_diff_sql,
+            exp.DateAdd: _add_date_sql,
+            exp.TsOrDsAdd: _add_date_sql,
+            exp.DateSub: _add_date_sql,
             # https://docs.exasol.com/db/latest/sql_references/functions/alphabeticallistfunctions/div.htm#DIV
             exp.IntDiv: rename_func("DIV"),
             exp.TsOrDsDiff: _date_diff_sql,
-            exp.DateTrunc: lambda self, e: self.func("TRUNC", e.this, unit_to_str(e)),
+            exp.DateTrunc: _date_trunc_sql,
+            exp.DayOfWeek: lambda self, e: f"CAST(TO_CHAR({self.sql(e, 'this')}, 'D') AS INTEGER)",
             exp.DatetimeTrunc: timestamptrunc_sql(),
             exp.GroupConcat: lambda self, e: groupconcat_sql(
                 self, e, func_name="LISTAGG", within_group=True
@@ -282,7 +501,7 @@ class Exasol(Dialect):
             exp.TsOrDsToDate: lambda self, e: self.func("TO_DATE", e.this, self.format_time(e)),
             exp.TimeToStr: lambda self, e: self.func("TO_CHAR", e.this, self.format_time(e)),
             exp.TimeStrToTime: timestrtotime_sql,
-            exp.TimestampTrunc: timestamptrunc_sql(),
+            exp.TimestampTrunc: _timestamp_trunc_sql,
             exp.StrToTime: lambda self, e: self.func("TO_DATE", e.this, self.format_time(e)),
             exp.CurrentUser: lambda *_: "CURRENT_USER",
             exp.AtTimeZone: lambda self, e: self.func(
@@ -307,7 +526,20 @@ class Exasol(Dialect):
             exp.MD5Digest: rename_func("HASHTYPE_MD5"),
             # https://docs.exasol.com/db/latest/sql/create_view.htm
             exp.CommentColumnConstraint: lambda self, e: f"COMMENT IS {self.sql(e, 'this')}",
+            exp.Select: transforms.preprocess(
+                [
+                    _qualify_unscoped_star,
+                    _add_local_prefix_for_aliases,
+                ]
+            ),
+            exp.SubstringIndex: _substring_index_sql,
             exp.WeekOfYear: rename_func("WEEK"),
+            # https://docs.exasol.com/db/latest/sql_references/functions/alphabeticallistfunctions/to_date.htm
+            exp.Date: rename_func("TO_DATE"),
+            # https://docs.exasol.com/db/latest/sql_references/functions/alphabeticallistfunctions/to_timestamp.htm
+            exp.Timestamp: rename_func("TO_TIMESTAMP"),
+            exp.Quarter: lambda self, e: f"CEIL(MONTH(TO_DATE({self.sql(e, 'this')}))/3)",
+            exp.LastDay: no_last_day_sql,
         }
 
         def converttimezone_sql(self, expression: exp.ConvertTimezone) -> str:
@@ -324,10 +556,11 @@ class Exasol(Dialect):
             false = self.sql(expression, "false")
             return f"IF {this} THEN {true} ELSE {false} ENDIF"
 
-        def dateadd_sql(self, expression: exp.DateAdd) -> str:
-            unit = expression.text("unit").upper() or "DAY"
-            if unit not in DATE_UNITS:
-                self.unsupported(f"'{unit}' is not supported in Exasol.")
-                return self.function_fallback_sql(expression)
+        def collate_sql(self, expression: exp.Collate) -> str:
+            return self.sql(expression.this)
 
-            return self.func(f"ADD_{unit}S", expression.this, expression.expression)
+        # https://docs.exasol.com/db/latest/sql_references/functions/alphabeticallistfunctions/rank.htm
+        def rank_sql(self, expression: exp.Rank) -> str:
+            if expression.args.get("expressions"):
+                self.unsupported("Exasol does not support arguments in RANK")
+            return self.func("RANK")

sqlglot/dialects/hive.py

@@ -46,6 +46,7 @@ from sqlglot.helper import seq_get
 from sqlglot.tokens import TokenType
 from sqlglot.generator import unsupported_args
 from sqlglot.optimizer.annotate_types import TypeAnnotator
+from sqlglot.typing.hive import EXPRESSION_METADATA
 
 # (FuncType, Multiplier)
 DATE_DELTA_INTERVAL = {
@@ -216,13 +217,11 @@ class Hive(Dialect):
     # https://spark.apache.org/docs/latest/sql-ref-identifier.html#description
     NORMALIZATION_STRATEGY = NormalizationStrategy.CASE_INSENSITIVE
 
-    ANNOTATORS = {
-        **Dialect.ANNOTATORS,
-        exp.If: lambda self, e: self._annotate_by_args(e, "true", "false", promote=True),
-        exp.Coalesce: lambda self, e: self._annotate_by_args(
-            e, "this", "expressions", promote=True
-        ),
-    }
+    EXPRESSION_METADATA = EXPRESSION_METADATA.copy()
+
+    # https://cwiki.apache.org/confluence/pages/viewpage.action?pageId=27362046#LanguageManualUDF-StringFunctions
+    # https://github.com/apache/hive/blob/master/ql/src/java/org/apache/hadoop/hive/ql/exec/Utilities.java#L266-L269
+    INITCAP_DEFAULT_DELIMITER_CHARS = " \t\n\r\f\u000b\u001c\u001d\u001e\u001f"
 
     # Support only the non-ANSI mode (default for Hive, Spark2, Spark)
     COERCES_TO = defaultdict(set, deepcopy(TypeAnnotator.COERCES_TO))
@@ -576,6 +575,7 @@ class Hive(Dialect):
             exp.ApproxDistinct: approx_count_distinct_sql,
             exp.ArgMax: arg_max_or_min_no_count("MAX_BY"),
             exp.ArgMin: arg_max_or_min_no_count("MIN_BY"),
+            exp.Array: transforms.preprocess([transforms.inherit_struct_field_names]),
             exp.ArrayConcat: rename_func("CONCAT"),
             exp.ArrayToString: lambda self, e: self.func("CONCAT_WS", e.expression, e.this),
             exp.ArraySort: _array_sort_sql,
@@ -838,7 +838,7 @@ class Hive(Dialect):
             return f"SET{serde}{exprs}{location}{file_format}{tags}"
 
         def serdeproperties_sql(self, expression: exp.SerdeProperties) -> str:
-            prefix = "WITH " if expression.args.get("with") else ""
+            prefix = "WITH " if expression.args.get("with_") else ""
             exprs = self.expressions(expression, flat=True)
 
             return f"{prefix}SERDEPROPERTIES ({exprs})"

sqlglot/dialects/mysql.py

@@ -202,6 +202,8 @@ class MySQL(Dialect):
         STRING_ESCAPES = ["'", '"', "\\"]
         BIT_STRINGS = [("b'", "'"), ("B'", "'"), ("0b", "")]
         HEX_STRINGS = [("x'", "'"), ("X'", "'"), ("0x", "")]
+        # https://dev.mysql.com/doc/refman/8.4/en/string-literals.html
+        ESCAPE_FOLLOW_CHARS = ["0", "b", "n", "r", "t", "Z", "%", "_"]
 
         NESTED_COMMENTS = False
 
@@ -464,6 +466,7 @@ class MySQL(Dialect):
             "INDEX": lambda self: self._parse_index_constraint(),
             "KEY": lambda self: self._parse_index_constraint(),
             "SPATIAL": lambda self: self._parse_index_constraint(kind="SPATIAL"),
+            "ZEROFILL": lambda self: self.expression(exp.ZeroFillColumnConstraint),
         }
 
         ALTER_PARSERS = {
@@ -671,7 +674,7 @@ class MySQL(Dialect):
                 for_role=for_role,
                 into_outfile=into_outfile,
                 json=json,
-                **{"global": global_},  # type: ignore
+                global_=global_,
             )
 
         def _parse_oldstyle_limit(
@@ -798,6 +801,7 @@ class MySQL(Dialect):
             exp.StrToDate: _str_to_date_sql,
             exp.StrToTime: _str_to_date_sql,
             exp.Stuff: rename_func("INSERT"),
+            exp.SessionUser: lambda *_: "SESSION_USER()",
             exp.TableSample: no_tablesample_sql,
             exp.TimeFromParts: rename_func("MAKETIME"),
             exp.TimestampAdd: date_add_interval_sql("DATE", "ADD"),
@@ -1229,7 +1233,7 @@ class MySQL(Dialect):
         def show_sql(self, expression: exp.Show) -> str:
             this = f" {expression.name}"
             full = " FULL" if expression.args.get("full") else ""
-            global_ = " GLOBAL" if expression.args.get("global") else ""
+            global_ = " GLOBAL" if expression.args.get("global_") else ""
 
             target = self.sql(expression, "target")
             target = f" {target}" if target else ""
@@ -1330,6 +1334,11 @@ class MySQL(Dialect):
         def isascii_sql(self, expression: exp.IsAscii) -> str:
             return f"REGEXP_LIKE({self.sql(expression.this)}, '^[[:ascii:]]*$')"
 
+        def ignorenulls_sql(self, expression: exp.IgnoreNulls) -> str:
+            # https://dev.mysql.com/doc/refman/8.4/en/window-function-descriptions.html
+            self.unsupported("MySQL does not support IGNORE NULLS.")
+            return self.sql(expression.this)
+
         @unsupported_args("this")
         def currentschema_sql(self, expression: exp.CurrentSchema) -> str:
             return self.func("SCHEMA")

sqlglot/dialects/oracle.py

@@ -45,6 +45,7 @@ class Oracle(Dialect):
     NULL_ORDERING = "nulls_are_large"
     ON_CONDITION_EMPTY_BEFORE_ERROR = False
     ALTER_TABLE_ADD_REQUIRED_FOR_EACH_COLUMN = False
+    DISABLES_ALIAS_REF_EXPANSION = True
 
     # See section 8: https://docs.oracle.com/cd/A97630_01/server.920/a96540/sql_elements9a.htm
     NORMALIZATION_STRATEGY = NormalizationStrategy.UPPERCASE
@@ -72,6 +73,15 @@ class Oracle(Dialect):
         "FF6": "%f",  # only 6 digits are supported in python formats
     }
 
+    PSEUDOCOLUMNS = {"ROWNUM", "ROWID", "OBJECT_ID", "OBJECT_VALUE", "LEVEL"}
+
+    def can_quote(self, identifier: exp.Identifier, identify: str | bool = "safe") -> bool:
+        # Disable quoting for pseudocolumns as it may break queries e.g
+        # `WHERE "ROWNUM" = ...` does not work but `WHERE ROWNUM = ...` does
+        return (
+            identifier.quoted or not isinstance(identifier.parent, exp.Pseudocolumn)
+        ) and super().can_quote(identifier, identify=identify)
+
     class Tokenizer(tokens.Tokenizer):
         VAR_SINGLE_TOKENS = {"@", "$", "#"}
 
@@ -119,6 +129,7 @@ class Oracle(Dialect):
                 unabbreviate=False,
             ),
         }
+        FUNCTIONS.pop("TO_BOOLEAN")
 
         NO_PAREN_FUNCTION_PARSERS = {
             **parser.Parser.NO_PAREN_FUNCTION_PARSERS,
@@ -264,6 +275,24 @@ class Oracle(Dialect):
         def _parse_connect_with_prior(self):
             return self._parse_assignment()
 
+        def _parse_insert_table(self) -> t.Optional[exp.Expression]:
+            # Oracle does not use AS for INSERT INTO alias
+            # https://docs.oracle.com/en/database/oracle/oracle-database/18/sqlrf/INSERT.html
+            # Parse table parts without schema to avoid parsing the alias with its columns
+            this = self._parse_table_parts(schema=True)
+
+            if isinstance(this, exp.Table):
+                alias_name = self._parse_id_var(any_token=False)
+                if alias_name:
+                    this.set("alias", exp.TableAlias(this=alias_name))
+
+                this.set("partition", self._parse_partition())
+
+                # Now parse the schema (column list) if present
+                return self._parse_schema(this=this)
+
+            return this
+
     class Generator(generator.Generator):
         LOCKING_READS_SUPPORTED = True
         JOIN_HINTS = False

sqlglot/dialects/postgres.py

@@ -36,8 +36,8 @@ from sqlglot.dialects.dialect import (
     strposition_sql,
     count_if_to_sum,
     groupconcat_sql,
-    Version,
     regexp_replace_global_modifier,
+    sha2_digest_sql,
 )
 from sqlglot.generator import unsupported_args
 from sqlglot.helper import is_int, seq_get
@@ -262,12 +262,35 @@ def _levenshtein_sql(self: Postgres.Generator, expression: exp.Levenshtein) -> s
 def _versioned_anyvalue_sql(self: Postgres.Generator, expression: exp.AnyValue) -> str:
     # https://www.postgresql.org/docs/16/functions-aggregate.html
     # https://www.postgresql.org/about/featurematrix/
-    if self.dialect.version < Version("16.0"):
+    if self.dialect.version < (16,):
         return any_value_to_max_sql(self, expression)
 
     return rename_func("ANY_VALUE")(self, expression)
 
 
+def _round_sql(self: Postgres.Generator, expression: exp.Round) -> str:
+    this = self.sql(expression, "this")
+    decimals = self.sql(expression, "decimals")
+
+    if not decimals:
+        return self.func("ROUND", this)
+
+    if not expression.type:
+        from sqlglot.optimizer.annotate_types import annotate_types
+
+        expression = annotate_types(expression, dialect=self.dialect)
+
+    # ROUND(double precision, integer) is not permitted in Postgres
+    # so it's necessary to cast to decimal before rounding.
+    if expression.this.is_type(exp.DataType.Type.DOUBLE):
+        decimal_type = exp.DataType.build(
+            exp.DataType.Type.DECIMAL, expressions=expression.expressions
+        )
+        this = self.sql(exp.Cast(this=this, to=decimal_type))
+
+    return self.func("ROUND", this, decimals)
+
+
 class Postgres(Dialect):
     INDEX_OFFSET = 1
     TYPED_DIVISION = True
@@ -275,6 +298,11 @@ class Postgres(Dialect):
     NULL_ORDERING = "nulls_are_large"
     TIME_FORMAT = "'YYYY-MM-DD HH24:MI:SS'"
     TABLESAMPLE_SIZE_IS_PERCENT = True
+    TABLES_REFERENCEABLE_AS_COLUMNS = True
+
+    DEFAULT_FUNCTIONS_COLUMN_NAMES = {
+        exp.ExplodingGenerateSeries: "generate_series",
+    }
 
     TIME_MAPPING = {
         "d": "%u",  # 1-based day of week
@@ -330,6 +358,8 @@ class Postgres(Dialect):
             "<@": TokenType.LT_AT,
             "?&": TokenType.QMARK_AMP,
             "?|": TokenType.QMARK_PIPE,
+            "&<": TokenType.AMP_LT,
+            "&>": TokenType.AMP_GT,
             "#-": TokenType.HASH_DASH,
             "|/": TokenType.PIPE_SLASH,
             "||/": TokenType.DPIPE_SLASH,
@@ -449,6 +479,8 @@ class Postgres(Dialect):
         RANGE_PARSERS = {
             **parser.Parser.RANGE_PARSERS,
             TokenType.DAMP: binary_range_parser(exp.ArrayOverlaps),
+            TokenType.AMP_LT: binary_range_parser(exp.ExtendsLeft),
+            TokenType.AMP_GT: binary_range_parser(exp.ExtendsRight),
             TokenType.DAT: lambda self, this: self.expression(
                 exp.MatchAgainst, this=self._parse_bitwise(), expressions=[this]
             ),
@@ -663,6 +695,7 @@ class Postgres(Dialect):
                 e.args.get("occurrence"),
                 regexp_replace_global_modifier(e),
             ),
+            exp.Round: _round_sql,
             exp.Select: transforms.preprocess(
                 [
                     transforms.eliminate_semi_and_anti_joins,
@@ -670,6 +703,7 @@ class Postgres(Dialect):
                 ]
             ),
             exp.SHA2: sha256_sql,
+            exp.SHA2Digest: sha2_digest_sql,
             exp.StrPosition: lambda self, e: strposition_sql(self, e, func_name="POSITION"),
             exp.StrToDate: lambda self, e: self.func("TO_DATE", e.this, self.format_time(e)),
             exp.StrToTime: lambda self, e: self.func("TO_TIMESTAMP", e.this, self.format_time(e)),
@@ -710,28 +744,6 @@ class Postgres(Dialect):
             exp.VolatileProperty: exp.Properties.Location.UNSUPPORTED,
         }
 
-        def round_sql(self, expression: exp.Round) -> str:
-            this = self.sql(expression, "this")
-            decimals = self.sql(expression, "decimals")
-
-            if not decimals:
-                return self.func("ROUND", this)
-
-            if not expression.type:
-                from sqlglot.optimizer.annotate_types import annotate_types
-
-                expression = annotate_types(expression, dialect=self.dialect)
-
-            # ROUND(double precision, integer) is not permitted in Postgres
-            # so it's necessary to cast to decimal before rounding.
-            if expression.this.is_type(exp.DataType.Type.DOUBLE):
-                decimal_type = exp.DataType.build(
-                    exp.DataType.Type.DECIMAL, expressions=expression.expressions
-                )
-                this = self.sql(exp.Cast(this=this, to=decimal_type))
-
-            return self.func("ROUND", this, decimals)
-
         def schemacommentproperty_sql(self, expression: exp.SchemaCommentProperty) -> str:
             self.unsupported("Table comments are not supported in the CREATE statement")
             return ""
@@ -836,6 +848,16 @@ class Postgres(Dialect):
         def isascii_sql(self, expression: exp.IsAscii) -> str:
             return f"({self.sql(expression.this)} ~ '^[[:ascii:]]*$')"
 
+        def ignorenulls_sql(self, expression: exp.IgnoreNulls) -> str:
+            # https://www.postgresql.org/docs/current/functions-window.html
+            self.unsupported("PostgreSQL does not support IGNORE NULLS.")
+            return self.sql(expression.this)
+
+        def respectnulls_sql(self, expression: exp.RespectNulls) -> str:
+            # https://www.postgresql.org/docs/current/functions-window.html
+            self.unsupported("PostgreSQL does not support RESPECT NULLS.")
+            return self.sql(expression.this)
+
         @unsupported_args("this")
         def currentschema_sql(self, expression: exp.CurrentSchema) -> str:
             return "CURRENT_SCHEMA"