One-click install
npx skills add https://github.com/mikialex/rendiation --skill query-system
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: query-system
Source: https://github.com/mikialex/rendiation/tree/main/.claude/skills/query-system
Command: npx skills add https://github.com/mikialex/rendiation --skill query-system

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

It eliminates the complexity of maintaining up-to-date derived state when in-memory relational data changes, so query results stay synchronized with incremental updates instead of requiring full recomputation.

Core Features & Use Cases

  • Incremental view + delta model: Represents each derived mapping as a current snapshot (view) plus a change sequence (delta), enabling correct propagation through combinators.
  • Composable query operators: Supports operators like map, filter/map, chain, join, union to build incremental computation pipelines over key→value and key→many data.
  • FK fanout for relational change propagation: Uses a reverse multi-query (TriQuery) to propagate changes across foreign-key relationships efficiently.
  • Batch change handling: Provides DataChanges abstractions and bridges from ValueChange-based deltas for batch processing workflows.
  • Validation helpers: Includes consistency checks for Query/MultiQuery behaviors (iter/access hints).

Quick Start

Use the query-system skill to design an incremental renderer pipeline where database writes produce deltas, combinators compute derived state, and fanout propagates FK updates to keep GPU-related inputs synchronized.

Frequently Asked Questions about query-system

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I keep incremental query results in sync when in-memory relational data changes?

Incremental query results stay synchronized by pairing a current snapshot view with a structured delta change stream, propagating updates through combinators instead of requiring full recomputation. This eliminates the complexity of maintaining up-to-date derived state.

What is the best way to propagate foreign-key changes across relational data pipelines?

Foreign-key change propagation uses a reverse multi-query (TriQuery) to fan out updates across inverse relations efficiently. This dual and tri-query model ensures reactive computation pipelines stay consistent when relational data mutates.

How do I build incremental computation pipelines with composable query operators?

Incremental computation pipelines are built using composable query operators like map, filter, chain, join, and union over key-to-value and key-to-many data. Each derived mapping maintains a snapshot plus delta sequence for correct propagation.

How does batch change handling work with ValueChange-based deltas?

Batch change handling bridges ValueChange-based deltas into DataChanges abstractions, enabling batch iteration semantics for processing workflows. This allows multiple relational updates to be applied and validated consistently in groups.

Do I need Rust traits to implement reactive query and multi-query models?

Yes, implementing reactive queries requires Rust traits to define Query, MultiQuery, DualQuery, and ValueChange behaviors. These traits establish the incremental view, delta model, and consistency validation needed for correct relational synchronization.

When should I avoid incremental view maintenance and use full recomputation instead?

Incremental view maintenance is unnecessary when relational data changes rarely or when derived state is simple enough that full recomputation costs less than delta propagation overhead. It suits scenarios where writes produce frequent deltas requiring synchronized GPU or renderer inputs.