🚀 Oferta especial: 60% OFF no CrazyStack - Últimas vagas!Garantir vaga →
Tutorial Prático

Tutorial completo em 5 minutos Acesse Banco SQLite React Native

Métodos práticos para acessar e visualizar bancos SQLite em apps React Native. Funciona em Android Studio e iOS Simulator.

Guia Técnico Avançado

Métodos Profissionais Debug SQLite React Native

Domine técnicas avançadas para acessar, debugar e otimizar bancos SQLite em React Native. Inclui automação, monitoramento em tempo real e troubleshooting.

7
Métodos Diferentes
15min
Setup Completo
100%
Produção Ready

Por que SQLite Debug é Crucial?

Para desenvolvedores React Native, debugar SQLite não é opcional - é essencial. Sem visibilidade dos dados, você está programando às cegas. Problemas de performance, corrupção de dados, queries lentas e inconsistências só são detectados quando você pode ver exatamente o que está acontecendo no banco.

Sem Debug SQLite

  • • Bugs silenciosos em produção
  • • Performance degradada sem saber o motivo
  • • Dados corrompidos não detectados
  • • Queries N+1 passando despercebidas
  • • Migrações falhando sem contexto
  • • Sincronização offline quebrada

Debug Básico

  • • Console.log para tudo
  • • Debugging reativo, não proativo
  • • Sem visibilidade de schema
  • • Análise de performance limitada
  • • Troubleshooting demorado
  • • Dependência de logs verbosos

Debug Profissional

  • • Visibilidade completa dos dados
  • • Análise de performance em tempo real
  • • Detecção proativa de problemas
  • • Otimização baseada em dados reais
  • • Troubleshooting rápido e preciso
  • • Monitoramento contínuo

Métodos Android

Android oferece múltiplas formas de acessar SQLite. Cada método tem suas vantagens dependendo do seu workflow e necessidades específicas.

1Device Explorer (Android Studio)

Passo a Passo

1. Abra Device Explorer:

View → Tool Windows → Device Explorer

2. Navegue até o diretório:

data/data/com.seuapp.nome/databases/

3. Baixe o arquivo:

Botão direito → Save As → meuapp.db

Vantagens & Limitações

✅ Vantagens:
  • • Interface gráfica intuitiva
  • • Não precisa de comandos
  • • Visualiza estrutura de arquivos
  • • Funciona com qualquer emulador
❌ Limitações:
  • • Snapshot estático (não tempo real)
  • • Precisa baixar arquivo manualmente
  • • Não funciona com dispositivos físicos

2ADB Shell (Linha de Comando)

Comandos Essenciais

Conectar ao dispositivo:

adb shell

Navegar até banco:

cd /data/data/com.seuapp.nome/databases/

Abrir SQLite:

sqlite3 seuarquivo.db

Comandos úteis:

.tables # Lista tabelas
.schema users # Schema da tabela
SELECT * FROM users LIMIT 5;

Script de Automação

debug-sqlite.sh:

#!/bin/bash
APP_PACKAGE="com.seuapp.nome"
DB_NAME="seuarquivo.db"
OUTPUT_DIR="./debug-db"

# Criar diretório de output
mkdir -p $OUTPUT_DIR

# Extrair banco do dispositivo
adb exec-out run-as $APP_PACKAGE cat databases/$DB_NAME > $OUTPUT_DIR/$DB_NAME

# Abrir com Beekeeper Studio
open -a "Beekeeper Studio" $OUTPUT_DIR/$DB_NAME

echo "✅ Banco extraído para $OUTPUT_DIR/$DB_NAME"

3Flipper Integration (Tempo Real)

Setup Flipper

1. Instalar Flipper:

npm install --save-dev react-native-flipper

2. Plugin SQLite:

npm install flipper-plugin-databases

3. Configurar no código:

import {flipperDatabasesPlugin} from 'flipper-plugin-databases';

// No seu database helper
if (__DEV__) {
  flipperDatabasesPlugin(db, 'MyAppDB');
}

Benefícios do Flipper

  • Tempo real: Vê mudanças instantaneamente
  • Query profiling: Analisa performance
  • Schema inspector: Visualiza estrutura
  • Network integration: Correlaciona com APIs
  • Logs centralizados: Tudo em um lugar
  • Export/Import: Backup e restore fácil

Métodos iOS

iOS oferece acesso mais direto aos dados através do simulador, permitindo monitoramento em tempo real e debugging avançado.

1Simulator Container Access

Comando Base

Localizar container:

xcrun simctl get_app_container booted com.seuapp.nome data

Abrir no Finder:

open $(xcrun simctl get_app_container booted com.seuapp.nome data)

Navegar para Documents:

cd $(xcrun simctl get_app_container booted com.seuapp.nome data)/Documents

Script Automatizado

ios-debug.sh:

#!/bin/bash
APP_BUNDLE="com.seuapp.nome"
DB_NAME="seuarquivo.db"

# Obter caminho do container
CONTAINER_PATH=$(xcrun simctl get_app_container booted $APP_BUNDLE data)

# Verificar se app está rodando
if [ -z "$CONTAINER_PATH" ]; then
  echo "❌ App não encontrado. Certifique-se que está rodando no simulador."
  exit 1
fi

# Caminho completo do banco
DB_PATH="$CONTAINER_PATH/Documents/$DB_NAME"

if [ -f "$DB_PATH" ]; then
  echo "✅ Banco encontrado: $DB_PATH"
  
  # Abrir com Beekeeper Studio
  open -a "Beekeeper Studio" "$DB_PATH"
  
  # Ou abrir pasta no Finder
  open "$CONTAINER_PATH/Documents"
else
  echo "❌ Banco não encontrado em: $DB_PATH"
  echo "📁 Listando arquivos disponíveis:"
  ls -la "$CONTAINER_PATH/Documents"
fi

2Xcode Database Debugging

Usando Xcode Organizer

1. Abrir Organizer:

Window → Organizer → Devices and Simulators

2. Selecionar Simulator:

Escolha o simulador ativo → Installed Apps

3. Download Container:

Selecione sua app → Download Container

Vantagens do Xcode

  • Interface visual: Não precisa de comandos
  • Container completo: Baixa todos os arquivos
  • Histórico: Mantém versões anteriores
  • Metadata: Informações detalhadas da app
  • Crash logs: Integração com debugging

3Monitoramento em Tempo Real

File System Watcher

watch-db.sh:

#!/bin/bash
APP_BUNDLE="com.seuapp.nome"
DB_NAME="seuarquivo.db"

# Obter caminho do banco
CONTAINER_PATH=$(xcrun simctl get_app_container booted $APP_BUNDLE data)
DB_PATH="$CONTAINER_PATH/Documents/$DB_NAME"

echo "🔍 Monitorando: $DB_PATH"
echo "📊 Pressione Ctrl+C para parar"

# Monitorar mudanças no arquivo
fswatch -o "$DB_PATH" | while read f; do
  echo "🔄 $(date): Banco atualizado!"
  
  # Opcional: executar query de verificação
  sqlite3 "$DB_PATH" "SELECT COUNT(*) as total_records FROM sqlite_master WHERE type='table';"
done

Live Query Monitor

live-monitor.sh:

#!/bin/bash
APP_BUNDLE="com.seuapp.nome"
DB_NAME="seuarquivo.db"

CONTAINER_PATH=$(xcrun simctl get_app_container booted $APP_BUNDLE data)
DB_PATH="$CONTAINER_PATH/Documents/$DB_NAME"

# Função para executar query e mostrar resultado
run_query() {
  echo "📊 $(date '+%H:%M:%S') - Executando queries..."
  
  # Contagem de registros por tabela
  sqlite3 "$DB_PATH" "
    SELECT 
      name as table_name,
      (SELECT COUNT(*) FROM ' || name || ') as record_count
    FROM sqlite_master 
    WHERE type='table' AND name NOT LIKE 'sqlite_%';
  " -header -column
  
  echo "---"
}

# Executar a cada 5 segundos
while true; do
  run_query
  sleep 5
done

Ferramentas Profissionais

Escolha a ferramenta certa para cada situação. Cada uma tem suas vantagens específicas para diferentes workflows de desenvolvimento.

Beekeeper Studio (Recomendado)

✅ Vantagens:

  • • Interface moderna e intuitiva
  • • Suporte a múltiplos bancos
  • • Query builder visual
  • • Export/Import em vários formatos
  • • Gratuito e open source
  • • Auto-complete inteligente
  • • Visualização de schema

Alternativas Profissionais

DB Browser for SQLite

Ferramenta clássica, interface mais técnica

TablePlus

Interface premium, pago mas muito polido

DBeaver

Solução enterprise, suporte a todos os bancos

VS Code SQLite Extension

Integração direta no editor

Queries Essenciais

Queries SQL específicas para debugging de apps React Native. Use estas consultas para diagnosticar problemas comuns.

Análise de Schema e Performance

Informações do Banco

Listar todas as tabelas:

SELECT name FROM sqlite_master WHERE type='table';

Schema de uma tabela:

PRAGMA table_info(nome_da_tabela);

Tamanho do banco:

PRAGMA page_count; PRAGMA page_size;

Análise de Performance

Índices existentes:

SELECT * FROM sqlite_master WHERE type='index';

Estatísticas de tabela:

ANALYZE; SELECT * FROM sqlite_stat1;

Query plan:

EXPLAIN QUERY PLAN SELECT * FROM users WHERE id = 1;

Debugging de Aplicação

Autenticação & Sessão

Verificar login ativo:

SELECT 
  id, username, token, 
  datetime(last_login, 'unixepoch') as last_login_formatted
FROM users 
WHERE token IS NOT NULL 
  AND token != '';

Sessões expiradas:

SELECT 
  COUNT(*) as expired_sessions
FROM user_sessions 
WHERE expires_at < datetime('now');

Cache & Performance

Cache válido:

SELECT 
  key, 
  datetime(expires_at, 'unixepoch') as expires,
  length(data) as size_bytes
FROM cache 
WHERE expires_at > strftime('%s', 'now')
ORDER BY expires_at DESC;

Limpeza de cache:

DELETE FROM cache 
WHERE expires_at < strftime('%s', 'now');

Sincronização & Offline

Estado de Sincronização

Dados pendentes de sync:

SELECT 
  table_name,
  operation,
  COUNT(*) as pending_count,
  MIN(datetime(created_at, 'unixepoch')) as oldest_pending
FROM sync_queue 
WHERE status = 'pending'
GROUP BY table_name, operation;

Falhas de sincronização:

SELECT 
  id, table_name, operation, error_message,
  datetime(last_attempt, 'unixepoch') as last_attempt,
  retry_count
FROM sync_queue 
WHERE status = 'failed'
ORDER BY last_attempt DESC;

Dados Offline

Conteúdo offline disponível:

SELECT 
  content_type,
  COUNT(*) as items_count,
  SUM(length(data)) as total_size_bytes,
  MIN(datetime(downloaded_at, 'unixepoch')) as oldest_download
FROM offline_content 
GROUP BY content_type;

Limpeza de dados antigos:

DELETE FROM offline_content 
WHERE downloaded_at < strftime('%s', 'now', '-7 days')
  AND content_type = 'cache';

Troubleshooting Avançado

Soluções para problemas comuns que você pode encontrar ao debugar SQLite em React Native.

Problemas Comuns & Soluções

❌ "Database is locked"

Erro comum quando múltiplas conexões tentam escrever simultaneamente.

Diagnóstico:

PRAGMA locking_mode; PRAGMA journal_mode;

Solução:

PRAGMA journal_mode=WAL; -- Permite leituras concorrentes

❌ "No such table" em produção

Migrações não executadas ou banco não inicializado corretamente.

Verificar versão do schema:

PRAGMA user_version; -- Deve retornar versão atual

Listar migrações aplicadas:

SELECT * FROM migrations ORDER BY version;

❌ Performance degradada

Queries lentas, falta de índices ou fragmentação do banco.

Analisar queries lentas:

-- Habilitar profiling
PRAGMA compile_options;

-- Verificar uso de índices
EXPLAIN QUERY PLAN 
SELECT * FROM users WHERE email = 'test@example.com';

Otimizar banco:

VACUUM; ANALYZE; -- Desfragmenta e atualiza estatísticas

Monitoramento de Produção

Métricas Importantes

Tamanho do banco:

SELECT 
  (page_count * page_size) / 1024.0 / 1024.0 as size_mb
FROM (
  SELECT 
    (SELECT * FROM pragma_page_count()) as page_count,
    (SELECT * FROM pragma_page_size()) as page_size
);

Fragmentação:

SELECT 
  (freelist_count * 100.0 / page_count) as fragmentation_percent
FROM pragma_page_count(), pragma_freelist_count();

Health Check Script

-- Health check completo
SELECT 'Database Size' as metric, 
       ROUND((page_count * page_size) / 1024.0 / 1024.0, 2) || ' MB' as value
FROM pragma_page_count(), pragma_page_size()

UNION ALL

SELECT 'Fragmentation', 
       ROUND((freelist_count * 100.0 / page_count), 2) || '%'
FROM pragma_page_count(), pragma_freelist_count()

UNION ALL

SELECT 'Journal Mode', 
       (SELECT * FROM pragma_journal_mode())

UNION ALL

SELECT 'WAL Size', 
       CASE WHEN (SELECT * FROM pragma_wal_checkpoint()) IS NULL 
            THEN 'N/A' 
            ELSE 'OK' END;

Domine React Native Profissionalmente

Aprenda técnicas avançadas de desenvolvimento mobile com nossa formação especializada