BUG / CoW: also return new object in case of null slice for both rows and columsn (.(i)loc[:, :])

pandas/core/indexing.py

@@ -13,6 +13,8 @@
 
 import numpy as np
 
+from pandas._config import get_option
+
 from pandas._libs.indexing import NDFrameIndexerBase
 from pandas._libs.lib import item_from_zerodim
 from pandas._typing import (
@@ -934,6 +936,12 @@ def _getitem_tuple_same_dim(self, tup: tuple):
             #  be handled by the _getitem_lowerdim call above.
             assert retval.ndim == self.ndim
 
+        if retval is self.obj and (
+            get_option("mode.copy_on_write")
+            and get_option("mode.data_manager") == "block"
+        ):
+            retval = retval.copy(deep=False)
+
         return retval
 
     @final

pandas/tests/copy_view/test_indexing.py

@@ -612,6 +612,68 @@ def test_subset_chained_single_block_row(using_copy_on_write, using_array_manage
         assert subset.iloc[0] == 0
 
 
+@pytest.mark.parametrize(
+    "method",
+    [
+        lambda df: df[:],
+        lambda df: df.loc[:, :],
+        lambda df: df.loc[:],
+        lambda df: df.iloc[:, :],
+        lambda df: df.iloc[:],
+    ],
+    ids=["getitem", "loc", "loc-rows", "iloc", "iloc-rows"],
+)
+def test_null_slice(request, method, using_copy_on_write):
+    # Case: also all variants of indexing with a null slice (:) should return
+    # new objects to ensure we correctly use CoW for the results
+    df = DataFrame({"a": [1, 2, 3], "b": [4, 5, 6], "c": [7, 8, 9]})
+    df_orig = df.copy()
+
+    df2 = method(df)
+
+    # with CoW, we always return new objects
+    if using_copy_on_write:
+        assert df2 is not df
+    else:
+        if request.node.callspec.id in ("loc", "iloc"):
+            assert df2 is df
+        else:
+            assert df2 is not df
+
+    # and those trigger CoW when mutated
+    df2.iloc[0, 0] = 0
+    if using_copy_on_write:
+        tm.assert_frame_equal(df, df_orig)
+    else:
+        assert df.iloc[0, 0] == 0
+
+
+@pytest.mark.parametrize(
+    "method",
+    [
+        lambda s: s[:],
+        lambda s: s.loc[:],
+        lambda s: s.iloc[:],
+    ],
+    ids=["getitem", "loc", "iloc"],
+)
+def test_null_slice_series(request, method, using_copy_on_write):
+    s = Series([1, 2, 3], index=["a", "b", "c"])
+    s_orig = s.copy()
+
+    s2 = method(s)
+
+    # with CoW, we always return new objects (also for non-CoW this is the case)
+    assert s2 is not s
+
+    # and those trigger CoW when mutated
+    s2.iloc[0] = 0
+    if using_copy_on_write:
+        tm.assert_series_equal(s, s_orig)
+    else:
+        assert s.iloc[0] == 0
+
+
 # TODO add more tests modifying the parent
 
 

pandas/tests/indexing/test_loc.py

@@ -1115,7 +1115,10 @@ def test_identity_slice_returns_new_object(
             assert (sliced_df["a"] == 4).all()
 
         # These should not return copies
-        assert original_df is original_df.loc[:, :]
+        if using_copy_on_write:
+            assert original_df is not original_df.loc[:, :]
+        else:
+            assert original_df is original_df.loc[:, :]
         df = DataFrame(np.random.randn(10, 4))
         assert df[0] is df.loc[:, 0]