`task-sql-decorator`: Introducing the `@task.sql` decorator by jroachgolf84 · Pull Request #60851 · apache/airflow

jroachgolf84 · 2026-01-21T03:55:32Z

Description

For DAG authors familiar with writing Python functions to do "something", the @task decorator is one of the most popular tools authoring logic in Airflow. There are several other decorators, such as @task.bash, @task.kubernetes, etc. that extend this functionality. However, there is no @task.sql decorator.

This PR introduces the @task.sql decorator. This decorator is a wrapper around the SQLExecuteQueryOperator. However, the value returned from the Python function is the SQL query that is executed.

Here's an example usage:

fromairflow.sdkimportDAG, taskfromdatetimeimportdatetimewithDAG(
dag_id="sql_deco",
start_date=datetime(2025, 1, 1),
schedule="@once"
) asdag:
@task.sql(conn_id="task-sql-decorator"# Transient connection defined in the UI )deftask_1():
return"SELECT 1;"task_1()

Testing

To run the unit tests that were authored for this decorator, the command below can be used:

breeze testing providers-tests providers/common/sql/tests/unit/common/sql/decorators/test_sql.py

The DAG above was also used to validate the functionality of the @task.sql decorator.

Other Notes

There will be additional documentation and examples that comes out of this initial pull request, with the goal of providing parity between this new decorator and the SQLExecuteQueryOperator. For now, this PR just provides the bare-bones.

kaxil

Looks good to me but worth checking how OL works with it.

cc @mobuchowski @kacpermuda

jroachgolf84 · 2026-02-15T02:01:50Z

@kaxil, what is the best way to test this? Do we have a framework in-place for this already?

potiuk · 2026-02-16T00:45:34Z

@kaxil, what is the best way to test this? Do we have a framework in-place for this already?

There is openlineage integration that starts Marquez I believe.

potiuk · 2026-02-16T00:46:05Z

Look at https://github.com/apache/airflow/blob/main/contributing-docs/testing/integration_tests.rst

kacpermuda

Looks good, thanks !

From the OL perspective, the Ol methods from SqlExecuteQueryOperator are executed, since PythonOperator does not have them. With the added type check in BaseSqlOperator's OL method, the *_on_start method does nothing, since we do not know SQL text before execution, and the *_on_complete behaves as the query was executed with the usual SqlExecuteQueryOperator which is good.

mobuchowski

I was going to look at OpenLineage impl, but @kacpermuda already did this - so I just have a few drive-by comments :)

@once

…0851) For DAG authors familiar with writing Python functions to do "something", the `@task` decorator is one of the most popular tools authoring logic in Airflow. There are several other decorators, such as `@task.bash`, `@task.kubernetes`, etc. that extend this functionality. However, there is no `@task.sql` decorator. This PR introduces the `@task.sql` decorator. This decorator is a wrapper around the `SQLExecuteQueryOperator`. However, the value returned from the Python function is the SQL query that is executed. Here's an example usage: ```python from airflow.sdk import DAG, task from datetime import datetime with DAG( dag_id="sql_deco", start_date=datetime(2025, 1, 1), schedule="@once" ) as dag: @task.sql( conn_id="task-sql-decorator" # Transient connection defined in the UI ) def task_1(): return "SELECT 1;" task_1() ```

@once

…0851) For DAG authors familiar with writing Python functions to do "something", the `@task` decorator is one of the most popular tools authoring logic in Airflow. There are several other decorators, such as `@task.bash`, `@task.kubernetes`, etc. that extend this functionality. However, there is no `@task.sql` decorator. This PR introduces the `@task.sql` decorator. This decorator is a wrapper around the `SQLExecuteQueryOperator`. However, the value returned from the Python function is the SQL query that is executed. Here's an example usage: ```python from airflow.sdk import DAG, task from datetime import datetime with DAG( dag_id="sql_deco", start_date=datetime(2025, 1, 1), schedule="@once" ) as dag: @task.sql( conn_id="task-sql-decorator" # Transient connection defined in the UI ) def task_1(): return "SELECT 1;" task_1() ```

@once

…0851) For DAG authors familiar with writing Python functions to do "something", the `@task` decorator is one of the most popular tools authoring logic in Airflow. There are several other decorators, such as `@task.bash`, `@task.kubernetes`, etc. that extend this functionality. However, there is no `@task.sql` decorator. This PR introduces the `@task.sql` decorator. This decorator is a wrapper around the `SQLExecuteQueryOperator`. However, the value returned from the Python function is the SQL query that is executed. Here's an example usage: ```python from airflow.sdk import DAG, task from datetime import datetime with DAG( dag_id="sql_deco", start_date=datetime(2025, 1, 1), schedule="@once" ) as dag: @task.sql( conn_id="task-sql-decorator" # Transient connection defined in the UI ) def task_1(): return "SELECT 1;" task_1() ```

@once

…0851) For DAG authors familiar with writing Python functions to do "something", the `@task` decorator is one of the most popular tools authoring logic in Airflow. There are several other decorators, such as `@task.bash`, `@task.kubernetes`, etc. that extend this functionality. However, there is no `@task.sql` decorator. This PR introduces the `@task.sql` decorator. This decorator is a wrapper around the `SQLExecuteQueryOperator`. However, the value returned from the Python function is the SQL query that is executed. Here's an example usage: ```python from airflow.sdk import DAG, task from datetime import datetime with DAG( dag_id="sql_deco", start_date=datetime(2025, 1, 1), schedule="@once" ) as dag: @task.sql( conn_id="task-sql-decorator" # Transient connection defined in the UI ) def task_1(): return "SELECT 1;" task_1() ```

@once

…0851) For DAG authors familiar with writing Python functions to do "something", the `@task` decorator is one of the most popular tools authoring logic in Airflow. There are several other decorators, such as `@task.bash`, `@task.kubernetes`, etc. that extend this functionality. However, there is no `@task.sql` decorator. This PR introduces the `@task.sql` decorator. This decorator is a wrapper around the `SQLExecuteQueryOperator`. However, the value returned from the Python function is the SQL query that is executed. Here's an example usage: ```python from airflow.sdk import DAG, task from datetime import datetime with DAG( dag_id="sql_deco", start_date=datetime(2025, 1, 1), schedule="@once" ) as dag: @task.sql( conn_id="task-sql-decorator" # Transient connection defined in the UI ) def task_1(): return "SELECT 1;" task_1() ```

jroachgolf84 · 2026-01-21T03:55:32Z

Description

For DAG authors familiar with writing Python functions to do "something", the @task decorator is one of the most popular tools authoring logic in Airflow. There are several other decorators, such as @task.bash, @task.kubernetes, etc. that extend this functionality. However, there is no @task.sql decorator.

This PR introduces the @task.sql decorator. This decorator is a wrapper around the SQLExecuteQueryOperator. However, the value returned from the Python function is the SQL query that is executed.

Here's an example usage:

fromairflow.sdkimportDAG, taskfromdatetimeimportdatetimewithDAG(
dag_id="sql_deco",
start_date=datetime(2025, 1, 1),
schedule="@once"
) asdag:
@task.sql(conn_id="task-sql-decorator"# Transient connection defined in the UI )deftask_1():
return"SELECT 1;"task_1()

Testing

To run the unit tests that were authored for this decorator, the command below can be used:

breeze testing providers-tests providers/common/sql/tests/unit/common/sql/decorators/test_sql.py

The DAG above was also used to validate the functionality of the @task.sql decorator.

Other Notes

There will be additional documentation and examples that comes out of this initial pull request, with the goal of providing parity between this new decorator and the SQLExecuteQueryOperator. For now, this PR just provides the bare-bones.

kaxil

Looks good to me but worth checking how OL works with it.

cc @mobuchowski @kacpermuda

jroachgolf84 · 2026-02-15T02:01:50Z

@kaxil, what is the best way to test this? Do we have a framework in-place for this already?

potiuk · 2026-02-16T00:45:34Z

@kaxil, what is the best way to test this? Do we have a framework in-place for this already?

There is openlineage integration that starts Marquez I believe.

potiuk · 2026-02-16T00:46:05Z

Look at https://github.com/apache/airflow/blob/main/contributing-docs/testing/integration_tests.rst

kacpermuda

Looks good, thanks !

From the OL perspective, the Ol methods from SqlExecuteQueryOperator are executed, since PythonOperator does not have them. With the added type check in BaseSqlOperator's OL method, the *_on_start method does nothing, since we do not know SQL text before execution, and the *_on_complete behaves as the query was executed with the usual SqlExecuteQueryOperator which is good.

mobuchowski

I was going to look at OpenLineage impl, but @kacpermuda already did this - so I just have a few drive-by comments :)

@once

…0851) For DAG authors familiar with writing Python functions to do "something", the `@task` decorator is one of the most popular tools authoring logic in Airflow. There are several other decorators, such as `@task.bash`, `@task.kubernetes`, etc. that extend this functionality. However, there is no `@task.sql` decorator. This PR introduces the `@task.sql` decorator. This decorator is a wrapper around the `SQLExecuteQueryOperator`. However, the value returned from the Python function is the SQL query that is executed. Here's an example usage: ```python from airflow.sdk import DAG, task from datetime import datetime with DAG( dag_id="sql_deco", start_date=datetime(2025, 1, 1), schedule="@once" ) as dag: @task.sql( conn_id="task-sql-decorator" # Transient connection defined in the UI ) def task_1(): return "SELECT 1;" task_1() ```

@once

…0851) For DAG authors familiar with writing Python functions to do "something", the `@task` decorator is one of the most popular tools authoring logic in Airflow. There are several other decorators, such as `@task.bash`, `@task.kubernetes`, etc. that extend this functionality. However, there is no `@task.sql` decorator. This PR introduces the `@task.sql` decorator. This decorator is a wrapper around the `SQLExecuteQueryOperator`. However, the value returned from the Python function is the SQL query that is executed. Here's an example usage: ```python from airflow.sdk import DAG, task from datetime import datetime with DAG( dag_id="sql_deco", start_date=datetime(2025, 1, 1), schedule="@once" ) as dag: @task.sql( conn_id="task-sql-decorator" # Transient connection defined in the UI ) def task_1(): return "SELECT 1;" task_1() ```

@once

…0851) For DAG authors familiar with writing Python functions to do "something", the `@task` decorator is one of the most popular tools authoring logic in Airflow. There are several other decorators, such as `@task.bash`, `@task.kubernetes`, etc. that extend this functionality. However, there is no `@task.sql` decorator. This PR introduces the `@task.sql` decorator. This decorator is a wrapper around the `SQLExecuteQueryOperator`. However, the value returned from the Python function is the SQL query that is executed. Here's an example usage: ```python from airflow.sdk import DAG, task from datetime import datetime with DAG( dag_id="sql_deco", start_date=datetime(2025, 1, 1), schedule="@once" ) as dag: @task.sql( conn_id="task-sql-decorator" # Transient connection defined in the UI ) def task_1(): return "SELECT 1;" task_1() ```

@once

…0851) For DAG authors familiar with writing Python functions to do "something", the `@task` decorator is one of the most popular tools authoring logic in Airflow. There are several other decorators, such as `@task.bash`, `@task.kubernetes`, etc. that extend this functionality. However, there is no `@task.sql` decorator. This PR introduces the `@task.sql` decorator. This decorator is a wrapper around the `SQLExecuteQueryOperator`. However, the value returned from the Python function is the SQL query that is executed. Here's an example usage: ```python from airflow.sdk import DAG, task from datetime import datetime with DAG( dag_id="sql_deco", start_date=datetime(2025, 1, 1), schedule="@once" ) as dag: @task.sql( conn_id="task-sql-decorator" # Transient connection defined in the UI ) def task_1(): return "SELECT 1;" task_1() ```

@once

…0851) For DAG authors familiar with writing Python functions to do "something", the `@task` decorator is one of the most popular tools authoring logic in Airflow. There are several other decorators, such as `@task.bash`, `@task.kubernetes`, etc. that extend this functionality. However, there is no `@task.sql` decorator. This PR introduces the `@task.sql` decorator. This decorator is a wrapper around the `SQLExecuteQueryOperator`. However, the value returned from the Python function is the SQL query that is executed. Here's an example usage: ```python from airflow.sdk import DAG, task from datetime import datetime with DAG( dag_id="sql_deco", start_date=datetime(2025, 1, 1), schedule="@once" ) as dag: @task.sql( conn_id="task-sql-decorator" # Transient connection defined in the UI ) def task_1(): return "SELECT 1;" task_1() ```

jroachgolf84 · 2026-01-21T03:55:32Z

Description

For DAG authors familiar with writing Python functions to do "something", the @task decorator is one of the most popular tools authoring logic in Airflow. There are several other decorators, such as @task.bash, @task.kubernetes, etc. that extend this functionality. However, there is no @task.sql decorator.

This PR introduces the @task.sql decorator. This decorator is a wrapper around the SQLExecuteQueryOperator. However, the value returned from the Python function is the SQL query that is executed.

Here's an example usage:

fromairflow.sdkimportDAG, taskfromdatetimeimportdatetimewithDAG(
dag_id="sql_deco",
start_date=datetime(2025, 1, 1),
schedule="@once"
) asdag:
@task.sql(conn_id="task-sql-decorator"# Transient connection defined in the UI )deftask_1():
return"SELECT 1;"task_1()

Testing

To run the unit tests that were authored for this decorator, the command below can be used:

breeze testing providers-tests providers/common/sql/tests/unit/common/sql/decorators/test_sql.py

The DAG above was also used to validate the functionality of the @task.sql decorator.

Other Notes

There will be additional documentation and examples that comes out of this initial pull request, with the goal of providing parity between this new decorator and the SQLExecuteQueryOperator. For now, this PR just provides the bare-bones.

kaxil

Looks good to me but worth checking how OL works with it.

cc @mobuchowski @kacpermuda

jroachgolf84 · 2026-02-15T02:01:50Z

@kaxil, what is the best way to test this? Do we have a framework in-place for this already?

potiuk · 2026-02-16T00:45:34Z

@kaxil, what is the best way to test this? Do we have a framework in-place for this already?

There is openlineage integration that starts Marquez I believe.

potiuk · 2026-02-16T00:46:05Z

Look at https://github.com/apache/airflow/blob/main/contributing-docs/testing/integration_tests.rst

kacpermuda

Looks good, thanks !

From the OL perspective, the Ol methods from SqlExecuteQueryOperator are executed, since PythonOperator does not have them. With the added type check in BaseSqlOperator's OL method, the *_on_start method does nothing, since we do not know SQL text before execution, and the *_on_complete behaves as the query was executed with the usual SqlExecuteQueryOperator which is good.

mobuchowski

I was going to look at OpenLineage impl, but @kacpermuda already did this - so I just have a few drive-by comments :)

@once

…0851) For DAG authors familiar with writing Python functions to do "something", the `@task` decorator is one of the most popular tools authoring logic in Airflow. There are several other decorators, such as `@task.bash`, `@task.kubernetes`, etc. that extend this functionality. However, there is no `@task.sql` decorator. This PR introduces the `@task.sql` decorator. This decorator is a wrapper around the `SQLExecuteQueryOperator`. However, the value returned from the Python function is the SQL query that is executed. Here's an example usage: ```python from airflow.sdk import DAG, task from datetime import datetime with DAG( dag_id="sql_deco", start_date=datetime(2025, 1, 1), schedule="@once" ) as dag: @task.sql( conn_id="task-sql-decorator" # Transient connection defined in the UI ) def task_1(): return "SELECT 1;" task_1() ```

@once

…0851) For DAG authors familiar with writing Python functions to do "something", the `@task` decorator is one of the most popular tools authoring logic in Airflow. There are several other decorators, such as `@task.bash`, `@task.kubernetes`, etc. that extend this functionality. However, there is no `@task.sql` decorator. This PR introduces the `@task.sql` decorator. This decorator is a wrapper around the `SQLExecuteQueryOperator`. However, the value returned from the Python function is the SQL query that is executed. Here's an example usage: ```python from airflow.sdk import DAG, task from datetime import datetime with DAG( dag_id="sql_deco", start_date=datetime(2025, 1, 1), schedule="@once" ) as dag: @task.sql( conn_id="task-sql-decorator" # Transient connection defined in the UI ) def task_1(): return "SELECT 1;" task_1() ```

@once

…0851) For DAG authors familiar with writing Python functions to do "something", the `@task` decorator is one of the most popular tools authoring logic in Airflow. There are several other decorators, such as `@task.bash`, `@task.kubernetes`, etc. that extend this functionality. However, there is no `@task.sql` decorator. This PR introduces the `@task.sql` decorator. This decorator is a wrapper around the `SQLExecuteQueryOperator`. However, the value returned from the Python function is the SQL query that is executed. Here's an example usage: ```python from airflow.sdk import DAG, task from datetime import datetime with DAG( dag_id="sql_deco", start_date=datetime(2025, 1, 1), schedule="@once" ) as dag: @task.sql( conn_id="task-sql-decorator" # Transient connection defined in the UI ) def task_1(): return "SELECT 1;" task_1() ```

@once

…0851) For DAG authors familiar with writing Python functions to do "something", the `@task` decorator is one of the most popular tools authoring logic in Airflow. There are several other decorators, such as `@task.bash`, `@task.kubernetes`, etc. that extend this functionality. However, there is no `@task.sql` decorator. This PR introduces the `@task.sql` decorator. This decorator is a wrapper around the `SQLExecuteQueryOperator`. However, the value returned from the Python function is the SQL query that is executed. Here's an example usage: ```python from airflow.sdk import DAG, task from datetime import datetime with DAG( dag_id="sql_deco", start_date=datetime(2025, 1, 1), schedule="@once" ) as dag: @task.sql( conn_id="task-sql-decorator" # Transient connection defined in the UI ) def task_1(): return "SELECT 1;" task_1() ```

@once

…0851) For DAG authors familiar with writing Python functions to do "something", the `@task` decorator is one of the most popular tools authoring logic in Airflow. There are several other decorators, such as `@task.bash`, `@task.kubernetes`, etc. that extend this functionality. However, there is no `@task.sql` decorator. This PR introduces the `@task.sql` decorator. This decorator is a wrapper around the `SQLExecuteQueryOperator`. However, the value returned from the Python function is the SQL query that is executed. Here's an example usage: ```python from airflow.sdk import DAG, task from datetime import datetime with DAG( dag_id="sql_deco", start_date=datetime(2025, 1, 1), schedule="@once" ) as dag: @task.sql( conn_id="task-sql-decorator" # Transient connection defined in the UI ) def task_1(): return "SELECT 1;" task_1() ```

jroachgolf84 · 2026-01-21T03:55:32Z

Description

For DAG authors familiar with writing Python functions to do "something", the @task decorator is one of the most popular tools authoring logic in Airflow. There are several other decorators, such as @task.bash, @task.kubernetes, etc. that extend this functionality. However, there is no @task.sql decorator.

This PR introduces the @task.sql decorator. This decorator is a wrapper around the SQLExecuteQueryOperator. However, the value returned from the Python function is the SQL query that is executed.

Here's an example usage:

fromairflow.sdkimportDAG, taskfromdatetimeimportdatetimewithDAG(
dag_id="sql_deco",
start_date=datetime(2025, 1, 1),
schedule="@once"
) asdag:
@task.sql(conn_id="task-sql-decorator"# Transient connection defined in the UI )deftask_1():
return"SELECT 1;"task_1()

Testing

To run the unit tests that were authored for this decorator, the command below can be used:

breeze testing providers-tests providers/common/sql/tests/unit/common/sql/decorators/test_sql.py

The DAG above was also used to validate the functionality of the @task.sql decorator.

Other Notes

There will be additional documentation and examples that comes out of this initial pull request, with the goal of providing parity between this new decorator and the SQLExecuteQueryOperator. For now, this PR just provides the bare-bones.

kaxil

Looks good to me but worth checking how OL works with it.

cc @mobuchowski @kacpermuda

jroachgolf84 · 2026-02-15T02:01:50Z

@kaxil, what is the best way to test this? Do we have a framework in-place for this already?

potiuk · 2026-02-16T00:45:34Z

@kaxil, what is the best way to test this? Do we have a framework in-place for this already?

There is openlineage integration that starts Marquez I believe.

potiuk · 2026-02-16T00:46:05Z

Look at https://github.com/apache/airflow/blob/main/contributing-docs/testing/integration_tests.rst

kacpermuda

Looks good, thanks !

From the OL perspective, the Ol methods from SqlExecuteQueryOperator are executed, since PythonOperator does not have them. With the added type check in BaseSqlOperator's OL method, the *_on_start method does nothing, since we do not know SQL text before execution, and the *_on_complete behaves as the query was executed with the usual SqlExecuteQueryOperator which is good.

mobuchowski

I was going to look at OpenLineage impl, but @kacpermuda already did this - so I just have a few drive-by comments :)

@once

…0851) For DAG authors familiar with writing Python functions to do "something", the `@task` decorator is one of the most popular tools authoring logic in Airflow. There are several other decorators, such as `@task.bash`, `@task.kubernetes`, etc. that extend this functionality. However, there is no `@task.sql` decorator. This PR introduces the `@task.sql` decorator. This decorator is a wrapper around the `SQLExecuteQueryOperator`. However, the value returned from the Python function is the SQL query that is executed. Here's an example usage: ```python from airflow.sdk import DAG, task from datetime import datetime with DAG( dag_id="sql_deco", start_date=datetime(2025, 1, 1), schedule="@once" ) as dag: @task.sql( conn_id="task-sql-decorator" # Transient connection defined in the UI ) def task_1(): return "SELECT 1;" task_1() ```

@once

…0851) For DAG authors familiar with writing Python functions to do "something", the `@task` decorator is one of the most popular tools authoring logic in Airflow. There are several other decorators, such as `@task.bash`, `@task.kubernetes`, etc. that extend this functionality. However, there is no `@task.sql` decorator. This PR introduces the `@task.sql` decorator. This decorator is a wrapper around the `SQLExecuteQueryOperator`. However, the value returned from the Python function is the SQL query that is executed. Here's an example usage: ```python from airflow.sdk import DAG, task from datetime import datetime with DAG( dag_id="sql_deco", start_date=datetime(2025, 1, 1), schedule="@once" ) as dag: @task.sql( conn_id="task-sql-decorator" # Transient connection defined in the UI ) def task_1(): return "SELECT 1;" task_1() ```

@once

…0851) For DAG authors familiar with writing Python functions to do "something", the `@task` decorator is one of the most popular tools authoring logic in Airflow. There are several other decorators, such as `@task.bash`, `@task.kubernetes`, etc. that extend this functionality. However, there is no `@task.sql` decorator. This PR introduces the `@task.sql` decorator. This decorator is a wrapper around the `SQLExecuteQueryOperator`. However, the value returned from the Python function is the SQL query that is executed. Here's an example usage: ```python from airflow.sdk import DAG, task from datetime import datetime with DAG( dag_id="sql_deco", start_date=datetime(2025, 1, 1), schedule="@once" ) as dag: @task.sql( conn_id="task-sql-decorator" # Transient connection defined in the UI ) def task_1(): return "SELECT 1;" task_1() ```

@once

…0851) For DAG authors familiar with writing Python functions to do "something", the `@task` decorator is one of the most popular tools authoring logic in Airflow. There are several other decorators, such as `@task.bash`, `@task.kubernetes`, etc. that extend this functionality. However, there is no `@task.sql` decorator. This PR introduces the `@task.sql` decorator. This decorator is a wrapper around the `SQLExecuteQueryOperator`. However, the value returned from the Python function is the SQL query that is executed. Here's an example usage: ```python from airflow.sdk import DAG, task from datetime import datetime with DAG( dag_id="sql_deco", start_date=datetime(2025, 1, 1), schedule="@once" ) as dag: @task.sql( conn_id="task-sql-decorator" # Transient connection defined in the UI ) def task_1(): return "SELECT 1;" task_1() ```

@once

…0851) For DAG authors familiar with writing Python functions to do "something", the `@task` decorator is one of the most popular tools authoring logic in Airflow. There are several other decorators, such as `@task.bash`, `@task.kubernetes`, etc. that extend this functionality. However, there is no `@task.sql` decorator. This PR introduces the `@task.sql` decorator. This decorator is a wrapper around the `SQLExecuteQueryOperator`. However, the value returned from the Python function is the SQL query that is executed. Here's an example usage: ```python from airflow.sdk import DAG, task from datetime import datetime with DAG( dag_id="sql_deco", start_date=datetime(2025, 1, 1), schedule="@once" ) as dag: @task.sql( conn_id="task-sql-decorator" # Transient connection defined in the UI ) def task_1(): return "SELECT 1;" task_1() ```

jroachgolf84 · 2026-01-21T03:55:32Z

Description

For DAG authors familiar with writing Python functions to do "something", the @task decorator is one of the most popular tools authoring logic in Airflow. There are several other decorators, such as @task.bash, @task.kubernetes, etc. that extend this functionality. However, there is no @task.sql decorator.

This PR introduces the @task.sql decorator. This decorator is a wrapper around the SQLExecuteQueryOperator. However, the value returned from the Python function is the SQL query that is executed.

Here's an example usage:

fromairflow.sdkimportDAG, taskfromdatetimeimportdatetimewithDAG(
dag_id="sql_deco",
start_date=datetime(2025, 1, 1),
schedule="@once"
) asdag:
@task.sql(conn_id="task-sql-decorator"# Transient connection defined in the UI )deftask_1():
return"SELECT 1;"task_1()

Testing

To run the unit tests that were authored for this decorator, the command below can be used:

breeze testing providers-tests providers/common/sql/tests/unit/common/sql/decorators/test_sql.py

The DAG above was also used to validate the functionality of the @task.sql decorator.

Other Notes

There will be additional documentation and examples that comes out of this initial pull request, with the goal of providing parity between this new decorator and the SQLExecuteQueryOperator. For now, this PR just provides the bare-bones.

kaxil

Looks good to me but worth checking how OL works with it.

cc @mobuchowski @kacpermuda

jroachgolf84 · 2026-02-15T02:01:50Z

@kaxil, what is the best way to test this? Do we have a framework in-place for this already?

potiuk · 2026-02-16T00:45:34Z

@kaxil, what is the best way to test this? Do we have a framework in-place for this already?

There is openlineage integration that starts Marquez I believe.

potiuk · 2026-02-16T00:46:05Z

Look at https://github.com/apache/airflow/blob/main/contributing-docs/testing/integration_tests.rst

kacpermuda

Looks good, thanks !

From the OL perspective, the Ol methods from SqlExecuteQueryOperator are executed, since PythonOperator does not have them. With the added type check in BaseSqlOperator's OL method, the *_on_start method does nothing, since we do not know SQL text before execution, and the *_on_complete behaves as the query was executed with the usual SqlExecuteQueryOperator which is good.

mobuchowski

I was going to look at OpenLineage impl, but @kacpermuda already did this - so I just have a few drive-by comments :)

@once

…0851) For DAG authors familiar with writing Python functions to do "something", the `@task` decorator is one of the most popular tools authoring logic in Airflow. There are several other decorators, such as `@task.bash`, `@task.kubernetes`, etc. that extend this functionality. However, there is no `@task.sql` decorator. This PR introduces the `@task.sql` decorator. This decorator is a wrapper around the `SQLExecuteQueryOperator`. However, the value returned from the Python function is the SQL query that is executed. Here's an example usage: ```python from airflow.sdk import DAG, task from datetime import datetime with DAG( dag_id="sql_deco", start_date=datetime(2025, 1, 1), schedule="@once" ) as dag: @task.sql( conn_id="task-sql-decorator" # Transient connection defined in the UI ) def task_1(): return "SELECT 1;" task_1() ```

@once

…0851) For DAG authors familiar with writing Python functions to do "something", the `@task` decorator is one of the most popular tools authoring logic in Airflow. There are several other decorators, such as `@task.bash`, `@task.kubernetes`, etc. that extend this functionality. However, there is no `@task.sql` decorator. This PR introduces the `@task.sql` decorator. This decorator is a wrapper around the `SQLExecuteQueryOperator`. However, the value returned from the Python function is the SQL query that is executed. Here's an example usage: ```python from airflow.sdk import DAG, task from datetime import datetime with DAG( dag_id="sql_deco", start_date=datetime(2025, 1, 1), schedule="@once" ) as dag: @task.sql( conn_id="task-sql-decorator" # Transient connection defined in the UI ) def task_1(): return "SELECT 1;" task_1() ```

@once

…0851) For DAG authors familiar with writing Python functions to do "something", the `@task` decorator is one of the most popular tools authoring logic in Airflow. There are several other decorators, such as `@task.bash`, `@task.kubernetes`, etc. that extend this functionality. However, there is no `@task.sql` decorator. This PR introduces the `@task.sql` decorator. This decorator is a wrapper around the `SQLExecuteQueryOperator`. However, the value returned from the Python function is the SQL query that is executed. Here's an example usage: ```python from airflow.sdk import DAG, task from datetime import datetime with DAG( dag_id="sql_deco", start_date=datetime(2025, 1, 1), schedule="@once" ) as dag: @task.sql( conn_id="task-sql-decorator" # Transient connection defined in the UI ) def task_1(): return "SELECT 1;" task_1() ```

@once

…0851) For DAG authors familiar with writing Python functions to do "something", the `@task` decorator is one of the most popular tools authoring logic in Airflow. There are several other decorators, such as `@task.bash`, `@task.kubernetes`, etc. that extend this functionality. However, there is no `@task.sql` decorator. This PR introduces the `@task.sql` decorator. This decorator is a wrapper around the `SQLExecuteQueryOperator`. However, the value returned from the Python function is the SQL query that is executed. Here's an example usage: ```python from airflow.sdk import DAG, task from datetime import datetime with DAG( dag_id="sql_deco", start_date=datetime(2025, 1, 1), schedule="@once" ) as dag: @task.sql( conn_id="task-sql-decorator" # Transient connection defined in the UI ) def task_1(): return "SELECT 1;" task_1() ```

@once

…0851) For DAG authors familiar with writing Python functions to do "something", the `@task` decorator is one of the most popular tools authoring logic in Airflow. There are several other decorators, such as `@task.bash`, `@task.kubernetes`, etc. that extend this functionality. However, there is no `@task.sql` decorator. This PR introduces the `@task.sql` decorator. This decorator is a wrapper around the `SQLExecuteQueryOperator`. However, the value returned from the Python function is the SQL query that is executed. Here's an example usage: ```python from airflow.sdk import DAG, task from datetime import datetime with DAG( dag_id="sql_deco", start_date=datetime(2025, 1, 1), schedule="@once" ) as dag: @task.sql( conn_id="task-sql-decorator" # Transient connection defined in the UI ) def task_1(): return "SELECT 1;" task_1() ```

jroachgolf84 · 2026-01-21T03:55:32Z

Description

For DAG authors familiar with writing Python functions to do "something", the @task decorator is one of the most popular tools authoring logic in Airflow. There are several other decorators, such as @task.bash, @task.kubernetes, etc. that extend this functionality. However, there is no @task.sql decorator.

This PR introduces the @task.sql decorator. This decorator is a wrapper around the SQLExecuteQueryOperator. However, the value returned from the Python function is the SQL query that is executed.

Here's an example usage:

fromairflow.sdkimportDAG, taskfromdatetimeimportdatetimewithDAG(
dag_id="sql_deco",
start_date=datetime(2025, 1, 1),
schedule="@once"
) asdag:
@task.sql(conn_id="task-sql-decorator"# Transient connection defined in the UI )deftask_1():
return"SELECT 1;"task_1()

Testing

To run the unit tests that were authored for this decorator, the command below can be used:

breeze testing providers-tests providers/common/sql/tests/unit/common/sql/decorators/test_sql.py

The DAG above was also used to validate the functionality of the @task.sql decorator.

Other Notes

There will be additional documentation and examples that comes out of this initial pull request, with the goal of providing parity between this new decorator and the SQLExecuteQueryOperator. For now, this PR just provides the bare-bones.

kaxil

Looks good to me but worth checking how OL works with it.

cc @mobuchowski @kacpermuda

jroachgolf84 · 2026-02-15T02:01:50Z

@kaxil, what is the best way to test this? Do we have a framework in-place for this already?

potiuk · 2026-02-16T00:45:34Z

@kaxil, what is the best way to test this? Do we have a framework in-place for this already?

There is openlineage integration that starts Marquez I believe.

potiuk · 2026-02-16T00:46:05Z

Look at https://github.com/apache/airflow/blob/main/contributing-docs/testing/integration_tests.rst

kacpermuda

Looks good, thanks !

From the OL perspective, the Ol methods from SqlExecuteQueryOperator are executed, since PythonOperator does not have them. With the added type check in BaseSqlOperator's OL method, the *_on_start method does nothing, since we do not know SQL text before execution, and the *_on_complete behaves as the query was executed with the usual SqlExecuteQueryOperator which is good.

mobuchowski

I was going to look at OpenLineage impl, but @kacpermuda already did this - so I just have a few drive-by comments :)

@once

…0851) For DAG authors familiar with writing Python functions to do "something", the `@task` decorator is one of the most popular tools authoring logic in Airflow. There are several other decorators, such as `@task.bash`, `@task.kubernetes`, etc. that extend this functionality. However, there is no `@task.sql` decorator. This PR introduces the `@task.sql` decorator. This decorator is a wrapper around the `SQLExecuteQueryOperator`. However, the value returned from the Python function is the SQL query that is executed. Here's an example usage: ```python from airflow.sdk import DAG, task from datetime import datetime with DAG( dag_id="sql_deco", start_date=datetime(2025, 1, 1), schedule="@once" ) as dag: @task.sql( conn_id="task-sql-decorator" # Transient connection defined in the UI ) def task_1(): return "SELECT 1;" task_1() ```

@once

…0851) For DAG authors familiar with writing Python functions to do "something", the `@task` decorator is one of the most popular tools authoring logic in Airflow. There are several other decorators, such as `@task.bash`, `@task.kubernetes`, etc. that extend this functionality. However, there is no `@task.sql` decorator. This PR introduces the `@task.sql` decorator. This decorator is a wrapper around the `SQLExecuteQueryOperator`. However, the value returned from the Python function is the SQL query that is executed. Here's an example usage: ```python from airflow.sdk import DAG, task from datetime import datetime with DAG( dag_id="sql_deco", start_date=datetime(2025, 1, 1), schedule="@once" ) as dag: @task.sql( conn_id="task-sql-decorator" # Transient connection defined in the UI ) def task_1(): return "SELECT 1;" task_1() ```

@once

…0851) For DAG authors familiar with writing Python functions to do "something", the `@task` decorator is one of the most popular tools authoring logic in Airflow. There are several other decorators, such as `@task.bash`, `@task.kubernetes`, etc. that extend this functionality. However, there is no `@task.sql` decorator. This PR introduces the `@task.sql` decorator. This decorator is a wrapper around the `SQLExecuteQueryOperator`. However, the value returned from the Python function is the SQL query that is executed. Here's an example usage: ```python from airflow.sdk import DAG, task from datetime import datetime with DAG( dag_id="sql_deco", start_date=datetime(2025, 1, 1), schedule="@once" ) as dag: @task.sql( conn_id="task-sql-decorator" # Transient connection defined in the UI ) def task_1(): return "SELECT 1;" task_1() ```

@once

…0851) For DAG authors familiar with writing Python functions to do "something", the `@task` decorator is one of the most popular tools authoring logic in Airflow. There are several other decorators, such as `@task.bash`, `@task.kubernetes`, etc. that extend this functionality. However, there is no `@task.sql` decorator. This PR introduces the `@task.sql` decorator. This decorator is a wrapper around the `SQLExecuteQueryOperator`. However, the value returned from the Python function is the SQL query that is executed. Here's an example usage: ```python from airflow.sdk import DAG, task from datetime import datetime with DAG( dag_id="sql_deco", start_date=datetime(2025, 1, 1), schedule="@once" ) as dag: @task.sql( conn_id="task-sql-decorator" # Transient connection defined in the UI ) def task_1(): return "SELECT 1;" task_1() ```

@once

…0851) For DAG authors familiar with writing Python functions to do "something", the `@task` decorator is one of the most popular tools authoring logic in Airflow. There are several other decorators, such as `@task.bash`, `@task.kubernetes`, etc. that extend this functionality. However, there is no `@task.sql` decorator. This PR introduces the `@task.sql` decorator. This decorator is a wrapper around the `SQLExecuteQueryOperator`. However, the value returned from the Python function is the SQL query that is executed. Here's an example usage: ```python from airflow.sdk import DAG, task from datetime import datetime with DAG( dag_id="sql_deco", start_date=datetime(2025, 1, 1), schedule="@once" ) as dag: @task.sql( conn_id="task-sql-decorator" # Transient connection defined in the UI ) def task_1(): return "SELECT 1;" task_1() ```

jroachgolf84 · 2026-01-21T03:55:32Z

Description

For DAG authors familiar with writing Python functions to do "something", the @task decorator is one of the most popular tools authoring logic in Airflow. There are several other decorators, such as @task.bash, @task.kubernetes, etc. that extend this functionality. However, there is no @task.sql decorator.

This PR introduces the @task.sql decorator. This decorator is a wrapper around the SQLExecuteQueryOperator. However, the value returned from the Python function is the SQL query that is executed.

Here's an example usage:

fromairflow.sdkimportDAG, taskfromdatetimeimportdatetimewithDAG(
dag_id="sql_deco",
start_date=datetime(2025, 1, 1),
schedule="@once"
) asdag:
@task.sql(conn_id="task-sql-decorator"# Transient connection defined in the UI )deftask_1():
return"SELECT 1;"task_1()

Testing

To run the unit tests that were authored for this decorator, the command below can be used:

breeze testing providers-tests providers/common/sql/tests/unit/common/sql/decorators/test_sql.py

The DAG above was also used to validate the functionality of the @task.sql decorator.

Other Notes

There will be additional documentation and examples that comes out of this initial pull request, with the goal of providing parity between this new decorator and the SQLExecuteQueryOperator. For now, this PR just provides the bare-bones.

kaxil

Looks good to me but worth checking how OL works with it.

cc @mobuchowski @kacpermuda

jroachgolf84 · 2026-02-15T02:01:50Z

@kaxil, what is the best way to test this? Do we have a framework in-place for this already?

potiuk · 2026-02-16T00:45:34Z

@kaxil, what is the best way to test this? Do we have a framework in-place for this already?

There is openlineage integration that starts Marquez I believe.

potiuk · 2026-02-16T00:46:05Z

Look at https://github.com/apache/airflow/blob/main/contributing-docs/testing/integration_tests.rst

kacpermuda

Looks good, thanks !

From the OL perspective, the Ol methods from SqlExecuteQueryOperator are executed, since PythonOperator does not have them. With the added type check in BaseSqlOperator's OL method, the *_on_start method does nothing, since we do not know SQL text before execution, and the *_on_complete behaves as the query was executed with the usual SqlExecuteQueryOperator which is good.

mobuchowski

I was going to look at OpenLineage impl, but @kacpermuda already did this - so I just have a few drive-by comments :)

@once

…0851) For DAG authors familiar with writing Python functions to do "something", the `@task` decorator is one of the most popular tools authoring logic in Airflow. There are several other decorators, such as `@task.bash`, `@task.kubernetes`, etc. that extend this functionality. However, there is no `@task.sql` decorator. This PR introduces the `@task.sql` decorator. This decorator is a wrapper around the `SQLExecuteQueryOperator`. However, the value returned from the Python function is the SQL query that is executed. Here's an example usage: ```python from airflow.sdk import DAG, task from datetime import datetime with DAG( dag_id="sql_deco", start_date=datetime(2025, 1, 1), schedule="@once" ) as dag: @task.sql( conn_id="task-sql-decorator" # Transient connection defined in the UI ) def task_1(): return "SELECT 1;" task_1() ```

@once

…0851) For DAG authors familiar with writing Python functions to do "something", the `@task` decorator is one of the most popular tools authoring logic in Airflow. There are several other decorators, such as `@task.bash`, `@task.kubernetes`, etc. that extend this functionality. However, there is no `@task.sql` decorator. This PR introduces the `@task.sql` decorator. This decorator is a wrapper around the `SQLExecuteQueryOperator`. However, the value returned from the Python function is the SQL query that is executed. Here's an example usage: ```python from airflow.sdk import DAG, task from datetime import datetime with DAG( dag_id="sql_deco", start_date=datetime(2025, 1, 1), schedule="@once" ) as dag: @task.sql( conn_id="task-sql-decorator" # Transient connection defined in the UI ) def task_1(): return "SELECT 1;" task_1() ```

@once

…0851) For DAG authors familiar with writing Python functions to do "something", the `@task` decorator is one of the most popular tools authoring logic in Airflow. There are several other decorators, such as `@task.bash`, `@task.kubernetes`, etc. that extend this functionality. However, there is no `@task.sql` decorator. This PR introduces the `@task.sql` decorator. This decorator is a wrapper around the `SQLExecuteQueryOperator`. However, the value returned from the Python function is the SQL query that is executed. Here's an example usage: ```python from airflow.sdk import DAG, task from datetime import datetime with DAG( dag_id="sql_deco", start_date=datetime(2025, 1, 1), schedule="@once" ) as dag: @task.sql( conn_id="task-sql-decorator" # Transient connection defined in the UI ) def task_1(): return "SELECT 1;" task_1() ```

@once

…0851) For DAG authors familiar with writing Python functions to do "something", the `@task` decorator is one of the most popular tools authoring logic in Airflow. There are several other decorators, such as `@task.bash`, `@task.kubernetes`, etc. that extend this functionality. However, there is no `@task.sql` decorator. This PR introduces the `@task.sql` decorator. This decorator is a wrapper around the `SQLExecuteQueryOperator`. However, the value returned from the Python function is the SQL query that is executed. Here's an example usage: ```python from airflow.sdk import DAG, task from datetime import datetime with DAG( dag_id="sql_deco", start_date=datetime(2025, 1, 1), schedule="@once" ) as dag: @task.sql( conn_id="task-sql-decorator" # Transient connection defined in the UI ) def task_1(): return "SELECT 1;" task_1() ```

@once

…0851) For DAG authors familiar with writing Python functions to do "something", the `@task` decorator is one of the most popular tools authoring logic in Airflow. There are several other decorators, such as `@task.bash`, `@task.kubernetes`, etc. that extend this functionality. However, there is no `@task.sql` decorator. This PR introduces the `@task.sql` decorator. This decorator is a wrapper around the `SQLExecuteQueryOperator`. However, the value returned from the Python function is the SQL query that is executed. Here's an example usage: ```python from airflow.sdk import DAG, task from datetime import datetime with DAG( dag_id="sql_deco", start_date=datetime(2025, 1, 1), schedule="@once" ) as dag: @task.sql( conn_id="task-sql-decorator" # Transient connection defined in the UI ) def task_1(): return "SELECT 1;" task_1() ```

jroachgolf84 · 2026-01-21T03:55:32Z

Description

For DAG authors familiar with writing Python functions to do "something", the @task decorator is one of the most popular tools authoring logic in Airflow. There are several other decorators, such as @task.bash, @task.kubernetes, etc. that extend this functionality. However, there is no @task.sql decorator.

This PR introduces the @task.sql decorator. This decorator is a wrapper around the SQLExecuteQueryOperator. However, the value returned from the Python function is the SQL query that is executed.

Here's an example usage:

fromairflow.sdkimportDAG, taskfromdatetimeimportdatetimewithDAG(
dag_id="sql_deco",
start_date=datetime(2025, 1, 1),
schedule="@once"
) asdag:
@task.sql(conn_id="task-sql-decorator"# Transient connection defined in the UI )deftask_1():
return"SELECT 1;"task_1()

Testing

To run the unit tests that were authored for this decorator, the command below can be used:

breeze testing providers-tests providers/common/sql/tests/unit/common/sql/decorators/test_sql.py

The DAG above was also used to validate the functionality of the @task.sql decorator.

Other Notes

There will be additional documentation and examples that comes out of this initial pull request, with the goal of providing parity between this new decorator and the SQLExecuteQueryOperator. For now, this PR just provides the bare-bones.

kaxil

Looks good to me but worth checking how OL works with it.

cc @mobuchowski @kacpermuda

jroachgolf84 · 2026-02-15T02:01:50Z

@kaxil, what is the best way to test this? Do we have a framework in-place for this already?

potiuk · 2026-02-16T00:45:34Z

@kaxil, what is the best way to test this? Do we have a framework in-place for this already?

There is openlineage integration that starts Marquez I believe.

potiuk · 2026-02-16T00:46:05Z

Look at https://github.com/apache/airflow/blob/main/contributing-docs/testing/integration_tests.rst

kacpermuda

Looks good, thanks !

From the OL perspective, the Ol methods from SqlExecuteQueryOperator are executed, since PythonOperator does not have them. With the added type check in BaseSqlOperator's OL method, the *_on_start method does nothing, since we do not know SQL text before execution, and the *_on_complete behaves as the query was executed with the usual SqlExecuteQueryOperator which is good.

mobuchowski

I was going to look at OpenLineage impl, but @kacpermuda already did this - so I just have a few drive-by comments :)

@once

…0851) For DAG authors familiar with writing Python functions to do "something", the `@task` decorator is one of the most popular tools authoring logic in Airflow. There are several other decorators, such as `@task.bash`, `@task.kubernetes`, etc. that extend this functionality. However, there is no `@task.sql` decorator. This PR introduces the `@task.sql` decorator. This decorator is a wrapper around the `SQLExecuteQueryOperator`. However, the value returned from the Python function is the SQL query that is executed. Here's an example usage: ```python from airflow.sdk import DAG, task from datetime import datetime with DAG( dag_id="sql_deco", start_date=datetime(2025, 1, 1), schedule="@once" ) as dag: @task.sql( conn_id="task-sql-decorator" # Transient connection defined in the UI ) def task_1(): return "SELECT 1;" task_1() ```

@once

…0851) For DAG authors familiar with writing Python functions to do "something", the `@task` decorator is one of the most popular tools authoring logic in Airflow. There are several other decorators, such as `@task.bash`, `@task.kubernetes`, etc. that extend this functionality. However, there is no `@task.sql` decorator. This PR introduces the `@task.sql` decorator. This decorator is a wrapper around the `SQLExecuteQueryOperator`. However, the value returned from the Python function is the SQL query that is executed. Here's an example usage: ```python from airflow.sdk import DAG, task from datetime import datetime with DAG( dag_id="sql_deco", start_date=datetime(2025, 1, 1), schedule="@once" ) as dag: @task.sql( conn_id="task-sql-decorator" # Transient connection defined in the UI ) def task_1(): return "SELECT 1;" task_1() ```

@once

…0851) For DAG authors familiar with writing Python functions to do "something", the `@task` decorator is one of the most popular tools authoring logic in Airflow. There are several other decorators, such as `@task.bash`, `@task.kubernetes`, etc. that extend this functionality. However, there is no `@task.sql` decorator. This PR introduces the `@task.sql` decorator. This decorator is a wrapper around the `SQLExecuteQueryOperator`. However, the value returned from the Python function is the SQL query that is executed. Here's an example usage: ```python from airflow.sdk import DAG, task from datetime import datetime with DAG( dag_id="sql_deco", start_date=datetime(2025, 1, 1), schedule="@once" ) as dag: @task.sql( conn_id="task-sql-decorator" # Transient connection defined in the UI ) def task_1(): return "SELECT 1;" task_1() ```

@once

…0851) For DAG authors familiar with writing Python functions to do "something", the `@task` decorator is one of the most popular tools authoring logic in Airflow. There are several other decorators, such as `@task.bash`, `@task.kubernetes`, etc. that extend this functionality. However, there is no `@task.sql` decorator. This PR introduces the `@task.sql` decorator. This decorator is a wrapper around the `SQLExecuteQueryOperator`. However, the value returned from the Python function is the SQL query that is executed. Here's an example usage: ```python from airflow.sdk import DAG, task from datetime import datetime with DAG( dag_id="sql_deco", start_date=datetime(2025, 1, 1), schedule="@once" ) as dag: @task.sql( conn_id="task-sql-decorator" # Transient connection defined in the UI ) def task_1(): return "SELECT 1;" task_1() ```

@once

…0851) For DAG authors familiar with writing Python functions to do "something", the `@task` decorator is one of the most popular tools authoring logic in Airflow. There are several other decorators, such as `@task.bash`, `@task.kubernetes`, etc. that extend this functionality. However, there is no `@task.sql` decorator. This PR introduces the `@task.sql` decorator. This decorator is a wrapper around the `SQLExecuteQueryOperator`. However, the value returned from the Python function is the SQL query that is executed. Here's an example usage: ```python from airflow.sdk import DAG, task from datetime import datetime with DAG( dag_id="sql_deco", start_date=datetime(2025, 1, 1), schedule="@once" ) as dag: @task.sql( conn_id="task-sql-decorator" # Transient connection defined in the UI ) def task_1(): return "SELECT 1;" task_1() ```

task-sql-decorator: Introducing the @task.sql decorator
accb1b8

boring-cyborgBot added area:providers provider:common-sql labels Jan 21, 2026

jroachgolf84and others added 10 commits February 3, 2026 18:23

Merge branch 'apache:main' into task-sql-decorator
8ddda9d

task-sql-decorator: Completing unit-tests for@SQL
15c9081

task-sql-decorator: Fixing prek issues
cdc3ebe

Merge branch 'main' into task-sql-decorator
5ba2326

task-sql-decorator: Adding examples and documentation
2f0f42a

Merge branch 'main' into task-sql-decorator
f0d8d96

task-sql-decorator: Fixing CI failures
ac5a504

task-sql-decorator: Updating dependencies to include sqlite
706c15d

task-sql-decorator: Updating unit-tests
36bfb45

task-sql-decorator: Handle compat issues
70fe2d9

jroachgolf84 marked this pull request as ready for review February 9, 2026 15:08

Merge branch 'main' into task-sql-decorator
d35864b

jroachgolf84 requested review from dstandish and kaxil February 9, 2026 18:34

kaxil approved these changes Feb 13, 2026
View reviewed changes

kacpermuda reviewed Feb 16, 2026
View reviewed changes

Comment threadproviders/common/sql/src/airflow/providers/common/sql/decorators/sql.py Outdated

kacpermuda reviewed Feb 16, 2026
View reviewed changes

Comment threadproviders/common/sql/src/airflow/providers/common/sql/decorators/sql.py

jroachgolf84and others added 2 commits February 16, 2026 07:56

Merge branch 'main' into task-sql-decorator
8083b30

task-sql-decorator: Handling invalid sql values
f325128

kacpermuda approved these changes Feb 16, 2026
View reviewed changes

mobuchowski approved these changes Feb 16, 2026
View reviewed changes

Comment threadproviders/common/sql/tests/system/common/sql/example_sql_execute_query.py
Comment threadproviders/common/sql/src/airflow/providers/common/sql/decorators/sql.py
Comment threadproviders/common/sql/src/airflow/providers/common/sql/decorators/sql.py

task-sql-decorator: Improving example
12e9b4c

kaxil merged commit e9021db into apache:mainFeb 16, 2026
101 checks passed

eladkal mentioned this pull request Feb 20, 2026
Status of testing Providers that were prepared on February 20, 2026 #62219
Closed
6 tasks

potiuk mentioned this pull request Feb 26, 2026
Status of testing Providers that were prepared on February 26, 2026 #62537
Closed