sqlakit 0.22.1__tar.gz → 0.22.3__tar.gz

{sqlakit-0.22.1 → sqlakit-0.22.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlakit
-Version: 0.22.1
+Version: 0.22.3
 Summary: A toolkit for SQLAlchemy applications.
 Keywords: sqlalchemy,database,orm,sql,asyncio
 Author: Anton Ruhlov
@@ -133,6 +133,13 @@ shows the source file of each query right away.
 that can't work, before the query runs. See [template
 validation](docs/sql.md#template-validation).
 
+The [VS Code
+extension](https://marketplace.visualstudio.com/items?itemName=sqlakit.sqlakit)
+completes the macros, links a template name in Python to its file, marks the
+same problems as you type, and shows a template rendered as the database gets
+it. It runs `sqlakit-lsp`, a language server any other editor can run too. See
+[editor support](docs/sql.md#editor-support).
+
 ### From a string
 
 ```python

{sqlakit-0.22.1 → sqlakit-0.22.3}/README.md

@@ -102,6 +102,13 @@ shows the source file of each query right away.
 that can't work, before the query runs. See [template
 validation](docs/sql.md#template-validation).
 
+The [VS Code
+extension](https://marketplace.visualstudio.com/items?itemName=sqlakit.sqlakit)
+completes the macros, links a template name in Python to its file, marks the
+same problems as you type, and shows a template rendered as the database gets
+it. It runs `sqlakit-lsp`, a language server any other editor can run too. See
+[editor support](docs/sql.md#editor-support).
+
 ### From a string
 
 ```python

{sqlakit-0.22.1 → sqlakit-0.22.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sqlakit"
-version = "0.22.1"
+version = "0.22.3"
 description = "A toolkit for SQLAlchemy applications."
 readme = "README.md"
 license = "MIT"
@@ -201,6 +201,7 @@ dev = [
     "dirty-equals>=0.11",
     "codespell>=2.4.3",
     "sqruff>=0.40.0",
+    "sqlfluff>=4.3.0",
 ]
 docs = [
     "mkdocs>=1.6.1,<2",

{sqlakit-0.22.1 → sqlakit-0.22.3}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "sqlakit"
-version = "0.22.1"
+version = "0.22.3"
 description = "A toolkit for SQLAlchemy applications."
 readme = "README.md"
 license = "MIT"
@@ -77,6 +77,7 @@ dev = [
     "dirty-equals>=0.11",
     "codespell>=2.4.3",
     "sqruff>=0.40.0",
+    "sqlfluff>=4.3.0",
 ]
 docs = [
     "mkdocs>=1.6.1,<2",

{sqlakit-0.22.1 → sqlakit-0.22.3}/sqlakit/_cli.py

@@ -8,10 +8,11 @@ import os
 import sys
 from pathlib import Path
 
+from . import _sql_formatter
+from ._linters import LINTERS, settings, stale
 from ._project import Problem, Project, load_project
 from ._pycharm import DIALECTS, ddl, dialects
 from ._sql import NAMESPACE, registered, signature_of
-from ._sqruff import settings, stale
 from .exceptions import MacroDefinitionError, ProjectConfigError, UnknownImportPathError
 
 
@@ -55,7 +56,7 @@ def main(argv: list[str] | None = None) -> int:
     export = commands.add_parser(
         "export", help="write what another tool needs to read the templates"
     )
-    export.add_argument("tool", choices=("sqruff", "pycharm"))
+    export.add_argument("tool", choices=(*LINTERS, "sql-formatter", "pycharm"))
     export.add_argument(
         "--project",
         default=".",
@@ -74,9 +75,23 @@ def main(argv: list[str] | None = None) -> int:
     if arguments.command == "check":
         return _check(Path(arguments.project), json_output=arguments.format == "json")
     if arguments.command == "export":
-        export = _export_pycharm if arguments.tool == "pycharm" else _export_sqruff
-        return export(
-            Path(arguments.project), dialect=arguments.dialect, check=arguments.check
+        if arguments.tool == "sql-formatter":
+            return _export_sql_formatter(
+                Path(arguments.project),
+                dialect=arguments.dialect,
+                check=arguments.check,
+            )
+        if arguments.tool == "pycharm":
+            return _export_pycharm(
+                Path(arguments.project),
+                dialect=arguments.dialect,
+                check=arguments.check,
+            )
+        return _export_linter(
+            arguments.tool,
+            Path(arguments.project),
+            dialect=arguments.dialect,
+            check=arguments.check,
         )
     if arguments.command == "macros":
         return _macros(
@@ -165,21 +180,24 @@ def _check(directory: Path, *, json_output: bool) -> int:
     return 1 if problems else 0
 
 
-def _export_sqruff(directory: Path, *, dialect: str | None, check: bool) -> int:
-    """Write the `sqruff` settings that read the templates into `pyproject.toml`."""
+def _export_linter(
+    name: str, directory: Path, *, dialect: str | None, check: bool
+) -> int:
+    """Write the settings of `sqruff` or `sqlfluff` that read the templates."""
+    linter = LINTERS[name]
     project = _load(directory)
     if project is None:
         return 2
     pyproject = project.root / "pyproject.toml"
     text = pyproject.read_text(encoding="utf-8") if pyproject.exists() else ""
     if check:
-        tables = stale(project, text)
+        tables = stale(linter, project, text)
         if tables:
-            _say(f"{', '.join(tables)} out of date: run `sqlakit export sqruff`")
+            _say(f"{', '.join(tables)} out of date: run `sqlakit export {name}`")
             return 1
         return 0
     try:
-        written = settings(project, text, dialect)
+        written = settings(linter, project, text, dialect)
     except ProjectConfigError as error:
         _say(str(error))
         return 2
@@ -188,6 +206,28 @@ def _export_sqruff(directory: Path, *, dialect: str | None, check: bool) -> int:
     return 0
 
 
+def _export_sql_formatter(directory: Path, *, dialect: str | None, check: bool) -> int:
+    """Write the `.sql-formatter.json` that reads `:name` as a parameter."""
+    project = _load(directory)
+    if project is None:
+        return 2
+    path = project.root / _sql_formatter.FILE
+    written = path.read_text(encoding="utf-8") if path.exists() else None
+    if check:
+        if _sql_formatter.stale(written):
+            _say(f"{_relative(path)} out of date: run `sqlakit export sql-formatter`")
+            return 1
+        return 0
+    try:
+        text = _sql_formatter.config(project, written, dialect)
+    except ProjectConfigError as error:
+        _say(str(error))
+        return 2
+    path.write_text(text, encoding="utf-8")
+    _say(f"wrote {_relative(path)}")
+    return 0
+
+
 def _export_pycharm(directory: Path, *, dialect: str | None, check: bool) -> int:
     """Write what PyCharm needs into `.idea/`: the macros as DDL, and the dialect."""
     project = _load(directory)

sqlakit-0.22.3/sqlakit/_linters.py

@@ -0,0 +1,258 @@
+"""The settings in `pyproject.toml` that let `sqruff` or `sqlfluff` read templates.
+
+The `placeholder` templater writes each `:name` as `name`. Where that reads as
+something else, `settings` gives the parameter a value; see
+`Project.placeholder_values`. Which names a dialect keeps for itself is asked
+of the linter, when it is installed, since its dialects keep words SQLAlchemy's
+do not: `exclude` and `row` on SQLite.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+import shutil
+import subprocess
+import tempfile
+import tomllib
+from dataclasses import dataclass
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+from ._project import LINT_EXCLUDED
+from .exceptions import ProjectConfigError
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from ._project import Project
+
+__all__ = ["LINTERS", "Linter", "settings", "stale"]
+
+_NEXT_TABLE = re.compile(r"^\[", re.MULTILINE)
+
+
+@dataclass(frozen=True, slots=True)
+class Linter:
+    """A linter that reads templates with its `placeholder` templater."""
+
+    name: str
+    """The executable, and the key of its tables under `[tool]`."""
+    dialects: dict[str, str]
+    """The linter's name for a dialect SQLAlchemy names another way."""
+    rules: tuple[str, ...]
+    """The lines of `[tool.<name>.core]` that choose the rules."""
+    default_dialect: str | None
+    """The dialect written when neither the call nor the project gives one."""
+    kept: Callable[[str, list[str], str | None], set[int]]
+    """Given the executable, the names and the dialect, the index of each name it
+    cannot read as a column."""
+
+    @property
+    def placeholder(self) -> str:
+        return f"[tool.{self.name}.templater.placeholder]"
+
+    @property
+    def core(self) -> str:
+        return f"[tool.{self.name}.core]"
+
+
+def stale(linter: Linter, project: Project, pyproject: str) -> list[str]:
+    """Return the tables of `pyproject.toml` that no longer read the templates."""
+    tables = tomllib.loads(pyproject).get("tool", {}).get(linter.name, {})
+    written = tables.get("templater", {}).get("placeholder", {})
+    chosen = _dialect(linter, tables, None, project)
+    values = project.placeholder_values(_kept(linter, project, chosen))
+    checked = (
+        (linter.core, "core" in tables),
+        (
+            linter.placeholder,
+            all(str(written.get(name)) == str(value) for name, value in values.items()),
+        ),
+    )
+    return [table for table, fresh in checked if not fresh]
+
+
+def settings(
+    linter: Linter, project: Project, pyproject: str, dialect: str | None
+) -> str:
+    """Return `pyproject.toml` with the settings that read the templates.
+
+    The values the templates need are written again each time, and a value
+    added to the table by hand stays. The core table is written only when it
+    is missing, so the rules set there stay.
+
+    Raises:
+        ProjectConfigError: if the table is written in a way this cannot rewrite.
+
+    """
+    tables = tomllib.loads(pyproject).get("tool", {}).get(linter.name, {})
+    written = dict(tables.get("templater", {}).get("placeholder", {}))
+    written.pop("param_style", None)
+    text = pyproject
+    chosen = _dialect(linter, tables, dialect, project)
+    if "core" not in tables:
+        core = [
+            linter.core,
+            *([f'dialect = "{chosen}"'] if chosen else []),
+            'templater = "placeholder"',
+            *linter.rules,
+            f'exclude_rules = "{",".join(LINT_EXCLUDED)}"',
+        ]
+        text = text.rstrip("\n") + "\n\n" + "\n".join(core) + "\n"
+    values = project.placeholder_values(_kept(linter, project, chosen))
+    merged = dict(sorted({**written, **values}.items()))
+    table = "\n".join(
+        [
+            linter.placeholder,
+            'param_style = "colon"',
+            *(f"{name} = {_toml_value(value)}" for name, value in merged.items()),
+        ]
+    )
+    header = re.compile(
+        rf"^{re.escape(linter.placeholder)}[ \t]*(?:#[^\n]*)?$", re.MULTILINE
+    )
+    if found := header.search(text):
+        following = _NEXT_TABLE.search(text, found.end())
+        end = following.start() if following else len(text)
+        after = "\n\n" if following else "\n"
+        written_out = text[: found.start()] + table + after + text[end:]
+    else:
+        written_out = text.rstrip("\n") + "\n\n" + table + "\n"
+    try:
+        tomllib.loads(written_out)
+    except tomllib.TOMLDecodeError as error:
+        problem = (
+            f"`{linter.placeholder}` is written in a way this "
+            f"cannot rewrite ({error}): give it a table of its own"
+        )
+        raise ProjectConfigError(problem) from error
+    return written_out
+
+
+def _dialect(
+    linter: Linter, tables: dict, given: str | None, project: Project
+) -> str | None:
+    """Return the dialect the linter reads the templates in, by its name."""
+    if "core" in tables:
+        # A table without a dialect is read as the linter reads it, and so here.
+        written = tables["core"].get("dialect")
+        return written if isinstance(written, str) else linter.default_dialect
+    chosen = given or project.dialect
+    if chosen is None:
+        return linter.default_dialect
+    return linter.dialects.get(chosen, chosen)
+
+
+def _kept(linter: Linter, project: Project, dialect: str | None) -> set[str]:
+    """Return the parameter names the linter cannot read as a column in the dialect.
+
+    Without the linter installed, the dialects of SQLAlchemy decide alone.
+    """
+    binary = shutil.which(linter.name)
+    names = sorted(project.parameter_names())
+    if binary is None or not names:
+        return set()
+    return {names[index] for index in linter.kept(binary, names, dialect)}
+
+
+def _sqruff_kept(binary: str, names: list[str], dialect: str | None) -> set[int]:
+    """Lint each name as `SELECT <name>;`, one to a line, in one run of `sqruff`."""
+    # JSON, as the report of its own is another shape on GitHub Actions.
+    command = [binary, "lint", "--parsing-errors", "--format", "json", "-"]
+    if dialect:
+        command[2:2] = ["--dialect", dialect]
+    source = "".join(f"SELECT {name};\n" for name in names)
+    # Away from the project, so no setting of its own changes the reading.
+    with tempfile.TemporaryDirectory() as empty:
+        found = subprocess.run(  # noqa: S603 - sqruff, found on the PATH
+            command,
+            input=source,
+            capture_output=True,
+            text=True,
+            cwd=empty,
+            check=False,
+        )
+    lines = {
+        problem["range"]["start"]["line"]
+        for problems in _report(found.stdout, found.stderr, shape=dict).values()
+        for problem in problems
+        # The name starts after `SELECT `, at the eighth character.
+        if problem.get("message") == "Unparsable section"
+        and problem["range"]["start"]["character"] == len("SELECT ") + 1
+    }
+    return {index for index in range(len(names)) if index + 1 in lines}
+
+
+def _sqlfluff_kept(binary: str, names: list[str], dialect: str | None) -> set[int]:
+    """Lint each name as `SELECT <name>;`, a file each, in one run of `sqlfluff`.
+
+    A file each, as `sqlfluff` reads the lines after one it cannot parse as
+    part of it.
+    """
+    with tempfile.TemporaryDirectory() as empty:
+        folder = Path(empty)
+        for index, name in enumerate(names):
+            (folder / f"{index}.sql").write_text(f"SELECT {name};\n", encoding="utf-8")
+        command = [binary, "lint", "--format", "json", "--dialect", dialect or "ansi"]
+        found = subprocess.run(  # noqa: S603 - sqlfluff, found on the PATH
+            [*command, "."],
+            capture_output=True,
+            text=True,
+            cwd=empty,
+            check=False,
+        )
+    return {
+        int(Path(report["filepath"]).stem)
+        for report in _report(found.stdout, found.stderr, shape=list)
+        for problem in report.get("violations", ())
+        # The name starts after `SELECT `, at the eighth character.
+        if problem.get("code") == "PRS"
+        and problem.get("start_line_no") == 1
+        and problem.get("start_line_pos") == len("SELECT ") + 1
+    }
+
+
+def _report(*outputs: str, shape: type) -> Any:  # noqa: ANN401 - either linter's JSON
+    """Return the JSON report, from whichever stream the linter wrote it to."""
+    for output in outputs:
+        try:
+            report = json.loads(output)
+        except json.JSONDecodeError:
+            continue
+        if isinstance(report, shape):
+            return report
+    return shape()
+
+
+def _toml_value(value: object) -> str:
+    """Return a value as TOML writes it: a string quoted, a flag in lower case."""
+    if isinstance(value, bool):
+        return str(value).lower()
+    if isinstance(value, int | float):
+        return str(value)
+    return json.dumps(str(value))
+
+
+SQRUFF = Linter(
+    name="sqruff",
+    dialects={"postgresql": "postgres", "mariadb": "mysql", "mssql": "tsql"},
+    # sqruff turns on a few rules unless told, and every one on `all`.
+    rules=('rules = "all"',),
+    # sqruff reads settings without a dialect as ANSI.
+    default_dialect=None,
+    kept=_sqruff_kept,
+)
+
+SQLFLUFF = Linter(
+    name="sqlfluff",
+    dialects={"postgresql": "postgres", "mssql": "tsql"},
+    # sqlfluff turns on every rule unless told.
+    rules=(),
+    # sqlfluff reads no template without a dialect.
+    default_dialect="ansi",
+    kept=_sqlfluff_kept,
+)
+
+LINTERS = {linter.name: linter for linter in (SQRUFF, SQLFLUFF)}
+"""Each linter `sqlakit export` writes settings for, by its name."""

sqlakit-0.22.3/sqlakit/_sql_formatter.py

@@ -0,0 +1,91 @@
+"""The `.sql-formatter.json` that lets `sql-formatter` format templates.
+
+`sql-formatter` reads `:name` as a parameter only when `paramTypes` says so.
+Without it, `c = :limit::int` on PostgreSQL comes back split over lines, with
+the parameter gone. A macro call is a function call to it, and needs nothing.
+"""
+
+from __future__ import annotations
+
+import json
+from typing import TYPE_CHECKING, Any
+
+from .exceptions import ProjectConfigError
+
+if TYPE_CHECKING:
+    from ._project import Project
+
+__all__ = ["FILE", "config", "stale"]
+
+FILE = ".sql-formatter.json"
+"""Where `sql-formatter` looks for its settings, in the directory it runs in."""
+
+LANGUAGES = {
+    "bigquery",
+    "clickhouse",
+    "db2",
+    "duckdb",
+    "hive",
+    "mariadb",
+    "mysql",
+    "postgresql",
+    "redshift",
+    "snowflake",
+    "sqlite",
+    "trino",
+}
+"""The dialects `sql-formatter` names as SQLAlchemy does."""
+
+_RENAMED = {"oracle": "plsql", "mssql": "transactsql", "databricks": "spark"}
+"""`sql-formatter`'s name for a dialect SQLAlchemy names another way."""
+
+
+def stale(written: str | None) -> bool:
+    """Whether the file is missing, or does not read `:name` as a parameter."""
+    if written is None:
+        return True
+    try:
+        settings = _read(written)
+    except ProjectConfigError:
+        return True
+    named = settings.get("paramTypes", {}).get("named", [])
+    return "language" not in settings or ":" not in named
+
+
+def config(project: Project, written: str | None, dialect: str | None) -> str:
+    """Return the file, with what `sql-formatter` needs to format the templates.
+
+    `:` is added to the named parameters, and the language is written when the
+    file has none. Every other setting stays as it is.
+
+    Raises:
+        ProjectConfigError: if the file is not a JSON object.
+
+    """
+    settings = _read(written) if written is not None else {}
+    if "language" not in settings:
+        chosen = (dialect or project.dialect or "").lower()
+        settings["language"] = _RENAMED.get(chosen) or (
+            chosen if chosen in LANGUAGES else "sql"
+        )
+    types = settings.setdefault("paramTypes", {})
+    if not isinstance(types, dict):
+        problem = f"`paramTypes` in {FILE} is not an object: make it one, or remove it"
+        raise ProjectConfigError(problem)
+    named = types.setdefault("named", [])
+    if ":" not in named:
+        named.append(":")
+    return json.dumps(settings, indent=2) + "\n"
+
+
+def _read(written: str) -> dict[str, Any]:
+    """Return the settings a file holds."""
+    try:
+        settings = json.loads(written)
+    except json.JSONDecodeError as error:
+        problem = f"{FILE} is not JSON ({error}): fix it, or remove it"
+        raise ProjectConfigError(problem) from error
+    if not isinstance(settings, dict):
+        problem = f"{FILE} is not a JSON object: fix it, or remove it"
+        raise ProjectConfigError(problem)
+    return settings

sqlakit-0.22.1/sqlakit/_sqruff.py

@@ -1,168 +0,0 @@
-"""The `sqruff` settings in `pyproject.toml` that read templates as SQL.
-
-The `placeholder` templater writes each `:name` as `name`. Where that reads as
-something else, `settings` gives the parameter a value; see
-`Project.placeholder_values`. Which names a dialect keeps for itself is asked
-of `sqruff`, when it is installed, since its dialects keep words SQLAlchemy's
-do not: `exclude` and `row` on SQLite.
-"""
-
-from __future__ import annotations
-
-import json
-import re
-import shutil
-import subprocess
-import tempfile
-import tomllib
-from typing import TYPE_CHECKING, Any
-
-from ._project import LINT_EXCLUDED
-from .exceptions import ProjectConfigError
-
-if TYPE_CHECKING:
-    from ._project import Project
-
-__all__ = ["settings", "stale"]
-
-_HEADER = re.compile(
-    r"^\[tool\.sqruff\.templater\.placeholder\][ \t]*(?:#[^\n]*)?$", re.MULTILINE
-)
-
-_DIALECTS = {"postgresql": "postgres", "mariadb": "mysql", "mssql": "tsql"}
-"""sqruff's name for a dialect SQLAlchemy names another way."""
-_NEXT_TABLE = re.compile(r"^\[", re.MULTILINE)
-
-
-def stale(project: Project, pyproject: str) -> list[str]:
-    """Return the tables of `pyproject.toml` that no longer read the templates."""
-    sqruff = tomllib.loads(pyproject).get("tool", {}).get("sqruff", {})
-    written = sqruff.get("templater", {}).get("placeholder", {})
-    values = project.placeholder_values(_kept(project, _dialect(sqruff, None, project)))
-    checked = (
-        ("[tool.sqruff.core]", "core" in sqruff),
-        (
-            "[tool.sqruff.templater.placeholder]",
-            all(str(written.get(name)) == str(value) for name, value in values.items()),
-        ),
-    )
-    return [table for table, fresh in checked if not fresh]
-
-
-def settings(project: Project, pyproject: str, dialect: str | None) -> str:
-    """Return `pyproject.toml` with the settings that read the templates.
-
-    The values the templates need are written again each time, and a value
-    added to the table by hand stays. `[tool.sqruff.core]` is written only when
-    it is missing, so the rules set there stay.
-
-    Raises:
-        ProjectConfigError: if the table is written in a way this cannot rewrite.
-
-    """
-    sqruff = tomllib.loads(pyproject).get("tool", {}).get("sqruff", {})
-    written = dict(sqruff.get("templater", {}).get("placeholder", {}))
-    written.pop("param_style", None)
-    text = pyproject
-    chosen = _dialect(sqruff, dialect, project)
-    if "core" not in sqruff:
-        core = [
-            "[tool.sqruff.core]",
-            *([f'dialect = "{chosen}"'] if chosen else []),
-            'templater = "placeholder"',
-            'rules = "all"',
-            f'exclude_rules = "{",".join(LINT_EXCLUDED)}"',
-        ]
-        text = text.rstrip("\n") + "\n\n" + "\n".join(core) + "\n"
-    values = project.placeholder_values(_kept(project, chosen))
-    merged = dict(sorted({**written, **values}.items()))
-    table = "\n".join(
-        [
-            "[tool.sqruff.templater.placeholder]",
-            'param_style = "colon"',
-            *(f"{name} = {_toml_value(value)}" for name, value in merged.items()),
-        ]
-    )
-    if found := _HEADER.search(text):
-        following = _NEXT_TABLE.search(text, found.end())
-        end = following.start() if following else len(text)
-        after = "\n\n" if following else "\n"
-        written_out = text[: found.start()] + table + after + text[end:]
-    else:
-        written_out = text.rstrip("\n") + "\n\n" + table + "\n"
-    try:
-        tomllib.loads(written_out)
-    except tomllib.TOMLDecodeError as error:
-        problem = (
-            "`[tool.sqruff.templater.placeholder]` is written in a way this "
-            f"cannot rewrite ({error}): give it a table of its own"
-        )
-        raise ProjectConfigError(problem) from error
-    return written_out
-
-
-def _dialect(sqruff: dict, given: str | None, project: Project) -> str | None:
-    """Return the dialect `sqruff` reads the templates in, by its name."""
-    if "core" in sqruff:
-        # sqruff reads a table without a dialect as ANSI, and so does this.
-        written = sqruff["core"].get("dialect")
-        return written if isinstance(written, str) else None
-    chosen = given or project.dialect
-    return _DIALECTS.get(chosen or "", chosen)
-
-
-def _kept(project: Project, dialect: str | None) -> set[str]:
-    """Return the parameter names `sqruff` cannot read as a column in the dialect.
-
-    Each name is linted as `SELECT <name>;`, one to a line, in one run. Without
-    `sqruff` installed, the dialects of SQLAlchemy decide alone.
-    """
-    binary = shutil.which("sqruff")
-    names = sorted(project.parameter_names())
-    if binary is None or not names:
-        return set()
-    # JSON, as the report of its own is another shape on GitHub Actions.
-    command = [binary, "lint", "--parsing-errors", "--format", "json", "-"]
-    if dialect:
-        command[2:2] = ["--dialect", dialect]
-    source = "".join(f"SELECT {name};\n" for name in names)
-    # Away from the project, so no setting of its own changes the reading.
-    with tempfile.TemporaryDirectory() as empty:
-        found = subprocess.run(  # noqa: S603 - sqruff, found on the PATH
-            command,
-            input=source,
-            capture_output=True,
-            text=True,
-            cwd=empty,
-            check=False,
-        )
-    lines = {
-        problem["range"]["start"]["line"]
-        for problems in _report(found.stdout, found.stderr).values()
-        for problem in problems
-        # The name starts after `SELECT `, at the eighth character.
-        if problem.get("message") == "Unparsable section"
-        and problem["range"]["start"]["character"] == len("SELECT ") + 1
-    }
-    return {name for number, name in enumerate(names, 1) if number in lines}
-
-
-def _report(*outputs: str) -> dict[str, list[dict[str, Any]]]:
-    """Return the JSON report, from whichever stream `sqruff` wrote it to."""
-    for output in outputs:
-        try:
-            report = json.loads(output)
-        except json.JSONDecodeError:
-            continue
-        if isinstance(report, dict):
-            return report
-    return {}
-
-
-def _toml_value(value: object) -> str:
-    """Return a value as TOML writes it: a string quoted, a flag in lower case."""
-    if isinstance(value, bool):
-        return str(value).lower()
-    if isinstance(value, int | float):
-        return str(value)
-    return json.dumps(str(value))