execsql2 2.33.0__py3-none-any.whl → 2.35.0__py3-none-any.whl

execsql/db/target_types.py

@@ -0,0 +1,277 @@
+"""The execsql data type of each column of a table that IMPORT or COPY loads.
+
+A load into a table that already exists converts each value by the type of
+the column it goes into, not by the type scanned from the source data
+(issue #100).  The adapters report each column's type: by the name their
+catalog gives it (PostgreSQL, MySQL, SQL Server, DuckDB, Oracle), or by the
+Python type their driver describes it with (Access, Firebird, ODBC DSNs).
+The functions here turn that
+into one of execsql's data types, or ``None`` when execsql has no
+conversion that fits (arrays, JSON, UUIDs, enums, geometry, intervals, …).
+
+Only the types that change how a value is converted are told apart: every
+character type is :class:`DT_Text`, every integer type :class:`DT_Long`,
+and so on.  A ``DECIMAL``/``NUMERIC``/``NUMBER`` with scale 0 holds whole
+numbers only, so it is :class:`DT_Long` too.
+"""
+
+from __future__ import annotations
+
+import datetime
+import math
+import re
+from collections.abc import Callable
+from decimal import Decimal
+from typing import Any, TypeAlias
+
+from execsql.exceptions import ErrInfo
+from execsql.types import (
+    DataType,
+    DT_Binary,
+    DT_Boolean,
+    DT_Date,
+    DT_Decimal,
+    DT_Float,
+    DT_Long,
+    DT_Text,
+    DT_Time,
+    DT_Timestamp,
+    DT_TimestampTZ,
+)
+
+__all__ = ["ColumnKinds", "existing_table_converter", "kind_for_python_type", "kind_for_type_name"]
+
+#: Lower-cased column name -> the execsql type values for it convert to, or None.
+#: A string, not ``dict[...]``: on Python 3.10 that object passes
+#: ``isinstance(x, type)``, so code that scans the adapter modules for classes
+#: would take it for one.
+ColumnKinds: TypeAlias = "dict[str, type[DataType] | None]"
+
+_TEXT = {
+    "char",
+    "character",
+    "varchar",
+    "character varying",
+    "varchar2",
+    "nchar",
+    "national character",
+    "nvarchar",
+    "nvarchar2",
+    "national character varying",
+    "bpchar",
+    "text",
+    "ntext",
+    "tinytext",
+    "mediumtext",
+    "longtext",
+    "string",
+    "clob",
+    "nclob",
+}
+_INTEGER = {
+    "integer",
+    "int",
+    "int1",
+    "int2",
+    "int4",
+    "int8",
+    "tinyint",
+    "smallint",
+    "mediumint",
+    "bigint",
+    "hugeint",
+    "utinyint",
+    "usmallint",
+    "uinteger",
+    "ubigint",
+    "uhugeint",
+    "serial",
+    "smallserial",
+    "bigserial",
+}
+_DECIMAL = {"decimal", "numeric", "number", "money", "smallmoney"}
+_FLOAT = {"float", "float4", "float8", "real", "double", "double precision", "binary_float", "binary_double"}
+_BOOLEAN = {"boolean", "bool"}
+_TIMESTAMP = {
+    "timestamp",
+    "timestamp without time zone",
+    "datetime",
+    "datetime2",
+    "smalldatetime",
+    "timestamp_s",
+    "timestamp_ms",
+    "timestamp_ns",
+}
+_TIMESTAMPTZ = {"timestamptz", "timestamp with time zone", "timestamp with local time zone", "datetimeoffset"}
+_TIME = {"time", "time without time zone"}
+_BINARY = {
+    "bytea",
+    "blob",
+    "tinyblob",
+    "mediumblob",
+    "longblob",
+    "binary",
+    "varbinary",
+    "binary varying",
+    "image",
+    "raw",
+    "long raw",
+}
+
+_PARAMS = re.compile(r"\(([^)]*)\)")
+
+
+def kind_for_type_name(type_name: str, *, oracle: bool = False) -> type[DataType] | None:
+    """The execsql type for a column declared as *type_name* (as the DBMS's catalog spells it).
+
+    *oracle*: Oracle's ``DATE`` holds a time of day too, so it is a timestamp there.
+    """
+    name = type_name.strip().lower()
+    if not name or "[" in name or name.endswith(" array"):
+        return None
+    params = _PARAMS.search(name)
+    args = [a.strip() for a in params.group(1).split(",")] if params else []
+    base = " ".join(_PARAMS.sub(" ", name).replace(" unsigned", " ").replace(" zerofill", " ").split())
+    if base == "tinyint" and args == ["1"]:
+        return DT_Boolean  # MySQL's BOOLEAN
+    if base == "bit":
+        # SQL Server's BIT; a wider BIT(n) is a bit string.
+        return DT_Boolean if args in ([], ["1"]) else None
+    if base in _TEXT:
+        return DT_Text
+    if base in _INTEGER:
+        return DT_Long
+    if base in _DECIMAL:
+        if args[1:] == ["0"] or len(args) == 1:
+            return DT_Long  # DECIMAL(p,0), NUMERIC(p), NUMBER(p): whole numbers
+        return DT_Decimal
+    if base in _FLOAT:
+        return DT_Float
+    if base in _BOOLEAN:
+        return DT_Boolean
+    if base == "date":
+        return DT_Timestamp if oracle else DT_Date
+    if base in _TIMESTAMP:
+        return DT_Timestamp
+    if base in _TIMESTAMPTZ:
+        return DT_TimestampTZ
+    if base in _TIME:
+        return DT_Time
+    if base in _BINARY:
+        return DT_Binary
+    return None
+
+
+def kind_for_python_type(type_code: object, scale: object = None) -> type[DataType] | None:
+    """The execsql type for a column a driver describes by the Python type it returns (pyodbc, firebird-driver).
+
+    Binary columns are left out: pyodbc describes a SQL Server
+    ``datetimeoffset`` as ``bytearray`` too.
+    """
+    if type_code is bool:
+        return DT_Boolean
+    if type_code is int:
+        return DT_Long
+    if type_code is float:
+        return DT_Float
+    if type_code is Decimal:
+        return DT_Long if scale == 0 else DT_Decimal
+    if type_code is str:
+        return DT_Text
+    if type_code is datetime.datetime:
+        return DT_Timestamp
+    if type_code is datetime.date:
+        return DT_Date
+    if type_code is datetime.time:
+        return DT_Time
+    return None
+
+
+# ---------------------------------------------------------------------------
+# Converting a value for the column it goes into
+# ---------------------------------------------------------------------------
+
+_INTEGER_TEXT = re.compile(r"^\s*[+-]?[0-9]+\s*$")
+_NUMBER_TEXT = re.compile(r"^\s*[+-]?(?:[0-9]+\.?[0-9]*|\.[0-9]+)(?:[eE][+-]?[0-9]+)?\s*$")
+# A whole number longer than this fits no integer column; it goes to the
+# database as given, which rejects it, instead of being expanded here.
+_MAX_INTEGER_DIGITS = 40
+
+Converter = Callable[[Any], Any]
+
+
+def _as_given(value: Any) -> Any:
+    return value
+
+
+def _whole_number_converter(column: str, table: str, default: Converter) -> Converter:
+    """Convert a value for integer column *column*: a fraction is an error, never rounded.
+
+    A value that is not a number (NULL, a date, a word) gets *default*, the
+    conversion it had before, and the database takes or rejects that.
+    """
+
+    def convert(value: Any) -> Any:
+        if isinstance(value, bool):
+            return default(value)
+        if isinstance(value, int):
+            return value
+        if isinstance(value, str):
+            if _INTEGER_TEXT.match(value):
+                return int(value)
+            if not _NUMBER_TEXT.match(value):
+                return default(value)
+            number = Decimal(value)
+        elif isinstance(value, Decimal):
+            number = value
+        elif isinstance(value, float):
+            if not math.isfinite(value):
+                return default(value)
+            number = Decimal(value)
+        else:
+            return default(value)
+        if not number.is_finite() or number.adjusted() >= _MAX_INTEGER_DIGITS:
+            return default(value)
+        if number == number.to_integral_value():
+            return int(number)
+        raise ErrInfo(
+            type="error",
+            other_msg=(
+                f"Can't load {value!r} into column {column} of {table}: the column holds whole numbers, "
+                "and the database would round the value."
+            ),
+        )
+
+    return convert
+
+
+def _true_false_as_number(default: Converter) -> Converter:
+    """Convert a value scanned as true/false for a number column: 1 or 0, read as before (``yes`` is 1)."""
+
+    def convert(value: Any) -> Any:
+        flag = default(value)
+        return int(flag) if isinstance(flag, bool) else flag
+
+    return convert
+
+
+def existing_table_converter(
+    kind: type[DataType] | None,
+    scanned: type[DataType],
+    default: Converter,
+    column: str,
+    table: str,
+) -> Converter:
+    """How a value for *column* of existing table *table* is converted.
+
+    *kind* is the column's type (``None`` if execsql has none that fits),
+    *scanned* the type the source column scanned as, and *default* the
+    conversion to that scanned type, which a new table's values get.
+    """
+    if kind is DT_Text:
+        return _as_given
+    if kind in (DT_Long, DT_Decimal, DT_Float) and scanned is DT_Boolean:
+        return _true_false_as_number(default)
+    if kind is DT_Long:
+        return _whole_number_converter(column, table, default)
+    return default

execsql/exporters/json.py

@@ -3,9 +3,11 @@ from __future__ import annotations
 """
 JSON export for execsql.
 
-Provides :func:`write_query_to_json` (standard JSON array of objects) and
-:func:`write_query_to_json_ts` (JSON with a top-level timestamp wrapper),
-both of which serialize a query result set to a file or stream.
+Provides :func:`write_query_to_json` (standard JSON array of objects),
+:func:`write_query_to_jsonl` (`JSON Lines <https://jsonlines.org/>`_, one
+object per line) and :func:`write_query_to_json_ts` (JSON with a top-level
+timestamp wrapper), all of which serialize a query result set to a file or
+stream.
 """
 
 import json
@@ -18,7 +20,13 @@ from execsql.models import DataTable, to_json_type
 from execsql.utils.errors import exception_desc
 from execsql.utils.fileio import filewriter_close
 
-__all__ = ["write_query_to_json", "write_query_to_json_ts"]
+__all__ = ["write_query_to_json", "write_query_to_json_ts", "write_query_to_jsonl"]
+
+
+def _row_json(hdrs: list[str], row: Any) -> str:
+    """One row as a compact JSON object; JSON and JSONL write rows alike."""
+    dictdata = dict(zip(hdrs, [str(v) if isinstance(v, str) else v for v in row]))
+    return json.dumps(dictdata, separators=(",", ":"), default=str)
 
 
 def write_query_to_json(
@@ -60,14 +68,50 @@ def write_query_to_json(
             else:
                 f.write(",\n")
             first = False
-            dictdata = dict(zip(uhdrs, [str(v) if isinstance(v, str) else v for v in row]))
-            jsondata = json.dumps(dictdata, separators=(",", ":"), default=str)
-            f.write(str(jsondata))
+            f.write(_row_json(uhdrs, row))
         f.write("\n]\n")
     finally:
         f.close()
 
 
+def write_query_to_jsonl(
+    select_stmt: str,
+    db: Any,
+    outfile: str,
+    append: bool = False,
+    desc: str | None = None,
+    zipfile: str | None = None,
+) -> None:
+    """Execute a SELECT and write the result set as JSON Lines: one JSON object per row, one row per line.
+
+    Values are written as :func:`write_query_to_json` writes them.  A line
+    break inside a value is escaped (``\\n``), so each row stays on one line.
+    With *append* the rows are added to the end of the file, which stays
+    valid JSON Lines.
+    """
+    conf = _state.conf
+    try:
+        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
+    f: Any
+    if zipfile is None:
+        filewriter_close(outfile)
+        from execsql.utils.fileio import EncodedFile
+
+        f = EncodedFile(outfile, conf.output_encoding).open("at" if append else "wt")
+    else:
+        f = ZipWriter(zipfile, outfile, append)
+    try:
+        uhdrs = [str(h) for h in hdrs]
+        for row in rows:
+            f.write(_row_json(uhdrs, row) + "\n")
+    finally:
+        f.close()
+
+
 def write_query_to_json_ts(
     select_stmt: str,
     db: Any,

execsql/exporters/protocol.py

@@ -51,6 +51,7 @@ class QueryExporter(Protocol):
     Conforming functions
     --------------------
     - ``write_query_to_json``
+    - ``write_query_to_jsonl``
     - ``write_query_to_html``
     - ``write_query_to_cgi_html``
     - ``write_query_to_latex``

execsql/importers/base.py

@@ -142,7 +142,7 @@ def import_data_table(
             )
         import_cols = hdrs
     try:
-        db.populate_table(schemaname, tablename, data, import_cols, get_ts)
+        db.populate_table(schemaname, tablename, data, import_cols, get_ts, existing_table=not is_new)
         db.commit()
     except ErrInfo:
         raise

execsql/importers/csv.py

@@ -91,7 +91,7 @@ def importtable(
                     other_msg=f"Non-existent table name ({tablename}) used with the IMPORT_FILE metacommand",
                 )
     try:
-        db.import_tabular_file(schemaname, tablename, inf, skipheader=True)
+        db.import_tabular_file(schemaname, tablename, inf, skipheader=True, existing_table=not is_new)
         db.commit()
     except ErrInfo:
         raise

execsql/metacommands/__init__.py

@@ -474,13 +474,29 @@ JSON_VARIANT_FORMATS = ["JSON_TS", "JSON_TABLESCHEMA"]
 QUERY_EXPORT_FORMATS = (
     DELIMITED_FORMATS
     + TEXT_FORMATS
-    + ["ODS", "XLSX", "JSON", "HTML", "CGI-HTML", "VALUES", "LATEX", "RAW", "B64", "FEATHER", "YAML", "MARKDOWN", "MD"]
+    + [
+        "ODS",
+        "XLSX",
+        "JSON",
+        "JSONL",
+        "HTML",
+        "CGI-HTML",
+        "VALUES",
+        "LATEX",
+        "RAW",
+        "B64",
+        "FEATHER",
+        "YAML",
+        "MARKDOWN",
+        "MD",
+    ]
 )
 TABLE_EXPORT_FORMATS = (
     DELIMITED_FORMATS
     + TEXT_FORMATS
     + [
         "JSON",
+        "JSONL",
         "XML",
         "VALUES",
         "HTML",

execsql/metacommands/data.py

@@ -21,7 +21,7 @@ What's actually here:
   ``x_set_counter``.
 - IMPORT / scanning configuration metacommands (the ``CONFIG …`` form):
   ``x_empty_strings``, ``x_trim_strings``, ``x_replace_newlines``,
-  ``x_empty_rows``, ``x_only_strings``, ``x_boolean_int``,
+  ``x_empty_rows``, ``x_exact_decimals``, ``x_only_strings``, ``x_boolean_int``,
   ``x_boolean_words``, ``x_fold_col_hdrs``, ``x_trim_col_hdrs``,
   ``x_clean_col_hdrs``, ``x_del_empty_cols``, ``x_create_col_hdrs``,
   ``x_dedup_col_hdrs``, ``x_import_common_cols_only``, ``x_max_int``.
@@ -301,6 +301,12 @@ def x_only_strings(**kwargs: Any) -> None:
     return None
 
 
+def x_exact_decimals(**kwargs: Any) -> None:
+    flag = kwargs["yesno"].lower()
+    _state.conf.exact_decimals = flag in ("yes", "on", "true", "1")
+    return None
+
+
 def x_boolean_int(**kwargs: Any) -> None:
     flag = kwargs["yesno"].lower()
     _state.conf.boolean_int = flag in ("yes", "on", "true", "1")

execsql/metacommands/dispatch.py

@@ -64,6 +64,7 @@ from execsql.metacommands.data import (
     x_dedup_col_hdrs,
     x_empty_rows,
     x_empty_strings,
+    x_exact_decimals,
     x_fold_col_hdrs,
     x_import_common_cols_only,
     x_max_int,
@@ -768,6 +769,12 @@ def build_dispatch_table() -> MetaCommandList:
         description="EMPTY_ROWS",
         category="config_option",
     )
+    mcl.add(
+        r"^\s*CONFIG\s+EXACT_DECIMALS\s+(?P<yesno>YES|NO|ON|OFF|TRUE|FALSE|0|1)\s*$",
+        x_exact_decimals,
+        description="EXACT_DECIMALS",
+        category="config_option",
+    )
     mcl.add(
         r"^\s*CONFIG\s+ONLY_STRINGS\s+(?P<yesno>YES|NO|ON|OFF|TRUE|FALSE|0|1)\s*$",
         x_only_strings,

execsql/metacommands/io_export.py

@@ -27,7 +27,7 @@ from execsql.exporters.delimited import write_delimited_file
 from execsql.exporters.duckdb import write_query_to_duckdb
 from execsql.exporters.feather import write_query_to_feather, write_query_to_hdf5
 from execsql.exporters.html import write_query_to_cgi_html, write_query_to_html
-from execsql.exporters.json import write_query_to_json, write_query_to_json_ts
+from execsql.exporters.json import write_query_to_json, write_query_to_json_ts, write_query_to_jsonl
 from execsql.exporters.latex import write_query_to_latex
 from execsql.exporters.ods import write_queries_to_ods, write_query_to_ods
 from execsql.exporters.xlsx import write_queries_to_xlsx, write_query_to_xlsx
@@ -123,6 +123,8 @@ def _dispatch_format(
         write_query_to_xml(select_stmt, xml_table, db, outfile, append, desc=description, zipfile=zipfilename)
     elif filefmt == "json":
         write_query_to_json(select_stmt, db, outfile, append, desc=description, zipfile=zipfilename)
+    elif filefmt == "jsonl":
+        write_query_to_jsonl(select_stmt, db, outfile, append, desc=description, zipfile=zipfilename)
     elif filefmt in ("json_ts", "json_tableschema"):
         write_query_to_json_ts(select_stmt, db, outfile, append, not notype, desc=description, zipfile=zipfilename)
     elif filefmt == "values":

execsql/metacommands/io_fileops.py

@@ -158,7 +158,7 @@ def x_copy(**kwargs: Any) -> None:
         return get_ts_tablespec
 
     try:
-        db2.populate_table(schema2, table2, rows_for_insert, hdrs, get_ts)
+        db2.populate_table(schema2, table2, rows_for_insert, hdrs, get_ts, existing_table=not new_tbl2)
         db2.commit()
     except BaseException:
         _close_rowsource(rows_to_close)
@@ -245,7 +245,7 @@ def x_copy_query(**kwargs: Any) -> None:
         return get_ts_tablespec
 
     try:
-        db2.populate_table(schema2, table2, rows_for_insert, hdrs, get_ts)
+        db2.populate_table(schema2, table2, rows_for_insert, hdrs, get_ts, existing_table=not new_tbl2)
         db2.commit()
     except BaseException:
         _close_rowsource(rows_to_close)

execsql/metacommands/reference.py

@@ -254,6 +254,7 @@ _METACOMMANDS: tuple[Metacommand, ...] = (
             "CONFIG DELETE_EMPTY_COLUMNS YES|NO",
             "CONFIG EMPTY_ROWS YES|NO",
             "CONFIG EMPTY_STRINGS YES|NO",
+            "CONFIG EXACT_DECIMALS YES|NO",
             "CONFIG EXPORT_ROW_BUFFER <n>",
             "CONFIG FOLD_COLUMN_HEADERS NO|LOWER|UPPER",
             "CONFIG GUI_LEVEL <n>",

execsql/models.py

@@ -49,6 +49,10 @@ __all__ = [
 
 ColumnType = tuple[str, type[DataType], int | None, bool, int | None, int | None]
 
+# Every decimal of up to this many significant digits reads back unchanged
+# from an IEEE double (DBL_DIG).
+_DOUBLE_EXACT_DIGITS = 15
+
 
 def _text_length(value: Any) -> int:
     """Return the length of *value* written as text (a column may turn out to be text)."""
@@ -71,9 +75,14 @@ class Column:
         """Accumulate match counts and length statistics for a single data type."""
 
         # Accumulates the count of matches for each data type, plus the maximum length if appropriate.
-        def __init__(self, data_type_obj: DataType) -> None:
-            """Initialise the accumulator for the given data type."""
+        def __init__(self, data_type_obj: DataType, *, exact_decimals: bool = False) -> None:
+            """Initialise the accumulator for the given data type.
+
+            *exact_decimals*: the ``exact_decimals`` setting; see
+            :meth:`chooses_float`.
+            """
             self.dt = data_type_obj
+            self.exact_decimals = exact_decimals
             self.failed = False
             self.count = 0
             self.maxlen = 0
@@ -127,6 +136,23 @@ class Column:
                     self.maxscale = max(self.dt.scale, self.maxscale)
                     self.max_int_digits = max(int_digits, self.max_int_digits)
 
+        def chooses_float(self) -> bool:
+            """Whether a decimal column gives way to a float column.
+
+            A column of decimals with different scales (``1.50``, ``2``,
+            ``-3.25``) is a float unless the ``exact_decimals`` setting is on,
+            or a value has more digits than a double holds exactly: every
+            decimal of up to 15 significant digits reads back unchanged from
+            a double, so such a column loses nothing, and a longer one
+            (``1234567890.1234567891``) stays ``DECIMAL(p, s)``.
+            """
+            return (
+                self.varscale
+                and not self.exact_decimals
+                and self.maxprecision is not None
+                and self.maxprecision <= _DOUBLE_EXACT_DIGITS
+            )
+
     def __init__(self, colname: str, infer_strings: bool = True) -> None:
         """Create a column characteriser for the named column.
 
@@ -169,7 +195,7 @@ class Column:
                 self.Accum(DT_Boolean()),
                 self.Accum(DT_Integer()),
                 self.Accum(DT_Long()),
-                self.Accum(DT_Decimal()),
+                self.Accum(DT_Decimal(), exact_decimals=conf.exact_decimals),
                 self.Accum(DT_Float()),
                 self.Accum(DT_Character()),
                 self.Accum(DT_Varchar()),
@@ -262,7 +288,7 @@ class Column:
                                 break
                     else:
                         if ac.dt.precspec:
-                            if ac.dt.precision is not None and ac.dt.scale is not None:
+                            if ac.dt.precision is not None and ac.dt.scale is not None and not ac.chooses_float():
                                 sel_type = ac
                                 break
                         else:

execsql/script/executor.py

@@ -85,6 +85,14 @@ _DEFER_RX = re.compile(r"!\{([$@&~#+]?\w+)\}!")
 _VARLIKE = re.compile(r"!![$@&~#]?\w+!!", re.I)
 
 
+def _warn_unsubstituted(cmd: str) -> None:
+    """Log a command that still looks like it holds a variable; print it too if ``write_warnings`` is on."""
+    from execsql.utils.errors import write_warning
+    from execsql.utils.fileio import redact
+
+    write_warning(f"There is a potential un-substituted variable in the command\n     {redact(cmd)}")
+
+
 def _stack_localvars(ctx: RuntimeContext) -> SubVarSet | None:
     """Build the merged ``~`` local + ``#`` param overlay for the current scope.
 
@@ -254,11 +262,7 @@ def _exec_sql(
     effective_locals = _stack_localvars(ctx) or localvars
     cmd = substitute_vars(text, effective_locals, ctx=ctx)
     if _VARLIKE.search(cmd):
-        from execsql.utils.fileio import redact
-
-        output.write(
-            f"Warning: There is a potential un-substituted variable in the command\n     {redact(cmd)}\n",
-        )
+        _warn_unsubstituted(cmd)
     e = None
     result = None
     try:
@@ -323,11 +327,7 @@ def _exec_metacommand(
     assert subvars is not None
 
     if _VARLIKE.search(cmd):
-        from execsql.utils.fileio import redact
-
-        output.write(
-            f"Warning: There is a potential un-substituted variable in the command\n     {redact(cmd)}\n",
-        )
+        _warn_unsubstituted(cmd)
     e = None
     try:
         applies, result = metacommandlist.eval(cmd)

execsql/script/variables.py

@@ -317,6 +317,10 @@ class SubVarSet:
         Uses case-insensitive string search instead of per-variable regex
         compilation to avoid O(N) ``re.compile`` calls on every invocation.
         """
+        # Every token below starts with one of these, so text without them
+        # can't match; skip the scan over every defined variable.
+        if "!!" not in command_str and "!'!" not in command_str and '!"!' not in command_str:
+            return command_str, False
         cmd_lower = command_str.lower()
 
         def _check_nul(name: str, value: str) -> None:

execsql/types.py

@@ -855,8 +855,8 @@ dbt_dsn.name_datatype(DT_Binary, "LONGBINARY")
 
 dbt_mysql = DbType("MySQL")
 dbt_mysql.name_datatype(DT_TimestampTZ, "varchar", True, "char")
-dbt_mysql.name_datatype(DT_Timestamp, "datetime", conv_mod_fn=lambda x: x if x is not None else "")
-dbt_mysql.name_datatype(DT_Date, "date", conv_mod_fn=lambda x: x if x is not None else "")
+dbt_mysql.name_datatype(DT_Timestamp, "datetime")
+dbt_mysql.name_datatype(DT_Date, "date")
 dbt_mysql.name_datatype(DT_Time, "time")
 dbt_mysql.name_datatype(DT_Integer, "integer", False, "signed integer")
 dbt_mysql.name_datatype(DT_Long, "bigint", False, "signed integer")

execsql/utils/errors.py

@@ -274,8 +274,8 @@ def write_warning(warning_msg: str, *, always: bool = False) -> None:
         warning_msg: The warning text to emit.
         always: When ``True``, always write to stderr regardless of the
             ``conf.write_warnings`` setting.  Use this for structural warnings
-            (e.g. IF-level mismatch, unsubstituted variables) that should always
-            be visible.  When ``False`` (default), stderr output is gated by
+            (e.g. IF-level mismatch) that should always be visible.  When
+            ``False`` (default), stderr output is gated by
             ``conf.write_warnings``.
     """
     if _state.exec_log is not None: