Was sind Live Queries in Echtzeit?

Eine Live Query ist ein Abonnement auf eine Datenbankabfrage: Der Server sendet create-, update- und delete-Ereignisse für passende Zeilen in Echtzeit. Es ist die fehlende Zeitform des Datenbankzugriffs: Normale Abfragen sprechen in der Vergangenheit (“was passte, als ich fragte”), Live Queries sprechen in der laufenden Gegenwart (“was passt, während es sich ändert”). Der Bildschirm hört auf zu fragen und bleibt einfach richtig.

Das Wichtigste in Kürze

Das Abonnement, in Code

Der entscheidende Handgriff – nehmen Sie die Abfrage, die Sie ohnehin hatten, und abonnieren Sie sie:

// JavaScript / Node.js — Back4app JS SDK
// A live query: subscribe to a QUERY and receive its changes as events
const query = new Parse.Query('Task');
query.equalTo('assignee', currentUser);

const sub = await query.subscribe();
sub.on('create', (t) => addRow(t));       // new match appeared
sub.on('update', (t) => refreshRow(t));   // a match changed
sub.on('enter',  (t) => addRow(t));       // edited INTO the result set
sub.on('leave',  (t) => removeRow(t));    // edited OUT of the result set
sub.on('delete', (t) => removeRow(t));    // a match was deleted

// Flutter / Dart — Back4app Flutter SDK
// A live query: subscribe to a QUERY and receive its changes as events
final liveQuery = LiveQuery();
final query = QueryBuilder<ParseObject>(ParseObject('Task'))
  ..whereEqualTo('assignee', currentUser);

final sub = await liveQuery.client.subscribe(query);
sub.on(LiveQueryEvent.create, (t) => addRow(t));     // new match
sub.on(LiveQueryEvent.update, (t) => refreshRow(t)); // match changed
sub.on(LiveQueryEvent.enter, (t) => addRow(t));      // edited into the set
sub.on(LiveQueryEvent.leave, (t) => removeRow(t));   // edited out of the set

// iOS / Swift — Back4app Swift SDK
// A live query: subscribe to a QUERY and receive its changes as events
let query = Task.query("assignee" == currentUser)

let subscription = query.subscribeCallback
subscription?.handleEvent { _, event in
  switch event {
  case .created(let t):  addRow(t)        // new match appeared
  case .updated(let t):  refreshRow(t)    // a match changed
  case .entered(let t):  addRow(t)        // edited INTO the result set
  case .left(let t):     removeRow(t)     // edited OUT of the result set
  case .deleted(let t):  removeRow(t)
  }
}

// Android / Kotlin — Back4app Android SDK
// A live query: subscribe to a QUERY and receive its changes as events
val client = ParseLiveQueryClient.Factory.getClient()
val query = ParseQuery.getQuery<ParseObject>("Task")
query.whereEqualTo("assignee", currentUser)

val sub = client.subscribe(query)
sub.handleEvent(SubscriptionHandling.Event.CREATE) { _, t -> addRow(t) }
sub.handleEvent(SubscriptionHandling.Event.UPDATE) { _, t -> refreshRow(t) }
sub.handleEvent(SubscriptionHandling.Event.ENTER)  { _, t -> addRow(t) }
sub.handleEvent(SubscriptionHandling.Event.LEAVE)  { _, t -> removeRow(t) }

Das Vokabular der Ereignisse verdient eine eigene Tabelle, denn enter und leave machen daraus ein Abonnement auf eine Abfrage statt einer Tabellenbenachrichtigung:

Die Pipeline hinter dem Push

Zwei Hälften, sauber trennbar: die Änderungsquelle – der eigene Schreib-Feed der Datenbank (Change Streams in dokumentenorientierten Speichern, anderswo Replikationsprotokolle) – und die Abgleichsschicht, die jede Änderung gegen jedes registrierte Prädikat prüft und genau an die Abonnenten sendet, deren Ergebnisse sich geändert haben, mit Berechtigungsprüfung pro Abonnent. Das offene LiveQuery-Protokoll ist eine gut lesbare Referenzimplementierung dieser gesamten Form.

Live Queries vs. Polling vs. SSE vs. WebSockets

Die letzte Spalte ist das Argument: Mit rohen Sockets bauen Sie das Nachrichtenprotokoll, das Routing, die Berechtigungsprüfungen und das Nachholen nach einer Wiederverbindung; mit Live Queries ist das Prädikat das Protokoll, und die Plattform besitzt den Rest.

Typische Anwendungsfälle

• Chat und Posteingänge – abonnieren Sie die Nachrichten einer Unterhaltung; die Ankunft ist ein Ereignis, keine Aktualisierung.
• Live-Dashboards – Bestellungen, Kennzahlen, Fuhrparks: Die Abfrage definiert die Ansicht, Ereignisse halten sie wahr.
• Kollaborative Apps – gemeinsame Aufgabenbretter und Dokumente, in denen sich die Änderungen von fünf Personen im Sekundentakt verschränken.
• Präsenz und Status – wer online ist, was gerade läuft – hier leisten enter und leave ihre präzise Arbeit.
• Betriebsbildschirme – Support-Konsolen und Admin-Ansichten, die die Produktion jetzt abbilden müssen, nicht zum Zeitpunkt der letzten Aktualisierung.

Pollen, pushen oder abonnieren? Eine Entscheidungsmatrix

Die Disziplin auf Client-Seite, die Abonnements gesund hält, wie Sie sich auch entscheiden: eng abonnieren (selektive Prädikate auf indizierten Feldern) und abbestellen, wenn der Bildschirm geschlossen wird – dauerhafte Abfragen sind Serverzustand, und Bildschirme, die sie lecken, sammeln unsichtbar Kosten an.

Grenzen und Trade-offs

• Der Abgleich ist eine echte Arbeitslast. Jeder Schreibvorgang wird gegen die registrierten Prädikate geprüft; Tausende breiter Abonnements auf stark genutzten Klassen vervielfachen das – Selektivität ist der Hebel.
• Verbindungen sind Zustand. Die Socket-Flotte braucht Affinität, Heartbeats und Fan-out-Backplanes – verwaltete Plattformen existieren genau deshalb, weil das undifferenzierte Schwerstarbeit ist.
• Wiederverbindungen brauchen ein Nachholen. Ein Client, der offline war, hat Ereignisse verpasst; robuste Abläufe führen beim erneuten Abonnieren die Basisabfrage noch einmal aus, statt darauf zu vertrauen, dass die Lücke ruhig war.
• Reihenfolge und Zustellung haben At-least-once-Charakter. Idempotente Ereignis-Handler (nach Objekt-ID anwenden, nicht anhängen) verkraften das gelegentliche Duplikat anstandslos.
• Nicht alles will ein Abonnement. Selten betrachtete, selten geänderte Daten sind Polling-Gebiet; Live Queries verdienen ihre Kosten dort, wo Blicke und Schreibvorgänge beide häufig sind.

Live Queries mit Back4app

Back4app ist eine Open-Source-Plattform für Backend as a Service (BaaS), die eine verwaltete Datenbank, automatisch generierte REST- und GraphQL-APIs, Authentifizierung, Dateispeicher und Serverless-Funktionen mit Cloud Code kombiniert. Live Query ist die zugehörige Echtzeit-Schicht, und die Code-Tabs oben sind die gesamte Geschichte auf Client-Seite: derselbe Query Builder, den Sie schon verwenden, ein einziger Abonnement-Aufruf, fünf typisierte Ereignisse – mit ACLs, die pro Abonnent geprüft werden, sodass Echtzeit das Berechtigungsmodell nie umgeht, und mit WebSocket-Flotte, Change Streams und Fan-out als verwaltete Infrastruktur. Aktivieren Sie Live Query für eine Klasse im Dashboard, abonnieren Sie aus jedem beliebigen SDK, und die laufende Gegenwart wird ein Feature statt eines Projekts.