Use collections.abc instead of deprecated typing for iterables objects

sqlglot/dialects/dialect.py

@@ -4,7 +4,7 @@
 import logging
 import typing as t
 import sys
-
+from collections.abc import Sequence
 from enum import Enum, auto
 from functools import reduce
 
@@ -1391,7 +1391,7 @@ def array_concat_sql(
         Dialects that propagate NULLs need to set `ARRAY_FUNCS_PROPAGATES_NULLS` to True.
     """
 
-    def _build_func_call(self: Generator, func_name: str, args: t.Sequence[exp.Expr]) -> str:
+    def _build_func_call(self: Generator, func_name: str, args: Sequence[exp.Expr]) -> str:
         """Build ARRAY_CONCAT call from a list of arguments, handling variadic vs binary nesting."""
         if self.ARRAY_CONCAT_IS_VAR_LEN:
             return self.func(func_name, *args)

sqlglot/dialects/duckdb.py

@@ -45,6 +45,7 @@
 from sqlglot.parsers.duckdb import DuckDBParser
 from sqlglot.tokens import TokenType
 from sqlglot.typing.duckdb import EXPRESSION_METADATA
+from builtins import type as Type
 
 # Regex to detect time zones in timestamps of the form [+|-]TT[:tt]
 # The pattern matches timezone offsets that appear after the time portion
@@ -1201,7 +1202,7 @@ def _bitshift_sql(
 def _scale_rounding_sql(
     self: DuckDB.Generator,
     expression: exp.Expr,
-    rounding_func: type[exp.Expr],
+    rounding_func: Type[exp.Expr],
 ) -> str | None:
     """
     Handle scale parameter transformation for rounding functions.

sqlglot/diff.py

@@ -16,6 +16,7 @@
 from sqlglot.helper import seq_get
 
 if t.TYPE_CHECKING:
+    from collections.abc import Iterator, Sequence
     from sqlglot.dialects.dialect import DialectType
 
 
@@ -369,7 +370,7 @@ def _bigram_histo(self, expression: exp.Expr) -> t.DefaultDict[str, int]:
         return bigram_histo
 
 
-def _get_expression_leaves(expression: exp.Expr) -> t.Iterator[exp.Expr]:
+def _get_expression_leaves(expression: exp.Expr) -> Iterator[exp.Expr]:
     has_child_exprs = False
 
     for node in expression.iter_expressions():
@@ -381,7 +382,7 @@ def _get_expression_leaves(expression: exp.Expr) -> t.Iterator[exp.Expr]:
         yield expression
 
 
-def _get_non_expression_leaves(expression: exp.Expr) -> t.Iterator[t.Tuple[str, t.Any]]:
+def _get_non_expression_leaves(expression: exp.Expr) -> Iterator[tuple[str, t.Any]]:
     for arg, value in expression.args.items():
         if (
             value is None
@@ -413,7 +414,7 @@ def _parent_similarity_score(source: t.Optional[exp.Expr], target: t.Optional[ex
     return 1 + _parent_similarity_score(source.parent, target.parent)
 
 
-def _expression_only_args(expression: exp.Expr) -> t.Iterator[exp.Expr]:
+def _expression_only_args(expression: exp.Expr) -> Iterator[exp.Expr]:
     yield from (
         arg
         for arg in expression.iter_expressions()
@@ -422,8 +423,8 @@ def _expression_only_args(expression: exp.Expr) -> t.Iterator[exp.Expr]:
 
 
 def _lcs(
-    seq_a: t.Sequence[T], seq_b: t.Sequence[T], equal: t.Callable[[T, T], bool]
-) -> t.Sequence[t.Optional[T]]:
+    seq_a: Sequence[T], seq_b: Sequence[T], equal: t.Callable[[T, T], bool]
+) -> Sequence[t.Optional[T]]:
     """Calculates the longest common subsequence"""
 
     len_a = len(seq_a)

sqlglot/errors.py

@@ -2,7 +2,7 @@
 
 import typing as t
 from enum import auto
-
+from collections.abc import Sequence
 from sqlglot.helper import AutoName
 
 
@@ -150,13 +150,13 @@ def highlight_sql(
     return formatted_sql, start_context, highlight, end_context
 
 
-def concat_messages(errors: t.Sequence[t.Any], maximum: int) -> str:
+def concat_messages(errors: Sequence[t.Any], maximum: int) -> str:
     msg = [str(e) for e in errors[:maximum]]
     remaining = len(errors) - maximum
     if remaining > 0:
         msg.append(f"... and {remaining} more")
     return "\n\n".join(msg)
 
 
-def merge_errors(errors: t.Sequence[ParseError]) -> t.List[t.Dict[str, t.Any]]:
+def merge_errors(errors: Sequence[ParseError]) -> list[dict[str, t.Any]]:
     return [e_dict for error in errors for e_dict in error.errors]

sqlglot/expressions/builders.py

@@ -50,6 +50,7 @@
 from sqlglot.expressions.array import Array
 
 if t.TYPE_CHECKING:
+    from collections.abc import Sequence, Iterable
     from sqlglot.dialects.dialect import DialectType
     from sqlglot.expressions.core import ExpOrStr, Func
     from sqlglot.expressions.datatypes import DATA_TYPE
@@ -195,7 +196,7 @@ def delete(
 def insert(
     expression: ExpOrStr,
     into: ExpOrStr,
-    columns: t.Optional[t.Sequence[str | Identifier]] = None,
+    columns: t.Optional[Sequence[str | Identifier]] = None,
     overwrite: t.Optional[bool] = None,
     returning: t.Optional[ExpOrStr] = None,
     dialect: DialectType = None,
@@ -512,9 +513,9 @@ def table_(
 
 
 def values(
-    values: t.Iterable[t.Tuple[object, ...] | Tuple],
+    values: Iterable[tuple[object, ...] | Tuple],
     alias: t.Optional[str] = None,
-    columns: t.Optional[t.Iterable[str] | t.Dict[str, DataType]] = None,
+    columns: t.Optional[Iterable[str] | dict[str, DataType]] = None,
 ) -> Values:
     """Build VALUES statement.