apache-airflow-providers-snowflake 5.2.1__tar.gz → 5.3.0__tar.gz

{apache_airflow_providers_snowflake-5.2.1 → apache_airflow_providers_snowflake-5.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: apache-airflow-providers-snowflake
-Version: 5.2.1
+Version: 5.3.0
 Summary: Provider package apache-airflow-providers-snowflake for Apache Airflow
 Keywords: airflow-provider,snowflake,airflow,integration
 Author-email: Apache Software Foundation <dev@airflow.apache.org>
@@ -27,8 +27,8 @@ Requires-Dist: snowflake-sqlalchemy>=1.1.0
 Requires-Dist: apache-airflow-providers-common-sql ; extra == "common.sql"
 Requires-Dist: apache-airflow-providers-openlineage ; extra == "openlineage"
 Project-URL: Bug Tracker, https://github.com/apache/airflow/issues
-Project-URL: Changelog, https://airflow.apache.org/docs/apache-airflow-providers-snowflake/5.2.1/changelog.html
-Project-URL: Documentation, https://airflow.apache.org/docs/apache-airflow-providers-snowflake/5.2.1
+Project-URL: Changelog, https://airflow.apache.org/docs/apache-airflow-providers-snowflake/5.3.0/changelog.html
+Project-URL: Documentation, https://airflow.apache.org/docs/apache-airflow-providers-snowflake/5.3.0
 Project-URL: Slack Chat, https://s.apache.org/airflow-slack
 Project-URL: Source Code, https://github.com/apache/airflow
 Project-URL: Twitter, https://twitter.com/ApacheAirflow
@@ -80,7 +80,7 @@ Provides-Extra: openlineage
 
 Package ``apache-airflow-providers-snowflake``
 
-Release: ``5.2.1``
+Release: ``5.3.0``
 
 
 `Snowflake <https://www.snowflake.com/>`__
@@ -93,7 +93,7 @@ This is a provider package for ``snowflake`` provider. All classes for this prov
 are in ``airflow.providers.snowflake`` python package.
 
 You can find package information and changelog for the provider
-in the `documentation <https://airflow.apache.org/docs/apache-airflow-providers-snowflake/5.2.1/>`_.
+in the `documentation <https://airflow.apache.org/docs/apache-airflow-providers-snowflake/5.3.0/>`_.
 
 Installation
 ------------
@@ -137,4 +137,4 @@ Dependent package
 ==============================================================================================================  ===============
 
 The changelog for the provider package can be found in the
-`changelog <https://airflow.apache.org/docs/apache-airflow-providers-snowflake/5.2.1/changelog.html>`_.
+`changelog <https://airflow.apache.org/docs/apache-airflow-providers-snowflake/5.3.0/changelog.html>`_.

{apache_airflow_providers_snowflake-5.2.1 → apache_airflow_providers_snowflake-5.3.0}/README.rst

@@ -42,7 +42,7 @@
 
 Package ``apache-airflow-providers-snowflake``
 
-Release: ``5.2.1``
+Release: ``5.3.0``
 
 
 `Snowflake <https://www.snowflake.com/>`__
@@ -55,7 +55,7 @@ This is a provider package for ``snowflake`` provider. All classes for this prov
 are in ``airflow.providers.snowflake`` python package.
 
 You can find package information and changelog for the provider
-in the `documentation <https://airflow.apache.org/docs/apache-airflow-providers-snowflake/5.2.1/>`_.
+in the `documentation <https://airflow.apache.org/docs/apache-airflow-providers-snowflake/5.3.0/>`_.
 
 Installation
 ------------
@@ -99,4 +99,4 @@ Dependent package
 ==============================================================================================================  ===============
 
 The changelog for the provider package can be found in the
-`changelog <https://airflow.apache.org/docs/apache-airflow-providers-snowflake/5.2.1/changelog.html>`_.
+`changelog <https://airflow.apache.org/docs/apache-airflow-providers-snowflake/5.3.0/changelog.html>`_.

{apache_airflow_providers_snowflake-5.2.1 → apache_airflow_providers_snowflake-5.3.0}/airflow/providers/snowflake/__init__.py

@@ -27,7 +27,7 @@ import packaging.version
 
 __all__ = ["__version__"]
 
-__version__ = "5.2.1"
+__version__ = "5.3.0"
 
 try:
     from airflow import __version__ as airflow_version

{apache_airflow_providers_snowflake-5.2.1 → apache_airflow_providers_snowflake-5.3.0}/airflow/providers/snowflake/get_provider_info.py

@@ -27,9 +27,10 @@ def get_provider_info():
         "package-name": "apache-airflow-providers-snowflake",
         "name": "Snowflake",
         "description": "`Snowflake <https://www.snowflake.com/>`__\n",
-        "suspended": False,
-        "source-date-epoch": 1703288173,
+        "state": "ready",
+        "source-date-epoch": 1705912272,
         "versions": [
+            "5.3.0",
             "5.2.1",
             "5.2.0",
             "5.1.2",

{apache_airflow_providers_snowflake-5.2.1 → apache_airflow_providers_snowflake-5.3.0}/airflow/providers/snowflake/hooks/snowflake.py

@@ -170,7 +170,9 @@ class SnowflakeHook(DbApiHook):
                 warnings.warn(
                     f"Conflicting params `{field_name}` and `{backcompat_key}` found in extras. "
                     f"Using value for `{field_name}`.  Please ensure this is the correct "
-                    f"value and remove the backcompat key `{backcompat_key}`."
+                    f"value and remove the backcompat key `{backcompat_key}`.",
+                    UserWarning,
+                    stacklevel=2,
                 )
             return extra_dict[field_name] or None
         return extra_dict.get(backcompat_key) or None
@@ -300,7 +302,7 @@ class SnowflakeHook(DbApiHook):
     def get_autocommit(self, conn):
         return getattr(conn, "autocommit_mode", False)
 
-    @overload
+    @overload  # type: ignore[override]
     def run(
         self,
         sql: str | Iterable[str],
@@ -385,10 +387,10 @@ class SnowflakeHook(DbApiHook):
             with self._get_cursor(conn, return_dictionaries) as cur:
                 results = []
                 for sql_statement in sql_list:
-                    self._run_command(cur, sql_statement, parameters)
+                    self._run_command(cur, sql_statement, parameters)  # type: ignore[attr-defined]
 
                     if handler is not None:
-                        result = self._make_common_data_structure(handler(cur))
+                        result = self._make_common_data_structure(handler(cur))  # type: ignore[attr-defined]
                         if return_single_query_results(sql, return_last, split_statements):
                             _last_result = result
                             _last_description = cur.description

{apache_airflow_providers_snowflake-5.2.1 → apache_airflow_providers_snowflake-5.3.0}/airflow/providers/snowflake/operators/snowflake.py

@@ -514,6 +514,21 @@ class SnowflakeSqlApiOperator(SQLExecuteQueryOperator):
         if self.do_xcom_push:
             context["ti"].xcom_push(key="query_ids", value=self.query_ids)
 
+        succeeded_query_ids = []
+        for query_id in self.query_ids:
+            self.log.info("Retrieving status for query id %s", query_id)
+            statement_status = self._hook.get_sql_api_query_status(query_id)
+            if statement_status.get("status") == "running":
+                break
+            elif statement_status.get("status") == "success":
+                succeeded_query_ids.append(query_id)
+            else:
+                raise AirflowException(f"{statement_status.get('status')}: {statement_status.get('message')}")
+
+        if len(self.query_ids) == len(succeeded_query_ids):
+            self.log.info("%s completed successfully.", self.task_id)
+            return
+
         if self.deferrable:
             self.defer(
                 timeout=self.execution_timeout,

apache_airflow_providers_snowflake-5.3.0/airflow/providers/snowflake/transfers/copy_into_snowflake.py

@@ -0,0 +1,298 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+"""Abstract operator that child classes implement ``COPY INTO <TABLE> SQL in Snowflake``."""
+from __future__ import annotations
+
+from typing import Any, Sequence
+
+from airflow.models import BaseOperator
+from airflow.providers.snowflake.hooks.snowflake import SnowflakeHook
+from airflow.providers.snowflake.utils.common import enclose_param
+
+
+class CopyFromExternalStageToSnowflakeOperator(BaseOperator):
+    """
+    Executes a COPY INTO command to load files from an external stage from clouds to Snowflake.
+
+    This operator requires the snowflake_conn_id connection. The snowflake host, login,
+    and, password field must be setup in the connection. Other inputs can be defined
+    in the connection or hook instantiation.
+
+    :param namespace: snowflake namespace
+    :param table: snowflake table
+    :param file_format: file format name i.e. CSV, AVRO, etc
+    :param stage: reference to a specific snowflake stage. If the stage's schema is not the same as the
+        table one, it must be specified
+    :param prefix: cloud storage location specified to limit the set of files to load
+    :param files: files to load into table
+    :param pattern: pattern to load files from external location to table
+    :param copy_into_postifx: optional sql postfix for INSERT INTO query
+           such as `formatTypeOptions` and `copyOptions`
+    :param snowflake_conn_id:  Reference to :ref:`Snowflake connection id<howto/connection:snowflake>`
+    :param account: snowflake account name
+    :param warehouse: name of snowflake warehouse
+    :param database: name of snowflake database
+    :param region: name of snowflake region
+    :param role: name of snowflake role
+    :param schema: name of snowflake schema
+    :param authenticator: authenticator for Snowflake.
+        'snowflake' (default) to use the internal Snowflake authenticator
+        'externalbrowser' to authenticate using your web browser and
+        Okta, ADFS or any other SAML 2.0-compliant identify provider
+        (IdP) that has been defined for your account
+        ``https://<your_okta_account_name>.okta.com`` to authenticate
+        through native Okta.
+    :param session_parameters: You can set session-level parameters at
+        the time you connect to Snowflake
+    :param copy_options: snowflake COPY INTO syntax copy options
+    :param validation_mode: snowflake COPY INTO syntax validation mode
+
+    """
+
+    template_fields: Sequence[str] = ("files",)
+    template_fields_renderers = {"files": "json"}
+
+    def __init__(
+        self,
+        *,
+        files: list | None = None,
+        table: str,
+        stage: str,
+        prefix: str | None = None,
+        file_format: str,
+        schema: str | None = None,
+        columns_array: list | None = None,
+        pattern: str | None = None,
+        warehouse: str | None = None,
+        database: str | None = None,
+        autocommit: bool = True,
+        snowflake_conn_id: str = "snowflake_default",
+        role: str | None = None,
+        authenticator: str | None = None,
+        session_parameters: dict | None = None,
+        copy_options: str | None = None,
+        validation_mode: str | None = None,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.files = files
+        self.table = table
+        self.stage = stage
+        self.prefix = prefix
+        self.file_format = file_format
+        self.schema = schema
+        self.columns_array = columns_array
+        self.pattern = pattern
+        self.warehouse = warehouse
+        self.database = database
+        self.autocommit = autocommit
+        self.snowflake_conn_id = snowflake_conn_id
+        self.role = role
+        self.authenticator = authenticator
+        self.session_parameters = session_parameters
+        self.copy_options = copy_options
+        self.validation_mode = validation_mode
+
+        self.hook: SnowflakeHook | None = None
+        self._sql: str | None = None
+        self._result: list[dict[str, Any]] = []
+
+    def execute(self, context: Any) -> None:
+        self.hook = SnowflakeHook(
+            snowflake_conn_id=self.snowflake_conn_id,
+            warehouse=self.warehouse,
+            database=self.database,
+            role=self.role,
+            schema=self.schema,
+            authenticator=self.authenticator,
+            session_parameters=self.session_parameters,
+        )
+
+        if self.schema:
+            into = f"{self.schema}.{self.table}"
+        else:
+            into = self.table
+
+        if self.columns_array:
+            into = f"{into}({', '.join(self.columns_array)})"
+
+        self._sql = f"""
+        COPY INTO {into}
+             FROM  @{self.stage}/{self.prefix or ""}
+        {"FILES=(" + ",".join(map(enclose_param, self.files)) + ")" if self.files else ""}
+        {"PATTERN=" + enclose_param(self.pattern) if self.pattern else ""}
+        FILE_FORMAT={self.file_format}
+        {self.copy_options or ""}
+        {self.validation_mode or ""}
+        """
+        self.log.info("Executing COPY command...")
+        self._result = self.hook.run(  # type: ignore # mypy does not work well with return_dictionaries=True
+            sql=self._sql,
+            autocommit=self.autocommit,
+            handler=lambda x: x.fetchall(),
+            return_dictionaries=True,
+        )
+        self.log.info("COPY command completed")
+
+    @staticmethod
+    def _extract_openlineage_unique_dataset_paths(
+        query_result: list[dict[str, Any]],
+    ) -> tuple[list[tuple[str, str]], list[str]]:
+        """Extracts and returns unique OpenLineage dataset paths and file paths that failed to be parsed.
+
+        Each row in the results is expected to have a 'file' field, which is a URI.
+        The function parses these URIs and constructs a set of unique OpenLineage (namespace, name) tuples.
+        Additionally, it captures any URIs that cannot be parsed or processed
+        and returns them in a separate error list.
+
+        For Azure, Snowflake has a unique way of representing URI:
+            azure://<account_name>.blob.core.windows.net/<container_name>/path/to/file.csv
+        that is transformed by this function to a Dataset with more universal naming convention:
+            Dataset(namespace="wasbs://container_name@account_name", name="path/to"), as described at
+        https://github.com/OpenLineage/OpenLineage/blob/main/spec/Naming.md#wasbs-azure-blob-storage
+
+        :param query_result: A list of dictionaries, each containing a 'file' key with a URI value.
+        :return: Two lists - the first is a sorted list of tuples, each representing a unique dataset path,
+         and the second contains any URIs that cannot be parsed or processed correctly.
+
+        >>> method = CopyFromExternalStageToSnowflakeOperator._extract_openlineage_unique_dataset_paths
+
+        >>> results = [{"file": "azure://my_account.blob.core.windows.net/azure_container/dir3/file.csv"}]
+        >>> method(results)
+        ([('wasbs://azure_container@my_account', 'dir3')], [])
+
+        >>> results = [{"file": "azure://my_account.blob.core.windows.net/azure_container"}]
+        >>> method(results)
+        ([('wasbs://azure_container@my_account', '/')], [])
+
+        >>> results = [{"file": "s3://bucket"}, {"file": "gcs://bucket/"}, {"file": "s3://bucket/a.csv"}]
+        >>> method(results)
+        ([('gcs://bucket', '/'), ('s3://bucket', '/')], [])
+
+        >>> results = [{"file": "s3://bucket/dir/file.csv"}, {"file": "gcs://bucket/dir/dir2/a.txt"}]
+        >>> method(results)
+        ([('gcs://bucket', 'dir/dir2'), ('s3://bucket', 'dir')], [])
+
+        >>> results = [
+        ...     {"file": "s3://bucket/dir/file.csv"},
+        ...     {"file": "azure://my_account.something_new.windows.net/azure_container"},
+        ... ]
+        >>> method(results)
+        ([('s3://bucket', 'dir')], ['azure://my_account.something_new.windows.net/azure_container'])
+        """
+        import re
+        from pathlib import Path
+        from urllib.parse import urlparse
+
+        azure_regex = r"azure:\/\/(\w+)?\.blob.core.windows.net\/(\w+)\/?(.*)?"
+        extraction_error_files = []
+        unique_dataset_paths = set()
+
+        for row in query_result:
+            uri = urlparse(row["file"])
+            if uri.scheme == "azure":
+                match = re.fullmatch(azure_regex, row["file"])
+                if not match:
+                    extraction_error_files.append(row["file"])
+                    continue
+                account_name, container_name, name = match.groups()
+                namespace = f"wasbs://{container_name}@{account_name}"
+            else:
+                namespace = f"{uri.scheme}://{uri.netloc}"
+                name = uri.path.lstrip("/")
+
+            name = Path(name).parent.as_posix()
+            if name in ("", "."):
+                name = "/"
+
+            unique_dataset_paths.add((namespace, name))
+
+        return sorted(unique_dataset_paths), sorted(extraction_error_files)
+
+    def get_openlineage_facets_on_complete(self, task_instance):
+        """Implement _on_complete because we rely on return value of a query."""
+        import re
+
+        from openlineage.client.facet import (
+            ExternalQueryRunFacet,
+            ExtractionError,
+            ExtractionErrorRunFacet,
+            SqlJobFacet,
+        )
+        from openlineage.client.run import Dataset
+
+        from airflow.providers.openlineage.extractors import OperatorLineage
+        from airflow.providers.openlineage.sqlparser import SQLParser
+
+        if not self._sql:
+            return OperatorLineage()
+
+        query_results = self._result or []
+        # If no files were uploaded we get [{"status": "0 files were uploaded..."}]
+        if len(query_results) == 1 and query_results[0].get("status"):
+            query_results = []
+        unique_dataset_paths, extraction_error_files = self._extract_openlineage_unique_dataset_paths(
+            query_results
+        )
+        input_datasets = [Dataset(namespace=namespace, name=name) for namespace, name in unique_dataset_paths]
+
+        run_facets = {}
+        if extraction_error_files:
+            self.log.debug(
+                f"Unable to extract Dataset namespace and name "
+                f"for the following files: `{extraction_error_files}`."
+            )
+            run_facets["extractionError"] = ExtractionErrorRunFacet(
+                totalTasks=len(query_results),
+                failedTasks=len(extraction_error_files),
+                errors=[
+                    ExtractionError(
+                        errorMessage="Unable to extract Dataset namespace and name.",
+                        stackTrace=None,
+                        task=file_uri,
+                        taskNumber=None,
+                    )
+                    for file_uri in extraction_error_files
+                ],
+            )
+
+        connection = self.hook.get_connection(getattr(self.hook, str(self.hook.conn_name_attr)))
+        database_info = self.hook.get_openlineage_database_info(connection)
+
+        dest_name = self.table
+        schema = self.hook.get_openlineage_default_schema()
+        database = database_info.database
+        if schema:
+            dest_name = f"{schema}.{dest_name}"
+            if database:
+                dest_name = f"{database}.{dest_name}"
+
+        snowflake_namespace = SQLParser.create_namespace(database_info)
+        query = SQLParser.normalize_sql(self._sql)
+        query = re.sub(r"\n+", "\n", re.sub(r" +", " ", query))
+
+        run_facets["externalQuery"] = ExternalQueryRunFacet(
+            externalQueryId=self.hook.query_ids[0], source=snowflake_namespace
+        )
+
+        return OperatorLineage(
+            inputs=input_datasets,
+            outputs=[Dataset(namespace=snowflake_namespace, name=dest_name)],
+            job_facets={"sql": SqlJobFacet(query=query)},
+            run_facets=run_facets,
+        )

{apache_airflow_providers_snowflake-5.2.1 → apache_airflow_providers_snowflake-5.3.0}/pyproject.toml

@@ -28,7 +28,7 @@ build-backend = "flit_core.buildapi"
 
 [project]
 name = "apache-airflow-providers-snowflake"
-version = "5.2.1"
+version = "5.3.0"
 description = "Provider package apache-airflow-providers-snowflake for Apache Airflow"
 readme = "README.rst"
 authors = [
@@ -62,8 +62,8 @@ dependencies = [
 ]
 
 [project.urls]
-"Documentation" = "https://airflow.apache.org/docs/apache-airflow-providers-snowflake/5.2.1"
-"Changelog" = "https://airflow.apache.org/docs/apache-airflow-providers-snowflake/5.2.1/changelog.html"
+"Documentation" = "https://airflow.apache.org/docs/apache-airflow-providers-snowflake/5.3.0"
+"Changelog" = "https://airflow.apache.org/docs/apache-airflow-providers-snowflake/5.3.0/changelog.html"
 "Bug Tracker" = "https://github.com/apache/airflow/issues"
 "Source Code" = "https://github.com/apache/airflow"
 "Slack Chat" = "https://s.apache.org/airflow-slack"

apache_airflow_providers_snowflake-5.2.1/airflow/providers/snowflake/transfers/copy_into_snowflake.py

@@ -1,141 +0,0 @@
-#
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-"""Abstract operator that child classes implement ``COPY INTO <TABLE> SQL in Snowflake``."""
-from __future__ import annotations
-
-from typing import Any, Sequence
-
-from airflow.models import BaseOperator
-from airflow.providers.snowflake.hooks.snowflake import SnowflakeHook
-from airflow.providers.snowflake.utils.common import enclose_param
-
-
-class CopyFromExternalStageToSnowflakeOperator(BaseOperator):
-    """
-    Executes a COPY INTO command to load files from an external stage from clouds to Snowflake.
-
-    This operator requires the snowflake_conn_id connection. The snowflake host, login,
-    and, password field must be setup in the connection. Other inputs can be defined
-    in the connection or hook instantiation.
-
-    :param namespace: snowflake namespace
-    :param table: snowflake table
-    :param file_format: file format name i.e. CSV, AVRO, etc
-    :param stage: reference to a specific snowflake stage. If the stage's schema is not the same as the
-        table one, it must be specified
-    :param prefix: cloud storage location specified to limit the set of files to load
-    :param files: files to load into table
-    :param pattern: pattern to load files from external location to table
-    :param copy_into_postifx: optional sql postfix for INSERT INTO query
-           such as `formatTypeOptions` and `copyOptions`
-    :param snowflake_conn_id:  Reference to :ref:`Snowflake connection id<howto/connection:snowflake>`
-    :param account: snowflake account name
-    :param warehouse: name of snowflake warehouse
-    :param database: name of snowflake database
-    :param region: name of snowflake region
-    :param role: name of snowflake role
-    :param schema: name of snowflake schema
-    :param authenticator: authenticator for Snowflake.
-        'snowflake' (default) to use the internal Snowflake authenticator
-        'externalbrowser' to authenticate using your web browser and
-        Okta, ADFS or any other SAML 2.0-compliant identify provider
-        (IdP) that has been defined for your account
-        ``https://<your_okta_account_name>.okta.com`` to authenticate
-        through native Okta.
-    :param session_parameters: You can set session-level parameters at
-        the time you connect to Snowflake
-    :param copy_options: snowflake COPY INTO syntax copy options
-    :param validation_mode: snowflake COPY INTO syntax validation mode
-
-    """
-
-    template_fields: Sequence[str] = ("files",)
-    template_fields_renderers = {"files": "json"}
-
-    def __init__(
-        self,
-        *,
-        files: list | None = None,
-        table: str,
-        stage: str,
-        prefix: str | None = None,
-        file_format: str,
-        schema: str | None = None,
-        columns_array: list | None = None,
-        pattern: str | None = None,
-        warehouse: str | None = None,
-        database: str | None = None,
-        autocommit: bool = True,
-        snowflake_conn_id: str = "snowflake_default",
-        role: str | None = None,
-        authenticator: str | None = None,
-        session_parameters: dict | None = None,
-        copy_options: str | None = None,
-        validation_mode: str | None = None,
-        **kwargs,
-    ):
-        super().__init__(**kwargs)
-        self.files = files
-        self.table = table
-        self.stage = stage
-        self.prefix = prefix
-        self.file_format = file_format
-        self.schema = schema
-        self.columns_array = columns_array
-        self.pattern = pattern
-        self.warehouse = warehouse
-        self.database = database
-        self.autocommit = autocommit
-        self.snowflake_conn_id = snowflake_conn_id
-        self.role = role
-        self.authenticator = authenticator
-        self.session_parameters = session_parameters
-        self.copy_options = copy_options
-        self.validation_mode = validation_mode
-
-    def execute(self, context: Any) -> None:
-        snowflake_hook = SnowflakeHook(
-            snowflake_conn_id=self.snowflake_conn_id,
-            warehouse=self.warehouse,
-            database=self.database,
-            role=self.role,
-            schema=self.schema,
-            authenticator=self.authenticator,
-            session_parameters=self.session_parameters,
-        )
-
-        if self.schema:
-            into = f"{self.schema}.{self.table}"
-        else:
-            into = self.table
-
-        if self.columns_array:
-            into = f"{into}({', '.join(self.columns_array)})"
-
-        sql = f"""
-        COPY INTO {into}
-             FROM  @{self.stage}/{self.prefix or ""}
-        {"FILES=(" + ",".join(map(enclose_param, self.files)) + ")" if self.files else ""}
-        {"PATTERN=" + enclose_param(self.pattern) if self.pattern else ""}
-        FILE_FORMAT={self.file_format}
-        {self.copy_options or ""}
-        {self.validation_mode or ""}
-        """
-        self.log.info("Executing COPY command...")
-        snowflake_hook.run(sql=sql, autocommit=self.autocommit)
-        self.log.info("COPY command completed")