Incremental Computation

Incremental Computation is a processing paradigm where, instead of recomputing results from scratch whenever new data arrives or underlying data changes, the system only processes the changes (increments or deltas) and updates the previously computed results. This approach is significantly more efficient than full recomputation, especially for large datasets or continuous data streams, as it minimizes redundant work.

RisingWave is fundamentally built around the principle of incremental computation, particularly for its Materialized Views and streaming dataflows.

Core Idea

Imagine you have a sum of a list of numbers.

Full Recomputation: If a new number is added to the list, you add up all the numbers in the new list from scratch.
Incremental Computation: If a new number is added, you take the previous sum and just add the new number to it. If a number is removed, you subtract it from the previous sum.

This simple example illustrates the efficiency gain, which becomes much more pronounced with complex computations and large datasets.

Why is Incremental Computation Important in Stream Processing?

Low Latency: By processing only new data (deltas), results can be updated very quickly, providing near real-time insights. This is crucial for applications that require immediate feedback or action based on fresh data.
Efficiency and Resource Savings: Processing only changes significantly reduces computational load, CPU usage, I/O operations, and memory consumption compared to recomputing everything. This makes it feasible to handle high-velocity data streams and complex analytics continuously.
Freshness of Results: Results (e.g., in Materialized Views) are kept consistently up-to-date as new data flows in, rather than becoming stale between batch updates.
Scalability: The reduced resource footprint per update allows the system to scale to handle larger data volumes and more complex queries.

How Incremental Computation Works in RisingWave

RisingWave employs incremental computation primarily through its Materialized Views and the underlying streaming dataflow engine.

Change Data Capture (CDC) / Stream Ingestion: RisingWave ingests streams of data, which are often sequences of change events (inserts, updates, deletes) from sources like Kafka, Kinesis, or CDC from databases.
Stateful Operators: Streaming operators in RisingWave (like joins, aggregations, filters) are stateful. They maintain the necessary intermediate state (e.g., current sum, count, joined records) to perform incremental updates.
Differential Dataflow / Operator Algebra:
- When a new batch of change events (a "delta") arrives, these events propagate through the dataflow graph.
- Each operator receives input changes, updates its internal state based on these changes, and emits output changes (another delta) to downstream operators.
- For example:
  - An aggregate operator (e.g., SUM) might receive +1 for a new record and -1 for a retracted (deleted/updated old version) record. It updates its current sum and emits the change in the sum.
  - A join operator maintains the state of records from both input streams that match the join condition. When a new record arrives on one stream, it probes the state of the other stream to find matches and emits joined results. If a record is retracted, it emits retractions for previously joined results.
Materialized Views as Incremental Updates:
- The results of a SQL query defining a Materialized View are maintained incrementally.
- When source data changes, RisingWave doesn't re-run the entire query. Instead, it uses the stream of changes from the dataflow to update only the affected rows in the Materialized View.
- This ensures that querying a Materialized View is fast, as the results are pre-computed and kept fresh.

Key Requirements for Effective Incremental Computation

Well-defined Semantics for Changes: The system needs a clear way to represent and process inserts, updates (often as a retraction of the old value and an insertion of the new value), and deletes.
State Management: Efficient and durable storage for the intermediate state of operators is essential (this is where Hummock comes into play in RisingWave).
Operator Design: Streaming operators must be designed to handle incremental updates correctly and efficiently.
Consistency: Ensuring that state updates and emitted changes are consistent, especially in distributed environments and during fault recovery (often tied to checkpointing).

Benefits in RisingWave