repo_id stringclasses 409
values | prefix large_stringlengths 34 36.3k | target large_stringlengths 1 498 | assertion_type stringclasses 31
values | difficulty stringclasses 8
values | test_file stringlengths 10 121 | test_function stringlengths 1 104 | test_class stringlengths 0 51 | lineno int32 2 11.3k | commit_idx int32 |
|---|---|---|---|---|---|---|---|---|---|
reata/sqllineage | from sqllineage.utils.entities import ColumnQualifierTuple
from ...helpers import assert_column_lineage_equal
def test_column_reference_from_cte_using_qualifier():
sql = """WITH wtab1 AS (SELECT col1 FROM tab2)
INSERT INTO tab1
SELECT wtab1.col1 FROM wtab1"""
asse | [(ColumnQualifierTuple("col1", "tab2"), ColumnQualifierTuple("col1", "tab1"))]) | assert_* | collection | tests/sql/column/test_column_select_from_cte.py | test_column_reference_from_cte_using_qualifier | 10 | null | |
reata/sqllineage | import pytest
from sqlparse.sql import Parenthesis
from sqllineage.core.models import Column, Path, Schema, SubQuery, Table
from sqllineage.exceptions import SQLLineageException
def test_hash_eq():
assert Schema("a") == Schema("a")
assert len({Schema("a"), Schema("a")}) == | 1 | assert | numeric_literal | tests/core/test_models.py | test_hash_eq | 23 | null | |
reata/sqllineage | from ...helpers import assert_table_lineage_equal
def test_non_reserved_keyword_as_target():
asse | {"host"}) | assert_* | collection | tests/sql/table/test_insert.py | test_non_reserved_keyword_as_target | 41 | null | |
reata/sqllineage | import pytest
from ...helpers import assert_table_lineage_equal
@pytest.mark.parametrize("dialect", ["bigquery"])
def test_merge_without_into(dialect: str):
"""
INTO is optional in BigQuery MERGE statement:
https://cloud.google.com/bigquery/docs/reference/standard-sql/dml-syntax#merge_statement
"""
... | {"target"}) | assert_* | collection | tests/sql/table/test_merge_dialect_specific.py | test_merge_without_into | 15 | null | |
reata/sqllineage | from ...helpers import assert_table_lineage_equal
def test_cte_and_union_but_not_selecting_from_cte():
# issue #398
sql = """WITH cte_1 AS (select col1 from tab1)
SELECT col2 from tab2
UNION
SELECT col3 from tab3"""
asse | {"tab1", "tab2", "tab3"}) | assert_* | collection | tests/sql/table/test_cte.py | test_cte_and_union_but_not_selecting_from_cte | 95 | null | |
reata/sqllineage | from sqllineage.utils.entities import ColumnQualifierTuple
from ...helpers import assert_column_lineage_equal
def test_column_reference_with_ansi89_join():
sql = """INSERT INTO tab3
SELECT a.id,
a.name AS name1,
b.name AS name2
FROM (SELECT id, name
FROM tab1) a,
(SELECT id, name
FR... | [ (ColumnQualifierTuple("id", "tab1"), ColumnQualifierTuple("id", "tab3")), ( ColumnQualifierTuple("name", "tab1"), ColumnQualifierTuple("name1", "tab3"), ), ( ColumnQualifierTuple("name", "tab2"), ColumnQualifierTuple("name2", "tab3"), ), ]) | assert_* | collection | tests/sql/column/test_column_select_from_join.py | test_column_reference_with_ansi89_join | 118 | null | |
reata/sqllineage | import pytest
from ...helpers import assert_table_lineage_equal
@pytest.mark.parametrize(
"dialect",
["db2", "duckdb", "greenplum", "materialize", "oracle", "postgres", "snowflake"],
)
def test_select_from_lateral_subqueries(dialect: str):
"""
db2: https://www.ibm.com/docs/en/informix-servers/12.10?to... | {"manufacturers"}) | assert_* | collection | tests/sql/table/test_select_dialect_specific.py | test_select_from_lateral_subqueries | 121 | null | |
reata/sqllineage | from sqllineage.utils.entities import ColumnQualifierTuple
from ...helpers import assert_column_lineage_equal
def test_select_column_using_window_function():
sql = """INSERT INTO tab1
SELECT row_number() over (partition BY col1 ORDER BY col2 DESC) AS rnum
FROM tab2"""
asse | [ ( ColumnQualifierTuple("col1", "tab2"), ColumnQualifierTuple("rnum", "tab1"), ), ( ColumnQualifierTuple("col2", "tab2"), ColumnQualifierTuple("rnum", "tab1"), ), ]) | assert_* | collection | tests/sql/column/test_column_select_function.py | test_select_column_using_window_function | 63 | null | |
reata/sqllineage | from sqllineage.utils.entities import ColumnQualifierTuple
from ...helpers import assert_column_lineage_equal
def test_select_column_using_expression_in_parenthesis():
sql = """INSERT INTO tab1
SELECT (col1 + col2)
FROM tab2"""
asse | [ ( ColumnQualifierTuple("col1", "tab2"), ColumnQualifierTuple("(col1 + col2)", "tab1"), ), ( ColumnQualifierTuple("col2", "tab2"), ColumnQualifierTuple("(col1 + col2)", "tab1"), ), ]) | assert_* | collection | tests/sql/column/test_column_select_expression.py | test_select_column_using_expression_in_parenthesis | 60 | null | |
reata/sqllineage | import concurrent.futures
import os
import random
import time
from unittest.mock import patch
import pytest
from sqllineage.config import SQLLineageConfig
from sqllineage.exceptions import ConfigException
from sqllineage.runner import LineageRunner
def _check_schema(schema: str):
# used by test_config_parallel, ... | schemas[i] | assert | complex_expr | tests/core/test_config.py | test_config_parallel | 81 | null | |
reata/sqllineage | from ...helpers import assert_table_lineage_equal
def test_insert_into_qualified_table_with_parenthesized_query():
"""
For sqlparse, it will work if:
1) table in unqualified
OR 2) query is not surrounded by parenthesis
With both in the game, it breaks.
"""
sql = """INSERT INTO default.... | {"default.tab2"}) | assert_* | collection | tests/sql/table/test_insert.py | test_insert_into_qualified_table_with_parenthesized_query | 59 | null | |
reata/sqllineage | import pytest
from sqllineage.utils.entities import ColumnQualifierTuple
from ...helpers import assert_column_lineage_equal
@pytest.mark.parametrize(
"dtype", ["string", "timestamp", "date", "decimal(18, 0)", "varchar(255)"]
)
def test_cast_to_data_type(dtype: str):
sql = f"""INSERT INTO tab1
SELECT cast(col... | [(ColumnQualifierTuple("col1", "tab2"), ColumnQualifierTuple("col1", "tab1"))]) | assert_* | collection | tests/sql/column/test_column_select_cast.py | test_cast_to_data_type | 60 | null | |
reata/sqllineage | import pytest
from ...helpers import assert_table_lineage_equal
@pytest.mark.parametrize("dialect", ["postgres", "redshift"])
def test_analyze_table_column(dialect: str):
assert_table_lineage_equal( | "analyze tab (col1, col2)") | assert_* | string_literal | tests/sql/table/test_other_without_lineage_dialect_specific.py | test_analyze_table_column | 123 | null | |
reata/sqllineage | import pytest
from sqllineage.core.metadata_provider import MetaDataProvider
from sqllineage.utils.entities import ColumnQualifierTuple
from ...helpers import assert_column_lineage_equal, generate_metadata_providers
providers = generate_metadata_providers(
{
"db1.table1": ["id", "a", "b", "c", "d"],
... | [ ( ColumnQualifierTuple("id", "db1.table1"), ColumnQualifierTuple("id", "db.tbl"), ), ( ColumnQualifierTuple("a", "db1.table1"), ColumnQualifierTuple("x", "db.tbl"), ), ( ColumnQualifierTuple("b", "db1.table1"), ColumnQualifierTuple("b", "db.tbl"), ), ( ColumnQualifierTuple("h", "db2.table2"), ColumnQualifierTuple("h"... | assert_* | collection | tests/sql/column/test_metadata_unqualified_column.py | test_select_column_from_tables | 24 | null | |
reata/sqllineage | import os
from unittest.mock import patch
import pytest
from sqllineage import SQLPARSE_DIALECT
from sqllineage.exceptions import (
InvalidSyntaxException,
SQLLineageException,
UnsupportedStatementException,
)
from sqllineage.runner import LineageRunner
def test_select_without_table():
with pytest.r... | SQLLineageException) | pytest.raises | variable | tests/core/test_exception.py | test_select_without_table | 16 | null | |
reata/sqllineage | from sqllineage.utils.entities import ColumnQualifierTuple
from ...helpers import assert_column_lineage_equal
def test_select_column():
sql = """INSERT INTO tab1
SELECT col1
FROM tab2"""
assert_column_lineage_equal(
sql,
[(ColumnQualifierTuple("col1", "tab2"), ColumnQualifierTuple("col1", "tab... | [(ColumnQualifierTuple("col1", "tab2"), ColumnQualifierTuple("col2", "tab1"))]) | assert_* | collection | tests/sql/column/test_column_select_column.py | test_select_column | 17 | null | |
reata/sqllineage | import pytest
from sqllineage.core.metadata_provider import MetaDataProvider
from sqllineage.utils.entities import ColumnQualifierTuple
from ...helpers import assert_column_lineage_equal, generate_metadata_providers
providers = generate_metadata_providers(
{
"db1.table1": ["id", "a", "b", "c", "d"],
... | [ ( ColumnQualifierTuple("a", "db1.table1"), ColumnQualifierTuple("a", "db.tbl"), ), ( ColumnQualifierTuple("b", "db1.table1"), ColumnQualifierTuple("x", "db.tbl"), ), ( ColumnQualifierTuple("h", "db2.table2"), ColumnQualifierTuple("h", "db.tbl"), ), ( ColumnQualifierTuple("j", "db2.table2"), ColumnQualifierTuple("y", ... | assert_* | collection | tests/sql/column/test_metadata_unqualified_column.py | test_select_column_from_subqueries | 101 | null | |
reata/sqllineage | import concurrent.futures
import os
import random
import time
from unittest.mock import patch
import pytest
from sqllineage.config import SQLLineageConfig
from sqllineage.exceptions import ConfigException
from sqllineage.runner import LineageRunner
@patch.dict(
os.environ,
{
"SQLLINEAGE_DIRECTORY": o... | bool | assert | variable | tests/core/test_config.py | test_config | 29 | null | |
reata/sqllineage | import pytest
from ...helpers import assert_table_lineage_equal
@pytest.mark.parametrize("dialect", ["postgres", "redshift"])
def test_analyze_table(dialect: str):
assert_table_lineage_equal( | "analyze tab") | assert_* | string_literal | tests/sql/table/test_other_without_lineage_dialect_specific.py | test_analyze_table | 118 | null | |
reata/sqllineage | import os
import pytest
from sqllineage.core.metadata.sqlalchemy import SQLAlchemyMetaDataProvider
from sqllineage.exceptions import MetaDataProviderException
def test_sqlalchemy_metadata_provider_connection_fail():
# connect to a directory as sqlite db, which is not possible. Simulate connection failure
wi... | MetaDataProviderException) | pytest.raises | variable | tests/core/test_metadata_provider.py | test_sqlalchemy_metadata_provider_connection_fail | 11 | null | |
reata/sqllineage | from sqllineage.utils.entities import ColumnQualifierTuple
from ...helpers import assert_column_lineage_equal
def test_select_column():
sql = """INSERT INTO tab1
SELECT col1
FROM tab2"""
asse | [(ColumnQualifierTuple("col1", "tab2"), ColumnQualifierTuple("col1", "tab1"))]) | assert_* | collection | tests/sql/column/test_column_select_column.py | test_select_column | 10 | null | |
reata/sqllineage | import pytest
from sqlparse.sql import Parenthesis
from sqllineage.core.models import Column, Path, Schema, SubQuery, Table
from sqllineage.exceptions import SQLLineageException
def test_repr_dummy():
assert repr(Schema())
assert repr(Table(""))
assert repr(Table("a.b.c"))
assert repr(SubQuery(Parenth... | SQLLineageException) | pytest.raises | variable | tests/core/test_models.py | test_repr_dummy | 15 | null | |
reata/sqllineage | import pytest
from sqllineage.core.metadata_provider import MetaDataProvider
from sqllineage.utils.entities import ColumnQualifierTuple
from ...helpers import assert_column_lineage_equal, generate_metadata_providers
providers = generate_metadata_providers(
{
"db.tbl_x": ["id", "a", "b"],
"db.tbl_... | [ ( ColumnQualifierTuple("a", "db.tbl_x"), ColumnQualifierTuple("a", "<default>.test_v"), ), ( ColumnQualifierTuple("h", "db.tbl_y"), ColumnQualifierTuple("h", "<default>.test_v"), ), ]) | assert_* | collection | tests/sql/column/test_metadata_wildcard.py | test_select_table_join_multiple_wildcards | 187 | null | |
reata/sqllineage | import os
from unittest.mock import patch
import pytest
from sqllineage.core.metadata_provider import MetaDataProvider
from sqllineage.utils.entities import ColumnQualifierTuple
from ...helpers import assert_column_lineage_equal, generate_metadata_providers
providers = generate_metadata_providers(
{
"pu... | [ ( ColumnQualifierTuple("alias1", "public.src_tbl1"), ColumnQualifierTuple("name", "public.tgt_tbl1"), ), ( ColumnQualifierTuple("b", "public.src_tbl1"), ColumnQualifierTuple("name", "public.tgt_tbl1"), ), ]) | assert_* | collection | tests/sql/column/test_column_select_lateral_alias_ref.py | test_column_disable_lateral_ref_within_subquery | 463 | null | |
reata/sqllineage | import pytest
from sqllineage.core.metadata_provider import MetaDataProvider
from sqllineage.utils.entities import ColumnQualifierTuple
from ...helpers import assert_column_lineage_equal, generate_metadata_providers
providers = generate_metadata_providers(
{
"db.tbl_x": ["id", "a", "b"],
"db.tbl_... | [ ( ColumnQualifierTuple("a", "db.tbl_x"), ColumnQualifierTuple("a", "<default>.test_v"), ), ( ColumnQualifierTuple("id", "db.tbl_y"), ColumnQualifierTuple("id", "<default>.test_v"), ), ( ColumnQualifierTuple("h", "db.tbl_y"), ColumnQualifierTuple("h", "<default>.test_v"), ), ]) | assert_* | collection | tests/sql/column/test_metadata_wildcard.py | test_select_table_join_partial_wildcard_at_last | 129 | null | |
reata/sqllineage | import os
from unittest.mock import patch
import pytest
from sqllineage.core.metadata_provider import MetaDataProvider
from sqllineage.utils.entities import ColumnQualifierTuple
from ...helpers import assert_column_lineage_equal, generate_metadata_providers
providers = generate_metadata_providers(
{
"pu... | [ ( ColumnQualifierTuple("name", "public.src_tbl1"), ColumnQualifierTuple("user_name", "public.tgt_tbl1"), ), ( ColumnQualifierTuple("user_name", "public.src_tbl1"), ColumnQualifierTuple("id", "public.tgt_tbl1"), ), ( ColumnQualifierTuple("email", "public.src_tbl1"), ColumnQualifierTuple("id", "public.tgt_tbl1"), ), ]) | assert_* | collection | tests/sql/column/test_column_select_lateral_alias_ref.py | test_column_top_level_disable_lateral_ref | 336 | null | |
reata/sqllineage | import os
from unittest.mock import patch
import pytest
from sqllineage import SQLPARSE_DIALECT
from sqllineage.exceptions import (
InvalidSyntaxException,
SQLLineageException,
UnsupportedStatementException,
)
from sqllineage.runner import LineageRunner
def test_full_unparsable_query_in_sqlfluff():
... | InvalidSyntaxException) | pytest.raises | variable | tests/core/test_exception.py | test_full_unparsable_query_in_sqlfluff | 23 | null | |
reata/sqllineage | from sqllineage.utils.entities import ColumnQualifierTuple
from ...helpers import assert_column_lineage_equal
def test_merge_into_insert_with_constant():
sql = """MERGE INTO target
USING src ON target.k = src.k
WHEN NOT MATCHED THEN INSERT (k, v) VALUES (src.k, 1)"""
assert_co | [(ColumnQualifierTuple("k", "src"), ColumnQualifierTuple("k", "target"))]) | assert_* | collection | tests/sql/column/test_column_merge.py | test_merge_into_insert_with_constant | 75 | null | |
reata/sqllineage | import pytest
from ...helpers import assert_table_lineage_equal
@pytest.mark.parametrize("dialect", ["vertica"])
def test_swapping_partitions(dialect: str):
"""
See https://www.vertica.com/docs/10.0.x/HTML/Content/Authoring/AdministratorsGuide/Partitions/SwappingPartitions.htm
for language specification
... | {"target"}) | assert_* | collection | tests/sql/table/test_other_with_lineage_dialect_specific.py | test_swapping_partitions | 40 | null | |
reata/sqllineage | from sqllineage.utils.entities import ColumnQualifierTuple
from ...helpers import assert_column_lineage_equal, assert_table_lineage_equal
def test_create_view_with_same_columns():
sql = "CREATE VIEW my_view (col1,col2) AS (SELECT col1,col2 FROM tbl)"
asse | [ ( ColumnQualifierTuple("col1", "tbl"), ColumnQualifierTuple("col1", "my_view"), ), ( ColumnQualifierTuple("col2", "tbl"), ColumnQualifierTuple("col2", "my_view"), ), ]) | assert_* | collection | tests/sql/column/test_column_select_column_specified_in_dml.py | test_create_view_with_same_columns | 77 | null | |
reata/sqllineage | import pytest
from ...helpers import assert_table_lineage_equal
@pytest.mark.parametrize("dialect", ["exasol", "mysql", "teradata"])
def test_rename_table(dialect: str):
"""
https://docs.exasol.com/db/latest/sql/rename.htm
https://dev.mysql.com/doc/refman/8.0/en/rename-table.html
https://docs.teradata... | "rename table tab1 to tab2") | assert_* | string_literal | tests/sql/table/test_other_without_lineage_dialect_specific.py | test_rename_table | 13 | null | |
reata/sqllineage | from sqllineage.utils.entities import ColumnQualifierTuple
from ...helpers import assert_column_lineage_equal
def test_select_column_multiply_expression():
sql = """INSERT INTO tab1
SELECT col1 * 1 AS col1
FROM tab2"""
asse | [ ( ColumnQualifierTuple("col1", "tab2"), ColumnQualifierTuple("col1", "tab1"), ), ]) | assert_* | collection | tests/sql/column/test_column_select_expression.py | test_select_column_multiply_expression | 45 | null | |
reata/sqllineage | from ...helpers import assert_table_lineage_equal
def test_update_from():
asse | {"tab2"}) | assert_* | collection | tests/sql/table/test_update.py | test_update_from | 11 | null | |
reata/sqllineage | import os
from unittest.mock import patch
import pytest
from ....helpers import assert_table_lineage_equal
@patch.dict(os.environ, {"SQLLINEAGE_TSQL_NO_SEMICOLON": "TRUE"})
@pytest.mark.parametrize("dialect", ["tsql"])
def test_tsql_multi_statement_no_semicolon(dialect: str):
"""
tsql multiple statements wit... | {"tab1", "tab2"}) | assert_* | collection | tests/sql/table/multiple_statements/test_tsql_no_semicolon.py | test_tsql_multi_statement_no_semicolon | 17 | null | |
reata/sqllineage | from ...helpers import assert_table_lineage_equal
def test_with_select():
assert_table_lineage_equal( | "WITH tab1 AS (SELECT 1) SELECT * FROM tab1") | assert_* | string_literal | tests/sql/table/test_cte.py | test_with_select | 5 | null | |
reata/sqllineage | import pytest
from ...helpers import assert_table_lineage_equal
@pytest.mark.parametrize("dialect", ["bigquery"])
def test_merge_insert_row(dialect: str):
"""
MERGE INSERT CLAUSE in BigQuery can be INSERT ROW without specifying columns via INSERT VALUES (col, ...)
https://cloud.google.com/bigquery/docs/re... | {"tgt"}) | assert_* | collection | tests/sql/table/test_merge_dialect_specific.py | test_merge_insert_row | 31 | null | |
reata/sqllineage | from sqllineage.utils.entities import ColumnQualifierTuple
from ...helpers import assert_column_lineage_equal, assert_table_lineage_equal
def test_insert_with_custom_columns_and_cte_within_query():
sql = """INSERT INTO tab2 (col1)
WITH cte1 AS (SELECT col2 FROM tab1)
SELECT col2 FROM cte1"""
asse | [ ( ColumnQualifierTuple("col2", "tab1"), ColumnQualifierTuple("col1", "tab2"), ) ]) | assert_* | collection | tests/sql/column/test_column_select_column_specified_in_dml.py | test_insert_with_custom_columns_and_cte_within_query | 170 | null | |
reata/sqllineage | import pytest
from ...helpers import assert_table_lineage_equal
@pytest.mark.parametrize("dialect", ["databricks", "hive", "sparksql"])
def test_insert_overwrite(dialect: str):
asse | {"tab1"}) | assert_* | collection | tests/sql/table/test_insert_dialect_specific.py | test_insert_overwrite | 12 | null | |
reata/sqllineage | import os.path
from pathlib import Path
from sqlalchemy import (
Column as SQLAlchemyColumn,
)
from sqlalchemy import (
Integer,
MetaData,
inspect,
text,
)
from sqlalchemy import (
Table as SQLAlchemyTable,
)
from sqllineage import SQLPARSE_DIALECT
from sqllineage.config import SQLLineageConfi... | expected | assert | variable | tests/helpers.py | _assert_column_lineage | 55 | null | |
reata/sqllineage | import pytest
from sqllineage.utils.entities import ColumnQualifierTuple
from ...helpers import assert_column_lineage_equal
def test_cast_with_comparison():
sql = """INSERT INTO tab1
SELECT cast(col1 = 1 AS int) col1, col2 = col3 col2
FROM tab2"""
asse | [ ( ColumnQualifierTuple("col1", "tab2"), ColumnQualifierTuple("col1", "tab1"), ), ( ColumnQualifierTuple("col2", "tab2"), ColumnQualifierTuple("col2", "tab1"), ), ( ColumnQualifierTuple("col3", "tab2"), ColumnQualifierTuple("col2", "tab1"), ), ]) | assert_* | collection | tests/sql/column/test_column_select_cast.py | test_cast_with_comparison | 34 | null | |
reata/sqllineage | from sqllineage.utils.entities import ColumnQualifierTuple
from ...helpers import assert_column_lineage_equal
def test_column_reference_from_cte_and_union():
sql = """WITH cte_1 AS (select col1 from tab1),
cte_2 AS (SELECT col1 from tab2)
INSERT INTO tab3
SELECT col1 from cte_1
UNION
SELECT col1 from ... | [ ( ColumnQualifierTuple("col1", "tab1"), ColumnQualifierTuple("col1", "tab3"), ), ( ColumnQualifierTuple("col1", "tab2"), ColumnQualifierTuple("col1", "tab3"), ), ]) | assert_* | collection | tests/sql/column/test_column_select_from_cte.py | test_column_reference_from_cte_and_union | 62 | null | |
reata/sqllineage | from ...helpers import assert_table_lineage_equal
def test_delete_from_table():
assert_table_lineage_equal( | "DELETE FROM table tab1") | assert_* | string_literal | tests/sql/table/test_other_without_lineage.py | test_delete_from_table | 30 | null | |
reata/sqllineage | from ...helpers import assert_table_lineage_equal
def test_drop():
assert_table_lineage_equal( | "DROP TABLE IF EXISTS tab1") | assert_* | string_literal | tests/sql/table/test_other_without_lineage.py | test_drop | 9 | null | |
reata/sqllineage | import pytest
from sqllineage.utils.entities import ColumnQualifierTuple
from ...helpers import assert_column_lineage_equal
def test_select_column_using_cast():
sql = """INSERT INTO tab1
SELECT cast(col1 AS timestamp)
FROM tab2"""
asse | [ ( ColumnQualifierTuple("col1", "tab2"), ColumnQualifierTuple("cast(col1 as timestamp)", "tab1"), ) ]) | assert_* | collection | tests/sql/column/test_column_select_cast.py | test_select_column_using_cast | 12 | null | |
reata/sqllineage | from sqllineage.utils.entities import ColumnQualifierTuple
from ...helpers import assert_column_lineage_equal
def test_select_column_using_expression_with_table_qualifier_without_column_alias():
sql = """INSERT INTO tab1
SELECT a.col1 + a.col2 + a.col3 + a.col4
FROM tab2 a"""
asse | [ ( ColumnQualifierTuple("col1", "tab2"), ColumnQualifierTuple("a.col1 + a.col2 + a.col3 + a.col4", "tab1"), ), ( ColumnQualifierTuple("col2", "tab2"), ColumnQualifierTuple("a.col1 + a.col2 + a.col3 + a.col4", "tab1"), ), ( ColumnQualifierTuple("col3", "tab2"), ColumnQualifierTuple("a.col1 + a.col2 + a.col3 + a.col4", ... | assert_* | collection | tests/sql/column/test_column_select_expression.py | test_select_column_using_expression_with_table_qualifier_without_column_alias | 114 | null | |
reata/sqllineage | import pytest
from sqllineage.core.metadata_provider import MetaDataProvider
from sqllineage.utils.entities import ColumnQualifierTuple
from ....helpers import assert_column_lineage_equal, generate_metadata_providers
providers = generate_metadata_providers(
{
"db1.table1": ["id", "a", "b", "c", "d"],
... | [ ( ColumnQualifierTuple("a", "db1.table1"), ColumnQualifierTuple("a", "db1.foo"), ), ( ColumnQualifierTuple("b", "db1.table1"), ColumnQualifierTuple("b", "db1.foo"), ), ( ColumnQualifierTuple("c", "db1.table1"), ColumnQualifierTuple("c", "db1.foo"), ), ]) | assert_* | collection | tests/sql/column/multiple_statements/test_session_metadata.py | test_do_not_register_session_metadata_for_update_statement | 28 | null | |
reata/sqllineage | from ...helpers import assert_table_lineage_equal
def test_cte_insert():
asse | {"tab3"}) | assert_* | collection | tests/sql/table/test_cte.py | test_cte_insert | 52 | null | |
reata/sqllineage | import pytest
from sqllineage.utils.entities import ColumnQualifierTuple
from ...helpers import assert_column_lineage_equal
def test_select_column_using_cast():
sql = """INSERT INTO tab1
SELECT cast(col1 AS timestamp)
FROM tab2"""
assert_column_lineage_equal(
sql,
[
(
... | [(ColumnQualifierTuple("col1", "tab2"), ColumnQualifierTuple("col2", "tab1"))]) | assert_* | collection | tests/sql/column/test_column_select_cast.py | test_select_column_using_cast | 24 | null | |
reata/sqllineage | from ....helpers import assert_table_lineage_equal
def test_alter_target_table_name():
asse | {"tab3"}) | assert_* | collection | tests/sql/table/multiple_statements/test_tmp_table.py | test_alter_target_table_name | 42 | null | |
reata/sqllineage | import os
from unittest.mock import patch
import pytest
from sqllineage.core.metadata_provider import MetaDataProvider
from sqllineage.utils.entities import ColumnQualifierTuple
from ...helpers import assert_column_lineage_equal, generate_metadata_providers
providers = generate_metadata_providers(
{
"pu... | [ ( ColumnQualifierTuple("id", "public.src_tbl1"), ColumnQualifierTuple("name", "public.tgt_tbl1"), ), ( ColumnQualifierTuple("name", "public.src_tbl1"), ColumnQualifierTuple("name", "public.tgt_tbl1"), ), ( ColumnQualifierTuple("email", "public.src_tbl2"), ColumnQualifierTuple("name", "public.tgt_tbl1"), ), ]) | assert_* | collection | tests/sql/column/test_column_select_lateral_alias_ref.py | test_column_enable_lateral_ref_within_subquery | 306 | null | |
reata/sqllineage | import concurrent.futures
import os
import random
import time
from unittest.mock import patch
import pytest
from sqllineage.config import SQLLineageConfig
from sqllineage.exceptions import ConfigException
from sqllineage.runner import LineageRunner
@patch.dict(
os.environ,
{
"SQLLINEAGE_DIRECTORY": o... | True | assert | bool_literal | tests/core/test_config.py | test_config | 30 | null | |
reata/sqllineage | from sqllineage.utils.entities import ColumnQualifierTuple
from ...helpers import assert_column_lineage_equal
def test_merge_into_insert():
sql = """MERGE INTO target
USING src ON target.k = src.k
WHEN NOT MATCHED THEN INSERT (k, v) VALUES (src.k, src.v)"""
asse | [ (ColumnQualifierTuple("k", "src"), ColumnQualifierTuple("k", "target")), (ColumnQualifierTuple("v", "src"), ColumnQualifierTuple("v", "target")), ]) | assert_* | collection | tests/sql/column/test_column_merge.py | test_merge_into_insert | 62 | null | |
reata/sqllineage | import pytest
from sqllineage.core.metadata_provider import MetaDataProvider
from sqllineage.utils.entities import ColumnQualifierTuple
from ...helpers import assert_column_lineage_equal, generate_metadata_providers
providers = generate_metadata_providers(
{
"db1.table1": ["id", "a", "b", "c", "d"],
... | [ ( ColumnQualifierTuple("a", "db1.table1"), ColumnQualifierTuple("x", "db.tbl"), ), ( ColumnQualifierTuple("b", "db1.table1"), ColumnQualifierTuple("b", "db.tbl"), ), ( ColumnQualifierTuple("pk", "db3.table3"), ColumnQualifierTuple("y", "db.tbl"), ), ( ColumnQualifierTuple("q", "db3.table3"), ColumnQualifierTuple("q",... | assert_* | collection | tests/sql/column/test_metadata_unqualified_column.py | test_select_column_from_table_subquery | 170 | null | |
reata/sqllineage | from sqllineage.utils.entities import ColumnQualifierTuple
from ...helpers import assert_column_lineage_equal
def test_select_column_name_case_insensitive():
sql = """INSERT INTO tab1
SELECT col1,
COL1
FROM tab2"""
asse | [ ( ColumnQualifierTuple("col1", "tab2"), ColumnQualifierTuple("col1", "tab1"), ) ]) | assert_* | collection | tests/sql/column/test_column_select_column.py | test_select_column_name_case_insensitive | 208 | null | |
reata/sqllineage | from sqllineage.utils.entities import ColumnQualifierTuple
from ...helpers import assert_column_lineage_equal
def test_column_reference_using_union():
sql = """INSERT INTO tab3
SELECT col1
FROM tab1
UNION ALL
SELECT col1
FROM tab2"""
asse | [ ( ColumnQualifierTuple("col1", "tab1"), ColumnQualifierTuple("col1", "tab3"), ), ( ColumnQualifierTuple("col1", "tab2"), ColumnQualifierTuple("col1", "tab3"), ), ]) | assert_* | collection | tests/sql/column/test_column_select_union.py | test_column_reference_using_union | 13 | null | |
reata/sqllineage | import pytest
from ...helpers import assert_table_lineage_equal
@pytest.mark.parametrize("dialect", ["snowflake"])
def test_select_from_generator(dialect: str):
# generator is Snowflake specific
sql = """SELECT seq4(), uniform(1, 10, random(12))
FROM table(generator()) v
ORDER BY 1;"""
assert_table_linea... | sql) | assert_* | variable | tests/sql/table/test_select_dialect_specific.py | test_select_from_generator | 60 | null | |
reata/sqllineage | import pytest
from ...helpers import assert_table_lineage_equal
@pytest.mark.parametrize("dialect", ["hive"])
def test_alter_table_exchange_partition(dialect: str):
"""
See https://cwiki.apache.org/confluence/display/Hive/Exchange+Partition for language manual
"""
asse | {"tab1"}) | assert_* | collection | tests/sql/table/test_other_with_lineage_dialect_specific.py | test_alter_table_exchange_partition | 11 | null | |
reata/sqllineage | import pytest
from sqllineage.core.metadata_provider import MetaDataProvider
from sqllineage.utils.entities import ColumnQualifierTuple
from ...helpers import assert_column_lineage_equal, generate_metadata_providers
providers = generate_metadata_providers(
{
"db.tbl_x": ["id", "a", "b"],
"db.tbl_... | [ ( ColumnQualifierTuple("col_b", "tab_b"), ColumnQualifierTuple("col_a", "tab_c"), ), ]) | assert_* | collection | tests/sql/column/test_metadata_wildcard.py | test_output_consistency | 426 | null | |
reata/sqllineage | from sqllineage.utils.entities import ColumnQualifierTuple
from ...helpers import assert_column_lineage_equal
def test_subquery_expression_without_source_table():
asse | [ ( ColumnQualifierTuple("col1", "bar"), ColumnQualifierTuple("sum_result", "foo"), ), ( ColumnQualifierTuple("col2", "bar"), ColumnQualifierTuple("sum_result", "foo"), ), ]) | assert_* | collection | tests/sql/column/test_column_select_expression.py | test_subquery_expression_without_source_table | 138 | null | |
reata/sqllineage | import pytest
from sqllineage.utils.entities import ColumnQualifierTuple
from ...helpers import assert_column_lineage_equal
@pytest.mark.parametrize("dialect", ["teradata"])
def test_teradata_title_phrase(dialect: str):
"""
The TITLE phrase of a CREATE TABLE, ALTER TABLE, or SELECT statement gives a name to ... | [ ( ColumnQualifierTuple("Name", "Employee"), ColumnQualifierTuple("Name", "foo"), ), ( ColumnQualifierTuple("DOB", "Employee"), ColumnQualifierTuple("DOB", "foo"), ), ]) | assert_* | collection | tests/sql/column/test_column_select_column_dialect_specific.py | test_teradata_title_phrase | 42 | null | |
reata/sqllineage | import pytest
from ...helpers import assert_table_lineage_equal
@pytest.mark.parametrize("dialect", ["databricks", "hive", "sparksql"])
def test_with_insert_plus_table_keyword(dialect: str):
asse | {"tab3"}) | assert_* | collection | tests/sql/table/test_cte_dialect_specific.py | test_with_insert_plus_table_keyword | 12 | null | |
reata/sqllineage | from sqllineage.utils.entities import ColumnQualifierTuple
from ...helpers import assert_column_lineage_equal
def test_column_with_ctas_and_func():
sql = """CREATE TABLE tab2 AS
SELECT coalesce(col1, 0) AS col1,
if(col1 IS NOT NULL, 1, NULL) AS col2
FROM tab1"""
asse | [ ( ColumnQualifierTuple("col1", "tab1"), ColumnQualifierTuple("col1", "tab2"), ), ( ColumnQualifierTuple("col1", "tab1"), ColumnQualifierTuple("col2", "tab2"), ), ]) | assert_* | collection | tests/sql/column/test_column_select_function.py | test_column_with_ctas_and_func | 116 | null | |
reata/sqllineage | import pytest
from ...helpers import assert_table_lineage_equal
@pytest.mark.parametrize("dialect", ["snowflake", "bigquery"])
def test_create_clone(dialect: str):
"""
Language manual:
https://cloud.google.com/bigquery/docs/table-clones-create
https://docs.snowflake.com/en/sql-reference/sql/cr... | {"tab2"}) | assert_* | collection | tests/sql/table/test_create_dialect_specific.py | test_create_clone | 94 | null | |
reata/sqllineage | import pytest
from sqllineage.core.metadata_provider import MetaDataProvider
from sqllineage.utils.entities import ColumnQualifierTuple
from ...helpers import assert_column_lineage_equal, generate_metadata_providers
providers = generate_metadata_providers(
{
"db.tbl_x": ["id", "a", "b"],
"db.tbl_... | [ ( ColumnQualifierTuple("id", "db.tbl_x"), ColumnQualifierTuple("id", "<default>.test_v"), ), ( ColumnQualifierTuple("a", "db.tbl_x"), ColumnQualifierTuple("a", "<default>.test_v"), ), ( ColumnQualifierTuple("b", "db.tbl_x"), ColumnQualifierTuple("b", "<default>.test_v"), ), ]) | assert_* | collection | tests/sql/column/test_metadata_wildcard.py | test_select_single_table_wildcard | 25 | null | |
reata/sqllineage | import pytest
from ...helpers import assert_table_lineage_equal
@pytest.mark.parametrize("dialect", ["mysql"])
def test_update_with_join(dialect: str):
asse | {"tab1"}) | assert_* | collection | tests/sql/table/test_update_dialect_specific.py | test_update_with_join | 8 | null | |
reata/sqllineage | import os
import pytest
from sqllineage.core.metadata.sqlalchemy import SQLAlchemyMetaDataProvider
from sqllineage.exceptions import MetaDataProviderException
def test_sqlalchemy_metadata_provider_query_fail():
provider = SQLAlchemyMetaDataProvider("sqlite:///:memory:")
assert ( | [] | assert | collection | tests/core/test_metadata_provider.py | test_sqlalchemy_metadata_provider_query_fail | 23 | null | |
reata/sqllineage | from unittest.mock import Mock
from sqlfluff.core import Linter
from sqllineage.core.parser.sqlfluff.models import SqlFluffColumn
from sqllineage.core.parser.sqlfluff.utils import find_from_expression_element
def test_return_none_find_from_expression_element():
file_segment = Linter(dialect="ansi").parse_string(... | None | assert | none_literal | tests/core/test_parser.py | test_return_none_find_from_expression_element | 17 | null | |
reata/sqllineage | import pytest
from ...helpers import assert_table_lineage_equal
@pytest.mark.parametrize("dialect", ["databricks", "sparksql"])
def test_show_functions(dialect: str):
assert_table_lineage_equal( | "SHOW FUNCTIONS trim") | assert_* | string_literal | tests/sql/table/test_other_without_lineage_dialect_specific.py | test_show_functions | 91 | null | |
reata/sqllineage | import pytest
from sqllineage.core.metadata_provider import MetaDataProvider
from sqllineage.utils.entities import ColumnQualifierTuple
from ...helpers import assert_column_lineage_equal, generate_metadata_providers
providers = generate_metadata_providers(
{
"db.tbl_x": ["id", "a", "b"],
"db.tbl_... | [ ( ColumnQualifierTuple("a", "db.tbl_x"), ColumnQualifierTuple("a", "<default>.test_v"), ), ( ColumnQualifierTuple("b", "db.tbl_x"), ColumnQualifierTuple("b", "<default>.test_v"), ), ]) | assert_* | collection | tests/sql/column/test_metadata_wildcard.py | test_select_single_table_partial_wildcard_in_subquery | 82 | null | |
reata/sqllineage | import pytest
from ...helpers import assert_table_lineage_equal
@pytest.mark.parametrize("dialect", ["databricks", "sparksql"])
def test_add_jar(dialect: str):
assert_table_lineage_equal( | "ADD JAR /tmp/SimpleUdf.jar") | assert_* | string_literal | tests/sql/table/test_other_without_lineage_dialect_specific.py | test_add_jar | 50 | null | |
reata/sqllineage | from sqllineage.utils.entities import ColumnQualifierTuple
from ...helpers import assert_column_lineage_equal, assert_table_lineage_equal
def test_insert_with_custom_columns():
# test with query as subquery
sql = "INSERT INTO tgt_tbl(random1, random2) (SELECT col1,col2 FROM src_tbl)"
assert_column_lineage... | [ ( ColumnQualifierTuple("col1", "src_tbl_new"), ColumnQualifierTuple("random1", "tgt_tbl"), ), ( ColumnQualifierTuple("col2", "src_tbl_new"), ColumnQualifierTuple("random2", "tgt_tbl"), ), ]) | assert_* | collection | tests/sql/column/test_column_select_column_specified_in_dml.py | test_insert_with_custom_columns | 150 | null | |
reata/sqllineage | from sqllineage.utils.entities import ColumnQualifierTuple
from ...helpers import assert_column_lineage_equal
def test_select_column_from_table_join():
sql = """INSERT INTO tab1
SELECT tab2.col1,
tab3.col2
FROM tab2
INNER JOIN tab3
ON tab2.id = tab3.id"""
assert_column_line... | [ ( ColumnQualifierTuple("col1", "tab2"), ColumnQualifierTuple("col3", "tab1"), ), ( ColumnQualifierTuple("col2", "tab3"), ColumnQualifierTuple("col4", "tab1"), ), ]) | assert_* | collection | tests/sql/column/test_column_select_from_join.py | test_select_column_from_table_join | 32 | null | |
reata/sqllineage | import os
from unittest.mock import patch
import pytest
from sqllineage.core.metadata_provider import MetaDataProvider
from sqllineage.utils.entities import ColumnQualifierTuple
from ...helpers import assert_column_lineage_equal, generate_metadata_providers
providers = generate_metadata_providers(
{
"pu... | [ ( ColumnQualifierTuple("alias1", None), ColumnQualifierTuple("name", "public.tgt_tbl1"), ), ( ColumnQualifierTuple("email", "public.src_tbl2"), ColumnQualifierTuple("name", "public.tgt_tbl1"), ), ]) | assert_* | collection | tests/sql/column/test_column_select_lateral_alias_ref.py | test_column_disable_lateral_ref_within_subquery | 495 | null | |
reata/sqllineage | from sqllineage.utils.entities import ColumnQualifierTuple
from ...helpers import assert_column_lineage_equal
def test_select_column_using_multiple_case_when_with_subquery():
sql = """INSERT INTO tab1
SELECT CASE
WHEN (SELECT avg(col1) FROM tab3) > 0 AND col2 = 1 THEN (SELECT avg(col1) FROM tab3)
WHEN (SELECT avg... | [ ( ColumnQualifierTuple("col2", "tab4"), ColumnQualifierTuple("col1", "tab1"), ), ( ColumnQualifierTuple("col1", "tab3"), ColumnQualifierTuple("col1", "tab1"), ), ( ColumnQualifierTuple("col1", "tab5"), ColumnQualifierTuple("col1", "tab1"), ), ]) | assert_* | collection | tests/sql/column/test_column_select_case_when.py | test_select_column_using_multiple_case_when_with_subquery | 55 | null | |
reata/sqllineage | from sqllineage.utils.entities import ColumnQualifierTuple
from ...helpers import assert_column_lineage_equal, assert_table_lineage_equal
def test_insert_into_with_columns():
# table lineage works for sqlparse
asse | {"tab1"}) | assert_* | collection | tests/sql/column/test_column_select_column_specified_in_dml.py | test_insert_into_with_columns | 95 | null | |
reata/sqllineage | from sqllineage.utils.entities import ColumnQualifierTuple
from ...helpers import assert_column_lineage_equal
def test_merge_into_update():
sql = """MERGE INTO target
USING src ON target.k = src.k
WHEN MATCHED THEN UPDATE SET target.v = src.v"""
asse | [(ColumnQualifierTuple("v", "src"), ColumnQualifierTuple("v", "target"))]) | assert_* | collection | tests/sql/column/test_column_merge.py | test_merge_into_update | 10 | null | |
reata/sqllineage | from sqllineage.utils.entities import ColumnQualifierTuple
from ...helpers import assert_column_lineage_equal
def test_merge_into_using_subquery():
sql = """MERGE INTO target USING (select k, max(v) as v_max from src group by k) AS b ON target.k = b.k
WHEN MATCHED THEN UPDATE SET target.v = b.v_max
WHEN NOT MATCH... | [ (ColumnQualifierTuple("v", "src"), ColumnQualifierTuple("v", "target")), (ColumnQualifierTuple("k", "src"), ColumnQualifierTuple("k", "target")), ]) | assert_* | collection | tests/sql/column/test_column_merge.py | test_merge_into_using_subquery | 100 | null | |
reata/sqllineage | from ...helpers import assert_table_lineage_equal
def test_use():
assert_table_lineage_equal( | "USE db1") | assert_* | string_literal | tests/sql/table/test_other_without_lineage.py | test_use | 5 | null | |
reata/sqllineage | import pytest
from ...helpers import assert_table_lineage_equal
@pytest.mark.parametrize("dialect", ["databricks", "sparksql"])
def test_set_command_without_property_value(dialect: str):
assert_table_lineage_equal( | "SET spark.sql.variable.substitute") | assert_* | string_literal | tests/sql/table/test_other_without_lineage_dialect_specific.py | test_set_command_without_property_value | 113 | null | |
reata/sqllineage | import pytest
from ...helpers import assert_table_lineage_equal
@pytest.mark.parametrize("dialect", ["postgres", "redshift", "tsql"])
def test_select_into(dialect: str):
"""
postgres: https://www.postgresql.org/docs/current/sql-selectinto.html
redshift: https://docs.aws.amazon.com/redshift/latest/dg/r_SEL... | {"films_recent"}) | assert_* | collection | tests/sql/table/test_select_dialect_specific.py | test_select_into | 71 | null | |
reata/sqllineage | from ...helpers import assert_table_lineage_equal
def test_drop_with_comment():
assert_table_lineage_equal( | """--comment DROP TABLE IF EXISTS tab1""") | assert_* | string_literal | tests/sql/table/test_other_without_lineage.py | test_drop_with_comment | 13 | null | |
reata/sqllineage | from sqllineage.utils.entities import ColumnQualifierTuple
from ...helpers import assert_column_lineage_equal
def test_coalesce_with_whitespace():
"""
coalesce is a keyword since ANSI SQL-2023
usually it's parsed as a function. however, when whitespace followed which is valid syntax,
sqlparse cannot p... | [ ( ColumnQualifierTuple("col1", "tab2"), ColumnQualifierTuple("col3", "tab1"), ), ( ColumnQualifierTuple("col2", "tab2"), ColumnQualifierTuple("col3", "tab1"), ), ]) | assert_* | collection | tests/sql/column/test_column_select_function.py | test_coalesce_with_whitespace | 140 | null | |
reata/sqllineage | import pytest
from sqllineage.core.metadata_provider import MetaDataProvider
from sqllineage.utils.entities import ColumnQualifierTuple
from ...helpers import assert_column_lineage_equal, generate_metadata_providers
providers = generate_metadata_providers(
{
"db.tbl_x": ["id", "a", "b"],
"db.tbl_... | [ ( ColumnQualifierTuple("id", "db.tbl_y"), ColumnQualifierTuple("id", "db.tbl_x2"), ), ( ColumnQualifierTuple("h", "db.tbl_y"), ColumnQualifierTuple("a", "db.tbl_x2"), ), ( ColumnQualifierTuple("i", "db.tbl_y"), ColumnQualifierTuple("b", "db.tbl_x2"), ), ]) | assert_* | collection | tests/sql/column/test_metadata_wildcard.py | test_insert_overwrite_with_partition_excludes_partition_columns | 446 | null | |
reata/sqllineage | from sqllineage.utils.entities import ColumnQualifierTuple
from ...helpers import assert_column_lineage_equal
def test_select_column_wildcard():
sql = """INSERT INTO tab1
SELECT *
FROM tab2"""
assert_column_lineage_equal(
sql,
[(ColumnQualifierTuple("*", "tab2"), ColumnQualifierTuple("*", "tab... | [ (ColumnQualifierTuple("*", "tab2"), ColumnQualifierTuple("*", "tab1")), (ColumnQualifierTuple("*", "tab3"), ColumnQualifierTuple("*", "tab1")), ]) | assert_* | collection | tests/sql/column/test_column_select_column.py | test_select_column_wildcard | 43 | null | |
reata/sqllineage | import concurrent.futures
import os
import random
import time
from unittest.mock import patch
import pytest
from sqllineage.config import SQLLineageConfig
from sqllineage.exceptions import ConfigException
from sqllineage.runner import LineageRunner
def test_update_config_using_context_manager():
with SQLLineageC... | "" | assert | string_literal | tests/core/test_config.py | test_update_config_using_context_manager | 45 | null | |
reata/sqllineage | from sqllineage.utils.entities import ColumnQualifierTuple
from ...helpers import assert_column_lineage_equal
def test_select_column_wildcard():
sql = """INSERT INTO tab1
SELECT *
FROM tab2"""
asse | [(ColumnQualifierTuple("*", "tab2"), ColumnQualifierTuple("*", "tab1"))]) | assert_* | collection | tests/sql/column/test_column_select_column.py | test_select_column_wildcard | 34 | null | |
reata/sqllineage | from sqllineage.utils.entities import ColumnQualifierTuple
from ...helpers import assert_column_lineage_equal
def test_select_column_using_case_when():
sql = """INSERT INTO tab1
SELECT CASE WHEN col1 = 1 THEN 'V1' WHEN col1 = 2 THEN 'V2' END
FROM tab2"""
assert_column_lineage_equal(
sql,
[
... | [(ColumnQualifierTuple("col1", "tab2"), ColumnQualifierTuple("col2", "tab1"))]) | assert_* | collection | tests/sql/column/test_column_select_case_when.py | test_select_column_using_case_when | 24 | null | |
reata/sqllineage | import pytest
from ...helpers import assert_table_lineage_equal
@pytest.mark.parametrize("dialect", ["databricks", "hive", "sparksql"])
def test_create_using_serde(dialect: str):
"""
https://cwiki.apache.org/confluence/display/Hive/LanguageManual+DDL#LanguageManualDDL-RowFormats&SerDe
here with is not an ... | {"apachelog"}) | assert_* | collection | tests/sql/table/test_create_dialect_specific.py | test_create_using_serde | 64 | null | |
reata/sqllineage | from sqllineage.utils.entities import ColumnQualifierTuple
from ...helpers import assert_column_lineage_equal
def test_window_function_in_subquery():
sql = """INSERT INTO tab1
SELECT rn FROM (
SELECT
row_number() over (partition BY col1, col2) rn
FROM tab2
) sub
WHERE rn = 1"""
asse | [ (ColumnQualifierTuple("col1", "tab2"), ColumnQualifierTuple("rn", "tab1")), (ColumnQualifierTuple("col2", "tab2"), ColumnQualifierTuple("rn", "tab1")), ]) | assert_* | collection | tests/sql/column/test_column_select_from_subquery.py | test_window_function_in_subquery | 106 | null | |
reata/sqllineage | import pytest
from ...helpers import assert_table_lineage_equal
@pytest.mark.parametrize("dialect", ["databricks", "sparksql"])
def test_uncache_table(dialect: str):
assert_table_lineage_equal( | "uncache table tab1") | assert_* | string_literal | tests/sql/table/test_other_without_lineage_dialect_specific.py | test_uncache_table | 35 | null | |
reata/sqllineage | import pytest
from ...helpers import assert_table_lineage_equal
@pytest.mark.parametrize("dialect", ["databricks", "sparksql"])
def test_create_function(dialect: str):
asse | """CREATE FUNCTION simple_udf AS 'SimpleUdf' USING JAR '/tmp/SimpleUdf.jar'""") | assert_* | string_literal | tests/sql/table/test_other_without_lineage_dialect_specific.py | test_create_function | 55 | null | |
reata/sqllineage | import pytest
from ...helpers import assert_table_lineage_equal
@pytest.mark.parametrize("dialect", ["databricks", "hive", "sparksql"])
def test_insert_overwrite_from_self(dialect: str):
asse | {"foo"}) | assert_* | collection | tests/sql/table/test_insert_dialect_specific.py | test_insert_overwrite_from_self | 22 | null | |
reata/sqllineage | from ...helpers import assert_table_lineage_equal
def test_create_view():
asse | {"view1"}) | assert_* | collection | tests/sql/table/test_create.py | test_create_view | 31 | null | |
reata/sqllineage | from ...helpers import assert_table_lineage_equal
def test_with_select_many():
asse | {"tab1", "tab2"}) | assert_* | collection | tests/sql/table/test_cte.py | test_with_select_many | 16 | null | |
reata/sqllineage | from sqllineage.utils.entities import ColumnQualifierTuple
from ...helpers import assert_column_lineage_equal
def test_multiple_column_references_from_previous_defined_cte():
sql = """WITH
cte1 AS (SELECT a, b FROM tab1),
cte2 AS (SELECT a, max(b) AS b_max, count(b) AS b_cnt FROM cte1 GROUP BY a)
INSERT INTO tab2... | [ (ColumnQualifierTuple("a", "tab1"), ColumnQualifierTuple("a", "tab2")), (ColumnQualifierTuple("b", "tab1"), ColumnQualifierTuple("b_max", "tab2")), (ColumnQualifierTuple("b", "tab1"), ColumnQualifierTuple("b_cnt", "tab2")), ]) | assert_* | collection | tests/sql/column/test_column_select_from_cte.py | test_multiple_column_references_from_previous_defined_cte | 45 | null | |
reata/sqllineage | from sqllineage.utils.entities import ColumnQualifierTuple
from ...helpers import assert_column_lineage_equal
def test_select_column_using_case_when_with_subquery():
sql = """INSERT INTO tab1
SELECT CASE WHEN (SELECT avg(col1) FROM tab3) > 0 AND col2 = 1 THEN (SELECT avg(col1) FROM tab3) ELSE 0 END AS col1
FROM t... | [ ( ColumnQualifierTuple("col2", "tab4"), ColumnQualifierTuple("col1", "tab1"), ), ( ColumnQualifierTuple("col1", "tab3"), ColumnQualifierTuple("col1", "tab1"), ), ]) | assert_* | collection | tests/sql/column/test_column_select_case_when.py | test_select_column_using_case_when_with_subquery | 34 | null | |
reata/sqllineage | from ...helpers import assert_table_lineage_equal
def test_drop_view():
assert_table_lineage_equal( | "DROP VIEW IF EXISTS view1") | assert_* | string_literal | tests/sql/table/test_other_without_lineage.py | test_drop_view | 18 | null | |
reata/sqllineage | from ...helpers import assert_table_lineage_equal
def test_with_select_join_table_with_same_name():
asse | {"schema1.tab1", "db.wtab1"}) | assert_* | collection | tests/sql/table/test_cte.py | test_with_select_join_table_with_same_name | 45 | null | |
reata/sqllineage | import pytest
from sqllineage.core.metadata_provider import MetaDataProvider
from sqllineage.utils.entities import ColumnQualifierTuple
from ...helpers import assert_column_lineage_equal, generate_metadata_providers
providers = generate_metadata_providers(
{
"db.tbl_x": ["id", "a", "b"],
"db.tbl_... | [ ( ColumnQualifierTuple("id", "db.tbl_x"), ColumnQualifierTuple("id", "<default>.test_v"), ), ( ColumnQualifierTuple("b", "db.tbl_x"), ColumnQualifierTuple("b", "<default>.test_v"), ), ]) | assert_* | collection | tests/sql/column/test_metadata_wildcard.py | test_select_single_table_wildcard_in_subquery | 56 | null | |
reata/sqllineage | import pytest
from sqllineage.core.models import Path
from ...helpers import assert_table_lineage_equal
@pytest.mark.parametrize("dialect", ["redshift"])
def test_redshift_unloading_data_to_s3(dialect: str):
"""
https://docs.aws.amazon.com/redshift/latest/dg/t_Unloading_tables.html
"""
asse | {Path("s3://amzn-s3-demo-bucket/tickit/unload/venue_")}) | assert_* | collection | tests/sql/table/test_path_dialect_specific.py | test_redshift_unloading_data_to_s3 | 77 | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.