SQL Operators¶
These operators perform various queries against a SQL database, including column- and table-level data quality checks.
Execute SQL query¶
Use the SQLExecuteQueryOperator to run SQL query against
different databases. Parameters of the operators are:
sql- single string, list of strings or string pointing to a template file to be executed;autocommit(optional) if True, each command is automatically committed (default: False);parameters(optional) the parameters to render the SQL query with.handler(optional) the function that will be applied to the cursor. If it’sNoneresults won’t returned (default: fetch_all_handler).split_statements(optional) if split single SQL string into statements and run separately (default: False).return_last(optional) dependssplit_statementsand if it’sTruethis parameter is used to return the result of only last statement or all split statements (default: True).
The example below shows how to instantiate the SQLExecuteQueryOperator task.
execute_query = SQLExecuteQueryOperator(
task_id="execute_query",
sql=f"SELECT 1; SELECT * FROM {AIRFLOW_DB_METADATA_TABLE} LIMIT 1;",
split_statements=True,
return_last=False,
)
The @task.sql decorator can also be used to execute a SQL query (or queries). The code below executes the same
queries as the snippet above, but this time, using the TaskFlow API. Using @task.sql provides a way for DAG authors
to dynamically build SQL queries without having to worry about top-level code. The string returns from the function
(in this case, execute_query_taskflow) is the query/queries that are executed.
@task.sql(split_statements=True, return_last=False)
def execute_query_taskflow():
return f"SELECT 1; SELECT * FROM {AIRFLOW_DB_METADATA_TABLE} LIMIT 1;"
execute_query_taskflow()
Check SQL Table Columns¶
Use the SQLColumnCheckOperator to run data quality
checks against columns of a given table. As well as a connection ID and table, a column_mapping
describing the relationship between columns and tests to run must be supplied. An example column mapping
is a set of three nested dictionaries and looks like:
column_mapping = {
"col_name": {
"null_check": {"equal_to": 0, "partition_clause": "other_col LIKE 'this'"},
"min": {
"greater_than": 5,
"leq_to": 10,
"tolerance": 0.2,
},
"max": {"less_than": 1000, "geq_to": 10, "tolerance": 0.01},
}
}
Where col_name is the name of the column to run checks on, and each entry in its dictionary is a check. The valid checks are:
null_check: checks the number of NULL values in the column
distinct_check: checks the COUNT of values in the column that are distinct
unique_check: checks the number of distinct values in a column against the number of rows
min: checks the minimum value in the column
max: checks the maximum value in the column
Each entry in the check’s dictionary is either a condition for success of the check, the tolerance, or a partition clause. The conditions for success are:
greater_than
geq_to
less_than
leq_to
equal_to
When specifying conditions, equal_to is not compatible with other conditions. Both a lower- and an upper- bound condition may be specified in the same check. The tolerance is a percentage that the result may be out of bounds but still considered successful.
The partition clauses may be given at the operator level as a parameter where it partitions all checks, at the column level in the column mapping where it partitions all checks for that column, or at the check level for a column where it partitions just that check.
A database may also be specified if not using the database from the supplied connection.
The accept_none argument, true by default, will convert None values returned by the query to 0s, allowing empty tables to return valid integers.
The below example demonstrates how to instantiate the SQLColumnCheckOperator task.
column_check = SQLColumnCheckOperator(
task_id="column_check",
table=AIRFLOW_DB_METADATA_TABLE,
column_mapping={
"id": {
"null_check": {
"equal_to": 0,
"tolerance": 0,
},
"distinct_check": {
"equal_to": 1,
},
}
},
)
Check SQL Table Values¶
Use the SQLTableCheckOperator to run data quality
checks against a given table. As well as a connection ID and table, a checks dictionary
describing the relationship between the table and tests to run must be supplied. An example
checks argument is a set of two nested dictionaries and looks like:
checks = (
{
"row_count_check": {
"check_statement": "COUNT(*) = 1000",
},
"column_sum_check": {
"check_statement": "col_a + col_b < col_c",
"partition_clause": "col_a IS NOT NULL",
},
},
)
The first set of keys are the check names, which are referenced in the templated query the operator builds. A dictionary key under the check name must include check_statement and the value a SQL statement that resolves to a boolean (this can be any string or int that resolves to a boolean in airflow.operators.sql.parse_boolean). The other possible key to supply is partition_clause, which is a check level statement that will partition the data in the table using a WHERE clause for that check. This statement is compatible with the parameter partition_clause, where the latter filters across all checks.
The below example demonstrates how to instantiate the SQLTableCheckOperator task.
row_count_check = SQLTableCheckOperator(
task_id="row_count_check",
table=AIRFLOW_DB_METADATA_TABLE,
checks={
"row_count_check": {
"check_statement": "COUNT(*) = 1",
}
},
)
Check value against expected¶
Use the SQLValueCheckOperator to compare a SQL query result
against an expected value, with some optionally specified tolerance for numeric results.
The parameters for this operator are:
sql- the sql query to be executed, as a templated string.pass_value- the expected value to compare the query result against.tolerance(optional) - numerical tolerance for comparisons involving numeric values.conn_id(optional) - the connection ID used to connect to the database.database(optional) - name of the database which overwrites the name defined in the connection.
The below example demonstrates how to instantiate the SQLValueCheckOperator task.
value_check = SQLValueCheckOperator(
task_id="threshhold_check",
conn_id="sales_db",
sql="SELECT count(distinct(customer_id)) FROM sales LIMIT 50;",
pass_value=40,
tolerance=5,
)
Check values against a threshold¶
Use the SQLThresholdCheckOperator to compare a specific SQL query result against defined minimum and maximum thresholds.
Both thresholds can either be a numeric value or another SQL query that evaluates to a numeric value.
This operator requires a connection ID, along with the SQL query to execute, and allows optional specification of a database, if the one from the connection_id should be overridden.
The parameters are:
- sql - the sql query to be executed, as a templated string.
- min_threshold The minimum threshold that is checked against. Either as a numeric value or templated sql query.
- max_threshold The maximum threshold that is checked against. Either as a numeric value or templated sql query.
- conn_id (optional) The connection ID used to connect to the database.
- database (optional) name of the database which overwrites the one from the connection.
The below example demonstrates how to instantiate the SQLThresholdCheckOperator task.
threshhold_check = SQLThresholdCheckOperator(
task_id="threshhold_check",
conn_id="sales_db",
sql="SELECT count(distinct(customer_id)) FROM sales;",
min_threshold=1,
max_threshold=1000,
)
If the value returned by the query, is within the thresholds, the task passes. Otherwise, it fails.
Insert rows into Table¶
Use the SQLInsertRowsOperator to insert rows into a database table
directly from Python data structures or an XCom. Parameters of the operator are:
table_name- name of the table in which the rows will be inserted (templated).conn_id- the Airflow connection ID used to connect to the database.schema(optional) - the schema in which the table is defined.database(optional) - name of the database which overrides the one defined in the connection.columns(optional) - list of columns to use for the insert when passing a list of dictionaries.ignored_columns(optional) - list of columns to ignore for the insert, if no columns are specified, columns will be dynamically resolved from the metadata.rows- rows to insert, a list of tuples.rows_processor(optional) - a function applied to the rows before inserting them.preoperator(optional) - SQL statement or list of statements to execute before inserting data (templated).postoperator(optional) - SQL statement or list of statements to execute after inserting data (templated).hook_params(optional) - dictionary of additional parameters passed to the underlying hook.insert_args(optional) - dictionary of additional arguments passed to the hook’sinsert_rowsmethod, can includereplace,executemany,fast_executemany,autocommit, and others supported by the hook.
The example below shows how to instantiate the SQLInsertRowsOperator task.
insert_rows = SQLInsertRowsOperator(
task_id="insert_rows",
table_name="actors",
columns=[
"name",
"firstname",
"age",
],
rows=[
("Stallone", "Sylvester", 78),
("Statham", "Jason", 57),
("Li", "Jet", 61),
("Lundgren", "Dolph", 66),
("Norris", "Chuck", 84),
],
preoperator=[
"""
CREATE TABLE IF NOT EXISTS actors (
index BIGINT PRIMARY KEY GENERATED ALWAYS AS IDENTITY,
name TEXT NOT NULL,
firstname TEXT NOT NULL,
age BIGINT NOT NULL
);
""",
"TRUNCATE TABLE actors;",
],
postoperator="DROP TABLE IF EXISTS actors;",
insert_args={
"commit_every": 1000,
"autocommit": False,
"executemany": True,
"fast_executemany": True,
},
)
Generic Transfer¶
Use the GenericTransfer to transfer data between
between two connections.
sql = "SELECT * FROM connection LIMIT 10;"
generic_transfer = GenericTransfer(
task_id="generic_transfer",
preoperator=[
"DROP TABLE IF EXISTS test_mysql_to_mysql",
"CREATE TABLE IF NOT EXISTS test_mysql_to_mysql LIKE connection",
],
source_conn_id="airflow_db",
destination_conn_id="airflow_db",
destination_table="test_mysql_to_mysql",
sql=sql,
)
Analytics Operator¶
The Analytics operator is designed to run analytic queries on data stored in various datastores. It is a generic operator that can query data in S3, GCS, Azure, and Local File System.
When to Use Analytics Operator¶
The Analytics Operator is ideal for performing efficient, high-performance analytics on large volumes of data across various storage systems. Under the hood, it uses Apache DataFusion, a high-performance, extensible query engine for Apache Arrow, which enables fast SQL queries on various data formats and storage systems. DataFusion is chosen for its ability to handle large-scale data processing on a single node, providing low-latency analytics without the need for a full database setup and without the need for high compute clusters. For more on Analytics Operator with DataFusion use cases, see https://datafusion.apache.org/user-guide/introduction.html#use-cases.
Supported Storage Systems¶
S3
Local File System
Note
GCS, Azure, HTTP, Delta, Iceberg are not yet supported but will be added in the future.
Supported File Formats¶
Parquet
CSV
Avro
Use the AnalyticsOperator to run analytic queries.
Parameters¶
datasource_configs(list[DataSourceConfig], required): List of datasource configurationsqueries(list[str], required): List of SQL queries to run on the datamax_rows_check(int, optional): Maximum number of rows to check for each query. Default is 100. If any query returns more than this number of rows, it will be skipped in the results returned by the operator. This is to prevent returning too many rows in the results which can cause xcom rendering issues in Airflow UI.engine(DataFusionEngine, optional): Query engine to use. Default is “datafusion”. Currently, only “datafusion” is supported.result_output_format(str, optional): Output format for the results. Default istabulate. Supported formats aretabulate,json.
DataSourceConfig Parameters¶
conn_id(str, required): Connection ID of the storage. e.g: “aws_default” for S3.uri(str, required): URI of the datasource.format(str, required): Format of the data.table_name(str, required): Name of the table. Note: This name can be any identifier and should match the table name used in the SQL queries.db_name(str, optional): Name of the database. Default is None. Ideally this is for catalog based storages like iceberg, provide the database name here and it will be used to fetch the table metadata.storage_type(StorageType, optional): Type of storage. Default is None. If not provided, it will be inferred from the URI.options(dict, optional): Additional options for the datasource. eg: if the datasource is partitioned, you can provide partitioning information in the options, e.g:{"table_partition_cols": [("year", "integer")]}look at here for more options: <https://datafusion.apache.org/python/autoapi/datafusion/context/index.html#datafusion.context.SessionContext>_.
S3 Storage¶
analytics_with_s3 = AnalyticsOperator(
task_id="analytics_with_s3",
datasource_configs=[datasource_config_s3],
queries=["SELECT * FROM users_data", "SELECT count(*) FROM users_data"],
)
Local File System Storage¶
analytics_with_local = AnalyticsOperator(
task_id="analytics_with_local",
datasource_configs=[datasource_config_local],
queries=["SELECT * FROM users_data", "SELECT count(*) FROM users_data"],
)
analytics_with_s3 >> analytics_with_local
Analytics TaskFlow Decorator¶
The @task.analytics decorator lets you write a function that returns the
analytics sql queries:
@task.analytics(datasource_configs=[datasource_config_s3])
def get_user_summary_queries():
return ["SELECT * FROM users_data LIMIT 10", "SELECT count(*) FROM users_data"]
Analytics with Iceberg¶
@task.analytics(datasource_configs=[datasource_config_iceberg])
def get_users_product_queries_from_iceberg_catalog():
return ["SELECT * FROM users_data LIMIT 10", "SELECT count(*) FROM users_data"]