cz-cli 0.1.0__py3-none-any.whl

cz_cli/__init__.py

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

cz_cli/commands/profile.py

@@ -0,0 +1,265 @@
+"""clickzetta profile command — manage connection profiles."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from typing import Any
+
+import click
+
+from cz_cli import output
+from cz_cli.logger import log_operation
+
+try:
+    import tomllib
+except ImportError:
+    import tomli as tomllib  # type: ignore
+
+
+_PROFILES_DIR = Path.home() / ".clickzetta"
+_PROFILES_FILE = _PROFILES_DIR / "profiles.toml"
+
+
+def _load_profiles() -> dict[str, Any]:
+    """Load profiles from ~/.clickzetta/profiles.toml"""
+    if not _PROFILES_FILE.exists():
+        return {"profiles": {}}
+
+    try:
+        with open(_PROFILES_FILE, "rb") as f:
+            return tomllib.load(f)
+    except Exception as exc:
+        return {"profiles": {}}
+
+
+def _save_profiles(data: dict[str, Any]) -> None:
+    """Save profiles to ~/.clickzetta/profiles.toml"""
+    _PROFILES_DIR.mkdir(parents=True, exist_ok=True)
+
+    # Convert to TOML format
+    lines = []
+
+    # Add default_profile at the top if it exists
+    if "default_profile" in data:
+        lines.append(f'default_profile = "{data["default_profile"]}"')
+        lines.append("")
+
+    for profile_name, profile_data in data.get("profiles", {}).items():
+        lines.append(f"[profiles.{profile_name}]")
+        for key, value in profile_data.items():
+            if isinstance(value, str):
+                lines.append(f'{key} = "{value}"')
+            else:
+                lines.append(f"{key} = {value}")
+        lines.append("")
+
+    with open(_PROFILES_FILE, "w", encoding="utf-8") as f:
+        f.write("\n".join(lines))
+
+
+@click.group("profile")
+@click.pass_context
+def profile_cmd(ctx: click.Context) -> None:
+    """Manage connection profiles."""
+
+
+@profile_cmd.command("list")
+@click.pass_context
+def list_profiles(ctx: click.Context) -> None:
+    """List all configured profiles."""
+    fmt: str = ctx.obj["format"]
+
+    try:
+        data = _load_profiles()
+        profiles = data.get("profiles", {})
+        default_profile = data.get("default_profile")
+
+        result = []
+        for name, profile_data in profiles.items():
+            result.append({
+                "name": name,
+                "username": profile_data.get("username", ""),
+                "service": profile_data.get("service", ""),
+                "instance": profile_data.get("instance", ""),
+                "workspace": profile_data.get("workspace", ""),
+                "is_default": name == default_profile,
+            })
+
+        log_operation("profile list", ok=True)
+        output.success(result, fmt=fmt)
+    except Exception as exc:
+        log_operation("profile list", ok=False, error_code="INTERNAL_ERROR")
+        output.error("INTERNAL_ERROR", str(exc), fmt=fmt)
+
+
+@profile_cmd.command("create")
+@click.argument("name")
+@click.option("--username", required=True, help="Username")
+@click.option("--password", required=True, help="Password")
+@click.option("--service", default="dev-api.clickzetta.com", help="Service endpoint")
+@click.option("--instance", required=True, help="Instance ID")
+@click.option("--workspace", required=True, help="Workspace name")
+@click.option("--schema", default="public", help="Default schema")
+@click.option("--vcluster", default="default", help="Virtual cluster")
+@click.option("--skip-verify", is_flag=True, help="Skip connection verification")
+@click.pass_context
+def create_profile(
+    ctx: click.Context,
+    name: str,
+    username: str,
+    password: str,
+    service: str,
+    instance: str,
+    workspace: str,
+    schema: str,
+    vcluster: str,
+    skip_verify: bool,
+) -> None:
+    """Create a new profile."""
+    fmt: str = ctx.obj["format"]
+
+    try:
+        data = _load_profiles()
+        profiles = data.get("profiles", {})
+
+        if name in profiles:
+            log_operation("profile create", ok=False, error_code="PROFILE_EXISTS")
+            output.error("PROFILE_EXISTS", f"Profile '{name}' already exists", fmt=fmt)
+            return
+
+        # Verify connection unless --skip-verify
+        if not skip_verify:
+            from cz_cli.connection import get_connection
+            try:
+                conn = get_connection(
+                    username=username,
+                    password=password,
+                    service=service,
+                    instance=instance,
+                    workspace=workspace,
+                    schema=schema,
+                    vcluster=vcluster,
+                )
+                # Test connection
+                cursor = conn.cursor()
+                cursor.execute("SELECT 1")
+                cursor.close()
+                conn.close()
+            except Exception as exc:
+                log_operation("profile create", ok=False, error_code="CONNECTION_FAILED")
+                output.error(
+                    "CONNECTION_FAILED",
+                    f"Failed to connect with provided credentials: {str(exc)}",
+                    fmt=fmt,
+                )
+                return
+
+        profiles[name] = {
+            "username": username,
+            "password": password,
+            "service": service,
+            "instance": instance,
+            "workspace": workspace,
+            "schema": schema,
+            "vcluster": vcluster,
+        }
+
+        data["profiles"] = profiles
+        _save_profiles(data)
+
+        log_operation("profile create", ok=True)
+        output.success({"message": f"Profile '{name}' created successfully"}, fmt=fmt)
+    except Exception as exc:
+        log_operation("profile create", ok=False, error_code="INTERNAL_ERROR")
+        output.error("INTERNAL_ERROR", str(exc), fmt=fmt)
+
+
+@profile_cmd.command("update")
+@click.argument("name")
+@click.argument("key")
+@click.argument("value")
+@click.pass_context
+def update_profile(ctx: click.Context, name: str, key: str, value: str) -> None:
+    """Update a profile field."""
+    fmt: str = ctx.obj["format"]
+
+    try:
+        data = _load_profiles()
+        profiles = data.get("profiles", {})
+
+        if name not in profiles:
+            log_operation("profile update", ok=False, error_code="PROFILE_NOT_FOUND")
+            output.error("PROFILE_NOT_FOUND", f"Profile '{name}' not found", fmt=fmt)
+            return
+
+        valid_keys = ["username", "password", "service", "instance", "workspace", "schema", "vcluster"]
+        if key not in valid_keys:
+            log_operation("profile update", ok=False, error_code="INVALID_KEY")
+            output.error("INVALID_KEY", f"Invalid key '{key}'. Valid keys: {', '.join(valid_keys)}", fmt=fmt)
+            return
+
+        profiles[name][key] = value
+        data["profiles"] = profiles
+        _save_profiles(data)
+
+        log_operation("profile update", ok=True)
+        output.success({"message": f"Profile '{name}' updated successfully"}, fmt=fmt)
+    except Exception as exc:
+        log_operation("profile update", ok=False, error_code="INTERNAL_ERROR")
+        output.error("INTERNAL_ERROR", str(exc), fmt=fmt)
+
+
+@profile_cmd.command("delete")
+@click.argument("name")
+@click.pass_context
+def delete_profile(ctx: click.Context, name: str) -> None:
+    """Delete a profile."""
+    fmt: str = ctx.obj["format"]
+
+    try:
+        data = _load_profiles()
+        profiles = data.get("profiles", {})
+
+        if name not in profiles:
+            log_operation("profile delete", ok=False, error_code="PROFILE_NOT_FOUND")
+            output.error("PROFILE_NOT_FOUND", f"Profile '{name}' not found", fmt=fmt)
+            return
+
+        del profiles[name]
+        data["profiles"] = profiles
+        _save_profiles(data)
+
+        log_operation("profile delete", ok=True)
+        output.success({"message": f"Profile '{name}' deleted successfully"}, fmt=fmt)
+    except Exception as exc:
+        log_operation("profile delete", ok=False, error_code="INTERNAL_ERROR")
+        output.error("INTERNAL_ERROR", str(exc), fmt=fmt)
+
+
+@profile_cmd.command("use")
+@click.argument("name")
+@click.pass_context
+def use_profile(ctx: click.Context, name: str) -> None:
+    """Set a profile as default."""
+    fmt: str = ctx.obj["format"]
+
+    try:
+        data = _load_profiles()
+        profiles = data.get("profiles", {})
+
+        if name not in profiles:
+            log_operation("profile use", ok=False, error_code="PROFILE_NOT_FOUND")
+            output.error("PROFILE_NOT_FOUND", f"Profile '{name}' not found", fmt=fmt)
+            return
+
+        # Set default_profile marker
+        data["default_profile"] = name
+
+        _save_profiles(data)
+
+        log_operation("profile use", ok=True)
+        output.success({"message": f"Profile '{name}' set as default"}, fmt=fmt)
+    except Exception as exc:
+        log_operation("profile use", ok=False, error_code="INTERNAL_ERROR")
+        output.error("INTERNAL_ERROR", str(exc), fmt=fmt)

cz_cli/commands/schema.py

@@ -0,0 +1,213 @@
+"""clickzetta schema command — manage schemas."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import click
+
+from cz_cli import output
+from cz_cli.connection import get_connection
+from cz_cli.logger import log_operation
+
+
+@click.group("schema")
+@click.pass_context
+def schema_cmd(ctx: click.Context) -> None:
+    """Manage schemas."""
+
+
+@schema_cmd.command("list")
+@click.option("--like", help="Filter schemas by pattern (e.g. 'test%').")
+@click.option("--limit", default=100, help="Maximum number of schemas to return (default: 100).")
+@click.pass_context
+def list_schemas(ctx: click.Context, like: str | None, limit: int) -> None:
+    """List all schemas in the current workspace."""
+    fmt: str = ctx.obj["format"]
+    profile: str | None = ctx.obj.get("profile")
+    jdbc_url: str | None = ctx.obj.get("jdbc_url")
+
+    try:
+        conn = get_connection(jdbc_url=jdbc_url, profile=profile)
+    except Exception as exc:
+        log_operation("schema list", ok=False, error_code="CONNECTION_ERROR")
+        output.error("CONNECTION_ERROR", str(exc), fmt=fmt)
+        return
+
+    timer = output.Timer()
+    try:
+        with timer:
+            cursor = conn.cursor()
+            try:
+                sql = "SHOW SCHEMAS"
+                if like:
+                    sql += f" LIKE '{like}'"
+                # Note: SHOW SCHEMAS does not support LIMIT clause, we'll limit client-side
+
+                cursor.execute(sql)
+                rows = cursor.fetchall()
+
+                # Convert tuples to dicts
+                columns = [d[0] for d in cursor.description] if cursor.description else []
+                rows_dict = [dict(zip(columns, row)) if isinstance(row, tuple) else row for row in rows]
+
+                result = []
+                for row in rows_dict:
+                    result.append({
+                        "name": row.get("schema_name", row.get("name", row.get(columns[0], "") if columns else "")),
+                        "type": row.get("type", ""),
+                    })
+
+                # Client-side limit (SHOW SCHEMAS doesn't support LIMIT clause)
+                total_count = len(result)
+                if total_count > limit:
+                    result = result[:limit]
+
+                # Add AI message if results were limited
+                ai_msg = None
+                if total_count > limit:
+                    ai_msg = f"Results limited to {limit} of {total_count} schemas. Use --limit to adjust or --like to filter."
+
+                log_operation("schema list", ok=True, time_ms=timer.elapsed_ms)
+                output.success(result, time_ms=timer.elapsed_ms, fmt=fmt, ai_message=ai_msg)
+            finally:
+                cursor.close()
+    except Exception as exc:
+        log_operation("schema list", ok=False, error_code="SQL_ERROR")
+        output.error("SQL_ERROR", str(exc), fmt=fmt)
+    finally:
+        conn.close()
+
+
+@schema_cmd.command("describe")
+@click.argument("name")
+@click.pass_context
+def describe_schema(ctx: click.Context, name: str) -> None:
+    """Show schema details including tables."""
+    fmt: str = ctx.obj["format"]
+    profile: str | None = ctx.obj.get("profile")
+    jdbc_url: str | None = ctx.obj.get("jdbc_url")
+
+    try:
+        conn = get_connection(jdbc_url=jdbc_url, profile=profile)
+    except Exception as exc:
+        log_operation("schema describe", ok=False, error_code="CONNECTION_ERROR")
+        output.error("CONNECTION_ERROR", str(exc), fmt=fmt)
+        return
+
+    timer = output.Timer()
+    try:
+        with timer:
+            cursor = conn.cursor()
+            try:
+                # Get schema info
+                cursor.execute(f"SHOW SCHEMAS EXTENDED WHERE schema_name='{name}'")
+                schema_rows = cursor.fetchall()
+
+                if not schema_rows:
+                    log_operation("schema describe", ok=False, error_code="SCHEMA_NOT_FOUND")
+                    output.error("SCHEMA_NOT_FOUND", f"Schema '{name}' not found", fmt=fmt)
+                    return
+
+                # Convert tuple to dict
+                columns = [d[0] for d in cursor.description] if cursor.description else []
+                schema_info = dict(zip(columns, schema_rows[0])) if isinstance(schema_rows[0], tuple) else schema_rows[0]
+
+                # Get tables in schema
+                cursor.execute(f"SHOW TABLES IN {name}")
+                table_rows = cursor.fetchall()
+
+                # Convert tuples to dicts
+                table_columns = [d[0] for d in cursor.description] if cursor.description else []
+                tables = []
+                for r in table_rows:
+                    if isinstance(r, tuple):
+                        row_dict = dict(zip(table_columns, r))
+                        tables.append(row_dict.get(table_columns[0], "") if table_columns else "")
+                    elif isinstance(r, dict):
+                        tables.append(list(r.values())[0] if r else "")
+                    else:
+                        tables.append(str(r))
+
+                result: dict[str, Any] = {
+                    "name": name,
+                    "type": schema_info.get("type", ""),
+                    "table_count": len(tables),
+                    "tables": tables,
+                }
+
+                log_operation("schema describe", ok=True, time_ms=timer.elapsed_ms)
+                output.success(result, time_ms=timer.elapsed_ms, fmt=fmt)
+            finally:
+                cursor.close()
+    except Exception as exc:
+        log_operation("schema describe", ok=False, error_code="SQL_ERROR")
+        output.error("SQL_ERROR", str(exc), fmt=fmt)
+    finally:
+        conn.close()
+
+
+@schema_cmd.command("create")
+@click.argument("name")
+@click.pass_context
+def create_schema(ctx: click.Context, name: str) -> None:
+    """Create a new schema."""
+    fmt: str = ctx.obj["format"]
+    profile: str | None = ctx.obj.get("profile")
+    jdbc_url: str | None = ctx.obj.get("jdbc_url")
+
+    try:
+        conn = get_connection(jdbc_url=jdbc_url, profile=profile)
+    except Exception as exc:
+        log_operation("schema create", ok=False, error_code="CONNECTION_ERROR")
+        output.error("CONNECTION_ERROR", str(exc), fmt=fmt)
+        return
+
+    timer = output.Timer()
+    try:
+        with timer:
+            cursor = conn.cursor()
+            try:
+                cursor.execute(f"CREATE SCHEMA {name}")
+                log_operation("schema create", ok=True, time_ms=timer.elapsed_ms)
+                output.success({"message": f"Schema '{name}' created successfully"}, time_ms=timer.elapsed_ms, fmt=fmt)
+            finally:
+                cursor.close()
+    except Exception as exc:
+        log_operation("schema create", ok=False, error_code="SQL_ERROR")
+        output.error("SQL_ERROR", str(exc), fmt=fmt)
+    finally:
+        conn.close()
+
+
+@schema_cmd.command("drop")
+@click.argument("name")
+@click.pass_context
+def drop_schema(ctx: click.Context, name: str) -> None:
+    """Drop a schema."""
+    fmt: str = ctx.obj["format"]
+    profile: str | None = ctx.obj.get("profile")
+    jdbc_url: str | None = ctx.obj.get("jdbc_url")
+
+    try:
+        conn = get_connection(jdbc_url=jdbc_url, profile=profile)
+    except Exception as exc:
+        log_operation("schema drop", ok=False, error_code="CONNECTION_ERROR")
+        output.error("CONNECTION_ERROR", str(exc), fmt=fmt)
+        return
+
+    timer = output.Timer()
+    try:
+        with timer:
+            cursor = conn.cursor()
+            try:
+                cursor.execute(f"DROP SCHEMA {name}")
+                log_operation("schema drop", ok=True, time_ms=timer.elapsed_ms)
+                output.success({"message": f"Schema '{name}' dropped successfully"}, time_ms=timer.elapsed_ms, fmt=fmt)
+            finally:
+                cursor.close()
+    except Exception as exc:
+        log_operation("schema drop", ok=False, error_code="SQL_ERROR")
+        output.error("SQL_ERROR", str(exc), fmt=fmt)
+    finally:
+        conn.close()