O que são Live Queries em Tempo Real?

Uma live query é uma subscription a uma consulta de banco de dados — o servidor faz push de eventos de criação, atualização e exclusão conforme acontecem. É o tempo verbal que faltava no acesso a dados: consultas normais falam no passado (“o que correspondia quando perguntei”), live queries falam no presente contínuo (“o que corresponde, à medida que muda”). A tela para de perguntar e passa a se manter certa.

Principais pontos

A subscription, em código

O movimento que define o conceito — pegue a consulta que você já tinha e inscreva-se nela:

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

O vocabulário de eventos merece sua própria tabela, porque enter e leave são o que torna isto uma subscription de consulta, e não uma notificação de tabela:

O pipeline por trás do push

Duas metades, separáveis com clareza: a fonte de mudanças — o feed de escritas do próprio banco (change streams em bancos de documentos, logs de replicação nos demais) — e a camada de correspondência, que verifica cada mudança contra todos os predicados registrados e faz push exatamente aos assinantes cujos resultados mudaram, com permissões aplicadas por assinante. O protocolo aberto LiveQuery é uma implementação de referência legível do formato inteiro.

Live queries vs. polling vs. SSE vs. WebSockets

A última coluna é o argumento: com sockets crus você constrói o protocolo de mensagens, o roteamento, as checagens de permissão e o reconectar-e-atualizar; com live queries o predicado é o protocolo e a plataforma é dona do resto.

Casos de uso comuns

• Chat e caixas de entrada — inscreva-se nas mensagens da conversa; a chegada é um evento, não um refresh.
• Dashboards ao vivo — pedidos, métricas, frotas: a consulta define a visão, os eventos a mantêm verdadeira.
• Apps colaborativos — quadros de tarefas e documentos compartilhados em que as edições de cinco pessoas se entrelaçam em segundos.
• Presença e status — quem está online, o que está em andamento — enter/leave fazendo seu trabalho de precisão.
• Telas operacionais — consoles de suporte e visões de admin que precisam refletir a produção agora, não no último refresh.

Poll, push ou subscription? Matriz de decisão

A disciplina de cliente que mantém subscriptions saudáveis, seja qual for a escolha: inscreva-se de forma estreita (predicados seletivos em campos indexados) e cancele a subscription quando a tela fechar — consultas permanentes são estado no servidor, e telas que as vazam acumulam custo invisivelmente.

Limitações e trade-offs

• Correspondência é carga de verdade. Cada escrita é verificada contra os predicados registrados; milhares de subscriptions amplas em classes quentes multiplicam isso — seletividade é a alavanca.
• Conexões são estado. A frota de sockets precisa de afinidade, heartbeats e backplanes de fan-out — plataformas gerenciadas existem exatamente porque isso é trabalho pesado sem diferencial.
• Reconexões precisam de catch-up. Um cliente que ficou offline perdeu eventos; fluxos robustos reexecutam a consulta base ao reinscrever-se, em vez de confiar que o intervalo foi quieto.
• Ordenação e entrega têm formato at-least-once. Handlers de eventos idempotentes (aplique por ID do objeto, não por append) absorvem o duplicado ocasional com elegância.
• Nem tudo quer uma subscription. Dados raramente vistos e raramente alterados são território de polling; live queries pagam seu custo onde olhos e escritas são ambos frequentes.

Live queries no Back4app

O Back4app é uma plataforma open-source de Backend as a Service (BaaS) que combina banco de dados gerenciado, APIs REST e GraphQL geradas automaticamente, autenticação, armazenamento de arquivos e funções serverless com Cloud Code. O Live Query é sua camada de tempo real, e as abas de código acima são toda a história do cliente: o mesmo query builder que você já usa, uma chamada de subscribe, cinco eventos tipados — com ACLs verificadas por assinante para que o tempo real nunca passe por cima do modelo de permissões, e com a frota de WebSockets, os change streams e o fan-out rodando como infraestrutura gerenciada. Habilite o Live Query em uma classe no dashboard, inscreva-se de qualquer SDK, e o presente contínuo vira uma feature, não um projeto.