execsql2 2.27.0__py3-none-any.whl → 2.29.0__py3-none-any.whl

execsql/cli/commands/format.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 from pathlib import Path
 
 import typer
+from rich.markup import escape
 
 from execsql.cli.application import ExecsqlCommand, app
 from execsql.cli.help import _err_console
@@ -90,7 +91,7 @@ def format_cmd(
         try:
             _require_sqlglot()
         except ImportError as exc:
-            _err_console.print(f"[bold red]Error:[/bold red] {exc}", highlight=False)
+            _err_console.print(f"[bold red]Error:[/bold red] {escape(str(exc))}", highlight=False)
             raise typer.Exit(code=1) from exc
     raise typer.Exit(
         code=run_formatter(

execsql/cli/commands/lsp.py

@@ -3,13 +3,31 @@
 from __future__ import annotations
 
 import typer
+from rich.markup import escape
 
 from execsql.cli.application import ExecsqlCommand, app
 from execsql.cli.help import _err_console
+from execsql.utils.errors import install_hint
 
 __all__ = ["lsp_cmd"]
 
 
+def _lsp_libraries_installed() -> bool:
+    """Whether pygls and lsprotocol are installed (whether or not this execsql can use them)."""
+    from importlib.util import find_spec
+
+    return all(find_spec(name) is not None for name in ("pygls", "lsprotocol"))
+
+
+def _pygls_version() -> str:
+    from importlib.metadata import PackageNotFoundError, version
+
+    try:
+        return version("pygls")
+    except PackageNotFoundError:
+        return "unknown"
+
+
 @app.command(
     cls=ExecsqlCommand,
     name="lsp",
@@ -17,24 +35,30 @@ __all__ = ["lsp_cmd"]
         "Run the execsql language server on stdin/stdout, for an editor to start. "
         "Shows execsql lint findings as you type, completes metacommands, "
         "conditional tests and variables, explains them on hover, and finds where variables, "
-        "SCRIPTs and included files are defined, offers quick fixes, and formats documents. Needs the lsp extra "
-        "(installed with any extras you already have, e.g. execsql2[postgres,lsp])."
+        "SCRIPTs and included files are defined, offers quick fixes, and formats documents. Requires the lsp "
+        "extra; --check reports whether it is installed."
     ),
 )
 def lsp_cmd(
     # Editors' language clients pass --stdio (VS Code always does); stdio is the only transport.
     stdio: bool = typer.Option(False, "--stdio", hidden=True),
+    check: bool = typer.Option(False, "--check", help="Report whether the language server can start, and exit."),
 ) -> None:
     """The ``lsp`` command; its user-facing help is the decorator's ``help``."""
     try:
         from execsql.lsp.server import create_server
     except ImportError as exc:
-        _err_console.print(
-            "[bold red]Error:[/bold red] execsql lsp needs the lsp extra. Install it with the "
-            'extras you already have, e.g. uv tool install "execsql2\\[postgres,lsp]" or '
-            'pipx install --force "execsql2\\[postgres,lsp]". '
-            "See https://execsql2.readthedocs.io/en/latest/getting-started/installation/#adding-an-extra-later",
-            highlight=False,
-        )
+        if _lsp_libraries_installed():
+            # pygls is there but this execsql cannot use it (another major version, a broken install).
+            message = (
+                f"execsql lsp cannot use the installed pygls {_pygls_version()} ({exc}). "
+                f"It needs pygls 2.x, which the lsp extra installs. {install_hint('lsp')}"
+            )
+        else:
+            message = f"execsql lsp needs the lsp extra. {install_hint('lsp')}"
+        _err_console.print(f"[bold red]Error:[/bold red] {escape(message)}", highlight=False)
         raise typer.Exit(code=1) from exc
+    if check:
+        typer.echo(f"execsql lsp is ready (pygls {_pygls_version()}).")
+        return
     create_server().start_io()

execsql/cli/lint.py

@@ -48,6 +48,7 @@ Public surface:
 
 from __future__ import annotations
 
+import functools
 import json
 import re
 from collections import Counter
@@ -460,23 +461,40 @@ def _read_ini_vars(
     language server; a file that is unreadable or not valid INI defines
     nothing.
     """
-    from configparser import ConfigParser
-    from configparser import Error as ConfigError
-
     p = Path(ini_file)
     if not p.is_absolute() and script_dir is not None:
         p = script_dir / p
+    try:
+        if not p.is_file():
+            return
+        stat = p.stat()
+        if stat.st_size > _MAX_INI_BYTES:
+            return
+        resolved = str(p.resolve())
+    except OSError:
+        return
+    defined_vars.update(_ini_section_keys(resolved, stat.st_size, stat.st_mtime_ns, section))
+
+
+@functools.lru_cache(maxsize=64)
+def _ini_section_keys(path: str, size: int, mtime_ns: int, section: str) -> frozenset[str]:
+    """The upper-cased keys of *section* in the INI file at *path*.
+
+    Cached by the file's size and modification time: a script that names
+    the same file on many SUB_INI lines, and the language server re-linting
+    on every edit, read it once.
+    """
+    from configparser import ConfigParser
+    from configparser import Error as ConfigError
 
     cp = ConfigParser()
     try:
-        if not p.is_file() or p.stat().st_size > _MAX_INI_BYTES:
-            return
-        cp.read_string(p.read_text(encoding="utf-8"), source=str(p))
+        cp.read_string(Path(path).read_text(encoding="utf-8"), source=path)
     except (OSError, UnicodeDecodeError, ConfigError):
-        return
-    if cp.has_section(section):
-        for key, _value in cp.items(section):
-            defined_vars.add(key.upper())
+        return frozenset()
+    if not cp.has_section(section):
+        return frozenset()
+    return frozenset(key.upper() for key, _value in cp.items(section))
 
 
 def _is_known_var(raw_name: str, defined_vars: set[str]) -> bool:
@@ -834,7 +852,12 @@ def _referencing_text(node: Node) -> list[str]:
     return texts
 
 
-def _check_unused_variables(script: Script, defined: set[str], issues: list[_Issue]) -> None:
+def _check_unused_variables(
+    script: Script,
+    defined: set[str],
+    issues: list[_Issue],
+    script_dir: Path | None = None,
+) -> None:
     """Report variables a SUB defines that nothing ever reads.
 
     Almost always a typo in either the definition or the reference — the two
@@ -845,8 +868,11 @@ def _check_unused_variables(script: Script, defined: set[str], issues: list[_Iss
     referenced: set[str] = set()
     _collect_var_references(script.body, referenced)
     unused = sorted(defined - referenced)
+    lines: dict[str, int] = {}
+    if unused:
+        _definition_lines(script.body, script_dir, lines)
     for name in unused:
-        line = _definition_line(script.body, name)
+        line = lines.get(name, 0)
         issues.append(
             _issue(
                 "V002",
@@ -857,18 +883,15 @@ def _check_unused_variables(script: Script, defined: set[str], issues: list[_Iss
         )
 
 
-def _definition_line(nodes: list[Node], name: str) -> int:
-    """Line of the SUB that defines *name*, or 0 when it cannot be located."""
+def _definition_lines(nodes: list[Node], script_dir: Path | None, lines: dict[str, int]) -> None:
+    """Add to *lines* the line of the first metacommand that defines each variable, in script order."""
     for node in nodes:
         if isinstance(node, MetaCommandStatement):
             probe: set[str] = set()
-            _extract_var_definition(node.command, None, probe)
-            if name in probe:
-                return node.span.start_line
-        found = _definition_line(list(node.children()), name)
-        if found:
-            return found
-    return 0
+            _extract_var_definition(node.command, script_dir, probe)
+            for name in probe:
+                lines.setdefault(name, node.span.start_line)
+        _definition_lines(list(node.children()), script_dir, lines)
 
 
 # ---------------------------------------------------------------------------
@@ -1008,7 +1031,7 @@ def lint(
     )
 
     # Pass 3: whole-script rules, which need every reference collected first
-    _check_unused_variables(script, all_defined, issues)
+    _check_unused_variables(script, all_defined, issues, script_dir)
 
     return issues
 

execsql/db/access.py

@@ -17,7 +17,7 @@ from typing import Any, cast
 from execsql.db.base import Database, _fetched
 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,
@@ -68,7 +68,7 @@ class AccessDatabase(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 Access. {install_hint('odbc')}")
         from execsql.types import dbt_access
 
         super().__init__(
@@ -327,8 +327,8 @@ class AccessDatabase(Database):
             rows = curs.fetchall()
             return [d[0] for d in curs.description], rows
 
-    def select_rowsource(self, sql: str) -> tuple[list[str], Any]:
-        """Return column names and an iterable that yields rows one at a time."""
+    def select_rowsource(self, sql: str, *, decode_bytes: bool = True) -> tuple[list[str], Any]:  # noqa: ARG002
+        """Return column names and an iterable that yields rows one at a time (values as the driver returns them)."""
         # Return 1) a list of column names, and 2) an iterable that yields rows.
         self.dao_flush_check()
         curs = self.cursor()

execsql/db/base.py

@@ -215,21 +215,18 @@ class Database(ABC):
     def quote_literal(self, value: Any) -> str:
         """Return *value* as a SQL string literal, safely escaped.
 
-        Default ANSI/Postgres behaviour: wrap in single quotes, double
-        embedded apostrophes, escape backslashes (so a value containing
-        ``\\'`` cannot terminate the literal on MySQL default mode or
-        PostgreSQL E-strings), and reject embedded NUL bytes (most
-        wire protocols truncate or reject them).
-
-        Override per-DBMS only when the wire protocol requires a different
-        literal form.
+        Standard SQL: wrap in single quotes and double embedded apostrophes;
+        a backslash is an ordinary character.  Embedded NUL bytes are
+        rejected (most wire protocols truncate or reject them).  A DBMS
+        that reads a backslash in a literal as an escape (MySQL) overrides
+        this.
         """
         if value is None:
             return "NULL"
         s = str(value)
         if "\x00" in s:
             raise ValueError("SQL literal contains a NUL byte; refusing to quote.")
-        return "'" + s.replace("\\", "\\\\").replace("'", "''") + "'"
+        return "'" + s.replace("'", "''") + "'"
 
     def paramsubs(self, paramcount: int) -> str:
         """Return a comma-separated string of *paramcount* parameter placeholders."""
@@ -405,8 +402,13 @@ class Database(ABC):
             rows = curs.fetchall()
             return [d[0] for d in curs.description], rows
 
-    def select_rowsource(self, sql: str) -> tuple[list[str], Generator]:
-        """Execute *sql* and return ``(column_names, row_generator)`` for streaming large result sets."""
+    def select_rowsource(self, sql: str, *, decode_bytes: bool = True) -> tuple[list[str], Generator]:
+        """Execute *sql* and return ``(column_names, row_generator)`` for streaming large result sets.
+
+        A binary value (``bytes``) is decoded to text with the connection's
+        encoding, as the exporters expect, unless *decode_bytes* is false:
+        COPY passes false so binary columns reach the target unchanged.
+        """
         # Return 1) a list of column names, and 2) an iterable that yields rows.
         curs = self.cursor()
         try:
@@ -433,7 +435,7 @@ class Database(ABC):
                         break
                     else:
                         for row in rows:
-                            if self.encoding:
+                            if self.encoding and decode_bytes:
                                 yield [
                                     c.decode(self.encoding, "backslashreplace") if isinstance(c, bytes) else c
                                     for c in row
@@ -501,6 +503,15 @@ class Database(ABC):
         """The schema (MySQL: database) an unqualified table name is created in, or ``None`` if unknown."""
         return None
 
+    def table_exists_where_created(self, table_name: str, schema_name: str | None = None) -> bool:
+        """Whether *table_name* exists where a ``CREATE TABLE`` on this connection would put it.
+
+        The same as :meth:`table_exists`, except on a connection that sees
+        tables of other databases (DuckDB ``ATTACH``): only the current
+        database counts there.
+        """
+        return self.table_exists(table_name, schema_name)
+
     def _query_current_schema(self, sql: str) -> str | None:
         with self._cursor() as curs:
             curs.execute(sql)

execsql/db/dsn.py

@@ -12,7 +12,7 @@ the CLI.
 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,
@@ -51,7 +51,7 @@ class DsnDatabase(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 through an ODBC DSN. {install_hint('odbc')}")
         from execsql.types import dbt_dsn
 
         super().__init__(

execsql/db/duckdb.py

@@ -14,7 +14,7 @@ from typing import Any
 
 from execsql.db.base import Database, statement_start
 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
 import execsql.state as _state
 
 __all__ = ["DuckDBDatabase"]
@@ -62,7 +62,7 @@ class DuckDBDatabase(Database):
         try:
             import duckdb  # noqa: F401
         except Exception:
-            fatal_error("The duckdb module is required.")
+            fatal_error(f"The duckdb module is required to use DuckDB. {install_hint('duckdb')}")
         from execsql.types import dbt_duckdb
 
         super().__init__(
@@ -167,6 +167,18 @@ class DuckDBDatabase(Database):
                 self.rollback()
                 raise
 
+    def table_exists_where_created(self, table_name: str, schema_name: str | None = None) -> bool:
+        """Whether *table_name* exists in the current database (not an ``ATTACH``ed one)."""
+        # information_schema.tables lists the tables of every attached database.
+        sql = "select table_name from information_schema.tables where table_name = ? and table_catalog = current_database()"
+        params: list = [table_name]
+        if schema_name:
+            sql += " and table_schema = ?"
+            params.append(schema_name)
+        with self._cursor() as curs:
+            curs.execute(sql, params)
+            return len(curs.fetchall()) > 0
+
     def view_exists(self, view_name: str, schema_name: str | None = None) -> bool:
         """Return True if the named view exists in the DuckDB database."""
         # DuckDB information_schema has no 'views' table; views are listed in 'tables'

execsql/db/firebird.py

@@ -11,7 +11,7 @@ via the ``firebird-driver`` package.  Corresponds to ``-t f`` on the CLI.
 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,
@@ -46,8 +46,7 @@ class FirebirdDatabase(Database):
             from firebird import driver as firebird_lib  # noqa: F401
         except Exception:
             fatal_error(
-                "The firebird-driver module is required to connect to Firebird.   "
-                "See https://pypi.org/project/firebird-driver/",
+                f"The firebird-driver module is required to connect to Firebird. {install_hint('firebird')}",
             )
         from execsql.types import dbt_firebird
 

execsql/db/mysql.py

@@ -12,7 +12,7 @@ from typing import Any, cast
 
 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,
@@ -67,6 +67,20 @@ class MySQLDatabase(Database):
         re.I,
     )
 
+    def quote_literal(self, value: Any) -> str:
+        """Return *value* as a string literal for MySQL/MariaDB.
+
+        Unless ``NO_BACKSLASH_ESCAPES`` is set, MySQL reads a backslash in a
+        literal as an escape, so ``\\'`` would end it: backslashes are doubled
+        as well as apostrophes.
+        """
+        if value is None:
+            return "NULL"
+        s = str(value)
+        if "\x00" in s:
+            raise ValueError("SQL literal contains a NUL byte; refusing to quote.")
+        return "'" + s.replace("\\", "\\\\").replace("'", "''") + "'"
+
     def __init__(
         self,
         server_name: str,
@@ -81,7 +95,7 @@ class MySQLDatabase(Database):
             import pymysql as mysql_lib  # noqa: F401
         except Exception:
             fatal_error(
-                "The pymysql module is required to connect to MySQL.   See https://pypi.python.org/pypi/PyMySQL",
+                f"The pymysql module is required to connect to MySQL. {install_hint('mysql')}",
             )
         from execsql.types import dbt_mysql
 
@@ -307,10 +321,12 @@ class MySQLDatabase(Database):
         table_cols = self.table_columns(table_name, schema_name)
         data_table_cols = [d.lower() for d in table_cols]
         csv_file_cols = csv_file_obj.column_headers()
+        # MySQL column names are case-insensitive: compare without case, and
+        # send the file's own spelling.
         if _state.conf.import_common_cols_only:
-            import_cols = [col for col in csv_file_cols if col in data_table_cols]
+            import_cols = [col for col in csv_file_cols if col.lower() in data_table_cols]
         else:
-            unmatched_cols = list(set(csv_file_cols) - set(data_table_cols))
+            unmatched_cols = [col for col in csv_file_cols if col.lower() not in data_table_cols]
             if len(unmatched_cols) > 0:
                 raise ErrInfo(
                     type="error",
@@ -326,7 +342,7 @@ class MySQLDatabase(Database):
         # reads the format that was detected.
         if (
             csv_file_obj.escapechar is None
-            and data_table_cols == csv_file_cols
+            and data_table_cols == [col.lower() for col in csv_file_cols]
             and _state.conf.empty_strings
             and _state.conf.empty_rows
             and not _state.conf.del_empty_cols

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
 
@@ -354,7 +353,7 @@ class PostgresDatabase(Database):
             from execsql.exporters.delimited import blank_lines_as_empty_rows
 
             # Use Postgres' COPY FROM method via psycopg3's cursor.copy() context manager.
-            rf = csv_file_obj.open("rt")
+            rf = csv_file_obj.openclean("rt")  # past the SKIP lines, as every other reader starts
             if skipheader:
                 next(rf)
             # Copy_from() requires a delimiter, but if there is none, feed it an

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
@@ -158,7 +158,7 @@ class XlsFile:
                 break
             ncols += 1
         sheet_data = []
-        for r in range(junk_header_rows, sheet.nrows - junk_header_rows):
+        for r in range(junk_header_rows, sheet.nrows):
             datarow = row_data(r, ncols)
             if datarow.count(None) == len(datarow):
                 break
@@ -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
@@ -270,7 +270,8 @@ class XlsxFile:
         sheet_data = []
         rowsrc = sheet.iter_rows(min_row=junk_header_rows + 1, values_only=True)
         for r in rowsrc:
-            if not any(r):
+            # A row of zeros or FALSE values is data; only a row of empty cells ends it.
+            if all(c is None or c == "" for c in r):
                 break
             sheet_data.append(list(r))
         for r in range(len(sheet_data)):

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')}",
         )