code: def _merge_results(
      self, left_result: cudf.DataFrame, right_result: cudf.DataFrame
  ):
      # Merge the DataFrames `left_result` and `right_result` into a single
      # `DataFrame`, suffixing column names if necessary.
  
      # If two key columns have the same name, a single output column appears
      # in the result. For all non-outer join types, the key column from the
      # rhs is simply dropped. For outer joins, the two key columns are
      # combined by filling nulls in the left key column with corresponding
      # values from the right key column:
      if self.how == "outer":
          for lkey, rkey in zip(self._left_keys, self._right_keys):
              if lkey.name == rkey.name:
                  # fill nulls in lhs from values in the rhs
                  lkey.set(
                      left_result,
                      lkey.get(left_result).fillna(
                          rkey.get(right_result)
                      ),
                      validate=False,
                  )
  
      # All columns from the left table make it into the output. Non-key
      # columns that share a name with a column in the right table are
      # suffixed with the provided suffix.
      common_names = set(left_result._data.names) & set(
          right_result._data.names
      )
      cols_to_suffix = common_names - self._key_columns_with_same_name
      data = {
          (
              f"{name}{self.lsuffix}"
              if name in cols_to_suffix
              else name
          ): col
          for name, col in left_result._data.items()
      }
  
      # The right table follows the same rule as the left table except that
      # key columns from the right table are removed.
      for name, col in right_result._data.items():
          if name in common_names:
              if name not in self._key_columns_with_same_name:
                  data[f"{name}{self.rsuffix}"] = col
          else:
              data[name] = col
  
      # determine if the result has multiindex columns.  The result
      # of a join has a MultiIndex as its columns if:
      # - both the `lhs` and `rhs` have a MultiIndex columns
      # OR
      # - either one of `lhs` or `rhs` have a MultiIndex columns,
      #   and the other is empty (i.e., no columns)
      if self.lhs._data and self.rhs._data:
          multiindex_columns = (
              self.lhs._data.multiindex and self.rhs._data.multiindex
          )
      elif self.lhs._data:
          multiindex_columns = self.lhs._data.multiindex
      elif self.rhs._data:
          multiindex_columns = self.rhs._data.multiindex
      else:
          multiindex_columns = False
  
      index: Optional[cudf.BaseIndex]
      if self._using_right_index:
          # right_index and left_on
          index = left_result._index
      elif self._using_left_index:
          # left_index and right_on
          index = right_result._index
      else:
          index = None
  
      # Construct result from data and index:
      return (
          left_result._data.__class__(
              data=data, multiindex=multiindex_columns
          ),
          index,
      )
  
file_path: cudf/python/cudf/cudf/core/join/join.py
imports: from __future__ import annotations
  import itertools
  import warnings
  from typing import Any, ClassVar, List, Optional
  import cudf
  from cudf import _lib
  from cudf._lib.types import size_type_dtype
  from cudf.core.copy_types import GatherMap
  from cudf.core.join._join_helpers import _coerce_to_tuple, _ColumnIndexer, _IndexIndexer, _match_join_keys
label_desc: Use image node_id 4 for calling the Merge obj's underlying member method code with example usage: obj._merge_results(left_result, right_result) and returns: left_result,  index