Continuous views

A windowed query emits a group once, when the watermark passes the window's end. A query with no window emits differently: a live --follow run whose GROUP BY has no window function is a materialized view. It holds one running value per group and, at each refresh, republishes the groups that changed since the last one.

ubik --from kafka://broker/orders --follow --emit-every '2 seconds' -f json \
  "SELECT merchant, sum(amount) AS revenue, count(*) AS n
   FROM orders GROUP BY merchant"

Produce three orders to the topic:

{"merchant":"acme","amount":250}
{"merchant":"globex","amount":42}
{"merchant":"acme","amount":980}

At the next refresh the view emits one row per group:

{"merchant":"acme","revenue":1230,"n":2}
{"merchant":"globex","revenue":42,"n":1}

Now produce two more, one for the existing acme and one for a new initech:

{"merchant":"acme","amount":70}
{"merchant":"initech","amount":300}

The next refresh republishes only the groups that changed:

{"merchant":"acme","revenue":1300,"n":3}
{"merchant":"initech","revenue":300,"n":1}

acme is re-emitted with its new running total, initech appears, and globex is not re-emitted because nothing about it changed. The output is an upsert changelog keyed by the group tuple (here merchant), so a consumer reading latest-per-key always holds the true current aggregate. Point --to kafka://broker/topic at a sink to write that changelog to Kafka; it is the same keyed-upsert contract a windowed changelog uses, keyed by window and group. See Kafka source and sink.

Refresh cadence

--emit-every sets the refresh interval, default 2 seconds.

A view that has caught up to the source refreshes immediately, whatever the interval says, so a burst is reflected without waiting out the clock. Setting --emit-every 0 seconds leaves only those caught-up refreshes and the one taken before each checkpoint, never no emission.

Exactly-once

A materialized view checkpoints like any other run: the running per-group state and the source offsets are in the checkpoint, so a kill -9 resumes the view with each group's aggregate intact and no double counting. Run it as a supervised pipeline for automatic restart, or with --pipeline for the one-command durable form. See exactly-once.

Windowed or continuous

Both run the same aggregates over the same stream; the difference is when a group is emitted.

• A windowed query (GROUP BY ..., TUMBLE/HOP/SESSION(...)) emits each window once, when the watermark passes its end. The result is a stream of finished windows. See windows.
• A continuous view (GROUP BY with no window) never finishes a group: it keeps one running value per key and republishes it as it changes, on the --emit-every cadence.