apache-airflow-providers-standard 0.0.1__py3-none-any.whl

airflow/providers/standard/hooks/subprocess.py

@@ -0,0 +1,119 @@
+# 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.
+from __future__ import annotations
+
+import contextlib
+import os
+import signal
+from collections import namedtuple
+from subprocess import PIPE, STDOUT, Popen
+from tempfile import TemporaryDirectory, gettempdir
+from typing import Iterator
+
+from airflow.hooks.base import BaseHook
+
+SubprocessResult = namedtuple("SubprocessResult", ["exit_code", "output"])
+
+
+@contextlib.contextmanager
+def working_directory(cwd: str | None = None) -> Iterator[str]:
+    """
+    Context manager for handling (temporary) working directory.
+
+    Use the given cwd as working directory, if provided.
+    Otherwise, create a temporary directory.
+    """
+    with contextlib.ExitStack() as stack:
+        if cwd is None:
+            cwd = stack.enter_context(TemporaryDirectory(prefix="airflowtmp"))
+        yield cwd
+
+
+class SubprocessHook(BaseHook):
+    """Hook for running processes with the ``subprocess`` module."""
+
+    def __init__(self, **kwargs) -> None:
+        self.sub_process: Popen[bytes] | None = None
+        super().__init__(**kwargs)
+
+    def run_command(
+        self,
+        command: list[str],
+        env: dict[str, str] | None = None,
+        output_encoding: str = "utf-8",
+        cwd: str | None = None,
+    ) -> SubprocessResult:
+        """
+        Execute the command.
+
+        If ``cwd`` is None, execute the command in a temporary directory which will be cleaned afterwards.
+        If ``env`` is not supplied, ``os.environ`` is passed
+
+        :param command: the command to run
+        :param env: Optional dict containing environment variables to be made available to the shell
+            environment in which ``command`` will be executed.  If omitted, ``os.environ`` will be used.
+            Note, that in case you have Sentry configured, original variables from the environment
+            will also be passed to the subprocess with ``SUBPROCESS_`` prefix. See:
+            https://airflow.apache.org/docs/apache-airflow/stable/administration-and-deployment/logging-monitoring/errors.html for details.
+        :param output_encoding: encoding to use for decoding stdout
+        :param cwd: Working directory to run the command in.
+            If None (default), the command is run in a temporary directory.
+        :return: :class:`namedtuple` containing ``exit_code`` and ``output``, the last line from stderr
+            or stdout
+        """
+        self.log.info("Tmp dir root location: %s", gettempdir())
+        with working_directory(cwd=cwd) as cwd:
+
+            def pre_exec():
+                # Restore default signal disposition and invoke setsid
+                for sig in ("SIGPIPE", "SIGXFZ", "SIGXFSZ"):
+                    if hasattr(signal, sig):
+                        signal.signal(getattr(signal, sig), signal.SIG_DFL)
+                os.setsid()
+
+            self.log.info("Running command: %s", command)
+
+            self.sub_process = Popen(
+                command,
+                stdout=PIPE,
+                stderr=STDOUT,
+                cwd=cwd,
+                env=env if env or env == {} else os.environ,
+                preexec_fn=pre_exec,
+            )
+
+            self.log.info("Output:")
+            line = ""
+            if self.sub_process is None:
+                raise RuntimeError("The subprocess should be created here and is None!")
+            if self.sub_process.stdout is not None:
+                for raw_line in iter(self.sub_process.stdout.readline, b""):
+                    line = raw_line.decode(output_encoding, errors="backslashreplace").rstrip()
+                    self.log.info("%s", line)
+
+            self.sub_process.wait()
+
+            self.log.info("Command exited with return code %s", self.sub_process.returncode)
+            return_code: int = self.sub_process.returncode
+
+        return SubprocessResult(exit_code=return_code, output=line)
+
+    def send_sigterm(self):
+        """Send SIGTERM signal to ``self.sub_process`` if one exists."""
+        self.log.info("Sending SIGTERM signal to process group")
+        if self.sub_process and hasattr(self.sub_process, "pid"):
+            os.killpg(os.getpgid(self.sub_process.pid), signal.SIGTERM)

airflow/providers/standard/operators/__init__.py

@@ -0,0 +1,16 @@
+# 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.

airflow/providers/standard/operators/bash.py

@@ -0,0 +1,304 @@
+#
+# 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.
+from __future__ import annotations
+
+import os
+import shutil
+import tempfile
+import warnings
+from functools import cached_property
+from typing import TYPE_CHECKING, Any, Callable, Container, Sequence, cast
+
+from airflow.exceptions import AirflowException, AirflowSkipException
+from airflow.models.baseoperator import BaseOperator
+from airflow.providers.standard.hooks.subprocess import SubprocessHook, SubprocessResult, working_directory
+from airflow.utils.operator_helpers import context_to_airflow_vars
+from airflow.utils.types import ArgNotSet
+
+if TYPE_CHECKING:
+    from airflow.models.taskinstance import TaskInstance
+    from airflow.utils.context import Context
+
+
+class BashOperator(BaseOperator):
+    r"""
+    Execute a Bash script, command or set of commands.
+
+    .. seealso::
+        For more information on how to use this operator, take a look at the guide:
+        :ref:`howto/operator:BashOperator`
+
+    If BaseOperator.do_xcom_push is True, the last line written to stdout
+    will also be pushed to an XCom when the bash command completes
+
+    :param bash_command: The command, set of commands or reference to a
+        Bash script (must be '.sh' or '.bash') to be executed. (templated)
+    :param env: If env is not None, it must be a dict that defines the
+        environment variables for the new process; these are used instead
+        of inheriting the current process environment, which is the default
+        behavior. (templated)
+    :param append_env: If False(default) uses the environment variables passed in env params
+        and does not inherit the current process environment. If True, inherits the environment variables
+        from current passes and then environment variable passed by the user will either update the existing
+        inherited environment variables or the new variables gets appended to it
+    :param output_encoding: Output encoding of Bash command
+    :param skip_on_exit_code: If task exits with this exit code, leave the task
+        in ``skipped`` state (default: 99). If set to ``None``, any non-zero
+        exit code will be treated as a failure.
+    :param cwd: Working directory to execute the command in (templated).
+        If None (default), the command is run in a temporary directory.
+        To use current DAG folder as the working directory,
+        you might set template ``{{ dag_run.dag.folder }}``.
+        When bash_command is a '.sh' or '.bash' file, Airflow must have write
+        access to the working directory. The script will be rendered (Jinja
+        template) into a new temporary file in this directory.
+    :param output_processor: Function to further process the output of the bash script
+        (default is lambda output: output).
+
+    Airflow will evaluate the exit code of the Bash command. In general, a non-zero exit code will result in
+    task failure and zero will result in task success.
+    Exit code ``99`` (or another set in ``skip_on_exit_code``)
+    will throw an :class:`airflow.exceptions.AirflowSkipException`, which will leave the task in ``skipped``
+    state. You can have all non-zero exit codes be treated as a failure by setting ``skip_on_exit_code=None``.
+
+    .. list-table::
+       :widths: 25 25
+       :header-rows: 1
+
+       * - Exit code
+         - Behavior
+       * - 0
+         - success
+       * - `skip_on_exit_code` (default: 99)
+         - raise :class:`airflow.exceptions.AirflowSkipException`
+       * - otherwise
+         - raise :class:`airflow.exceptions.AirflowException`
+
+    .. note::
+
+        Airflow will not recognize a non-zero exit code unless the whole shell exit with a non-zero exit
+        code.  This can be an issue if the non-zero exit arises from a sub-command.  The easiest way of
+        addressing this is to prefix the command with ``set -e;``
+
+        .. code-block:: python
+
+            bash_command = "set -e; python3 script.py '{{ next_execution_date }}'"
+
+    .. note::
+
+        To simply execute a ``.sh`` or ``.bash`` script (without any Jinja template), add a space after the
+        script name ``bash_command`` argument -- for example ``bash_command="my_script.sh "``. This
+        is because Airflow tries to load this file and process it as a Jinja template when
+        it ends with ``.sh`` or ``.bash``.
+
+        If you have Jinja template in your script, do not put any blank space. And add the script's directory
+        in the DAG's ``template_searchpath``. If you specify a ``cwd``, Airflow must have write access to
+        this directory. The script will be rendered (Jinja template) into a new temporary file in this directory.
+
+    .. warning::
+
+        Care should be taken with "user" input or when using Jinja templates in the
+        ``bash_command``, as this bash operator does not perform any escaping or
+        sanitization of the command.
+
+        This applies mostly to using "dag_run" conf, as that can be submitted via
+        users in the Web UI. Most of the default template variables are not at
+        risk.
+
+    For example, do **not** do this:
+
+    .. code-block:: python
+
+        bash_task = BashOperator(
+            task_id="bash_task",
+            bash_command='echo "Here is the message: \'{{ dag_run.conf["message"] if dag_run else "" }}\'"',
+        )
+
+    Instead, you should pass this via the ``env`` kwarg and use double-quotes
+    inside the bash_command, as below:
+
+    .. code-block:: python
+
+        bash_task = BashOperator(
+            task_id="bash_task",
+            bash_command="echo \"here is the message: '$message'\"",
+            env={"message": '{{ dag_run.conf["message"] if dag_run else "" }}'},
+        )
+
+    .. versionadded:: 2.10.0
+       The `output_processor` parameter.
+
+    """
+
+    template_fields: Sequence[str] = ("bash_command", "env", "cwd")
+    template_fields_renderers = {"bash_command": "bash", "env": "json"}
+    template_ext: Sequence[str] = (".sh", ".bash")
+    ui_color = "#f0ede4"
+
+    def __init__(
+        self,
+        *,
+        bash_command: str | ArgNotSet,
+        env: dict[str, str] | None = None,
+        append_env: bool = False,
+        output_encoding: str = "utf-8",
+        skip_exit_code: int | None = None,
+        skip_on_exit_code: int | Container[int] | None = 99,
+        cwd: str | None = None,
+        output_processor: Callable[[str], Any] = lambda result: result,
+        **kwargs,
+    ) -> None:
+        super().__init__(**kwargs)
+        self.bash_command = bash_command
+        self.env = env
+        self.output_encoding = output_encoding
+        if skip_exit_code is not None:
+            warnings.warn(
+                "skip_exit_code is deprecated. Please use skip_on_exit_code", DeprecationWarning, stacklevel=2
+            )
+            skip_on_exit_code = skip_exit_code
+        self.skip_on_exit_code = (
+            skip_on_exit_code
+            if isinstance(skip_on_exit_code, Container)
+            else [skip_on_exit_code]
+            if skip_on_exit_code is not None
+            else []
+        )
+        self.cwd = cwd
+        self.append_env = append_env
+        self.output_processor = output_processor
+
+        # When using the @task.bash decorator, the Bash command is not known until the underlying Python
+        # callable is executed and therefore set to NOTSET initially. This flag is useful during execution to
+        # determine whether the bash_command value needs to re-rendered.
+        self._init_bash_command_not_set = isinstance(self.bash_command, ArgNotSet)
+
+        # Keep a copy of the original bash_command, without the Jinja template rendered.
+        # This is later used to determine if the bash_command is a script or an inline string command.
+        # We do this later, because the bash_command is not available in __init__ when using @task.bash.
+        self._unrendered_bash_command: str | ArgNotSet = bash_command
+
+    @cached_property
+    def subprocess_hook(self):
+        """Returns hook for running the bash command."""
+        return SubprocessHook()
+
+    @staticmethod
+    def refresh_bash_command(ti: TaskInstance) -> None:
+        """
+        Rewrite the underlying rendered bash_command value for a task instance in the metadatabase.
+
+        TaskInstance.get_rendered_template_fields() cannot be used because this will retrieve the
+        RenderedTaskInstanceFields from the metadatabase which doesn't have the runtime-evaluated bash_command
+        value.
+
+        :meta private:
+        """
+        from airflow.models.renderedtifields import RenderedTaskInstanceFields
+
+        RenderedTaskInstanceFields._update_runtime_evaluated_template_fields(ti)
+
+    def get_env(self, context) -> dict:
+        """Build the set of environment variables to be exposed for the bash command."""
+        system_env = os.environ.copy()
+        env = self.env
+        if env is None:
+            env = system_env
+        else:
+            if self.append_env:
+                system_env.update(env)
+                env = system_env
+
+        airflow_context_vars = context_to_airflow_vars(context, in_env_var_format=True)
+        self.log.debug(
+            "Exporting env vars: %s",
+            " ".join(f"{k}={v!r}" for k, v in airflow_context_vars.items()),
+        )
+        env.update(airflow_context_vars)
+        return env
+
+    def execute(self, context: Context):
+        bash_path: str = shutil.which("bash") or "bash"
+        if self.cwd is not None:
+            if not os.path.exists(self.cwd):
+                raise AirflowException(f"Can not find the cwd: {self.cwd}")
+            if not os.path.isdir(self.cwd):
+                raise AirflowException(f"The cwd {self.cwd} must be a directory")
+        env = self.get_env(context)
+
+        # Because the bash_command value is evaluated at runtime using the @task.bash decorator, the
+        # RenderedTaskInstanceField data needs to be rewritten and the bash_command value re-rendered -- the
+        # latter because the returned command from the decorated callable could contain a Jinja expression.
+        # Both will ensure the correct Bash command is executed and that the Rendered Template view in the UI
+        # displays the executed command (otherwise it will display as an ArgNotSet type).
+        if self._init_bash_command_not_set:
+            is_inline_command = self._is_inline_command(bash_command=cast(str, self.bash_command))
+            ti = cast("TaskInstance", context["ti"])
+            self.refresh_bash_command(ti)
+        else:
+            is_inline_command = self._is_inline_command(bash_command=cast(str, self._unrendered_bash_command))
+
+        if is_inline_command:
+            result = self._run_inline_command(bash_path=bash_path, env=env)
+        else:
+            result = self._run_rendered_script_file(bash_path=bash_path, env=env)
+
+        if result.exit_code in self.skip_on_exit_code:
+            raise AirflowSkipException(f"Bash command returned exit code {result.exit_code}. Skipping.")
+        elif result.exit_code != 0:
+            raise AirflowException(
+                f"Bash command failed. The command returned a non-zero exit code {result.exit_code}."
+            )
+
+        return self.output_processor(result.output)
+
+    def _run_inline_command(self, bash_path: str, env: dict) -> SubprocessResult:
+        """Pass the bash command as string directly in the subprocess."""
+        return self.subprocess_hook.run_command(
+            command=[bash_path, "-c", self.bash_command],
+            env=env,
+            output_encoding=self.output_encoding,
+            cwd=self.cwd,
+        )
+
+    def _run_rendered_script_file(self, bash_path: str, env: dict) -> SubprocessResult:
+        """
+        Save the bash command into a file and execute this file.
+
+        This allows for longer commands, and prevents "Argument list too long error".
+        """
+        with working_directory(cwd=self.cwd) as cwd:
+            with tempfile.NamedTemporaryFile(mode="w", dir=cwd, suffix=".sh") as file:
+                file.write(cast(str, self.bash_command))
+                file.flush()
+
+                bash_script = os.path.basename(file.name)
+                return self.subprocess_hook.run_command(
+                    command=[bash_path, bash_script],
+                    env=env,
+                    output_encoding=self.output_encoding,
+                    cwd=cwd,
+                )
+
+    @classmethod
+    def _is_inline_command(cls, bash_command: str) -> bool:
+        """Return True if the bash command is an inline string. False if it's a bash script file."""
+        return not bash_command.endswith(tuple(cls.template_ext))
+
+    def on_kill(self) -> None:
+        self.subprocess_hook.send_sigterm()

airflow/providers/standard/operators/datetime.py

@@ -0,0 +1,110 @@
+# 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.
+from __future__ import annotations
+
+import datetime
+from typing import TYPE_CHECKING, Iterable
+
+from airflow.exceptions import AirflowException
+from airflow.operators.branch import BaseBranchOperator
+from airflow.utils import timezone
+
+if TYPE_CHECKING:
+    from airflow.utils.context import Context
+
+
+class BranchDateTimeOperator(BaseBranchOperator):
+    """
+    Branches into one of two lists of tasks depending on the current datetime.
+
+    For more information on how to use this operator, take a look at the guide:
+    :ref:`howto/operator:BranchDateTimeOperator`.
+
+    True branch will be returned when ``datetime.datetime.now()`` falls below
+    ``target_upper`` and above ``target_lower``.
+
+    :param follow_task_ids_if_true: task_id, task_group_id, or a list of task_ids and/or task_group_ids
+        to follow if ``datetime.datetime.now()`` falls above target_lower and below target_upper.
+    :param follow_task_ids_if_false: task_id, task_group_id, or a list of task_ids and/or task_group_ids
+        to follow if ``datetime.datetime.now()`` falls below target_lower or above target_upper.
+    :param target_lower: target lower bound.
+    :param target_upper: target upper bound.
+    :param use_task_logical_date: If ``True``, uses task's logical date to compare with targets.
+        Execution date is useful for backfilling. If ``False``, uses system's date.
+    """
+
+    def __init__(
+        self,
+        *,
+        follow_task_ids_if_true: str | Iterable[str],
+        follow_task_ids_if_false: str | Iterable[str],
+        target_lower: datetime.datetime | datetime.time | None,
+        target_upper: datetime.datetime | datetime.time | None,
+        use_task_logical_date: bool = False,
+        **kwargs,
+    ) -> None:
+        super().__init__(**kwargs)
+        if target_lower is None and target_upper is None:
+            raise AirflowException(
+                "Both target_upper and target_lower are None. At least one "
+                "must be defined to be compared to the current datetime"
+            )
+
+        self.target_lower = target_lower
+        self.target_upper = target_upper
+        self.follow_task_ids_if_true = follow_task_ids_if_true
+        self.follow_task_ids_if_false = follow_task_ids_if_false
+        self.use_task_logical_date = use_task_logical_date
+
+    def choose_branch(self, context: Context) -> str | Iterable[str]:
+        if self.use_task_logical_date:
+            now = context["logical_date"]
+        else:
+            now = timezone.coerce_datetime(timezone.utcnow())
+        lower, upper = target_times_as_dates(now, self.target_lower, self.target_upper)
+        lower = timezone.coerce_datetime(lower, self.dag.timezone)
+        upper = timezone.coerce_datetime(upper, self.dag.timezone)
+
+        if upper is not None and upper < now:
+            return self.follow_task_ids_if_false
+
+        if lower is not None and lower > now:
+            return self.follow_task_ids_if_false
+
+        return self.follow_task_ids_if_true
+
+
+def target_times_as_dates(
+    base_date: datetime.datetime,
+    lower: datetime.datetime | datetime.time | None,
+    upper: datetime.datetime | datetime.time | None,
+):
+    """Ensure upper and lower time targets are datetimes by combining them with base_date."""
+    if isinstance(lower, datetime.datetime) and isinstance(upper, datetime.datetime):
+        return lower, upper
+
+    if lower is not None and isinstance(lower, datetime.time):
+        lower = datetime.datetime.combine(base_date, lower)
+    if upper is not None and isinstance(upper, datetime.time):
+        upper = datetime.datetime.combine(base_date, upper)
+
+    if lower is None or upper is None:
+        return lower, upper
+
+    if upper < lower:
+        upper += datetime.timedelta(days=1)
+    return lower, upper

airflow/providers/standard/operators/generic_transfer.py

@@ -0,0 +1,133 @@
+#
+# 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.
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Sequence
+
+from airflow.hooks.base import BaseHook
+from airflow.models import BaseOperator
+
+if TYPE_CHECKING:
+    from airflow.utils.context import Context
+
+
+class GenericTransfer(BaseOperator):
+    """
+    Moves data from a connection to another.
+
+    Assuming that they both provide the required methods in their respective hooks.
+    The source hook needs to expose a `get_records` method, and the destination a
+    `insert_rows` method.
+
+    This is meant to be used on small-ish datasets that fit in memory.
+
+    :param sql: SQL query to execute against the source database. (templated)
+    :param destination_table: target table. (templated)
+    :param source_conn_id: source connection. (templated)
+    :param destination_conn_id: destination connection. (templated)
+    :param preoperator: sql statement or list of statements to be
+        executed prior to loading the data. (templated)
+    :param insert_args: extra params for `insert_rows` method.
+    """
+
+    template_fields: Sequence[str] = (
+        "source_conn_id",
+        "destination_conn_id",
+        "sql",
+        "destination_table",
+        "preoperator",
+        "insert_args",
+    )
+    template_ext: Sequence[str] = (
+        ".sql",
+        ".hql",
+    )
+    template_fields_renderers = {"preoperator": "sql"}
+    ui_color = "#b0f07c"
+
+    def __init__(
+        self,
+        *,
+        sql: str,
+        destination_table: str,
+        source_conn_id: str,
+        source_hook_params: dict | None = None,
+        destination_conn_id: str,
+        destination_hook_params: dict | None = None,
+        preoperator: str | list[str] | None = None,
+        insert_args: dict | None = None,
+        **kwargs,
+    ) -> None:
+        super().__init__(**kwargs)
+        self.sql = sql
+        self.destination_table = destination_table
+        self.source_conn_id = source_conn_id
+        self.source_hook_params = source_hook_params
+        self.destination_conn_id = destination_conn_id
+        self.destination_hook_params = destination_hook_params
+        self.preoperator = preoperator
+        self.insert_args = insert_args or {}
+
+    @classmethod
+    def get_hook(cls, conn_id: str, hook_params: dict | None = None) -> BaseHook:
+        """
+        Return default hook for this connection id.
+
+        :param conn_id: connection id
+        :param hook_params: hook parameters
+        :return: default hook for this connection
+        """
+        connection = BaseHook.get_connection(conn_id)
+        return connection.get_hook(hook_params=hook_params)
+
+    def execute(self, context: Context):
+        source_hook = self.get_hook(conn_id=self.source_conn_id, hook_params=self.source_hook_params)
+        destination_hook = self.get_hook(
+            conn_id=self.destination_conn_id, hook_params=self.destination_hook_params
+        )
+
+        self.log.info("Extracting data from %s", self.source_conn_id)
+        self.log.info("Executing: \n %s", self.sql)
+        get_records = getattr(source_hook, "get_records", None)
+        if not callable(get_records):
+            raise RuntimeError(
+                f"Hook for connection {self.source_conn_id!r} "
+                f"({type(source_hook).__name__}) has no `get_records` method"
+            )
+        else:
+            results = get_records(self.sql)
+
+        if self.preoperator:
+            run = getattr(destination_hook, "run", None)
+            if not callable(run):
+                raise RuntimeError(
+                    f"Hook for connection {self.destination_conn_id!r} "
+                    f"({type(destination_hook).__name__}) has no `run` method"
+                )
+            self.log.info("Running preoperator")
+            self.log.info(self.preoperator)
+            run(self.preoperator)
+
+        insert_rows = getattr(destination_hook, "insert_rows", None)
+        if not callable(insert_rows):
+            raise RuntimeError(
+                f"Hook for connection {self.destination_conn_id!r} "
+                f"({type(destination_hook).__name__}) has no `insert_rows` method"
+            )
+        self.log.info("Inserting rows into %s", self.destination_conn_id)
+        insert_rows(table=self.destination_table, rows=results, **self.insert_args)