def test_operaotors(self):
expr = self.compile("SELECT 1 + 1 AS expr")
self.assertEqual(
expr,
qc.EvalQuery([
qc.EvalTarget(
qc.Operator(qp.Add,
[qc.EvalConstant(1),
qc.EvalConstant(1)]), 'expr', False)
], None, None, None, None, None, None, None))
expr = self.compile("SELECT 1 + meta('int') AS expr")
self.assertEqual(
expr,
qc.EvalQuery([
qc.EvalTarget(
qc.Operator(qp.Add, [
qc.EvalConstant(1),
qe.Function('decimal', [
qe.Function('meta', [
qc.EvalConstant('int'),
]),
]),
]), 'expr', False)
], None, None, None, None, None, None, None))
def test_print_from(self):
self.assertCompile(
qc.EvalPrint(
qc.EvalFrom(
qc.Operator(qp.Equal, [
qe.YearEntryColumn(),
qc.EvalConstant(2014),
]), None, None, None)), """PRINT FROM year = 2014;""")
def test_expr_binaryop(self):
self.assertEqual(
qc.Operator(
qp.Equal,
[qe.DateColumn(),
qc.EvalConstant(datetime.date(2014, 1, 1))]),
qc.compile_expression(
qp.Equal(qp.Column('date'),
qp.Constant(datetime.date(2014, 1, 1))),
qe.TargetsEnvironment()))
def test_get_columns_and_aggregates(self):
# Simple column.
c_query = qe.PositionColumn()
columns, aggregates = qc.get_columns_and_aggregates(c_query)
self.assertEqual((1, 0), (len(columns), len(aggregates)))
self.assertFalse(qc.is_aggregate(c_query))
# Multiple columns.
c_query = qc.Operator(qp.And, [qe.PositionColumn(), qe.DateColumn()])
columns, aggregates = qc.get_columns_and_aggregates(c_query)
self.assertEqual((2, 0), (len(columns), len(aggregates)))
self.assertFalse(qc.is_aggregate(c_query))
# Simple aggregate.
c_query = qe.SumPosition([qe.PositionColumn()])
columns, aggregates = qc.get_columns_and_aggregates(c_query)
self.assertEqual((0, 1), (len(columns), len(aggregates)))
self.assertTrue(qc.is_aggregate(c_query))
# Multiple aggregates.
c_query = qc.Operator(
qp.And, [qe.First([qe.DateColumn()]),
qe.Last([qe.FlagColumn()])])
columns, aggregates = qc.get_columns_and_aggregates(c_query)
self.assertEqual((0, 2), (len(columns), len(aggregates)))
self.assertTrue(qc.is_aggregate(c_query))
# Simple non-aggregate function.
c_query = qe.Function('length', [qe.AccountColumn()])
columns, aggregates = qc.get_columns_and_aggregates(c_query)
self.assertEqual((1, 0), (len(columns), len(aggregates)))
self.assertFalse(qc.is_aggregate(c_query))
# Mix of column and aggregates (this is used to detect this illegal case).
c_query = qc.Operator(qp.And, [
qe.Function('length', [qe.AccountColumn()]),
qe.SumPosition([qe.PositionColumn()]),
])
columns, aggregates = qc.get_columns_and_aggregates(c_query)
self.assertEqual((1, 1), (len(columns), len(aggregates)))
self.assertTrue(qc.is_aggregate(c_query))
def test_uses_balance_column(self):
c_simple = qe.BalanceColumn()
self.assertTrue(qx.uses_balance_column(c_simple))
c_simple_not = qe.AccountColumn()
self.assertFalse(qx.uses_balance_column(c_simple_not))
# c_subexpr = qc.Operator(qp.Equal, [qe.BalanceColumn(), qc.EvalConstant(2012)])
# self.assertTrue(qx.uses_balance_column(c_subexpr))
c_subexpr_not = qc.Operator(qp.Equal, [qe.AccountColumn(), qc.EvalConstant('Assets')])
self.assertFalse(qx.uses_balance_column(c_subexpr_not))
def test_print_with_filter(self):
statement = qc.EvalPrint(
qc.EvalFrom(
qc.Operator(qp.Equal, [
qe.YearEntryColumn(),
qc.EvalConstant(2012),
]),
None, None, None))
oss = io.StringIO()
qx.execute_print(statement, self.entries, self.options_map, oss)
self.assertEqualEntries("""
2012-02-02 * "Dinner with Dos"
Assets:Bank:Checking 102.00 USD
Expenses:Restaurant -102.00 USD
""", oss.getvalue())
def test_compile_Div(self):
c_plus = qc.Operator(
qp.Div,
[qc.EvalConstant(17), qc.EvalConstant(18)])
self.assertEqual(Decimal, c_plus.dtype)
def test_compile_Equal(self):
c_equal = qc.Operator(
qp.Equal,
[qc.EvalConstant(17), qc.EvalConstant(18)])
self.assertEqual(bool, c_equal.dtype)
def test_compile_GreaterEq(self):
c_ge = qc.Operator(
qp.GreaterEq,
[qc.EvalConstant(17), qc.EvalConstant(18)])
self.assertEqual(bool, c_ge.dtype)
def test_is_aggregate_derived(self):
columns, aggregates = qc.get_columns_and_aggregates(
qc.Operator(qp.And, [
qc.Operator(qp.Equal, [
qe.LineNoColumn(),
qc.EvalConstant(42),
]),
qc.Operator(qp.Or, [
qc.Operator(qp.Not, [
qc.Operator(qp.Equal, [
qe.DateColumn(),
qc.EvalConstant(datetime.date(2014, 1, 1)),
]),
]),
qc.EvalConstant(False),
]),
]))
self.assertEqual((2, 0), (len(columns), len(aggregates)))
columns, aggregates = qc.get_columns_and_aggregates(
qc.Operator(
qp.And,
[
qc.Operator(qp.Equal, [
qe.LineNoColumn(),
qc.EvalConstant(42),
]),
qc.Operator(
qp.Or,
[
qc.Operator(qp.Not, [
qc.Operator(qp.Not, [
qc.Operator(qp.Equal, [
qe.DateColumn(),
qc.EvalConstant(
datetime.date(2014, 1, 1)),
]),
]),
]),
# Aggregation node deep in the tree.
qe.SumInt([qc.EvalConstant(1)]),
]),
]))
self.assertEqual((2, 1), (len(columns), len(aggregates)))
def test_expr_unaryop(self):
self.assertEqual(
qc.Operator(qp.Not, [qe.AccountColumn()]),
qc.compile_expression(qp.Not(qp.Column('account')),
qe.TargetsEnvironment()))
def test_compile_LessEq(self):
c_le = qc.Operator(
qp.LessEq,
[qc.EvalConstant(17), qc.EvalConstant(18)])
self.assertEqual(bool, c_le.dtype)
def test_compile_Sub(self):
c_plus = qc.Operator(
qp.Sub,
[qc.EvalConstant(17), qc.EvalConstant(18)])
self.assertEqual(int, c_plus.dtype)
def test_compile_Not(self):
c_not = qc.Operator(qp.Not, [qc.EvalConstant(17)])
self.assertEqual(bool, c_not.dtype)
def test_compile_Or(self):
c_or = qc.Operator(qp.Or, [qc.EvalConstant(17), qc.EvalConstant(18)])
self.assertEqual(bool, c_or.dtype)
def test_compile_And(self):
c_and = qc.Operator(qp.And, [qc.EvalConstant(17), qc.EvalConstant(18)])
self.assertEqual(bool, c_and.dtype)
def test_compile_Match(self):
c_match = qc.Operator(qp.Match,
[qc.EvalConstant('abc'),
qc.EvalConstant('b')])
self.assertEqual(bool, c_match.dtype)