query/me.ahoo.wow.query.store/QueryStores

QueryStores

class QueryStores(val bulkheads: Map<String, QueryBulkhead> = emptyMap(), val limits: List<AdaptiveQueryLimit> = emptyList(), val datasets: QueryBulkhead? = null, unpinned: (AggregateType) -> UnpinnedEvents = { UnpinnedEvents.ALLOW })

How the queries of a node's stores run, composed once, in wow-query, so every host gets the same bounds: the bulkheads of the stores, by name, their adaptive limits, the bulkhead every dataset query runs under (datasets), and whether each aggregate type's events queries that name no aggregate run (unpinned). A state read's replay of a log runs under the bulkhead of the log's store too (replay).

Constructors

QueryStores

constructor(bulkheads: Map<String, QueryBulkhead> = emptyMap(), limits: List<AdaptiveQueryLimit> = emptyList(), datasets: QueryBulkhead? = null, unpinned: (AggregateType) -> UnpinnedEvents = { UnpinnedEvents.ALLOW })

Types

Companion

@InternalWowApi

object Companion

Properties

all

val all: List<QueryBulkhead>

Every bulkhead: the stores' and the datasets'.

bulkheads

val bulkheads: Map<String, QueryBulkhead>

datasets

val datasets: QueryBulkhead?

The bulkhead of the dataset queries (wow.query.dataset.max-concurrent), or null when they run unbounded. Its limit is fixed: the warehouse's writes (the ClickHouse Sink's) give the node no write pressure to adapt to.

limits

val limits: List<AdaptiveQueryLimit>

The bounds of bulkheads that adapt to their store's write pressure.

Functions

pressed

fun pressed(store: String?): Boolean

Whether the writes of store pressed in the last period its adaptive bound read (AdaptiveQueryLimit.pressed); false for a store whose bound does not adapt, or none.

replay

suspend fun <T> replay(store: String?, read: suspend () -> T): T

Runs read, a replay of a log on store, under that store's bulkhead; at once without one.

toString

open override fun toString(): String

unpinned

fun unpinned(type: AggregateType): UnpinnedEvents

Whether type's events queries that name no aggregate run.