handle corner case of null ptr

Author: shuoweil

bigframes/core/blocks.py

@@ -2488,6 +2488,11 @@ def join(
             )
             if result is not None:
                 return result
+
+            # For block identify joins with null indices, perform cross join
+            if block_identity_join and how == "left":
+                return join_with_single_row(self, other)
+
             raise bigframes.exceptions.NullIndexError(
                 "Cannot implicitly align objects. Set an explicit index using set_index."
             )

bigframes/dataframe.py

@@ -2289,7 +2289,7 @@ def _assign_series_join_on_index(
         self, label: str, series: bigframes.series.Series
     ) -> DataFrame:
         block, (get_column_left, get_column_right) = self._block.join(
-            series._block, how="left"
+            series._block, how="left", block_identity_join=True
         )
 
         column_ids = [

tests/system/small/test_dataframe.py

@@ -2949,6 +2949,28 @@ def test_df_join_series(scalars_dfs, how):
         assert_pandas_df_equal(bf_result, pd_result, ignore_order=True)
 
 
+def test_dataframe_assign_series_null_index_partial_ordering(
+    scalars_df_null_index: bigframes.dataframe.DataFrame,
+    unordered_session: bigframes.Session,
+):
+    """Test that DataFrame column assignment works with null indices in partial ordering mode."""
+
+    # Use existing null index DataFrame but create Series in unordered session
+    df = scalars_df_null_index[["int64_col", "string_col"]].head(3)
+    # Create Series with explicit values in unordered session
+    series_to_assign = bpd.Series([10, 20, 30], session=unordered_session)
+
+    df["new_col"] = series_to_assign
+    result_df = df.to_pandas(ordered=False)
+
+    # Verify the column was added and has the correct length
+    assert "new_col" in result_df.columns
+    assert len(result_df) == 3
+
+    # Verify the assigned values are exactly what we expect
+    assert result_df["new_col"].tolist() == [10, 20, 30]
+
+
 @pytest.mark.parametrize(
     ("by", "ascending", "na_position"),
     [

tests/system/small/test_null_index.py

@@ -16,6 +16,9 @@
 import pandas as pd
 import pytest
 
+import bigframes.core
+import bigframes.core.blocks as blocks
+import bigframes.core.local_data as local_data
 import bigframes.exceptions
 import bigframes.pandas as bpd
 
@@ -398,5 +401,49 @@ def test_null_index_transpose(scalars_df_null_index):
         _ = scalars_df_null_index.T
 
 
-def test_null_index_contains(scalars_df_null_index):
-    assert 3 not in scalars_df_null_index
+@pytest.mark.parametrize(
+    ("session_fixture",),
+    [
+        pytest.param("session"),
+        pytest.param("unordered_session"),
+    ],
+)
+def test_block_join_identity_null_index(request, session_fixture):
+    """Test the Block.join method with block_identity_join=True and null indices."""
+
+    session = request.getfixturevalue(session_fixture)
+
+    left_data = pd.DataFrame({"a": [1, 2, 3]})
+    right_data = pd.DataFrame({"b": [10, 20, 30]})
+
+    left_managed = local_data.ManagedArrowTable.from_pandas(left_data)
+    right_managed = local_data.ManagedArrowTable.from_pandas(right_data)
+
+    left_array = bigframes.core.ArrayValue.from_managed(left_managed, session=session)
+    right_array = bigframes.core.ArrayValue.from_managed(right_managed, session=session)
+
+    # Create blocks with empty index_columns to get null indices
+    left_block = blocks.Block(
+        left_array,
+        index_columns=[],
+        column_labels=["a"],
+    )
+    right_block = blocks.Block(
+        right_array,
+        index_columns=[],
+        column_labels=["b"],
+    )
+
+    # Test the join with block_identity_join=True
+    result_block, (left_mapping, right_mapping) = left_block.join(
+        right_block, how="left", block_identity_join=True
+    )
+
+    # Verify both have null indices
+    assert left_block.index.nlevels == 0
+    assert right_block.index.nlevels == 0
+
+    # Verify the join succeeded
+    assert result_block is not None
+    assert len(left_mapping) > 0
+    assert len(right_mapping) > 0