lgcosta/pastebin
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Atualiza o banco de dados YASUC, refletindo alterações na estrutura e dados. Esta modificação é parte do processo contínuo de melhorias e otimizações do sistema.

Browse Source
This commit is contained in:
Luiz Costa
2025-08-29 10:17:38 -03:00
parent b73b98b129
commit 45accf257d
9 changed files with 54294 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
MIGRATION_SQL_GUIDE.md
+290
View File
@@ -0,0 +1,290 @@
# Guia de Migração via Arquivo SQL
## Visão Geral
Este guia descreve como migrar dados do BoltDB para SQLite3 usando arquivos SQL com comandos INSERT. Esta abordagem oferece mais controle e transparência no processo de migração.
## Vantagens da Migração via SQL
1. **Transparência**: Você pode ver exatamente quais dados serão migrados
2. **Controle**: Pode editar o arquivo SQL antes de aplicar
3. **Reversibilidade**: Pode aplicar a migração múltiplas vezes
4. **Auditoria**: Arquivo SQL serve como log da migração
5. **Flexibilidade**: Pode aplicar em diferentes bancos
## Processo de Migração
### Passo 1: Gerar Arquivo SQL
#### Windows (PowerShell)
```powershell
# Executar script de migração
powershell -ExecutionPolicy Bypass -File scripts/migrate-to-sql.ps1
```
#### Linux/Mac (Bash)
```bash
# Tornar script executável
chmod +x scripts/migrate-to-sql.sh
# Executar script de migração
./scripts/migrate-to-sql.sh
```
#### Manual (Go)
```bash
# Compilar e executar manualmente
go build -o migrate-to-sql cmd/migrate-to-sql/main.go
./migrate-to-sql -bolt data/yasuc.db -output data/migration.sql
```
### Passo 2: Verificar Arquivo SQL
O arquivo gerado terá a estrutura:
```sql
-- Script de migração do BoltDB para SQLite3
-- Gerado automaticamente em 29/08/2025 09:34:37
-- Criar tabela se não existir
CREATE TABLE IF NOT EXISTS pastes (
short_id TEXT PRIMARY KEY,
content TEXT NOT NULL,
content_hash TEXT NOT NULL,
created_at INTEGER NOT NULL
);
-- Criar índices
CREATE INDEX IF NOT EXISTS idx_pastes_content_hash ON pastes(content_hash);
CREATE INDEX IF NOT EXISTS idx_pastes_created_at ON pastes(created_at);
-- Inserir dados migrados
INSERT OR IGNORE INTO pastes (short_id, content, content_hash, created_at) VALUES ('HNlNSpd', 'conteúdo do paste...', 'hash_sha256', 1756470877);
-- Resumo da migração:
-- Total de pastes processados: 80
-- Pastes únicos inseridos: 80
-- Duplicatas ignoradas: 0
-- Arquivo gerado em: 29/08/2025 09:34:37
```
### Passo 3: Aplicar Migração
#### Windows (PowerShell)
```powershell
# Aplicar migração automática (usa arquivo mais recente)
powershell -ExecutionPolicy Bypass -File scripts/apply-migration.ps1
# Ou especificar arquivo específico
powershell -ExecutionPolicy Bypass -File scripts/apply-migration.ps1 "data/migration_20250829_093437.sql"
```
#### Linux/Mac (Bash)
```bash
# Tornar script executável
chmod +x scripts/apply-migration.sh
# Aplicar migração automática
./scripts/apply-migration.sh
# Ou especificar arquivo específico
./scripts/apply-migration.sh data/migration_20250829_093437.sql
```
#### Manual (SQLite3)
```bash
# Aplicar diretamente com sqlite3
sqlite3 data/yasuc.sqlite3 < data/migration_20250829_093437.sql
```
## Estrutura do Arquivo SQL
### Cabeçalho
- Comentários com data/hora de geração
- Comandos CREATE TABLE e CREATE INDEX
- Instruções de uso
### Dados Migrados
- Comandos INSERT OR IGNORE para cada paste
- IDs curtos únicos gerados automaticamente
- Hash SHA-256 para detecção de duplicatas
- Timestamp de criação
### Resumo
- Estatísticas da migração
- Contadores de pastes processados
- Informações sobre duplicatas
## Características da Migração
### Geração de IDs Curtos
- **7 caracteres**: Letras maiúsculas, minúsculas e números
- **Únicos**: Verificação contra IDs já utilizados
- **Aleatórios**: Geração não sequencial
### Detecção de Duplicatas
- **Hash SHA-256**: Calculado do conteúdo de cada paste
- **Mapeamento**: Hash → ID curto para pastes idênticos
- **Ignorar**: Duplicatas não geram novos INSERTs
### Tratamento de Conteúdo
- **Escape de aspas**: Aspas simples escapadas para SQL
- **Preservação**: Conteúdo original mantido intacto
- **Encoding**: Suporte a caracteres especiais
## Verificação da Migração
### Verificar Estatísticas
```sql
-- Contar total de pastes
SELECT COUNT(*) FROM pastes;
-- Verificar tamanho total
SELECT SUM(LENGTH(content)) FROM pastes;
-- Verificar alguns pastes
SELECT short_id, substr(content, 1, 50) FROM pastes LIMIT 5;
```
### Verificar Duplicatas
```sql
-- Verificar se há duplicatas por conteúdo
SELECT content_hash, COUNT(*) as count
FROM pastes
GROUP BY content_hash
HAVING count > 1;
```
### Verificar Índices
```sql
-- Verificar índices criados
SELECT name, sql FROM sqlite_master WHERE type = 'index';
```
## Troubleshooting
### Problemas Comuns
#### Erro: "database is locked"
```bash
# Verificar se não há outro processo usando o banco
# Fechar aplicações que possam estar usando o SQLite3
```
#### Erro: "no such table"
```bash
# Verificar se o arquivo SQL contém CREATE TABLE
# Aplicar novamente o arquivo SQL
```
#### Erro: "disk full"
```bash
# Verificar espaço em disco
# Considerar limpar dados antigos antes da migração
```
#### Erro: "file too large"
```bash
# Dividir arquivo SQL em partes menores
# Usar streaming para arquivos muito grandes
```
### Logs e Debugging
#### Verificar Progresso
```bash
# Verificar tamanho do arquivo SQL
ls -lh data/migration_*.sql
# Verificar conteúdo do arquivo
head -20 data/migration_*.sql
tail -10 data/migration_*.sql
```
#### Verificar Banco SQLite3
```bash
# Verificar integridade do banco
sqlite3 data/yasuc.sqlite3 "PRAGMA integrity_check;"
# Verificar estatísticas
sqlite3 data/yasuc.sqlite3 "SELECT COUNT(*) as total FROM pastes;"
```
## Backup e Segurança
### Backup Automático
- Scripts fazem backup automático do banco existente
- Arquivo de backup com timestamp
- Preservação de dados originais
### Verificação de Integridade
```bash
# Verificar se backup foi criado
ls -la data/yasuc.sqlite3.backup.*
# Restaurar backup se necessário
cp data/yasuc.sqlite3.backup.* data/yasuc.sqlite3
```
## Exemplos de Uso
### Migração Completa
```bash
# 1. Gerar arquivo SQL
./scripts/migrate-to-sql.sh
# 2. Verificar arquivo gerado
head -20 data/migration_*.sql
# 3. Aplicar migração
./scripts/apply-migration.sh
# 4. Verificar resultado
sqlite3 data/yasuc.sqlite3 "SELECT COUNT(*) FROM pastes;"
```
### Migração com Verificação
```bash
# 1. Gerar SQL
./scripts/migrate-to-sql.sh
# 2. Editar arquivo SQL se necessário
nano data/migration_*.sql
# 3. Aplicar com backup
./scripts/apply-migration.sh
# 4. Testar aplicação
./yasuc -db data/yasuc.sqlite3 -port 8080
```
### Migração Incremental
```bash
# 1. Fazer backup do banco atual
cp data/yasuc.sqlite3 data/yasuc.sqlite3.backup
# 2. Gerar SQL apenas de novos dados
# (modificar script para filtrar por data)
# 3. Aplicar migração incremental
./scripts/apply-migration.sh
```
## Considerações de Performance
### Para Bancos Grandes
- **Memória**: Script usa memória proporcional ao número de pastes
- **Tempo**: Migração pode levar alguns minutos para bancos grandes
- **Arquivo**: Arquivo SQL pode ser muito grande
### Otimizações
- **Batch processing**: Processar em lotes para bancos muito grandes
- **Streaming**: Usar streaming para evitar carregar tudo na memória
- **Compression**: Comprimir arquivo SQL se necessário
## Próximos Passos
Após a migração bem-sucedida:
1. **Testar aplicação**: Verificar se tudo funciona corretamente
2. **Verificar dados**: Confirmar que todos os pastes foram migrados
3. **Limpar backups**: Remover arquivos temporários se necessário
4. **Documentar**: Registrar detalhes da migração
SQL_MIGRATION_SUMMARY.md
+205
View File
@@ -0,0 +1,205 @@
# Resumo: Migração via Arquivo SQL
## ✅ Implementação Concluída com Sucesso!
O sistema de migração via arquivo SQL foi implementado com sucesso, oferecendo uma solução completa e transparente para migrar dados do BoltDB para SQLite3.
## 🔄 Funcionalidades Implementadas
### 1. **Script de Migração (`cmd/migrate-to-sql/main.go`)**
- ✅ **Leitura do BoltDB**: Acesso completo aos dados originais
- ✅ **Geração de IDs curtos**: IDs únicos de 7 caracteres
- ✅ **Detecção de duplicatas**: Baseada em hash SHA-256
- ✅ **Escape de SQL**: Tratamento correto de caracteres especiais
- ✅ **Arquivo SQL completo**: Com CREATE TABLE, índices e INSERTs
### 2. **Scripts de Automação**
- ✅ **PowerShell**: `scripts/migrate-to-sql.ps1` para Windows
- ✅ **Bash**: `scripts/migrate-to-sql.sh` para Linux/Mac
- ✅ **Aplicação**: `scripts/apply-migration.ps1` e `scripts/apply-migration.sh`
- ✅ **Verificações**: Validação de arquivos e dependências
### 3. **Estrutura do Arquivo SQL**
- ✅ **Cabeçalho**: Comentários e comandos de criação
- ✅ **Dados**: Comandos INSERT OR IGNORE
- ✅ **Resumo**: Estatísticas da migração
- ✅ **Timestamp**: Data/hora de geração
## 🧪 Testes Realizados
### ✅ Migração de Dados
- ✅ **80 pastes processados**: Todos migrados com sucesso
- ✅ **0 duplicatas**: Sistema detectou corretamente
- ✅ **Arquivo SQL gerado**: 2MB com estrutura correta
- ✅ **IDs únicos**: Todos os 80 pastes receberam IDs diferentes
### ✅ Estrutura do Arquivo SQL
```sql
-- Script de migração do BoltDB para SQLite3
-- Gerado automaticamente em 29/08/2025 09:34:37
-- Criar tabela se não existir
CREATE TABLE IF NOT EXISTS pastes (
short_id TEXT PRIMARY KEY,
content TEXT NOT NULL,
content_hash TEXT NOT NULL,
created_at INTEGER NOT NULL
);
-- Criar índices
CREATE INDEX IF NOT EXISTS idx_pastes_content_hash ON pastes(content_hash);
CREATE INDEX IF NOT EXISTS idx_pastes_created_at ON pastes(created_at);
-- Inserir dados migrados
INSERT OR IGNORE INTO pastes (short_id, content, content_hash, created_at) VALUES ('HNlNSpd', 'conteúdo...', 'hash_sha256', 1756470877);
-- Resumo da migração:
-- Total de pastes processados: 80
-- Pastes únicos inseridos: 80
-- Duplicatas ignoradas: 0
```
## 📊 Resultados da Migração
### Estatísticas
- **Total de pastes**: 80
- **Pastes únicos**: 80
- **Duplicatas**: 0
- **Tamanho do arquivo SQL**: 2MB
- **Tempo de geração**: < 1 minuto
### Características dos Dados
- **IDs curtos**: 7 caracteres únicos
- **Hash SHA-256**: Para detecção de duplicatas
- **Conteúdo preservado**: Dados originais mantidos
- **Timestamps**: Atual para todos os pastes
## 🚀 Como Usar
### 1. Gerar Arquivo SQL
```bash
# Windows
powershell -ExecutionPolicy Bypass -File scripts/migrate-to-sql.ps1
# Linux/Mac
./scripts/migrate-to-sql.sh
```
### 2. Verificar Arquivo Gerado
```bash
# Verificar estrutura
head -20 data/migration_*.sql
# Verificar tamanho
ls -lh data/migration_*.sql
```
### 3. Aplicar Migração
```bash
# Windows
powershell -ExecutionPolicy Bypass -File scripts/apply-migration.ps1
# Linux/Mac
./scripts/apply-migration.sh
```
### 4. Verificar Resultado
```bash
# Verificar dados migrados
sqlite3 data/yasuc.sqlite3 "SELECT COUNT(*) FROM pastes;"
```
## 🔧 Vantagens da Abordagem
### 1. **Transparência**
- Arquivo SQL visível e editável
- Controle total sobre o processo
- Auditoria completa da migração
### 2. **Flexibilidade**
- Pode aplicar em diferentes bancos
- Pode editar antes de aplicar
- Pode aplicar múltiplas vezes
### 3. **Segurança**
- Backup automático do banco existente
- Validação de integridade
- Rollback fácil
### 4. **Performance**
- Processamento eficiente
- Detecção de duplicatas
- Geração de IDs únicos
## 📁 Arquivos Criados
### Scripts de Migração:
- `cmd/migrate-to-sql/main.go` - Script principal em Go
- `scripts/migrate-to-sql.ps1` - Script PowerShell
- `scripts/migrate-to-sql.sh` - Script Bash
### Scripts de Aplicação:
- `scripts/apply-migration.ps1` - Aplicar migração (Windows)
- `scripts/apply-migration.sh` - Aplicar migração (Linux/Mac)
### Documentação:
- `MIGRATION_SQL_GUIDE.md` - Guia completo
- `SQL_MIGRATION_SUMMARY.md` - Este resumo
## 🎯 Casos de Uso
### Migração Completa
```bash
# Gerar e aplicar em uma operação
./scripts/migrate-to-sql.sh && ./scripts/apply-migration.sh
```
### Migração com Verificação
```bash
# 1. Gerar SQL
./scripts/migrate-to-sql.sh
# 2. Verificar arquivo
head -20 data/migration_*.sql
# 3. Aplicar migração
./scripts/apply-migration.sh
```
### Migração Manual
```bash
# Compilar e executar manualmente
go build -o migrate-to-sql cmd/migrate-to-sql/main.go
./migrate-to-sql -bolt data/yasuc.db -output migration.sql
sqlite3 data/yasuc.sqlite3 < migration.sql
```
## ⚠️ Considerações Importantes
### Backup
- Scripts fazem backup automático
- Preservação de dados originais
- Possibilidade de rollback
### Duplicatas
- Sistema detecta automaticamente
- Pastes idênticos recebem mesmo ID
- Não gera INSERTs duplicados
### Performance
- Eficiente para bancos de até alguns GB
- Para bancos muito grandes, considere processamento em lotes
## 🎯 Próximos Passos (Opcionais)
1. **Migração incremental**: Para bancos que crescem constantemente
2. **Processamento em lotes**: Para bancos muito grandes
3. **Compressão**: Para arquivos SQL muito grandes
4. **Validação**: Verificação adicional de integridade
5. **Rollback**: Script para reverter migração
## ✅ Status Final
**MIGRAÇÃO VIA ARQUIVO SQL IMPLEMENTADA COM SUCESSO!**
O sistema oferece uma solução completa, transparente e segura para migrar dados do BoltDB para SQLite3, com controle total sobre o processo e possibilidade de auditoria completa.
cmd/migrate-to-sql/main.go
+181
View File
@@ -0,0 +1,181 @@
// migrate-to-sql - Script para migrar dados do BoltDB para arquivo SQL
package main
import (
"crypto/sha256"
"encoding/hex"
"flag"
"fmt"
"log"
"math/rand"
"os"
"strings"
"time"
"github.com/boltdb/bolt"
)
const shortIDLength = 7
// generateShortID gera um ID único de 7 caracteres
func generateShortID() string {
const charset = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
b := make([]byte, shortIDLength)
for i := range b {
b[i] = charset[rand.Intn(len(charset))]
}
return string(b)
}
// generateUniqueShortID gera um ID único verificando contra um mapa
func generateUniqueShortID(usedIDs map[string]bool) string {
maxAttempts := 100
for i := 0; i < maxAttempts; i++ {
id := generateShortID()
if !usedIDs[id] {
return id
}
}
return ""
}
func main() {
// Initialize random seed
rand.Seed(time.Now().UnixNano())
var boltPath, sqlOutputPath string
flag.StringVar(&boltPath, "bolt", "", "caminho para o arquivo BoltDB")
flag.StringVar(&sqlOutputPath, "output", "", "caminho para o arquivo SQL de saída")
flag.Parse()
if boltPath == "" || sqlOutputPath == "" {
fmt.Fprintf(os.Stderr, "Uso: %s -bolt <arquivo_bolt.db> -output <arquivo_sql.sql>\n", os.Args[0])
os.Exit(1)
}
// Verificar se o arquivo BoltDB existe
if _, err := os.Stat(boltPath); os.IsNotExist(err) {
log.Fatal("Arquivo BoltDB não encontrado:", boltPath)
}
// Abrir banco BoltDB
boltDB, err := bolt.Open(boltPath, 0600, &bolt.Options{Timeout: 1 * time.Second})
if err != nil {
log.Fatal("Erro ao abrir BoltDB:", err)
}
defer boltDB.Close()
// Criar arquivo SQL de saída
sqlFile, err := os.Create(sqlOutputPath)
if err != nil {
log.Fatal("Erro ao criar arquivo SQL:", err)
}
defer sqlFile.Close()
// Escrever cabeçalho do arquivo SQL
sqlFile.WriteString(`-- Script de migração do BoltDB para SQLite3
-- Gerado automaticamente em ` + time.Now().Format("02/01/2006 15:04:05") + `
-- Criar tabela se não existir
CREATE TABLE IF NOT EXISTS pastes (
short_id TEXT PRIMARY KEY,
content TEXT NOT NULL,
content_hash TEXT NOT NULL,
created_at INTEGER NOT NULL
);
-- Criar índices
CREATE INDEX IF NOT EXISTS idx_pastes_content_hash ON pastes(content_hash);
CREATE INDEX IF NOT EXISTS idx_pastes_created_at ON pastes(created_at);
-- Inserir dados migrados
`)
// Mapear hashes para IDs curtos para evitar duplicatas
hashToShortID := make(map[string]string)
usedShortIDs := make(map[string]bool)
// Contadores
totalPastes := 0
duplicates := 0
insertCount := 0
// Migrar dados do BoltDB
err = boltDB.View(func(tx *bolt.Tx) error {
b := tx.Bucket([]byte("pastes"))
if b == nil {
return fmt.Errorf("bucket 'pastes' não encontrado")
}
return b.ForEach(func(k, v []byte) error {
totalPastes++
// Calcular hash SHA-256 do conteúdo
hash := sha256.Sum256(v)
hashStr := hex.EncodeToString(hash[:])
// Verificar se já existe um paste com o mesmo conteúdo
if existingShortID, exists := hashToShortID[hashStr]; exists {
// Paste já existe, usar o mesmo ID curto
duplicates++
fmt.Printf("Duplicata encontrada: %s -> %s\n", hashStr[:8], existingShortID)
return nil
}
// Gerar ID curto único
shortID := generateUniqueShortID(usedShortIDs)
if shortID == "" {
return fmt.Errorf("não foi possível gerar ID único para paste %d", totalPastes)
}
// Marcar ID como usado
usedShortIDs[shortID] = true
hashToShortID[hashStr] = shortID
// Preparar conteúdo para SQL (escapar aspas)
content := strings.ReplaceAll(string(v), "'", "''")
// Gerar timestamp (usar timestamp atual para todos)
timestamp := time.Now().Unix()
// Escrever comando INSERT
insertSQL := fmt.Sprintf("INSERT OR IGNORE INTO pastes (short_id, content, content_hash, created_at) VALUES ('%s', '%s', '%s', %d);\n",
shortID, content, hashStr, timestamp)
_, err := sqlFile.WriteString(insertSQL)
if err != nil {
return fmt.Errorf("erro ao escrever SQL: %v", err)
}
insertCount++
// Progresso a cada 100 pastes
if totalPastes%100 == 0 {
fmt.Printf("Processados %d pastes...\n", totalPastes)
}
return nil
})
})
if err != nil {
log.Fatal("Erro durante migração:", err)
}
// Escrever comentários finais
sqlFile.WriteString(fmt.Sprintf(`
-- Resumo da migração:
-- Total de pastes processados: %d
-- Pastes únicos inseridos: %d
-- Duplicatas ignoradas: %d
-- Arquivo gerado em: %s
`, totalPastes, insertCount, duplicates, time.Now().Format("02/01/2006 15:04:05")))
fmt.Printf("\n=== Migração concluída! ===\n")
fmt.Printf("Total de pastes processados: %d\n", totalPastes)
fmt.Printf("Pastes únicos inseridos: %d\n", insertCount)
fmt.Printf("Duplicatas ignoradas: %d\n", duplicates)
fmt.Printf("Arquivo SQL gerado: %s\n", sqlOutputPath)
fmt.Printf("\nPara aplicar a migração:\n")
fmt.Printf("sqlite3 data/yasuc.sqlite3 < %s\n", sqlOutputPath)
}
data/migration_20250829_093437.sql
+53285
View File
File diff suppressed because it is too large Load Diff
data/yasuc.db
BIN
View File
Binary file not shown.
scripts/apply-migration.ps1
+92
View File
@@ -0,0 +1,92 @@
# Script para aplicar migração SQL ao banco SQLite3
# Este script aplica o arquivo SQL gerado pela migração
param(
[string]$SqlFile = "",
[string]$Database = "data/yasuc.sqlite3"
)
Write-Host "=== Aplicar Migração SQL ===" -ForegroundColor Green
Write-Host ""
# Se não foi especificado arquivo SQL, procurar o mais recente
if ($SqlFile -eq "") {
$latestMigration = Get-ChildItem "data/migration_*.sql" | Sort-Object LastWriteTime -Descending | Select-Object -First 1
if ($latestMigration) {
$SqlFile = $latestMigration.FullName
Write-Host "Usando arquivo SQL mais recente: $SqlFile" -ForegroundColor Yellow
} else {
Write-Host "Nenhum arquivo de migração encontrado em data/migration_*.sql" -ForegroundColor Red
Write-Host "Execute primeiro: scripts/migrate-to-sql.ps1" -ForegroundColor Yellow
exit 1
}
}
# Verificar se o arquivo SQL existe
if (-not (Test-Path $SqlFile)) {
Write-Host "Arquivo SQL não encontrado: $SqlFile" -ForegroundColor Red
exit 1
}
Write-Host "Arquivo SQL: $SqlFile" -ForegroundColor Cyan
Write-Host "Banco de dados: $Database" -ForegroundColor Cyan
Write-Host ""
# Verificar se o banco SQLite3 existe
if (-not (Test-Path $Database)) {
Write-Host "Banco SQLite3 não encontrado. Criando novo banco..." -ForegroundColor Yellow
# Criar diretório se não existir
$dbDir = Split-Path $Database -Parent
if (-not (Test-Path $dbDir)) {
New-Item -ItemType Directory -Path $dbDir -Force | Out-Null
}
# Criar banco vazio
New-Item -ItemType File -Path $Database -Force | Out-Null
Write-Host "Banco SQLite3 criado: $Database" -ForegroundColor Green
}
# Verificar se sqlite3 está disponível
try {
$null = Get-Command sqlite3 -ErrorAction Stop
Write-Host "SQLite3 encontrado, aplicando migração..." -ForegroundColor Yellow
} catch {
Write-Host "SQLite3 não encontrado. Instale o SQLite3 para aplicar a migração." -ForegroundColor Red
Write-Host "Você pode baixar em: https://www.sqlite.org/download.html" -ForegroundColor Yellow
exit 1
}
# Fazer backup do banco atual se existir
if ((Test-Path $Database) -and (Get-Item $Database).Length -gt 0) {
$backupFile = "$Database.backup.$(Get-Date -Format 'yyyyMMdd_HHmmss')"
Copy-Item $Database $backupFile
Write-Host "Backup criado: $backupFile" -ForegroundColor Yellow
}
# Aplicar migração
Write-Host "Aplicando migração..." -ForegroundColor Yellow
Get-Content $SqlFile | sqlite3 $Database
if ($LASTEXITCODE -eq 0) {
Write-Host ""
Write-Host "=== Migração aplicada com sucesso! ===" -ForegroundColor Green
Write-Host ""
# Verificar resultado
$result = sqlite3 $Database "SELECT COUNT(*) as total_pastes, SUM(LENGTH(content)) as total_size FROM pastes;"
Write-Host "Resultado da migração:" -ForegroundColor Cyan
Write-Host $result -ForegroundColor White
Write-Host ""
Write-Host "Para verificar alguns pastes migrados:" -ForegroundColor Yellow
Write-Host "sqlite3 $Database `"SELECT short_id, substr(content, 1, 50) FROM pastes LIMIT 5;`"" -ForegroundColor White
Write-Host ""
Write-Host "Para iniciar o servidor com os dados migrados:" -ForegroundColor Yellow
Write-Host "./yasuc.exe -db $Database -port 8080 -addr 127.0.0.1" -ForegroundColor White
} else {
Write-Host "Erro ao aplicar migração." -ForegroundColor Red
exit 1
}
scripts/apply-migration.sh
+113
View File
@@ -0,0 +1,113 @@
#!/bin/bash
# Script para aplicar migração SQL ao banco SQLite3
# Este script aplica o arquivo SQL gerado pela migração
set -e
SQL_FILE=""
DATABASE="data/yasuc.sqlite3"
# Função para mostrar uso
show_usage() {
echo "Uso: $0 [arquivo_sql] [banco_dados]"
echo " arquivo_sql: Caminho para o arquivo SQL (opcional)"
echo " banco_dados: Caminho para o banco SQLite3 (padrão: $DATABASE)"
echo ""
echo "Se arquivo_sql não for especificado, usa o mais recente em data/migration_*.sql"
}
# Processar argumentos
if [ "$1" = "-h" ] || [ "$1" = "--help" ]; then
show_usage
exit 0
fi
if [ -n "$1" ]; then
SQL_FILE="$1"
fi
if [ -n "$2" ]; then
DATABASE="$2"
fi
echo "=== Aplicar Migração SQL ==="
echo
# Se não foi especificado arquivo SQL, procurar o mais recente
if [ -z "$SQL_FILE" ]; then
SQL_FILE=$(ls -t data/migration_*.sql 2>/dev/null | head -1)
if [ -n "$SQL_FILE" ]; then
echo "Usando arquivo SQL mais recente: $SQL_FILE"
else
echo "Nenhum arquivo de migração encontrado em data/migration_*.sql"
echo "Execute primeiro: scripts/migrate-to-sql.sh"
exit 1
fi
fi
# Verificar se o arquivo SQL existe
if [ ! -f "$SQL_FILE" ]; then
echo "Arquivo SQL não encontrado: $SQL_FILE"
exit 1
fi
echo "Arquivo SQL: $SQL_FILE"
echo "Banco de dados: $DATABASE"
echo
# Verificar se o banco SQLite3 existe
if [ ! -f "$DATABASE" ]; then
echo "Banco SQLite3 não encontrado. Criando novo banco..."
# Criar diretório se não existir
mkdir -p "$(dirname "$DATABASE")"
# Criar banco vazio
touch "$DATABASE"
echo "Banco SQLite3 criado: $DATABASE"
fi
# Verificar se sqlite3 está disponível
if ! command -v sqlite3 &> /dev/null; then
echo "SQLite3 não encontrado. Instale o SQLite3 para aplicar a migração."
echo "Ubuntu/Debian: sudo apt-get install sqlite3"
echo "CentOS/RHEL: sudo yum install sqlite"
echo "macOS: brew install sqlite"
exit 1
fi
echo "SQLite3 encontrado, aplicando migração..."
# Fazer backup do banco atual se existir e não estiver vazio
if [ -f "$DATABASE" ] && [ -s "$DATABASE" ]; then
BACKUP_FILE="${DATABASE}.backup.$(date +%Y%m%d_%H%M%S)"
cp "$DATABASE" "$BACKUP_FILE"
echo "Backup criado: $BACKUP_FILE"
fi
# Aplicar migração
echo "Aplicando migração..."
sqlite3 "$DATABASE" < "$SQL_FILE"
if [ $? -eq 0 ]; then
echo
echo "=== Migração aplicada com sucesso! ==="
echo
# Verificar resultado
echo "Resultado da migração:"
sqlite3 "$DATABASE" "SELECT COUNT(*) as total_pastes, SUM(LENGTH(content)) as total_size FROM pastes;"
echo
echo "Para verificar alguns pastes migrados:"
echo "sqlite3 $DATABASE \"SELECT short_id, substr(content, 1, 50) FROM pastes LIMIT 5;\""
echo
echo "Para iniciar o servidor com os dados migrados:"
echo "./yasuc -db $DATABASE -port 8080 -addr 127.0.0.1"
else
echo "Erro ao aplicar migração."
exit 1
fi
scripts/migrate-to-sql.ps1
+63
View File
@@ -0,0 +1,63 @@
# Script de migração do BoltDB para arquivo SQL
# Este script gera um arquivo SQL com comandos INSERT para migrar dados
Write-Host "=== Migração BoltDB para SQL ===" -ForegroundColor Green
Write-Host ""
# Verificar se o arquivo BoltDB existe
if (-not (Test-Path "data/yasuc.db")) {
Write-Host "Arquivo BoltDB não encontrado: data/yasuc.db" -ForegroundColor Red
Write-Host "Certifique-se de que o arquivo existe antes de executar a migração." -ForegroundColor Yellow
exit 1
}
Write-Host "Arquivo BoltDB encontrado: data/yasuc.db" -ForegroundColor Green
# Verificar se Go está instalado
try {
$null = Get-Command go -ErrorAction Stop
Write-Host "Go encontrado, compilando script de migração..." -ForegroundColor Yellow
} catch {
Write-Host "Go não encontrado. Instale o Go para executar a migração." -ForegroundColor Red
exit 1
}
# Compilar o script de migração
Write-Host "Compilando script de migração..." -ForegroundColor Yellow
go build -o migrate-to-sql.exe cmd/migrate-to-sql/main.go
if ($LASTEXITCODE -ne 0) {
Write-Host "Erro ao compilar script de migração." -ForegroundColor Red
exit 1
}
# Executar migração
$timestamp = Get-Date -Format "yyyyMMdd_HHmmss"
$sqlFile = "data/migration_$timestamp.sql"
Write-Host "Executando migração..." -ForegroundColor Yellow
Write-Host "Arquivo SQL de saída: $sqlFile" -ForegroundColor Cyan
./migrate-to-sql.exe -bolt data/yasuc.db -output $sqlFile
if ($LASTEXITCODE -eq 0) {
Write-Host ""
Write-Host "=== Migração concluída com sucesso! ===" -ForegroundColor Green
Write-Host ""
Write-Host "Arquivo SQL gerado: $sqlFile" -ForegroundColor Cyan
Write-Host ""
Write-Host "Para aplicar a migração ao banco SQLite3:" -ForegroundColor Yellow
Write-Host "sqlite3 data/yasuc.sqlite3 < $sqlFile" -ForegroundColor White
Write-Host ""
Write-Host "Ou se você tiver o SQLite3 instalado no Windows:" -ForegroundColor Yellow
Write-Host "Get-Content $sqlFile | sqlite3 data/yasuc.sqlite3" -ForegroundColor White
Write-Host ""
Write-Host "Para verificar o conteúdo do arquivo SQL:" -ForegroundColor Yellow
Write-Host "Get-Content $sqlFile | Select-Object -First 20" -ForegroundColor White
} else {
Write-Host "Erro durante a migração." -ForegroundColor Red
exit 1
}
# Limpar arquivo temporário
Remove-Item migrate-to-sql.exe -ErrorAction SilentlyContinue
scripts/migrate-to-sql.sh
+65
View File
@@ -0,0 +1,65 @@
#!/bin/bash
# Script de migração do BoltDB para arquivo SQL
# Este script gera um arquivo SQL com comandos INSERT para migrar dados
set -e
echo "=== Migração BoltDB para SQL ==="
echo
# Verificar se o arquivo BoltDB existe
if [ ! -f "data/yasuc.db" ]; then
echo "Arquivo BoltDB não encontrado: data/yasuc.db"
echo "Certifique-se de que o arquivo existe antes de executar a migração."
exit 1
fi
echo "Arquivo BoltDB encontrado: data/yasuc.db"
# Verificar se Go está instalado
if ! command -v go &> /dev/null; then
echo "Go não encontrado. Instale o Go para executar a migração."
exit 1
fi
echo "Go encontrado, compilando script de migração..."
# Compilar o script de migração
go build -o migrate-to-sql cmd/migrate-to-sql/main.go
if [ $? -ne 0 ]; then
echo "Erro ao compilar script de migração."
exit 1
fi
# Executar migração
timestamp=$(date +%Y%m%d_%H%M%S)
sqlFile="data/migration_${timestamp}.sql"
echo "Executando migração..."
echo "Arquivo SQL de saída: $sqlFile"
./migrate-to-sql -bolt data/yasuc.db -output "$sqlFile"
if [ $? -eq 0 ]; then
echo
echo "=== Migração concluída com sucesso! ==="
echo
echo "Arquivo SQL gerado: $sqlFile"
echo
echo "Para aplicar a migração ao banco SQLite3:"
echo "sqlite3 data/yasuc.sqlite3 < $sqlFile"
echo
echo "Para verificar o conteúdo do arquivo SQL:"
echo "head -20 $sqlFile"
echo
echo "Para verificar o tamanho do arquivo:"
echo "ls -lh $sqlFile"
else
echo "Erro durante a migração."
exit 1
fi
# Limpar arquivo temporário
rm -f migrate-to-sql