else:

            store[self.handle].add(value)

    def __call__(self, context: Context) -> set:

        """Return the result for an aggregation."""

        return context.store[self.handle]  # type:ignore[no-any-return]

class FilterPostingsEnvironment(bc_query_env.FilterPostingsEnvironment):

    functions: EnvironmentFunctions = bc_query_env.FilterPostingsEnvironment.functions.copy()  # type:ignore[assignment]

    functions['meta_docs'] = MetaDocs

    functions['str_meta'] = StrMeta

class TargetsEnvironment(bc_query_env.TargetsEnvironment):

    functions = FilterPostingsEnvironment.functions.copy()

    functions.update(bc_query_env.AGGREGATOR_FUNCTIONS)

    functions['set'] = AggregateSet

class BooksLoader:

    """Closure to load books with a zero-argument callable

    This matches the load interface that BQLShell expects.

    """

    def __init__(

            self,

            books_loader: Optional[books.Loader],

            start_date: Optional[datetime.date]=None,

            stop_date: Optional[datetime.date]=None,

            rewrite_rules: Sequence[rewrite.RewriteRuleset]=(),

    ) -> None:

        self.books_loader = books_loader

        self.start_date = start_date

        self.stop_date = stop_date

        self.rewrite_rules = rewrite_rules

    def __call__(self) -> books.LoadResult:

        logger.debug("BooksLoader called")

        result = books.Loader.dispatch(self.books_loader, self.start_date, self.stop_date)

        logger.debug("books loaded from Beancount")

        if self.rewrite_rules:

            for index, entry in enumerate(result.entries):

                # entry might not be a Transaction; we catch that later.

                # The type ignores are because the underlying Beancount type isn't

                # type-checkable.

                postings = data.Posting.from_txn(entry)  # type:ignore[arg-type]

                for ruleset in self.rewrite_rules:

                    postings = ruleset.rewrite(postings)

                try:

                    result.entries[index] = entry._replace(postings=list(postings))  # type:ignore[call-arg]

                except AttributeError:

                    pass

            logger.debug("rewrite rules applied")

        return result

class BQLShell(bc_query_shell.BQLShell):

    def __init__(

            self,

            is_interactive: bool,

            loadfun: Callable[[], books.LoadResult],

            outfile: TextIO,

            default_format: str='text',

            do_numberify: bool=False,

            rt_wrapper: Optional[rtutil.RT]=None,

    ) -> None:

        super().__init__(is_interactive, loadfun, outfile, default_format, do_numberify)

        self.env_postings = FilterPostingsEnvironment()

        self.env_targets = TargetsEnvironment()

        self.ods = QueryODS(rt_wrapper)

    def on_Select(self, statement: QueryStatement) -> None:

        output_format: str = self.vars['format']

        try:

            render_func = getattr(self, f'_render_{output_format}')

        except AttributeError:

            logger.error("unknown output format %r", output_format)

            return

        try:

            logger.debug("compiling query")

            compiled_query = bc_query_compile.compile(

                statement, self.env_targets, self.env_postings, self.env_entries,

            )

            logger.debug("executing query")

            row_types, rows = bc_query_execute.execute_query(

                compiled_query, self.entries, self.options_map,

            )

            if self.vars['numberify']:

                logger.debug("numberifying query")

                row_types, rows = bc_query_numberify.numberify_results(

                    row_types, rows, self.options_map['dcontext'].build(),

                )

        except Exception as error:

            logger.error(str(error), exc_info=logger.isEnabledFor(logging.DEBUG))

            return

        if not rows and output_format != 'ods':

            print("(empty)", file=self.outfile)

        else:

            logger.debug("rendering query as %s", output_format)

            render_func(statement, row_types, rows)

    def _render_csv(self, statement: QueryStatement, row_types: RowTypes, rows: Rows) -> None:

        bc_query_render.render_csv(

            row_types,

            rows,

            self.options_map['dcontext'],

            self.outfile,

            self.vars['expand'],

        )

    def _render_ods(self, statement: QueryStatement, row_types: RowTypes, rows: Rows) -> None:

        self.ods.write_query(statement, row_types, rows)

        logger.info(

            "%s rows of results saved in sheet %s",

            len(rows),

            self.ods.sheet.getAttribute('name'),

        )

    def _render_text(self, statement: QueryStatement, row_types: RowTypes, rows: Rows) -> None:

        with contextlib.ExitStack() as stack:

            if self.is_interactive:

                output = stack.enter_context(self.get_pager())

            else:

                output = self.outfile

            bc_query_render.render_text(

                row_types,

                rows,

                self.options_map['dcontext'],

                output,

                self.vars['expand'],

                self.vars['boxed'],

                self.vars['spaced'],

            )

class QueryODS(core.BaseODS[NamedTuple, None]):

    META_FNAMES = frozenset([

        # Names of functions, as defined in Environments, that look up

        # posting metadata that could contain documentation links

        'any_meta',

        'entry_meta',

        'meta',

        'meta_docs',

        'str_meta',

    ])

    def is_empty(self) -> bool:

        return not self.sheet.childNodes

    def section_key(self, row: NamedTuple) -> None:

        return None

    def _generic_cell(self, value: Any) -> odf.table.TableCell:

        if isinstance(value, Iterable) and not isinstance(value, (str, tuple)):

            return self.multiline_cell(value)

        else:

            return self.string_cell('' if value is None else str(value))

    def _inventory_cell(self, value: Inventory) -> odf.table.TableCell:

        return self.balance_cell(core.Balance(pos.units for pos in value))

    def _link_string_cell(self, value: str) -> odf.table.TableCell:

        return self.meta_links_cell(value.split())

    def _metadata_cell(self, value: MetaValue) -> odf.table.TableCell:

        return self._cell_type(type(value))(value)

    def _position_cell(self, value: Position) -> odf.table.TableCell:

        return self.currency_cell(value.units)

    def _cell_type(self, row_type: Type) -> CellFunc:

        """Return a function to create a cell, for non-metadata row types."""

        if issubclass(row_type, Inventory):

            return self._inventory_cell

        elif issubclass(row_type, Position):

            return self._position_cell

        elif issubclass(row_type, BeancountAmount):

            return self.currency_cell

        elif issubclass(row_type, (int, float, Decimal)):

            return self.float_cell

        elif issubclass(row_type, datetime.date):

            return self.date_cell

        elif issubclass(row_type, str):

            return self.string_cell

        else:

            return self._generic_cell

    def _link_cell_type(self, row_type: Type) -> CellFunc:

        """Return a function to create a cell from metadata with documentation links."""