dbbridgekit 0.1.0__py3-none-any.whl

dbbridge/migration/data_migration.py

@@ -0,0 +1,76 @@
+"""Migração de DADOS: copia linhas de uma conexão origem pra uma conexão destino, tabela por tabela,
+em lotes. Não infere schema aqui — recebe a lista de tabelas (normalmente as mesmas que
+`schema_migration.py` acabou de criar no destino) e usa introspecção simples via SQL padrão
+(SELECT * FROM tabela) pra descobrir as colunas de cada lado.
+
+Nunca faz DROP/TRUNCATE sozinho — se a tabela destino já tem linha, ver `on_conflict` (default:
+'append', nunca sobrescreve sem pedir)."""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass
+class TableMigrationResult:
+    table: str
+    rows_copied: int
+    source_count: int
+    target_count: int
+
+    @property
+    def counts_match(self) -> bool:
+        return self.source_count == self.target_count
+
+
+@dataclass
+class DataMigrationResult:
+    tables: list[TableMigrationResult] = field(default_factory=list)
+
+    @property
+    def total_rows(self) -> int:
+        return sum(t.rows_copied for t in self.tables)
+
+    @property
+    def all_counts_match(self) -> bool:
+        return all(t.counts_match for t in self.tables)
+
+
+def _table_columns(connection, table: str) -> list[str]:
+    """Introspecção genérica via SELECT com LIMIT 0 — funciona em qualquer dialeto que devolva
+    `cursor.description` (sqlite3 e psycopg fazem), sem precisar de PRAGMA/information_schema
+    específico de dialeto pra esta finalidade pontual."""
+    cur = connection.execute(f"SELECT * FROM {table} WHERE 1=0")
+    return [d[0] if not hasattr(d, "name") else d.name for d in cur.description]
+
+
+def migrate_table_data(source_connection, target_connection, table: str, batch_size: int = 500) -> TableMigrationResult:
+    columns = _table_columns(source_connection, table)
+    col_list = ",".join(columns)
+    placeholders = ",".join(["?"] * len(columns))
+
+    cur = source_connection.execute(f"SELECT {col_list} FROM {table}")
+    copied = 0
+    while True:
+        rows = cur.fetchmany(batch_size) if hasattr(cur, "fetchmany") else cur.fetchall()
+        if not rows:
+            break
+        for row in rows:
+            values = tuple(row[c] if hasattr(row, "keys") else row[i] for i, c in enumerate(columns))
+            target_connection.execute(f"INSERT INTO {table}({col_list}) VALUES({placeholders})", values)
+            copied += 1
+        if not hasattr(cur, "fetchmany"):
+            break
+    if hasattr(target_connection, "commit"):
+        target_connection.commit()
+
+    source_count = source_connection.execute(f"SELECT COUNT(*) FROM {table}").fetchone()[0]
+    target_count = target_connection.execute(f"SELECT COUNT(*) FROM {table}").fetchone()[0]
+
+    return TableMigrationResult(table=table, rows_copied=copied, source_count=source_count, target_count=target_count)
+
+
+def migrate_data(source_connection, target_connection, tables: list[str], batch_size: int = 500) -> DataMigrationResult:
+    result = DataMigrationResult()
+    for table in tables:
+        result.tables.append(migrate_table_data(source_connection, target_connection, table, batch_size))
+    return result

dbbridge/migration/rollback.py

@@ -0,0 +1,57 @@
+"""Rollback: desfaz mudanças de CÓDIGO aplicadas pelo codemod (via backup automático — ver
+codemod/codemod.py, que já salva uma cópia de cada arquivo ANTES de escrever). Rollback de DADOS/
+SCHEMA é dialeto-específico de propósito — a forma correta de reverter um schema/dado já migrado é
+restaurar o backup do BANCO ORIGEM (nunca tentar "desfazer" writes já commitados no destino via SQL
+reverso, que é frágil e pode mascarar erro). Ver README.md pra orientação de backup do banco antes
+de qualquer `migrate-data`.
+"""
+from __future__ import annotations
+
+from collections import defaultdict
+from pathlib import Path
+
+
+def rollback_code_changes(project_root: Path, backup_dir: Path | None = None) -> int:
+    """Restaura cada arquivo Python a partir do backup MAIS ANTIGO salvo em `backup_dir` (o estado
+    de antes da primeira mudança aplicada nesta sessão de codemod) — mesma lógica e mesmo diretório
+    que `codemod.apply_changes()` já usa pra criar os backups."""
+    import shutil
+
+    backup_dir = backup_dir or (Path(project_root) / ".dbbridge_backups")
+    if not backup_dir.exists():
+        return 0
+
+    by_original: dict[str, list[Path]] = defaultdict(list)
+    for backup in backup_dir.glob("*.bak"):
+        original_name = backup.name.split(".")[0] + ".py"
+        by_original[original_name].append(backup)
+
+    restored = 0
+    for original_name, backups in by_original.items():
+        oldest = sorted(backups, key=lambda p: p.stat().st_mtime)[0]
+        matches = list(Path(project_root).rglob(original_name))
+        if matches:
+            shutil.copy2(oldest, matches[0])
+            restored += 1
+    return restored
+
+
+class DatabaseSnapshot:
+    """Ponto de extensão pra rollback de BANCO — deliberadamente sem implementação concreta de
+    dialeto aqui (backup de SQLite via `.backup()` nativo, backup de Postgres via `pg_dump`, cada
+    um com ferramentas/permissões próprias — ver scripts equivalentes já usados em produção nesta
+    mesma base de código, `backend/scripts/backup_db.py` e `migrate_to_postgres.py`, como
+    referência de padrão a seguir quando isso for implementado de verdade pra cada dialeto)."""
+
+    def __init__(self, dialect: str):
+        self.dialect = dialect
+
+    def create(self, dsn: str, dest_path: Path) -> None:
+        raise NotImplementedError(
+            f"Snapshot de banco pro dialeto '{self.dialect}' ainda não implementado — "
+            "faça backup manual antes de rodar migrate-data (ver README.md).")
+
+    def restore(self, dsn: str, snapshot_path: Path) -> None:
+        raise NotImplementedError(
+            f"Restore de banco pro dialeto '{self.dialect}' ainda não implementado — "
+            "restaure o backup manual feito antes da migração.")

dbbridge/migration/schema_migration.py

@@ -0,0 +1,56 @@
+"""Migração de SCHEMA: pega o Schema (IR) já parseado da origem, renderiza pro destino, e aplica
+(executa o DDL gerado) contra uma conexão real do destino. Separado de data_migration.py de
+propósito — schema primeiro (Fase 1), dados depois (Fase 4), sempre nessa ordem."""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from ..core.parser import get_parser
+from ..core.renderer import get_renderer
+from ..core.sql_lex import split_statements
+
+
+@dataclass
+class SchemaMigrationResult:
+    sql: str
+    statements_executed: int
+    review_required_count: int
+    findings: list[str] = field(default_factory=list)
+
+
+def render_target_ddl(source_sql: str, source_dialect: str, target_dialect: str) -> tuple[str, list[str]]:
+    """Só a etapa de tradução (parser origem -> IR -> renderer destino) — não toca em banco nenhum.
+    Separado de `apply_schema` pra permitir revisar o SQL gerado antes de rodar de verdade."""
+    parser = get_parser(source_dialect)
+    renderer = get_renderer(target_dialect)
+    parse_result = parser.parse(source_sql)
+    render_result = renderer.render_schema(parse_result.schema)
+
+    findings = [f"parse: {f.reason}" for f in parse_result.findings]
+    findings += [f"render: {f.reason}" for f in render_result.findings]
+    return render_result.sql, findings
+
+
+def apply_schema(target_connection, target_sql: str) -> int:
+    """Executa o DDL renderizado contra uma conexão de verdade do destino (objeto com `.execute()`
+    estilo sqlite3/psycopg/DBBridge compat). Devolve quantos statements rodaram. Nunca faz DROP
+    nem TRUNCATE — só CREATE (o schema_migration é aditivo, igual init_db() em qualquer app real)."""
+    count = 0
+    for stmt in split_statements(target_sql):
+        target_connection.execute(stmt)
+        count += 1
+    if hasattr(target_connection, "commit"):
+        target_connection.commit()
+    return count
+
+
+def migrate_schema(source_sql: str, source_dialect: str, target_dialect: str, target_connection=None) -> SchemaMigrationResult:
+    """Fluxo completo: traduz e (se `target_connection` for passado) aplica. Sem conexão, só devolve
+    o SQL traduzido pra revisão (dry-run implícito)."""
+    target_sql, findings = render_target_ddl(source_sql, source_dialect, target_dialect)
+    executed = 0
+    if target_connection is not None:
+        executed = apply_schema(target_connection, target_sql)
+    return SchemaMigrationResult(
+        sql=target_sql, statements_executed=executed,
+        review_required_count=len(findings), findings=findings)

dbbridge/migration/validator.py

@@ -0,0 +1,85 @@
+"""Validação pós-migração: contagem de linhas (sempre) e checksum por tabela (quando possível) —
+prova que os dados migrados são os mesmos, não só "a mesma quantidade"."""
+from __future__ import annotations
+
+import hashlib
+from dataclasses import dataclass, field
+
+
+@dataclass
+class TableValidation:
+    table: str
+    source_count: int
+    target_count: int
+    source_checksum: str | None
+    target_checksum: str | None
+
+    @property
+    def counts_match(self) -> bool:
+        return self.source_count == self.target_count
+
+    @property
+    def checksums_match(self) -> bool | None:
+        if self.source_checksum is None or self.target_checksum is None:
+            return None  # não calculado (ex: tabela grande demais, ver skip_checksum_above)
+        return self.source_checksum == self.target_checksum
+
+    @property
+    def ok(self) -> bool:
+        return self.counts_match and (self.checksums_match is not False)
+
+
+@dataclass
+class ValidationReport:
+    tables: list[TableValidation] = field(default_factory=list)
+
+    @property
+    def all_ok(self) -> bool:
+        return all(t.ok for t in self.tables)
+
+    def to_dict(self) -> dict:
+        return {
+            "all_ok": self.all_ok,
+            "tables": [
+                {"table": t.table, "source_count": t.source_count, "target_count": t.target_count,
+                 "counts_match": t.counts_match, "checksums_match": t.checksums_match}
+                for t in self.tables
+            ],
+        }
+
+
+def _row_checksum(connection, table: str, columns: list[str]) -> str:
+    """Concatena todas as linhas (ordenadas por todas as colunas, pra não depender de ordem física
+    de armazenamento) e faz hash — barato o bastante pra tabelas de tamanho moderado; ver
+    `skip_checksum_above` em `validate_table` pra tabelas grandes onde isso seria caro demais."""
+    col_list = ",".join(columns)
+    rows = connection.execute(f"SELECT {col_list} FROM {table} ORDER BY {col_list}").fetchall()
+    h = hashlib.sha256()
+    for row in rows:
+        values = [row[c] if hasattr(row, "keys") else row[i] for i, c in enumerate(columns)]
+        h.update("|".join(str(v) for v in values).encode("utf-8", errors="replace"))
+        h.update(b"\x00")
+    return h.hexdigest()
+
+
+def validate_table(source_connection, target_connection, table: str, columns: list[str] | None = None,
+                    skip_checksum_above: int = 100_000) -> TableValidation:
+    source_count = source_connection.execute(f"SELECT COUNT(*) FROM {table}").fetchone()[0]
+    target_count = target_connection.execute(f"SELECT COUNT(*) FROM {table}").fetchone()[0]
+
+    source_checksum = target_checksum = None
+    if columns and source_count <= skip_checksum_above:
+        source_checksum = _row_checksum(source_connection, table, columns)
+        target_checksum = _row_checksum(target_connection, table, columns)
+
+    return TableValidation(table=table, source_count=source_count, target_count=target_count,
+                            source_checksum=source_checksum, target_checksum=target_checksum)
+
+
+def validate(source_connection, target_connection, tables: dict[str, list[str] | None],
+             skip_checksum_above: int = 100_000) -> ValidationReport:
+    """`tables`: mapa nome_tabela -> lista de colunas (ou None pra pular checksum, só contar)."""
+    report = ValidationReport()
+    for table, columns in tables.items():
+        report.tables.append(validate_table(source_connection, target_connection, table, columns, skip_checksum_above))
+    return report

dbbridge/reports/__init__.py

@@ -0,0 +1,3 @@
+from .report import render_report
+
+__all__ = ["render_report"]

dbbridge/reports/report.py

@@ -0,0 +1,58 @@
+"""Geração de relatório unificado — usado pelos comandos `scan`, `report`, `migrate-data`, `validate`
+da CLI. Formato comum (texto/JSON) pra qualquer um dos resultados do pacote (ScanReport,
+SchemaMigrationResult, DataMigrationResult, ValidationReport), sem cada comando reinventar a própria
+formatação de saída.
+"""
+from __future__ import annotations
+
+import json
+from dataclasses import asdict, is_dataclass
+from datetime import datetime, timezone
+
+
+def _to_jsonable(obj):
+    if is_dataclass(obj) and not isinstance(obj, type):
+        return {k: _to_jsonable(v) for k, v in asdict(obj).items()}
+    if isinstance(obj, dict):
+        return {k: _to_jsonable(v) for k, v in obj.items()}
+    if isinstance(obj, (list, tuple)):
+        return [_to_jsonable(v) for v in obj]
+    if hasattr(obj, "__fspath__"):  # Path
+        return str(obj)
+    return obj
+
+
+def render_report(title: str, payload, fmt: str = "text") -> str:
+    """`payload` pode ser um objeto com `.to_dict()` (ScanReport/ValidationReport) ou qualquer
+    dataclass (SchemaMigrationResult/DataMigrationResult) — normaliza os dois casos."""
+    data = payload.to_dict() if hasattr(payload, "to_dict") else _to_jsonable(payload)
+
+    if fmt == "json":
+        return json.dumps({
+            "title": title,
+            "generated_at": datetime.now(timezone.utc).isoformat(),
+            "data": data,
+        }, indent=2, ensure_ascii=False)
+
+    lines = [f"=== {title} ===", f"Gerado em: {datetime.now(timezone.utc).isoformat()}", ""]
+    lines.append(_dict_to_text(data))
+    return "\n".join(lines)
+
+
+def _dict_to_text(data, indent: int = 0) -> str:
+    prefix = "  " * indent
+    lines = []
+    if isinstance(data, dict):
+        for k, v in data.items():
+            if isinstance(v, (dict, list)):
+                lines.append(f"{prefix}{k}:")
+                lines.append(_dict_to_text(v, indent + 1))
+            else:
+                lines.append(f"{prefix}{k}: {v}")
+    elif isinstance(data, list):
+        for item in data:
+            lines.append(_dict_to_text(item, indent))
+            lines.append("")
+    else:
+        lines.append(f"{prefix}{data}")
+    return "\n".join(lines)

dbbridge/scanner/__init__.py

@@ -0,0 +1,3 @@
+from .scanner import Finding, ScanReport, scan_file, scan_project
+
+__all__ = ["Finding", "ScanReport", "scan_file", "scan_project"]

dbbridge/scanner/scanner.py

@@ -0,0 +1,176 @@
+"""Scanner: percorre um projeto Python procurando SQL potencialmente incompatível entre o dialeto
+origem e destino escolhidos. Generaliza o scanner do PostgresModel (que só conhecia SQLite->Postgres)
+pra qualquer par suportado — a diferença de risco entre `?`->`%s` (Postgres) e `?`->`?` (MySQL, sem
+mudança) só faz sentido sabendo os dois lados, por isso o scanner recebe `source`/`target`.
+"""
+from __future__ import annotations
+
+import ast
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Iterable
+
+RISK_LOW = "LOW"
+RISK_MEDIUM = "MEDIUM"
+RISK_HIGH = "HIGH"
+
+# Placeholder nativo de cada dialeto — usado pra saber se `?`/`%s`/etc precisa mudar entre origem/destino.
+_PLACEHOLDER_STYLE = {
+    "sqlite": "?",
+    "postgres": "%s",
+    "mysql": "%s",
+    "sqlserver": "?",
+}
+
+_AUTOINCREMENT_KEYWORDS = {
+    "sqlite": "AUTOINCREMENT",
+    "postgres": "GENERATED",
+    "mysql": "AUTO_INCREMENT",
+    "sqlserver": "IDENTITY",
+}
+
+
+@dataclass
+class Finding:
+    file: Path
+    line: int
+    category: str
+    risk: str
+    snippet: str
+    suggestion: str
+
+
+@dataclass
+class ScanReport:
+    source: str
+    target: str
+    findings: list[Finding] = field(default_factory=list)
+
+    def by_risk(self, risk: str) -> list[Finding]:
+        return [f for f in self.findings if f.risk == risk]
+
+    def by_category(self) -> dict[str, list[Finding]]:
+        out: dict[str, list[Finding]] = {}
+        for f in self.findings:
+            out.setdefault(f.category, []).append(f)
+        return out
+
+    def to_text(self) -> str:
+        lines = [f"Origem: {self.source} -> Destino: {self.target}"]
+        for category, items in sorted(self.by_category().items()):
+            lines.append(f"\n=== {category} ({len(items)} ocorrência(s)) ===")
+            for it in items:
+                lines.append(f"  [{it.risk}] {it.file}:{it.line}  {it.snippet!r}")
+                lines.append(f"    -> {it.suggestion}")
+        lines.append(f"\nTotal: {len(self.findings)} achado(s), "
+                     f"{len(self.by_risk(RISK_HIGH))} de alto risco (REVIEW_REQUIRED).")
+        return "\n".join(lines)
+
+    def to_dict(self) -> dict:
+        return {
+            "source": self.source, "target": self.target, "total": len(self.findings),
+            "by_risk": {r: len(self.by_risk(r)) for r in (RISK_LOW, RISK_MEDIUM, RISK_HIGH)},
+            "findings": [
+                {"file": str(f.file), "line": f.line, "category": f.category,
+                 "risk": f.risk, "snippet": f.snippet, "suggestion": f.suggestion}
+                for f in self.findings
+            ],
+        }
+
+
+def _extract_sql_text(node: ast.AST) -> str | None:
+    if isinstance(node, ast.Constant) and isinstance(node.value, str):
+        return node.value
+    if isinstance(node, ast.JoinedStr):
+        parts = []
+        for v in node.values:
+            if isinstance(v, ast.Constant):
+                parts.append(str(v.value))
+            elif isinstance(v, ast.FormattedValue):
+                parts.append("{X}")
+        return "".join(parts)
+    if isinstance(node, ast.BinOp) and isinstance(node.op, ast.Add):
+        left = _extract_sql_text(node.left)
+        right = _extract_sql_text(node.right)
+        if left is not None and right is not None:
+            return left + right
+    if isinstance(node, ast.Call) and isinstance(node.func, ast.Attribute) and node.func.attr == "join":
+        return "{JOIN}"
+    return None
+
+
+def _classify(sql: str, file: Path, line: int, source: str, target: str) -> list[Finding]:
+    import re
+    findings: list[Finding] = []
+
+    src_ph = _PLACEHOLDER_STYLE.get(source, "?")
+    tgt_ph = _PLACEHOLDER_STYLE.get(target, "?")
+    if src_ph in sql and src_ph != tgt_ph:
+        findings.append(Finding(file, line, "PLACEHOLDER", RISK_LOW, src_ph,
+                                 f"'{src_ph}' -> '{tgt_ph}' — traduzido pelo compat runtime."))
+
+    src_autoinc = _AUTOINCREMENT_KEYWORDS.get(source)
+    if src_autoinc and re.search(rf"\b{src_autoinc}\b", sql, re.IGNORECASE) and "CREATE TABLE" in sql.upper():
+        findings.append(Finding(file, line, "AUTOINCREMENT", RISK_LOW, src_autoinc,
+                                 f"Sintaxe de autoincrement de {source} — traduzida automaticamente em DDL."))
+
+    if re.search(r"\bINSERT\s+OR\s+IGNORE\b", sql, re.IGNORECASE):
+        risk = RISK_LOW if target in ("postgres", "sqlite") else RISK_HIGH
+        findings.append(Finding(file, line, "INSERT_OR_IGNORE", risk, "INSERT OR IGNORE",
+                                 "ON CONFLICT DO NOTHING (Postgres/SQLite) — verificar equivalente pro destino."))
+
+    if re.search(r"\bINSERT\s+OR\s+REPLACE\b", sql, re.IGNORECASE):
+        findings.append(Finding(file, line, "INSERT_OR_REPLACE", RISK_HIGH, "INSERT OR REPLACE",
+                                 "Precisa saber a coluna de conflito — nunca traduzido automaticamente."))
+
+    if re.search(r"\bsqlite_master\b", sql, re.IGNORECASE) and target != "sqlite":
+        findings.append(Finding(file, line, "SQLITE_MASTER", RISK_HIGH, "sqlite_master",
+                                 "Sem equivalente direto fora do SQLite — trocar por catálogo do destino "
+                                 "(information_schema no Postgres/MySQL)."))
+
+    if re.search(r"\bPRAGMA\s+\w+", sql, re.IGNORECASE) and target != "sqlite":
+        findings.append(Finding(file, line, "PRAGMA", RISK_HIGH, "PRAGMA",
+                                 "Comando específico do SQLite — sem equivalente direto no destino."))
+
+    if re.search(r"\bLIKE\b", sql, re.IGNORECASE) and not re.search(r"\bILIKE\b", sql, re.IGNORECASE) and target == "postgres":
+        findings.append(Finding(file, line, "LIKE_CASE_SENSITIVITY", RISK_HIGH, "LIKE",
+                                 "Case-sensitivity muda entre dialetos — confirmar se ILIKE é necessário."))
+
+    return findings
+
+
+class _ExecuteVisitor(ast.NodeVisitor):
+    def __init__(self, file: Path, source: str, target: str):
+        self.file = file
+        self.source = source
+        self.target = target
+        self.findings: list[Finding] = []
+
+    def visit_Call(self, node: ast.Call):
+        if isinstance(node.func, ast.Attribute) and node.func.attr in ("execute", "executemany"):
+            if node.args:
+                sql = _extract_sql_text(node.args[0])
+                if sql is not None:
+                    self.findings.extend(_classify(sql, self.file, node.lineno, self.source, self.target))
+        self.generic_visit(node)
+
+
+def scan_file(path: Path, source: str, target: str) -> list[Finding]:
+    try:
+        src = path.read_text(encoding="utf-8")
+        tree = ast.parse(src, filename=str(path))
+    except (SyntaxError, UnicodeDecodeError) as e:
+        return [Finding(path, 0, "PARSE_ERROR", RISK_HIGH, str(e), "Arquivo não pôde ser lido/parseado.")]
+    visitor = _ExecuteVisitor(path, source, target)
+    visitor.visit(tree)
+    return visitor.findings
+
+
+def scan_project(root: Path, source: str, target: str,
+                  exclude: Iterable[str] = ("venv", ".venv", "__pycache__", "node_modules")) -> ScanReport:
+    report = ScanReport(source=source, target=target)
+    for path in sorted(Path(root).rglob("*.py")):
+        if any(part in exclude for part in path.parts):
+            continue
+        report.findings.extend(scan_file(path, source, target))
+    return report