def test_repr(self):
# Check "no select" signature.
query = Query(['label1'])
regex = r"Query\(\[u?'label1'\]\)"
self.assertRegex(repr(query), regex)
# Check "no select" with keyword string.
query = Query(['label1'], label2='x')
regex = r"Query\(\[u?'label1'\], label2='x'\)"
self.assertRegex(repr(query), regex)
# Check "no select" with keyword list.
query = Query(['label1'], label2=['x', 'y'])
regex = r"Query\(\[u?'label1'\], label2=\[u?'x', u?'y'\]\)"
self.assertRegex(repr(query), regex)
# Check "select-provided" signature.
select = Select([('A', 'B'), ('x', 1), ('y', 2), ('z', 3)])
query = Query(select, ['B'])
short_repr = super(Select, select).__repr__()
expected = "Query({0}, {1!r})".format(short_repr, ['B'])
#print(repr(query))
self.assertEqual(repr(query), expected)
# Check "from_object" signature.
query = Query.from_object([1, 2, 3])
expected = "Query.from_object([1, 2, 3])"
self.assertEqual(repr(query), expected)
# Check query steps.
query = Query(['label1']).distinct().count()
regex = r"Query\(\[u?'label1'\]\).distinct\(\).count\(\)"
self.assertRegex(repr(query), regex)
# Check query steps with function argument.
def upper(x):
return str(x.upper())
query = Query(['label1']).map(upper)
regex = r"Query\(\[u?'label1'\]\).map\(upper\)"
self.assertRegex(repr(query), regex)
# Check query steps with lambda argument.
lower = lambda x: str(x).lower()
query = Query(['label1']).map(lower)
regex = r"Query\(\[u?'label1'\]\).map\(<lambda>\)"
self.assertRegex(repr(query), regex)
def test_get_user_function(self):
select = Select([['A', 'B'], ['x', 1], ['y', 2], ['z', 3]])
# Verify that "_user_function_dict" us empty.
self.assertEqual(len(select._user_function_dict), 0, 'should be empty dict')
# Get existing function.
isodd = lambda x: x % 2 == 1
select._create_user_function(isodd)
func_name = select._get_user_function(isodd)
self.assertEqual(len(select._user_function_dict), 1)
self.assertRegex(func_name, r'FUNC\d+')
# Get new function.
iseven = lambda x: x % 2 == 0
func_name = select._get_user_function(iseven)
self.assertEqual(len(select._user_function_dict), 2, 'should be auto-created')
self.assertRegex(func_name, r'FUNC\d+')
def test_build_where_clause(self):
select = Select([['A', 'B'], ['x', 1], ['y', 2], ['z', 3]])
result = select._build_where_clause({'A': 'x'})
expected = ('A=?', ['x'])
self.assertEqual(result, expected)
result = select._build_where_clause({'A': set(['x', 'y'])})
self.assertEqual(len(result), 2)
self.assertEqual(result[0], 'A IN (?, ?)')
self.assertEqual(set(result[1]), set(['x', 'y']))
# User-defined function.
userfunc = lambda x: len(x) == 1
result = select._build_where_clause({'A': userfunc})
self.assertEqual(len(result), 2)
self.assertRegex(result[0], r'FUNC\d+\(A\)')
self.assertEqual(result[1], [])
# Predicate (a type)
prev_len = len(select._user_function_dict)
predicate = int
result = select._build_where_clause({'A': predicate})
self.assertEqual(len(result), 2)
self.assertRegex(result[0], r'FUNC\d+\(A\)')
self.assertEqual(result[1], [])
self.assertEqual(len(select._user_function_dict), prev_len + 1)
# Predicate (a boolean)
prev_len = len(select._user_function_dict)
predicate = True
result = select._build_where_clause({'A': predicate})
self.assertEqual(len(result), 2)
self.assertRegex(result[0], r'FUNC\d+\(A\)')
self.assertEqual(result[1], [])
self.assertEqual(len(select._user_function_dict), prev_len + 1)
def test_iterate_single_result(self):
"""Single items should be wrapped as iterators when iterated over."""
select = Select([('A', 'B'), (1, 2), (1, 2)])
query = Query(select, ['B']).sum()
self.assertEqual(list(query), [4])
def test_iterate_source(self):
select = Select([('A', 'B'), (1, 2), (1, 2)])
query = Query(select, ['B'])
self.assertEqual(list(query), [2, 2])
def test_Query(self):
source = Select([('A', 'B'), ('x', 1), ('y', 2)])
query = source({'A': 'B'}).apply(lambda x: next(x))
normalized = _get_iteritems(query)
self.assertEqual(list(normalized), [('x', 1), ('y', 2)])
def test_repr(self):
data = [['A', 'B'], ['x', 100], ['y', 200]]
# Empty select.
select = Select()
self.assertEqual(repr(select), '<Select (no data loaded)>')
# Data-only (no args)
select = Select(data)
expected = "<Select [['A', 'B'], ['x', 100], ['y', 200]]>"
self.assertEqual(repr(select), expected)
# Data with args (args don't affect repr)
iterable = iter(data)
select = Select(iterable, 'foo', bar='baz')
regex = '<Select <[a-z_]+ object at [^\n>]+>>'
self.assertRegex(repr(select), regex)
# Extended after instantiation.
select = Select()
select.load_data([['A', 'B'], ['z', 300]])
select.load_data([['A', 'B'], ['y', 200]])
select.load_data([['A', 'B'], ['x', 100]])
expected = (
"<Select (3 sources):\n"
" [['A', 'B'], ['x', 100]]\n"
" [['A', 'B'], ['y', 200]]\n"
" [['A', 'B'], ['z', 300]]>"
)
self.assertEqual(repr(select), expected)
# Test long repr truncation.
select = Select([
['xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'],
['yyyyyyyyyyyyyyyyyyyyyyyyyyyyyy'],
])
self.assertEqual(len(repr(select)), 72)
expected = "<Select [['xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'], ['yyyyyyyyyyyyy...yyyyy']]>"
self.assertEqual(repr(select), expected)
def test_iterate(self):
select = Select([('A', 'B'), (1, 2), (1, 2)])
self.assertEqual(list(select), [[1, 2], [1, 2]])
def setUp(self):
self.select = Select([['A', 'B'], ['x', 1], ['y', 2]])
def test_fieldnames(self):
expected = ['label1', 'label2', 'value']
self.assertEqual(self.select.fieldnames, expected)
select = Select() # <- Empty select.
self.assertEqual(select.fieldnames, [], msg='should be empty list')
def test_empty_select(self):
select = Select()
def setUpClass(cls):
cls.select = Select([['A', 'B', 'C'], ['x', 'foo', 20],
['x', 'foo', 30], ['y', 'foo', 10],
['y', 'bar', 20], ['z', 'bar', 10],
['z', 'bar', 10]])
