apache-airflow-providers-postgres 6.2.3rc1__py3-none-any.whl → 6.3.0rc1__py3-none-any.whl

airflow/providers/postgres/__init__.py

@@ -29,7 +29,7 @@ from airflow import __version__ as airflow_version
 
 __all__ = ["__version__"]
 
-__version__ = "6.2.3"
+__version__ = "6.3.0"
 
 if packaging.version.parse(packaging.version.parse(airflow_version).base_version) < packaging.version.parse(
     "2.10.0"

airflow/providers/postgres/dialects/postgres.py

@@ -16,9 +16,11 @@
 # under the License.
 from __future__ import annotations
 
+from collections.abc import Callable
+
 from methodtools import lru_cache
 
-from airflow.providers.common.sql.dialects.dialect import Dialect
+from airflow.providers.common.sql.dialects.dialect import Dialect, T
 
 
 class PostgresDialect(Dialect):
@@ -39,22 +41,71 @@ class PostgresDialect(Dialect):
         """
         if schema is None:
             table, schema = self.extract_schema_from_table(table)
-        sql = """
-            select kcu.column_name
-            from information_schema.table_constraints tco
-                    join information_schema.key_column_usage kcu
-                        on kcu.constraint_name = tco.constraint_name
-                            and kcu.constraint_schema = tco.constraint_schema
-                            and kcu.constraint_name = tco.constraint_name
-            where tco.constraint_type = 'PRIMARY KEY'
-            and kcu.table_schema = %s
-            and kcu.table_name = %s
-        """
         pk_columns = [
-            row[0] for row in self.get_records(sql, (self.unescape_word(schema), self.unescape_word(table)))
+            row[0]
+            for row in self.get_records(
+                """
+                  select kcu.column_name
+                  from information_schema.table_constraints tco
+                           join information_schema.key_column_usage kcu
+                                on kcu.constraint_name = tco.constraint_name
+                                    and kcu.constraint_schema = tco.constraint_schema
+                                    and kcu.constraint_name = tco.constraint_name
+                  where tco.constraint_type = 'PRIMARY KEY'
+                    and kcu.table_schema = %s
+                    and kcu.table_name = %s
+                  order by kcu.ordinal_position
+                  """,
+                (self.unescape_word(schema), self.unescape_word(table)),
+            )
         ]
         return pk_columns or None
 
+    @staticmethod
+    def _to_row(row):
+        return {
+            "name": row[0],
+            "type": row[1],
+            "nullable": row[2].casefold() == "yes",
+            "default": row[3],
+            "autoincrement": row[4].casefold() == "always",
+            "identity": row[5].casefold() == "yes",
+        }
+
+    @lru_cache(maxsize=None)
+    def get_column_names(
+        self, table: str, schema: str | None = None, predicate: Callable[[T], bool] = lambda column: True
+    ) -> list[str] | None:
+        if schema is None:
+            table, schema = self.extract_schema_from_table(table)
+
+        column_names = list(
+            row["name"]
+            for row in filter(
+                predicate,
+                map(
+                    self._to_row,
+                    self.get_records(
+                        """
+                        select column_name,
+                               data_type,
+                               is_nullable,
+                               column_default,
+                               is_generated,
+                               is_identity
+                        from information_schema.columns
+                        where table_schema = %s
+                          and table_name = %s
+                        order by ordinal_position
+                        """,
+                        (self.unescape_word(schema), self.unescape_word(table)),
+                    ),
+                ),
+            )
+        )
+        self.log.debug("Column names for table '%s': %s", table, column_names)
+        return column_names
+
     def generate_replace_sql(self, table, values, target_fields, **kwargs) -> str:
         """
         Generate the REPLACE SQL statement.

airflow/providers/postgres/hooks/postgres.py

@@ -21,12 +21,13 @@ import os
 from collections.abc import Mapping
 from contextlib import closing
 from copy import deepcopy
-from typing import TYPE_CHECKING, Any, Literal, TypeAlias, cast, overload
+from typing import TYPE_CHECKING, Any, Literal, Protocol, TypeAlias, cast, overload
 
 import psycopg2
 import psycopg2.extensions
 import psycopg2.extras
-from psycopg2.extras import DictCursor, NamedTupleCursor, RealDictCursor
+from more_itertools import chunked
+from psycopg2.extras import DictCursor, NamedTupleCursor, RealDictCursor, execute_batch
 from sqlalchemy.engine import URL
 
 from airflow.exceptions import (
@@ -36,20 +37,66 @@ from airflow.exceptions import (
 from airflow.providers.common.sql.hooks.sql import DbApiHook
 from airflow.providers.postgres.dialects.postgres import PostgresDialect
 
+USE_PSYCOPG3: bool
+try:
+    import psycopg as psycopg  # needed for patching in unit tests
+    import sqlalchemy
+    from packaging.version import Version
+
+    sqlalchemy_version = Version(sqlalchemy.__version__)
+    is_sqla2 = (sqlalchemy_version.major, sqlalchemy_version.minor, sqlalchemy_version.micro) >= (2, 0, 0)
+
+    USE_PSYCOPG3 = is_sqla2  # implicitly includes `and bool(psycopg)` since the import above succeeded
+except (ImportError, ModuleNotFoundError):
+    USE_PSYCOPG3 = False
+
+if USE_PSYCOPG3:
+    from psycopg.rows import dict_row, namedtuple_row
+    from psycopg.types.json import register_default_adapters
+
 if TYPE_CHECKING:
     from pandas import DataFrame as PandasDataFrame
     from polars import DataFrame as PolarsDataFrame
-    from psycopg2.extensions import connection
 
     from airflow.providers.common.sql.dialects.dialect import Dialect
     from airflow.providers.openlineage.sqlparser import DatabaseInfo
 
+    if USE_PSYCOPG3:
+        from psycopg.errors import Diagnostic
+
     try:
         from airflow.sdk import Connection
     except ImportError:
         from airflow.models.connection import Connection  # type: ignore[assignment]
 
 CursorType: TypeAlias = DictCursor | RealDictCursor | NamedTupleCursor
+CursorRow: TypeAlias = dict[str, Any] | tuple[Any, ...]
+
+
+class CompatConnection(Protocol):
+    """Protocol for type hinting psycopg2 and psycopg3 connection objects."""
+
+    def cursor(self, *args, **kwargs) -> Any: ...
+    def commit(self) -> None: ...
+    def close(self) -> None: ...
+
+    # Context manager support
+    def __enter__(self) -> CompatConnection: ...
+    def __exit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None: ...
+
+    # Common properties
+    @property
+    def notices(self) -> list[Any]: ...
+
+    # psycopg3 specific (optional)
+    @property
+    def adapters(self) -> Any: ...
+
+    @property
+    def row_factory(self) -> Any: ...
+
+    # Optional method for psycopg3
+    def add_notice_handler(self, handler: Any) -> None: ...
 
 
 class PostgresHook(DbApiHook):
@@ -58,8 +105,8 @@ class PostgresHook(DbApiHook):
 
     You can specify ssl parameters in the extra field of your connection
     as ``{"sslmode": "require", "sslcert": "/path/to/cert.pem", etc}``.
-    Also you can choose cursor as ``{"cursor": "dictcursor"}``. Refer to the
-    psycopg2.extras for more details.
+    Also, you can choose cursor as ``{"cursor": "dictcursor"}``. Refer to the
+    psycopg2.extras or psycopg.rows for more details.
 
     Note: For Redshift, use keepalives_idle in the extra connection parameters
     and set it to less than 300 seconds.
@@ -93,6 +140,8 @@ class PostgresHook(DbApiHook):
 
     conn_name_attr = "postgres_conn_id"
     default_conn_name = "postgres_default"
+    default_client_log_level = "warning"
+    default_connector_version: int = 2
     conn_type = "postgres"
     hook_name = "Postgres"
     supports_autocommit = True
@@ -113,11 +162,15 @@ class PostgresHook(DbApiHook):
         self, *args, options: str | None = None, enable_log_db_messages: bool = False, **kwargs
     ) -> None:
         super().__init__(*args, **kwargs)
-        self.conn: connection = None
+        self.conn: CompatConnection | None = None
         self.database: str | None = kwargs.pop("database", None)
         self.options = options
         self.enable_log_db_messages = enable_log_db_messages
 
+    @staticmethod
+    def __cast_nullable(value, dst_type: type) -> Any:
+        return dst_type(value) if value is not None else None
+
     @property
     def sqlalchemy_url(self) -> URL:
         conn = self.connection
@@ -125,12 +178,12 @@ class PostgresHook(DbApiHook):
         if not isinstance(query, dict):
             raise AirflowException("The parameter 'sqlalchemy_query' must be of type dict!")
         return URL.create(
-            drivername="postgresql",
-            username=conn.login,
-            password=conn.password,
-            host=conn.host,
-            port=conn.port,
-            database=self.database or conn.schema,
+            drivername="postgresql+psycopg" if USE_PSYCOPG3 else "postgresql",
+            username=self.__cast_nullable(conn.login, str),
+            password=self.__cast_nullable(conn.password, str),
+            host=self.__cast_nullable(conn.host, str),
+            port=self.__cast_nullable(conn.port, int),
+            database=self.__cast_nullable(self.database, str) or self.__cast_nullable(conn.schema, str),
             query=query,
         )
 
@@ -142,8 +195,24 @@ class PostgresHook(DbApiHook):
     def dialect(self) -> Dialect:
         return PostgresDialect(self)
 
+    def _notice_handler(self, notice: Diagnostic):
+        """Handle notices from the database and log them."""
+        self.log.info(str(notice.message_primary).strip())
+
     def _get_cursor(self, raw_cursor: str) -> CursorType:
         _cursor = raw_cursor.lower()
+        if USE_PSYCOPG3:
+            if _cursor == "dictcursor":
+                return dict_row
+            if _cursor == "namedtuplecursor":
+                return namedtuple_row
+            if _cursor == "realdictcursor":
+                raise AirflowException(
+                    "realdictcursor is not supported with psycopg3. Use dictcursor instead."
+                )
+            valid_cursors = "dictcursor, namedtuplecursor"
+            raise ValueError(f"Invalid cursor passed {_cursor}. Valid options are: {valid_cursors}")
+
         cursor_types = {
             "dictcursor": psycopg2.extras.DictCursor,
             "realdictcursor": psycopg2.extras.RealDictCursor,
@@ -154,33 +223,63 @@ class PostgresHook(DbApiHook):
         valid_cursors = ", ".join(cursor_types.keys())
         raise ValueError(f"Invalid cursor passed {_cursor}. Valid options are: {valid_cursors}")
 
-    def get_conn(self) -> connection:
+    def _generate_cursor_name(self):
+        """Generate a unique name for server-side cursor."""
+        import uuid
+
+        return f"airflow_cursor_{uuid.uuid4().hex}"
+
+    def get_conn(self) -> CompatConnection:
         """Establish a connection to a postgres database."""
         conn = deepcopy(self.connection)
 
-        # check for authentication via AWS IAM
         if conn.extra_dejson.get("iam", False):
-            conn.login, conn.password, conn.port = self.get_iam_token(conn)
+            login, password, port = self.get_iam_token(conn)
+            conn.login = cast("Any", login)
+            conn.password = cast("Any", password)
+            conn.port = cast("Any", port)
 
-        conn_args = {
+        conn_args: dict[str, Any] = {
             "host": conn.host,
             "user": conn.login,
             "password": conn.password,
             "dbname": self.database or conn.schema,
             "port": conn.port,
         }
-        raw_cursor = conn.extra_dejson.get("cursor", False)
-        if raw_cursor:
-            conn_args["cursor_factory"] = self._get_cursor(raw_cursor)
 
         if self.options:
             conn_args["options"] = self.options
 
+        # Add extra connection arguments
         for arg_name, arg_val in conn.extra_dejson.items():
             if arg_name not in self.ignored_extra_options:
                 conn_args[arg_name] = arg_val
 
-        self.conn = psycopg2.connect(**conn_args)
+        if USE_PSYCOPG3:
+            from psycopg.connection import Connection as pgConnection
+
+            raw_cursor = conn.extra_dejson.get("cursor")
+            if raw_cursor:
+                conn_args["row_factory"] = self._get_cursor(raw_cursor)
+
+            # Use Any type for the connection args to avoid type conflicts
+            connection = pgConnection.connect(**cast("Any", conn_args))
+            self.conn = cast("CompatConnection", connection)
+
+            # Register JSON handlers for both json and jsonb types
+            # This ensures JSON data is properly decoded from bytes to Python objects
+            register_default_adapters(connection)
+
+            # Add the notice handler AFTER the connection is established
+            if self.enable_log_db_messages and hasattr(self.conn, "add_notice_handler"):
+                self.conn.add_notice_handler(self._notice_handler)
+        else:  # psycopg2
+            raw_cursor = conn.extra_dejson.get("cursor", False)
+            if raw_cursor:
+                conn_args["cursor_factory"] = self._get_cursor(raw_cursor)
+
+            self.conn = cast("CompatConnection", psycopg2.connect(**conn_args))
+
         return self.conn
 
     @overload
@@ -231,7 +330,9 @@ class PostgresHook(DbApiHook):
 
             engine = self.get_sqlalchemy_engine()
             with engine.connect() as conn:
-                return psql.read_sql(sql, con=conn, params=parameters, **kwargs)
+                if isinstance(sql, list):
+                    sql = "; ".join(sql)  # Or handle multiple queries differently
+                return cast("PandasDataFrame", psql.read_sql(sql, con=conn, params=parameters, **kwargs))
 
         elif df_type == "polars":
             return self._get_polars_df(sql, parameters, **kwargs)
@@ -241,7 +342,7 @@ class PostgresHook(DbApiHook):
 
     def copy_expert(self, sql: str, filename: str) -> None:
         """
-        Execute SQL using psycopg2's ``copy_expert`` method.
+        Execute SQL using psycopg's ``copy_expert`` method.
 
         Necessary to execute COPY command without access to a superuser.
 
@@ -252,14 +353,38 @@ class PostgresHook(DbApiHook):
         they have to check its existence by themselves.
         """
         self.log.info("Running copy expert: %s, filename: %s", sql, filename)
-        if not os.path.isfile(filename):
-            with open(filename, "w"):
-                pass
-
-        with open(filename, "r+") as file, closing(self.get_conn()) as conn, closing(conn.cursor()) as cur:
-            cur.copy_expert(sql, file)
-            file.truncate(file.tell())
-            conn.commit()
+        if USE_PSYCOPG3:
+            if " from stdin" in sql.lower():
+                # Handle COPY FROM STDIN: read from the file and write to the database.
+                if not os.path.isfile(filename):
+                    with open(filename, "w"):
+                        pass  # Create an empty file to prevent errors.
+
+                with open(filename, "rb") as file, self.get_conn() as conn, conn.cursor() as cur:
+                    with cur.copy(sql) as copy:
+                        while data := file.read(8192):
+                            copy.write(data)
+                    conn.commit()
+            else:
+                # Handle COPY TO STDOUT: read from the database and write to the file.
+                with open(filename, "wb") as file, self.get_conn() as conn, conn.cursor() as cur:
+                    with cur.copy(sql) as copy:
+                        for data in copy:
+                            file.write(data)
+                    conn.commit()
+        else:
+            if not os.path.isfile(filename):
+                with open(filename, "w"):
+                    pass
+
+            with (
+                open(filename, "r+") as file,
+                closing(self.get_conn()) as conn,
+                closing(conn.cursor()) as cur,
+            ):
+                cur.copy_expert(sql, file)
+                file.truncate(file.tell())
+                conn.commit()
 
     def get_uri(self) -> str:
         """
@@ -278,9 +403,9 @@ class PostgresHook(DbApiHook):
         self.copy_expert(f"COPY {table} TO STDOUT", tmp_file)
 
     @staticmethod
-    def _serialize_cell(cell: object, conn: connection | None = None) -> Any:
+    def _serialize_cell_ppg2(cell: object, conn: CompatConnection | None = None) -> Any:
         """
-        Serialize a cell.
+        Serialize a cell using psycopg2.
 
         Psycopg2 adapts all arguments to the ``execute()`` method internally,
         hence we return the cell without any conversion.
@@ -297,6 +422,24 @@ class PostgresHook(DbApiHook):
         """
         return cell
 
+    @staticmethod
+    def _serialize_cell_ppg3(cell: object, conn: CompatConnection | None = None) -> Any:
+        """Serialize a cell using psycopg3."""
+        if isinstance(cell, (dict, list)):
+            try:
+                from psycopg.types.json import Json
+
+                return Json(cell)
+            except ImportError:
+                return cell
+        return cell
+
+    @staticmethod
+    def _serialize_cell(cell: object, conn: Any | None = None) -> Any:
+        if USE_PSYCOPG3:
+            return PostgresHook._serialize_cell_ppg3(cell, conn)
+        return PostgresHook._serialize_cell_ppg2(cell, conn)
+
     def get_iam_token(self, conn: Connection) -> tuple[str, str, int]:
         """
         Get the IAM token.
@@ -420,11 +563,91 @@ class PostgresHook(DbApiHook):
         }
 
     def get_db_log_messages(self, conn) -> None:
+        """Log database messages."""
+        if not self.enable_log_db_messages:
+            return
+
+        if USE_PSYCOPG3:
+            self.log.debug(
+                "With psycopg3, database notices are logged upon creation (via self._notice_handler)."
+            )
+            return
+
+        for output in conn.notices:
+            self.log.info(output)
+
+    def insert_rows(
+        self,
+        table,
+        rows,
+        target_fields=None,
+        commit_every=1000,
+        replace=False,
+        *,
+        executemany=False,
+        fast_executemany=False,
+        autocommit=False,
+        **kwargs,
+    ):
         """
-        Log all database messages sent to the client during the session.
+        Insert a collection of tuples into a table.
+
+        Rows are inserted in chunks, each chunk (of size ``commit_every``) is
+        done in a new transaction.
 
-        :param conn: Connection object
+        :param table: Name of the target table
+        :param rows: The rows to insert into the table
+        :param target_fields: The names of the columns to fill in the table
+        :param commit_every: The maximum number of rows to insert in one
+            transaction. Set to 0 to insert all rows in one transaction.
+        :param replace: Whether to replace instead of insert
+        :param executemany: If True, all rows are inserted at once in
+            chunks defined by the commit_every parameter. This only works if all rows
+            have same number of column names, but leads to better performance.
+        :param fast_executemany: If True, rows will be inserted using an optimized
+            bulk execution strategy (``psycopg2.extras.execute_batch``). This can
+            significantly improve performance for large inserts. If set to False,
+            the method falls back to the default implementation from
+            ``DbApiHook.insert_rows``.
+        :param autocommit: What to set the connection's autocommit setting to
+            before executing the query.
         """
-        if self.enable_log_db_messages:
-            for output in conn.notices:
-                self.log.info(output)
+        # if fast_executemany is disabled, defer to default implementation of insert_rows in DbApiHook
+        if not fast_executemany:
+            return super().insert_rows(
+                table,
+                rows,
+                target_fields=target_fields,
+                commit_every=commit_every,
+                replace=replace,
+                executemany=executemany,
+                autocommit=autocommit,
+                **kwargs,
+            )
+
+        # if fast_executemany is enabled, use optimized execute_batch from psycopg
+        nb_rows = 0
+        with self._create_autocommit_connection(autocommit) as conn:
+            conn.commit()
+            with closing(conn.cursor()) as cur:
+                for chunked_rows in chunked(rows, commit_every):
+                    values = list(
+                        map(
+                            lambda row: self._serialize_cells(row, conn),
+                            chunked_rows,
+                        )
+                    )
+                    sql = self._generate_insert_sql(table, values[0], target_fields, replace, **kwargs)
+                    self.log.debug("Generated sql: %s", sql)
+
+                    try:
+                        execute_batch(cur, sql, values, page_size=commit_every)
+                    except Exception as e:
+                        self.log.error("Generated sql: %s", sql)
+                        self.log.error("Parameters: %s", values)
+                        raise e
+
+                    conn.commit()
+                    nb_rows += len(chunked_rows)
+                    self.log.info("Loaded %s rows into %s so far", nb_rows, table)
+        self.log.info("Done loading. Loaded a total of %s rows into %s", nb_rows, table)

{apache_airflow_providers_postgres-6.2.3rc1.dist-info → apache_airflow_providers_postgres-6.3.0rc1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: apache-airflow-providers-postgres
-Version: 6.2.3rc1
+Version: 6.3.0rc1
 Summary: Provider package apache-airflow-providers-postgres for Apache Airflow
 Keywords: airflow-provider,postgres,airflow,integration
 Author-email: Apache Software Foundation <dev@airflow.apache.org>
@@ -30,9 +30,10 @@ Requires-Dist: apache-airflow-providers-openlineage ; extra == "openlineage"
 Requires-Dist: pandas>=2.1.2 ; extra == "pandas" and ( python_version <"3.13")
 Requires-Dist: pandas>=2.2.3 ; extra == "pandas" and ( python_version >="3.13")
 Requires-Dist: polars>=1.26.0 ; extra == "polars"
+Requires-Dist: psycopg[binary]>=3.2.9 ; extra == "psycopg"
 Project-URL: Bug Tracker, https://github.com/apache/airflow/issues
-Project-URL: Changelog, https://airflow.staged.apache.org/docs/apache-airflow-providers-postgres/6.2.3/changelog.html
-Project-URL: Documentation, https://airflow.staged.apache.org/docs/apache-airflow-providers-postgres/6.2.3
+Project-URL: Changelog, https://airflow.staged.apache.org/docs/apache-airflow-providers-postgres/6.3.0/changelog.html
+Project-URL: Documentation, https://airflow.staged.apache.org/docs/apache-airflow-providers-postgres/6.3.0
 Project-URL: Mastodon, https://fosstodon.org/@airflow
 Project-URL: Slack Chat, https://s.apache.org/airflow-slack
 Project-URL: Source Code, https://github.com/apache/airflow
@@ -41,6 +42,7 @@ Provides-Extra: amazon
 Provides-Extra: openlineage
 Provides-Extra: pandas
 Provides-Extra: polars
+Provides-Extra: psycopg
 
 
 .. Licensed to the Apache Software Foundation (ASF) under one
@@ -67,9 +69,8 @@ Provides-Extra: polars
 
 Package ``apache-airflow-providers-postgres``
 
-Release: ``6.2.3``
+Release: ``6.3.0``
 
-Release Date: ``|PypiReleaseDate|``
 
 `PostgreSQL <https://www.postgresql.org/>`__
 
@@ -81,12 +82,12 @@ This is a provider package for ``postgres`` provider. All classes for this provi
 are in ``airflow.providers.postgres`` python package.
 
 You can find package information and changelog for the provider
-in the `documentation <https://airflow.apache.org/docs/apache-airflow-providers-postgres/6.2.3/>`_.
+in the `documentation <https://airflow.apache.org/docs/apache-airflow-providers-postgres/6.3.0/>`_.
 
 Installation
 ------------
 
-You can install this package on top of an existing Airflow 2 installation (see ``Requirements`` below
+You can install this package on top of an existing Airflow installation (see ``Requirements`` below
 for the minimum Airflow version supported) via
 ``pip install apache-airflow-providers-postgres``
 
@@ -127,5 +128,5 @@ Dependent package
 ==============================================================================================================  ===============
 
 The changelog for the provider package can be found in the
-`changelog <https://airflow.apache.org/docs/apache-airflow-providers-postgres/6.2.3/changelog.html>`_.
+`changelog <https://airflow.apache.org/docs/apache-airflow-providers-postgres/6.3.0/changelog.html>`_.
 

{apache_airflow_providers_postgres-6.2.3rc1.dist-info → apache_airflow_providers_postgres-6.3.0rc1.dist-info}/RECORD

@@ -1,13 +1,13 @@
 airflow/providers/postgres/LICENSE,sha256=gXPVwptPlW1TJ4HSuG5OMPg-a3h43OGMkZRR1rpwfJA,10850
-airflow/providers/postgres/__init__.py,sha256=AGf6WOLMkDqDRwtMgRbiZ8xMIXq-l-oK88uqcaOVUsk,1497
+airflow/providers/postgres/__init__.py,sha256=EBlBQkd4wsb32h6i--UVow1UxLY3oTKzALQLc1L5W7s,1497
 airflow/providers/postgres/get_provider_info.py,sha256=qEEYbClLY3-NH40dBk2u_nOIfvfEIHdXaWsIJ8J5Z68,2626
 airflow/providers/postgres/assets/__init__.py,sha256=9hdXHABrVpkbpjZgUft39kOFL2xSGeG4GEua0Hmelus,785
 airflow/providers/postgres/assets/postgres.py,sha256=XNhOJCbOA_soaaiS73JjULMqAM_7PBryhToe8FJREA0,1522
 airflow/providers/postgres/dialects/__init__.py,sha256=9hdXHABrVpkbpjZgUft39kOFL2xSGeG4GEua0Hmelus,785
-airflow/providers/postgres/dialects/postgres.py,sha256=8ygA2Jq2WBPhNOISU8YyitLmahxWnPGYNt8OaU_CBFI,3764
+airflow/providers/postgres/dialects/postgres.py,sha256=WhRMbSQv2u373R62e3buE5J1L3j-XGHhZxrWc8Gtc5s,5551
 airflow/providers/postgres/hooks/__init__.py,sha256=mlJxuZLkd5x-iq2SBwD3mvRQpt3YR7wjz_nceyF1IaI,787
-airflow/providers/postgres/hooks/postgres.py,sha256=_iulx6UoEBcGP2_wxmdoXnYM9I97I4dGGAAkw4mmLTg,17737
-apache_airflow_providers_postgres-6.2.3rc1.dist-info/entry_points.txt,sha256=dhtJi6PTWHd6BwKhmI4OtSPvQVI_p0yYWI0eba83HqY,104
-apache_airflow_providers_postgres-6.2.3rc1.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
-apache_airflow_providers_postgres-6.2.3rc1.dist-info/METADATA,sha256=YNhTrvJxeTW0-3ovqYYXUfoky0h7JjnSPWNp8JL3Nhk,6264
-apache_airflow_providers_postgres-6.2.3rc1.dist-info/RECORD,,
+airflow/providers/postgres/hooks/postgres.py,sha256=YwA99YPz_ZpCvBn5yyw4ykhJ9hMGNvEsMmAf5nsfVE8,26908
+apache_airflow_providers_postgres-6.3.0rc1.dist-info/entry_points.txt,sha256=dhtJi6PTWHd6BwKhmI4OtSPvQVI_p0yYWI0eba83HqY,104
+apache_airflow_providers_postgres-6.3.0rc1.dist-info/WHEEL,sha256=G2gURzTEtmeR8nrdXUJfNiB3VYVxigPQ-bEQujpNiNs,82
+apache_airflow_providers_postgres-6.3.0rc1.dist-info/METADATA,sha256=-yMIPOzaKFmX8R55IV-td9dERi-HzogSQcxtawr2FAU,6309
+apache_airflow_providers_postgres-6.3.0rc1.dist-info/RECORD,,