¿Qué son las Live Queries en Tiempo Real?

Una live query es una suscripción a una consulta de base de datos: el servidor envía eventos create, update y delete de los registros coincidentes al ocurrir. Es el tiempo verbal que le faltaba al acceso a datos: las consultas normales hablan en pasado (“qué coincidía cuando pregunté”), las live queries hablan en presente continuo (“qué coincide, a medida que cambia”). La pantalla deja de preguntar y empieza a mantenerse en lo correcto.

Puntos clave

La suscripción, en código

El movimiento que lo define — toma la consulta que ya tenías, y suscríbete a ella:

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

El vocabulario de eventos merece su tabla, porque enter y leave son lo que hace de esto una suscripción a consultas y no una notificación de tablas:

El pipeline detrás del push

Dos mitades, limpiamente separables: la fuente de cambios — el propio feed de escrituras de la base de datos (change streams en los almacenes de documentos, logs de replicación en el resto) — y la capa de matching, que compara cada cambio contra cada predicado registrado y hace push exactamente a los suscriptores cuyos resultados cambiaron, con permisos aplicados por suscriptor. El protocolo abierto LiveQuery es una implementación de referencia legible de toda esta forma.

Live queries vs. polling vs. SSE vs. WebSockets

La última columna es el argumento: con sockets crudos construyes el protocolo de mensajes, el enrutamiento, los chequeos de permisos y la puesta al día tras reconectar; con live queries el predicado es el protocolo y la plataforma es dueña del resto.

Casos de uso comunes

• Chat e inboxes — suscríbete a los mensajes de la conversación; la llegada es un evento, no un refresh.
• Dashboards en vivo — pedidos, métricas, flotas: la consulta define la vista, los eventos la mantienen verdadera.
• Apps colaborativas — tableros de tareas y documentos compartidos donde las ediciones de cinco personas se entrelazan en segundos.
• Presencia y estado — quién está en línea, qué está en curso — enter/leave haciendo su trabajo de precisión.
• Pantallas operativas — consolas de soporte y vistas de administración que deben reflejar producción ahora, no el último refresh.

¿Poll, push o suscripción? Matriz de decisión

La disciplina del lado del cliente que mantiene sanas las suscripciones, elijas lo que elijas: suscríbete de forma acotada (predicados selectivos sobre campos indexados) y cancela la suscripción cuando la pantalla se cierra — las consultas permanentes son estado del servidor, y las pantallas que las filtran acumulan costo de forma invisible.

Limitaciones y trade-offs

• El matching es una carga de trabajo real. Cada escritura se verifica contra los predicados registrados; miles de suscripciones amplias sobre clases calientes lo multiplican — la selectividad es la palanca.
• Las conexiones son estado. La flota de sockets necesita afinidad, heartbeats y backplanes de fan-out — las plataformas gestionadas existen precisamente porque esto es trabajo pesado sin diferenciación.
• Las reconexiones necesitan puesta al día. Un cliente que estuvo offline se perdió eventos; los flujos robustos vuelven a correr la consulta base al resuscribirse en lugar de confiar en que el hueco estuvo tranquilo.
• El orden y la entrega tienen forma de at-least-once. Handlers de eventos idempotentes (aplica por ID de objeto, no por append) absorben con gracia el duplicado ocasional.
• No todo quiere una suscripción. Los datos poco vistos y poco cambiados son territorio de polling; las live queries ganan su costo donde ojos y escrituras son ambos frecuentes.

Live queries en Back4app

Back4app es una plataforma open-source de Backend as a Service (BaaS) que combina base de datos gestionada, APIs REST y GraphQL generadas automáticamente, autenticación, almacenamiento de archivos y funciones serverless con Cloud Code. Live Query es su capa de tiempo real, y las pestañas de código de arriba son toda la historia del cliente: el mismo constructor de consultas que ya usas, una llamada de suscripción, cinco eventos tipados — con ACLs verificadas por suscriptor para que el tiempo real nunca se salte el modelo de permisos, y con la flota de WebSockets, los change streams y el fan-out corriendo como infraestructura gestionada. Habilita Live Query en una clase desde el dashboard, suscríbete desde cualquier SDK, y el presente continuo pasa a ser una funcionalidad, no un proyecto.