tsdb-sql-tool 0.1.0__py3-none-any.whl

sql_tool/__about__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

sql_tool/__init__.py

@@ -0,0 +1,5 @@
+"""SQL Tool - PostgreSQL query and administration tool."""
+
+from sql_tool.__about__ import __version__
+
+__all__ = ["__version__"]

sql_tool/__main__.py

@@ -0,0 +1,6 @@
+"""Module entry point for python -m sql_tool."""
+
+from sql_tool.cli.main import app
+
+if __name__ == "__main__":
+    app()

sql_tool/cli/commands/_shared.py

@@ -0,0 +1,125 @@
+"""Shared CLI plumbing for command modules.
+
+Client creation, format-option handling, and output helpers.
+Distinct from cli.helpers which contains pure data-formatting functions.
+"""
+
+from __future__ import annotations
+
+import sys
+from typing import TYPE_CHECKING, Any
+
+from sql_tool.cli.helpers import fmt_size
+from sql_tool.cli.output import get_formatter, resolve_format, write_output
+from sql_tool.core.client import PgClient
+from sql_tool.core.config import load_config, resolve_config
+
+if TYPE_CHECKING:
+    import typer
+
+    from sql_tool.cli.output import OutputFormat
+    from sql_tool.core.models import QueryResult
+
+
+def get_client(ctx: typer.Context, timeout: float | None = None) -> PgClient:
+    obj = ctx.ensure_object(dict)
+    config = load_config(obj.get("config_file"))
+
+    cli_overrides: dict[str, Any] = {}
+    for key in ("host", "port", "database", "user", "password", "schema"):
+        val = obj.get(key)
+        if val is not None:
+            cli_overrides[key] = val
+    if timeout is not None:
+        cli_overrides["timeout"] = timeout
+
+    resolved = resolve_config(
+        config,
+        profile_name=obj.get("profile"),
+        dsn=obj.get("dsn"),
+        **cli_overrides,
+    )
+
+    return PgClient(resolved)
+
+
+def format_options(ctx: typer.Context) -> dict[str, Any]:
+    obj = ctx.ensure_object(dict)
+    return {
+        "format_flag": obj.get("format"),
+        "compact": obj.get("compact", False),
+        "width": obj.get("width", 40),
+        "no_header": obj.get("no_header", False),
+    }
+
+
+def output_result(ctx: typer.Context, result: QueryResult) -> None:
+    opts = format_options(ctx)
+    formatter = get_formatter(**opts)
+    write_output(formatter, result)
+
+
+def apply_local_format_options(
+    ctx: typer.Context,
+    *,
+    format: OutputFormat | None = None,
+    table: bool = False,
+    compact: bool = False,
+    width: int | None = None,
+    no_header: bool = False,
+) -> None:
+    if format is not None or table or compact or width is not None or no_header:
+        obj = ctx.ensure_object(dict)
+        if format is not None:
+            obj["format"] = format.value
+        if table:
+            obj["format"] = "table"
+        if compact:
+            obj["compact"] = compact
+        if width is not None:
+            obj["width"] = width
+        if no_header:
+            obj["no_header"] = no_header
+
+
+def is_table_format(ctx: typer.Context) -> bool:
+    obj = ctx.ensure_object(dict)
+    return resolve_format(obj.get("format")) == "table"
+
+
+def size_formatter(ctx: typer.Context) -> tuple[Any, bool]:
+    is_tbl = is_table_format(ctx)
+    fmt = fmt_size if is_tbl else (lambda b: str(b or 0))
+    return fmt, is_tbl
+
+
+def parse_table_arg(table_arg: str) -> tuple[str, str]:
+    if "." in table_arg:
+        schema, table = table_arg.split(".", 1)
+        return schema, table
+    return "public", table_arg
+
+
+def preprocess_optional_int_flags() -> None:
+    """Insert default '10' after bare --head/--tail/--sample when used without a value.
+
+    Typer 0.23 doesn't support Click's flag_value parameter, so these options
+    always require an explicit argument. This preprocessor lets users write
+    ``--head`` instead of ``--head 10`` by inserting the default before Typer
+    parses argv.
+    """
+    if "table" not in sys.argv:
+        return
+    flags = {"--head", "--tail", "--sample"}
+    new_argv: list[str] = []
+    i = 0
+    while i < len(sys.argv):
+        new_argv.append(sys.argv[i])
+        if sys.argv[i] in flags:
+            next_is_value = i + 1 < len(sys.argv) and not sys.argv[i + 1].startswith(
+                "-"
+            )
+            if not next_is_value:
+                new_argv.append("10")
+        i += 1
+    sys.argv = new_argv

sql_tool/cli/commands/config.py

@@ -0,0 +1,118 @@
+"""Configuration management CLI commands."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import typer
+
+from sql_tool.core.config import DEFAULT_CONFIG_PATH, load_config, resolve_config
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+    from sql_tool.core.config import ResolvedConfig
+
+config_app = typer.Typer(help="Configuration management commands")
+
+
+@config_app.callback(invoke_without_command=True)
+def config_callback(ctx: typer.Context) -> None:
+    if not ctx.invoked_subcommand:
+        typer.echo(ctx.get_help())
+        raise typer.Exit()
+
+
+def _get_resolved_config(ctx: typer.Context) -> tuple[ResolvedConfig, Path | None]:
+    config_path: Path | None = ctx.obj.get("config_file")
+    app_config = load_config(config_path)
+    resolved = resolve_config(
+        app_config,
+        profile_name=ctx.obj.get("profile"),
+        dsn=ctx.obj.get("dsn"),
+        host=ctx.obj.get("host"),
+        port=ctx.obj.get("port"),
+        database=ctx.obj.get("database"),
+        user=ctx.obj.get("user"),
+        password=ctx.obj.get("password"),
+    )
+    return resolved, config_path
+
+
+def _mask_password(value: str | None) -> str:
+    if value is None:
+        return "not set"
+    return "***"
+
+
+@config_app.command("show")
+def config_show(ctx: typer.Context) -> None:
+    """Display resolved configuration with source attribution."""
+    resolved, config_path = _get_resolved_config(ctx)
+    sources = resolved.sources
+
+    typer.echo("Connection Settings (resolved):")
+    connection_fields = [
+        ("host", resolved.host),
+        ("port", str(resolved.port)),
+        ("database", resolved.dbname),
+        ("user", resolved.user or "not set"),
+        ("password", _mask_password(resolved.password)),
+        ("sslmode", resolved.sslmode),
+    ]
+    for field_name, value in connection_fields:
+        source_key = "dbname" if field_name == "database" else field_name
+        source = sources.get(source_key, "default")
+        typer.echo(f"  {field_name}: {value} ({source})")
+
+    typer.echo("")
+    typer.echo("General:")
+    timeout_source = sources.get("default_timeout", "default")
+    typer.echo(f"  timeout: {resolved.default_timeout}s ({timeout_source})")
+    format_source = sources.get("default_format", "default")
+    typer.echo(f"  format: {resolved.default_format} ({format_source})")
+
+    typer.echo("")
+    if resolved.active_profile:
+        typer.echo(f"Active Profile: {resolved.active_profile}")
+    else:
+        typer.echo("Active Profile: none")
+
+    display_path = config_path or DEFAULT_CONFIG_PATH
+    typer.echo(f"Config File: {display_path}")
+
+
+@config_app.command("profiles")
+def config_profiles(ctx: typer.Context) -> None:
+    """List available connection profiles."""
+    config_path: Path | None = ctx.obj.get("config_file")
+    app_config = load_config(config_path)
+    active_profile = ctx.obj.get("profile") or None
+
+    if not app_config.profiles:
+        typer.echo("No profiles configured.")
+        display_path = config_path or DEFAULT_CONFIG_PATH
+        typer.echo(f"Add profiles to: {display_path}")
+        return
+
+    typer.echo("Available Profiles:")
+    typer.echo("")
+    for name, profile in sorted(app_config.profiles.items()):
+        is_active = name == active_profile
+        marker = "* " if is_active else "  "
+        label = " (active)" if is_active else ""
+        typer.echo(f"{marker}{name}{label}")
+
+        display_fields = [
+            ("host", profile.host),
+            ("port", str(profile.port)),
+            ("database", profile.dbname),
+        ]
+        if profile.user:
+            display_fields.append(("user", profile.user))
+        if profile.sslmode != "prefer":
+            display_fields.append(("sslmode", profile.sslmode))
+
+        for field_name, value in display_fields:
+            typer.echo(f"      {field_name}: {value}")
+        typer.echo("")

sql_tool/cli/commands/query.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from typing import Annotated
+
+import structlog
+import typer
+
+from sql_tool.cli.commands._shared import get_client, output_result
+from sql_tool.core.query_source import resolve_query_source
+
+log = structlog.get_logger()
+
+
+def query_command(
+    ctx: typer.Context,
+    file: Annotated[
+        str | None,
+        typer.Argument(help="SQL file to execute"),
+    ] = None,
+    execute: Annotated[
+        str | None,
+        typer.Option("--execute", "-e", help="Execute inline SQL query"),
+    ] = None,
+    timeout: Annotated[
+        float | None,
+        typer.Option("--timeout", "-t", help="Query timeout in seconds"),
+    ] = None,
+) -> None:
+    """Execute a SQL query from file, inline (-e), or stdin."""
+    sql = resolve_query_source(inline=execute, file_path=file)
+
+    with get_client(ctx, timeout=timeout) as client:
+        result = client.execute_query(sql)
+
+    output_result(ctx, result)

sql_tool/cli/commands/service.py

@@ -0,0 +1,94 @@
+"""Service and maintenance CLI commands.
+
+Thin CLI layer: typer decorators, argument parsing, output formatting.
+Business logic delegated to core.postgres module.
+"""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+
+from sql_tool.cli.commands._shared import get_client, output_result
+from sql_tool.core.postgres import (
+    check_server,
+    kill_backend,
+    list_user_tables,
+    vacuum_tables,
+)
+
+service_app = typer.Typer(help="Service and maintenance commands")
+
+
+@service_app.callback(invoke_without_command=True)
+def service_callback(
+    ctx: typer.Context,
+) -> None:
+    if not ctx.invoked_subcommand:
+        typer.echo(ctx.get_help())
+        raise typer.Exit()
+
+
+@service_app.command("vacuum")
+def vacuum_command(
+    ctx: typer.Context,
+    table_arg: Annotated[
+        str | None,
+        typer.Argument(help="Table name to vacuum"),
+    ] = None,
+    full: Annotated[
+        bool,
+        typer.Option("--full", help="Run VACUUM FULL (locks table, rewrites)"),
+    ] = False,
+    all_tables: Annotated[
+        bool,
+        typer.Option("--all", help="Vacuum all user tables"),
+    ] = False,
+) -> None:
+    """VACUUM marks dead rows as reusable. VACUUM FULL rewrites tables but requires exclusive lock."""
+    if not table_arg and not all_tables:
+        typer.echo("Error: Must specify table name or --all", err=True)
+        raise typer.Exit(2)
+
+    with get_client(ctx) as client:
+        table_names = list_user_tables(client) if all_tables else [table_arg]  # type: ignore[list-item]
+
+        count = vacuum_tables(client, table_names, full=full)
+
+    typer.echo(f"Vacuumed {count} table(s)")
+
+
+@service_app.command("kill")
+def kill_command(
+    ctx: typer.Context,
+    pid: Annotated[int, typer.Argument(help="Backend process ID to terminate")],
+    cancel: Annotated[
+        bool,
+        typer.Option("--cancel", help="Cancel query only (don't kill connection)"),
+    ] = False,
+) -> None:
+    """pg_terminate_backend() kills the connection. pg_cancel_backend() cancels query but keeps connection alive."""
+    with get_client(ctx) as client:
+        success = kill_backend(client, pid, cancel=cancel)
+
+    action = "Cancelled" if cancel else "Terminated"
+    if success:
+        typer.echo(f"{action} backend {pid}")
+    else:
+        typer.echo(f"Error: Backend {pid} not found or already terminated", err=True)
+        raise typer.Exit(1)
+
+
+@service_app.command("check")
+def check_command(ctx: typer.Context) -> None:
+    """
+    Check PostgreSQL server connectivity and version.
+
+    Reports server version, current database, connected user, and uptime.
+    Useful for verifying connection parameters and server availability.
+    """
+    with get_client(ctx) as client:
+        result = check_server(client)
+
+    output_result(ctx, result)