beancount.query

def get_column(self, name):
    """Return a column accessor for the given named column.
    Args:
      name: A string, the name of the column to access.
    """
    try:
        return self.columns[name]()
    except KeyError:
        raise CompilationError("Invalid column name '{}' in {} context.".format(
            name, self.context_name))

def get_function(self, name, operands):
    """Return a function accessor for the given named function.
    Args:
      name: A string, the name of the function to access.
    """
    try:
        key = tuple([name] + [operand.dtype for operand in operands])
        return self.functions[key](operands)
    except KeyError:
        # If not found with the operands, try just looking it up by name.
        try:
            return self.functions[name](operands)
        except KeyError:
            signature = '{}({})'.format(name,
                                        ', '.join(operand.dtype.__name__
                                                  for operand in operands))
            raise CompilationError("Invalid function '{}' in {} context".format(
                signature, self.context_name))

def __call__(self, context):
    """Return the value on evaluation.

    Args:
      context: The evaluation object to which the evaluation need to apply.
        This is either an entry, a Posting instance, or a particular result
        set row from a sub-select. This is the provider for the underlying
        data.
    Returns:
      The final aggregated value.
    """
    # Return None by default.

def allocate(self, allocator):
    """Allocate handles to store data for a node's aggregate storage.

    This is called once before beginning aggregations. If you need any
    kind of per-aggregate storage during the computation phase, get it
    in this method.

    Args:
      allocator: An instance of Allocator, on which you can call allocate() to
        obtain a handle for a slot to store data on store objects later on.
    """
    # Do nothing by default.

def finalize(self, store):
    """Finalize this node's aggregate data and return it.

    For aggregate methods, this finalizes the node and returns the final
    value. The context node will be the alloc instead of the context object.

    Args:
      store: An object indexable by handles appropriated during allocate().
    """
    # Do nothing by default.

def initialize(self, store):
    """Initialize this node's aggregate data. If the node is not an aggregate,
    simply initialize the subnodes. Override this method in the aggregator
    if you need data for storage.

    Args:
      store: An object indexable by handles appropriated during allocate().
    """
    # Do nothing by default.

def update(self, store, context):
    """Evaluate this node. This is designed to recurse on its children.

    Args:
      store: An object indexable by handles appropriated during allocate().
      context: The object to which the evaluation need to apply (see __call__).
    """
    # Do nothing by default.

def __getnewargs__(self):
    'Return self as a plain tuple.  Used by copy and pickle.'
    return _tuple(self)

def __repr__(self):
    'Return a nicely formatted representation string'
    return self.__class__.__name__ + repr_fmt % self

def _asdict(self):
    'Return a new dict which maps field names to their values.'
    return _dict(_zip(self._fields, self))

@classmethod
def _make(cls, iterable):
    result = tuple_new(cls, iterable)
    if _len(result) != num_fields:
        raise TypeError(f'Expected {num_fields} arguments, got {len(result)}')
    return result

def _replace(self, /, **kwds):
    result = self._make(_map(kwds.pop, field_names, self))
    if kwds:
        raise ValueError(f'Got unexpected field names: {list(kwds)!r}')
    return result

def __call__(self, context):
    """Evaluate this node. This is designed to recurse on its children.
    All subclasses must override and implement this method.

    Args:
      context: The evaluation object to which the evaluation need to apply.
        This is either an entry, a Posting instance, or a particular result
        set row from a sub-select. This is the provider for the underlying
        data.
    Returns:
      The evaluated value for this sub-expression tree.
    """
    raise NotImplementedError

def __eq__(self, other):
    """Override the equality operator to compare the data type and a all attributes
    of this node. This is used by tests for comparing nodes.
    """
    return (isinstance(other, type(self))
            and all(
                getattr(self, attribute) == getattr(other, attribute)
                for attribute in self.__slots__))

def __str__(self):
    return "{}({})".format(type(self).__name__,
                           ', '.join(repr(getattr(self, child))
                                     for child in self.__slots__))

def childnodes(self):
    """Returns the child nodes of this node.
    Yields:
      A list of EvalNode instances.
    """
    for attr in self.__slots__:
        child = getattr(self, attr)
        if isinstance(child, EvalNode):
            yield child
        elif isinstance(child, list):
            for element in child:
                if isinstance(element, EvalNode):
                    yield element

def __getnewargs__(self):
    'Return self as a plain tuple.  Used by copy and pickle.'
    return _tuple(self)

def __repr__(self):
    'Return a nicely formatted representation string'
    return self.__class__.__name__ + repr_fmt % self

def _asdict(self):
    'Return a new dict which maps field names to their values.'
    return _dict(_zip(self._fields, self))

@classmethod
def _make(cls, iterable):
    result = tuple_new(cls, iterable)
    if _len(result) != num_fields:
        raise TypeError(f'Expected {num_fields} arguments, got {len(result)}')
    return result

def _replace(self, /, **kwds):
    result = self._make(_map(kwds.pop, field_names, self))
    if kwds:
        raise ValueError(f'Got unexpected field names: {list(kwds)!r}')
    return result

def __getnewargs__(self):
    'Return self as a plain tuple.  Used by copy and pickle.'
    return _tuple(self)

def __repr__(self):
    'Return a nicely formatted representation string'
    return self.__class__.__name__ + repr_fmt % self

def _asdict(self):
    'Return a new dict which maps field names to their values.'
    return _dict(_zip(self._fields, self))

@classmethod
def _make(cls, iterable):
    result = tuple_new(cls, iterable)
    if _len(result) != num_fields:
        raise TypeError(f'Expected {num_fields} arguments, got {len(result)}')
    return result

def _replace(self, /, **kwds):
    result = self._make(_map(kwds.pop, field_names, self))
    if kwds:
        raise ValueError(f'Got unexpected field names: {list(kwds)!r}')
    return result

def __getnewargs__(self):
    'Return self as a plain tuple.  Used by copy and pickle.'
    return _tuple(self)

def __repr__(self):
    'Return a nicely formatted representation string'
    return self.__class__.__name__ + repr_fmt % self

def _asdict(self):
    'Return a new dict which maps field names to their values.'
    return _dict(_zip(self._fields, self))

@classmethod
def _make(cls, iterable):
    result = tuple_new(cls, iterable)
    if _len(result) != num_fields:
        raise TypeError(f'Expected {num_fields} arguments, got {len(result)}')
    return result

def _replace(self, /, **kwds):
    result = self._make(_map(kwds.pop, field_names, self))
    if kwds:
        raise ValueError(f'Got unexpected field names: {list(kwds)!r}')
    return result

def get_column(self, name):
    """Override the column getter to provide a single attribute getter.
    """
    # FIXME: How do we figure out the data type here? We need the context.
    return AttributeColumn(name)

def assertCompile(self, expected, query, debug=False):
    """Assert parsed and compiled contents from 'query' is 'expected'.

    Args:
      expected: An expected AST to compare against the parsed value.
      query: An SQL query to be parsed.
      debug: A boolean, if true, print extra debugging information on the console.
    Raises:
      AssertionError: If the actual AST does not match the expected one.
    """
    actual = self.compile(query)
    if debug:
        print()
        print()
        print(actual)
        print()
    try:
        self.assertEqual(expected, actual)
        return actual
    except AssertionError:
        print()
        print("Expected: {}".format(expected))
        print("Actual  : {}".format(actual))
        raise

def assertIndexes(self,
                  query,
                  expected_simple_indexes,
                  expected_aggregate_indexes,
                  expected_group_indexes,
                  expected_order_indexes):
    """Check the four lists of indexes for comparison.

    Args:
      query: An instance of EvalQuery, a compiled query statement.
      expected_simple_indexes: The expected visible non-aggregate indexes.
      expected_aggregate_indexes: The expected visible aggregate indexes.
      expected_group_indexes: The expected group_indexes.
      expected_order_indexes: The expected order_indexes.
    Raises:
      AssertionError: if the check fails.
    """
    # Compute the list of _visible_ aggregates and non-aggregates.
    simple_indexes = [index
                      for index, c_target in enumerate(query.c_targets)
                      if c_target.name and not qc.is_aggregate(c_target.expression)]
    aggregate_indexes = [index
                         for index, c_target in enumerate(query.c_targets)
                         if c_target.name and qc.is_aggregate(c_target.expression)]

    self.assertEqual(set(expected_simple_indexes), set(simple_indexes))

    self.assertEqual(set(expected_aggregate_indexes), set(aggregate_indexes))

    self.assertEqual(
        set(expected_group_indexes) if expected_group_indexes is not None else None,
        set(query.group_indexes) if query.group_indexes is not None else None)

    self.assertEqual(
        set(expected_order_indexes) if expected_order_indexes is not None else None,
        set(query.order_indexes) if query.order_indexes is not None else None)

def assertSelectInvariants(self, query):
    """Assert the invariants on the query.

    Args:
      query: An instance of EvalQuery, a compiled query statement.
    Raises:
      AssertionError: if the check fails.
    """
    # Check that the group references cover all the simple indexes.
    if query.group_indexes is not None:
        non_aggregate_indexes = [index
                                 for index, c_target in enumerate(query.c_targets)
                                 if not qc.is_aggregate(c_target.c_expr)]

        self.assertEqual(set(non_aggregate_indexes), set(query.group_indexes),
                         "Invalid indexes: {}".format(query))

def compile(self, query):
    """Parse one query and compile it.

    Args:
      query: An SQL query to be parsed.
    Returns:
      The AST.
    """
    statement = self.parse(query)
    c_query = qc.compile(statement,
                         self.xcontext_targets,
                         self.xcontext_postings,
                         self.xcontext_entries)
    if isinstance(c_query, qp.Select):
        self.assertSelectInvariants(c_query)
    return c_query

def setUp(self):
    self.parser = qp.Parser()

def allocate(self, allocator):
    self.handle = allocator.allocate()

def initialize(self, store):
    store[self.handle] = 0

def update(self, store, unused_ontext):
    store[self.handle] += 1

def allocate(self, allocator):
    self.handle = allocator.allocate()

def initialize(self, store):
    store[self.handle] = None

def update(self, store, context):
    if store[self.handle] is None:
        value = self.eval_args(context)[0]
        store[self.handle] = value

def allocate(self, allocator):
    self.handle = allocator.allocate()

def initialize(self, store):
    store[self.handle] = None

def update(self, store, context):
    value = self.eval_args(context)[0]
    store[self.handle] = value

def allocate(self, allocator):
    self.handle = allocator.allocate()

def initialize(self, store):
    store[self.handle] = self.dtype()

def update(self, store, context):
    value = self.eval_args(context)[0]
    if value > store[self.handle]:
        store[self.handle] = value

def allocate(self, allocator):
    self.handle = allocator.allocate()

def initialize(self, store):
    store[self.handle] = self.dtype()

def update(self, store, context):
    value = self.eval_args(context)[0]
    if value < store[self.handle]:
        store[self.handle] = value

def allocate(self, allocator):
    self.handle = allocator.allocate()

def initialize(self, store):
    store[self.handle] = self.dtype()

def update(self, store, context):
    value = self.eval_args(context)[0]
    if value is not None:
        store[self.handle] += value

def update(self, store, context):
    value = self.eval_args(context)[0]
    store[self.handle].add_amount(value)

def allocate(self, allocator):
    self.handle = allocator.allocate()

def initialize(self, store):
    store[self.handle] = inventory.Inventory()

def update(self, store, context):
    value = self.eval_args(context)[0]
    store[self.handle].add_inventory(value)

def update(self, store, context):
    value = self.eval_args(context)[0]
    store[self.handle].add_position(value)

@parser.parse_doc()
def test_AnyMeta(self, entries, _, options_map):
    """
    2016-11-20 *
      name: "TheName"
      address: "1 Wrong Way"
      empty: "NotEmpty"
      Assets:Banking          1 USD
        color: "Green"
        address: "1 Right Way"
        empty:
    """
    rtypes, rrows = query.run_query(entries, options_map,
                                    'SELECT ANY_META("name") as m')
    self.assertEqual([('TheName',)], rrows)

    rtypes, rrows = query.run_query(entries, options_map,
                                    'SELECT ANY_META("color") as m')
    self.assertEqual([('Green',)], rrows)

    rtypes, rrows = query.run_query(entries, options_map,
                                    'SELECT ANY_META("address") as m')
    self.assertEqual([('1 Right Way',)], rrows)

    rtypes, rrows = query.run_query(entries, options_map,
                                    'SELECT ANY_META("empty") as m')
    self.assertEqual([(None,)], rrows)

@parser.parse_doc()
def test_Coalesce(self, entries, _, options_map):
    """
    2016-11-20 *
      Assets:Banking          1 USD
    """
    rtypes, rrows = query.run_query(entries, options_map,
                                    'SELECT COALESCE(account, price) as m')
    self.assertEqual([('Assets:Banking',)], rrows)

    rtypes, rrows = query.run_query(entries, options_map,
                                    'SELECT COALESCE(price, account) as m')
    self.assertEqual([('Assets:Banking',)], rrows)

    rtypes, rrows = query.run_query(entries, options_map,
                                    'SELECT COALESCE(price, cost_number) as m')
    self.assertEqual([(None,)], rrows)

    rtypes, rrows = query.run_query(entries, options_map,
                                    'SELECT COALESCE(narration, account) as m')
    self.assertEqual([('',)], rrows)

@parser.parse_doc()
def test_Date(self, entries, _, options_map):
    """
    2016-11-20 * "ok"
      Assets:Banking          1 USD
    """
    rtypes, rrows = query.run_query(entries, options_map,
                                    'SELECT date(2020, 1, 2) as m')
    self.assertEqual([(datetime.date(2020, 1, 2),)], rrows)

    rtypes, rrows = query.run_query(entries, options_map,
                                    'SELECT date(year, month, 1) as m')
    self.assertEqual([(datetime.date(2016, 11, 1),)], rrows)

    with self.assertRaisesRegex(ValueError, "day is out of range for month"):
        rtypes, rrows = query.run_query(entries, options_map,
                                        'SELECT date(2020, 2, 32) as m')

    rtypes, rrows = query.run_query(entries, options_map,
                                    'SELECT date("2020-01-02") as m')
    self.assertEqual([(datetime.date(2020, 1, 2),)], rrows)

    rtypes, rrows = query.run_query(entries, options_map,
                                    'SELECT date("2016/11/1") as m')
    self.assertEqual([(datetime.date(2016, 11, 1),)], rrows)

@parser.parse_doc()
def test_DateDiffAdjust(self, entries, _, options_map):
    """
    2016-11-20 * "ok"
      Assets:Banking          -1 STOCK { 5 USD, 2016-10-30 }
    """
    rtypes, rrows = query.run_query(entries, options_map,
                                    'SELECT date_diff(date, cost_date) as m')
    self.assertEqual([(21,)], rrows)

    rtypes, rrows = query.run_query(entries, options_map,
                                    'SELECT date_diff(cost_date, date) as m')
    self.assertEqual([(-21,)], rrows)

    rtypes, rrows = query.run_query(entries, options_map,
                                    'SELECT date_add(date, 1) as m')
    self.assertEqual([(datetime.date(2016, 11, 21),)], rrows)

    rtypes, rrows = query.run_query(entries, options_map,
                                    'SELECT date_add(date, -1) as m')
    self.assertEqual([(datetime.date(2016, 11, 19),)], rrows)

@parser.parse_doc()
def test_GrepN(self, entries, _, options_map):
    """
    2016-11-20 * "prev match in context next"
      Assets:Banking          1 USD
    """
    rtypes, rrows = query.run_query(entries, options_map, '''
      SELECT GREPN("in", narration, 0) as m
    ''')
    self.assertEqual([('in',)], rrows)

    rtypes, rrows = query.run_query(entries, options_map, '''
      SELECT GREPN("match (.*) context", narration, 1) as m
    ''')
    self.assertEqual([('in',)], rrows)

    rtypes, rrows = query.run_query(entries, options_map, '''
      SELECT GREPN("(.*) in (.*)", narration, 2) as m
    ''')
    self.assertEqual([('context next',)], rrows)

    rtypes, rrows = query.run_query(entries, options_map, '''
      SELECT GREPN("ab(at)hing", "abathing", 1) as m
    ''')
    self.assertEqual([('at',)], rrows)

@parser.parse_doc()
def test_Subst(self, entries, _, options_map):
    """
    2016-11-20 * "I love candy"
      Assets:Banking       -1 USD

    2016-11-21 * "Buy thing thing"
      Assets:Cash          -1 USD
    """
    rtypes, rrows = query.run_query(entries, options_map, '''
      SELECT SUBST("[Cc]andy", "carrots", narration) as m where date = 2016-11-20
    ''')
    self.assertEqual([('I love carrots',)], rrows)

    rtypes, rrows = query.run_query(entries, options_map, '''
      SELECT SUBST("thing", "t", narration) as m where date = 2016-11-21
    ''')
    self.assertEqual([('Buy t t',)], rrows)

    rtypes, rrows = query.run_query(entries, options_map, '''
      SELECT SUBST("random", "t", narration) as m where date = 2016-11-21
    ''')
    self.assertEqual([('Buy thing thing',)], rrows)

    rtypes, rrows = query.run_query(entries, options_map, '''
      SELECT SUBST("(love)", "\\1 \\1", narration) as m where date = 2016-11-20
    ''')
    self.assertEqual([('I love love candy',)], rrows)

    rtypes, rrows = query.run_query(entries, options_map, '''
      SELECT SUBST("Assets:.*", "Savings", account) as a, str(sum(position)) as p
    ''')
    self.assertEqual([('Savings', '(-2 USD)')], rrows)

def allocate(self):
    """Allocate a new slot to store row aggregation information.

    Returns:
      A unique handle used to index into an row-aggregation store (an integer).
    """
    handle = self.size
    self.size += 1
    return handle

def create_store(self):
    """Create a new row-aggregation store suitable to contain all the node allocations.

    Returns:
      A store that can accommodate and be indexed by all the allocated slot handles.
    """
    return [None] * self.size

def compile(self, bql_string):
    """Parse a query and compile it.

    Args:
      bql_string: An SQL query to be parsed.
    Returns:
      A compiled EvalQuery node.
    """
    return qc.compile_select(self.parse(bql_string),
                             self.xcontext_targets,
                             self.xcontext_postings,
                             self.xcontext_entries)

def parse(self, bql_string):
    """Parse a query.

    Args:
      bql_string: An SQL query to be parsed.
    Returns:
      A parsed statement (Select() node).
    """
    return self.parser.parse(bql_string.strip())

def setUp(self):
    super().setUp()
    self.parser = query_parser.Parser()

def __getnewargs__(self):
    'Return self as a plain tuple.  Used by copy and pickle.'
    return _tuple(self)

def __repr__(self):
    'Return a nicely formatted representation string'
    return self.__class__.__name__ + repr_fmt % self

def _asdict(self):
    'Return a new dict which maps field names to their values.'
    return _dict(_zip(self._fields, self))

@classmethod
def _make(cls, iterable):
    result = tuple_new(cls, iterable)
    if _len(result) != num_fields:
        raise TypeError(f'Expected {num_fields} arguments, got {len(result)}')
    return result

def _replace(self, /, **kwds):
    result = self._make(_map(kwds.pop, field_names, self))
    if kwds:
        raise ValueError(f'Got unexpected field names: {list(kwds)!r}')
    return result

def __getnewargs__(self):
    'Return self as a plain tuple.  Used by copy and pickle.'
    return _tuple(self)

def __repr__(self):
    'Return a nicely formatted representation string'
    return self.__class__.__name__ + repr_fmt % self

def _asdict(self):
    'Return a new dict which maps field names to their values.'
    return _dict(_zip(self._fields, self))

@classmethod
def _make(cls, iterable):
    result = tuple_new(cls, iterable)
    if _len(result) != num_fields:
        raise TypeError(f'Expected {num_fields} arguments, got {len(result)}')
    return result

def _replace(self, /, **kwds):
    result = self._make(_map(kwds.pop, field_names, self))
    if kwds:
        raise ValueError(f'Got unexpected field names: {list(kwds)!r}')
    return result

def __getnewargs__(self):
    'Return self as a plain tuple.  Used by copy and pickle.'
    return _tuple(self)

def __repr__(self):
    'Return a nicely formatted representation string'
    return self.__class__.__name__ + repr_fmt % self

def _asdict(self):
    'Return a new dict which maps field names to their values.'
    return _dict(_zip(self._fields, self))

@classmethod
def _make(cls, iterable):
    result = tuple_new(cls, iterable)
    if _len(result) != num_fields:
        raise TypeError(f'Expected {num_fields} arguments, got {len(result)}')
    return result

def _replace(self, /, **kwds):
    result = self._make(_map(kwds.pop, field_names, self))
    if kwds:
        raise ValueError(f'Got unexpected field names: {list(kwds)!r}')
    return result

def __getnewargs__(self):
    'Return self as a plain tuple.  Used by copy and pickle.'
    return _tuple(self)

def __repr__(self):
    'Return a nicely formatted representation string'
    return self.__class__.__name__ + repr_fmt % self

def _asdict(self):
    'Return a new dict which maps field names to their values.'
    return _dict(_zip(self._fields, self))

@classmethod
def _make(cls, iterable):
    result = tuple_new(cls, iterable)
    if _len(result) != num_fields:
        raise TypeError(f'Expected {num_fields} arguments, got {len(result)}')
    return result

def _replace(self, /, **kwds):
    result = self._make(_map(kwds.pop, field_names, self))
    if kwds:
        raise ValueError(f'Got unexpected field names: {list(kwds)!r}')
    return result

def t_DATE(self, token):
    r"(\#(\"[^\"]*\"|\'[^\']*\')|\d\d\d\d-\d\d-\d\d)"
    if token.value[0] == '#':
        token.value = dateutil.parser.parse(token.value[2:-1]).date()
    else:
        token.value = datetime.datetime.strptime(token.value, '%Y-%m-%d').date()
    return token

def t_DECIMAL(self, token):
    r"[-+]?([0-9]+\.[0-9]*|[0-9]*\.[0-9]+)"
    token.value = D(token.value)
    return token

def t_ID(self, token):
    "[a-zA-Z][a-zA-Z_]*"
    utoken = token.value.upper()
    if utoken in self.keywords:
        token.type = utoken
        token.value = token.value.upper()
    else:
        token.value = token.value.lower()
    return token

def t_INTEGER(self, token):
    r"[-+]?[0-9]+"
    token.value = int(token.value)
    return token

def t_STRING(self, token):
    "(\"[^\"]*\"|\'[^\']*\')"
    token.value = token.value[1:-1]
    return token

def p_balances_statement(self, p):
    """
    balances_statement : BALANCES summary_func from where
    """
    p[0] = Balances(p[2], p[3], p[4])

def p_delimiter(self, p):
    """
    delimiter : SEMI
              | empty
    """

def p_errors_statement(self, p):
    """
    errors_statement : ERRORS
    """
    p[0] = Errors()

def p_explain_statement(self, p):
    "top_statement : EXPLAIN statement delimiter"
    p[0] = Explain(p[2])

def p_journal_statement(self, p):
    """
    journal_statement : JOURNAL summary_func from
                      | JOURNAL account summary_func from
    """
    p[0] = Journal(None, p[2], p[3]) if len(p) == 4 else Journal(p[2], p[3], p[4])

def p_print_statement(self, p):
    """
    print_statement : PRINT from
    """
    p[0] = Print(p[2])

def p_regular_statement(self, p):
    "top_statement : statement delimiter"
    p[0] = p[1]

def p_reload_statement(self, p):
    """
    reload_statement : RELOAD
    """
    p[0] = Reload()

def p_run_statement(self, p):
    """
    run_statement : RUN ID
                  | RUN STRING
                  | RUN ASTERISK
                  | RUN empty
    """
    p[0] = RunCustom(p[2])

def p_statement(self, p):
    """
    statement : select_statement
              | balances_statement
              | journal_statement
              | print_statement
              | run_statement
              | errors_statement
              | reload_statement
    """
    p[0] = p[1]

def p_summary_func(self, p):
    """
    summary_func : empty
                 | AT ID
    """
    p[0] = p[2] if len(p) == 3 else None

def __getnewargs__(self):
    'Return self as a plain tuple.  Used by copy and pickle.'
    return _tuple(self)

def __repr__(self):
    'Return a nicely formatted representation string'
    return self.__class__.__name__ + repr_fmt % self

def _asdict(self):
    'Return a new dict which maps field names to their values.'
    return _dict(_zip(self._fields, self))

@classmethod
def _make(cls, iterable):
    result = tuple_new(cls, iterable)
    if _len(result) != num_fields:
        raise TypeError(f'Expected {num_fields} arguments, got {len(result)}')
    return result

def _replace(self, /, **kwds):
    result = self._make(_map(kwds.pop, field_names, self))
    if kwds:
        raise ValueError(f'Got unexpected field names: {list(kwds)!r}')
    return result

def __getnewargs__(self):
    'Return self as a plain tuple.  Used by copy and pickle.'
    return _tuple(self)

def __repr__(self):
    'Return a nicely formatted representation string'
    return self.__class__.__name__ + repr_fmt % self

def _asdict(self):
    'Return a new dict which maps field names to their values.'
    return _dict(_zip(self._fields, self))

@classmethod
def _make(cls, iterable):
    result = tuple_new(cls, iterable)
    if _len(result) != num_fields:
        raise TypeError(f'Expected {num_fields} arguments, got {len(result)}')
    return result

def _replace(self, /, **kwds):
    result = self._make(_map(kwds.pop, field_names, self))
    if kwds:
        raise ValueError(f'Got unexpected field names: {list(kwds)!r}')
    return result

def __getnewargs__(self):
    'Return self as a plain tuple.  Used by copy and pickle.'
    return _tuple(self)

def __repr__(self):
    'Return a nicely formatted representation string'
    return self.__class__.__name__ + repr_fmt % self

def _asdict(self):
    'Return a new dict which maps field names to their values.'
    return _dict(_zip(self._fields, self))

@classmethod
def _make(cls, iterable):
    result = tuple_new(cls, iterable)
    if _len(result) != num_fields:
        raise TypeError(f'Expected {num_fields} arguments, got {len(result)}')
    return result

def _replace(self, /, **kwds):
    result = self._make(_map(kwds.pop, field_names, self))
    if kwds:
        raise ValueError(f'Got unexpected field names: {list(kwds)!r}')
    return result

def __getnewargs__(self):
    'Return self as a plain tuple.  Used by copy and pickle.'
    return _tuple(self)

def __repr__(self):
    'Return a nicely formatted representation string'
    return self.__class__.__name__ + repr_fmt % self

def _asdict(self):
    'Return a new dict which maps field names to their values.'
    return _dict(_zip(self._fields, self))

@classmethod
def _make(cls, iterable):
    result = tuple_new(cls, iterable)
    if _len(result) != num_fields:
        raise TypeError(f'Expected {num_fields} arguments, got {len(result)}')
    return result

def _replace(self, /, **kwds):
    result = self._make(_map(kwds.pop, field_names, self))
    if kwds:
        raise ValueError(f'Got unexpected field names: {list(kwds)!r}')
    return result

def handle_comma_separated_list(self, p):
    """Handle a list of 0, 1 or more comma-separated values.
    Args:
      p: A grammar object.
    """
    if len(p) == 2:
        return [] if p[1] is None else [p[1]]
    else:
        return p[1] + [p[3]]

def p_account(self, p):
    """
    account : STRING
    """
    p[0] = p[1]

def p_boolean(self, p):
    """
    boolean : TRUE
            | FALSE
    """
    p[0] = (p[1] == 'TRUE')

def p_column(self, p):
    """
    column : ID
    """
    p[0] = Column(p[1])

def p_column_list(self, p):
    """
    column_list : column
                | column_list COMMA column
    """
    p[0] = self.handle_comma_separated_list(p)

def p_constant(self, p):
    """
    constant : NULL
             | boolean
             | INTEGER
             | DECIMAL
             | STRING
             | DATE
    """
    p[0] = Constant(p[1] if p[1] != 'NULL' else None)

def p_distinct(self, p):
    """
    distinct : empty
             | DISTINCT
    """
    p[0] = True if p[1] == 'DISTINCT' else None

def p_empty(self, _):
    """
    empty :
    """

def p_expr_index(self, p):
    """
    expr_index : expression
               | INTEGER
    """
    p[0] = p[1]

def p_expr_index_list(self, p):
    """
    expr_index_list : expr_index
                    | expr_index_list COMMA expr_index
    """
    p[0] = self.handle_comma_separated_list(p)

def p_expression_add(self, p):
    "expression : expression PLUS expression"
    p[0] = Add(p[1], p[3])

def p_expression_and(self, p):
    "expression : expression AND expression"
    p[0] = And(p[1], p[3])

def p_expression_column(self, p):
    "expression : column"
    p[0] = p[1]

def p_expression_constant(self, p):
    "expression : constant"
    p[0] = p[1]

def p_expression_contains(self, p):
    "expression : expression IN expression"
    p[0] = Contains(p[1], p[3])

def p_expression_div(self, p):
    "expression : expression SLASH expression"
    p[0] = Div(p[1], p[3])

def p_expression_eq(self, p):
    "expression : expression EQ expression"
    p[0] = Equal(p[1], p[3])

def p_expression_function(self, p):
    "expression : ID LPAREN expression_list_opt RPAREN"
    p[0] = Function(p[1], p[3])

def p_expression_gt(self, p):
    "expression : expression GT expression"
    p[0] = Greater(p[1], p[3])

def p_expression_gte(self, p):
    "expression : expression GTE expression"
    p[0] = GreaterEq(p[1], p[3])

def p_expression_list(self, p):
    """
    expression_list : expression
                    | expression_list COMMA expression
    """
    p[0] = self.handle_comma_separated_list(p)

def p_expression_list_opt(self, p):
    """
    expression_list_opt : empty
                        | expression
                        | expression_list COMMA expression
    """
    p[0] = self.handle_comma_separated_list(p)

def p_expression_lt(self, p):
    "expression : expression LT expression"
    p[0] = Less(p[1], p[3])

def p_expression_lte(self, p):
    "expression : expression LTE expression"
    p[0] = LessEq(p[1], p[3])

def p_expression_match(self, p):
    "expression : expression TILDE expression"
    p[0] = Match(p[1], p[3])

def p_expression_mul(self, p):
    "expression : expression ASTERISK expression"
    p[0] = Mul(p[1], p[3])

def p_expression_ne(self, p):
    "expression : expression NE expression"
    p[0] = Not(Equal(p[1], p[3]))

def p_expression_not(self, p):
    "expression : NOT expression"
    p[0] = Not(p[2])

def p_expression_or(self, p):
    "expression : expression OR expression"
    p[0] = Or(p[1], p[3])

def p_expression_paren(self, p):
    "expression : LPAREN expression RPAREN"
    p[0] = p[2]

def p_expression_sub(self, p):
    "expression : expression MINUS expression"
    p[0] = Sub(p[1], p[3])

def p_flatten(self, p):
    """
    flatten : empty
            | FLATTEN
    """
    p[0] = True if p[1] == 'FLATTEN' else None

def p_from(self, p):
    """
    from : empty
         | FROM opt_expression opt_open opt_close opt_clear
    """
    if len(p) != 2:
        if all(p[i] is None for i in range(2, 6)):
            raise ParseError("Empty FROM expression is not allowed")
        p[0] = From(p[2], p[3], p[4], p[5])
    else:
        p[0] = None

def p_from_subselect(self, p):
    """
    from_subselect : from
                   | FROM LPAREN select_statement RPAREN
    """
    if len(p) == 2:
        p[0] = p[1]
    else:
        p[0] = p[3]

def p_group_by(self, p):
    """
    group_by : empty
             | GROUP BY expr_index_list having
    """
    p[0] = GroupBy(p[3], p[4]) if len(p) != 2 else None

def p_having(self, p):
    """
    having : empty
           | HAVING expression
    """
    p[0] = p[2] if len(p) == 3 else None

def p_limit(self, p):
    """
    limit : empty
          | LIMIT INTEGER
    """
    p[0] = p[2] if len(p) == 3 else None

def p_opt_clear(self, p):
    """
    opt_clear : empty
              | CLEAR
    """
    p[0] = True if (p[1] == 'CLEAR') else None

def p_opt_close(self, p):
    """
    opt_close : empty
              | CLOSE
              | CLOSE ON DATE
    """
    p[0] = p[3] if len(p) == 4 else (True
                                     if (p[1] == 'CLOSE') else
                                     self.default_close_date)

def p_opt_expression(self, p):
    """
    opt_expression : empty
                   | expression
    """
    p[0] = p[1]

def p_opt_open(self, p):
    """
    opt_open : empty
             | OPEN ON DATE
    """
    p[0] = p[3] if len(p) == 4 else None

def p_order_by(self, p):
    """
    order_by : empty
             | ORDER BY expr_index_list ordering
    """
    p[0] = None if len(p) == 2 else OrderBy(p[3], p[4])

def p_ordering(self, p):
    """
    ordering : empty
             | ASC
             | DESC
    """
    p[0] = p[1]

def p_pivot_by(self, p):
    """
    pivot_by : empty
             | PIVOT BY column_list
    """
    p[0] = PivotBy(p[3]) if len(p) == 4 else None

def p_select_statement(self, p):
    """
    select_statement : SELECT distinct target_spec from_subselect where \
                       group_by order_by pivot_by limit flatten
    """
    p[0] = Select(p[3], p[4], p[5], p[6], p[7], p[8], p[9], p[2], p[10])

def p_target(self, p):
    """
    target : expression AS ID
           | expression
    """
    p[0] = Target(p[1], p[3] if len(p) == 4 else None)

def p_target_list(self, p):
    """
    target_list : target
                | target_list COMMA target
    """
    p[0] = self.handle_comma_separated_list(p)

def p_target_spec(self, p):
    """
    target_spec : ASTERISK
                | target_list
    """
    p[0] = Wildcard() if p[1] == '*' else p[1]

def p_where(self, p):
    """
    where : empty
          | WHERE expression
    """
    if len(p) == 3:
        assert p[2], "Empty WHERE clause is not allowed"
        p[0] = p[2]

def assertParse(self, expected, query, debug=False):
    """Assert parsed contents from 'query' is 'expected'.

    Args:
      expected: An expected AST to compare against the parsed value.
      query: An SQL query to be parsed.
      debug: A boolean, if true, print extra debugging information on the console.
    Raises:
      AssertionError: If the actual AST does not match the expected one.
    """
    actual = self.parse(query)
    if debug:
        print()
        print()
        print(actual)
        print()
    self.assertEqual(expected, actual)
    return actual

def parse(self, query):
    """Parse one query.

    Args:
      query: An SQL query to be parsed.
    Returns:
      The AST.
    """
    return self.parser.parse(query.strip())

def setUp(self):
    self.parser = qp.Parser()

def setUp(self):
    super().setUp()
    self.targets = [qp.Target(qp.Column('a'), None),
                    qp.Target(qp.Column('b'), None)]
    self.expr = qp.Equal(qp.Column('d'),
                         qp.And(
                             qp.Function('max', [qp.Column('e')]),
                             qp.Constant(17)))

def on_Balances(self, balance):
    """
    Select balances of some subset of postings. This command is a
    convenience and converts into an equivalent Select statement, designed
    to extract the most sensible list of columns for the register of a list
    of entries as a table.

    The general form of a JOURNAL statement loosely follows SQL syntax:

       BALANCE [FROM_CLAUSE]

    See the SELECT query help for more details on the FROM clause.
    """
    return self.on_Select(balance)

def on_Errors(self, errors_statement):
    """
    Print the errors that occurred during parsing.
    """
    if self.errors:
        printer.print_errors(self.errors)
    else:
        print('(No errors)', file=self.outfile)

def on_Explain(self, explain):
    """
    Compile and print a compiled statement for debugging.
    """
    # pylint: disable=invalid-name
    pr = lambda *args: print(*args, file=self.outfile)
    pr("Parsed statement:")
    pr("  {}".format(explain.statement))
    pr()

    # Compile the select statement and print it uot.
    try:
        query = query_compile.compile(explain.statement,
                                      self.env_targets,
                                      self.env_postings,
                                      self.env_entries)
    except query_compile.CompilationError as exc:
        pr(str(exc).rstrip('.'))
        return

    pr("Compiled query:")
    pr("  {}".format(query))
    pr()
    pr("Targets:")
    for c_target in query.c_targets:
        pr("  '{}'{}: {}".format(
            c_target.name or '(invisible)',
            ' (aggregate)' if query_compile.is_aggregate(c_target.c_expr) else '',
            c_target.c_expr.dtype.__name__))
    pr()

def on_Journal(self, journal):
    """
    Select a journal of some subset of postings. This command is a
    convenience and converts into an equivalent Select statement, designed
    to extract the most sensible list of columns for the register of a list
    of entries as a table.

    The general form of a JOURNAL statement loosely follows SQL syntax:

       JOURNAL <account-regexp> [FROM_CLAUSE]

    See the SELECT query help for more details on the FROM clause.
    """
    return self.on_Select(journal)

def on_Print(self, print_stmt):
    """
    Print entries in Beancount format.

    The general form of a PRINT statement includes an SQL-like FROM
    selector:

       PRINT [FROM <from_expr> ...]

    Where:

      from_expr: A logical expression that matches on the attributes of
        the directives. See SELECT command for details (this FROM expression
        supports all the same expressions including its OPEN, CLOSE and
        CLEAR operations).

    """
    # Compile the print statement.
    try:
        c_print = query_compile.compile(print_stmt,
                                        self.env_targets,
                                        self.env_postings,
                                        self.env_entries)
    except query_compile.CompilationError as exc:
        print('ERROR: {}.'.format(str(exc).rstrip('.')), file=self.outfile)
        return

    if self.outfile is sys.stdout:
        query_execute.execute_print(c_print, self.entries, self.options_map,
                                    file=self.outfile)
    else:
        with self.get_pager() as file:
            query_execute.execute_print(c_print, self.entries, self.options_map, file)

def on_Reload(self, unused_statement=None):
    """
    Reload the input file without restarting the shell.
    """
    self.entries, self.errors, self.options_map = self.loadfun()
    if self.is_interactive:
        print_statistics(self.entries, self.options_map, self.outfile)

def on_RunCustom(self, run_stmt):
    """
    Run a custom query instead of a SQL command.

       RUN <custom-query-name>

    Where:

      custom-query-name: Should be the name of a custom query to be defined
        in the Beancount input file.

    """
    custom_query_map = create_custom_query_map(self.entries)
    name = run_stmt.query_name
    if name is None:
        # List the available queries.
        for name in sorted(custom_query_map):
            print(name)
    elif name == "*":
        for name, query in sorted(custom_query_map.items()):
            print('{}:'.format(name))
            self.run_parser(query.query_string, default_close_date=query.date)
            print()
            print()
    else:
        query = None
        if name in custom_query_map:
            query = custom_query_map[name]
        else:  # lookup best query match using name as prefix
            queries = [q for q in custom_query_map if q.startswith(name)]
            if len(queries) == 1:
                name = queries[0]
                query = custom_query_map[name]
        if query:
            statement = self.parser.parse(query.query_string)
            self.dispatch(statement)
        else:
            print("ERROR: Query '{}' not found".format(name))

def on_Select(self, statement):
    """
    Extract data from a query on the postings.

    The general form of a SELECT statement loosely follows SQL syntax, with
    some mild and idiomatic extensions:

       SELECT [DISTINCT] [<targets>|*]
       [FROM <from_expr> [OPEN ON <date>] [CLOSE [ON <date>]] [CLEAR]]
       [WHERE <where_expr>]
       [GROUP BY <groups>]
       [ORDER BY <groups> [ASC|DESC]]
       [LIMIT num]

    Where:

      targets: A list of desired output attributes from the postings, and
        expressions on them. Some of the attributes of the parent transaction
        directive are made available in this context as well. Simple functions
        (that return a single value per row) and aggregation functions (that
        return a single value per group) are available. For the complete
        list of supported columns and functions, see help on "targets".
        You can also provide a wildcard here, which will select a reasonable
        default set of columns for rendering a journal.

      from_expr: A logical expression that matches on the attributes of
        the directives (not postings). This allows you to select a subset of
        transactions, so the accounting equation is respected for balance
        reports. For the complete list of supported columns and functions,
        see help on "from".

      where_expr: A logical expression that matches on the attributes of
        postings. The available columns are similar to those in the targets
        clause, without the aggregation functions.

      OPEN clause: replace all the transactions before the given date by
        summarizing entries and transfer Income and Expenses balances to
        Equity.

      CLOSE clause: Remove all the transactions after the given date and

      CLEAR: Transfer final Income and Expenses balances to Equity.

    """
    # Compile the SELECT statement.
    try:
        c_query = query_compile.compile(statement,
                                        self.env_targets,
                                        self.env_postings,
                                        self.env_entries)
    except query_compile.CompilationError as exc:
        print('ERROR: {}.'.format(str(exc).rstrip('.')), file=self.outfile)
        return

    # Execute it to obtain the result rows.
    rtypes, rrows = query_execute.execute_query(c_query,
                                                self.entries,
                                                self.options_map)

    # Output the resulting rows.
    if not rrows:
        print("(empty)", file=self.outfile)
    else:
        output_format = self.vars['format']
        if output_format == 'text':
            kwds = dict(boxed=self.vars['boxed'],
                        spaced=self.vars['spaced'],
                        expand=self.vars['expand'])
            if self.outfile is sys.stdout:
                with self.get_pager() as file:
                    query_render.render_text(rtypes, rrows,
                                             self.options_map['dcontext'],
                                             file,
                                             **kwds)
            else:
                query_render.render_text(rtypes, rrows,
                                         self.options_map['dcontext'],
                                         self.outfile,
                                         **kwds)

        elif output_format == 'csv':
            # Numberify CSV output if requested.
            if self.vars['numberify']:
                dformat = self.options_map['dcontext'].build()
                rtypes, rrows = numberify.numberify_results(rtypes, rrows, dformat)

            query_render.render_csv(rtypes, rrows,
                                    self.options_map['dcontext'],
                                    self.outfile,
                                    expand=self.vars['expand'])

        else:
            assert output_format not in _SUPPORTED_FORMATS
            print("Unsupported output format: '{}'.".format(output_format),
                  file=self.outfile)

def __init__(self, is_interactive, parser, outfile, default_format, do_numberify):
    """Create a shell with history.

    Args:
      is_interactive: A boolean, true if this serves an interactive tty.
      parser: A command parser.
      outfile: An output file object to write communications to.
      default_format: A string, the default output format.
    """
    super().__init__()
    if is_interactive and readline is not None:
        load_history(path.expanduser(HISTORY_FILENAME))
    self.is_interactive = is_interactive
    self.parser = parser
    self.initialize_vars(default_format, do_numberify)
    self.add_help()
    self.outfile = outfile

def add_help(self):
    "Attach help functions for each of the parsed token handlers."
    for attrname, func in list(self.__class__.__dict__.items()):
        match = re.match('on_(.*)', attrname)
        if not match:
            continue
        command_name = match.group(1)
        setattr(self.__class__, 'help_{}'.format(command_name.lower()),
                lambda _, fun=func: print(textwrap.dedent(fun.__doc__).strip(),
                                          file=self.outfile))

def cmdloop(self):
    """Override cmdloop to handle keyboard interrupts."""
    while True:
        try:
            super().cmdloop()
            break
        except KeyboardInterrupt:
            print('\n(Interrupted)', file=self.outfile)

def default(self, line):
    """Default handling of lines which aren't recognized as native shell commands.

    Args:
      line: The string to be parsed.
    """
    self.run_parser(line)

def dispatch(self, statement):
    """Dispatch the given statement to a suitable method.

    Args:
      statement: An instance provided by the parser.
    Returns:
      Whatever the invoked method happens to return.
    """
    try:
        method = getattr(self, 'on_{}'.format(type(statement).__name__))
    except AttributeError:
        print("Internal error: statement '{}' is unsupported.".format(statement),
              file=self.outfile)
    else:
        return method(statement)

def exit(self, _):
    """Exit the parser."""
    print('exit', file=self.outfile)
    return 1

def do_clear(self, _):
    "Clear the history."
    readline.clear_history()

def exit(self, _):
    """Exit the parser."""
    print('exit', file=self.outfile)
    return 1

def do_help(self, command):
    """Strip superfluous semicolon."""
    super().do_help(command.rstrip('; \t'))

def do_history(self, _):
    "Print the command-line history statement."
    if readline is not None:
        for index, line in enumerate(get_history(self.max_entries)):
            print(line, file=self.outfile)

def do_lex(self, line):
    "Just run the lexer on the following command and print the output."
    try:
        self.parser.tokenize(line)
    except query_parser.ParseError as exc:
        print(exc, file=self.outfile)

def do_parse(self, line):
    "Just run the parser on the following command and print the output."
    print("INPUT: {}".format(repr(line)), file=self.outfile)
    try:
        statement = self.parser.parse(line, True)
        print(statement, file=self.outfile)
    except (query_parser.ParseError,
            query_compile.CompilationError) as exc:
        print(exc, file=self.outfile)
    except Exception as exc:
        traceback.print_exc(file=self.outfile)

def exit(self, _):
    """Exit the parser."""
    print('exit', file=self.outfile)
    return 1

def do_set(self, line):
    "Get/set shell settings variables."
    if not line:
        for varname, value in sorted(self.vars.items()):
            print('{}: {}'.format(varname, value), file=self.outfile)
    else:
        components = shlex.split(line)
        varname = components[0]
        if len(components) == 1:
            try:
                value = self.vars[varname]
                print('{}: {}'.format(varname, value), file=self.outfile)
            except KeyError:
                print("Variable '{}' does not exist.".format(varname),
                      file=self.outfile)
        elif len(components) == 2:
            value = components[1]
            try:
                converted_value = self.vars_types[varname](value)
                self.vars[varname] = converted_value
                print('{}: {}'.format(varname, converted_value), file=self.outfile)
            except KeyError:
                print("Variable '{}' does not exist.".format(varname),
                      file=self.outfile)
        else:
            print("Invalid number of arguments.", file=self.outfile)

def do_lex(self, line):
    "Just run the lexer on the following command and print the output."
    try:
        self.parser.tokenize(line)
    except query_parser.ParseError as exc:
        print(exc, file=self.outfile)

def emptyline(self):
    """Do nothing on an empty line."""

def exit(self, _):
    """Exit the parser."""
    print('exit', file=self.outfile)
    return 1

def get_pager(self):
    """Create and return a context manager to write to, a pager subprocess if required.

    Returns:
      A pair of a file object to write to, and a pipe object to wait on (or
    None if not necessary to wait).
    """
    if self.is_interactive:
        return pager.ConditionalPager(self.vars.get('pager', None),
                                      minlines=misc_utils.get_screen_height())
    else:
        file = (codecs.getwriter("utf-8")(sys.stdout.buffer)
                if hasattr(sys.stdout, 'buffer') else
                sys.stdout)
        return pager.flush_only(file)

def initialize_vars(self, default_format, do_numberify):
    """Initialize the setting variables of the interactive shell."""
    self.vars_types = {
        'pager': str,
        'format': str,
        'boxed': convert_bool,
        'spaced': convert_bool,
        'expand': convert_bool,
        'numberify': convert_bool,
        }
    self.vars = {
        'pager': os.environ.get('PAGER', None),
        'format': default_format,
        'boxed': False,
        'spaced': False,
        'expand': False,
        'numberify': do_numberify,
        }

def run_parser(self, line, default_close_date=None):
    """Handle statements via our parser instance and dispatch to appropriate methods.

    Args:
      line: The string to be parsed.
      default_close_date: A datetimed.date instance, the default close date.
    """
    try:
        statement = self.parser.parse(line,
                                      default_close_date=default_close_date)
        self.dispatch(statement)
    except query_parser.ParseError as exc:
        print(exc, file=self.outfile)
    except Exception as exc:
        traceback.print_exc(file=self.outfile)

@test_utils.docfile
def test_success(self, filename):
    """
    2013-01-01 open Assets:Account1
    2013-01-01 open Assets:Account2
    2013-01-01 open Assets:Account3
    2013-01-01 open Equity:Unknown

    2013-04-05 *
      Equity:Unknown
      Assets:Account1     5000 USD

    2013-04-05 *
      Assets:Account1     -3000 USD
      Assets:Account2        30 BOOG {100 USD}

    2013-04-05 *
      Assets:Account1     -1000 USD
      Assets:Account3       800 EUR @ 1.25 USD
    """
    with test_utils.capture('stdout', 'stderr') as (stdout, _):
        test_utils.run_with_args(shell.main, [filename, "SELECT 1;"])
    self.assertTrue(stdout.getvalue())