db-agent-kit 0.2.0__py3-none-any.whl

db_agent/engines/sqlserver/usage.py

@@ -0,0 +1,127 @@
+"""Report usage from the SSRS execution log (ExecutionLog3) or an exported CSV.
+
+Only counts are kept. User names are used to count distinct users and are then dropped.
+
+Important: SSRS keeps the execution log for 60 days by default (ExecutionLogDaysKept). A report
+that runs once a year looks unused in a 60-day log. So every result carries the log window, and
+the classifier refuses to say "retire" unless the window covers the retire period.
+"""
+
+from __future__ import annotations
+
+import csv
+from dataclasses import dataclass
+from datetime import datetime, timedelta
+from pathlib import Path
+
+from .db import SafeConnection
+
+Q_USAGE = """
+SELECT ItemPath,
+       MAX(TimeStart) AS last_run,
+       SUM(CASE WHEN TimeStart >= DATEADD(day, -90, GETDATE()) THEN 1 ELSE 0 END) AS runs_90,
+       SUM(CASE WHEN TimeStart >= DATEADD(day, -365, GETDATE()) THEN 1 ELSE 0 END) AS runs_365,
+       COUNT(DISTINCT UserName) AS distinct_users,
+       AVG(CAST(DATEDIFF(millisecond, TimeStart, TimeEnd) AS bigint)) AS avg_ms,
+       SUM(CASE WHEN Status <> 'rsSuccess' THEN 1 ELSE 0 END) AS errors
+FROM dbo.ExecutionLog3
+WHERE RequestType IN ('Interactive', 'Subscription')
+GROUP BY ItemPath
+"""
+Q_WINDOW = "SELECT MIN(TimeStart) AS oldest, MAX(TimeStart) AS newest, COUNT(*) AS entries FROM dbo.ExecutionLog3"
+
+
+@dataclass
+class ReportUsage:
+    last_run: datetime | None = None
+    runs_90: int = 0
+    runs_365: int = 0
+    distinct_users: int = 0
+    avg_ms: int | None = None
+    errors: int = 0
+
+
+@dataclass
+class UsageData:
+    by_path: dict[str, ReportUsage]
+    oldest: datetime | None
+    newest: datetime | None
+    as_of: datetime
+    source: str  # "executionlog3" | "csv"
+
+    @property
+    def window_days(self) -> int:
+        """How many days back the log reaches. 0 when the log is empty."""
+        if self.oldest is None:
+            return 0
+        return max(0, (self.as_of - self.oldest).days)
+
+    def get(self, path: str) -> ReportUsage:
+        return self.by_path.get(path.lower(), ReportUsage())
+
+
+def _parse_dt(value: str) -> datetime | None:
+    value = (value or "").strip()
+    if not value:
+        return None
+    for fmt in ("%Y-%m-%d %H:%M:%S", "%Y-%m-%dT%H:%M:%S", "%Y-%m-%d", "%Y-%m-%d %H:%M:%S.%f", "%m/%d/%Y %H:%M:%S", "%m/%d/%Y"):
+        try:
+            return datetime.strptime(value[:26] if "." in value else value, fmt)
+        except ValueError:
+            continue
+    try:
+        return datetime.fromisoformat(value.replace("Z", "")).replace(tzinfo=None)
+    except ValueError:
+        return None
+
+
+def load_csv(path: Path, as_of: datetime | None = None) -> UsageData:
+    """Columns follow ExecutionLog3: ItemPath, UserName, TimeStart, TimeEnd, Status, RequestType.
+    Only ItemPath and TimeStart are required."""
+    as_of = as_of or datetime.now()
+    rows: dict[str, list[dict]] = {}
+    oldest = newest = None
+    with open(path, newline="", encoding="utf-8-sig") as fh:
+        reader = csv.DictReader(fh)
+        header = {h.lower(): h for h in (reader.fieldnames or [])}
+        for need in ("itempath", "timestart"):
+            if need not in header:
+                raise ValueError(f"usage CSV needs a column named {'ItemPath' if need == 'itempath' else 'TimeStart'}")
+        for r in reader:
+            lr = {k.lower(): v for k, v in r.items()}
+            rtype = (lr.get("requesttype") or "Interactive").strip()
+            ts = _parse_dt(lr.get("timestart", ""))
+            if ts is None:
+                continue
+            oldest = ts if oldest is None or ts < oldest else oldest
+            newest = ts if newest is None or ts > newest else newest
+            if rtype not in ("Interactive", "Subscription"):
+                continue
+            rows.setdefault((lr.get("itempath") or "").strip().lower(), []).append(
+                {"ts": ts, "end": _parse_dt(lr.get("timeend", "")), "user": lr.get("username") or "", "status": (lr.get("status") or "rsSuccess").strip()}
+            )
+    by_path: dict[str, ReportUsage] = {}
+    d90, d365 = as_of - timedelta(days=90), as_of - timedelta(days=365)
+    for key, items in rows.items():
+        durations = [(i["end"] - i["ts"]).total_seconds() * 1000 for i in items if i["end"]]
+        by_path[key] = ReportUsage(
+            last_run=max(i["ts"] for i in items),
+            runs_90=sum(1 for i in items if i["ts"] >= d90),
+            runs_365=sum(1 for i in items if i["ts"] >= d365),
+            distinct_users=len({i["user"] for i in items if i["user"]}),
+            avg_ms=int(sum(durations) / len(durations)) if durations else None,
+            errors=sum(1 for i in items if i["status"] != "rsSuccess"),
+        )
+    return UsageData(by_path, oldest, newest, as_of, "csv")
+
+
+def load_executionlog(conn: SafeConnection) -> UsageData:
+    win = conn.query(Q_WINDOW)[0]
+    by_path: dict[str, ReportUsage] = {}
+    for r in conn.query(Q_USAGE):
+        by_path[(r["ItemPath"] or "").lower()] = ReportUsage(
+            last_run=r["last_run"], runs_90=int(r["runs_90"] or 0), runs_365=int(r["runs_365"] or 0),
+            distinct_users=int(r["distinct_users"] or 0), avg_ms=int(r["avg_ms"]) if r["avg_ms"] is not None else None,
+            errors=int(r["errors"] or 0),
+        )
+    return UsageData(by_path, win["oldest"], win["newest"], datetime.now(), "executionlog3")

db_agent/engines/sqlserver/validate.py

@@ -0,0 +1,238 @@
+"""Compare report dataset results between a source and a target server.
+
+Rows are folded into a row count and per-column totals as they arrive and are then discarded.
+Only counts and totals reach memory beyond one chunk, and only counts and totals reach disk.
+Every statement passes through the QueryGuard. Stored procedures run only with allow_exec.
+"""
+
+from __future__ import annotations
+
+import math
+import re
+import time
+from dataclasses import dataclass, field
+from datetime import date, datetime
+from decimal import Decimal
+from typing import Any, Callable
+
+from .db import ConnectionConfig, DatabaseError, SafeConnection
+from .guard import GuardError, QueryGuard, sanitize
+
+_PARAM_RE = re.compile(r"(?<![\w@])@(\w+)")
+
+
+@dataclass
+class Fold:
+    columns: list[str] = field(default_factory=list)
+    rows: int = 0
+    sums: dict[str, Decimal | float] = field(default_factory=dict)
+    nonnull: dict[str, int] = field(default_factory=dict)
+    ms: int = 0
+    truncated: bool = False
+
+
+def _is_number(v: Any) -> bool:
+    return isinstance(v, (int, float, Decimal)) and not isinstance(v, bool)
+
+
+def fold_chunks(chunks: Any, max_rows: int) -> Fold:
+    out = Fold()
+    started = time.monotonic()
+    for cols, rows in chunks:
+        if not out.columns:
+            out.columns = list(cols)
+        for row in rows:
+            out.rows += 1
+            for c, v in zip(cols, row):
+                if v is None:
+                    continue
+                out.nonnull[c] = out.nonnull.get(c, 0) + 1
+                if _is_number(v):
+                    cur = out.sums.get(c, Decimal(0) if not isinstance(v, float) else 0.0)
+                    if isinstance(cur, Decimal) and isinstance(v, float):
+                        cur = float(cur)
+                    elif isinstance(cur, float) and isinstance(v, Decimal):
+                        v = float(v)
+                    out.sums[c] = cur + v
+        if out.rows > max_rows:
+            out.truncated = True
+            break
+    out.ms = int((time.monotonic() - started) * 1000)
+    return out
+
+
+def compare(src: Fold, tgt: Fold, rel_tol: float = 1e-9) -> tuple[str, list[str]]:
+    """Return ("pass" | "fail", differences). Differences hold counts and totals only."""
+    diffs: list[str] = []
+    s_cols, t_cols = [c.lower() for c in src.columns], [c.lower() for c in tgt.columns]
+    if s_cols != t_cols:
+        diffs.append(f"columns differ: source {src.columns} target {tgt.columns}")
+    if src.rows != tgt.rows:
+        diffs.append(f"row count: source {src.rows}, target {tgt.rows}")
+    for c in src.columns:
+        a, b = src.sums.get(c), tgt.sums.get(c)
+        if a is None and b is None:
+            continue
+        if a is None or b is None:
+            diffs.append(f"{c}: numeric total present on one side only")
+            continue
+        if isinstance(a, float) or isinstance(b, float):
+            ok = math.isclose(float(a), float(b), rel_tol=rel_tol, abs_tol=1e-9)
+        else:
+            ok = a == b
+        if not ok:
+            diffs.append(f"{c} total: source {a}, target {b}")
+        if src.nonnull.get(c, 0) != tgt.nonnull.get(c, 0):
+            diffs.append(f"{c} non-null count: source {src.nonnull.get(c, 0)}, target {tgt.nonnull.get(c, 0)}")
+    return ("fail" if diffs else "pass"), diffs
+
+
+def coerce(value: str, dtype: str | None) -> Any:
+    t = (dtype or "String").lower()
+    if t in ("integer", "int", "int32", "int64"):
+        return int(value)
+    if t in ("float", "decimal", "double"):
+        return float(value)
+    if t == "boolean":
+        return value.strip().lower() in ("true", "1", "yes")
+    if t == "datetime":
+        s = value.strip()
+        for fmt in ("%Y-%m-%d %H:%M:%S", "%Y-%m-%dT%H:%M:%S", "%Y-%m-%d"):
+            try:
+                return datetime.strptime(s, fmt)
+            except ValueError:
+                continue
+        raise ValueError(f"bad date value {value!r}")
+    return value
+
+
+def bind_params(report: dict[str, Any], dataset: dict[str, Any], overrides: dict[str, Any]) -> tuple[str, dict[str, Any]] | str:
+    """Return (sql_with_placeholders, params) or a string explaining why the dataset must be skipped."""
+    rp = {p["name"].lower(): p for p in report["parameters"]}
+    sql = dataset["command_text"]
+    wanted = {m.group(1) for m in _PARAM_RE.finditer(sanitize(sql, preserve_length=True))}
+    mapping: dict[str, str] = {}  # sql parameter -> report parameter
+    for q in dataset["query_parameters"]:
+        m = re.fullmatch(r"=\s*Parameters!(\w+)\.Value", q["value"].strip(), re.IGNORECASE)
+        mapping[q["name"].lstrip("@").lower()] = m.group(1) if m else q["value"]
+    params: dict[str, Any] = {}
+    for name in wanted:
+        source = mapping.get(name.lower(), name)
+        p = rp.get(source.lower())
+        if p and p["multi_value"]:
+            return f"parameter {source} is multi-value; not supported in this version"
+        raw = overrides.get(source) if source in overrides else overrides.get(name)
+        if raw is None and p:
+            raw = p["default"]
+        if raw is None or (isinstance(raw, str) and raw.startswith("=")):
+            return f"no value for parameter {source}; set it in params.yaml"
+        try:
+            params[name] = coerce(str(raw), p["type"] if p else None)
+        except ValueError as exc:
+            return f"parameter {source}: {exc}"
+    if not params:
+        return sql, {}
+    text = sanitize(sql, preserve_length=True)
+    out, last = [], 0
+    for m in _PARAM_RE.finditer(text):
+        out.append(sql[last : m.start()].replace("%", "%%"))
+        out.append(f"%({m.group(1)})s")
+        last = m.end()
+    out.append(sql[last:].replace("%", "%%"))
+    return "".join(out), params
+
+
+def _run(cfg: ConnectionConfig, guard: QueryGuard, sql: str, params: dict[str, Any] | None, max_rows: int) -> Fold:
+    with SafeConnection(cfg, guard) as c:
+        return fold_chunks(c.stream(sql, params or None), max_rows)
+
+
+def validate_reports(
+    reports: list[dict[str, Any]],
+    source: ConnectionConfig,
+    target: ConnectionConfig,
+    overrides: dict[str, Any] | None = None,
+    allow_exec: bool = False,
+    max_rows: int = 1_000_000,
+    progress: Callable[[str], None] | None = None,
+) -> list[dict[str, Any]]:
+    overrides = overrides or {}
+    say = progress or (lambda _m: None)
+    results: list[dict[str, Any]] = []
+    for rep in reports:
+        if rep["classification"] != "move":
+            continue
+        rep_over = {**overrides.get("defaults", {}), **overrides.get("reports", {}).get(rep["path"], {})}
+        for ds in rep["datasets"]:
+            row = {"report": rep["path"], "dataset": ds["name"], "status": "skipped", "reason": "", "source_rows": None,
+                   "target_rows": None, "source_ms": None, "target_ms": None, "differences": ""}
+            results.append(row)
+            say(f"{rep['path']} / {ds['name']}")
+            if ds["shared_reference"] and not ds["command_text"]:
+                row["reason"] = "shared dataset was not supplied"
+                continue
+            if ds["confidence"] == "n/a" and ds["command_type"] != "StoredProcedure":
+                row["reason"] = ds.get("parse_error") or "nothing to run"
+                continue
+            if ds["command_type"] == "TableDirect":
+                row["reason"] = "TableDirect datasets are not run"
+                continue
+            guard = QueryGuard()
+            if ds["command_type"] == "StoredProcedure":
+                if not allow_exec:
+                    row["reason"] = "stored procedure; run again with --allow-exec"
+                    continue
+                proc = ds["command_text"].strip()
+                guard.allow_proc(proc)
+                args = ", ".join(f"@{q['name'].lstrip('@')}=%({q['name'].lstrip('@')})s" for q in ds["query_parameters"])
+                bound = bind_exec(rep, ds, rep_over)
+                if isinstance(bound, str):
+                    row["reason"] = bound
+                    continue
+                sql, params = f"EXEC {proc} {args}".strip(), bound
+            else:
+                bound = bind_params(rep, ds, rep_over)
+                if isinstance(bound, str):
+                    row["reason"] = bound
+                    continue
+                sql, params = bound
+            try:
+                src = _run(source, guard, sql, params, max_rows)
+            except GuardError as exc:
+                row["reason"] = f"not run: cannot verify read-only ({exc})"
+                continue
+            except DatabaseError as exc:
+                row["reason"] = f"source error: {str(exc)[:160]}"
+                continue
+            if src.truncated:
+                row["reason"] = f"more than {max_rows} rows; not compared"
+                continue
+            try:
+                tgt = _run(target, guard, sql, params, max_rows)
+            except DatabaseError as exc:
+                row.update(status="fail", reason=f"target error: {str(exc)[:160]}", source_rows=src.rows, source_ms=src.ms)
+                continue
+            status, diffs = compare(src, tgt)
+            row.update(status=status, reason="" if status == "pass" else "results differ", source_rows=src.rows, target_rows=tgt.rows,
+                       source_ms=src.ms, target_ms=tgt.ms, differences="; ".join(diffs))
+    return results
+
+
+def bind_exec(report: dict[str, Any], dataset: dict[str, Any], overrides: dict[str, Any]) -> dict[str, Any] | str:
+    rp = {p["name"].lower(): p for p in report["parameters"]}
+    params: dict[str, Any] = {}
+    for q in dataset["query_parameters"]:
+        name = q["name"].lstrip("@")
+        m = re.fullmatch(r"=\s*Parameters!(\w+)\.Value", q["value"].strip(), re.IGNORECASE)
+        source = m.group(1) if m else name
+        p = rp.get(source.lower())
+        raw = overrides.get(source, overrides.get(name))
+        if raw is None and p:
+            raw = p["default"]
+        if raw is None or (isinstance(raw, str) and raw.startswith("=")):
+            return f"no value for parameter {source}; set it in params.yaml"
+        try:
+            params[name] = coerce(str(raw), p["type"] if p else None)
+        except ValueError as exc:
+            return f"parameter {source}: {exc}"
+    return params

db_agent_kit-0.2.0.dist-info/METADATA

@@ -0,0 +1,192 @@
+Metadata-Version: 2.5
+Name: db-agent-kit
+Version: 0.2.0
+Summary: Read-only DBA toolkit CLI: SQL Server 2016/2017 upgrade and SSRS to Power BI inventory, Databricks workspace health and DBU cost checks.
+Project-URL: Homepage, https://github.com/db-agent/db-agent-kit
+Project-URL: Documentation, https://github.com/db-agent/db-agent-kit/tree/main/docs
+Project-URL: Issues, https://github.com/db-agent/db-agent-kit/issues
+Project-URL: Text-to-SQL agent, https://github.com/db-agent/db-agent
+Project-URL: Fixed-price help, https://becloudready.com/sql-server
+License-Expression: Apache-2.0
+License-File: LICENSE
+Keywords: azure-sql,cli,database-inventory,database-migration,databricks,dba,dbu-cost,end-of-life,migration-assessment,power-bi,sql-server,sql-server-upgrade,ssrs,unity-catalog
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: System Administrators
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Database
+Classifier: Topic :: System :: Systems Administration
+Classifier: Topic :: Utilities
+Requires-Python: >=3.11
+Requires-Dist: databricks-sdk>=0.40
+Requires-Dist: jinja2>=3.1
+Requires-Dist: lxml>=5
+Requires-Dist: openpyxl>=3.1
+Requires-Dist: pandas>=2.2
+Requires-Dist: pymssql>=2.3
+Requires-Dist: pyyaml>=6
+Requires-Dist: sqlglot>=25
+Requires-Dist: typer>=0.12
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == 'dev'
+Provides-Extra: odbc
+Requires-Dist: pyodbc>=5; extra == 'odbc'
+Description-Content-Type: text/markdown
+
+# db-agent CLI: read-only DBA toolkit for SQL Server, SSRS and Databricks
+
+Check a database before you upgrade, migrate or pay for another year of it. db-agent only reads, and writes a report you can hand to a manager: SQL Server 2016/2017 upgrade risks, an SSRS to Power BI report inventory, and Databricks workspace health with DBU spend. One command per engine. Nothing is changed on any server.
+
+Looking for the text-to-SQL agent? See [db-agent/db-agent](https://github.com/db-agent/db-agent).
+
+```
+db-agent <engine> <verb>
+db-agent engines          # what is implemented and what is planned
+```
+
+| Engine | Status | Verbs |
+|---|---|---|
+| `sqlserver` | available | `inventory`, `ssrs`, `validate`, `report` |
+| `databricks` | available; live-tested on one small AWS workspace only, see the docs | `health` ([docs](https://github.com/db-agent/db-agent-kit/blob/main/docs/databricks-health.md)) |
+
+Each engine is described below. To add one, see [docs/adding-an-engine.md](https://github.com/db-agent/db-agent-kit/blob/main/docs/adding-an-engine.md).
+
+## db-agent sqlserver: inventory SQL Server and SSRS reports before you upgrade or move to Power BI
+
+SQL Server 2016 reached end of support on July 14, 2026. SQL Server 2017 follows on October 12, 2027.
+If you run SSRS (SQL Server Reporting Services) on either, you have two jobs: upgrade the database
+server, and decide what happens to every report. This command line tool does the **SSRS migration
+inventory** and the upgrade check, **read-only**. It lists your databases and reports, flags what will
+break, sorts each report into **move**, **review** or **retire**, checks results after a move, and writes
+a report you can hand to a manager or a client. It is the first step of an **SSRS to Power BI** move.
+
+*Part of the [db-agent](https://github.com/db-agent) project.* Apache-2.0.
+
+![Sample summary report](https://raw.githubusercontent.com/db-agent/db-agent-kit/main/docs/images/summary.png)
+
+## What it does
+
+| Command | What you get |
+|---|---|
+| `sqlserver inventory` | Version, edition, databases, tables, row counts (from metadata), views, procedures with code, linked servers, Agent jobs. **Upgrade risks**, each with a link to the Microsoft page it comes from. |
+| `sqlserver ssrs` | Every report: data sources, datasets, tables and procedures used, parameters, subreports, custom code, subscriptions, usage. Each report is **move**, **review** or **retire** with the reason. |
+| `sqlserver validate` | Runs each "move" report's queries on the old and new server and compares row counts and totals. |
+| `sqlserver report` | One printable `summary.html` and one Excel workbook with all of it. |
+
+## Install
+
+```bash
+pip install db-agent-kit      # after the first PyPI release
+```
+
+From source (Python 3.11 or newer):
+
+```bash
+git clone https://github.com/db-agent/db-agent-kit && cd db-agent-kit
+python3 -m venv .venv && .venv/bin/pip install -e .
+```
+
+A Docker image and a Windows single-file `.exe` do not exist yet.
+
+## 5-minute demo (no database needed)
+
+Run this from the source checkout (see Install):
+
+```bash
+make demo-files
+```
+
+This reads 12 sample reports and a synthetic usage log (`examples/`, clearly labelled sample data) and
+opens `summary.html`. You will see 5 move, 5 review and 2 retire, each with a reason.
+
+To also see `inventory` and `validate`, start two SQL Server containers, restore the AdventureWorks
+sample database and run `make demo`. See [docs/demo.md](https://github.com/db-agent/db-agent-kit/blob/main/docs/demo.md).
+
+## Use it
+
+Run it as `db-agent sqlserver <command>`.
+
+```bash
+db-agent sqlserver inventory --server sql01 --user dbagent_reader          # password: env DBAGENT_SQL_PASSWORD or a prompt
+db-agent sqlserver ssrs --reportserver-db ReportServer --server sql01 --user dbagent_reader
+db-agent sqlserver ssrs --rdl-folder ./reports --usage-csv executionlog.csv       # no server access needed
+db-agent sqlserver validate --source "server=old,database=Sales,user=u" --target "server=new,database=Sales,user=u" --reports db-agent-sqlserver-output/reports.csv
+db-agent sqlserver report
+```
+
+Output goes to `./db-agent-sqlserver-output` (change with `--out`). Windows authentication needs `--driver odbc`,
+`pip install ".[odbc]"` and a Microsoft ODBC driver for SQL Server. The tool finds driver 18, 17 or 13 on its own; set
+`DBAGENT_ODBC_DRIVER` to force one. It was tested with driver 17 and a local Windows account (NTLM). Domain (Kerberos)
+logins and Microsoft Entra ID were not tested.
+
+## What your DBA needs to grant
+
+A dedicated login with read access to metadata and the ReportServer catalog. Nothing that can write.
+The exact T-SQL script is in [docs/permissions.md](https://github.com/db-agent/db-agent-kit/blob/main/docs/permissions.md).
+
+## Sample output
+
+`reports.csv`, one row per report (a few of the columns; run counts move with the date you run it):
+
+| path | classification | runs_365 | last_run | reasons |
+|---|---|---|---|---|
+| /Inventory/BillOfMaterials | move | 41 | 2026-11-03 | Plain report, no hard-to-move features |
+| /HR/EmployeeDirectory | review | 12 | 2026-11-02 | Custom code block (3 lines) |
+| /Purchasing/VendorSpend | review | 50 | 2026-11-04 | Dataset SQL could not be fully parsed (Spend); table list is a guess |
+| /Inventory/LegacyInventory | retire | 0 | | No runs in the last 365 days (log covers 522 days) |
+
+## What it does not do
+
+- It does **not convert reports.** It tells you what to move and what is hard. A layout hint says which reports look like Power BI paginated reports and which look like an interactive rebuild. It is a hint only.
+- It does **not read business data** during `inventory` or `ssrs`. Row counts come from system views.
+- `validate` is the one command that runs report queries. It keeps **only row counts and numeric totals**, never row values, and only on a login you choose to give read access to.
+- It does **not change anything** on any server, and sends nothing over the network except to the SQL Servers you name.
+
+## FAQ
+
+**Is it safe?** Every statement goes through one guard that allows a single `SELECT` (or, with `--allow-exec`, a stored procedure you named). `SELECT ... INTO`, `OPENROWSET`, linked servers and anything it cannot parse are refused. Tests check that no command can bypass it. The login's permissions are the real boundary: give it only what [docs/permissions.md](https://github.com/db-agent/db-agent-kit/blob/main/docs/permissions.md) lists.
+
+**What access does it need?** See above. For `ssrs` without database access, export the `.rdl` files and the execution log and run it on a laptop.
+
+**Does it work with Azure SQL?** It reads Azure SQL Database and Managed Instance for `inventory` and flags what would not work there. Tested against one Azure SQL Database (AdventureWorksLT); Managed Instance is not tested.
+
+**What about Power BI paginated reports?** Reports are classified by what is hard to move, not converted. The hint column says which look paginated. Check Microsoft's current paginated report limits for your reports.
+
+**Why are no reports marked retire?** SSRS keeps its usage log for 60 days by default. A report that runs once a year looks unused in a 60-day log. The kit only calls a report retire when the log covers 365 days, and says so. See [docs/ssrs-inventory.md](https://github.com/db-agent/db-agent-kit/blob/main/docs/ssrs-inventory.md).
+
+**Where does my data go?** Nowhere. Everything is written to a local folder. Object code (`modules.json`) can contain secrets: skip it with `--no-code`.
+
+## db-agent databricks: workspace health and DBU spend
+
+```bash
+databricks auth login --host https://<workspace>.cloud.databricks.com
+db-agent databricks health                       # uses a SQL warehouse that is already running
+db-agent databricks health --profile <name> --warehouse-id <id> --out ./out
+db-agent databricks health --no-sql              # REST API checks only, no warehouse needed
+```
+
+It reads the REST API and system tables and changes nothing. It checks:
+
+- Clusters and job clusters on runtimes past end of support, or within 180 days of it (`--eos-warning-days`). In the built-in table, 13.3 LTS ended on 2026-08-22 and 14.3 LTS ends on 2027-02-01.
+- Legacy dependencies: Hive metastore tables, DBFS mount events, init scripts stored on DBFS, and clusters without a Unity Catalog access mode.
+- DBU spend by month at list price, split into usage and price change, with a note when the SKU tier changes.
+- Spend waste: scheduled jobs on all-purpose clusters, clusters with auto-termination off, SQL warehouses billed with no queries or with auto-stop off, and spend with no tags.
+
+Live-tested on one small AWS workspace only. See [docs/databricks-health.md](https://github.com/db-agent/db-agent-kit/blob/main/docs/databricks-health.md) for options, access needed and limits.
+
+## Status
+
+Version 0.2.0. What was tested is listed in [docs/testing.md](https://github.com/db-agent/db-agent-kit/blob/main/docs/testing.md):
+
+- `sqlserver`: real SQL Server 2017 and 2022 (Linux, Docker), real SQL Server 2016 SP3 with a real SSRS 2016 server (Windows VM), and `inventory` on one Azure SQL Database (AdventureWorksLT). ODBC with Windows authentication was tested with a local account.
+- `databricks`: one small AWS workspace. See [docs/databricks-health.md](https://github.com/db-agent/db-agent-kit/blob/main/docs/databricks-health.md).
+- Not tested: SSRS 2017 and later, Power BI Report Server, domain (Kerberos) authentication, Entra ID, Azure SQL Managed Instance.
+
+[Upgrade risk rules](https://github.com/db-agent/db-agent-kit/blob/main/docs/risk-rules.md) · [SSRS inventory](https://github.com/db-agent/db-agent-kit/blob/main/docs/ssrs-inventory.md) · [Permissions](https://github.com/db-agent/db-agent-kit/blob/main/docs/permissions.md) · [Examples](https://github.com/db-agent/db-agent-kit/blob/main/examples/README.md)
+
+Need the upgrade and report move done for you at a fixed price? [becloudready.com/sql-server](https://becloudready.com/sql-server)

db_agent_kit-0.2.0.dist-info/RECORD

@@ -0,0 +1,36 @@
+db_agent/__init__.py,sha256=j0-dWiRXV6ESuGrqeYBvlu8mO0MUwHwC__PNVJM55EY,100
+db_agent/cli.py,sha256=7JtZPFtoMLYFWDa0kZrxBMjO2D1m_V9v5FMWjBcVx1s,852
+db_agent/engines/__init__.py,sha256=WWsjznYgYopDYXtmHR8_y6s--5p998kclxzBXIsXQXI,1410
+db_agent/engines/databricks/__init__.py,sha256=mp5iUZ2ZVR3_1nhzt4hvVD8A60JegdhSPJ1lPxZtkl4,96
+db_agent/engines/databricks/checks.py,sha256=RFo0S0XICjpeUYyziVmxOzzs9wUPt8zfTtdb7pJWDWY,12235
+db_agent/engines/databricks/cli.py,sha256=_s8vBYvB2UedkQM8lOGfAz7ApY6yi95EegcgHYQq8kM,3565
+db_agent/engines/databricks/client.py,sha256=4l91AVduqhwk4wZVWu54UQX-SqIpu9c1Bs4z_EwwAkA,3548
+db_agent/engines/databricks/cost.py,sha256=H0EweWS7C29WIRDQZRT0bJzkuPG08mKh4aR-4NroEzw,3821
+db_agent/engines/databricks/health.py,sha256=JRyQRNJci4aSJOzx9RPdv4M6PW7lzUxvR-_77v7EaUU,7950
+db_agent/engines/databricks/model.py,sha256=3lvw6puBvvRAOoRxuDI8s2r1QuD_Ep_diM76lptgC2g,633
+db_agent/engines/databricks/queries.py,sha256=FaY9OpKIFrP-BzRNyXiBCTBcnrsgTi0S3M30x1WwLig,4313
+db_agent/engines/databricks/render.py,sha256=BCyVZgHgL6ZaBc4fY6XayLsePwLka7tuRFhoXQZ3KhI,3399
+db_agent/engines/databricks/runtimes.py,sha256=KLSACuJIdPM9NxgmW-l2_GNRXpe-6wMb3HwidJDwQ30,2826
+db_agent/engines/databricks/sqlguard.py,sha256=XjfmDvBCvWkOVC-gYje_RyrxBJzPgErKEuyiezAVcR8,2878
+db_agent/engines/sqlserver/__init__.py,sha256=I7SsCx3QCahLxVuQvYe0sp88_rZUQfqP6hHqnica674,424
+db_agent/engines/sqlserver/classify.py,sha256=GGbHa7tKVunZJNd5G_ejeXFLKnhOk8n9mpCtY2RVO1A,5131
+db_agent/engines/sqlserver/cli.py,sha256=h1yVDoCLkK1y8nTLaRt8m8MyXqSjGWSpDsfPhxUyssE,14810
+db_agent/engines/sqlserver/db.py,sha256=EnyXSHbtPgibChP3fCBRu7a7BM1fy6FqL4mGSo0LNKc,7036
+db_agent/engines/sqlserver/guard.py,sha256=p_DLTjDEzlJm7tvNjUFn03zfB4bO6f7lePvXpuINOsM,7669
+db_agent/engines/sqlserver/inventory.py,sha256=znm-YgsJ0yVK3Oexl5uKSqC57u42e0C796_vqSKHZmM,15757
+db_agent/engines/sqlserver/outputs.py,sha256=Ehnd6xziq4D110_uPbt7enJSrt1DrwfRJyf8mJAi1Ys,15577
+db_agent/engines/sqlserver/rdl.py,sha256=57vHNpTJx5NUmgxeKFcxQvsEQFVl5y5KORZtOLoBiT8,11496
+db_agent/engines/sqlserver/report.py,sha256=tEfzZMqOLxYWw1v05tpz3WFTMeim_6vY7ndU0E8Seeg,7359
+db_agent/engines/sqlserver/risks.py,sha256=AgEnGtTq0ABCmSif8FZrkLNQHwjdBn8u01py9jEAeMk,12867
+db_agent/engines/sqlserver/rules.py,sha256=xKdxTZlYFrTb2pDlXEgUs9RCGnUHWvMqGddPQrTuDTo,8723
+db_agent/engines/sqlserver/sqlrefs.py,sha256=Yt49pjg2Qk-U-mfQdObC5CHzHzDoEQCrpfB4NSylE5g,4091
+db_agent/engines/sqlserver/ssrs.py,sha256=CyVUCiOBsv-eQS3H2MLpgcHINn3KFtpP-WbEaF3gjS0,10205
+db_agent/engines/sqlserver/usage.py,sha256=kePBG86DYQIFR-q1H37E9wwreLukYwUvvd7X5m3ZRiY,5301
+db_agent/engines/sqlserver/validate.py,sha256=k_ie-XbtnCt_EDYW_9lpmV7NlgFbQ3wvKwp5GVE2jr0,10230
+db_agent/engines/sqlserver/data/classification.yaml,sha256=PnHZiKfYV3IEhx68WFiV6jx4vtMbwIjMmVGiD7Dpsh8,1049
+db_agent/engines/sqlserver/templates/summary.html.j2,sha256=D158rr9VSQY1HjBEnY8DiWa80VA9LBHEwCrarXUZomM,9830
+db_agent_kit-0.2.0.dist-info/METADATA,sha256=BeXrzDkeaDrCp3ws_a8mhEcjuA4yKoaqIQlOeIRCG1A,11785
+db_agent_kit-0.2.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+db_agent_kit-0.2.0.dist-info/entry_points.txt,sha256=Ts_abJe0exYQwFimnNb7-K_xCczRjHjTzwFNjf-Y0PU,46
+db_agent_kit-0.2.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+db_agent_kit-0.2.0.dist-info/RECORD,,

db_agent_kit-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any

db_agent_kit-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+db-agent = db_agent.cli:app