Che cosa sono le Live Queries in tempo reale?

Una live query è una sottoscrizione a una query sul database: il server spinge gli eventi create, update e delete delle righe corrispondenti. È il tempo verbale che mancava all’accesso ai dati: le query normali parlano al passato (“che cosa corrispondeva nel momento della richiesta”), le live queries parlano al presente continuo (“che cosa corrisponde, mentre cambia”). Lo schermo smette di chiedere e inizia a restare giusto.

Punti chiave

La sottoscrizione, in codice

Il gesto che definisce tutto – prendere la query che già esisteva e sottoscriverla:

// 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) }

Il vocabolario degli eventi merita la sua tabella, perché enter e leave sono ciò che fa di questa la sottoscrizione a una query e non la notifica di una tabella:

La pipeline dietro il push

Due metà, separabili con pulizia: la sorgente dei cambiamenti – il feed di scritture del database stesso (change streams negli archivi documentali, log di replica altrove) – e il livello di matching, che confronta ogni cambiamento con ogni predicato registrato e spinge esattamente verso i sottoscrittori i cui risultati sono cambiati, con i permessi applicati per singolo sottoscrittore. Il protocollo aperto LiveQuery è un’implementazione di riferimento leggibile di tutta questa forma.

Live queries vs. polling vs. SSE vs. WebSocket

L’ultima colonna è l’argomento: con i socket grezzi restano da costruire il protocollo dei messaggi, l’instradamento, le verifiche dei permessi e il recupero dopo la riconnessione; con le live queries il predicato è il protocollo e il resto appartiene alla piattaforma.

Casi d’uso tipici

• Chat e caselle di posta – si sottoscrivono i messaggi della conversazione; l’arrivo è un evento, non un aggiornamento manuale.
• Dashboard in diretta – ordini, metriche, flotte: la query definisce la vista, gli eventi la tengono vera.
• App collaborative – bacheche di attività e documenti condivisi, dove le modifiche di cinque persone si intrecciano in pochi secondi.
• Presenza e stato – chi è online, che cosa è in corso: enter e leave fanno qui il loro lavoro di precisione.
• Schermate operative – console di supporto e viste di amministrazione che devono rispecchiare la produzione adesso, non all’ultimo aggiornamento.

Polling, push o sottoscrizione? Matrice decisionale

La disciplina lato client che tiene sane le sottoscrizioni, qualunque sia la scelta: sottoscrivere in modo ristretto (predicati selettivi su campi indicizzati) e disiscriversi quando la schermata si chiude – le query permanenti sono stato sul server, e le schermate che le lasciano filtrare accumulano costi in modo invisibile.

Limiti e trade-off

• Il matching è un carico di lavoro reale. Ogni scrittura viene confrontata con i predicati registrati; migliaia di sottoscrizioni larghe su classi molto sollecitate lo moltiplicano – la selettività è la leva.
• Le connessioni sono stato. La flotta di socket ha bisogno di affinità, heartbeat e backplane di fan-out – le piattaforme gestite esistono proprio perché questo è lavoro pesante e indifferenziato.
• Le riconnessioni richiedono un recupero. Un client che era offline ha perso degli eventi; i flussi robusti rieseguono la query di base alla ri-sottoscrizione invece di dare per buono che nel buco non sia successo nulla.
• Ordine e consegna hanno la forma dell’at-least-once. Handler di eventi idempotenti (applicare per ID dell’oggetto, non per accodamento) assorbono con eleganza il duplicato occasionale.
• Non tutto chiede una sottoscrizione. I dati guardati raramente e cambiati raramente sono territorio del polling; le live queries si guadagnano il loro costo dove occhi e scritture sono entrambi frequenti.

Le live queries su Back4app

Back4app è una piattaforma open-source di Backend as a Service (BaaS) che combina database gestito, API REST e GraphQL generate automaticamente, autenticazione, archiviazione di file e funzioni serverless con Cloud Code. Live Query ne è il livello di tempo reale, e le schede di codice qui sopra sono tutta la storia lato client: lo stesso query builder già in uso, una sola chiamata di sottoscrizione, cinque eventi tipizzati – con le ACL verificate per singolo sottoscrittore, così che il tempo reale non scavalchi mai il modello dei permessi, e con flotta di WebSocket, change stream e fan-out che girano come infrastruttura gestita. Basta abilitare Live Query su una classe nella dashboard e sottoscrivere da qualsiasi SDK: il presente continuo diventa una feature, non un progetto.