rosetta-sql 1.0.3__tar.gz → 1.2.0__tar.gz

{rosetta_sql-1.0.3/rosetta_sql.egg-info → rosetta_sql-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rosetta-sql
-Version: 1.0.3
+Version: 1.2.0
 Summary: Cross-DBMS SQL behavioral consistency verification tool
 Author: yangshijie
 License: MIT
@@ -27,8 +27,6 @@ Requires-Dist: rich>=13.0
 Requires-Dist: prompt_toolkit>=3.0.52
 Provides-Extra: mysql-connector
 Requires-Dist: mysql-connector-python>=8.0; extra == "mysql-connector"
-Provides-Extra: gcov
-Requires-Dist: fastcov>=1.13; extra == "gcov"
 Dynamic: license-file
 
 # Rosetta

{rosetta_sql-1.0.3 → rosetta_sql-1.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "rosetta-sql"
-version = "1.0.3"
+version = "1.2.0"
 description = "Cross-DBMS SQL behavioral consistency verification tool"
 readme = "README.md"
 license = {text = "MIT"}
@@ -34,7 +34,6 @@ dependencies = [
 
 [project.optional-dependencies]
 mysql-connector = ["mysql-connector-python>=8.0"]
-gcov = ["fastcov>=1.13"]
 
 [project.scripts]
 rosetta = "rosetta.cli:main"

rosetta_sql-1.2.0/rosetta/__init__.py

@@ -0,0 +1,11 @@
+"""Rosetta — Cross-DBMS SQL behavioral consistency verification tool."""
+
+from importlib.metadata import version as _get_version
+
+try:
+    __version__ = _get_version("rosetta-sql")
+except Exception:
+    # Fallback for editable install / development mode
+    import tomllib
+    with open(__file__ + "/../pyproject.toml", "rb") as _f:
+        __version__ = tomllib.load(_f)["project"]["version"]

rosetta_sql-1.2.0/rosetta/__main__.py

@@ -0,0 +1,6 @@
+"""Allow running as: python -m rosetta"""
+
+from .cli.main import main
+
+if __name__ == "__main__":
+    main()

{rosetta_sql-1.0.3 → rosetta_sql-1.2.0}/rosetta/cli/exec.py

@@ -82,10 +82,10 @@ def handle_exec(args, output: "OutputFormatter") -> CommandResult:
             # so the MTR parser treats each as a separate statement.
             parts = [p.strip() for p in sql_text.split(";") if p.strip()]
             sql_text_for_parse = ";\n".join(parts) + ";\n"
-            mtr_parser = MtrParser()
+            mtr_parser = MtrParser("<inline>")
             parsed = mtr_parser.parse_text(sql_text_for_parse)
         else:
-            mtr_parser = MtrParser()
+            mtr_parser = MtrParser("<inline>")
             parsed = mtr_parser.parse_text(sql_text)
         statements = [cmd.argument for cmd in parsed.commands
                       if cmd.cmd_type == MtrCommandType.SQL]

{rosetta_sql-1.0.3 → rosetta_sql-1.2.0}/rosetta/cli/main.py

@@ -94,7 +94,8 @@ def create_parser() -> argparse.ArgumentParser:
     _add_config_subparser(subparsers)
     _add_result_subparser(subparsers)
     _add_interactive_subparser(subparsers)
-    
+    _add_update_subparser(subparsers)
+
     return parser
 
 
@@ -192,27 +193,14 @@ def _add_mtr_arguments(parser):
         default=False,
         help="Enable optimistic transaction mode (--mysqld=--tdsql_trans_type=1)",
     )
-    parser.add_argument(
-        "-v", "--vector",
-        action="store_true",
-        default=False,
-        help="Enable vector engine mode (--ve-protocol)",
-    )
-    parser.add_argument(
-        "-pq", "--parallel-query",
-        action="store_true",
-        default=False,
-        help="Enable parallel query mode (--parallel-query)",
-    )
     parser.add_argument(
         "-m", "--mode",
         type=str,
         default=None,
         help="Run multiple MTR modes in parallel. "
-             "Comma-separated list of: row (行存), col (列存/ve-protocol), pq (并行查询), "
+             "Comma-separated list of: row, col, pq, "
              "or 'all' (equivalent to row,col,pq). "
-             "Example: --mode row,col,pq. "
-             "When specified, --vector and --parallel-query flags are ignored.",
+             "Example: --mode row,col,pq",
     )
     parser.add_argument(
         "-r", "--record",
@@ -588,6 +576,16 @@ def _add_interactive_subparser(subparsers):
         )
 
 
+def _add_update_subparser(subparsers):
+    """Add the 'update' subcommand."""
+    update_parser = subparsers.add_parser(
+        "update",
+        help="Update rosetta to the latest version",
+        description="Pull latest code from git and reinstall",
+    )
+    _add_global_options(update_parser)
+
+
 def main(argv: Optional[List[str]] = None) -> int:
     """
     Main entry point for the rosetta CLI.
@@ -687,6 +685,9 @@ def main(argv: Optional[List[str]] = None) -> int:
         elif args.command in ["interactive", "repl", "i"]:
             from .interactive_cmd import handle_interactive
             result = handle_interactive(args, output)
+        elif args.command == "update":
+            from .update_cmd import handle_update
+            result = handle_update(args, output)
         else:
             result = CommandResult.failure(
                 f"Unknown command: {args.command}",

{rosetta_sql-1.0.3 → rosetta_sql-1.2.0}/rosetta/cli/mtr_cmd.py

@@ -858,8 +858,6 @@ def _run_native_mtr(args, output: "OutputFormatter") -> CommandResult:
         "suite_timeout": file_cfg["suite_timeout"],
         "optimistic": False,
         "record": False,
-        "vector": False,
-        "parallel_query": False,
         "suite": None,
         "cases": [],
     }
@@ -900,8 +898,6 @@ def _run_native_mtr(args, output: "OutputFormatter") -> CommandResult:
 
     cfg["optimistic"] = getattr(args, "optimistic", False)
     cfg["record"] = getattr(args, "record", False)
-    cfg["vector"] = getattr(args, "vector", False)
-    cfg["parallel_query"] = getattr(args, "parallel_query", False)
     cfg["suite"] = getattr(args, "suite", None)
     cfg["cases"] = getattr(args, "cases", [])
 
@@ -948,16 +944,19 @@ def _run_native_mtr(args, output: "OutputFormatter") -> CommandResult:
             info_lines.append(f"[bold]Record[/bold]     : ON")
         if cfg["optimistic"]:
             info_lines.append(f"[bold]Optimistic[/bold] : ON")
-        if cfg["vector"]:
-            info_lines.append(f"[bold]Vector[/bold]     : ON")
-        if cfg["parallel_query"]:
-            info_lines.append(f"[bold]PQ[/bold]         : ON")
         console_plan.print(_Panel(
             "\n".join(info_lines),
             title="[bold cyan]MTR Execution Plan[/bold cyan]",
             title_align="left",
             padding=(0, 1),
         ))
+        # Print actual MTR command
+        console_plan.print(_Panel(
+            f"[dim]{cmd}[/dim]",
+            title="[bold cyan]Command[/bold cyan]",
+            title_align="left",
+            padding=(0, 1),
+        ))
 
     # --- 4. Execute MTR ---
     original_dir = os.getcwd()
@@ -965,10 +964,6 @@ def _run_native_mtr(args, output: "OutputFormatter") -> CommandResult:
 
     # Build mode label for progress display
     mode_parts = []
-    if cfg["vector"]:
-        mode_parts.append("ve-protocol")
-    if cfg["parallel_query"]:
-        mode_parts.append("parallel-query")
     if cfg["optimistic"]:
         mode_parts.append("optimistic")
     mode_label = "+".join(mode_parts) if mode_parts else "row (default)"
@@ -1137,8 +1132,6 @@ def _run_native_mtr(args, output: "OutputFormatter") -> CommandResult:
         "cases": cfg["cases"],
         "record": cfg["record"],
         "optimistic": cfg["optimistic"],
-        "vector": cfg["vector"],
-        "parallel_query": cfg["parallel_query"],
         "exit_code": exit_code,
         "elapsed_seconds": total_elapsed,
         "log_dir": log_dir,

rosetta_sql-1.2.0/rosetta/cli/update_cmd.py

@@ -0,0 +1,129 @@
+"""Handler for 'rosetta update' — self-update to latest PyPI version."""
+
+import json
+import subprocess
+import sys
+import urllib.request
+from importlib.metadata import version
+
+from .result import CommandResult
+
+_PYPI_JSON_URL = "https://pypi.org/pypi/rosetta-sql/json"
+_PACKAGE_NAME = "rosetta-sql"
+
+
+def handle_update(args, output) -> CommandResult:
+    """Check for updates and upgrade rosetta to the latest PyPI release.
+
+    Steps:
+      1. Query PyPI JSON API for latest version
+      2. Compare with locally installed version
+      3. If behind → pip install --upgrade rosetta-sql
+      4. If up-to-date → inform user
+    """
+    is_json = getattr(args, "json", False)
+
+    # Step 1: Get local version
+    local_ver = _get_local_version()
+
+    # Step 2: Get remote (PyPI) latest version
+    if not is_json:
+        from rich.console import Console
+        Console().print("  [dim]Checking for updates...[/dim]")
+    pypi_info = _fetch_pypi_info()
+    if pypi_info is None:
+        return CommandResult.failure(
+            "Failed to fetch version info from PyPI. Check your network.",
+        )
+    remote_ver = pypi_info["info"]["version"]
+
+    # Step 3: Compare
+    if _version_tuple(local_ver) >= _version_tuple(remote_ver):
+        if is_json:
+            return CommandResult.success(
+                "update",
+                {"status": "up_to_date", "version": local_ver,
+                 "message": f"Already at latest version ({local_ver})"},
+            )
+        else:
+            from rich.console import Console
+            Console().print(
+                f"\n  [green bold]✓[/green bold] Already up to date: "
+                f"rosetta {local_ver}\n",
+            )
+            return CommandResult.success("update")
+
+    # Step 4: Upgrade
+    if not is_json:
+        from rich.console import Console
+        console = Console()
+        console.print(f"\n  [yellow]Update available:[/yellow]")
+        console.print(f"     Current : {local_ver}")
+        console.print(f"     Latest  : {remote_ver}")
+        console.print()
+        Console().print("  [dim]Upgrading...[/dim]")
+
+    result = subprocess.run(
+        [sys.executable, "-m", "pip", "install", "--upgrade",
+         _PACKAGE_NAME, "--quiet"],
+        capture_output=True,
+        timeout=120,
+    )
+    if result.returncode != 0:
+        return CommandResult.failure(
+            f"pip install failed:\n{result.stderr.decode(errors='replace')}",
+        )
+
+    final_ver = _get_local_version()
+    if is_json:
+        return CommandResult.success(
+            "update",
+            {
+                "status": "updated",
+                "old_version": local_ver,
+                "new_version": final_ver,
+            },
+        )
+    else:
+        from rich.console import Console
+        Console().print(
+            f"\n  [green bold]✓[/green bold] Updated to "
+            f"[bold cyan]{final_ver}[/bold cyan]\n",
+        )
+        return CommandResult.success("update")
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _get_local_version() -> str:
+    try:
+        return version(_PACKAGE_NAME)
+    except Exception:
+        return "unknown"
+
+
+def _fetch_pypi_info():
+    """Query PyPI JSON API. Returns parsed dict or None on failure."""
+    try:
+        req = urllib.request.Request(_PYPI_JSON_URL, headers={"Accept": "application/json"})
+        with urllib.request.urlopen(req, timeout=15) as resp:
+            return json.loads(resp.read().decode())
+    except Exception:
+        return None
+
+
+def _version_tuple(v: str) -> tuple:
+    """Parse '1.2.3' into comparable tuple of ints."""
+    parts = []
+    for part in v.split("."):
+        # Handle suffixes like .dev1, .a1, .rc1 — treat as 0
+        num = ""
+        for ch in part:
+            if ch.isdigit():
+                num += ch
+            else:
+                break
+        parts.append(int(num) if num else 0)
+    return tuple(parts) if parts else (0,)

{rosetta_sql-1.0.3 → rosetta_sql-1.2.0}/rosetta/comparator.py

@@ -13,7 +13,12 @@ _RE_ENGINE = re.compile(r"ENGINE\s*=\s*\w+")
 _RE_CHARSET_COLLATE = re.compile(
     r"DEFAULT CHARSET=\w+(\s+COLLATE=\w+)?"
 )
-_RE_ERROR_LINE = re.compile(r"^ERROR\b[^(]*\((\d+),")
+_RE_ERROR_LINE = re.compile(r"^ERROR\b(?:\s*(\d+)|\D*\((\d+)[,:\)])")
+# OceanBase appends trace_id lines after errors like [IP:PORT] [timestamp] or [YB4Z...]
+_RE_OB_TRACE = re.compile(
+    r"^\[\d+\.\d+\.\d+\.\d+:\d+\]"       # [IP:PORT]
+    r"|\[[A-Z0-9]{8,}(-[\w]+){2,}\]"      # [OB-trace-id]
+)
 _RE_AUTO_INCREMENT = re.compile(r"\s*AUTO_INCREMENT=\d+")
 _RE_ROW_FORMAT = re.compile(r"\s*ROW_FORMAT=\w+")
 _RE_STATS_PERSISTENT = re.compile(r"\s*STATS_PERSISTENT=\d+")
@@ -30,14 +35,16 @@ def normalize_line(line: str) -> str:
     """Normalize a single output line to ignore known non-functional diffs.
 
     Handled cases:
-      - ERROR lines: only keep error code
+      - ERROR lines: only keep error code (supports both MTR "ERROR(code,"
+        and MySQL-style "ERROR 1662:" formats)
       - TDSQL tail (txid, sql-node, error-store-node)
       - ENGINE=, CHARSET=, AUTO_INCREMENT=, ROW_FORMAT=, DEFINER=, etc.
     """
     s = line
     m = _RE_ERROR_LINE.match(s)
     if m:
-        return f"ERROR: ({m.group(1)})"
+        code = m.group(1) or m.group(2)
+        return f"ERROR: ({code})"
     if s.startswith("ERROR"):
         return "ERROR: (unknown)"
     s = _RE_TDSQL_TAIL.sub("", s)
@@ -53,12 +60,14 @@ def normalize_line(line: str) -> str:
 def normalize_block(block: List[str]) -> List[str]:
     """Normalize all lines in a block for comparison.
 
-    Filters out Warning lines and the "Warnings:" header.
+    Filters out Warning lines, the "Warnings:" header, and OceanBase
+    trace_id appendages that appear after error messages.
     """
     lines = [normalize_line(l) for l in block]
     return [l for l in lines
             if l.strip() != "Warnings:"
-            and not _RE_WARNING_LINE.match(l.strip())]
+            and not _RE_WARNING_LINE.match(l.strip())
+            and not _RE_OB_TRACE.match(l.strip())]
 
 
 def filter_warnings(block: List[str]) -> List[str]: