execsql2 2.15.8__py3-none-any.whl → 2.16.0__py3-none-any.whl

execsql/metacommands/io_export.py

@@ -56,190 +56,132 @@ def _apply_output_dir(path: str) -> str:
     return str(Path(output_dir) / path)
 
 
-def x_export(**kwargs: Any) -> None:
-    schema = kwargs["schema"]
-    table = kwargs["table"]
-    queryname = _state.dbs.current().schema_qualified_table_name(schema, table)
-    select_stmt = f"select * from {queryname};"
-    outfile = _apply_output_dir(kwargs["filename"])
-    description = kwargs["description"]
-    tee = kwargs["tee"]
-    tee = bool(tee)
-    append = kwargs["append"]
-    append = bool(append)
-    filefmt = kwargs["format"].lower()
-    zipfilename = _apply_output_dir(kwargs["zipfilename"]) if kwargs["zipfilename"] else None
-    if zipfilename is not None:
-        if outfile.lower() == "stdout":
-            raise ErrInfo("error", other_msg="Cannot write stdout to a zipfile.")
-        elif len(outfile) > 1 and outfile[1] == ":":
-            raise ErrInfo("error", other_msg="Cannot use a drive letter for a file path within a zipfile.")
-        if filefmt == "duckdb":
-            raise ErrInfo("error", other_msg="Cannot export to the DuckDB format within a zipfile.")
-        if filefmt == "sqlite":
-            raise ErrInfo("error", other_msg="Cannot export to the SQLite format within a zipfile.")
-        if filefmt == "latex":
-            raise ErrInfo("error", other_msg="Cannot export to the LaTeX format within a zipfile.")
-        if filefmt == "feather":
-            raise ErrInfo("error", other_msg="Cannot export to the feather format within a zipfile.")
-        if filefmt == "parquet":
-            raise ErrInfo("error", other_msg="Cannot export to the parquet format within a zipfile.")
-        if filefmt == "hdf5":
-            raise ErrInfo("error", other_msg="Cannot export to the HDF5 format within a zipfile.")
-        if filefmt == "ods":
-            raise ErrInfo("error", other_msg="Cannot export to an ODS workbook within a zipfile.")
-        if filefmt == "xlsx":
-            raise ErrInfo("error", other_msg="Cannot export to an XLSX workbook within a zipfile.")
-    notype = bool(kwargs.get("notype"))
-    if zipfilename is not None:
-        check_dir(zipfilename)
-    else:
-        check_dir(outfile)
-    if tee and outfile.lower() != "stdout":
-        prettyprint_query(select_stmt, _state.dbs.current(), "stdout", False, desc=description)
+# ---------------------------------------------------------------------------
+# Shared format-dispatch logic
+# ---------------------------------------------------------------------------
+
+# Formats that cannot be written into a zipfile.
+_NO_ZIP_FORMATS = frozenset({"duckdb", "sqlite", "latex", "feather", "parquet", "hdf5", "ods", "xlsx"})
+
+
+def _check_zip_compat(outfile: str, filefmt: str, zipfilename: str | None) -> None:
+    """Raise if the format/outfile combination is incompatible with zip output."""
+    if zipfilename is None:
+        return
+    if outfile.lower() == "stdout":
+        raise ErrInfo("error", other_msg="Cannot write stdout to a zipfile.")
+    if len(outfile) > 1 and outfile[1] == ":":
+        raise ErrInfo("error", other_msg="Cannot use a drive letter for a file path within a zipfile.")
+    if filefmt in _NO_ZIP_FORMATS:
+        raise ErrInfo("error", other_msg=f"Cannot export to the {filefmt} format within a zipfile.")
+
+
+def _dispatch_format(
+    select_stmt: str,
+    outfile: str,
+    filefmt: str,
+    append: bool,
+    *,
+    description: str | None = None,
+    zipfilename: str | None = None,
+    notype: bool = False,
+    sheetname: str | None = None,
+    tablename: str | None = None,
+    xml_table: str | None = None,
+    hdf5_table: str | None = None,
+) -> None:
+    """Execute the appropriate exporter for *filefmt*.
+
+    All format-specific parameters that differ between ``x_export`` and
+    ``x_export_query`` are passed explicitly rather than duplicating the
+    dispatch chain.
+    """
+    db = _state.dbs.current()
     if filefmt in ("txt", "text"):
-        prettyprint_query(
-            select_stmt,
-            _state.dbs.current(),
-            outfile,
-            append,
-            desc=description,
-            zipfile=zipfilename,
-        )
-    elif filefmt in ("txt-and", "text-and", "txt-and", "text-and"):
-        prettyprint_query(
-            select_stmt,
-            _state.dbs.current(),
-            outfile,
-            append,
-            and_val="AND",
-            desc=description,
-            zipfile=zipfilename,
-        )
+        prettyprint_query(select_stmt, db, outfile, append, desc=description, zipfile=zipfilename)
+    elif filefmt in ("txt-and", "text-and"):
+        prettyprint_query(select_stmt, db, outfile, append, and_val="AND", desc=description, zipfile=zipfilename)
     elif filefmt == "ods":
-        write_query_to_ods(
-            select_stmt,
-            _state.dbs.current(),
-            outfile,
-            append,
-            sheetname=queryname,
-            desc=description,
-        )
+        write_query_to_ods(select_stmt, db, outfile, append, sheetname=sheetname, desc=description)
     elif filefmt == "xlsx":
-        write_query_to_xlsx(
-            select_stmt,
-            _state.dbs.current(),
-            outfile,
-            append,
-            sheetname=queryname,
-            desc=description,
-        )
+        write_query_to_xlsx(select_stmt, db, outfile, append, sheetname=sheetname, desc=description)
     elif filefmt == "duckdb":
-        write_query_to_duckdb(select_stmt, _state.dbs.current(), outfile, append, tablename=queryname)
+        write_query_to_duckdb(select_stmt, db, outfile, append, tablename=tablename)
     elif filefmt == "sqlite":
-        write_query_to_sqlite(select_stmt, _state.dbs.current(), outfile, append, tablename=queryname)
+        write_query_to_sqlite(select_stmt, db, outfile, append, tablename=tablename)
     elif filefmt == "xml":
-        write_query_to_xml(
-            select_stmt,
-            table,
-            _state.dbs.current(),
-            outfile,
-            append,
-            desc=description,
-            zipfile=zipfilename,
-        )
+        write_query_to_xml(select_stmt, xml_table, db, outfile, append, desc=description, zipfile=zipfilename)
     elif filefmt == "json":
-        write_query_to_json(
-            select_stmt,
-            _state.dbs.current(),
-            outfile,
-            append,
-            desc=description,
-            zipfile=zipfilename,
-        )
+        write_query_to_json(select_stmt, db, outfile, append, desc=description, zipfile=zipfilename)
     elif filefmt in ("json_ts", "json_tableschema"):
-        write_query_to_json_ts(
-            select_stmt,
-            _state.dbs.current(),
-            outfile,
-            append,
-            not notype,
-            desc=description,
-            zipfile=zipfilename,
-        )
+        write_query_to_json_ts(select_stmt, db, outfile, append, not notype, desc=description, zipfile=zipfilename)
     elif filefmt == "values":
-        write_query_to_values(
-            select_stmt,
-            _state.dbs.current(),
-            outfile,
-            append,
-            desc=description,
-            zipfile=zipfilename,
-        )
+        write_query_to_values(select_stmt, db, outfile, append, desc=description, zipfile=zipfilename)
     elif filefmt == "html":
-        write_query_to_html(
-            select_stmt,
-            _state.dbs.current(),
-            outfile,
-            append,
-            desc=description,
-            zipfile=zipfilename,
-        )
+        write_query_to_html(select_stmt, db, outfile, append, desc=description, zipfile=zipfilename)
     elif filefmt == "cgi-html":
-        write_query_to_cgi_html(
-            select_stmt,
-            _state.dbs.current(),
-            outfile,
-            append,
-            desc=description,
-            zipfile=zipfilename,
-        )
+        write_query_to_cgi_html(select_stmt, db, outfile, append, desc=description, zipfile=zipfilename)
     elif filefmt == "latex":
-        write_query_to_latex(
-            select_stmt,
-            _state.dbs.current(),
-            outfile,
-            append,
-            desc=description,
-            zipfile=zipfilename,
-        )
+        write_query_to_latex(select_stmt, db, outfile, append, desc=description, zipfile=zipfilename)
     elif filefmt == "hdf5":
-        write_query_to_hdf5(table, select_stmt, _state.dbs.current(), outfile, append, desc=description)
+        write_query_to_hdf5(hdf5_table, select_stmt, db, outfile, append, desc=description)
     elif filefmt == "yaml":
-        write_query_to_yaml(
-            select_stmt,
-            _state.dbs.current(),
-            outfile,
-            append,
-            desc=description,
-            zipfile=zipfilename,
-        )
+        write_query_to_yaml(select_stmt, db, outfile, append, desc=description, zipfile=zipfilename)
     elif filefmt in ("markdown", "md"):
-        write_query_to_markdown(
-            select_stmt,
-            _state.dbs.current(),
-            outfile,
-            append,
-            desc=description,
-            zipfile=zipfilename,
-        )
+        write_query_to_markdown(select_stmt, db, outfile, append, desc=description, zipfile=zipfilename)
     else:
         try:
-            hdrs, rows = _state.dbs.current().select_rowsource(select_stmt)
+            hdrs, rows = db.select_rowsource(select_stmt)
         except ErrInfo:
             raise
         except Exception as e:
             raise ErrInfo("db", select_stmt, exception_msg=exception_desc()) from e
         if filefmt == "raw":
-            write_query_raw(outfile, rows, _state.dbs.current().encoding, append, zipfile=zipfilename)
+            write_query_raw(outfile, rows, db.encoding, append, zipfile=zipfilename)
         elif filefmt == "b64":
-            write_query_b64(outfile, rows, append)
+            write_query_b64(outfile, rows, append, zipfile=zipfilename)
         elif filefmt == "feather":
             write_query_to_feather(outfile, hdrs, rows)
         elif filefmt == "parquet":
             write_query_to_parquet(outfile, hdrs, rows)
         else:
             write_delimited_file(outfile, filefmt, hdrs, rows, _state.conf.output_encoding, append, zipfilename)
+
+
+# ---------------------------------------------------------------------------
+# EXPORT <table> TO <format> <file>
+# ---------------------------------------------------------------------------
+
+
+def x_export(**kwargs: Any) -> None:
+    schema = kwargs["schema"]
+    table = kwargs["table"]
+    queryname = _state.dbs.current().schema_qualified_table_name(schema, table)
+    select_stmt = f"select * from {queryname};"
+    outfile = _apply_output_dir(kwargs["filename"])
+    description = kwargs["description"]
+    tee = bool(kwargs["tee"])
+    append = bool(kwargs["append"])
+    filefmt = kwargs["format"].lower()
+    zipfilename = _apply_output_dir(kwargs["zipfilename"]) if kwargs["zipfilename"] else None
+    notype = bool(kwargs.get("notype"))
+    _check_zip_compat(outfile, filefmt, zipfilename)
+    check_dir(zipfilename if zipfilename is not None else outfile)
+    if tee and outfile.lower() != "stdout":
+        prettyprint_query(select_stmt, _state.dbs.current(), "stdout", False, desc=description)
+    _dispatch_format(
+        select_stmt,
+        outfile,
+        filefmt,
+        append,
+        description=description,
+        zipfilename=zipfilename,
+        notype=notype,
+        sheetname=queryname,
+        tablename=queryname,
+        xml_table=table,
+        hdf5_table=table,
+    )
     _state.export_metadata.add(ExportRecord(queryname, outfile, zipfilename, description))
     if _state.exec_log:
         _, line_no = current_script_line()
@@ -247,178 +189,38 @@ def x_export(**kwargs: Any) -> None:
     return None
 
 
+# ---------------------------------------------------------------------------
+# EXPORT QUERY <sql> TO <format> <file>
+# ---------------------------------------------------------------------------
+
+
 def x_export_query(**kwargs: Any) -> None:
     select_stmt = kwargs["query"]
     outfile = kwargs["filename"]
     description = kwargs["description"]
-    tee = kwargs["tee"]
-    tee = bool(tee)
-    append = kwargs["append"]
-    append = bool(append)
+    tee = bool(kwargs["tee"])
+    append = bool(kwargs["append"])
     filefmt = kwargs["format"].lower()
     zipfilename = kwargs["zipfilename"]
-    if zipfilename is not None:
-        if outfile == "stdout":
-            raise ErrInfo("error", other_msg="Cannot write stdout to a zipfile.")
-        elif len(outfile) > 1 and outfile[1] == ":":
-            raise ErrInfo("error", other_msg="Cannot use a drive letter for a file path within a zipfile.")
-        if filefmt == "latex":
-            raise ErrInfo("error", other_msg="Cannot export to the LaTeX format within a zipfile.")
-        if filefmt == "feather":
-            raise ErrInfo("error", other_msg="Cannot export to the feather format within a zipfile.")
-        if filefmt == "parquet":
-            raise ErrInfo("error", other_msg="Cannot export to the parquet format within a zipfile.")
-        if filefmt == "hdf5":
-            raise ErrInfo("error", other_msg="Cannot export to the HDF5 format within a zipfile.")
-        if filefmt == "ods":
-            raise ErrInfo("error", other_msg="Cannot export to an ODS workbook within a zipfile.")
-        if filefmt == "xlsx":
-            raise ErrInfo("error", other_msg="Cannot export to an XLSX workbook within a zipfile.")
     notype = bool(kwargs.get("notype"))
+    _check_zip_compat(outfile, filefmt, zipfilename)
     check_dir(outfile)
     if tee and outfile.lower() != "stdout":
         prettyprint_query(select_stmt, _state.dbs.current(), "stdout", False, desc=description)
-    if filefmt in ("txt", "text"):
-        prettyprint_query(
-            select_stmt,
-            _state.dbs.current(),
-            outfile,
-            append,
-            desc=description,
-            zipfile=zipfilename,
-        )
-    elif filefmt in ("txt-and", "text-and", "txt-and", "text-and"):
-        prettyprint_query(
-            select_stmt,
-            _state.dbs.current(),
-            outfile,
-            append,
-            and_val="AND",
-            desc=description,
-            zipfile=zipfilename,
-        )
-    elif filefmt == "ods":
-        script_name, lno = current_script_line()
-        write_query_to_ods(
-            select_stmt,
-            _state.dbs.current(),
-            outfile,
-            append,
-            sheetname=f"Query_{lno}",
-            desc=description,
-        )
-    elif filefmt == "xlsx":
-        script_name, lno = current_script_line()
-        write_query_to_xlsx(
-            select_stmt,
-            _state.dbs.current(),
-            outfile,
-            append,
-            sheetname=f"Query_{lno}",
-            desc=description,
-        )
-    elif filefmt == "json":
-        write_query_to_json(
-            select_stmt,
-            _state.dbs.current(),
-            outfile,
-            append,
-            desc=description,
-            zipfile=zipfilename,
-        )
-    elif filefmt in ("json_ts", "json_tableschema"):
-        write_query_to_json_ts(
-            select_stmt,
-            _state.dbs.current(),
-            outfile,
-            append,
-            not notype,
-            desc=description,
-            zipfile=zipfilename,
-        )
-    elif filefmt == "values":
-        write_query_to_values(
-            select_stmt,
-            _state.dbs.current(),
-            outfile,
-            append,
-            desc=description,
-            zipfile=zipfilename,
-        )
-    elif filefmt == "html":
-        write_query_to_html(
-            select_stmt,
-            _state.dbs.current(),
-            outfile,
-            append,
-            desc=description,
-            zipfile=zipfilename,
-        )
-    elif filefmt == "cgi-html":
-        write_query_to_cgi_html(
-            select_stmt,
-            _state.dbs.current(),
-            outfile,
-            append,
-            desc=description,
-            zipfile=zipfilename,
-        )
-    elif filefmt == "latex":
-        write_query_to_latex(
-            select_stmt,
-            _state.dbs.current(),
-            outfile,
-            append,
-            desc=description,
-            zipfile=zipfilename,
-        )
-    elif filefmt == "yaml":
-        write_query_to_yaml(
-            select_stmt,
-            _state.dbs.current(),
-            outfile,
-            append,
-            desc=description,
-            zipfile=zipfilename,
-        )
-    elif filefmt in ("markdown", "md"):
-        write_query_to_markdown(
-            select_stmt,
-            _state.dbs.current(),
-            outfile,
-            append,
-            desc=description,
-            zipfile=zipfilename,
-        )
-    else:
-        try:
-            hdrs, rows = _state.dbs.current().select_rowsource(select_stmt)
-        except ErrInfo:
-            raise
-        except Exception as e:
-            raise ErrInfo("db", select_stmt, exception_msg=exception_desc()) from e
-        if filefmt == "raw":
-            write_query_raw(outfile, rows, _state.dbs.current().encoding, append, zipfile=zipfilename)
-        elif filefmt == "b64":
-            write_query_b64(outfile, rows, append, zipfile=zipfilename)
-        elif filefmt == "feather":
-            write_query_to_feather(outfile, hdrs, rows)
-        elif filefmt == "parquet":
-            write_query_to_parquet(outfile, hdrs, rows)
-        else:
-            write_delimited_file(
-                outfile,
-                filefmt,
-                hdrs,
-                rows,
-                _state.conf.output_encoding,
-                append,
-                zipfile=zipfilename,
-            )
+    _, lno = current_script_line()
+    _dispatch_format(
+        select_stmt,
+        outfile,
+        filefmt,
+        append,
+        description=description,
+        zipfilename=zipfilename,
+        notype=notype,
+        sheetname=f"Query_{lno}",
+    )
     _state.export_metadata.add(ExportRecord(select_stmt, outfile, zipfilename, description))
     if _state.exec_log:
-        _, line_no = current_script_line()
-        _state.exec_log.log_action_export(line_no, select_stmt[:80], outfile)
+        _state.exec_log.log_action_export(lno, select_stmt[:80], outfile)
     return None
 
 

execsql/metacommands/io_fileops.py

@@ -16,7 +16,7 @@ from typing import Any
 import execsql.state as _state
 from execsql.exceptions import ErrInfo
 from execsql.models import DataTable
-from execsql.script import current_script_line, read_sqlfile
+from execsql.script import current_script_line
 from execsql.types import dbt_firebird
 from execsql.utils.errors import exception_desc
 from execsql.utils.fileio import filewriter_close
@@ -24,18 +24,12 @@ from execsql.utils.strings import unquoted
 
 
 def x_include(**kwargs: Any) -> None:
-    filename = kwargs["filename"]
-    if len(filename) > 1 and filename[0] == "~" and filename[1] == os.sep:
-        filename = str(Path.home() / filename[2:])
-    exists = kwargs["exists"]
-    if exists is not None:
-        if Path(filename).is_file():
-            read_sqlfile(filename)
-    else:
-        if not Path(filename).is_file():
-            raise ErrInfo(type="error", other_msg=f"File {filename} does not exist.")
-        read_sqlfile(filename)
-    return None
+    # INCLUDE is now handled natively by the AST executor (_execute_include_native).
+    # This handler exists only for dispatch table registration compatibility.
+    raise ErrInfo(
+        type="cmd",
+        other_msg="INCLUDE should be handled by the AST executor, not the dispatch table.",
+    )
 
 
 def x_copy(**kwargs: Any) -> None:

execsql/metacommands/io_write.py

@@ -45,7 +45,7 @@ def x_write(**kwargs: Any) -> None:
         except ConsoleUIError as e:
             _state.output.reset()
             _state.exec_log.log_status_info(f"Console UI write failed (message {{{e.value}}}); output reset to stdout.")
-            _state.output.write(msg.encode(_state.conf.output_encoding))
+            _state.output.write(msg)
     if _state.conf.tee_write_log:
         _state.exec_log.log_user_msg(msg)
     return None

execsql/metacommands/script_ext.py

@@ -14,7 +14,7 @@ from typing import Any
 
 import execsql.state as _state
 from execsql.exceptions import ErrInfo
-from execsql.script import MetacommandStmt, ScriptCmd, ScriptExecSpec, SqlStmt, current_script_line
+from execsql.script import MetacommandStmt, ScriptCmd, SqlStmt, current_script_line
 
 
 def x_extendscript(**kwargs: Any) -> None:
@@ -57,7 +57,10 @@ def x_extendscript_sql(**kwargs: Any) -> None:
 
 
 def x_executescript(**kwargs: Any) -> None:
-    exists = kwargs["exists"]
-    script_id = kwargs["script_id"].lower()
-    if exists is None or (exists is not None and script_id in _state.savedscripts):
-        ScriptExecSpec(**kwargs).execute()
+    # EXECUTE SCRIPT is now handled natively by the AST executor
+    # (_execute_include / _execute_script_native). This handler exists only
+    # for dispatch table registration compatibility.
+    raise ErrInfo(
+        "cmd",
+        other_msg="EXECUTE SCRIPT should be handled by the AST executor, not the dispatch table.",
+    )

execsql/metacommands/upsert.py

@@ -573,3 +573,43 @@ def x_pg_upsert_check(**kwargs: Any) -> None:
             command_text=metacommandline,
             other_msg=_qa_failure_msg(result),
         )
+
+
+# ---------------------------------------------------------------------------
+# Plugin registration
+# ---------------------------------------------------------------------------
+
+_PG_UPSERT_RX = r"^\s*PG_UPSERT\s+FROM\s+(?P<staging_schema>\S+)\s+TO\s+(?P<base_schema>\S+)\s+TABLES\s+(?P<tail>.+)$"
+_PG_UPSERT_CHECK_RX = (
+    r"^\s*PG_UPSERT\s+CHECK\s+FROM\s+(?P<staging_schema>\S+)\s+TO\s+(?P<base_schema>\S+)\s+TABLES\s+(?P<tail>.+)$"
+)
+_PG_UPSERT_QA_RX = (
+    r"^\s*PG_UPSERT\s+QA\s+FROM\s+(?P<staging_schema>\S+)\s+TO\s+(?P<base_schema>\S+)\s+TABLES\s+(?P<tail>.+)$"
+)
+
+
+def register(mcl: Any) -> None:
+    """Register PG_UPSERT metacommands as a plugin.
+
+    Called by execsql's plugin discovery via the ``execsql.metacommands``
+    entry point.  The CHECK and QA variants are registered first so their
+    more-specific regexes take priority over the general form.
+    """
+    mcl.add(
+        _PG_UPSERT_CHECK_RX,
+        x_pg_upsert_check,
+        description="PG_UPSERT CHECK",
+        category="action",
+    )
+    mcl.add(
+        _PG_UPSERT_QA_RX,
+        x_pg_upsert_qa,
+        description="PG_UPSERT QA",
+        category="action",
+    )
+    mcl.add(
+        _PG_UPSERT_RX,
+        x_pg_upsert,
+        description="PG_UPSERT",
+        category="action",
+    )

execsql/models.py

@@ -307,20 +307,16 @@ class DataTable:
 class JsonDatatype:
     """Namespace mapping Python DataType subclasses to JSON Schema type strings."""
 
-    def __init__(self) -> None:
-        """Create an empty JsonDatatype namespace instance."""
-        pass
+    any = "any"
+    integer = "integer"
+    string = "string"
+    date = "date"
+    datetime = "datetime"
+    time = "time"
+    number = "number"
+    boolean = "boolean"
 
 
-JsonDatatype.any = "any"
-JsonDatatype.integer = "integer"
-JsonDatatype.string = "string"
-JsonDatatype.date = "date"
-JsonDatatype.datetime = "datetime"
-JsonDatatype.time = "time"
-JsonDatatype.number = "number"
-JsonDatatype.boolean = "boolean"
-
 # Types without a JSON type equivalent are converted
 # to strings via the "default=str" argument of 'json.dumps()'.
 to_json_type = {