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_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 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 on_Select(self, statement): # pylint: disable=invalid-name
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
rtypes, rrows = query_execute.execute_query(c_query, self.entries,
self.options_map)
if not rrows:
print("(empty)", file=self.outfile)
self.result = rtypes, rrows
def on_Select(self, statement): # pylint: disable=invalid-name
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
rtypes, rrows = query_execute.execute_query(c_query, self.entries,
self.options_map)
if not rrows:
print("(empty)", file=self.outfile)
self.result = rtypes, rrows
def run_query(entries, options_map, query, *format_args, numberify=False):
"""Compile and execute a query, return the result types and rows.
Args:
entries: A list of entries, as produced by the loader.
options_map: A dict of options, as produced by the loader.
query: A string, a single BQL query, optionally containing some new-style
(e.g., {}) formatting specifications.
format_args: A tuple of arguments to be formatted in the query. This is
just provided as a convenience.
numberify: If true, numberify the results before returning them.
Returns:
A pair of result types and result rows.
Raises:
ParseError: If the statement cannot be parsed.
CompilationError: If the statement cannot be compiled.
"""
env_targets = query_env.TargetsEnvironment()
env_entries = query_env.FilterEntriesEnvironment()
env_postings = query_env.FilterPostingsEnvironment()
# Apply formatting to the query.
formatted_query = query.format(*format_args)
# Parse the statement.
parser = query_parser.Parser()
statement = parser.parse(formatted_query)
# Compile the SELECT statement.
c_query = query_compile.compile(statement, env_targets, env_postings,
env_entries)
# Execute it to obtain the result rows.
rtypes, rrows = query_execute.execute_query(c_query, entries, options_map)
# Numberify the results, if requested.
if numberify:
dformat = options_map['dcontext'].build()
rtypes, rrows = numberify_lib.numberify_results(rtypes, rrows, dformat)
return rtypes, rrows
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)
