Implement update() function

python/cudf/cudf/core/dataframe.py

@@ -1456,6 +1456,90 @@ def add(self, other, axis="columns", level=None, fill_value=None):
 
         return self._apply_op("add", other, fill_value)
 
+
+    def update(self, other, join="left", overwrite=True, filter_func=None, errors="ignore"):
+        """
+        Modify a DataFrame in place using non-NA values from another DataFrame.
+
+        Aligns on indices. There is no return value.
+
+        Parameters
+        ----------
+        other : DataFrame, or object coercible into a DataFrame
+            Should have at least one matching index/column label with the 
+            original DataFrame. If a Series is passed, its name attribute must
+            be set, and that will be used as the column name to align with the 
+            original DataFrame.
+
+        join : {‘left’}, default ‘left’
+            Only left join is implemented, keeping the index and 
+            columns of the original object.
+
+        overwrite : {True, False}, default True
+            How to handle non-NA values for overlapping keys:
+            True: overwrite original DataFrame’s values with values from other.
+            False: only update values that are NA in the original DataFrame.
+
+        filter_func : None
+            filter_func is not supported yet
+            Return True for values that should be updated.
+
+        errors : {‘raise’, ‘ignore’}, default ‘ignore’
+            If ‘raise’, will raise a ValueError if the DataFrame and other both contain non-NA data in the same place.
+
+
+        Returns
+        -------
+        None : method directly changes calling object
+
+        Raises
+        -------
+        ValueError
+            - When ``errors``= 'raise' and there’s overlapping non-NA data.
+            - When ``errors`` is not either 'ignore' or 'raise'
+
+        NotImplementedError
+            - If ``join`` != ‘left’
+
+        """
+        # TODO: Support other joins
+        if join != "left": 
+            raise NotImplementedError("Only left join is supported")
+        if errors not in {"ignore", "raise"}:
+            raise ValueError("The parameter errors must be either 'ignore' or 'raise'")
+        if filter_func != None:
+            raise NotImplementedError("filter_func is not supported yet")
+
+        if not isinstance(other, DataFrame):
+            other = DataFrame(other)
+
+        if self.columns.any() != other.columns.any():
+            other = other.reindex(self.columns, axis=1)
+        if self.index.any() != other.index.any():
+            other = other.reindex(self.index, axis=0)
+
+        for col in self.columns: 
+            this = self[col]
+            that = other[col]  
+
+            if errors == "raise":
+                mask_this = that.notna()
+                mask_that = this.notna()
+                if ((mask_this & mask_that).any()):
+                    raise ValueError("Data overlaps.")
+
+            if overwrite:
+                mask = that.isna()
+            else:
+                mask = this.notna()
+
+            # don't overwrite columns unnecessarily
+            if mask.all():
+                continue
+
+            self[col] = this.where(mask, that)
+
+
     def __add__(self, other):
         return self._apply_op("__add__", other)
 

python/cudf/cudf/tests/test_dataframe.py

@@ -8191,3 +8191,63 @@ def test_agg_for_dataframe_with_string_columns(aggs):
         ),
     ):
         gdf.agg(aggs)
+
+
+@pytest.mark.parametrize("join",["left"],)
+@pytest.mark.parametrize("overwrite",[True, False],)
+@pytest.mark.parametrize("filter_func",[None],)
+@pytest.mark.parametrize("errors",["ignore"],)
+@pytest.mark.parametrize(
+    "data",
+    [
+        {"a": [1, 2, 3], "b": [3, 4, 5]},
+        {"a": [1.0, 2.0, 3.0], "b": [3.0, 4.0, 5.0]},
+        {"a": [False, False, True], "b": [True, True, False]},
+        {"a": [2.0, np.nan, 4.0], "b": [np.nan, np.nan, np.nan]},
+        {"a": [np.nan, np.nan, np.nan], "b": [np.nan, np.nan, np.nan]},
+    ],
+)
+@pytest.mark.parametrize(
+    "data2",
+    [
+        {"a": [7, 5, 8], "b": [2.0, 7.0, 9.0]},
+        {"a": [True, False, True], "b":[3.0, 4.0, 5.0]},
+        {"a": [np.nan, np.nan, np.nan], "b": [np.nan, np.nan, np.nan]},
+        {"a": [np.nan, 2.0, np.nan], "b": [2, np.nan, 5.0]}, 
+    ],
+)
+def test_update_for_dataframes(data, data2, join, overwrite, filter_func, errors):
+    pdf = pd.DataFrame(data)
+    gdf = gd.DataFrame(data)
+
+    other_pd = pd.DataFrame(data2)
+    other_gd = gd.DataFrame(data2)
+
+    expect = pdf.update(other_pd, join, overwrite, filter_func, errors)
+    got = gdf.update(other_gd, join, overwrite, filter_func, errors)
+
+    assert_eq(expect, got)
+
+@pytest.mark.parametrize("join",["right"],)
+def test_update_for_right_join(join):
+    pdf = pd.DataFrame({"a": [1, 2, 3], "b": [3.0, 4.0, 5.0]})
+    gdf = gd.DataFrame({"a": [1, 2, 3], "b": [3.0, 4.0, 5.0]})
+
+    other_pd = pd.DataFrame({"a": [1, np.nan, 3], "b": [np.nan, 2.0, 5.0]})
+    other_gd = gd.DataFrame({"a": [1, np.nan, 3], "b": [np.nan, 2.0, 5.0]})
+
+    with pytest.raises(
+        NotImplementedError,
+        match="Only left join is supported"
+    ):
+        gdf.update(other_gd,join)
+
+@pytest.mark.parametrize("errors",["raise"],)
+def test_update_for_data_overlap(errors):
+    pdf = pd.DataFrame({"a": [1, 2, 3], "b": [3.0, 4.0, 5.0]})
+    gdf = gd.DataFrame({"a": [1, 2, 3], "b": [3.0, 4.0, 5.0]})
+
+    other_pd = pd.DataFrame({"a": [1, np.nan, 3], "b": [np.nan, 2.0, 5.0]})
+    other_gd = gd.DataFrame({"a": [1, np.nan, 3], "b": [np.nan, 2.0, 5.0]})
+
+    assert_exceptions_equal(lambda: pdf.update(other_pd,errors), lambda: gdf.update(other_gd,errors))