NodeQueries

The queries of the subscription handlers (ContextQueries.of): the node's NodeQueryApi pinned to the tenant of each commit, as trusted code; an application's own NodeQueryApi bean as a caller of that tenant.

The bindings of the datasets: the application's QueryBindings<QueryDataset> bean, else the one dataset backend on the class path that is available (HostDatasets.provided), else none.

The engine's dataset gateways; the dataset bindings forget a dataset that leaves the QueryDatasets.

The events query backend of each aggregate type, by its events store: the store wow.aggregates.[<context>.<aggregate>].query.events.store names (an Elasticsearch store its event search Sink writes, say), else the store its log is on. The application's own EventQueryBackend bean when it has one, else the one of the query provider of the store's type: PostgreSQL's or MongoDB's over the log in place (the store's query-read-preference), Elasticsearch's over the Sink's events index, and a log in memory scanned in memory unless wow.query.memory.enabled is false, as its snapshots are queried then. Any other log, in memory without it, on a store whose type has no query provider, or the application's own, is not queried: its events model is not served, and an info log says so. A store named for a type that cannot serve its events queries fails the start.

Which of the service's aggregates its access policies govern, as its QueryEngine resolved them: what the ClickHouse Sink records of each aggregate in wow_catalog, so that the analytics catalog refuses their rows. Asked when a Sink describes its tables, once the node has started.

The query models the public routes serve: the engine's, wow.query.budgets.http.default-list-size.

The node's typed NodeQueryApi: the engine's gateways and read facade, each aggregate type found by its model's state class, its states read as the public port's state reads, its lists defaulted by wow.query.budgets.in-process.default-list-size and its streams read in wow.query.stream.chunk-size chunks. An application replaces it by declaring a NodeQueryApi bean, not by calling this method.

The application's beans the engine is built of, which it may give or not.

The count cache of the snapshot gateways, unless wow.query.count-cache.enabled is off: each count valid while the snapshot write checkpoint of its type on this node (me.ahoo.wow.runtime.node.ContextNode.snapshotCheckpoint) holds.

The datasets of the dataset files, wow.query.dataset.config-directory first, then the classpath; an application may give its own QueryDatasets, or add to this one while the node runs.

The node's read side: the QueryEngine of the Manifest over the snapshot, events and dataset backends, the application's schema sources, mask strategies, access policies, read authorizers, filters and observers and its count caches, under wow.query.* (sensitivity, entry policy). The engine holds every security rule of the read side; this only maps the configuration onto it.

The node whose write pressure the stores' query bounds adapt to, once the context has built it.

The engine's schema Catalog.

How the queries of each store run: the bulkheads of the stores (wow.stores.<name>.query. max-concurrent, wow.query.max-concurrent, else the provider's from its pool), and whether each type's events queries that name no aggregate run. They are built before the node, which replays its states under them (wowReplayGate), so they take none of its beans: the node's write pressure is read as the bounds adapt (HostQueryNode), and the events backend, which the application's may build over the node, when a query asks.

Ends the open query streams before the public server's graceful shutdown waits for them.

How the state reads replay the log of an aggregate without a snapshot, and the node's subscriptions rebuild a state: under the query bulkhead of its log store, as that store's queries run; and whether that store's writes pressed, as its adaptive bound read them, which the access walk gives way to. The node is built with it (ServiceNode's replayGate), so it depends on no bean of the node's.