dbbridgekit 0.1.0__py3-none-any.whl

dbbridge/dialects/postgres.py

@@ -0,0 +1,292 @@
+"""Dialeto PostgreSQL: parser (DDL Postgres -> IR) e renderer (IR -> DDL Postgres).
+
+Mesmo escopo documentado em dialects/sqlite.py — subconjunto realista de DDL, não gramática
+completa. Reaproveita o parser de tabela genérico (core/sql_lex.py) mudando só o mapeamento de
+tipos e o reconhecimento de `GENERATED ... AS IDENTITY`/`SERIAL` como autoincrement.
+"""
+from __future__ import annotations
+
+import re
+
+from ..core.ir import (
+    CheckConstraint,
+    Column,
+    ForeignKey,
+    Index,
+    Schema,
+    Table,
+    UniqueConstraint,
+    View,
+)
+from ..core.parser import DialectParser, ParseFinding, ParseResult, register_parser
+from ..core.renderer import DialectRenderer, RenderFinding, RenderResult, register_renderer
+from ..core.sql_lex import split_statements, split_top_level_commas, strip_outer_parens
+from ..core.types import Ambiguity, CanonicalType
+
+_POSTGRES_TYPE_MAP = {
+    "INTEGER": CanonicalType.INTEGER, "INT": CanonicalType.INTEGER, "INT4": CanonicalType.INTEGER,
+    "SERIAL": CanonicalType.INTEGER,  # auto_increment=True tratado à parte
+    "SMALLINT": CanonicalType.SMALLINT, "INT2": CanonicalType.SMALLINT, "SMALLSERIAL": CanonicalType.SMALLINT,
+    "BIGINT": CanonicalType.BIGINT, "INT8": CanonicalType.BIGINT, "BIGSERIAL": CanonicalType.BIGINT,
+    "REAL": CanonicalType.FLOAT, "FLOAT4": CanonicalType.FLOAT, "DOUBLE PRECISION": CanonicalType.FLOAT, "FLOAT8": CanonicalType.FLOAT,
+    "NUMERIC": CanonicalType.NUMERIC, "DECIMAL": CanonicalType.NUMERIC,
+    "BOOLEAN": CanonicalType.BOOLEAN, "BOOL": CanonicalType.BOOLEAN,
+    "TEXT": CanonicalType.TEXT,
+    "VARCHAR": CanonicalType.VARCHAR, "CHARACTER VARYING": CanonicalType.VARCHAR, "CHAR": CanonicalType.VARCHAR,
+    "DATE": CanonicalType.DATE,
+    "TIME": CanonicalType.TIME,
+    "TIMESTAMP": CanonicalType.DATETIME,
+    "TIMESTAMPTZ": CanonicalType.TIMESTAMP_TZ, "TIMESTAMP WITH TIME ZONE": CanonicalType.TIMESTAMP_TZ,
+    "JSON": CanonicalType.JSON, "JSONB": CanonicalType.JSON,
+    "UUID": CanonicalType.UUID,
+    "BYTEA": CanonicalType.BINARY,
+}
+_SERIAL_TYPES = {"SERIAL", "SMALLSERIAL", "BIGSERIAL"}
+
+_CREATE_TABLE_RE = re.compile(
+    r"^\s*CREATE\s+TABLE\s+(IF\s+NOT\s+EXISTS\s+)?\"?(\w+)\"?\s*\((.*)\)\s*$",
+    re.IGNORECASE | re.DOTALL,
+)
+_CREATE_INDEX_RE = re.compile(
+    r"^\s*CREATE\s+(UNIQUE\s+)?INDEX\s+(IF\s+NOT\s+EXISTS\s+)?\"?(\w+)\"?\s+"
+    r"ON\s+\"?(\w+)\"?\s*\((.*)\)\s*$",
+    re.IGNORECASE | re.DOTALL,
+)
+_CREATE_VIEW_RE = re.compile(
+    r"^\s*CREATE\s+VIEW\s+(IF\s+NOT\s+EXISTS\s+)?\"?(\w+)\"?\s+AS\s+(.*)$",
+    re.IGNORECASE | re.DOTALL,
+)
+_TYPE_WITH_ARGS_RE = re.compile(r"^([\w\s]+?)\s*(?:\(\s*(\d+)\s*(?:,\s*(\d+)\s*)?\))?$")
+_IDENTITY_RE = re.compile(r"GENERATED\s+(?:ALWAYS|BY\s+DEFAULT)\s+AS\s+IDENTITY", re.IGNORECASE)
+
+
+def _parse_column(item: str) -> tuple[Column | None, list[ParseFinding]]:
+    findings: list[ParseFinding] = []
+    tokens = item.strip().split(None, 2)
+    if len(tokens) < 2:
+        return None, [ParseFinding(Ambiguity.UNRECOGNIZED_DDL, item, "Definição de coluna incompleta.")]
+    name = tokens[0].strip('"')
+    type_str = tokens[1]
+    rest = tokens[2] if len(tokens) > 2 else ""
+
+    # "DOUBLE PRECISION"/"TIMESTAMP WITH TIME ZONE"/"CHARACTER VARYING" são tipos de 2+ palavras —
+    # tenta casar contra o mapa antes de assumir que a 2ª palavra em diante já é constraint.
+    combined_upper = f"{type_str} {rest}".upper()
+    multi_word_type = next((t for t in _POSTGRES_TYPE_MAP if " " in t and combined_upper.startswith(t)), None)
+    if multi_word_type:
+        type_str = multi_word_type
+        # recupera o texto original (preserva caixa) removendo o prefixo do tipo já identificado
+        original_combined = f"{tokens[1]} {tokens[2] if len(tokens) > 2 else ''}"
+        rest = original_combined[len(multi_word_type):].strip()
+
+    base_match = _TYPE_WITH_ARGS_RE.match(type_str.strip())
+    if not base_match:
+        canonical, length, precision, scale, auto_increment = CanonicalType.TEXT, None, None, None, False
+        findings.append(ParseFinding(Ambiguity.UNSUPPORTED_TYPE, type_str, f"Tipo '{type_str}' não reconhecido — assumido TEXT."))
+    else:
+        base = base_match.group(1).strip().upper()
+        canonical = _POSTGRES_TYPE_MAP.get(base)
+        auto_increment = base in _SERIAL_TYPES
+        if canonical is None:
+            canonical = CanonicalType.TEXT
+            findings.append(ParseFinding(Ambiguity.UNSUPPORTED_TYPE, type_str, f"Tipo '{base}' não mapeado — assumido TEXT."))
+        length = int(base_match.group(2)) if (canonical == CanonicalType.VARCHAR and base_match.group(2)) else None
+        precision = int(base_match.group(2)) if (canonical == CanonicalType.NUMERIC and base_match.group(2)) else None
+        scale = int(base_match.group(3)) if (canonical == CanonicalType.NUMERIC and base_match.group(3)) else None
+
+    upper_rest = rest.upper()
+    nullable = "NOT NULL" not in upper_rest
+    primary_key = "PRIMARY KEY" in upper_rest
+    if _IDENTITY_RE.search(rest):
+        auto_increment = True
+    unique = bool(re.search(r"\bUNIQUE\b", upper_rest)) and "PRIMARY KEY" not in upper_rest[:upper_rest.find("UNIQUE") if "UNIQUE" in upper_rest else 0]
+
+    default = None
+    if not _IDENTITY_RE.search(rest):
+        # Checagem tem que ser no `rest` INTEIRO, não só no trecho casado por default_m: a frase
+        # "GENERATED BY DEFAULT AS IDENTITY" contém a substring "DEFAULT AS", que o regex de default
+        # casava sozinho (bug real encontrado testando: virava `DEFAULT AS` na coluna, lixo). Só
+        # tenta achar um DEFAULT de verdade se a coluna não for IDENTITY (que já cobre o "default"
+        # dela via auto_increment, sem precisar de um valor literal).
+        default_m = re.search(r"DEFAULT\s+('(?:[^']|'')*'|\S+)", rest, re.IGNORECASE)
+        if default_m:
+            default = default_m.group(1)
+
+    col = Column(name=name, type=canonical, nullable=nullable, primary_key=primary_key,
+                 auto_increment=auto_increment, unique=unique, default=default,
+                 length=length, precision=precision, scale=scale)
+    return col, findings
+
+
+def _parse_table_body(body: str) -> tuple[list[Column], list[ForeignKey], list[UniqueConstraint], list[CheckConstraint], list[ParseFinding]]:
+    columns: list[Column] = []
+    fks: list[ForeignKey] = []
+    uniques: list[UniqueConstraint] = []
+    checks: list[CheckConstraint] = []
+    findings: list[ParseFinding] = []
+
+    for item in split_top_level_commas(body):
+        stripped = item.strip()
+        upper = stripped.upper()
+        if upper.startswith("PRIMARY KEY"):
+            cols_txt = strip_outer_parens(stripped[len("PRIMARY KEY"):].strip())
+            col_names = [c.strip(' "') for c in cols_txt.split(",")]
+            for cname in col_names:
+                col = next((c for c in columns if c.name == cname), None)
+                if col:
+                    col.primary_key = True
+        elif upper.startswith("FOREIGN KEY"):
+            # Ações de FK são um conjunto FIXO da SQL padrão (CASCADE/RESTRICT/NO ACTION/SET NULL/SET
+            # DEFAULT) — enumeradas explicitamente em vez de `\w+(?:\s+\w+)?` genérico, que capturava
+            # greedy demais (bug real: "CASCADE ON UPDATE ..." virava on_delete="CASCADE ON" porque o
+            # 2º grupo opcional casava a palavra "ON" antes do literal "ON UPDATE" ter chance de bater).
+            _FK_ACTION = r"CASCADE|RESTRICT|NO\s+ACTION|SET\s+NULL|SET\s+DEFAULT"
+            m = re.match(r'FOREIGN\s+KEY\s*\(([^)]*)\)\s*REFERENCES\s+"?(\w+)"?\s*\(([^)]*)\)'
+                          rf'(?:\s+ON\s+DELETE\s+({_FK_ACTION}))?(?:\s+ON\s+UPDATE\s+({_FK_ACTION}))?',
+                          stripped, re.IGNORECASE)
+            if m:
+                cols = [c.strip(' "') for c in m.group(1).split(",")]
+                ref_cols = [c.strip(' "') for c in m.group(3).split(",")]
+                fks.append(ForeignKey(name=None, columns=cols, ref_table=m.group(2),
+                                       ref_columns=ref_cols, on_delete=m.group(4), on_update=m.group(5)))
+            else:
+                findings.append(ParseFinding(Ambiguity.UNRECOGNIZED_DDL, stripped, "FOREIGN KEY não reconhecida."))
+        elif upper.startswith("UNIQUE"):
+            cols_txt = strip_outer_parens(stripped[len("UNIQUE"):].strip())
+            col_names = [c.strip(' "') for c in cols_txt.split(",")]
+            uniques.append(UniqueConstraint(name=None, columns=col_names))
+        elif upper.startswith("CHECK"):
+            expr = strip_outer_parens(stripped[len("CHECK"):].strip())
+            checks.append(CheckConstraint(name=None, expression=expr))
+        else:
+            col, col_findings = _parse_column(stripped)
+            findings.extend(col_findings)
+            if col:
+                columns.append(col)
+
+    return columns, fks, uniques, checks, findings
+
+
+class PostgresParser(DialectParser):
+    name = "postgres"
+
+    def parse(self, sql: str) -> ParseResult:
+        schema = Schema()
+        findings: list[ParseFinding] = []
+
+        for stmt in split_statements(sql):
+            m = _CREATE_TABLE_RE.match(stmt)
+            if m:
+                table_name = m.group(2)
+                columns, fks, uniques, checks, body_findings = _parse_table_body(m.group(3))
+                findings.extend(body_findings)
+                schema.tables.append(Table(
+                    name=table_name, columns=columns, foreign_keys=fks,
+                    unique_constraints=uniques, check_constraints=checks))
+                continue
+
+            m = _CREATE_INDEX_RE.match(stmt)
+            if m:
+                is_unique, _, idx_name, table_name, cols_txt = m.groups()
+                cols = [c.strip(' "') for c in cols_txt.split(",")]
+                table = schema.table(table_name)
+                if table:
+                    table.indexes.append(Index(name=idx_name, columns=cols, unique=bool(is_unique)))
+                else:
+                    findings.append(ParseFinding(Ambiguity.UNRECOGNIZED_DDL, stmt,
+                                                  f"Índice '{idx_name}' referencia tabela '{table_name}' não vista ainda."))
+                continue
+
+            m = _CREATE_VIEW_RE.match(stmt)
+            if m:
+                schema.views.append(View(name=m.group(2), query=m.group(3).strip()))
+                continue
+
+            if re.match(r"^\s*CREATE\s+(OR\s+REPLACE\s+)?(TRIGGER|FUNCTION)", stmt, re.IGNORECASE):
+                findings.append(ParseFinding(Ambiguity.UNSUPPORTED_EXPRESSION, stmt,
+                                              "Trigger/função procedural é específica do dialeto — "
+                                              "não convertida automaticamente."))
+                continue
+
+            findings.append(ParseFinding(Ambiguity.UNRECOGNIZED_DDL, stmt, "Statement não reconhecido pelo parser Postgres."))
+
+        return ParseResult(schema=schema, findings=findings)
+
+
+_CANONICAL_TO_POSTGRES = {
+    CanonicalType.INTEGER: "INTEGER", CanonicalType.SMALLINT: "SMALLINT", CanonicalType.BIGINT: "BIGINT",
+    CanonicalType.FLOAT: "DOUBLE PRECISION", CanonicalType.NUMERIC: "NUMERIC", CanonicalType.BOOLEAN: "BOOLEAN",
+    CanonicalType.TEXT: "TEXT", CanonicalType.VARCHAR: "VARCHAR", CanonicalType.DATE: "DATE",
+    CanonicalType.TIME: "TIME", CanonicalType.DATETIME: "TIMESTAMP", CanonicalType.TIMESTAMP_TZ: "TIMESTAMPTZ",
+    CanonicalType.JSON: "JSONB", CanonicalType.UUID: "UUID", CanonicalType.BINARY: "BYTEA",
+    CanonicalType.ENUM: "TEXT",
+}
+
+
+def _render_column(col: Column) -> str:
+    if col.primary_key and col.auto_increment:
+        # Ver docstring do módulo/README: IDENTITY é a forma moderna recomendada (SERIAL é legado,
+        # mantido só implicitamente compatível — nunca emitido pelo renderer).
+        type_sql = "INTEGER GENERATED BY DEFAULT AS IDENTITY" if col.type != CanonicalType.BIGINT else \
+                   "BIGINT GENERATED BY DEFAULT AS IDENTITY"
+    elif col.type == CanonicalType.VARCHAR and col.length:
+        type_sql = f"VARCHAR({col.length})"
+    elif col.type == CanonicalType.NUMERIC and col.precision:
+        type_sql = f"NUMERIC({col.precision}{',' + str(col.scale) if col.scale else ''})"
+    else:
+        type_sql = _CANONICAL_TO_POSTGRES.get(col.type, "TEXT")
+
+    parts = [col.name, type_sql]
+    if col.primary_key:
+        parts.append("PRIMARY KEY")
+    if not col.nullable and not col.primary_key:
+        parts.append("NOT NULL")
+    if col.unique and not col.primary_key:
+        parts.append("UNIQUE")
+    if col.default is not None:
+        parts.append(f"DEFAULT {col.default}")
+    if col.type == CanonicalType.ENUM and col.enum_values:
+        values = ",".join(f"'{v}'" for v in col.enum_values)
+        parts.append(f"CHECK({col.name} IN ({values}))")
+    return " ".join(parts)
+
+
+class PostgresRenderer(DialectRenderer):
+    name = "postgres"
+
+    def render_schema(self, schema: Schema) -> RenderResult:
+        statements: list[str] = []
+        findings: list[RenderFinding] = []
+
+        for table in schema.tables:
+            lines = [_render_column(c) for c in table.columns]
+            for fk in table.foreign_keys:
+                cols = ",".join(fk.columns)
+                ref_cols = ",".join(fk.ref_columns)
+                clause = f"FOREIGN KEY({cols}) REFERENCES {fk.ref_table}({ref_cols})"
+                if fk.on_delete:
+                    clause += f" ON DELETE {fk.on_delete}"
+                if fk.on_update:
+                    clause += f" ON UPDATE {fk.on_update}"
+                lines.append(clause)
+            for uq in table.unique_constraints:
+                lines.append(f"UNIQUE({','.join(uq.columns)})")
+            for chk in table.check_constraints:
+                lines.append(f"CHECK({chk.expression})")
+            statements.append(f"CREATE TABLE IF NOT EXISTS {table.name} (\n  " + ",\n  ".join(lines) + "\n)")
+            for idx in table.indexes:
+                kind = "UNIQUE INDEX" if idx.unique else "INDEX"
+                statements.append(f"CREATE {kind} IF NOT EXISTS {idx.name} ON {table.name}({','.join(idx.columns)})")
+
+        for view in schema.views:
+            statements.append(f"CREATE OR REPLACE VIEW {view.name} AS {view.query}")
+
+        for trigger in schema.triggers:
+            findings.append(RenderFinding(Ambiguity.UNSUPPORTED_EXPRESSION, trigger.name,
+                                           "Trigger não renderizado — corpo procedural é específico do dialeto de origem."))
+
+        return RenderResult(sql=";\n\n".join(statements) + (";" if statements else ""), findings=findings)
+
+
+register_parser("postgres", PostgresParser())
+register_renderer("postgres", PostgresRenderer())

dbbridge/dialects/sqlite.py

@@ -0,0 +1,279 @@
+"""Dialeto SQLite: parser (DDL SQLite -> IR) e renderer (IR -> DDL SQLite).
+
+Cobre o subconjunto de sintaxe que aplicações reais realmente geram (o mesmo padrão observado numa
+base de código de produção real durante o desenvolvimento desta ferramenta: `CREATE TABLE
+IF NOT EXISTS nome(col TIPO restrições, ..., PRIMARY KEY(...), FOREIGN KEY(...) REFERENCES...)`) —
+não é um parser de gramática SQL completa. Qualquer coisa fora desse subconjunto vira uma
+`ParseFinding`/`RenderFinding`, nunca uma adivinhação.
+"""
+from __future__ import annotations
+
+import re
+
+from ..core.ir import (
+    CheckConstraint,
+    Column,
+    ForeignKey,
+    Index,
+    Schema,
+    Table,
+    UniqueConstraint,
+    View,
+)
+from ..core.parser import DialectParser, ParseFinding, ParseResult, register_parser
+from ..core.renderer import DialectRenderer, RenderFinding, RenderResult, register_renderer
+from ..core.sql_lex import split_statements, split_top_level_commas, strip_outer_parens
+from ..core.types import Ambiguity, CanonicalType
+
+# ---------------------------------------------------------------------------
+# Mapeamento de tipos: SQLite tem "afinidade de tipo" (nomes livres) — normaliza os nomes mais
+# comuns pro vocabulário canônico. Qualquer nome não reconhecido cai em TEXT (afinidade padrão do
+# SQLite pra tipo desconhecido) COM uma finding, nunca silenciosamente.
+# ---------------------------------------------------------------------------
+_SQLITE_TYPE_MAP = {
+    "INTEGER": CanonicalType.INTEGER, "INT": CanonicalType.INTEGER,
+    "SMALLINT": CanonicalType.SMALLINT,
+    "BIGINT": CanonicalType.BIGINT,
+    "REAL": CanonicalType.FLOAT, "FLOAT": CanonicalType.FLOAT, "DOUBLE": CanonicalType.FLOAT,
+    "NUMERIC": CanonicalType.NUMERIC, "DECIMAL": CanonicalType.NUMERIC,
+    "BOOLEAN": CanonicalType.BOOLEAN, "BOOL": CanonicalType.BOOLEAN,
+    "TEXT": CanonicalType.TEXT, "CLOB": CanonicalType.TEXT,
+    "VARCHAR": CanonicalType.VARCHAR, "CHAR": CanonicalType.VARCHAR,
+    "DATE": CanonicalType.DATE,
+    "TIME": CanonicalType.TIME,
+    "DATETIME": CanonicalType.DATETIME, "TIMESTAMP": CanonicalType.DATETIME,
+    "JSON": CanonicalType.JSON,
+    "BLOB": CanonicalType.BINARY,
+}
+
+_CREATE_TABLE_RE = re.compile(
+    r"^\s*CREATE\s+TABLE\s+(IF\s+NOT\s+EXISTS\s+)?[\"'`\[]?(\w+)[\"'`\]]?\s*\((.*)\)\s*$",
+    re.IGNORECASE | re.DOTALL,
+)
+_CREATE_INDEX_RE = re.compile(
+    r"^\s*CREATE\s+(UNIQUE\s+)?INDEX\s+(IF\s+NOT\s+EXISTS\s+)?[\"'`\[]?(\w+)[\"'`\]]?\s+"
+    r"ON\s+[\"'`\[]?(\w+)[\"'`\]]?\s*\((.*)\)\s*$",
+    re.IGNORECASE | re.DOTALL,
+)
+_CREATE_VIEW_RE = re.compile(
+    r"^\s*CREATE\s+VIEW\s+(IF\s+NOT\s+EXISTS\s+)?[\"'`\[]?(\w+)[\"'`\]]?\s+AS\s+(.*)$",
+    re.IGNORECASE | re.DOTALL,
+)
+_TYPE_WITH_ARGS_RE = re.compile(r"^(\w+)\s*(?:\(\s*(\d+)\s*(?:,\s*(\d+)\s*)?\))?$")
+
+
+def _parse_column(item: str) -> tuple[Column | None, list[ParseFinding]]:
+    findings: list[ParseFinding] = []
+    tokens = item.strip().split(None, 2)
+    if len(tokens) < 2:
+        return None, [ParseFinding(Ambiguity.UNRECOGNIZED_DDL, item, "Definição de coluna incompleta.")]
+    name = tokens[0].strip('"\'`[]')
+    type_str = tokens[1]
+    rest = tokens[2] if len(tokens) > 2 else ""
+
+    m = _TYPE_WITH_ARGS_RE.match(type_str)
+    if m and not m.group(2) and rest:
+        # tipo pode ter argumentos com espaço antes do parêntese (ex: "VARCHAR (120)") — tenta juntar
+        combined = f"{type_str} {rest}".strip()
+        m2 = re.match(r"^(\w+)\s*\(\s*(\d+)\s*(?:,\s*(\d+)\s*)?\)\s*(.*)$", combined, re.IGNORECASE)
+        if m2:
+            type_str = f"{m2.group(1)}({m2.group(2)}{',' + m2.group(3) if m2.group(3) else ''})"
+            rest = m2.group(4)
+
+    base_match = re.match(r"^(\w+)\s*(?:\(\s*(\d+)\s*(?:,\s*(\d+)\s*)?\))?$", type_str)
+    if not base_match:
+        canonical, length, precision, scale = CanonicalType.TEXT, None, None, None
+        findings.append(ParseFinding(Ambiguity.UNSUPPORTED_TYPE, type_str, f"Tipo '{type_str}' não reconhecido — assumido TEXT."))
+    else:
+        base = base_match.group(1).upper()
+        canonical = _SQLITE_TYPE_MAP.get(base)
+        if canonical is None:
+            canonical = CanonicalType.TEXT
+            findings.append(ParseFinding(Ambiguity.UNSUPPORTED_TYPE, type_str, f"Tipo '{base}' não mapeado — assumido TEXT."))
+        length = int(base_match.group(2)) if (canonical == CanonicalType.VARCHAR and base_match.group(2)) else None
+        precision = int(base_match.group(2)) if (canonical == CanonicalType.NUMERIC and base_match.group(2)) else None
+        scale = int(base_match.group(3)) if (canonical == CanonicalType.NUMERIC and base_match.group(3)) else None
+
+    upper_rest = rest.upper()
+    nullable = "NOT NULL" not in upper_rest
+    primary_key = "PRIMARY KEY" in upper_rest
+    auto_increment = "AUTOINCREMENT" in upper_rest
+    unique = bool(re.search(r"\bUNIQUE\b", upper_rest)) and "PRIMARY KEY" not in upper_rest[:upper_rest.find("UNIQUE")]
+
+    default = None
+    default_m = re.search(r"DEFAULT\s+('(?:[^']|'')*'|\S+)", rest, re.IGNORECASE)
+    if default_m:
+        default = default_m.group(1)
+
+    col = Column(name=name, type=canonical, nullable=nullable, primary_key=primary_key,
+                 auto_increment=auto_increment, unique=unique, default=default,
+                 length=length, precision=precision, scale=scale)
+    return col, findings
+
+
+def _parse_table_body(body: str) -> tuple[list[Column], list[ForeignKey], list[UniqueConstraint], list[CheckConstraint], list[ParseFinding]]:
+    columns: list[Column] = []
+    fks: list[ForeignKey] = []
+    uniques: list[UniqueConstraint] = []
+    checks: list[CheckConstraint] = []
+    findings: list[ParseFinding] = []
+
+    for item in split_top_level_commas(body):
+        stripped = item.strip()
+        upper = stripped.upper()
+        if upper.startswith("PRIMARY KEY"):
+            cols_txt = strip_outer_parens(stripped[len("PRIMARY KEY"):].strip())
+            col_names = [c.strip(' "\'`[]') for c in cols_txt.split(",")]
+            for cname in col_names:
+                col = next((c for c in columns if c.name == cname), None)
+                if col:
+                    col.primary_key = True
+        elif upper.startswith("FOREIGN KEY"):
+            # Ver dialects/postgres.py — mesmo conjunto fixo de ações de FK em vez de `\w+(?:\s+\w+)?`
+            # genérico (bug real: capturava "CASCADE ON" por engano).
+            _FK_ACTION = r"CASCADE|RESTRICT|NO\s+ACTION|SET\s+NULL|SET\s+DEFAULT"
+            m = re.match(r'FOREIGN\s+KEY\s*\(([^)]*)\)\s*REFERENCES\s+["\'`\[]?(\w+)["\'`\]]?\s*\(([^)]*)\)'
+                          rf'(?:\s+ON\s+DELETE\s+({_FK_ACTION}))?(?:\s+ON\s+UPDATE\s+({_FK_ACTION}))?',
+                          stripped, re.IGNORECASE)
+            if m:
+                cols = [c.strip(' "\'`[]') for c in m.group(1).split(",")]
+                ref_cols = [c.strip(' "\'`[]') for c in m.group(3).split(",")]
+                fks.append(ForeignKey(name=None, columns=cols, ref_table=m.group(2),
+                                       ref_columns=ref_cols, on_delete=m.group(4), on_update=m.group(5)))
+            else:
+                findings.append(ParseFinding(Ambiguity.UNRECOGNIZED_DDL, stripped, "FOREIGN KEY não reconhecida."))
+        elif upper.startswith("UNIQUE"):
+            cols_txt = strip_outer_parens(stripped[len("UNIQUE"):].strip())
+            col_names = [c.strip(' "\'`[]') for c in cols_txt.split(",")]
+            uniques.append(UniqueConstraint(name=None, columns=col_names))
+        elif upper.startswith("CHECK"):
+            expr = strip_outer_parens(stripped[len("CHECK"):].strip())
+            checks.append(CheckConstraint(name=None, expression=expr))
+        else:
+            col, col_findings = _parse_column(stripped)
+            findings.extend(col_findings)
+            if col:
+                columns.append(col)
+
+    return columns, fks, uniques, checks, findings
+
+
+class SQLiteParser(DialectParser):
+    name = "sqlite"
+
+    def parse(self, sql: str) -> ParseResult:
+        schema = Schema()
+        findings: list[ParseFinding] = []
+
+        for stmt in split_statements(sql):
+            m = _CREATE_TABLE_RE.match(stmt)
+            if m:
+                table_name = m.group(2)
+                columns, fks, uniques, checks, body_findings = _parse_table_body(m.group(3))
+                findings.extend(body_findings)
+                schema.tables.append(Table(
+                    name=table_name, columns=columns, foreign_keys=fks,
+                    unique_constraints=uniques, check_constraints=checks))
+                continue
+
+            m = _CREATE_INDEX_RE.match(stmt)
+            if m:
+                is_unique, _, idx_name, table_name, cols_txt = m.groups()
+                cols = [c.strip(' "\'`[]') for c in cols_txt.split(",")]
+                table = schema.table(table_name)
+                if table:
+                    table.indexes.append(Index(name=idx_name, columns=cols, unique=bool(is_unique)))
+                else:
+                    findings.append(ParseFinding(Ambiguity.UNRECOGNIZED_DDL, stmt,
+                                                  f"Índice '{idx_name}' referencia tabela '{table_name}' não vista ainda."))
+                continue
+
+            m = _CREATE_VIEW_RE.match(stmt)
+            if m:
+                schema.views.append(View(name=m.group(2), query=m.group(3).strip()))
+                continue
+
+            if re.match(r"^\s*CREATE\s+TRIGGER", stmt, re.IGNORECASE):
+                findings.append(ParseFinding(Ambiguity.UNSUPPORTED_EXPRESSION, stmt,
+                                              "Corpo de TRIGGER é código procedural específico do dialeto — "
+                                              "não convertido automaticamente."))
+                continue
+
+            findings.append(ParseFinding(Ambiguity.UNRECOGNIZED_DDL, stmt, "Statement não reconhecido pelo parser SQLite."))
+
+        return ParseResult(schema=schema, findings=findings)
+
+
+_CANONICAL_TO_SQLITE = {
+    CanonicalType.INTEGER: "INTEGER", CanonicalType.SMALLINT: "INTEGER", CanonicalType.BIGINT: "INTEGER",
+    CanonicalType.FLOAT: "REAL", CanonicalType.NUMERIC: "NUMERIC", CanonicalType.BOOLEAN: "INTEGER",
+    CanonicalType.TEXT: "TEXT", CanonicalType.VARCHAR: "VARCHAR", CanonicalType.DATE: "TEXT",
+    CanonicalType.TIME: "TEXT", CanonicalType.DATETIME: "TEXT", CanonicalType.TIMESTAMP_TZ: "TEXT",
+    CanonicalType.JSON: "TEXT", CanonicalType.UUID: "TEXT", CanonicalType.BINARY: "BLOB",
+    CanonicalType.ENUM: "TEXT",
+}
+
+
+def _render_column(col: Column) -> str:
+    if col.type == CanonicalType.VARCHAR and col.length:
+        type_sql = f"VARCHAR({col.length})"
+    elif col.type == CanonicalType.NUMERIC and col.precision:
+        type_sql = f"NUMERIC({col.precision}{',' + str(col.scale) if col.scale else ''})"
+    else:
+        type_sql = _CANONICAL_TO_SQLITE.get(col.type, "TEXT")
+    parts = [col.name, type_sql]
+    if col.primary_key:
+        parts.append("PRIMARY KEY")
+        if col.auto_increment:
+            parts.append("AUTOINCREMENT")
+    if not col.nullable and not col.primary_key:
+        parts.append("NOT NULL")
+    if col.unique and not col.primary_key:
+        parts.append("UNIQUE")
+    if col.default is not None:
+        parts.append(f"DEFAULT {col.default}")
+    if col.type == CanonicalType.ENUM and col.enum_values:
+        values = ",".join(f"'{v}'" for v in col.enum_values)
+        parts.append(f"CHECK({col.name} IN ({values}))")
+    return " ".join(parts)
+
+
+class SQLiteRenderer(DialectRenderer):
+    name = "sqlite"
+
+    def render_schema(self, schema: Schema) -> RenderResult:
+        statements: list[str] = []
+        findings: list[RenderFinding] = []
+
+        for table in schema.tables:
+            lines = [_render_column(c) for c in table.columns]
+            for fk in table.foreign_keys:
+                cols = ",".join(fk.columns)
+                ref_cols = ",".join(fk.ref_columns)
+                clause = f"FOREIGN KEY({cols}) REFERENCES {fk.ref_table}({ref_cols})"
+                if fk.on_delete:
+                    clause += f" ON DELETE {fk.on_delete}"
+                if fk.on_update:
+                    clause += f" ON UPDATE {fk.on_update}"
+                lines.append(clause)
+            for uq in table.unique_constraints:
+                lines.append(f"UNIQUE({','.join(uq.columns)})")
+            for chk in table.check_constraints:
+                lines.append(f"CHECK({chk.expression})")
+            statements.append(f"CREATE TABLE IF NOT EXISTS {table.name} (\n  " + ",\n  ".join(lines) + "\n)")
+            for idx in table.indexes:
+                kind = "UNIQUE INDEX" if idx.unique else "INDEX"
+                statements.append(f"CREATE {kind} IF NOT EXISTS {idx.name} ON {table.name}({','.join(idx.columns)})")
+
+        for view in schema.views:
+            statements.append(f"CREATE VIEW IF NOT EXISTS {view.name} AS {view.query}")
+
+        for trigger in schema.triggers:
+            findings.append(RenderFinding(Ambiguity.UNSUPPORTED_EXPRESSION, trigger.name,
+                                           "Trigger não renderizado — corpo procedural é específico do dialeto de origem."))
+
+        return RenderResult(sql=";\n\n".join(statements) + (";" if statements else ""), findings=findings)
+
+
+register_parser("sqlite", SQLiteParser())
+register_renderer("sqlite", SQLiteRenderer())

dbbridge/dialects/sqlserver.py

@@ -0,0 +1,15 @@
+"""Dialeto SQL Server — estrutura preparada (Fase 5 do roadmap), ainda não implementado.
+
+Quando chegar a hora: `IDENTITY(1,1)` como autoincrement, `NVARCHAR`/`DATETIME2`/`UNIQUEIDENTIFIER`
+no mapa de tipos, `[colchetes]` como quoting de identificador (já previsto nos regexes de
+dialects/sqlite.py como referência de padrão a seguir), e `TOP n` no lugar de `LIMIT` (fora do
+escopo de DDL, mas relevante pro scanner/codemod quando entrar em cena).
+"""
+from __future__ import annotations
+
+from ..core.parser import register_parser
+from ..core.renderer import register_renderer
+from ._stub import NotImplementedDialectParser, NotImplementedDialectRenderer
+
+register_parser("sqlserver", NotImplementedDialectParser("sqlserver", "Fase 5"))
+register_renderer("sqlserver", NotImplementedDialectRenderer("sqlserver", "Fase 5"))

dbbridge/migration/__init__.py

@@ -0,0 +1,11 @@
+from .data_migration import DataMigrationResult, TableMigrationResult, migrate_data, migrate_table_data
+from .rollback import DatabaseSnapshot, rollback_code_changes
+from .schema_migration import SchemaMigrationResult, apply_schema, migrate_schema, render_target_ddl
+from .validator import TableValidation, ValidationReport, validate, validate_table
+
+__all__ = [
+    "migrate_schema", "render_target_ddl", "apply_schema", "SchemaMigrationResult",
+    "migrate_data", "migrate_table_data", "DataMigrationResult", "TableMigrationResult",
+    "validate", "validate_table", "ValidationReport", "TableValidation",
+    "rollback_code_changes", "DatabaseSnapshot",
+]