Allow for join between to multi-index dataframe instances

Author: harisbal

doc/source/merging.rst

@@ -31,10 +31,17 @@ operations.
 Concatenating objects
 ---------------------
 
+<<<<<<< HEAD
+The :func:`~pandas.concat` function (in the main pandas namespace) does all of
+the heavy lifting of performing concatenation operations along an axis while
+performing optional set logic (union or intersection) of the indexes (if any) on
+the other axes. Note that I say "if any" because there is only a single possible
+=======
 The :func:`~pandas.concat` function (in the main pandas namespace) does all of 
 the heavy lifting of performing concatenation operations along an axis while 
 performing optional set logic (union or intersection) of the indexes (if any) on 
 the other axes. Note that I say "if any" because there is only a single possible 
+>>>>>>> remotes/upstream/master
 axis of concatenation for Series.
 
 Before diving into all of the details of ``concat`` and what it can do, here is
@@ -109,9 +116,9 @@ some configurable handling of "what to do with the other axes":
   to the actual data concatenation.
 - ``copy`` : boolean, default True. If False, do not copy data unnecessarily.
 
-Without a little bit of context many of these arguments don't make much sense. 
-Let's revisit the above example. Suppose we wanted to associate specific keys 
-with each of the pieces of the chopped up DataFrame. We can do this using the 
+Without a little bit of context many of these arguments don't make much sense.
+Let's revisit the above example. Suppose we wanted to associate specific keys
+with each of the pieces of the chopped up DataFrame. We can do this using the
 ``keys`` argument:
 
 .. ipython:: python
@@ -138,9 +145,9 @@ It's not a stretch to see how this can be very useful. More detail on this
 functionality below.
 
 .. note::
-   It is worth noting that :func:`~pandas.concat` (and therefore 
-   :func:`~pandas.append`) makes a full copy of the data, and that constantly 
-   reusing this function can create a significant performance hit. If you need 
+   It is worth noting that :func:`~pandas.concat` (and therefore
+   :func:`~pandas.append`) makes a full copy of the data, and that constantly
+   reusing this function can create a significant performance hit. If you need
    to use the operation over several datasets, use a list comprehension.
 
 ::
@@ -153,7 +160,7 @@ Set logic on the other axes
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 When gluing together multiple DataFrames, you have a choice of how to handle
-the other axes (other than the one being concatenated). This can be done in 
+the other axes (other than the one being concatenated). This can be done in
 the following three ways:
 
 - Take the (sorted) union of them all, ``join='outer'``. This is the default
@@ -216,8 +223,8 @@ DataFrame:
 Concatenating using ``append``
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-A useful shortcut to :func:`~pandas.concat` are the :meth:`~DataFrame.append` 
-instance methods on ``Series`` and ``DataFrame``. These methods actually predated 
+A useful shortcut to :func:`~pandas.concat` are the :meth:`~DataFrame.append`
+instance methods on ``Series`` and ``DataFrame``. These methods actually predated
 ``concat``. They concatenate along ``axis=0``, namely the index:
 
 .. ipython:: python
@@ -263,8 +270,8 @@ need to be:
 
 .. note::
 
-   Unlike the :py:meth:`~list.append` method, which appends to the original list 
-   and returns ``None``, :meth:`~DataFrame.append`  here **does not** modify 
+   Unlike the :py:meth:`~list.append` method, which appends to the original list
+   and returns ``None``, :meth:`~DataFrame.append`  here **does not** modify
    ``df1`` and returns its copy with ``df2`` appended.
 
 .. _merging.ignore_index:
@@ -362,9 +369,9 @@ Passing ``ignore_index=True`` will drop all name references.
 More concatenating with group keys
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-A fairly common use of the ``keys`` argument is to override the column names 
+A fairly common use of the ``keys`` argument is to override the column names
 when creating a new ``DataFrame`` based on existing ``Series``.
-Notice how the default behaviour consists on letting the resulting ``DataFrame`` 
+Notice how the default behaviour consists on letting the resulting ``DataFrame``
 inherit the parent ``Series``' name, when these existed.
 
 .. ipython:: python
@@ -460,7 +467,7 @@ Appending rows to a DataFrame
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 While not especially efficient (since a new object must be created), you can
-append a single row to a ``DataFrame`` by passing a ``Series`` or dict to 
+append a single row to a ``DataFrame`` by passing a ``Series`` or dict to
 ``append``, which returns a new ``DataFrame`` as above.
 
 .. ipython:: python
@@ -505,15 +512,15 @@ pandas has full-featured, **high performance** in-memory join operations
 idiomatically very similar to relational databases like SQL. These methods
 perform significantly better (in some cases well over an order of magnitude
 better) than other open source implementations (like ``base::merge.data.frame``
-in R). The reason for this is careful algorithmic design and the internal layout 
+in R). The reason for this is careful algorithmic design and the internal layout
 of the data in ``DataFrame``.
 
 See the :ref:`cookbook<cookbook.merge>` for some advanced strategies.
 
 Users who are familiar with SQL but new to pandas might be interested in a
 :ref:`comparison with SQL<compare_with_sql.join>`.
 
-pandas provides a single function, :func:`~pandas.merge`, as the entry point for 
+pandas provides a single function, :func:`~pandas.merge`, as the entry point for
 all standard database join operations between ``DataFrame`` objects:
 
 ::
@@ -582,7 +589,11 @@ and ``right`` is a subclass of DataFrame, the return type will still be
 ``DataFrame``.
 
 ``merge`` is a function in the pandas namespace, and it is also available as a
+<<<<<<< HEAD
+``DataFrame`` instance method :meth:`~DataFrame.merge`, with the calling
+=======
 ``DataFrame`` instance method :meth:`~DataFrame.merge`, with the calling 
+>>>>>>> remotes/upstream/master
 ``DataFrame `` being implicitly considered the left object in the join.
 
 The related :meth:`~DataFrame.join` method, uses ``merge`` internally for the
@@ -594,7 +605,7 @@ Brief primer on merge methods (relational algebra)
 
 Experienced users of relational databases like SQL will be familiar with the
 terminology used to describe join operations between two SQL-table like
-structures (``DataFrame`` objects). There are several cases to consider which 
+structures (``DataFrame`` objects). There are several cases to consider which
 are very important to understand:
 
 - **one-to-one** joins: for example when joining two ``DataFrame`` objects on
@@ -634,8 +645,8 @@ key combination:
           labels=['left', 'right'], vertical=False);
    plt.close('all');
 
-Here is a more complicated example with multiple join keys. Only the keys 
-appearing in ``left`` and ``right`` are present (the intersection), since 
+Here is a more complicated example with multiple join keys. Only the keys
+appearing in ``left`` and ``right`` are present (the intersection), since
 ``how='inner'`` by default.
 
 .. ipython:: python
@@ -751,13 +762,13 @@ Checking for duplicate keys
 
 .. versionadded:: 0.21.0
 
-Users can use the ``validate`` argument to automatically check whether there 
-are unexpected duplicates in their merge keys. Key uniqueness is checked before 
-merge operations and so should protect against memory overflows. Checking key 
-uniqueness is also a good way to ensure user data structures are as expected. 
+Users can use the ``validate`` argument to automatically check whether there
+are unexpected duplicates in their merge keys. Key uniqueness is checked before
+merge operations and so should protect against memory overflows. Checking key
+uniqueness is also a good way to ensure user data structures are as expected.
 
-In the following example, there are duplicate values of ``B`` in the right 
-``DataFrame``. As this is not a one-to-one merge -- as specified in the 
+In the following example, there are duplicate values of ``B`` in the right
+``DataFrame``. As this is not a one-to-one merge -- as specified in the
 ``validate`` argument -- an exception will be raised.
 
 
@@ -770,11 +781,11 @@ In the following example, there are duplicate values of ``B`` in the right
 
   In [53]: result = pd.merge(left, right, on='B', how='outer', validate="one_to_one")
   ...
-  MergeError: Merge keys are not unique in right dataset; not a one-to-one merge    
+  MergeError: Merge keys are not unique in right dataset; not a one-to-one merge
 
-If the user is aware of the duplicates in the right ``DataFrame`` but wants to 
-ensure there are no duplicates in the left DataFrame, one can use the 
-``validate='one_to_many'`` argument instead, which will not raise an exception. 
+If the user is aware of the duplicates in the right ``DataFrame`` but wants to
+ensure there are no duplicates in the left DataFrame, one can use the
+``validate='one_to_many'`` argument instead, which will not raise an exception.
 
 .. ipython:: python
 
@@ -786,8 +797,8 @@ ensure there are no duplicates in the left DataFrame, one can use the
 The merge indicator
 ~~~~~~~~~~~~~~~~~~~
 
-:func:`~pandas.merge` accepts the argument ``indicator``. If ``True``, a 
-Categorical-type column called ``_merge`` will be added to the output object 
+:func:`~pandas.merge` accepts the argument ``indicator``. If ``True``, a
+Categorical-type column called ``_merge`` will be added to the output object
 that takes on values:
 
   ===================================   ================
@@ -895,7 +906,7 @@ Joining on index
 ~~~~~~~~~~~~~~~~
 
 :meth:`DataFrame.join` is a convenient method for combining the columns of two
-potentially differently-indexed ``DataFrames`` into a single result 
+potentially differently-indexed ``DataFrames`` into a single result
 ``DataFrame``. Here is a very basic example:
 
 .. ipython:: python
@@ -975,9 +986,15 @@ indexes:
 Joining key columns on an index
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
+<<<<<<< HEAD
+:meth:`~DataFrame.join` takes an optional ``on`` argument which may be a column
+or multiple column names, which specifies that the passed ``DataFrame`` is to be
+aligned on that column in the ``DataFrame``. These two function calls are
+=======
 :meth:`~DataFrame.join` takes an optional ``on`` argument which may be a column 
 or multiple column names, which specifies that the passed ``DataFrame`` is to be
 aligned on that column in the ``DataFrame``. These two function calls are 
+>>>>>>> remotes/upstream/master
 completely equivalent:
 
 ::
@@ -987,7 +1004,11 @@ completely equivalent:
           how='left', sort=False)
 
 Obviously you can choose whichever form you find more convenient. For
+<<<<<<< HEAD
+many-to-one joins (where one of the ``DataFrame``'s is already indexed by the
+=======
 many-to-one joins (where one of the ``DataFrame``'s is already indexed by the 
+>>>>>>> remotes/upstream/master
 join key), using ``join`` may be more convenient. Here is a simple example:
 
 .. ipython:: python
@@ -1125,20 +1146,25 @@ This is equivalent but less verbose and more memory efficient / faster than this
 Joining with two multi-indexes
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-This is not implemented via ``join`` at-the-moment, however it can be done using
-the following code.
+As of Pandas 0.23.1 the :func:`Dataframe.join` can be used to join multi-indexed ``Dataframe`` instances on the overlaping index levels
 
 .. ipython:: python
 
-   index = pd.MultiIndex.from_tuples([('K0', 'X0'), ('K0', 'X1'),
+   index_left = pd.MultiIndex.from_tuples([('K0', 'X0'), ('K0', 'X1'),
                                       ('K1', 'X2')],
                                        names=['key', 'X'])
    left = pd.DataFrame({'A': ['A0', 'A1', 'A2'],
                         'B': ['B0', 'B1', 'B2']},
-                         index=index)
+                         index=index_left)
+
+   index_right = pd.MultiIndex.from_tuples([('K0', 'Y0'), ('K1', 'Y1'),
+                                    ('K2', 'Y2'), ('K2', 'Y3')],
+                                     names=['key', 'Y'])
+   right = pd.DataFrame({'C': ['C0', 'C1', 'C2', 'C3'],
+                         'D': ['D0', 'D1', 'D2', 'D3']},
+                         index=index_right)
 
-   result = pd.merge(left.reset_index(), right.reset_index(),
-                     on=['key'], how='inner').set_index(['key','X','Y'])
+    left.join(right)
 
 .. ipython:: python
    :suppress:
@@ -1148,6 +1174,13 @@ the following code.
           labels=['left', 'right'], vertical=False);
    plt.close('all');
 
+For earlier versions it can be done using the following.
+
+.. ipython:: python
+
+   pd.merge(left.reset_index(), right.reset_index(),
+            on=['key'], how='inner').set_index(['key','X','Y'])
+
 .. _merging.merge_on_columns_and_levels:
 
 Merging on a combination of columns and index levels
@@ -1254,7 +1287,7 @@ similarly.
 Joining multiple DataFrame or Panel objects
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-A list or tuple of ``DataFrames`` can also be passed to :meth:`~DataFrame.join` 
+A list or tuple of ``DataFrames`` can also be passed to :meth:`~DataFrame.join`
 to join them together on their indexes.
 
 .. ipython:: python
@@ -1276,7 +1309,7 @@ Merging together values within Series or DataFrame columns
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 Another fairly common situation is to have two like-indexed (or similarly
-indexed) ``Series`` or ``DataFrame`` objects and wanting to "patch" values in 
+indexed) ``Series`` or ``DataFrame`` objects and wanting to "patch" values in
 one object from values for matching indices in the other. Here is an example:
 
 .. ipython:: python
@@ -1301,7 +1334,7 @@ For this, use the :meth:`~DataFrame.combine_first` method:
    plt.close('all');
 
 Note that this method only takes values from the right ``DataFrame`` if they are
-missing in the left ``DataFrame``. A related method, :meth:`~DataFrame.update`, 
+missing in the left ``DataFrame``. A related method, :meth:`~DataFrame.update`,
 alters non-NA values inplace:
 
 .. ipython:: python
@@ -1353,15 +1386,15 @@ Merging AsOf
 
 .. versionadded:: 0.19.0
 
-A :func:`merge_asof` is similar to an ordered left-join except that we match on 
-nearest key rather than equal keys. For each row in the ``left`` ``DataFrame``, 
-we select the last row in the ``right`` ``DataFrame`` whose ``on`` key is less 
+A :func:`merge_asof` is similar to an ordered left-join except that we match on
+nearest key rather than equal keys. For each row in the ``left`` ``DataFrame``,
+we select the last row in the ``right`` ``DataFrame`` whose ``on`` key is less
 than the left's key. Both DataFrames must be sorted by the key.
 
-Optionally an asof merge can perform a group-wise merge. This matches the 
+Optionally an asof merge can perform a group-wise merge. This matches the
 ``by`` key equally, in addition to the nearest match on the ``on`` key.
 
-For example; we might have ``trades`` and ``quotes`` and we want to ``asof`` 
+For example; we might have ``trades`` and ``quotes`` and we want to ``asof``
 merge them.
 
 .. ipython:: python
@@ -1420,8 +1453,8 @@ We only asof within ``2ms`` between the quote time and the trade time.
                  by='ticker',
                  tolerance=pd.Timedelta('2ms'))
 
-We only asof within ``10ms`` between the quote time and the trade time and we 
-exclude exact matches on time. Note that though we exclude the exact matches 
+We only asof within ``10ms`` between the quote time and the trade time and we
+exclude exact matches on time. Note that though we exclude the exact matches
 (of the quotes), prior quotes **do** propagate to that point in time.
 
 .. ipython:: python

doc/source/whatsnew/v0.23.0.txt

@@ -59,6 +59,40 @@ The :func:`get_dummies` now accepts a ``dtype`` argument, which specifies a dtyp
    pd.get_dummies(df, columns=['c']).dtypes
    pd.get_dummies(df, columns=['c'], dtype=bool).dtypes
 
+.. _whatsnew_0230.enhancements.join_with_two_multiindexes:
+
+Joining with two multi-indexes
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+As of Pandas 0.23.1 the :func:`Dataframe.join` can be used to join multi-indexed ``Dataframe`` instances on the overlaping index levels
+
+See the :ref:`Merge, join, and concatenate
+<merging.Join_with_two_multi_indexes>` documentation section.
+
+.. ipython:: python
+
+   index_left = pd.MultiIndex.from_tuples([('K0', 'X0'), ('K0', 'X1'),
+                                      ('K1', 'X2')],
+                                       names=['key', 'X'])
+   left = pd.DataFrame({'A': ['A0', 'A1', 'A2'],
+                        'B': ['B0', 'B1', 'B2']},
+                         index=index_left)
+
+   index_right = pd.MultiIndex.from_tuples([('K0', 'Y0'), ('K1', 'Y1'),
+                                    ('K2', 'Y2'), ('K2', 'Y3')],
+                                     names=['key', 'Y'])
+   right = pd.DataFrame({'C': ['C0', 'C1', 'C2', 'C3'],
+                         'D': ['D0', 'D1', 'D2', 'D3']},
+                         index=index_right)
+
+    left.join(right)
+
+For earlier versions it can be done using the following.
+
+.. ipython:: python
+
+   pd.merge(left.reset_index(), right.reset_index(),
+            on=['key'], how='inner').set_index(['key','X','Y'])
 
 .. _whatsnew_0230.enhancements.merge_on_columns_and_levels: