fix(bigquery): qualify column refs in test_unique/test_not_null to avoid row-struct resolution

When a column shares its name with the model, BigQuery's identifier
resolution returns the row STRUCT rather than the column value for
unqualified references. The default `bigquery__test_unique` and the
inherited `default__test_not_null` therefore evaluated WHERE/GROUP BY
against the row struct, masking duplicates and nulls.

Alias the source relation as `dbt_test__source` and qualify the column
references in `bigquery__test_unique`, and add a `bigquery__test_not_null`
override that does the same. Adds a regression test that creates a
single-column model whose column name matches the model name and
asserts both generic tests detect failures.

Resolves dbt-core#11067.

Author: 1fanwang

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

@@ -0,0 +1,8 @@
+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.
+time: 2026-04-27T08:38:10.000000+00:00
+custom:
+  Author: "1fanwang"
+  Issue: "11067"

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

@@ -209,13 +209,16 @@
 {% endmacro %}
 
 
+{# 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. #}
 {% macro bigquery__test_unique(model, column_name) %}
 
 with dbt_test__target as (
 
-  select {{ column_name }} as unique_field
-  from {{ model }}
-  where {{ column_name }} is not null
+  select dbt_test__source.{{ column_name }} as unique_field
+  from {{ model }} dbt_test__source
+  where dbt_test__source.{{ column_name }} is not null
 
 )
 
@@ -229,6 +232,18 @@ having count(*) > 1
 
 {% endmacro %}
 
+{# Same row-vs-column resolution issue as bigquery__test_unique: alias the
+   relation and qualify the column reference. #}
+{% 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
+where dbt_test__source.{{ column_name }} is null
+
+{% endmacro %}
+
 {% macro bigquery__upload_file(local_file_path, database, table_schema, table_name) %}
 
   {{ log("kwargs: " ~ kwargs) }}

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

@@ -0,0 +1,67 @@
+"""
+Regression test for dbt-core#11067.
+
+When a column has the same name as its table, BigQuery resolves an unqualified
+column reference to the row STRUCT (containing all of the row's columns) rather
+than to the column value. The default `unique` and `not_null` generic tests
+emit unqualified column references, which means the resulting SQL filters and
+groups against the row struct instead of the column. After the fix in
+`bigquery__test_unique` and `bigquery__test_not_null`, the source relation is
+aliased and column references are qualified, so the tests evaluate against the
+column as expected.
+"""
+
+import pytest
+
+from dbt.tests.util import run_dbt
+
+
+_MODEL_SQL = """
+select 1 as orders union all
+select 1 as orders union all
+select 2 as orders union all
+select cast(null as int64) as orders
+""".lstrip()
+
+
+_SCHEMA_YML = """
+version: 2
+models:
+  - name: orders
+    columns:
+      - name: orders
+        data_tests:
+          - unique
+          - not_null
+""".lstrip()
+
+
+class TestBigQueryGenericTestsColumnTableNameCollision:
+    @pytest.fixture(scope="class")
+    def models(self):
+        return {
+            "orders.sql": _MODEL_SQL,
+            "schema.yml": _SCHEMA_YML,
+        }
+
+    def test_unique_and_not_null_detect_failures(self, project):
+        run_dbt(["run"])
+        results = run_dbt(["test"], expect_pass=False)
+
+        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}); "
+            "with the bug, the row-struct grouping can mask duplicates"
+        )
+        assert unique_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}); "
+            "with the bug, the row-struct nullness check masks the null column value"
+        )
+        assert not_null_failures >= 1