def test_mergesort_3():
table1 = (('foo', 'bar'),
('A', 9),
('C', 2),
('D', 10),
('A', 6),
('F', 1))
table2 = (('foo', 'baz'),
('B', 3),
('D', 10),
('A', 10),
('F', 4))
# should be same as concatenate then sort (but more efficient, esp. when
# presorted)
expect = sort(cat(table1, table2), key='foo', reverse=True)
actual = mergesort(table1, table2, key='foo', reverse=True)
ieq(expect, actual)
ieq(expect, actual)
actual = mergesort(sort(table1, key='foo', reverse=True),
sort(table2, key='foo', reverse=True),
key='foo', reverse=True, presorted=True)
ieq(expect, actual)
ieq(expect, actual)
def test_mergesort_2():
table1 = (("foo", "bar"), ("A", 9), ("C", 2), ("D", 10), ("A", 6), ("F", 1))
table2 = (("foo", "baz"), ("B", 3), ("D", 10), ("A", 10), ("F", 4))
# should be same as concatenate then sort (but more efficient, esp. when
# presorted)
expect = sort(cat(table1, table2), key="foo")
actual = mergesort(table1, table2, key="foo")
ieq(expect, actual)
ieq(expect, actual)
actual = mergesort(sort(table1, key="foo"), sort(table2, key="foo"), key="foo", presorted=True)
ieq(expect, actual)
ieq(expect, actual)
def test_mergesort_1():
table1 = (('foo', 'bar'), ('A', 6), ('C', 2), ('D', 10), ('A', 9), ('F',
1))
table2 = (('foo', 'bar'), ('B', 3), ('D', 10), ('A', 10), ('F', 4))
# should be same as concatenate then sort (but more efficient, esp. when
# presorted)
expect = sort(cat(table1, table2))
actual = mergesort(table1, table2)
ieq(expect, actual)
ieq(expect, actual)
actual = mergesort(sort(table1), sort(table2), presorted=True)
ieq(expect, actual)
ieq(expect, actual)
def test_mergesort_empty():
table1 = (("foo", "bar"), ("A", 9), ("C", 2), ("D", 10), ("F", 1))
table2 = (("foo", "bar"),)
expect = table1
actual = mergesort(table1, table2, key="foo")
ieq(expect, actual)
ieq(expect, actual)
def test_mergesort_4():
table1 = (("foo", "bar", "baz"), (1, "A", True), (2, "B", None), (4, "C", True))
table2 = (("bar", "baz", "quux"), ("A", True, 42.0), ("B", False, 79.3), ("C", False, 12.4))
expect = sort(cat(table1, table2), key="bar")
actual = mergesort(table1, table2, key="bar")
ieq(expect, actual)
ieq(expect, actual)
def test_mergesort_empty():
table1 = (('foo', 'bar'), ('A', 9), ('C', 2), ('D', 10), ('F', 1))
table2 = (('foo', 'bar'), )
expect = table1
actual = mergesort(table1, table2, key='foo')
ieq(expect, actual)
ieq(expect, actual)
def merge(*tables, **kwargs):
"""
Convenience function to combine multiple tables (via :func:`mergesort`) then
combine duplicate rows by merging under the given key (via
:func:`mergeduplicates`). E.g.::
>>> from petl import look, merge
>>> look(table1)
+-------+-------+-------+
| 'foo' | 'bar' | 'baz' |
+=======+=======+=======+
| 1 | 'A' | True |
+-------+-------+-------+
| 2 | 'B' | None |
+-------+-------+-------+
| 4 | 'C' | True |
+-------+-------+-------+
>>> look(table2)
+-------+-------+--------+
| 'bar' | 'baz' | 'quux' |
+=======+=======+========+
| 'A' | True | 42.0 |
+-------+-------+--------+
| 'B' | False | 79.3 |
+-------+-------+--------+
| 'C' | False | 12.4 |
+-------+-------+--------+
>>> table3 = merge(table1, table2, key='bar')
>>> look(table3)
+-------+-------+-------------------------+--------+
| 'bar' | 'foo' | 'baz' | 'quux' |
+=======+=======+=========================+========+
| 'A' | 1 | True | 42.0 |
+-------+-------+-------------------------+--------+
| 'B' | 2 | False | 79.3 |
+-------+-------+-------------------------+--------+
| 'C' | 4 | Conflict([False, True]) | 12.4 |
+-------+-------+-------------------------+--------+
Keyword arguments are the same as for :func:`mergesort`, except `key` is
required.
.. versionchanged:: 0.9
Now uses :func:`mergesort`, should be more efficient for presorted inputs.
"""
assert 'key' in kwargs, 'keyword argument "key" is required'
key = kwargs['key']
t1 = mergesort(*tables, **kwargs)
t2 = mergeduplicates(t1, key=key, presorted=True)
return t2
def test_mergesort_4():
table1 = (('foo', 'bar', 'baz'), (1, 'A', True), (2, 'B', None), (4, 'C',
True))
table2 = (('bar', 'baz', 'quux'), ('A', True, 42.0), ('B', False, 79.3),
('C', False, 12.4))
expect = sort(cat(table1, table2), key='bar')
actual = mergesort(table1, table2, key='bar')
ieq(expect, actual)
ieq(expect, actual)
def test_mergesort_empty():
table1 = (('foo', 'bar'),
('A', 9),
('C', 2),
('D', 10),
('F', 1))
table2 = (('foo', 'bar'),)
expect = table1
actual = mergesort(table1, table2, key='foo')
ieq(expect, actual)
ieq(expect, actual)
def test_mergesort_4():
table1 = (('foo', 'bar', 'baz'),
(1, 'A', True),
(2, 'B', None),
(4, 'C', True))
table2 = (('bar', 'baz', 'quux'),
('A', True, 42.0),
('B', False, 79.3),
('C', False, 12.4))
expect = sort(cat(table1, table2), key='bar')
actual = mergesort(table1, table2, key='bar')
ieq(expect, actual)
ieq(expect, actual)
def merge(*tables, **kwargs):
"""
Convenience function to combine multiple tables (via
:func:`petl.transform.sorts.mergesort`) then combine duplicate rows by
merging under the given key (via
:func:`petl.transform.reductions.mergeduplicates`). E.g.::
>>> import petl as etl
>>> table1 = [['foo', 'bar', 'baz'],
... [1, 'A', True],
... [2, 'B', None],
... [4, 'C', True]]
>>> table2 = [['bar', 'baz', 'quux'],
... ['A', True, 42.0],
... ['B', False, 79.3],
... ['C', False, 12.4]]
>>> table3 = etl.merge(table1, table2, key='bar')
>>> table3
+-----+-----+-------------------------+------+
| bar | foo | baz | quux |
+=====+=====+=========================+======+
| 'A' | 1 | True | 42.0 |
+-----+-----+-------------------------+------+
| 'B' | 2 | False | 79.3 |
+-----+-----+-------------------------+------+
| 'C' | 4 | Conflict({False, True}) | 12.4 |
+-----+-----+-------------------------+------+
Keyword arguments are the same as for
:func:`petl.transform.sorts.mergesort`, except `key` is required.
"""
assert 'key' in kwargs, 'keyword argument "key" is required'
key = kwargs['key']
t1 = mergesort(*tables, **kwargs)
t2 = mergeduplicates(t1, key=key, presorted=True)
return t2
def merge(*tables, **kwargs):
"""
Convenience function to combine multiple tables (via
:func:`petl.transform.sorts.mergesort`) then combine duplicate rows by
merging under the given key (via
:func:`petl.transform.reductions.mergeduplicates`). E.g.::
>>> import petl as etl
>>> table1 = [['foo', 'bar', 'baz'],
... [1, 'A', True],
... [2, 'B', None],
... [4, 'C', True]]
>>> table2 = [['bar', 'baz', 'quux'],
... ['A', True, 42.0],
... ['B', False, 79.3],
... ['C', False, 12.4]]
>>> table3 = etl.merge(table1, table2, key='bar')
>>> table3
+-----+-----+-------------------------+------+
| bar | foo | baz | quux |
+=====+=====+=========================+======+
| 'A' | 1 | True | 42.0 |
+-----+-----+-------------------------+------+
| 'B' | 2 | False | 79.3 |
+-----+-----+-------------------------+------+
| 'C' | 4 | Conflict({False, True}) | 12.4 |
+-----+-----+-------------------------+------+
Keyword arguments are the same as for
:func:`petl.transform.sorts.mergesort`, except `key` is required.
"""
assert 'key' in kwargs, 'keyword argument "key" is required'
key = kwargs['key']
t1 = mergesort(*tables, **kwargs)
t2 = mergeduplicates(t1, key=key, presorted=True)
return t2