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

execsql/db/mysql.py

@@ -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,
@@ -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/postgres.py

@@ -353,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/exporters/xls.py

@@ -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
@@ -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/gui/__init__.py

@@ -1,4 +1,4 @@
-"""GUI backend factory and manager thread for execsql.
+"""The GUI manager thread for execsql.
 
 Usage
 -----
@@ -7,7 +7,7 @@ and start the manager thread.  All dialog requests are then placed on
 ``_state.gui_manager_queue`` as ``GuiSpec`` objects and dispatched by
 ``gui_manager_loop()``.
 
-Backend selection (framework-based, not level-based):
+``enable_gui()`` picks the backend by framework, not by level:
 
     framework "tkinter" → TkinterBackend → TextualBackend → ConsoleBackend
     framework "textual" → TextualBackend → ConsoleBackend
@@ -21,35 +21,7 @@ from typing import TYPE_CHECKING, Any
 if TYPE_CHECKING:
     from execsql.gui.base import GuiBackend
 
-__all__ = ["get_backend", "gui_manager_loop"]
-
-
-def get_backend(framework: str = "tkinter") -> GuiBackend:
-    """Return the best available backend for *framework*.
-
-    Falls back gracefully if the preferred backend's dependencies are missing.
-    """
-    if framework == "tkinter":
-        try:
-            from execsql.gui.desktop import TkinterBackend
-
-            backend = TkinterBackend()
-            backend.start()
-            return backend
-        except (ImportError, RuntimeError, Exception):
-            pass
-
-    # Textual path (framework == "textual", or tkinter unavailable)
-    try:
-        from execsql.gui.tui import TextualBackend
-
-        return TextualBackend()
-    except ImportError:
-        pass
-
-    from execsql.gui.console import ConsoleBackend
-
-    return ConsoleBackend()
+__all__ = ["gui_manager_loop"]
 
 
 def gui_manager_loop(q: queue.Queue[Any], backend: GuiBackend) -> None:

execsql/lsp/_util.py

@@ -0,0 +1,21 @@
+"""Small helpers several language-server features share."""
+
+from __future__ import annotations
+
+import re
+
+from lsprotocol import types
+
+__all__ = ["RX_METACOMMAND", "markdown", "span"]
+
+# A metacommand line: the ``-- !x!`` marker (with its spacing) and the command after it.
+RX_METACOMMAND = re.compile(r"^(?P<lead>\s*--\s*!x!\s*)(?P<command>.*?)\s*$", re.I)
+
+
+def span(line: int, start: int, end: int) -> types.Range:
+    """The characters *start* to *end* of zero-based *line*."""
+    return types.Range(start=types.Position(line=line, character=start), end=types.Position(line=line, character=end))
+
+
+def markdown(text: str) -> types.MarkupContent:
+    return types.MarkupContent(kind=types.MarkupKind.Markdown, value=text)

execsql/lsp/cache.py

@@ -0,0 +1,73 @@
+"""What the server keeps between requests, so each one reparses only what changed.
+
+Every feature request indexes the current document together with every file
+it ``INCLUDE``s.  Without this, a script with fifty large includes rereads and
+reparses all of them on each completion, hover or definition request.
+"""
+
+from __future__ import annotations
+
+from collections import OrderedDict
+from pathlib import Path
+
+from execsql.lsp.document import FileFacts, file_facts, read_included, same_file_key
+
+__all__ = ["IndexCache"]
+
+# Characters of file text held at most (included files' text plus the texts facts were taken from).
+MAX_CACHED_CHARS = 64 * 1024 * 1024
+
+
+class IndexCache:
+    """Included files' text, by path and the file's size and modification time, and each text's :class:`FileFacts`."""
+
+    def __init__(self, max_chars: int = MAX_CACHED_CHARS) -> None:
+        self.max_chars = max_chars
+        self._texts: OrderedDict[tuple[str, int, int], str | None] = OrderedDict()
+        self._facts: OrderedDict[tuple[str | None, str | None, str], FileFacts] = OrderedDict()
+        self._chars = 0
+
+    def text(self, path: Path) -> str | None:
+        """:func:`read_included` of *path*, read again only when the file's size or modification time changed."""
+        try:
+            stat = path.stat()
+        except (OSError, ValueError):  # missing, unreadable, or a name the OS rejects
+            return None
+        key = (str(path), stat.st_mtime_ns, stat.st_size)
+        if key in self._texts:
+            self._texts.move_to_end(key)
+            return self._texts[key]
+        text = read_included(path)
+        self._texts[key] = text
+        self._grow(len(text or ""))
+        return text
+
+    def facts(self, source: str, path: str | None, base_dir: str | None = None) -> FileFacts:
+        """:func:`file_facts` of *source*, taken again only when its text or paths differ, or it reads an INI file."""
+        key = (path, base_dir, source)
+        found = self._facts.get(key)
+        if found is not None and not found.reads_ini:
+            self._facts.move_to_end(key)
+            return found
+        found = file_facts(source, path, base_dir)
+        if key not in self._facts:
+            self._grow(len(source))
+        self._facts[key] = found
+        return found
+
+    def forget(self, path: str) -> None:
+        """Drop what was read from the file at *path*: the client says it changed."""
+        changed = same_file_key(path)
+        for key in [k for k in self._texts if same_file_key(k[0]) == changed]:
+            self._chars -= len(self._texts.pop(key) or "")
+
+    def _grow(self, chars: int) -> None:
+        self._chars += chars
+        while self._chars > self.max_chars and (self._texts or self._facts):
+            # From the kind holding more entries, least recently used first.
+            if self._texts and (not self._facts or len(self._texts) >= len(self._facts)):
+                _, text = self._texts.popitem(last=False)
+                self._chars -= len(text or "")
+            else:
+                (_, _, source), _ = self._facts.popitem(last=False)
+                self._chars -= len(source)

execsql/lsp/code_actions.py

@@ -18,14 +18,14 @@ from collections.abc import Iterator, Sequence
 
 from lsprotocol import types
 
-from execsql.cli.lint import _dispatch_table, _with_placeholders, lint_source
+from execsql.cli.lint import _dispatch_table, lint_source
 from execsql.format import open_dollar_quote
 from execsql.lsp.document import ScriptIndex
 from execsql.metacommands import reference
+from execsql.lsp._util import RX_METACOMMAND, span
 
 __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
@@ -53,10 +53,6 @@ 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,
@@ -81,7 +77,7 @@ def _clears(lines: list[str], path: str | None, code: str, before: tuple[int, in
 
 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)
+    m = RX_METACOMMAND.match(text)
     if not m:
         return
     vocabulary = _vocabulary()
@@ -93,7 +89,7 @@ def _metacommand_fixes(text: str, row: int) -> Iterator[tuple[str, int, int, str
             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:
+            if table.get_match(fixed) is not None:
                 yield candidate, offset + word.start(), offset + word.end(), word.group()
 
 
@@ -104,7 +100,7 @@ def _p003(uri: str, lines: list[str], diagnostic: types.Diagnostic) -> list[type
             f"Change {written} to {_cased_like(candidate, written)}",
             uri,
             diagnostic,
-            [types.TextEdit(range=_range(row, start, end), new_text=_cased_like(candidate, written))],
+            [types.TextEdit(range=span(row, start, end), new_text=_cased_like(candidate, written))],
         )
         for candidate, start, end, written in _metacommand_fixes(lines[row], row)
     ]
@@ -113,7 +109,7 @@ def _p003(uri: str, lines: list[str], diagnostic: types.Diagnostic) -> list[type
 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)
+    m = RX_METACOMMAND.match(text)
     if not m:
         return []
     names = {c.name for c in reference.conditions() if c.name not in ("NOT", "OR")}
@@ -126,7 +122,7 @@ def _p004(uri: str, path: str | None, lines: list[str], diagnostic: types.Diagno
         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)
+                edit = types.TextEdit(range=span(row, word.start(), word.end()), new_text=new)
                 actions.append(_fix(f"Change {word.group()} to {new}", uri, diagnostic, [edit]))
     return actions
 
@@ -151,7 +147,7 @@ def _v001(index: ScriptIndex, uri: str, diagnostic: types.Diagnostic) -> list[ty
             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)
+            edit = types.TextEdit(range=span(row, loc.start, loc.end), new_text=new)
             actions.append(_fix(f"Change !!{ref.name}!! to !!{new}!!", uri, diagnostic, [edit]))
         break
     return actions
@@ -183,8 +179,8 @@ def _p002(uri: str, path: str | None, lines: list[str], diagnostic: types.Diagno
     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"),
+        types.TextEdit(range=span(row, 0, 0), new_text=f"{indent}-- !x! BEGIN SQL\n"),
+        types.TextEdit(range=span(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)]
 

execsql/lsp/completion.py

@@ -14,6 +14,7 @@ from lsprotocol import types
 
 from execsql.lsp.document import ScriptIndex
 from execsql.metacommands import reference
+from execsql.lsp._util import markdown, span
 
 __all__ = ["completions"]
 
@@ -27,17 +28,9 @@ _RX_EXPORT_FORMAT = re.compile(r"^\s*--\s*!x!\s*EXPORT\b.*\bAS\s+(?P<partial>\w*
 _RX_IS_METACOMMAND = re.compile(r"^\s*--\s*!x!", re.I)
 
 
-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 _markdown(text: str) -> types.MarkupContent:
-    return types.MarkupContent(kind=types.MarkupKind.Markdown, value=text)
-
-
 def _metacommand_doc(entry: reference.Metacommand) -> types.MarkupContent:
     forms = "\n".join(entry.forms)
-    return _markdown(f"{entry.summary}\n\n```\n{forms}\n```\n\n[Reference]({entry.url})")
+    return markdown(f"{entry.summary}\n\n```\n{forms}\n```\n\n[Reference]({entry.url})")
 
 
 def _keyword_items(line: int, start: int, end: int, typed: str, snippets: bool) -> list[types.CompletionItem]:
@@ -59,7 +52,7 @@ def _keyword_items(line: int, start: int, end: int, typed: str, snippets: bool)
                     filter_text=entry.keyword,
                     sort_text=f"{entry.keyword}\x00{n:03d}",
                     text_edit=types.TextEdit(
-                        range=_range(line, start, end),
+                        range=span(line, start, end),
                         new_text=reference.to_snippet(form) if snippets else entry.keyword,
                     ),
                     insert_text_format=types.InsertTextFormat.Snippet if snippets else types.InsertTextFormat.PlainText,
@@ -78,9 +71,9 @@ def _condition_items(line: int, start: int, end: int, snippets: bool) -> list[ty
                 label=entry.name,
                 kind=types.CompletionItemKind.Function,
                 detail=entry.forms[0],
-                documentation=_markdown(f"{entry.summary}\n\n```\n{entry.forms[0]}\n```\n\n[Reference]({entry.url})"),
+                documentation=markdown(f"{entry.summary}\n\n```\n{entry.forms[0]}\n```\n\n[Reference]({entry.url})"),
                 text_edit=types.TextEdit(
-                    range=_range(line, start, end),
+                    range=span(line, start, end),
                     new_text=entry.snippet if snippets else entry.name,
                 ),
                 insert_text_format=types.InsertTextFormat.Snippet if snippets else types.InsertTextFormat.PlainText,
@@ -107,9 +100,9 @@ def _variable_items(
                 label=name,
                 kind=kind,
                 detail=detail,
-                documentation=_markdown(doc) if doc else None,
+                documentation=markdown(doc) if doc else None,
                 text_edit=types.TextEdit(
-                    range=_range(line, start, end),
+                    range=span(line, start, end),
                     new_text=(snippet if use_snippet and snippet is not None else name) + closing,
                 ),
                 insert_text_format=types.InsertTextFormat.Snippet if use_snippet else types.InsertTextFormat.PlainText,
@@ -182,7 +175,7 @@ def completions(
                     label=fmt.upper(),
                     kind=types.CompletionItemKind.EnumMember,
                     detail="export format",
-                    text_edit=types.TextEdit(range=_range(line, start, character), new_text=fmt.upper()),
+                    text_edit=types.TextEdit(range=span(line, start, character), new_text=fmt.upper()),
                 )
                 for fmt in sorted(ALL_EXPORT_FORMATS)
             ],

execsql/lsp/diagnostics.py

@@ -44,18 +44,30 @@ def diagnostics(
     path: str | None,
     select: tuple[str, ...] = (),
     ignore: tuple[str, ...] = (),
+    base_dir: str | None = None,
 ) -> list[types.Diagnostic]:
     """Lint *source* (the editor's current text of the file at *path*).
 
-    *path* lets lint resolve ``INCLUDE`` targets relative to the file;
+    *path* lets lint resolve ``INCLUDE`` targets relative to the file (an
+    unsaved buffer's, with no *path*, resolve against *base_dir*);
     *select* and *ignore* are rule-code prefixes, as ``execsql lint`` takes
     them from ``--select`` / ``--ignore`` or a config file's ``[lint]``.
     """
-    issues = filter_issues(lint_source(source, path or "<untitled>", path), select, ignore)
+    issues = filter_issues(lint_source(source, path or "<untitled>", path, base_dir), select, ignore)
     lines = source.splitlines()
     return [to_diagnostic(issue, lines) for issue in sorted(issues, key=lambda i: (i.line, i.code))]
 
 
+def failure_diagnostic(exc: BaseException) -> types.Diagnostic:
+    """Stands in for lint's findings when checking the script raised an unexpected error."""
+    return types.Diagnostic(
+        range=types.Range(start=types.Position(line=0, character=0), end=types.Position(line=0, character=0)),
+        message=f"execsql could not check this script ({type(exc).__name__}: {exc}).",
+        severity=types.DiagnosticSeverity.Error,
+        source="execsql",
+    )
+
+
 def too_deep_diagnostic() -> types.Diagnostic:
     """Stands in for lint's findings on a script nested too deeply to parse."""
     return types.Diagnostic(