execsql2 2.22.9__py3-none-any.whl → 2.23.0__py3-none-any.whl

execsql/api.py

@@ -29,6 +29,7 @@ Usage::
 
 from __future__ import annotations
 
+import atexit
 import dataclasses
 import datetime
 import io
@@ -511,6 +512,11 @@ def run(
         errors: list[ScriptError] = []
         t0 = time.perf_counter()
 
+        # WRITE ... TO <file> and TEE are handled by a FileWriter subprocess,
+        # and fileio drops every write when none is running.  Start one here so
+        # the API behaves like the CLI.
+        _ensure_filewriter(conf)
+
         try:
             execute(tree, ctx=ctx)
         except SystemExit:
@@ -538,6 +544,17 @@ def run(
 
         elapsed = time.perf_counter() - t0
 
+        # Flush and close every file the script wrote, so the caller can read
+        # them the moment run() returns.  The subprocess itself is left running
+        # for reuse by a later run() and is reaped by the atexit handler; a
+        # writer the caller started is theirs and is never shut down here.
+        from execsql.utils.fileio import filewriter_close_all_after_write
+
+        try:
+            filewriter_close_all_after_write()
+        except Exception:
+            pass  # Best-effort: a failed flush must not mask a script error.
+
         # ------------------------------------------------------------------
         # Collect results
         # ------------------------------------------------------------------
@@ -571,6 +588,60 @@ def run(
 # ---------------------------------------------------------------------------
 # Helpers
 # ---------------------------------------------------------------------------
+def _ensure_filewriter(conf: Any) -> bool:
+    """Start the FileWriter subprocess if one is not already running.
+
+    ``WRITE ... TO <file>`` and ``TEE`` hand their output to a FileWriter
+    subprocess, and every entry point in :mod:`execsql.utils.fileio` guards on
+    the subprocess being alive — dropping the write when it is not, so that a
+    dead writer cannot deadlock the caller on a full pipe.  The CLI starts one
+    during startup; :func:`run` did not, so every file write under the API was
+    silently discarded and the run still reported success.
+
+    A writer started here outlives the call and is reused by a later
+    :func:`run`, exactly as the CLI keeps one for the life of the process; it
+    is reaped by an ``atexit`` handler.  A writer the caller started themselves
+    is left alone.
+
+    Returns:
+        ``True`` if this call started the writer, ``False`` if one was already
+        running.
+    """
+    import execsql.state as _state
+    import execsql.utils.fileio as _fileio
+    from execsql.utils.fileio import FileWriter, filewriter_end
+
+    if _fileio.filewriter is not None and _fileio.filewriter.is_alive():
+        return False
+
+    # Drain stale messages so a previously-dead subprocess cannot leak
+    # responses or unconsumed commands into the new one.  On macOS (`spawn`)
+    # the OS pipe buffer is small enough that retained entries would deadlock
+    # the next put().
+    for q in (_fileio.fw_input, _fileio.fw_output):
+        try:
+            while True:
+                q.get_nowait()
+        except Exception:
+            pass
+
+    try:
+        _fileio.filewriter = _state.filewriter = FileWriter(
+            _fileio.fw_input,
+            _fileio.fw_output,
+            file_encoding=conf.output_encoding,
+            open_timeout=getattr(conf, "outfile_open_timeout", 10),
+        )
+        _state.filewriter.start()
+    except Exception:
+        # Under the `spawn` start method (macOS, Windows) the subprocess
+        # re-imports the parent's __main__, which fails from a REPL, a
+        # notebook, or `python -c`.  Leave the writer unset: fileio's guards
+        # then warn on the first dropped write rather than deadlocking.
+        _fileio.filewriter = _state.filewriter = None
+        return False
+    atexit.register(filewriter_end)
+    return True
 
 
 def _capture_errors(ctx: RuntimeContext, errors: list[ScriptError]) -> None:

execsql/config.py

@@ -316,6 +316,7 @@ class ConfigData:
         self._get_int(cp, self._OUTPUT_SECTION, "zip_buffer_mb", "zip_buffer_mb")
         # --- [interface] ---
         self._get_bool(cp, self._INTERFACE_SECTION, "write_warnings", "write_warnings")
+        self._get_bool(cp, self._INTERFACE_SECTION, "support_tier_notice", "support_tier_notice")
         self._get_int(cp, self._INTERFACE_SECTION, "console_height", "gui_console_height", min_val=5)
         self._get_int(cp, self._INTERFACE_SECTION, "console_width", "gui_console_width", min_val=20)
         self._get_bool(cp, self._INTERFACE_SECTION, "console_wait_when_done", "gui_wait_on_exit")
@@ -409,6 +410,7 @@ class ConfigData:
         self.scan_lines = 100
         self.hdf5_text_len = 1000
         self.write_warnings = False
+        self.support_tier_notice = True
         self.write_prefix: str | None = None
         self.write_suffix: str | None = None
         self.gui_level: int = 0

execsql/data/execsql.conf.template

@@ -231,6 +231,11 @@
 # Values: Yes or No.  Default: No.
 #write_warnings=No
 
+# Whether opening a best-effort database connection (MS Access, Firebird,
+# Oracle, ODBC DSN) notes on stderr that the adapter is not verified in CI.
+# Values: Yes or No.  Default: Yes.
+#support_tier_notice=Yes
+
 # Text to prefix to WRITE output (with a space separator). "clear" removes a previous prefix.
 #write_prefix=
 

execsql/db/access.py

@@ -15,6 +15,7 @@ from pathlib import Path
 from typing import Any, cast
 
 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.auth import clear_stored_password, get_password, password_from_keyring
@@ -26,6 +27,11 @@ __all__ = ["AccessDatabase"]
 class AccessDatabase(Database):
     """MS Access adapter connecting to .mdb/.accdb files via DAO (win32com) with pyodbc fallback."""
 
+    #: The Access Database Engine install on the Windows CI runner is
+    #: best-effort, so a run can silently skip these tests.
+    support_tier = SupportTier.BEST_EFFORT
+    support_tier_name = "MS Access"
+
     # Regex for the 'create temporary view' SQL extension
     temp_rx = re.compile(
         r"^\s*create(?:\s+or\s+replace)?(\s+temp(?:orary)?)?\s+(?:(view|query))\s+(\w+) as\s+",
@@ -58,13 +64,15 @@ class AccessDatabase(Database):
             fatal_error("The pyodbc module is required.  See http://github.com/mkleehammer/pyodbc")
         from execsql.types import dbt_access
 
+        super().__init__(
+            server_name=None,
+            db_name=Access_fn,
+            user_name=user_name,
+            need_passwd=need_passwd,
+        )
         self.type = dbt_access
-        self.server_name = None
-        self.db_name = Access_fn
         # The following assignment is tentative and may be changed when the connection is made.
         self.jet4 = len(Access_fn) > 6 and Access_fn.lower()[-6:] == ".accdb"
-        self.user = user_name
-        self.need_passwd = need_passwd
         self.password = password
         # Encoding is only applicable to Jet < 4.0: non-accdb databases.
         self.encoding = encoding or "windows-1252"

execsql/db/base.py

@@ -19,11 +19,12 @@ import datetime
 import re
 from abc import ABC, abstractmethod
 from decimal import Decimal
-from typing import Any
+from typing import Any, ClassVar
 from collections.abc import Callable, Generator, Iterator
 
 from execsql.exceptions import ErrInfo
 from execsql.utils.errors import exception_desc
+from execsql.db.tiers import SupportTier, announce_tier
 import execsql.state as _state
 
 __all__ = ["Database", "DatabasePool"]
@@ -80,6 +81,15 @@ class Database(ABC):
     conn: Any
     autocommit: bool
 
+    #: How thoroughly this adapter is verified.  Subclasses that are not
+    #: exercised against a live server in CI override this with
+    #: ``SupportTier.BEST_EFFORT``; see :mod:`execsql.db.tiers`.
+    support_tier: ClassVar[SupportTier] = SupportTier.SUPPORTED
+
+    #: Name used in the best-effort notice.  Defaults to the class name minus
+    #: the ``Database`` suffix (``FirebirdDatabase`` -> ``Firebird``).
+    support_tier_name: ClassVar[str | None] = None
+
     _dt_cast: dict[type, Callable] | None = None
 
     @property
@@ -778,6 +788,10 @@ class DatabasePool:
                 )
             self.pool[db_alias].close()
         self.pool[db_alias] = db_obj
+        announce_tier(
+            db_obj.support_tier,
+            db_obj.support_tier_name or type(db_obj).__name__.removesuffix("Database"),
+        )
         # Refresh static system vars so $DB_NAME, $DB_USER, etc. reflect the new connection.
         try:
             from execsql.script.engine import set_static_system_vars

execsql/db/dsn.py

@@ -10,6 +10,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.auth import clear_stored_password, get_password, password_from_keyring
@@ -21,6 +22,11 @@ __all__ = ["DsnDatabase"]
 class DsnDatabase(Database):
     """Generic ODBC adapter that connects to any data source registered as an ODBC DSN via pyodbc."""
 
+    #: CI covers DSN string parsing only — no live DSN is ever opened,
+    #: and a DSN may front any DBMS at all.
+    support_tier = SupportTier.BEST_EFFORT
+    support_tier_name = "ODBC DSN"
+
     # There's no telling what is actually connected to a DSN, so this uses
     # generic Database methods almost exclusively.  Only 'exec_cmd()' is
     # overridden, and that uses the method for SQL Server because the DAO
@@ -41,18 +47,17 @@ class DsnDatabase(Database):
             fatal_error("The pyodbc module is required.  See http://github.com/mkleehammer/pyodbc")
         from execsql.types import dbt_dsn
 
+        super().__init__(
+            server_name=None,
+            db_name=dsn_name,
+            user_name=user_name,
+            need_passwd=need_passwd,
+        )
         self.type = dbt_dsn
-        self.server_name = None
-        self.db_name = dsn_name
-        self.user = user_name
-        self.need_passwd = need_passwd
         self.password = password
-        self.port = None
         self.encoding = encoding
         self.encode_commands = True
         self.paramstr = "?"
-        self.conn = None
-        self.autocommit = True
         self.open_db()
         self.password = None  # Clear cleartext password after successful connection
 

execsql/db/duckdb.py

@@ -28,17 +28,16 @@ class DuckDBDatabase(Database):
             fatal_error("The duckdb module is required.")
         from execsql.types import dbt_duckdb
 
+        super().__init__(
+            server_name=None,
+            db_name=DuckDB_fn,
+            user_name=None,
+            need_passwd=False,
+            encoding="UTF-8",
+        )
         self.type = dbt_duckdb
-        self.server_name = None
-        self.db_name = DuckDB_fn
         self.catalog_name = Path(DuckDB_fn).stem
-        self.user = None
-        self.need_passwd = False
-        self.encoding = "UTF-8"
         self.encode_commands = False
-        self.paramstr = "?"
-        self.conn = None
-        self.autocommit = True
         self.open_db()
 
     def __repr__(self) -> str:

execsql/db/firebird.py

@@ -9,6 +9,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.auth import clear_stored_password, get_password, password_from_keyring
@@ -20,6 +21,10 @@ __all__ = ["FirebirdDatabase"]
 class FirebirdDatabase(Database):
     """Firebird adapter using the firebird-driver package."""
 
+    #: No Firebird server runs in CI; this adapter has no tests.
+    support_tier = SupportTier.BEST_EFFORT
+    support_tier_name = "Firebird"
+
     def __init__(
         self,
         server_name: str,
@@ -39,18 +44,18 @@ class FirebirdDatabase(Database):
             )
         from execsql.types import dbt_firebird
 
+        super().__init__(
+            server_name=str(server_name),
+            db_name=str(db_name),
+            user_name=str(user_name),
+            need_passwd=need_passwd,
+            port=port if port else 3050,
+        )
         self.type = dbt_firebird
-        self.server_name = str(server_name)
-        self.db_name = str(db_name)
-        self.user = str(user_name)
-        self.need_passwd = need_passwd
         self.password = password
-        self.port = port if port else 3050
         self.encoding = encoding or "latin1"
         self.encode_commands = True
         self.paramstr = "?"
-        self.conn = None
-        self.autocommit = True
         self.open_db()
         self.password = None  # Clear cleartext password after successful connection
 

execsql/db/mysql.py

@@ -22,6 +22,7 @@ __all__ = ["MySQLDatabase"]
 _PYTHON_TO_MYSQL_CHARSET: dict[str, str] = {
     "utf-8": "utf8mb4",
     "utf8": "utf8mb4",
+    "utf8mb4": "utf8mb4",
     "latin-1": "latin1",
     "iso-8859-1": "latin1",
     "iso8859-1": "latin1",
@@ -31,6 +32,20 @@ _PYTHON_TO_MYSQL_CHARSET: dict[str, str] = {
 }
 
 
+def _crlf_terminated(filename: str) -> bool:
+    """True if the file's first line ends with CRLF.
+
+    Read as bytes so no decoding or newline translation can hide the answer.
+    """
+    try:
+        with open(filename, "rb") as f:
+            chunk = f.read(65536)
+    except OSError:
+        return False
+    i = chunk.find(b"\n")
+    return i > 0 and chunk[i - 1 : i] == b"\r"
+
+
 class MySQLDatabase(Database):
     """MySQL and MariaDB adapter using the pymysql package."""
 
@@ -41,7 +56,7 @@ class MySQLDatabase(Database):
         user_name: str | None,
         need_passwd: bool = False,
         port: int | None = 3306,
-        encoding: str | None = "latin1",
+        encoding: str | None = "utf8mb4",
         password: str | None = None,
     ) -> None:
         try:
@@ -52,18 +67,23 @@ class MySQLDatabase(Database):
             )
         from execsql.types import dbt_mysql
 
+        super().__init__(
+            server_name=str(server_name) if server_name is not None else None,
+            db_name=str(db_name) if db_name is not None else None,
+            user_name=str(user_name) if user_name is not None else None,
+            need_passwd=need_passwd,
+            port=port if port else 3306,
+        )
         self.type = dbt_mysql
-        self.server_name = str(server_name) if server_name is not None else None
-        self.db_name = str(db_name) if db_name is not None else None
-        self.user = str(user_name) if user_name is not None else None
-        self.need_passwd = need_passwd
         self.password = password
-        self.port = port if port else 3306
-        self.encoding = encoding or "latin1"
+        # utf8mb4, not latin1: the connection charset only governs how text moves
+        # between client and server, and MySQL transcodes to and from each
+        # column's own charset.  A latin1 connection cannot carry CJK, emoji,
+        # Greek, or Cyrillic at all — it raises UnicodeEncodeError before the
+        # server is reached — so it silently capped what execsql could move.
+        self.encoding = encoding or "utf8mb4"
         self.encode_commands = True
         self.paramstr = "%s"
-        self.conn = None
-        self.autocommit = True
         self.open_db()
         self.password = None  # Clear cleartext password after successful connection
 
@@ -297,8 +317,22 @@ class MySQLDatabase(Database):
                 if csv_file_obj.quotechar:
                     safe_quote = csv_file_obj.quotechar.replace("'", "''")
                     import_sql = f"{import_sql} optionally enclosed by '{safe_quote}'"
+            # Tell LOAD DATA what ends a line.  Its default is "\n", so a CRLF
+            # file left a carriage return on the last field of every row: the
+            # value was not empty, NULLIF below could not see it, and a date
+            # column silently became 0000-00-00.  Every other backend reads the
+            # same file correctly.
+            if _crlf_terminated(csv_file_obj.csvfname):
+                import_sql = f"{import_sql} lines terminated by '\\r\\n'"
             import_sql = f"{import_sql} ignore {1 + csv_file_obj.junk_header_lines} lines"
-            import_sql = f"{import_sql} ({input_col_list});"
+            # Read every column into a user variable and NULLIF it back.  LOAD
+            # DATA otherwise coerces an empty field to the column's zero value
+            # — an empty numeric became 0 and an empty date 0000-00-00 — so the
+            # same CSV imported to MySQL differed from every other backend,
+            # where an empty field is NULL.
+            vars_list = ",".join(f"@ecs_{i}" for i in range(len(import_cols)))
+            set_list = ",".join(f"{col}=nullif(@ecs_{i},'')" for i, col in enumerate(import_cols))
+            import_sql = f"{import_sql} ({vars_list}) set {set_list};"
             if _state.exec_log is not None:
                 _state.exec_log.log_status_info(
                     f"IMPORTing {csv_file_obj.csvfname} using the DBMS' fast file reading routine",

execsql/db/oracle.py

@@ -11,6 +11,7 @@ on the CLI.
 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.auth import clear_stored_password, get_password, password_from_keyring
@@ -22,6 +23,10 @@ __all__ = ["OracleDatabase"]
 class OracleDatabase(Database):
     """Oracle adapter using the cx_Oracle (python-oracledb) driver."""
 
+    #: No Oracle server runs in CI; this adapter has no tests.
+    support_tier = SupportTier.BEST_EFFORT
+    support_tier_name = "Oracle"
+
     def __init__(
         self,
         server_name: str,
@@ -40,18 +45,18 @@ class OracleDatabase(Database):
             )
         from execsql.types import dbt_oracle
 
+        super().__init__(
+            server_name=server_name,
+            db_name=db_name,
+            user_name=user_name,
+            need_passwd=need_passwd,
+            port=port if port else 1521,
+        )
         self.type = dbt_oracle
-        self.server_name = server_name
-        self.db_name = db_name
-        self.user = user_name
-        self.need_passwd = need_passwd
         self.password = password
-        self.port = port if port else 1521
         self.encoding = encoding or "UTF8"
         self.encode_commands = False
         self.paramstr = ":1"
-        self.conn = None
-        self.autocommit = True
         self.open_db()
         self.password = None  # Clear cleartext password after successful connection
 

execsql/db/postgres.py

@@ -49,20 +49,20 @@ class PostgresDatabase(Database):
             )
         from execsql.types import dbt_postgres
 
+        super().__init__(
+            server_name=server_name,
+            db_name=db_name,
+            user_name=user_name,
+            need_passwd=need_passwd,
+            port=port if port else 5432,
+            encoding=encoding or "UTF8",
+        )
         self.type = dbt_postgres
-        self.server_name = server_name
-        self.db_name = db_name
-        self.user = user_name
-        self.need_passwd = need_passwd
         self.password = password
-        self.port = port if port else 5432
         self.new_db = new_db
-        self.encoding = encoding or "UTF8"
         self.encode_commands = False
         self.paramstr = "%s"
         self.connect_timeout = connect_timeout
-        self.conn = None
-        self.autocommit = True
         self.open_db()
         self.password = None  # Clear cleartext password after successful connection
 
@@ -318,8 +318,16 @@ class PostgresDatabase(Database):
         input_enc = csv_file_obj.encoding.lower()
         if input_enc in enc_xlates:
             input_enc = enc_xlates[input_enc]
+        # COPY's CSV format always has a quote character — `"` unless told
+        # otherwise — so it cannot read a file that has none: with QUOTE NONE,
+        # or when none is detected, it would strip the `"` from `Well "A" 12`.
+        # Nor is it told about a detected escape character, so `\"` inside a
+        # quoted field came out as `\`. Both kinds of file take the row-by-row
+        # path, which reads the format that was detected.
         if (
-            encodings_match(input_enc, self.encoding)
+            csv_file_obj.quotechar is not None
+            and csv_file_obj.escapechar is None
+            and encodings_match(input_enc, self.encoding)
             and data_table_cols == csv_file_cols
             and _state.conf.empty_strings
             and _state.conf.empty_rows

execsql/db/sqlite.py

@@ -33,17 +33,16 @@ class SQLiteDatabase(Database):
             fatal_error("The sqlite3 module is required.")
         from execsql.types import dbt_sqlite
 
+        super().__init__(
+            server_name=None,
+            db_name=SQLite_fn,
+            user_name=None,
+            need_passwd=False,
+            encoding="UTF-8",
+        )
         self.type = dbt_sqlite
-        self.server_name = None
-        self.db_name = SQLite_fn
-        self.user = None
-        self.need_passwd = False
-        self.encoding = "UTF-8"
         self.encode_commands = False
-        self.paramstr = "?"
         self.timeout = timeout
-        self.conn = None
-        self.autocommit = True
         self.open_db()
 
     def __repr__(self) -> str:

execsql/db/sqlserver.py

@@ -37,18 +37,18 @@ class SqlServerDatabase(Database):
             fatal_error("The pyodbc module is required.  See http://github.com/mkleehammer/pyodbc")
         from execsql.types import dbt_sqlserver
 
+        super().__init__(
+            server_name=server_name,
+            db_name=db_name,
+            user_name=user_name,
+            need_passwd=need_passwd,
+            port=port if port else 1433,
+        )
         self.type = dbt_sqlserver
-        self.server_name = server_name
-        self.db_name = db_name
-        self.user = user_name
-        self.need_passwd = need_passwd
         self.password = password
-        self.port = port if port else 1433
         self.encoding = encoding or "latin1"  # Default on installation of SQL Server
         self.encode_commands = True
         self.paramstr = "?"
-        self.conn = None
-        self.autocommit = True
         self.open_db()
         self.password = None  # Clear cleartext password after successful connection
 

execsql/db/tiers.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+"""
+Database support tiers.
+
+execsql2 ships nine DBMS adapters, but only five of them are exercised
+against a live server (or a real database file) on every CI run.  The other
+four are carried forward from the upstream monolith and are not verified
+anywhere.  Documenting all nine with equal confidence tells users nothing
+about which ones have actually been run.
+
+:class:`SupportTier` records that distinction, each adapter declares its own
+tier via ``Database.support_tier``, and :func:`announce_tier` emits a single
+informational line the first time a session opens a Tier 2 connection.
+
+The notice is written to stderr (never stdout, so it cannot corrupt piped
+query output) and can be switched off with ``support_tier_notice=No`` in the
+``[interface]`` section of ``execsql.conf``.
+"""
+
+import enum
+
+import execsql.state as _state
+
+__all__ = ["SupportTier", "announce_tier"]
+
+
+class SupportTier(enum.Enum):
+    """How thoroughly a DBMS adapter is verified.
+
+    Attributes:
+        SUPPORTED: Tested against a live server or real database file on
+            every CI run.  Regressions block a release, and bugs are fixed.
+        BEST_EFFORT: Inherited from the upstream monolith and not verified
+            in CI.  The code is present and may work; nothing proves it
+            still does.  Issues and pull requests are welcome, but no
+            guarantee is made.
+    """
+
+    SUPPORTED = "supported"
+    BEST_EFFORT = "best effort"
+
+
+_NOTICE = (
+    "Note: {dbms} support is best-effort — it is not verified in CI and may break. "
+    "Set support_tier_notice=No in the [interface] section of execsql.conf to silence this."
+)
+
+
+def announce_tier(tier: SupportTier, dbms_name: str) -> None:
+    """Emit the best-effort notice for ``dbms_name``, at most once per session.
+
+    Silent for :attr:`SupportTier.SUPPORTED`, when the user has set
+    ``support_tier_notice=No``, and before output hooks are installed (which is
+    the case for adapters built by the test suite and by library callers that
+    have not started a run).
+
+    Which names have been announced is tracked on the runtime context, so
+    :func:`execsql.state.reset` clears it between runs and between tests, and a
+    script that opens twenty Firebird connections prints the notice once.
+
+    Args:
+        tier: The adapter's declared support tier.
+        dbms_name: Human-readable DBMS name used in the message.
+    """
+    if tier is not SupportTier.BEST_EFFORT:
+        return
+    conf = _state.conf
+    if conf is not None and not getattr(conf, "support_tier_notice", True):
+        return
+    shown = _state.tier_notices_shown
+    if dbms_name in shown:
+        return
+    shown.add(dbms_name)
+    message = _NOTICE.format(dbms=dbms_name)
+    if _state.exec_log is not None:
+        _state.exec_log.log_status_info(message)
+    if _state.output is not None:
+        _state.output.write_err(message)

execsql/exporters/delimited.py

@@ -386,6 +386,16 @@ class CsvFile(EncodedFile):
                 break
             except:
                 raise
+            # A quoted field may contain a newline — RFC 4180 allows it, and
+            # execsql's own CSV writer produces it.  Read on until the quotes
+            # balance, so diagnosis sees one logical record rather than two
+            # physical lines whose delimiter counts disagree; an odd count made
+            # the real delimiter look inconsistent and it was rejected.
+            while ln.count('"') % 2 == 1:
+                try:
+                    ln += next(linestream)
+                except StopIteration:
+                    break
             while len(ln) > 0 and ln[-1] in ("\n", "\r"):
                 ln = ln[:-1]
             if len(ln) > 0:
@@ -799,7 +809,11 @@ def write_delimited_file(
     else:
         fmode = "w" if not append else "a"
         filewriter_close(outfile)
-        ofile = EncodedFile(outfile, file_encoding).open(mode=fmode)
+        # newline="": a delimited field may legitimately contain a newline, and
+        # universal-newline translation would rewrite it to \r\n on Windows,
+        # changing the exported value.  Row terminators stay "\n" on every
+        # platform, so the same query now produces the same bytes everywhere.
+        ofile = EncodedFile(outfile, file_encoding).open(mode=fmode, newline="")
         fdesc = outfile
     try:
         if not (filefmt.lower() == "plain" or (append and zipfile is None)):