smart-cache-sqlite • Exemplos de Uso

O que e smart-cache-sqlite?

O smart-cache-sqlite e uma biblioteca que adiciona uma camada de cache inteligente sobre bancos de dados SQLite. Ela combina estrategias de cache modernas com invalidacao automatica baseada nas mudancas do banco de dados.

Cache com TTL e LRU

Gerenciamento automatico de memoria usando Time-To-Live e Least Recently Used para otimizar performance.

Tres Estrategias de Cache

Cache-First, Network-First e Stale-While-Revalidate para diferentes necessidades de dados.

Invalidacao Automatica

Detecta mudancas no banco usando PRAGMA data_version do SQLite, sem necessidade de triggers manuais.

Telemetria Detalhada

Estatisticas completas de performance, hit rates e uso de memoria para monitoramento.

Instalacao

npm install smart-cache-sqlite better-sqlite3

Ou para projetos que usam sqlite3 assincrono:

npm install smart-cache-sqlite sqlite3

Exemplo Basico

Veja como e simples usar o smart-cache-sqlite em seu projeto:

import { SmartCache } from 'smart-cache-sqlite';
import Database from 'better-sqlite3';

// Criar conexao com o banco
const db = new Database('meu_banco.db');

// Criar instancia do cache
const cache = new SmartCache(db, {
  maxItems: 1000,
  ttlMs: 5 * 60 * 1000, // 5 minutos
  strategy: 'cache-first'
});

// Usar o cache para executar queries
const usuarios = cache.query('SELECT * FROM usuarios WHERE cidade = ?', ['Sao Paulo']);
console.log(usuarios);

Nota: O cache detecta automaticamente quando o banco de dados muda e invalida as entradas afetadas.

Estrategias de Cache

O smart-cache-sqlite oferece tres estrategias diferentes para diferentes tipos de dados:

Cache-First

Sempre tenta servir dados do cache primeiro. Se nao encontrar ou estiver expirado, busca no banco e armazena no cache. Ideal para dados que nao mudam frequentemente.

Network-First

Sempre busca no banco primeiro, depois armazena no cache. Util para dados criticos que precisam estar sempre atualizados.

Stale-While-Revalidate

Serve dados do cache imediatamente (mesmo se velhos), mas revalida em background para a proxima requisicao. Oferece a melhor experiencia do usuario.

Exemplo: Configurando Estrategias

// Cache-First para dados estaticos
const cacheEstatico = new SmartCache(db, {
  strategy: 'cache-first',
  ttlMs: 10 * 60 * 1000 // 10 minutos
});

// Network-First para dados criticos
const cacheCritico = new SmartCache(db, {
  strategy: 'network-first',
  ttlMs: 60 * 1000 // 1 minuto
});

// Stale-While-Revalidate para melhor UX
const cacheUX = new SmartCache(db, {
  strategy: 'stale-while-revalidate',
  ttlMs: 5 * 60 * 1000 // 5 minutos
});

Exemplos Avancados

Queries Complexas com JOIN

Busca de pedidos com informacoes do cliente

const pedidosComCliente = cache.query(`
  SELECT p.id, p.total, p.data_pedido,
         c.nome as cliente_nome, c.email
  FROM pedidos p
  JOIN clientes c ON p.cliente_id = c.id
  WHERE p.status = ?
  ORDER BY p.data_pedido DESC
  LIMIT ?
`, ['pendente', 50]);

O cache automaticamente identifica que esta query envolve as tabelas 'pedidos' e 'clientes', e ira invalidar o cache quando qualquer dessas tabelas for modificada.

Estatisticas e Monitoramento

Acompanhando performance do cache

// Obter estatisticas detalhadas
const stats = cache.stats();
console.log('Taxa de acerto:', stats.hitRate);
console.log('Total de consultas:', stats.totalQueries);
console.log('Itens em cache:', stats.totalItems);

// Exemplo de output:
// Taxa de acerto: 0.85 (85%)
// Total de consultas: 1247
// Itens em cache: 234

Invalidacao Manual

Limpar cache quando necessario

// Invalidar todo o cache
cache.invalidateAll();

// Invalidar queries especificas (futuro)
// cache.invalidatePattern('SELECT * FROM usuarios WHERE %');

Use invalidateAll() quando precisar forcar uma atualizacao completa dos dados em cache.

Configuracao Avancada

Opcoes do Construtor

const cache = new SmartCache(db, {
  // Numero maximo de itens em cache
  maxItems: 1000,

  // Tempo de vida em milissegundos
  ttlMs: 5 * 60 * 1000, // 5 minutos

  // Estrategia de cache
  strategy: 'cache-first', // 'cache-first' | 'network-first' | 'stale-while-revalidate'

  // Habilitar triggers para invalidacao fina (opcional)
  enableTriggers: false,

  // Tabelas para monitorar com triggers (se enableTriggers = true)
  trackedTables: ['usuarios', 'pedidos']
});

Adaptadores Disponiveis

O smart-cache-sqlite suporta diferentes adaptadores para SQLite:

BetterSqliteAdapter: Para better-sqlite3 (sincrono, mais rapido)
Sqlite3AsyncAdapter: Para sqlite3 (assincrono, mais compatibilidade)
ReactNativeQuickAdapter: Para React Native

Melhores Praticas

1. Escolha a estrategia certa

Use Cache-First para dados estaticos, Network-First para dados criticos, e Stale-While-Revalidate para melhor experiencia do usuario.

2. Configure TTL apropriado

Defina tempos de vida que balanceiem performance com atualidade dos dados. Dados muito estaticos podem ter TTL maior.

3. Monitore a performance

Use o metodo stats() regularmente para acompanhar hit rates e ajustar configuracoes conforme necessario.

4. Considere triggers para alta frequencia

Para bancos com muitas atualizacoes, considere habilitar triggers para invalidacao mais precisa por tabela.

Teste Interativo

Experimente o smart-cache-sqlite funcionando em tempo real. Esta é uma demonstração simulada que mostra como o cache se comporta com diferentes estratégias:

Nota: Esta demo usa dados simulados pois está hospedada no GitHub Pages (apenas arquivos estáticos). Para uma experiência completa com banco de dados real, execute localmente com npm run demo.

0

Itens no Cache

0%

Taxa de Acerto

0

Total de Consultas

LOG DE OPERACOES: