execsql2 2.26.0__py3-none-any.whl → 2.28.0__py3-none-any.whl

execsql/db/oracle.py

@@ -14,7 +14,7 @@ from typing import Any
 from execsql.db.base import Database
 from execsql.db.tiers import SupportTier
 from execsql.exceptions import ErrInfo
-from execsql.utils.errors import exception_desc, fatal_error
+from execsql.utils.errors import exception_desc, fatal_error, install_hint
 from execsql.utils.auth import (
     begin_login,
     clear_stored_password,
@@ -76,7 +76,7 @@ class OracleDatabase(Database):
     ) -> None:
         if _oracle_driver() is None:
             fatal_error(
-                'The oracledb module is required to connect to Oracle. Install it with: pip install "execsql2[oracle]"',
+                f"The oracledb module is required to connect to Oracle. {install_hint('oracle')}",
             )
         from execsql.types import dbt_oracle
 
@@ -164,12 +164,12 @@ class OracleDatabase(Database):
         else:
             return super().select_data(sql)
 
-    def select_rowsource(self, sql: str) -> Any:
+    def select_rowsource(self, sql: str, *, decode_bytes: bool = True) -> Any:
         """Return column names and an iterable that yields rows one at a time."""
         if sql[-1:] == ";":
-            return super().select_rowsource(sql[:-1])
+            return super().select_rowsource(sql[:-1], decode_bytes=decode_bytes)
         else:
-            return super().select_rowsource(sql)
+            return super().select_rowsource(sql, decode_bytes=decode_bytes)
 
     def select_rowdict(self, sql: str) -> Any:
         """Return column names and an iterable that yields rows as dictionaries."""

execsql/db/postgres.py

@@ -15,7 +15,7 @@ from typing import Any
 
 from execsql.db.base import Database
 from execsql.exceptions import ErrInfo
-from execsql.utils.errors import exception_desc, fatal_error
+from execsql.utils.errors import exception_desc, fatal_error, install_hint
 from execsql.utils.auth import (
     begin_login,
     clear_stored_password,
@@ -51,8 +51,7 @@ class PostgresDatabase(Database):
             import psycopg  # noqa: F401
         except Exception:
             fatal_error(
-                "The psycopg module (psycopg3) is required to connect to PostgreSQL.   "
-                "See https://www.psycopg.org/psycopg3/",
+                f"The psycopg module (psycopg3) is required to connect to PostgreSQL. {install_hint('postgres')}",
             )
         from execsql.types import dbt_postgres
 

execsql/db/sqlserver.py

@@ -11,7 +11,7 @@ import re
 
 from execsql.db.base import Database
 from execsql.exceptions import ErrInfo
-from execsql.utils.errors import fatal_error
+from execsql.utils.errors import fatal_error, install_hint
 from execsql.utils.auth import (
     begin_login,
     clear_stored_password,
@@ -41,7 +41,7 @@ class SqlServerDatabase(Database):
         try:
             import pyodbc  # noqa: F401
         except Exception:
-            fatal_error("The pyodbc module is required.  See http://github.com/mkleehammer/pyodbc")
+            fatal_error(f"The pyodbc module is required to connect to SQL Server. {install_hint('mssql')}")
         from execsql.types import dbt_sqlserver
 
         super().__init__(

execsql/exporters/duckdb.py

@@ -33,9 +33,9 @@ def export_duckdb(
     try:
         import duckdb
     except Exception:
-        from execsql.utils.errors import fatal_error
+        from execsql.utils.errors import fatal_error, install_hint
 
-        fatal_error("The duckdb module is required to export data in that format.")
+        fatal_error(f"The duckdb module is required to export data in that format. {install_hint('duckdb')}")
         return
 
     from execsql.models import DataTable

execsql/exporters/ods.py

@@ -20,7 +20,7 @@ import execsql.state as _state
 from execsql.exceptions import OdsFileError
 from execsql.exceptions import ErrInfo
 from execsql.script import current_script_line
-from execsql.utils.errors import exception_desc, fatal_error
+from execsql.utils.errors import exception_desc, fatal_error, install_hint
 from execsql.utils.fileio import filewriter_close
 from execsql.utils.strings import unquoted
 
@@ -57,7 +57,7 @@ class OdsFile:
             import odf.number  # noqa: F401
             import odf.style  # noqa: F401
         except ImportError:
-            fatal_error("The odfpy library is needed to create OpenDocument spreadsheets.")
+            fatal_error(f"The odfpy library is needed to create OpenDocument spreadsheets. {install_hint('formats')}")
         self.filename: str | None = None
         self.wbk: Any = None
         self.cell_style_names: list[str] = []

execsql/exporters/templates.py

@@ -14,7 +14,7 @@ from typing import Any
 
 import execsql.state as _state
 from execsql.exceptions import ErrInfo
-from execsql.utils.errors import fatal_error
+from execsql.utils.errors import fatal_error, install_hint
 from execsql.utils.fileio import filewriter_close
 
 __all__ = ["StrTemplateReport", "JinjaTemplateReport", "report_query"]
@@ -91,7 +91,7 @@ class JinjaTemplateReport:
             self._jinja2 = jinja2
         except ImportError:
             fatal_error(
-                "The jinja2 library is required to produce reports with the Jinja2 templating system.   See http://jinja.pocoo.org/",
+                f"The jinja2 library is required to produce reports with the Jinja2 templating system. {install_hint('formats')}",
             )
         conf = _state.conf
         template_root = getattr(conf, "template_root", None)

execsql/exporters/xls.py

@@ -22,7 +22,7 @@ from pathlib import Path
 from typing import Any, cast
 
 from execsql.exceptions import XlsFileError, XlsxFileError
-from execsql.utils.errors import fatal_error
+from execsql.utils.errors import fatal_error, install_hint
 
 __all__ = ["XlsFile", "XlsxFile"]
 
@@ -51,7 +51,7 @@ class XlsFile:
 
             self._xlrd = xlrd
         except ImportError:
-            fatal_error("The xlrd library is needed to read Excel (.xls) spreadsheets.")
+            fatal_error(f"The xlrd library is needed to read Excel (.xls) spreadsheets. {install_hint('formats')}")
         self.filename: str | None = None
         self.encoding: str | None = None
         self.wbk: Any = None
@@ -190,7 +190,7 @@ class XlsxFile:
 
             self._openpyxl = openpyxl
         except ImportError:
-            fatal_error("The openpyxl library is needed to read Excel (.xlsx) spreadsheets.")
+            fatal_error(f"The openpyxl library is needed to read Excel (.xlsx) spreadsheets. {install_hint('formats')}")
         self.filename: str | None = None
         self.encoding: str | None = None
         self.wbk: Any = None

execsql/exporters/xlsx.py

@@ -20,7 +20,7 @@ from execsql.exceptions import ErrInfo
 from execsql.exporters.base import ExportRecord
 from execsql.exporters.pretty import prettyprint_query
 from execsql.script import current_script_line
-from execsql.utils.errors import exception_desc, fatal_error
+from execsql.utils.errors import exception_desc, fatal_error, install_hint
 from execsql.utils.fileio import filewriter_close
 from execsql.utils.strings import unquoted
 
@@ -39,7 +39,7 @@ def _require_openpyxl() -> Any:
         return openpyxl
     except ImportError:
         fatal_error(
-            "The openpyxl library is needed to write Excel (.xlsx) spreadsheets (install the formats extra, execsql2[formats]).",
+            f"The openpyxl library is needed to write Excel (.xlsx) spreadsheets. {install_hint('formats')}",
         )
 
 

execsql/exporters/yaml.py

@@ -6,8 +6,7 @@ YAML export for execsql.
 Provides :func:`write_query_to_yaml` which serialises a query result set as a
 YAML sequence of mappings (one mapping per row).
 
-Requires the ``PyYAML`` package (``pip install PyYAML`` or
-``pip install 'execsql2[formats]'``).
+Requires the ``PyYAML`` package (the ``formats`` extra).
 """
 
 from typing import Any
@@ -15,7 +14,7 @@ from typing import Any
 import execsql.state as _state
 from execsql.exceptions import ErrInfo
 from execsql.exporters.zip import ZipWriter
-from execsql.utils.errors import exception_desc
+from execsql.utils.errors import exception_desc, install_hint
 from execsql.utils.fileio import filewriter_close
 
 __all__ = ["write_query_to_yaml"]
@@ -54,7 +53,7 @@ def write_query_to_yaml(
     except ImportError as exc:
         raise ErrInfo(
             "error",
-            other_msg=("PyYAML is required for FORMAT YAML export. Install it with: pip install PyYAML"),
+            other_msg=f"PyYAML is required for FORMAT YAML export. {install_hint('formats')}",
         ) from exc
 
     conf = _state.conf

execsql/format.py

@@ -21,11 +21,14 @@ from types import ModuleType
 __all__ = ["collect_paths", "format_file", "open_dollar_quote", "parse_keyword", "run_formatter"]
 
 
-_SQLGLOT_MISSING_MSG = (
-    "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."
-)
+def _sqlglot_missing_msg() -> str:
+    from execsql.utils.errors import install_hint
+
+    return (
+        "execsql format requires sqlglot for SQL reformatting.\n"
+        f"  {install_hint('formatter')}\n"
+        "  Or skip SQL reformatting with the --no-sql flag."
+    )
 
 
 def _require_sqlglot():
@@ -36,7 +39,7 @@ def _require_sqlglot():
 
         return sqlglot
     except ImportError as e:
-        raise ImportError(_SQLGLOT_MISSING_MSG) from e
+        raise ImportError(_sqlglot_missing_msg()) from e
 
 
 # ---------------------------------------------------------------------------
@@ -532,20 +535,57 @@ def _statement_sources(sqlglot: ModuleType, sql: str) -> list[str]:
     return sources
 
 
-def _layout_tokens(sqlglot: ModuleType, sql: str) -> list[str]:
-    """*sql*'s tokens with everything the formatter may change taken out.
+def _ends_with_semicolon(sqlglot: ModuleType, sql: str) -> bool:
+    """Whether the last token of *sql* is a statement-ending ``;``."""
+    tokens = sqlglot.tokenize(sql, read="postgres")
+    return bool(tokens) and tokens[-1].token_type.name == "SEMICOLON"
+
+
+def _layout_tokens(sqlglot: ModuleType, sql: str) -> list[tuple[str, str]]:
+    """*sql*'s tokens, as (type, text), with everything the formatter may change taken out.
 
-    Whitespace and comments are not tokens.  Keywords and unquoted names are
-    compared without case; strings and quoted names exactly.
+    Whitespace and comments are not tokens.  Keywords and unquoted names
+    (function names included) are compared without case; strings and quoted
+    names exactly.  The type is compared too, so a string that came back as a
+    quoted name of the same text is a change.
     """
     return [
-        token.text
-        if token.token_type.name.endswith("STRING") or token.token_type.name == "IDENTIFIER"
-        else token.text.upper()
+        (
+            token.token_type.name,
+            token.text
+            if token.token_type.name.endswith("STRING") or token.token_type.name == "IDENTIFIER"
+            else token.text.upper(),
+        )
         for token in sqlglot.tokenize(sql, read="postgres")
     ]
 
 
+# An optimizer hint (``/*+ ... */``, Oracle and MySQL) or a MySQL executable
+# comment (``/*! ... */``) is SQL the server reads, though it looks like a
+# comment.  sqlglot keeps neither: it writes them back as ``/* + ... */`` and
+# moves a hint away from its keyword, which disables it.
+_RX_HINT_COMMENT = re.compile(r"/\*[+!]")
+
+
+def _has_hint_comment(sqlglot: ModuleType, sql: str) -> bool:
+    """Whether *sql* holds a hint or executable comment outside its strings and quoted names."""
+    if not _RX_HINT_COMMENT.search(sql):
+        return False
+    tokens = [(t.start, t.end) for t in sqlglot.tokenize(sql, read="postgres")]
+    return any(not any(start <= m.start() <= end for start, end in tokens) for m in _RX_HINT_COMMENT.finditer(sql))
+
+
+def _as_written(source: str) -> str:
+    """A statement's source text to keep as written, without the space that followed the previous ``;``.
+
+    A statement that starts on its own line keeps that line's indentation.
+    """
+    source = source.rstrip()
+    body = source.lstrip()
+    lead = source[: len(source) - len(body)]
+    return source[lead.rfind("\n") + 1 :] if "\n" in lead else body
+
+
 def _sqlglot_format(
     sql_lines: list[str],
     sql_indent: int = 4,
@@ -596,9 +636,10 @@ def _sqlglot_format(
             # parse is left exactly as written.
             ast = sqlglot.parse(protected, read="postgres", error_level=sqlglot_errors.ErrorLevel.RAISE)
             nodes = [node for node in ast if node is not None]
-            sources = None if rewrite_sql else _statement_sources(sqlglot, protected)
-            if sources is not None and len(sources) != len(nodes):
+            sources = _statement_sources(sqlglot, protected)
+            if len(sources) != len(nodes) and (not rewrite_sql or _has_hint_comment(sqlglot, protected)):
                 return sql_lines
+            aligned = len(sources) == len(nodes)
             statements: list[str] = []
             for i, node in enumerate(nodes):
                 # For Command nodes (psql backslash commands, ERROR:, etc.)
@@ -614,20 +655,29 @@ def _sqlglot_format(
                         max_text_width=120,
                     )
                 generated = re.sub(r"\bINTO TEMPORARY\b(?!\s+TABLE)", "INTO TEMPORARY TABLE", generated)
-                if sources is not None and _layout_tokens(sqlglot, generated) != _layout_tokens(sqlglot, sources[i]):
-                    generated = sources[i].lstrip("\n").rstrip()  # layout only: keep it as written
+                if aligned and (
+                    _has_hint_comment(sqlglot, sources[i])
+                    or (not rewrite_sql and _layout_tokens(sqlglot, generated) != _layout_tokens(sqlglot, sources[i]))
+                ):
+                    generated = _as_written(sources[i])
                 statements.append(generated)
         stmts = [s for s in statements if s]
         if not stmts:
             return sql_lines
 
+        # Terminate the last statement only if the source did: execsql refuses
+        # a script whose last statement is unfinished, and formatting must not
+        # turn it into one that runs.
+        terminated = _ends_with_semicolon(sqlglot, protected)
+
         # Safety: if sqlglot produced more statements than the input had
-        # semicolons, it likely split a fragment (e.g. a SELECT column list)
-        # into multiple pseudo-statements.  Fall back to the original text.
-        if len(stmts) > max(input_semis, 1):
+        # semicolons (plus an unterminated last one), it likely split a
+        # fragment (e.g. a SELECT column list) into multiple pseudo-statements.
+        # Fall back to the original text.
+        if len(stmts) > max(input_semis + (0 if terminated else 1), 1):
             return sql_lines
 
-        joined = ";\n".join(stmts) + ";"
+        joined = ";\n".join(stmts) + (";" if terminated else "")
 
         # Content-loss check: sqlglot with IGNORE error level can silently
         # drop tokens it doesn't understand (e.g. ``ERROR: ...``).  If the

execsql/importers/base.py

@@ -16,15 +16,7 @@ from execsql.exceptions import ErrInfo
 from execsql.db.base import Database
 import execsql.state as _state
 
-__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
+__all__ = ["import_data_table", "refuse_existing_table"]
 
 
 def refuse_existing_table(db: Database, schema_name: str | None, table_name: str) -> None:
@@ -43,7 +35,11 @@ def refuse_existing_table(db: Database, schema_name: str | None, table_name: str
             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):
+    try:
+        exists = db.table_exists_where_created(table_name, lookup_schema)
+    except Exception:
+        return  # The database cannot say; CREATE TABLE reports any conflict.
+    if exists:
         name = db.schema_qualified_table_name(schema_name, table_name)
         raise ErrInfo(
             type="cmd",

execsql/lsp/__init__.py

@@ -0,0 +1,6 @@
+"""Language server for execsql scripts: ``execsql lsp``.
+
+Editors start it over stdio. The features are plain functions over a
+document's text, so they are tested without a client; :mod:`.server` wires
+them to the protocol with pygls (the ``lsp`` extra).
+"""

execsql/lsp/code_actions.py

@@ -0,0 +1,217 @@
+"""Quick fixes for lint findings.
+
+Each fix is checked before it is offered: a spelling fix must make the
+metacommand match a dispatch-table form (P003) or make lint's finding go away
+(P004, P002).  A fix that would not clear the finding is never shown.
+
+- P003 unknown metacommand: a misspelled keyword, e.g. ``EXPROT`` -> ``EXPORT``.
+- P004 unknown condition: a misspelled conditional test, e.g. ``HASROWZ`` -> ``HASROWS``.
+- V001 undefined variable: a near-miss of a variable the script defines (or of a system variable).
+- P002 split dollar quote: put the statement between ``BEGIN SQL`` and ``END SQL``.
+"""
+
+from __future__ import annotations
+
+import difflib
+import re
+from collections.abc import Iterator, Sequence
+
+from lsprotocol import types
+
+from execsql.cli.lint import _dispatch_table, _with_placeholders, lint_source
+from execsql.format import open_dollar_quote
+from execsql.lsp.document import ScriptIndex
+from execsql.metacommands import reference
+
+__all__ = ["code_actions"]
+
+_RX_METACOMMAND = re.compile(r"^(?P<lead>\s*--\s*!x!\s*)(?P<command>.*?)\s*$", re.I)
+_RX_WORD = re.compile(r"[A-Za-z_][A-Za-z_0-9]*")
+_RX_UNDEFINED = re.compile(r"!!(?P<name>[^!]+)!!")
+_SUGGESTIONS = 3  # per misspelled word
+_CUTOFF = 0.7
+
+
+def _vocabulary() -> set[str]:
+    """Every literal word of a metacommand's syntax: keywords and words such as TO, AS, WITH."""
+    words: set[str] = set()
+    for entry in reference.metacommands():
+        for form in entry.forms:
+            words.update(re.findall(r"\b[A-Z][A-Z_]+\b", re.sub(r"<[^>]*>", " ", form)))
+    return words
+
+
+def _cased_like(word: str, written: str) -> str:
+    return word.lower() if written.islower() else word
+
+
+def _close(word: str, choices: set[str] | list[str]) -> list[str]:
+    return difflib.get_close_matches(word.upper(), list(choices), n=_SUGGESTIONS, cutoff=_CUTOFF)
+
+
+def _replace(text: str, start: int, end: int, new: str) -> str:
+    return text[:start] + new + text[end:]
+
+
+def _range(line: int, start: int, end: int) -> types.Range:
+    return types.Range(start=types.Position(line=line, character=start), end=types.Position(line=line, character=end))
+
+
+def _fix(title: str, uri: str, diagnostic: types.Diagnostic, edits: list[types.TextEdit]) -> types.CodeAction:
+    return types.CodeAction(
+        title=title,
+        kind=types.CodeActionKind.QuickFix,
+        diagnostics=[diagnostic],
+        edit=types.WorkspaceEdit(changes={uri: edits}),
+    )
+
+
+def _count(source: str, path: str | None, code: str) -> int:
+    return sum(1 for issue in lint_source(source, path or "<untitled>", script_path=path) if issue.code == code)
+
+
+def _clears(lines: list[str], path: str | None, code: str, before: tuple[int, int], row: int, new_line: str) -> bool:
+    """Whether replacing line *row* with *new_line* removes a *code* finding without adding a parse error.
+
+    *before* is the (*code*, P001) count of the unchanged script.
+    """
+    fixed = "\n".join(lines[:row] + [new_line] + lines[row + 1 :]) + "\n"
+    return _count(fixed, path, code) < before[0] and _count(fixed, path, "P001") <= before[1]
+
+
+def _metacommand_fixes(text: str, row: int) -> Iterator[tuple[str, int, int, str]]:
+    """(suggestion, start, end, written) for each word whose replacement makes the metacommand match."""
+    m = _RX_METACOMMAND.match(text)
+    if not m:
+        return
+    vocabulary = _vocabulary()
+    offset = m.start("command")
+    command = m.group("command")
+    table = _dispatch_table()
+    for word in _RX_WORD.finditer(command):
+        if word.group().upper() in vocabulary:
+            continue
+        for candidate in _close(word.group(), vocabulary):
+            fixed = _replace(command, word.start(), word.end(), candidate)
+            if table.get_match(fixed) is not None or table.get_match(_with_placeholders(fixed)) is not None:
+                yield candidate, offset + word.start(), offset + word.end(), word.group()
+
+
+def _p003(uri: str, lines: list[str], diagnostic: types.Diagnostic) -> list[types.CodeAction]:
+    row = diagnostic.range.start.line
+    return [
+        _fix(
+            f"Change {written} to {_cased_like(candidate, written)}",
+            uri,
+            diagnostic,
+            [types.TextEdit(range=_range(row, start, end), new_text=_cased_like(candidate, written))],
+        )
+        for candidate, start, end, written in _metacommand_fixes(lines[row], row)
+    ]
+
+
+def _p004(uri: str, path: str | None, lines: list[str], diagnostic: types.Diagnostic) -> list[types.CodeAction]:
+    row = diagnostic.range.start.line
+    text = lines[row]
+    m = _RX_METACOMMAND.match(text)
+    if not m:
+        return []
+    names = {c.name for c in reference.conditions() if c.name not in ("NOT", "OR")}
+    source = "\n".join(lines) + "\n"
+    before = (_count(source, path, "P004"), _count(source, path, "P001"))
+    actions = []
+    for word in _RX_WORD.finditer(text, m.start("command")):
+        if word.group().upper() in names or not text[word.end() :].lstrip().startswith("("):
+            continue
+        for candidate in _close(word.group(), names):
+            new = _cased_like(candidate, word.group())
+            if _clears(lines, path, "P004", before, row, _replace(text, word.start(), word.end(), new)):
+                edit = types.TextEdit(range=_range(row, word.start(), word.end()), new_text=new)
+                actions.append(_fix(f"Change {word.group()} to {new}", uri, diagnostic, [edit]))
+    return actions
+
+
+def _v001(index: ScriptIndex, uri: str, diagnostic: types.Diagnostic) -> list[types.CodeAction]:
+    m = _RX_UNDEFINED.search(diagnostic.message)
+    if not m:
+        return []
+    row = diagnostic.range.start.line
+    written = m.group("name")
+    actions = []
+    for ref in index.references:
+        loc = ref.location
+        if loc.path != index.path or loc.line != row or ref.name.lower() != written.lower():
+            continue
+        prefix = ref.name[: len(ref.name) - len(ref.name.lstrip("~+"))]
+        bare = ref.name[len(prefix) :]
+        if bare.startswith("$"):
+            choices = {v.name for v in reference.system_variables() if not v.name.endswith("_x")}
+            spelled = {name: name for name in choices}
+        else:
+            spelled = {key: index.spellings[key] for key in index.definitions}
+        for candidate in _close(bare, set(spelled)):
+            new = prefix + spelled[candidate]
+            edit = types.TextEdit(range=_range(row, loc.start, loc.end), new_text=new)
+            actions.append(_fix(f"Change !!{ref.name}!! to !!{new}!!", uri, diagnostic, [edit]))
+        break
+    return actions
+
+
+def _statement_end(lines: list[str], row: int) -> int | None:
+    """The line that ends the statement whose dollar-quoted body opens on *row*."""
+    open_tag: str | None = None
+    for end in range(row, len(lines)):
+        open_tag = open_dollar_quote(lines[end] + "\n", open_tag)
+        if open_tag is None and end > row and lines[end].rstrip().endswith(";"):
+            return end
+    return None
+
+
+def _p002(uri: str, path: str | None, lines: list[str], diagnostic: types.Diagnostic) -> list[types.CodeAction]:
+    row = diagnostic.range.start.line
+    end = _statement_end(lines, row)
+    if end is None:
+        return []
+    indent = lines[row][: len(lines[row]) - len(lines[row].lstrip())]
+    fixed = (
+        lines[:row]
+        + [f"{indent}-- !x! BEGIN SQL"]
+        + lines[row : end + 1]
+        + [f"{indent}-- !x! END SQL"]
+        + lines[end + 1 :]
+    )
+    if _count("\n".join(fixed) + "\n", path, "P002") >= _count("\n".join(lines) + "\n", path, "P002"):
+        return []
+    edits = [
+        types.TextEdit(range=_range(row, 0, 0), new_text=f"{indent}-- !x! BEGIN SQL\n"),
+        types.TextEdit(range=_range(end, len(lines[end]), len(lines[end])), new_text=f"\n{indent}-- !x! END SQL"),
+    ]
+    return [_fix("Put the statement between BEGIN SQL and END SQL", uri, diagnostic, edits)]
+
+
+def code_actions(
+    index: ScriptIndex,
+    uri: str,
+    source: str,
+    diagnostics: Sequence[types.Diagnostic],
+) -> list[types.CodeAction]:
+    """The quick fixes for the execsql *diagnostics* the editor asks about."""
+    lines = source.splitlines()
+    actions: list[types.CodeAction] = []
+    for diagnostic in diagnostics:
+        if diagnostic.source != "execsql" or diagnostic.range.start.line >= len(lines):
+            continue
+        if diagnostic.code == "P003":
+            found = _p003(uri, lines, diagnostic)
+        elif diagnostic.code == "P004":
+            found = _p004(uri, index.path, lines, diagnostic)
+        elif diagnostic.code == "V001":
+            found = _v001(index, uri, diagnostic)
+        elif diagnostic.code == "P002":
+            found = _p002(uri, index.path, lines, diagnostic)
+        else:
+            continue
+        if len(found) == 1:
+            found[0].is_preferred = True
+        actions.extend(found)
+    return actions