execsql2 2.23.1__py3-none-any.whl → 2.25.0__py3-none-any.whl

execsql/format.py

@@ -17,12 +17,12 @@ import re
 from collections.abc import Iterator
 from pathlib import Path
 
-__all__ = ["collect_paths", "format_file", "main", "parse_keyword"]
+__all__ = ["collect_paths", "format_file", "open_dollar_quote", "parse_keyword", "run_formatter"]
 
 
 _SQLGLOT_MISSING_MSG = (
-    "execsql-format requires sqlglot for SQL reformatting.\n"
-    "  Install with:  pip install execsql2[formatter]\n"
+    "execsql format requires sqlglot for SQL reformatting.\n"
+    '  Install the formatter extra:  uv tool install "execsql2[formatter]"  (or pip install "execsql2[formatter]")\n'
     "  Or skip SQL reformatting with the --no-sql flag."
 )
 
@@ -122,7 +122,7 @@ CONTINUATION = frozenset({"ANDIF", "ORIF"})  # emit at depth-1, no depth change
 # Inline IF: "IF (cond) { command }" — self-contained, no ENDIF, no depth
 # change. Pattern must accept the same payloads as
 # src/execsql/script/parser.py:_IF_INLINE_RX. Kept as a separate compiled
-# pattern (not an import) so execsql-format doesn't pull in the AST parser
+# pattern (not an import) so the formatter doesn't pull in the AST parser
 # module graph at startup; tests/test_format.py has a drift check that
 # asserts both regexes recognise the same inputs.
 _IF_INLINE_RE = re.compile(r"^\s*IF\s*\(\s*.+\s*\)\s*\{.+\}\s*$", re.I)
@@ -286,6 +286,33 @@ def _iter_sql_spans(sql: str) -> Iterator[tuple[int, int, str]]:
         i += 1
 
 
+def open_dollar_quote(sql: str, open_tag: str | None = None) -> str | None:
+    """The dollar-quote tag (``$$`` or ``$tag$``) still open at the end of *sql*, or ``None``.
+
+    *open_tag* is a tag already open where *sql* starts, as when a script is
+    split at a ``;`` inside a dollar-quoted body and *sql* is a later piece.
+    Comments, quoted identifiers and ``'...'`` literals are skipped, so a
+    ``$$`` inside them is not taken for a marker.
+    """
+    start = 0
+    if open_tag is not None:
+        close = sql.find(open_tag)
+        if close < 0:
+            return open_tag
+        start = close + len(open_tag)
+    rest = sql[start:]
+    for span_start, span_stop, kind in _iter_sql_spans(rest):
+        if kind != "dollar":
+            continue
+        m = _DOLLAR_QUOTE_RE.match(rest, span_start)
+        assert m is not None
+        tag = m.group(0)
+        body = rest[span_start:span_stop]
+        if len(body) < 2 * len(tag) or not body.endswith(tag):
+            return tag
+    return None
+
+
 def _iter_sql_literals(sql: str) -> Iterator[tuple[int, int, str]]:
     """Yield ``(start, end, kind)`` spans for every string literal in *sql*.
 
@@ -1204,90 +1231,102 @@ def collect_paths(inputs: list[Path]) -> list[Path]:
 
 
 # ---------------------------------------------------------------------------
-# Entry point (execsql-format)
+# Entry point (execsql format)
 # ---------------------------------------------------------------------------
 
 
-def main() -> None:
-    """CLI entry point for the execsql-format console script."""
+def run_formatter(
+    targets: list[Path],
+    *,
+    check: bool = False,
+    in_place: bool = False,
+    no_sql: bool = False,
+    indent: int = 4,
+    leading_comma: bool = False,
+    encoding: str = "utf-8",
+    diff: bool = False,
+) -> int:
+    """Format or check *targets*; return the process exit code.
+
+    The options are declared once, on the ``execsql format`` command, and
+    arrive here as arguments. Previously they lived on a Typer app built
+    inside ``main()``, which meant the command that wrapped it had no options
+    of its own to show and ``execsql format --help`` listed nothing.
+
+    With *diff*, nothing is written: each file that would change is printed
+    as a unified diff, and the exit code is 1 when any would, as for *check*.
+    """
     import sys
 
-    import typer
     from rich.console import Console
 
     _console = Console()
     _err_console = Console(stderr=True)
 
-    app = typer.Typer(
-        name="execsql-format",
-        help="Format execsql scripts: normalize metacommand indentation and uppercase keywords.",
-        rich_markup_mode="rich",
-        no_args_is_help=True,
-        add_completion=False,
-    )
+    use_sql = not no_sql
+    paths = collect_paths(targets)
+    if not paths:
+        _err_console.print("[bold red]Error:[/bold red] No .sql files found.")
+        return 1
+
+    any_changed = False
+    any_errors = False
+    for path in paths:
+        stdin = str(path) == "-"
+        label = "<stdin>" if stdin else str(path)
+        try:
+            source = sys.stdin.buffer.read().decode(encoding) if stdin else path.read_text(encoding=encoding)
+        except OSError as exc:
+            _err_console.print(f"[bold red]Error:[/bold red] reading {label}: {exc}")
+            any_errors = True
+            # Collect read errors instead of short-circuiting so a single
+            # unreadable file doesn't hide the rest of the report.
+            continue
+        except UnicodeDecodeError as exc:
+            _err_console.print(
+                f"[bold red]Error:[/bold red] decoding {label} as {encoding}: {exc}. "
+                f"Try [bold]--script-encoding cp1252[/bold] or another text encoding.",
+            )
+            any_errors = True
+            continue
 
-    @app.command(context_settings={"allow_extra_args": False})
-    def _cmd(
-        targets: list[Path] = typer.Argument(
-            ...,
-            metavar="FILE_OR_DIR",
-            help="Files or directories to format. Directories are searched recursively for *.sql files.",
-        ),
-        check: bool = typer.Option(False, "--check", help="Exit 1 if any file needs changes (don't write)."),
-        in_place: bool = typer.Option(False, "-i", "--in-place", help="Modify files in place."),
-        no_sql: bool = typer.Option(False, "--no-sql", help="Skip SQL formatting via sqlglot."),
-        indent: int = typer.Option(4, "--indent", metavar="N", help="Spaces per indent level."),
-        leading_comma: bool = typer.Option(
-            False,
-            "--leading-comma",
-            help="Place commas at the start of lines instead of the end.",
-        ),
-        encoding: str = typer.Option(
-            "utf-8",
-            "--encoding",
-            metavar="NAME",
-            help="Text encoding used to read and write SQL files (default utf-8).",
-        ),
-    ) -> None:
-        use_sql = not no_sql
-        paths = collect_paths(targets)
-        if not paths:
-            _err_console.print("[bold red]Error:[/bold red] No .sql files found.")
-            raise typer.Exit(code=1)
-
-        any_changed = False
-        any_errors = False
-        for path in paths:
-            try:
-                source = path.read_text(encoding=encoding)
-            except OSError as exc:
-                _err_console.print(f"[bold red]Error:[/bold red] reading {path}: {exc}")
-                any_errors = True
-                # Collect read errors instead of short-circuiting so a single
-                # unreadable file doesn't hide the rest of the report.
-                continue
-            except UnicodeDecodeError as exc:
-                _err_console.print(
-                    f"[bold red]Error:[/bold red] decoding {path} as {encoding}: {exc}. "
-                    f"Try [bold]--encoding cp1252[/bold] or another text encoding.",
-                )
-                any_errors = True
-                continue
+        formatted = format_file(source, indent=indent, use_sql=use_sql, leading_comma=leading_comma)
+
+        if diff:
+            if formatted != source:
+                any_changed = True
+                _write_diff(source, formatted, label)
+        elif check:
+            if formatted != source:
+                _console.print(f"would reformat {label}")
+                any_changed = True
+        elif in_place:
+            if formatted != source:
+                path.write_text(formatted, encoding=encoding)
+                _console.print(f"reformatted {path}")
+        else:
+            sys.stdout.write(formatted)
 
-            formatted = format_file(source, indent=indent, use_sql=use_sql, leading_comma=leading_comma)
+    return 1 if (any_errors or ((check or diff) and any_changed)) else 0
 
-            if check:
-                if formatted != source:
-                    _console.print(f"would reformat {path}")
-                    any_changed = True
-            elif in_place:
-                if formatted != source:
-                    path.write_text(formatted, encoding=encoding)
-                    _console.print(f"reformatted {path}")
-            else:
-                sys.stdout.write(formatted)
 
-        if any_errors or (check and any_changed):
-            raise typer.Exit(code=1)
+def _write_diff(before: str, after: str, label: str) -> None:
+    """Print a unified diff of one file, colored when stdout is a terminal."""
+    import difflib
+    import sys
+
+    from execsql.utils.color import color_disabled_by_env
 
-    app()
+    lines = difflib.unified_diff(
+        before.splitlines(keepends=True),
+        after.splitlines(keepends=True),
+        fromfile=label,
+        tofile=label,
+    )
+    color = sys.stdout.isatty() and not color_disabled_by_env()
+    styles = {"+": "\033[32m", "-": "\033[31m", "@": "\033[36m"}
+    for line in lines:
+        if not line.endswith("\n"):
+            line += "\n\\n"
+        style = styles.get(line[0]) if color and not line.startswith(("+++", "---")) else None
+        sys.stdout.write(f"{style}{line.rstrip(chr(10))}\033[0m\n" if style else line)

execsql/gui/desktop.py

@@ -162,7 +162,6 @@ class MsgDialog:
 class PauseDialog:
     def __init__(self, root: tk.Tk, args: dict) -> None:
         self.result: dict = {}
-        self._quit = False
 
         win = tk.Toplevel(root)
         win.title(args.get("title", "Pause"))
@@ -177,7 +176,6 @@ class PauseDialog:
         )
 
         countdown = args.get("countdown")
-        self._remaining = countdown
 
         status_var = tk.StringVar(value="")
         ttk.Label(frame, textvariable=status_var).pack()
@@ -897,7 +895,7 @@ class MapDialog:
                 frame,
                 text=(
                     "(Interactive map requires the tkintermapview package — "
-                    "`pip install execsql2[map]` — showing tabular data)"
+                    "install the map extra, execsql2[map] — showing tabular data)"
                 ),
                 wraplength=580,
                 justify="left",

execsql/gui/tui.py

@@ -12,7 +12,7 @@ SQL script in a background thread and keeps the main thread for the Textual
 ``_state.gui_manager_queue``; the conductor polls that queue and serves each
 request by pushing the appropriate ``ModalScreen`` via ``push_screen_wait()``.
 
-Install with: pip install "execsql2[tui]"
+Textual is a dependency of execsql2, so it is installed with the package.
 """
 
 from __future__ import annotations
@@ -33,7 +33,7 @@ try:
     import textual  # noqa: F401
 except ImportError as _e:
     raise ImportError(
-        "Textual is not installed. Install it with: pip install 'execsql2[tui]'",
+        "Textual is not installed. It is a dependency of execsql2; reinstall execsql2 to restore it.",
     ) from _e
 
 from textual import on

execsql/importers/base.py

@@ -16,7 +16,39 @@ from execsql.exceptions import ErrInfo
 from execsql.db.base import Database
 import execsql.state as _state
 
-__all__ = ["import_data_table"]
+__all__ = ["import_data_table", "refuse_existing_table", "table_exists_if_known"]
+
+
+def table_exists_if_known(db: Database, table_name: str, schema_name: str | None = None) -> bool | None:
+    """Whether the table exists, or ``None`` when the database cannot say (no catalog access, ...)."""
+    try:
+        return db.table_exists(table_name, schema_name)
+    except Exception:
+        return None
+
+
+def refuse_existing_table(db: Database, schema_name: str | None, table_name: str) -> None:
+    """Stop a ``TO NEW`` before any DDL when the target table already exists.
+
+    Only the schema the CREATE TABLE will use counts: for an unqualified
+    name, the database's current schema (MySQL: database).  Best effort:
+    when the database cannot say, the command goes ahead and the CREATE
+    TABLE reports any conflict itself.
+    """
+    lookup_schema = schema_name
+    if schema_name is None and not db.unqualified_lookup_is_scoped:
+        try:
+            lookup_schema = db.current_schema()
+        except Exception:
+            lookup_schema = None
+        if lookup_schema is None:
+            return  # An unqualified lookup would search every schema.
+    if table_exists_if_known(db, table_name, lookup_schema):
+        name = db.schema_qualified_table_name(schema_name, table_name)
+        raise ErrInfo(
+            type="cmd",
+            other_msg=f"Table {name} already exists",
+        )
 
 
 def import_data_table(
@@ -74,6 +106,8 @@ def import_data_table(
         return tablespec_cache
 
     if is_new:
+        if is_new == 1:
+            refuse_existing_table(db, schemaname, tablename)
         if is_new == 2:
             tblspec = db.schema_qualified_table_name(schemaname, tablename)
             try:

execsql/importers/csv.py

@@ -14,6 +14,7 @@ from typing import Any
 
 from execsql.exceptions import ErrInfo
 from execsql.db.base import Database
+from execsql.importers.base import refuse_existing_table
 import execsql.state as _state
 from execsql.types import dbt_firebird
 
@@ -26,7 +27,6 @@ def importtable(
     tablename: str,
     filename: str,
     is_new: Any,
-    skip_header_line: bool = True,
     quotechar: str | None = None,
     delimchar: str | None = None,
     encoding: str | None = None,
@@ -49,6 +49,8 @@ def importtable(
             quotechar = None
         inf.lineformat(delimchar, quotechar, None)
     if is_new in (1, 2):
+        if is_new == 1:
+            refuse_existing_table(db, schemaname, tablename)
         inf.evaluate_column_types()
         sql = inf.create_table(db.type, schemaname, tablename)
         if is_new == 2:

execsql/interactive.py

@@ -0,0 +1,232 @@
+"""The engine behind the debug REPL a ``BREAKPOINT`` (or ``run --debug``) opens.
+
+Input runs as the next lines of the paused script
+(:func:`~execsql.script.executor.execute_input`): where the script paused, in
+its variable scope and transaction.
+
+What runs, and how it runs, follows script rules:
+
+- SQL ends with ``;`` and may span lines. Variables are substituted, and each
+  statement is committed unless ``AUTOCOMMIT OFF`` or a batch is in effect.
+  Results print as tables.
+- A metacommand is typed as in a script (``-- !x! EXPORT …``) or without the
+  comment marker (``!x! EXPORT …``).
+- A block (``IF`` … ``ENDIF``, ``LOOP``, ``BEGIN BATCH``, ``BEGIN SCRIPT``)
+  keeps the prompt reading until it is closed, then runs as a whole.
+
+The one difference from a script: an error that would halt the run ends only
+the input that caused it. The prompt reports it and reads the next input.
+``HALT`` still ends the run.
+
+A line starting with ``.`` is a command to the prompt itself. :class:`Prompt`
+holds a prompt's name and its own commands; ``.vars``, ``.set``, ``.scripts``
+and ``.cancel`` are handled here for any prompt.
+
+Display helpers (colors, tables, variable listings) live in
+:mod:`execsql.debug.repl` and are reached through the module, so tests that
+patch them there see every caller.
+"""
+
+from __future__ import annotations
+
+
+import execsql.state as _state
+from execsql.exceptions import ErrInfo
+
+__all__ = ["Prompt", "read_eval_loop", "run_input", "uncommitted"]
+
+
+class Prompt:
+    """What differs between the prompts; subclassed by each.
+
+    Attributes:
+        name: The prompt text before ``>``, e.g. ``execsql``.
+        source: The name input is given in messages and ``$CURRENT_SCRIPT``.
+    """
+
+    name = "execsql"
+    source = "<prompt>"
+
+    def dot_command(self, command: str, argument: str, line: str) -> bool:
+        """Handle a ``.`` command; return ``False`` to leave the prompt.
+
+        *command* is the lowercased word after the dot, *argument* the rest
+        of the line as typed.
+        """
+        if not common_dot_command(command, argument, line):
+            unknown_dot_command(line)
+        return True
+
+
+def uncommitted() -> bool:
+    """Whether SQL run now waits for a commit: ``AUTOCOMMIT OFF`` or an open batch."""
+    status = _state.status
+    if status is not None and status.batch.in_batch():
+        return True
+    dbs = _state.dbs
+    if dbs is None:
+        return False
+    try:
+        db = dbs.current()
+    except Exception:
+        return False
+    return db is not None and not db.autocommit
+
+
+def _prompts(prompt: Prompt) -> tuple[str, str]:
+    """The prompt and continuation-line strings; ``*`` marks uncommitted mode."""
+    first = f"{prompt.name}{'*' if uncommitted() else ''}> "
+    return first, "...> ".rjust(len(first))
+
+
+def _is_metacommand(line: str) -> bool:
+    stripped = line.strip()
+    return stripped.startswith("--") and stripped[2:].lstrip().lower().startswith("!x!")
+
+
+def _complete(line: str) -> bool:
+    """Whether input ending with *line* may be whole: it ends with ``;`` or is a metacommand."""
+    return line.rstrip().endswith(";") or _is_metacommand(line)
+
+
+def _one_line(text: str) -> str:
+    return " ".join(text.split())
+
+
+def describe_error(exc: BaseException) -> str:
+    """One line for a prompt: the driver's or handler's own message, and where it came from."""
+    from execsql.debug import repl as _ui
+
+    label = "Error:"
+    if isinstance(exc, ErrInfo):
+        cause = exc.__cause__
+        if isinstance(cause, Exception) and not isinstance(cause, ErrInfo) and str(cause):
+            message = str(cause)
+        else:
+            message = exc.other or exc.exception or exc.type
+            if exc.command and exc.command not in message:
+                message = f"{message}: {exc.command}"
+        if exc.cmdtype == "sql":
+            label = "SQL error:"
+        source = exc.script_file
+        if source and not (source.startswith("<") and source.endswith(">")) and exc.script_line_no:
+            message = f"{message} (line {exc.script_line_no} of {source})"
+    else:
+        message = str(exc) or type(exc).__name__
+    return f"{_ui._c(_ui._RED, label)} {_one_line(message)}"
+
+
+def _show_result(result: tuple[list[str], list] | None) -> None:
+    """Print a statement's rows as a table, or how many rows it changed."""
+    from execsql.debug import repl as _ui
+
+    if result is not None:
+        _ui._print_table(*result)
+        return
+    count = -1
+    if _state.subvars is not None:
+        try:
+            count = int(_state.subvars.varvalue("$LAST_ROWCOUNT") or -1)
+        except (TypeError, ValueError):
+            count = -1
+    word = "row" if count == 1 else "rows"
+    _ui._write(f"  {_ui._c(_ui._DIM, f'({count} {word} affected)' if count >= 0 else '(statement executed)')}\n")
+
+
+def run_input(text: str, source: str) -> None:
+    """Parse *text* and run it as the next lines of the run; errors are raised."""
+    from execsql.script.executor import execute_input
+    from execsql.script.parser import parse_string
+
+    execute_input(parse_string(text + "\n", source), _show_result)
+
+
+def common_dot_command(command: str, argument: str, line: str) -> bool:
+    """Handle a command both prompts share; return ``False`` if *command* is not one."""
+    from execsql.debug import repl as _ui
+
+    if command in ("vars", "v"):
+        if argument.lower() == "all":
+            _ui._print_all_vars(include_env=True)
+        elif argument:
+            _ui._print_var(argument)
+        else:
+            _ui._print_all_vars()
+    elif command in ("set", "s"):
+        parts = argument.split(None, 1)
+        if not parts:
+            _ui._write(f"  Usage: .{command} VAR VALUE\n")
+        else:
+            _ui._set_var(parts[0], parts[1] if len(parts) > 1 else "")
+    elif command == "scripts":
+        if argument:
+            _ui._print_script_detail(argument)
+        else:
+            _ui._print_scripts()
+    else:
+        return False
+    return True
+
+
+def unknown_dot_command(line: str) -> None:
+    from execsql.debug import repl as _ui
+
+    _ui._write(f"  {_ui._c(_ui._RED, 'Unknown command:')} {line!r}. Type '.help' for available commands.\n")
+
+
+def read_eval_loop(prompt: Prompt) -> None:
+    """Read and run inputs until the prompt's own command ends it, or input ends.
+
+    Lines are read with ``input()`` (line editing, a prompt). Ctrl-D or
+    Ctrl-C discards a half-typed input, and on an empty line leaves the
+    prompt.
+    """
+    from execsql.debug import repl as _ui
+
+    buffer: list[str] = []
+    while True:
+        first, more = _prompts(prompt)
+        try:
+            line = input(more if buffer else first)
+        except (EOFError, KeyboardInterrupt):
+            if buffer:
+                buffer.clear()
+                _ui._write("\n  (input discarded)\n")
+                continue
+            _ui._write("\n")
+            return
+        stripped = line.strip()
+        if not stripped and not buffer:
+            continue
+        if stripped.startswith("."):
+            command, _, argument = stripped[1:].partition(" ")
+            command = command.lower()
+            if command == "cancel":
+                if buffer:
+                    buffer.clear()
+                    _ui._write("  (input discarded)\n")
+                continue
+            try:
+                if not prompt.dot_command(command, argument.strip(), stripped):
+                    return
+            except (SystemExit, KeyboardInterrupt):
+                raise
+            except Exception as exc:
+                _ui._write(f"  {describe_error(exc)}\n")
+            continue
+        if stripped.lower().startswith("!x!"):
+            line = "-- " + stripped
+        buffer.append(line)
+        if not _complete(line):
+            continue
+        try:
+            run_input("\n".join(buffer), prompt.source)
+        except ErrInfo as exc:
+            if "at end of file" in str(exc):
+                continue  # a block is still open; keep reading
+            _ui._write(f"  {describe_error(exc)}\n")
+        except KeyboardInterrupt:
+            _ui._write("\n  (interrupted)\n")
+        except Exception as exc:
+            _ui._write(f"  {describe_error(exc)}\n")
+        buffer.clear()