recce-nightly 1.2.0.20250506__py3-none-any.whl → 1.26.0.20251124__py3-none-any.whl

tests/adapter/dbt_adapter/test_dbt_cll.py

@@ -1,27 +1,127 @@
 from recce.adapter.dbt_adapter import DbtAdapter
+from recce.models.types import CllData
+from recce.util.lineage import build_column_key
+
+
+def assert_parent_map(result: CllData, node_or_column_id, parents):
+    a_parents = result.parent_map.get(node_or_column_id) or set()
+
+    assert len(a_parents) == len(parents), "parents length mismatch"
+    for parent in parents:
+        if isinstance(parent, str):
+            node_id = parent
+            assert node_id in a_parents, f"Node {node_id} not found in parent list"
+        elif len(parent) == 1:
+            (node_id,) = parent
+            assert node_id in a_parents, f"Column {parent} not found in parent list"
+        elif len(parent) == 2:
+            node, column = parent
+            column_id = build_column_key(node, column)
+            assert column_id in a_parents, f"Column {column_id} not found in parent list for {node_or_column_id}"
+        else:
+            raise ValueError(f"Invalid parent format: {parent}. Expected node_id or (node_id, column_name).")
+
+
+def assert_column(
+    result: CllData,
+    node_id,
+    column_name,
+    transformation_type=None,
+    change_status=None,
+    parents=None,
+):
+    column_id = build_column_key(node_id, column_name)
+    entry = result.columns.get(column_id)
+    assert entry is not None, f"Column {column_id} not found in result"
+    assert (
+        entry.transformation_type == transformation_type
+    ), f"Column {column_name} type mismatch: expected {transformation_type}, got {entry.transformation_type}"
+    assert_parent_map(result, column_id, parents)
+    assert (
+        entry.change_status == change_status
+    ), f"Column {column_name} change status mismatch: expected {change_status}, got {entry.change_status}"
+
+
+def assert_model(
+    result: CllData,
+    node_id,
+    change_category=None,
+    impacted=None,
+    parents=None,
+):
+    entry = result.nodes.get(node_id)
+    assert entry is not None, f"Node {node_id} not found in result"
+    assert_parent_map(result, node_id, parents)
+
+    assert (
+        entry.change_category == change_category
+    ), f"Node {node_id} change category mismatch: expected {change_category}, got {entry.change_category}"
+
+    assert (
+        entry.impacted == impacted
+    ), f"Node {node_id} impacted status mismatch: expected {impacted}, got {entry.impacted}"
+
+
+def assert_cll_contain_nodes(cll_data: CllData, nodes):
+    assert len(nodes) == len(cll_data.nodes), "Model count mismatch"
+    for node in nodes:
+        assert node in cll_data.nodes, f"Model {node} not found in lineage"
+
+
+def assert_cll_contain_columns(cll_data: CllData, columns):
+    assert len(columns) == len(cll_data.columns), "Column count mismatch"
+    for column in columns:
+        column_key = f"{column[0]}_{column[1]}"
+        assert column_key in cll_data.columns, f"Column {column} not found in lineage"
+        assert column[0] == cll_data.columns[column_key].table_id, f"Column {column[0]} node mismatch"
+        assert column[1] == cll_data.columns[column_key].name, f"Column {column[1]} name mismatch"
 
 
 def test_cll_basic(dbt_test_helper):
-    dbt_test_helper.create_model("model1", curr_sql="select 1 as c", curr_columns={"c": "int"})
-    dbt_test_helper.create_model("model2", curr_sql='select c from {{ ref("model1") }}', curr_columns={"c": "int"},
-                                 depends_on=["model1"])
+    dbt_test_helper.create_model(
+        "model1", unique_id="model.model1", curr_sql="select 1 as c", curr_columns={"c": "int"}
+    )
+    dbt_test_helper.create_model(
+        "model2",
+        unique_id="model.model2",
+        curr_sql='select c from {{ ref("model1") }} where c > 0',
+        curr_columns={"c": "int"},
+        depends_on=["model.model1"],
+    )
+    dbt_test_helper.create_model(
+        "model3",
+        unique_id="model.model3",
+        curr_sql='select c from {{ ref("recce_test", "model1") }} where c > 0',
+        curr_columns={"c": "int"},
+        depends_on=["model.model1"],
+    )
     adapter: DbtAdapter = dbt_test_helper.context.adapter
-    result = adapter.get_cll_by_node_id("model1")
-    assert result['nodes']['model2']['columns']['c']['depends_on'][0].column == 'c'
-    assert result['nodes']['model2']['columns']['c']['depends_on'][0].node == 'model1'
+
+    result = adapter.get_cll("model.model1", "c")
+    assert_model(result, "model.model2", parents=[("model.model1", "c")])
+    assert_column(result, "model.model2", "c", transformation_type="passthrough", parents=[("model.model1", "c")])
+
+    assert_model(result, "model.model3", parents=[("model.model1", "c")])
+    assert_column(result, "model.model3", "c", transformation_type="passthrough", parents=[("model.model1", "c")])
 
 
 def test_cll_table_alisa(dbt_test_helper):
     def patch_node(node):
-        node['alias'] = 'model1_alias'
+        node["alias"] = "model1_alias"
 
-    dbt_test_helper.create_model("model1", curr_sql="select 1 as c", curr_columns={"c": "int"}, patch_func=patch_node)
-    dbt_test_helper.create_model("model2", curr_sql='select c from {{ ref("model1") }}', curr_columns={"c": "int"},
-                                 depends_on=["model1"])
+    dbt_test_helper.create_model(
+        "model1", unique_id="model.model1", curr_sql="select 1 as c", curr_columns={"c": "int"}, patch_func=patch_node
+    )
+    dbt_test_helper.create_model(
+        "model2",
+        unique_id="model.model2",
+        curr_sql='select c from {{ ref("model1") }}',
+        curr_columns={"c": "int"},
+        depends_on=["model.model1"],
+    )
     adapter: DbtAdapter = dbt_test_helper.context.adapter
-    result = adapter.get_cll_by_node_id("model1")
-    assert result['nodes']['model2']['columns']['c']['depends_on'][0].column == 'c'
-    assert result['nodes']['model2']['columns']['c']['depends_on'][0].node == 'model1'
+    result = adapter.get_cll("model.model1", "c")
+    assert_column(result, "model.model2", "c", transformation_type="passthrough", parents=[("model.model1", "c")])
 
 
 def test_seed(dbt_test_helper):
@@ -32,20 +132,38 @@ def test_seed(dbt_test_helper):
     3,Charlie,35
     """
 
-    dbt_test_helper.create_model("seed1",
-                                 curr_csv=csv_data_curr,
-                                 curr_columns={"customer_id": "varchar", "name": "varchar", "age": "int"},
-                                 resource_type="seed")
+    dbt_test_helper.create_model(
+        "seed1",
+        unique_id="seed.seed1",
+        curr_csv=csv_data_curr,
+        curr_columns={"customer_id": "varchar", "name": "varchar", "age": "int"},
+        resource_type="seed",
+    )
+    dbt_test_helper.create_model(
+        "model1",
+        unique_id="model.model1",
+        curr_sql='select customer_id from {{ ref("seed1") }} where age > 0',
+        curr_columns={"customer_id": "varchar"},
+        depends_on=["seed.seed1"],
+    )
     adapter: DbtAdapter = dbt_test_helper.context.adapter
-    result = adapter.get_cll_by_node_id("seed1")
 
-    assert result['nodes']['seed1']['columns']['customer_id']['transformation_type'] == 'source'
-    assert len(result['nodes']['seed1']['columns']['customer_id']['depends_on']) == 0
+    result = adapter.get_cll("model.model1")
+    assert_model(result, "seed.seed1", parents=[])
+    assert_column(result, "seed.seed1", "customer_id", transformation_type="source", parents=[])
+    assert_model(result, "model.model1", parents=["seed.seed1", ("seed.seed1", "age")])
+    assert_column(
+        result,
+        "model.model1",
+        "customer_id",
+        transformation_type="passthrough",
+        parents=[("seed.seed1", "customer_id")],
+    )
 
 
 def test_python_model(dbt_test_helper):
     def python_node(node):
-        node['language'] = 'python'
+        node["language"] = "python"
 
     csv_data_curr = """
     customer_id,name,age
@@ -53,20 +171,23 @@ def test_python_model(dbt_test_helper):
     2,Bob,25
     3,Charlie,35
     """
-    dbt_test_helper.create_model("model1",
-                                 curr_csv=csv_data_curr,
-                                 curr_columns={"customer_id": "varchar", "name": "varchar", "age": "int"})
-    dbt_test_helper.create_model("model2",
-                                 curr_csv=csv_data_curr,
-                                 curr_columns={"customer_id": "varchar", "name": "varchar", "age": "int"},
-                                 depends_on=["model1"],
-                                 patch_func=python_node)
+    dbt_test_helper.create_model(
+        "model1", curr_csv=csv_data_curr, curr_columns={"customer_id": "varchar", "name": "varchar", "age": "int"}
+    )
+    dbt_test_helper.create_model(
+        "model2",
+        curr_csv=csv_data_curr,
+        curr_columns={"customer_id": "varchar", "name": "varchar", "age": "int"},
+        depends_on=["model1"],
+        patch_func=python_node,
+    )
     adapter: DbtAdapter = dbt_test_helper.context.adapter
-    assert not adapter.is_python_model('model1')
-    assert adapter.is_python_model('model2')
+    assert not adapter.is_python_model("model1")
+    assert adapter.is_python_model("model2")
 
-    result = adapter.get_cll_by_node_id("model1")
-    assert result['nodes']['model2']['columns']['customer_id']['transformation_type'] == 'unknown'
+    result = adapter.get_cll("model2")
+    assert_model(result, "model2", parents=["model1"])
+    assert_column(result, "model2", "customer_id", transformation_type="unknown", parents=[])
 
 
 def test_source(dbt_test_helper):
@@ -80,23 +201,517 @@ def test_source(dbt_test_helper):
     dbt_test_helper.create_source(
         "source1",
         "table1",
+        unique_id="source.source1.table1",
         curr_csv=csv_data_curr,
-        curr_columns={"customer_id": "varchar", "name": "varchar", "age": "int"})
+        curr_columns={"customer_id": "varchar", "name": "varchar", "age": "int"},
+    )
+    dbt_test_helper.create_model(
+        "model1",
+        unique_id="model.model1",
+        curr_sql='select customer_id from {{ source("source1", "table1") }}',
+        curr_columns={"customer_id": "int"},
+        depends_on=["source.source1.table1"],
+    )
     adapter: DbtAdapter = dbt_test_helper.context.adapter
-    result = adapter.get_cll_by_node_id("source1.table1")
-    assert result['nodes']['source1.table1']['columns']['customer_id']['transformation_type'] == 'source'
+    result = adapter.get_cll("model.model1")
+    assert_column(result, "source.source1.table1", "customer_id", transformation_type="source", parents=[])
+    assert_column(
+        result,
+        "model.model1",
+        "customer_id",
+        transformation_type="passthrough",
+        parents=[("source.source1.table1", "customer_id")],
+    )
 
 
 def test_parse_error(dbt_test_helper):
     dbt_test_helper.create_model("model1", curr_sql="select 1 as c", curr_columns={"c": "int"})
-    dbt_test_helper.create_model("model2", curr_sql='this is not a valid sql', curr_columns={"c": "int"})
+    dbt_test_helper.create_model("model2", curr_sql="this is not a valid sql", curr_columns={"c": "int"})
     adapter: DbtAdapter = dbt_test_helper.context.adapter
-    result = adapter.get_cll_by_node_id("model2")
-    assert result['nodes']['model2']['columns']['c']['transformation_type'] == 'unknown'
+    result = adapter.get_cll("model2")
+    assert_column(result, "model2", "c", transformation_type="unknown", parents=[])
 
 
 def test_model_without_catalog(dbt_test_helper):
     dbt_test_helper.create_model("model1", curr_sql="select 1 as c")
     adapter: DbtAdapter = dbt_test_helper.context.adapter
-    result = adapter.get_cll_by_node_id("model1")
-    assert not hasattr(result['nodes']['model1'], 'columns')
+    result = adapter.get_cll("model1")
+    assert not result.nodes["model1"].columns
+
+
+def test_column_level_lineage(dbt_test_helper):
+    dbt_test_helper.create_model(
+        "model1", unique_id="model.model1", curr_sql="select 1 as c", curr_columns={"c": "int"}
+    )
+    dbt_test_helper.create_model(
+        "model2",
+        unique_id="model.model2",
+        curr_sql='select c, 2025 as y from {{ ref("model1") }}',
+        curr_columns={"c": "int", "y": "int"},
+        depends_on=["model.model1"],
+    )
+    dbt_test_helper.create_model(
+        "model3",
+        unique_id="model.model3",
+        curr_sql='select c from {{ ref("model2") }} where y < 2025',
+        curr_columns={"c": "int"},
+        depends_on=["model.model2"],
+    )
+    dbt_test_helper.create_model(
+        "model4",
+        unique_id="model.model4",
+        curr_sql='select y from {{ ref("model2") }}',
+        curr_columns={"y": "int"},
+        depends_on=["model.model2"],
+    )
+
+    adapter: DbtAdapter = dbt_test_helper.context.adapter
+
+    result = adapter.get_cll("model.model2", "c")
+    assert_cll_contain_nodes(result, [])
+    assert_cll_contain_columns(result, [("model.model1", "c"), ("model.model2", "c"), ("model.model3", "c")])
+    assert_column(result, "model.model2", "c", transformation_type="passthrough", parents=[("model.model1", "c")])
+
+    result = adapter.get_cll("model.model2", "y")
+    assert_cll_contain_nodes(result, ["model.model3"])
+    assert_cll_contain_columns(result, [("model.model2", "y"), ("model.model4", "y")])
+    assert_column(result, "model.model2", "y", transformation_type="source", parents=[])
+
+    result = adapter.get_cll("model.model3", "c")
+    assert_cll_contain_nodes(result, [])
+    assert_cll_contain_columns(result, [("model.model1", "c"), ("model.model2", "c"), ("model.model3", "c")])
+    assert_column(result, "model.model2", "c", transformation_type="passthrough", parents=[("model.model1", "c")])
+
+    result = adapter.get_cll("model.model2", "c", no_upstream=True, no_downstream=True)
+    assert_cll_contain_nodes(result, [])
+    assert_cll_contain_columns(result, [("model.model2", "c")])
+    assert_column(result, "model.model2", "c", transformation_type="passthrough", parents=[])
+
+
+def test_impact_radius_no_change_analysis_no_cll(dbt_test_helper):
+    dbt_test_helper.create_model(
+        "model1",
+        unique_id="model.model1",
+        curr_sql="select 1 as c",
+        base_sql="select 1 as c --- non-breaking",
+        curr_columns={"c": "int"},
+        base_columns={"c": "int"},
+    )
+    dbt_test_helper.create_model(
+        "model2",
+        unique_id="model.model2",
+        curr_sql='select c, 2025 as y from {{ ref("model1") }}',
+        base_sql='select c, 2025 as y from {{ ref("model1") }} where c > 0 --- breaking',
+        curr_columns={"c": "int", "y": "int"},
+        base_columns={"c": "int", "y": "int"},
+        depends_on=["model.model1"],
+    )
+    dbt_test_helper.create_model(
+        "model3",
+        unique_id="model.model3",
+        curr_sql='select c from {{ ref("model2") }} where y < 2025',
+        base_sql='select c from {{ ref("model2") }} where y < 2025',
+        curr_columns={"c": "int"},
+        base_columns={"c": "int"},
+        depends_on=["model.model2"],
+    )
+    dbt_test_helper.create_model(
+        "model4",
+        unique_id="model.model4",
+        curr_sql='select y + 1 as year from {{ ref("model2") }} --- partial breaking',
+        base_sql='select y as year from {{ ref("model2") }}',
+        curr_columns={"year": "int"},
+        base_columns={"year": "int"},
+        depends_on=["model.model2"],
+    )
+    dbt_test_helper.create_model(
+        "model5",
+        unique_id="model.model5",
+        curr_sql='select c, 2025 as y from {{ ref("model1") }}',
+        base_sql='select c, 2025 as y from {{ ref("model1") }}',
+        curr_columns={"c": "int", "y": "int"},
+        base_columns={"c": "int", "y": "int"},
+        depends_on=["model.model1"],
+    )
+
+    adapter: DbtAdapter = dbt_test_helper.context.adapter
+
+    result = adapter.get_cll(no_cll=True)
+    assert_cll_contain_nodes(result, ["model.model1", "model.model2", "model.model3", "model.model4", "model.model5"])
+    assert_model(result, "model.model1", parents=[])
+    assert_model(result, "model.model2", parents=["model.model1"])
+    assert_model(result, "model.model3", parents=["model.model2"])
+    assert_model(result, "model.model4", parents=["model.model2"])
+    assert_model(result, "model.model5", parents=["model.model1"])
+
+
+def test_impact_radius_with_change_analysis_no_cll(dbt_test_helper):
+    dbt_test_helper.create_model(
+        "model1",
+        unique_id="model.model1",
+        curr_sql="select 1 as c",
+        base_sql="select 1 as c --- non-breaking",
+        curr_columns={"c": "int"},
+        base_columns={"c": "int"},
+    )
+    dbt_test_helper.create_model(
+        "model2",
+        unique_id="model.model2",
+        curr_sql='select c, 2025 as y from {{ ref("model1") }}',
+        base_sql='select c, 2025 as y from {{ ref("model1") }} where c > 0 --- breaking',
+        curr_columns={"c": "int", "y": "int"},
+        base_columns={"c": "int", "y": "int"},
+        depends_on=["model.model1"],
+    )
+    dbt_test_helper.create_model(
+        "model3",
+        unique_id="model.model3",
+        curr_sql='select c from {{ ref("model2") }} where y < 2025',
+        base_sql='select c from {{ ref("model2") }} where y < 2025',
+        curr_columns={"c": "int"},
+        base_columns={"c": "int"},
+        depends_on=["model.model2"],
+    )
+    dbt_test_helper.create_model(
+        "model4",
+        unique_id="model.model4",
+        curr_sql='select y + 1 as year from {{ ref("model2") }} --- partial breaking',
+        base_sql='select y as year from {{ ref("model2") }}',
+        curr_columns={"year": "int"},
+        base_columns={"year": "int"},
+        depends_on=["model.model2"],
+    )
+    dbt_test_helper.create_model(
+        "model5",
+        unique_id="model.model5",
+        curr_sql='select c, 2025 as y from {{ ref("model1") }}',
+        base_sql='select c, 2025 as y from {{ ref("model1") }}',
+        curr_columns={"c": "int", "y": "int"},
+        base_columns={"c": "int", "y": "int"},
+        depends_on=["model.model1"],
+    )
+
+    adapter: DbtAdapter = dbt_test_helper.context.adapter
+
+    # breaking
+    result = adapter.get_cll(change_analysis=True, no_cll=True, no_upstream=True)
+    assert_cll_contain_nodes(result, ["model.model1", "model.model2", "model.model3", "model.model4"])
+    assert_model(result, "model.model1", parents=[], change_category="non_breaking", impacted=False)
+    assert_model(result, "model.model2", parents=[], change_category="breaking", impacted=True)
+    assert_model(result, "model.model3", parents=["model.model2"], change_category=None, impacted=True)
+    assert_model(result, "model.model4", parents=["model.model2"], change_category="partial_breaking", impacted=True)
+
+
+def test_impact_radius_with_change_analysis_no_cll_2(dbt_test_helper):
+    # partial breaking
+    dbt_test_helper.create_model(
+        "model1",
+        unique_id="model.model1",
+        curr_sql="select 1 as c",
+        base_sql="select 2 as c",
+        curr_columns={"c": "int"},
+        base_columns={"c": "int"},
+    )
+    # breaking
+    dbt_test_helper.create_model(
+        "model2",
+        unique_id="model.model2",
+        curr_sql='select c, 2025 as y from {{ ref("model1") }}',
+        base_sql='select c, 2025 as y from {{ ref("model1") }} where c > 0 --- breaking',
+        curr_columns={"c": "int", "y": "int"},
+        base_columns={"c": "int", "y": "int"},
+        depends_on=["model.model1"],
+    )
+    # no change
+    dbt_test_helper.create_model(
+        "model3",
+        unique_id="model.model3",
+        curr_sql='select c from {{ ref("model2") }} where y < 2025',
+        base_sql='select c from {{ ref("model2") }} where y < 2025',
+        curr_columns={"c": "int"},
+        base_columns={"c": "int"},
+        depends_on=["model.model2"],
+    )
+    # partial breaking
+    dbt_test_helper.create_model(
+        "model4",
+        unique_id="model.model4",
+        curr_sql='select y + 1 as year from {{ ref("model2") }} --- partial breaking',
+        base_sql='select y as year from {{ ref("model2") }}',
+        curr_columns={"year": "int"},
+        base_columns={"year": "int"},
+        depends_on=["model.model2"],
+    )
+    # no change
+    dbt_test_helper.create_model(
+        "model5",
+        unique_id="model.model5",
+        curr_sql='select c, 2025 as y from {{ ref("model1") }}',
+        base_sql='select c, 2025 as y from {{ ref("model1") }}',
+        curr_columns={"c": "int", "y": "int"},
+        base_columns={"c": "int", "y": "int"},
+        depends_on=["model.model1"],
+    )
+
+    adapter: DbtAdapter = dbt_test_helper.context.adapter
+
+    # breaking
+    result = adapter.get_cll(change_analysis=True, no_cll=True, no_upstream=True)
+    assert_cll_contain_nodes(result, ["model.model1", "model.model2", "model.model3", "model.model4", "model.model5"])
+    assert_model(result, "model.model1", parents=[], change_category="partial_breaking", impacted=True)
+    assert_model(result, "model.model2", parents=["model.model1"], change_category="breaking", impacted=True)
+    assert_model(result, "model.model3", parents=["model.model2"], change_category=None, impacted=True)
+    assert_model(result, "model.model4", parents=["model.model2"], change_category="partial_breaking", impacted=True)
+    assert_model(result, "model.model5", parents=["model.model1"], impacted=True)
+
+
+def test_impact_radius_with_change_analysis_with_cll(dbt_test_helper):
+    dbt_test_helper.create_model(
+        "model1",
+        unique_id="model.model1",
+        curr_sql="select 1 as c",
+        base_sql="select 1 as c --- non-breaking",
+        curr_columns={"c": "int"},
+        base_columns={"c": "int"},
+    )
+    dbt_test_helper.create_model(
+        "model2",
+        unique_id="model.model2",
+        curr_sql='select c, 2025 as y from {{ ref("model1") }}',
+        base_sql='select c, 2025 as y from {{ ref("model1") }} where c > 0 --- breaking',
+        curr_columns={"c": "int", "y": "int"},
+        base_columns={"c": "int", "y": "int"},
+        depends_on=["model.model1"],
+    )
+    dbt_test_helper.create_model(
+        "model3",
+        unique_id="model.model3",
+        curr_sql='select c from {{ ref("model2") }} where y < 2025',
+        base_sql='select c from {{ ref("model2") }} where y < 2025',
+        curr_columns={"c": "int"},
+        base_columns={"c": "int"},
+        depends_on=["model.model2"],
+    )
+    dbt_test_helper.create_model(
+        "model4",
+        unique_id="model.model4",
+        curr_sql='select y + 1 as year from {{ ref("model2") }} --- partial breaking',
+        base_sql='select y as year from {{ ref("model2") }}',
+        curr_columns={"year": "int"},
+        base_columns={"year": "int"},
+        depends_on=["model.model2"],
+    )
+    dbt_test_helper.create_model(
+        "model5",
+        unique_id="model.model5",
+        curr_sql='select c, 2025 as y from {{ ref("model1") }}',
+        base_sql='select c, 2025 as y from {{ ref("model1") }}',
+        curr_columns={"c": "int", "y": "int"},
+        base_columns={"c": "int", "y": "int"},
+        depends_on=["model.model1"],
+    )
+
+    adapter: DbtAdapter = dbt_test_helper.context.adapter
+
+    result = adapter.get_cll(change_analysis=True, no_upstream=True)
+    assert_cll_contain_nodes(result, ["model.model1", "model.model2", "model.model3", "model.model4"])
+    assert_cll_contain_columns(result, [("model.model4", "year")])
+    assert_model(result, "model.model1", parents=[], change_category="non_breaking", impacted=False)
+    assert_model(result, "model.model2", parents=[], change_category="breaking", impacted=True)
+    assert_model(result, "model.model3", parents=["model.model2"], change_category=None, impacted=True)
+    assert_model(result, "model.model4", parents=["model.model2"], change_category="partial_breaking", impacted=True)
+
+
+def test_impact_radius_with_change_analysis_with_cll_added_removed(dbt_test_helper):
+    # rename model
+    dbt_test_helper.create_model(
+        "model1",
+        unique_id="model.model1",
+        base_sql="select 1 as c",
+        base_columns={"c": "int"},
+    )
+    dbt_test_helper.create_model(
+        "model1_v2",
+        unique_id="model.model1_v2",
+        curr_sql="select 1 as c",
+        curr_columns={"c": "int"},
+    )
+    # change upstream
+    dbt_test_helper.create_model(
+        "model2",
+        unique_id="model.model2",
+        base_sql='select c from {{ ref("model1") }}',
+        base_columns={"c": "int"},
+        depends_on=["model.model1"],
+    )
+    dbt_test_helper.create_model(
+        "model2",
+        unique_id="model.model2",
+        curr_sql='select c from {{ ref("model1_v2") }}',
+        curr_columns={"c": "int"},
+        depends_on=["model.model1_v2"],
+    )
+
+    adapter: DbtAdapter = dbt_test_helper.context.adapter
+    result = adapter.get_cll(change_analysis=True, no_upstream=True)
+    assert_model(result, "model.model1_v2", parents=[], impacted=True)
+    assert_column(result, "model.model1_v2", "c", transformation_type="source", change_status="added", parents=[])
+    assert_model(result, "model.model2", parents=["model.model1_v2"], change_category="breaking", impacted=True)
+    assert_cll_contain_nodes(result, ["model.model1_v2", "model.model2"])
+    assert_cll_contain_columns(result, [("model.model1_v2", "c"), ("model.model2", "c")])
+
+
+def test_impact_radius_by_node_no_cll(dbt_test_helper):
+    # non-breaking
+    dbt_test_helper.create_model(
+        "model1",
+        unique_id="model.model1",
+        curr_sql="select 1 as c",
+        base_sql="select 1 as c --- non-breaking",
+        curr_columns={"c": "int"},
+        base_columns={"c": "int"},
+    )
+    # breaking
+    dbt_test_helper.create_model(
+        "model2",
+        unique_id="model.model2",
+        curr_sql='select c, 2025 as y from {{ ref("model1") }}',
+        base_sql='select c, 2025 as y from {{ ref("model1") }} where c > 0 --- breaking',
+        curr_columns={"c": "int", "y": "int"},
+        base_columns={"c": "int", "y": "int"},
+        depends_on=["model.model1"],
+    )
+    dbt_test_helper.create_model(
+        "model3",
+        unique_id="model.model3",
+        curr_sql='select c from {{ ref("model2") }} where y < 2025',
+        base_sql='select c from {{ ref("model2") }} where y < 2025',
+        curr_columns={"c": "int"},
+        base_columns={"c": "int"},
+        depends_on=["model.model2"],
+    )
+    dbt_test_helper.create_model(
+        "model4",
+        unique_id="model.model4",
+        curr_sql='select y from {{ ref("model2") }}',
+        base_sql='select y from {{ ref("model2") }}',
+        curr_columns={"y": "int"},
+        base_columns={"y": "int"},
+        depends_on=["model.model2"],
+    )
+
+    adapter: DbtAdapter = dbt_test_helper.context.adapter
+
+    # breaking
+    result = adapter.get_cll(node_id="model.model2", change_analysis=True, no_cll=True, no_upstream=True)
+    assert_cll_contain_nodes(result, ["model.model2", "model.model3", "model.model4"])
+
+    # non-breaking
+    result = adapter.get_cll(node_id="model.model1", change_analysis=True, no_cll=True, no_upstream=True)
+    assert_cll_contain_nodes(result, ["model.model1"])
+
+
+def test_impact_radius_by_node_with_cll(dbt_test_helper):
+    # added column
+    dbt_test_helper.create_model(
+        "model1",
+        unique_id="model.model1",
+        curr_sql="select 1 as c, 2 as d --- add d",
+        base_sql="select 1 as c",
+        curr_columns={"c": "int", "d": "int"},
+        base_columns={"c": "int"},
+    )
+    # modified column
+    dbt_test_helper.create_model(
+        "model2",
+        unique_id="model.model2",
+        curr_sql='select c, 2024 as y from {{ ref("model1") }} --- modify y',
+        base_sql='select c, 2025 as y from {{ ref("model1") }}',
+        curr_columns={"c": "int", "y": "int"},
+        base_columns={"c": "int", "y": "int"},
+        depends_on=["model.model1"],
+    )
+    dbt_test_helper.create_model(
+        "model3",
+        unique_id="model.model3",
+        curr_sql='select c from {{ ref("model2") }} where y < 2025',
+        base_sql='select c from {{ ref("model2") }} where y < 2025',
+        curr_columns={"c": "int"},
+        base_columns={"c": "int"},
+        depends_on=["model.model2"],
+    )
+    dbt_test_helper.create_model(
+        "model4",
+        unique_id="model.model4",
+        curr_sql='select y from {{ ref("model2") }}',
+        base_sql='select y from {{ ref("model2") }}',
+        curr_columns={"y": "int"},
+        base_columns={"y": "int"},
+        depends_on=["model.model2"],
+    )
+
+    adapter: DbtAdapter = dbt_test_helper.context.adapter
+
+    result = adapter.get_cll(node_id="model.model2", change_analysis=True, no_upstream=True)
+    assert_model(result, "model.model2", parents=[], change_category="partial_breaking", impacted=False)
+    assert_model(result, "model.model3", parents=[("model.model2", "y")], impacted=True)
+    assert_column(result, "model.model2", "y", transformation_type="source", parents=[], change_status="modified")
+    assert_cll_contain_nodes(result, ["model.model2", "model.model3"])
+    assert_cll_contain_columns(result, [("model.model2", "y"), ("model.model4", "y")])
+
+    result = adapter.get_cll(node_id="model.model1", change_analysis=True, no_upstream=True)
+    assert_cll_contain_nodes(result, ["model.model1"])
+    assert_cll_contain_columns(result, [("model.model1", "d")])
+    assert_model(result, "model.model1", parents=[], change_category="non_breaking", impacted=False)
+    assert_column(result, "model.model1", "d", transformation_type="source", parents=[], change_status="added")
+
+
+def test_impact_radius_by_node_with_cll_2(dbt_test_helper):
+    # added column
+    dbt_test_helper.create_model(
+        "model1",
+        unique_id="model.model1",
+        curr_sql="select 1 as c, 2 as d --- add d",
+        base_sql="select 1 as c",
+        curr_columns={"c": "int", "d": "int"},
+        base_columns={"c": "int"},
+    )
+    # breaking, added column, modified column
+    dbt_test_helper.create_model(
+        "model2",
+        unique_id="model.model2",
+        curr_sql='select c, 2024 as y, d from {{ ref("model1") }} --- modify y, add d',
+        base_sql='select c, 2025 as y from {{ ref("model1") }} where c > 0 --- breaking',
+        curr_columns={"c": "int", "y": "int", "d": "int"},
+        base_columns={"c": "int", "y": "int"},
+        depends_on=["model.model1"],
+    )
+    dbt_test_helper.create_model(
+        "model3",
+        unique_id="model.model3",
+        curr_sql='select c from {{ ref("model2") }} where y < 2025',
+        base_sql='select c from {{ ref("model2") }} where y < 2025',
+        curr_columns={"c": "int"},
+        base_columns={"c": "int"},
+        depends_on=["model.model2"],
+    )
+    dbt_test_helper.create_model(
+        "model4",
+        unique_id="model.model4",
+        curr_sql='select y from {{ ref("model2") }}',
+        base_sql='select y from {{ ref("model2") }}',
+        curr_columns={"y": "int"},
+        base_columns={"y": "int"},
+        depends_on=["model.model2"],
+    )
+
+    adapter: DbtAdapter = dbt_test_helper.context.adapter
+
+    result = adapter.get_cll(node_id="model.model2", change_analysis=True, no_upstream=True)
+    assert_model(result, "model.model2", parents=[], change_category="breaking", impacted=True)
+    assert_column(result, "model.model2", "y", transformation_type="source", parents=[], change_status="modified")
+    assert_model(result, "model.model3", parents=["model.model2", ("model.model2", "y")], impacted=True)
+    assert_model(result, "model.model4", parents=["model.model2"], impacted=True)
+    assert_column(result, "model.model4", "y", transformation_type="passthrough", parents=[("model.model2", "y")])
+    assert_cll_contain_nodes(result, ["model.model2", "model.model3", "model.model4"])
+    assert_cll_contain_columns(result, [("model.model2", "d"), ("model.model2", "y"), ("model.model4", "y")])