fix(bigquery): wrap model in subquery before aliasing in test_unique/not_null

`get_where_subquery` renders `model` as `(select * from <rel> where ...)
dbt_subquery` for `where:`-filtered generic tests. The previous form
`from {{ model }} dbt_test__source` produced an invalid double alias
`(...) dbt_subquery dbt_test__source` in that case. Wrap `model` in
`(select * from {{ model }})` before applying the `dbt_test__source`
alias so the macros work whether `model` is a bare relation or an
already-aliased subquery.

Add a regression test that exercises `unique` and `not_null` with the
column/table name collision under a `where:` config, and switch the
existing test's result lookup to prefix matching so it surfaces a clear
error if generic-test node naming changes.

Author: 1fanwang

dbt-bigquery/.changes/unreleased/Fixes-20260427-083810.yaml

@@ -1,7 +1,9 @@
 kind: Fixes
 body: Alias the source relation in `bigquery__test_unique` and add a `bigquery__test_not_null`
   override so that columns sharing a name with their model resolve to the column
-  value instead of BigQuery's row STRUCT, fixing dbt-core#11067.
+  value instead of BigQuery's row STRUCT. The relation is wrapped in a subquery
+  before aliasing so `where:`-filtered tests, where `get_where_subquery` already
+  emits a `dbt_subquery` alias, still produce valid SQL. Fixes dbt-core#11067.
 time: 2026-04-27T08:38:10.000000+00:00
 custom:
   Author: "1fanwang"

dbt-bigquery/src/dbt/include/bigquery/macros/adapters.sql

@@ -211,13 +211,17 @@
 
 {# When a column has the same name as its table, BigQuery resolves an unqualified
    column reference to the row STRUCT instead of the column value. Aliasing the
-   relation and qualifying the column reference forces resolution to the column. #}
+   relation and qualifying the column reference forces resolution to the column.
+   `model` is wrapped in a subquery before aliasing because `get_where_subquery`
+   may already render it as `(...) dbt_subquery` for `where:`-filtered tests; a
+   bare `{{ model }} dbt_test__source` would then produce an invalid double
+   alias. #}
 {% macro bigquery__test_unique(model, column_name) %}
 
 with dbt_test__target as (
 
   select dbt_test__source.{{ column_name }} as unique_field
-  from {{ model }} dbt_test__source
+  from (select * from {{ model }}) dbt_test__source
   where dbt_test__source.{{ column_name }} is not null
 
 )
@@ -232,14 +236,16 @@ having count(*) > 1
 
 {% endmacro %}
 
-{# Same row-vs-column resolution issue as bigquery__test_unique: alias the
-   relation and qualify the column reference. #}
+{# Same row-vs-column resolution issue as bigquery__test_unique. `model` is
+   wrapped in a subquery before aliasing so `where:`-filtered tests, where
+   `get_where_subquery` already adds a `dbt_subquery` alias, do not produce an
+   invalid double alias. #}
 {% macro bigquery__test_not_null(model, column_name) %}
 
 {% set column_list = '*' if should_store_failures() else 'dbt_test__source.' ~ column_name %}
 
 select {{ column_list }}
-from {{ model }} dbt_test__source
+from (select * from {{ model }}) dbt_test__source
 where dbt_test__source.{{ column_name }} is null
 
 {% endmacro %}

dbt-bigquery/tests/functional/adapter/generic_tests/test_column_table_name_collision.py

@@ -36,6 +36,46 @@
 """.lstrip()
 
 
+# Same column/table name collision but with a `where:` filter on each test.
+# `get_where_subquery` renders `model` as `(select * from <rel> where ...)
+# dbt_subquery`; the BigQuery overrides must still compile and execute against
+# that already-aliased subquery.
+_SCHEMA_WHERE_YML = """
+version: 2
+models:
+  - name: orders
+    columns:
+      - name: orders
+        data_tests:
+          - unique:
+              config:
+                where: "orders is not null"
+          - not_null:
+              config:
+                where: "orders is not null or orders is null"
+""".lstrip()
+
+
+def _result_for_prefix(results, prefix):
+    """Look up a test result by node-name prefix.
+
+    Generic test node names (`unique_<model>_<column>` etc.) are stable today
+    but tying assertions to the literal name makes the test brittle across dbt
+    versions if naming gains suffixes. Match on prefix and surface a clear
+    error if the expected result is missing.
+    """
+    matches = [r for r in results if r.node.name.startswith(prefix)]
+    assert matches, (
+        f"expected a test result whose node name starts with {prefix!r}; "
+        f"found: {sorted(r.node.name for r in results)}"
+    )
+    assert len(matches) == 1, (
+        f"expected exactly one result for prefix {prefix!r}; "
+        f"got: {[r.node.name for r in matches]}"
+    )
+    return matches[0]
+
+
 class TestBigQueryGenericTestsColumnTableNameCollision:
     @pytest.fixture(scope="class")
     def models(self):
@@ -50,18 +90,53 @@ def test_unique_and_not_null_detect_failures(self, project):
 
         assert len(results) == 2
 
-        statuses = {r.node.name: (r.status, r.failures) for r in results}
-
-        unique_status, unique_failures = statuses["unique_orders_orders"]
-        assert unique_status == "fail", (
-            f"unique test passed unexpectedly (status={unique_status}); "
+        unique_result = _result_for_prefix(results, "unique_")
+        assert unique_result.status == "fail", (
+            f"unique test passed unexpectedly (status={unique_result.status}); "
             "with the bug, the row-struct grouping can mask duplicates"
         )
-        assert unique_failures >= 1
+        assert unique_result.failures >= 1
 
-        not_null_status, not_null_failures = statuses["not_null_orders_orders"]
-        assert not_null_status == "fail", (
-            f"not_null test passed unexpectedly (status={not_null_status}); "
+        not_null_result = _result_for_prefix(results, "not_null_")
+        assert not_null_result.status == "fail", (
+            f"not_null test passed unexpectedly (status={not_null_result.status}); "
             "with the bug, the row-struct nullness check masks the null column value"
         )
-        assert not_null_failures >= 1
+        assert not_null_result.failures >= 1
+
+
+class TestBigQueryGenericTestsColumnTableNameCollisionWithWhere:
+    """`where:`-filtered tests render `model` as `(select * from <rel> where ...)
+    dbt_subquery`. The BigQuery overrides wrap `model` in another subquery
+    before aliasing so this case still produces valid SQL."""
+
+    @pytest.fixture(scope="class")
+    def models(self):
+        return {
+            "orders.sql": _MODEL_SQL,
+            "schema.yml": _SCHEMA_WHERE_YML,
+        }
+
+    def test_unique_and_not_null_compile_with_where_filter(self, project):
+        run_dbt(["run"])
+        # `expect_pass=False` because the `not_null` test still observes the
+        # null row (its `where:` keeps null values); the `unique` test still
+        # sees duplicates of `orders=1`. The important assertion is that the
+        # SQL compiles and runs at all when `model` is an aliased subquery.
+        results = run_dbt(["test"], expect_pass=False)
+
+        assert len(results) == 2
+
+        unique_result = _result_for_prefix(results, "unique_")
+        assert unique_result.status == "fail", (
+            f"unique test status was {unique_result.status}; "
+            "expected fail because duplicate non-null orders remain after the where filter"
+        )
+        assert unique_result.failures >= 1
+
+        not_null_result = _result_for_prefix(results, "not_null_")
+        assert not_null_result.status == "fail", (
+            f"not_null test status was {not_null_result.status}; "
+            "expected fail because the where filter retains the null row"
+        )
+        assert not_null_result.failures >= 1