execsql2 2.23.1__py3-none-any.whl → 2.25.0__py3-none-any.whl

execsql/db/factory.py

@@ -64,7 +64,16 @@ def db_Postgres(
     password: str | None = None,
 ) -> PostgresDatabase:
     """Open a new PostgreSQL connection via psycopg (psycopg3)."""
-    return PostgresDatabase(server_name, database_name, user, pw_needed, port, new_db=new_db, password=password)
+    return PostgresDatabase(
+        server_name,
+        database_name,
+        user,
+        pw_needed,
+        port,
+        new_db=new_db,
+        encoding=encoding,
+        password=password,
+    )
 
 
 def db_SQLite(
@@ -84,7 +93,7 @@ def db_SQLite(
         if not Path(sqlite_fn).exists():
             raise ErrInfo(
                 type="error",
-                other_msg=f'SQLite database file "{sqlite_fn}" does not exist.',
+                other_msg=f'SQLite database file "{sqlite_fn}" does not exist. Use -n (--new-db) to create it.',
             )
     return SQLiteDatabase(sqlite_fn)
 
@@ -129,7 +138,7 @@ def db_DuckDB(
         if not Path(duckdb_fn).exists():
             raise ErrInfo(
                 type="error",
-                other_msg=f'DuckDB database file "{duckdb_fn}" does not exist.',
+                other_msg=f'DuckDB database file "{duckdb_fn}" does not exist. Use -n (--new-db) to create it.',
             )
     return DuckDBDatabase(duckdb_fn)
 
@@ -143,7 +152,7 @@ def db_Oracle(
     encoding: str | None = None,
     password: str | None = None,
 ) -> OracleDatabase:
-    """Open an Oracle database connection via cx_Oracle (python-oracledb)."""
+    """Open an Oracle database connection via python-oracledb."""
     return OracleDatabase(server_name, database_name, user, pw_needed, port, encoding, password=password)
 
 

execsql/db/firebird.py

@@ -12,7 +12,14 @@ 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
+from execsql.utils.auth import (
+    begin_login,
+    clear_stored_password,
+    get_password,
+    is_login_failure,
+    password_from_keyring,
+    remember_password,
+)
 import execsql.state as _state
 
 __all__ = ["FirebirdDatabase"]
@@ -54,7 +61,6 @@ class FirebirdDatabase(Database):
         self.type = dbt_firebird
         self.password = password
         self.encoding = encoding or "latin1"
-        self.encode_commands = True
         self.paramstr = "?"
         self.open_db()
         self.password = None  # Clear cleartext password after successful connection
@@ -100,28 +106,34 @@ class FirebirdDatabase(Database):
 
         if self.conn is None:
             try:
+                begin_login()
                 if self.user and self.need_passwd and not self.password:
                     self.password = get_password(
                         "Firebird",
                         self.db_name,
                         self.user,
                         server_name=self.server_name,
+                        port=self.port,
                     )
                 try:
                     self.conn = db_conn()
-                except Exception:
-                    if not password_from_keyring():
+                except Exception as e:
+                    # Only a rejected password means the stored one is stale;
+                    # a timeout or a missing database leaves it alone.
+                    if not (password_from_keyring() and is_login_failure(e)):
                         raise
-                    clear_stored_password("Firebird", self.db_name, self.user, self.server_name)
+                    clear_stored_password("Firebird", self.db_name, self.user, self.server_name, port=self.port)
                     self.password = get_password(
                         "Firebird",
                         self.db_name,
                         self.user,
                         server_name=self.server_name,
+                        port=self.port,
                         skip_keyring=True,
                         other_msg="(stored credential failed — enter current password)",
                     )
                     self.conn = db_conn()
+                remember_password("Firebird", self.db_name, self.user, self.server_name, port=self.port)
             except SystemExit:
                 # If the user canceled the password prompt.
                 raise
@@ -143,6 +155,9 @@ class FirebirdDatabase(Database):
                 raise
             _state.subvars.add_substitution("$LAST_ROWCOUNT", curs.rowcount)
 
+    # table_exists() without a schema looks only where CREATE TABLE puts a table: one namespace.
+    unqualified_lookup_is_scoped = True
+
     def table_exists(self, table_name: str, schema_name: str | None = None) -> bool:
         """Return True if the named table exists in the Firebird database."""
         sql = (
@@ -243,8 +258,7 @@ class FirebirdDatabase(Database):
         return len(rows) > 0
 
     def drop_table(self, tablename: str) -> None:
-        """Drop the named table from the Firebird database."""
+        """Drop *tablename*, schema-qualified and quoted by the caller."""
         # Firebird will thrown an error if there are foreign keys into the table.
-        tablename = self.type.quoted(tablename)
         self.execute(f"DROP TABLE {tablename};")
         self.conn.commit()

execsql/db/mysql.py

@@ -13,7 +13,14 @@ from typing import Any, cast
 from execsql.db.base import Database
 from execsql.exceptions import ErrInfo
 from execsql.utils.errors import exception_desc, fatal_error
-from execsql.utils.auth import clear_stored_password, get_password, password_from_keyring
+from execsql.utils.auth import (
+    begin_login,
+    clear_stored_password,
+    get_password,
+    is_login_failure,
+    password_from_keyring,
+    remember_password,
+)
 import execsql.state as _state
 
 __all__ = ["MySQLDatabase"]
@@ -93,7 +100,6 @@ class MySQLDatabase(Database):
         # 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.open_db()
         self.password = None  # Clear cleartext password after successful connection
@@ -149,6 +155,9 @@ class MySQLDatabase(Database):
         """Lowercase *name* when the server is case-insensitive (LCTN 1/2)."""
         return name.lower() if self._lower_case_table_names() in (1, 2) else name
 
+    def current_schema(self) -> str | None:
+        return self._query_current_schema("select database()")
+
     # NB: schema_exists is overridden below to return False unconditionally
     # — MySQL's pre-existing behavior. The case-folding only matters for
     # adapters where schema lookups are meaningful, which MySQL skips.
@@ -209,28 +218,34 @@ class MySQLDatabase(Database):
 
         if self.conn is None:
             try:
+                begin_login()
                 if self.user and self.need_passwd and not self.password:
                     self.password = get_password(
                         "MySQL",
                         self.db_name,
                         self.user,
                         server_name=self.server_name,
+                        port=self.port,
                     )
                 try:
                     self.conn = db_conn()
-                except Exception:
-                    if not password_from_keyring():
+                except Exception as e:
+                    # Only a rejected password means the stored one is stale;
+                    # a timeout or a missing database leaves it alone.
+                    if not (password_from_keyring() and is_login_failure(e)):
                         raise
-                    clear_stored_password("MySQL", self.db_name, self.user, self.server_name)
+                    clear_stored_password("MySQL", self.db_name, self.user, self.server_name, port=self.port)
                     self.password = get_password(
                         "MySQL",
                         self.db_name,
                         self.user,
                         server_name=self.server_name,
+                        port=self.port,
                         skip_keyring=True,
                         other_msg="(stored credential failed — enter current password)",
                     )
                     self.conn = db_conn()
+                remember_password("MySQL", self.db_name, self.user, self.server_name, port=self.port)
                 self.execute("set session sql_mode='ANSI';")
             except SystemExit:
                 # If the user canceled the password prompt.
@@ -306,8 +321,12 @@ class MySQLDatabase(Database):
                 )
             import_cols = csv_file_cols
         input_col_list = ",".join(import_cols)
+        # LOAD DATA is told the file has no escape character (ESCAPED BY ''),
+        # so a file where one was detected takes the row-by-row path, which
+        # reads the format that was detected.
         if (
-            data_table_cols == csv_file_cols
+            csv_file_obj.escapechar is None
+            and data_table_cols == csv_file_cols
             and _state.conf.empty_strings
             and _state.conf.empty_rows
             and not _state.conf.del_empty_cols
@@ -315,19 +334,21 @@ class MySQLDatabase(Database):
             and not _state.conf.trim_strings
             and not _state.conf.replace_newlines
         ):
-            safe_fname = csv_file_obj.csvfname.replace("'", "''")
-            import_sql = f"load data local infile '{safe_fname}' into table {sq_name}"
+            # String literals in this session treat a backslash as an escape,
+            # so the file name, delimiter and quote character are quoted with
+            # quote_literal, which doubles it.
+            import_sql = f"load data local infile {self.quote_literal(csv_file_obj.csvfname)} into table {sq_name}"
             if csv_file_obj.encoding:
                 charset = _PYTHON_TO_MYSQL_CHARSET.get(csv_file_obj.encoding.lower(), csv_file_obj.encoding)
                 import_sql = f"{import_sql} character set {charset}"
-            if csv_file_obj.delimiter or csv_file_obj.quotechar:
-                import_sql = import_sql + " columns"
-                if csv_file_obj.delimiter:
-                    safe_delim = csv_file_obj.delimiter.replace("'", "''")
-                    import_sql = f"{import_sql} terminated by '{safe_delim}'"
-                if csv_file_obj.quotechar:
-                    safe_quote = csv_file_obj.quotechar.replace("'", "''")
-                    import_sql = f"{import_sql} optionally enclosed by '{safe_quote}'"
+            import_sql = import_sql + " columns"
+            if csv_file_obj.delimiter:
+                import_sql = f"{import_sql} terminated by {self.quote_literal(csv_file_obj.delimiter)}"
+            if csv_file_obj.quotechar:
+                import_sql = f"{import_sql} optionally enclosed by {self.quote_literal(csv_file_obj.quotechar)}"
+            # MySQL's default ESCAPED BY '\\' turned C:\new into a newline and
+            # \N into NULL; every other backend keeps the text as written.
+            import_sql = f"{import_sql} escaped by ''"
             # 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

execsql/db/oracle.py

@@ -15,14 +15,42 @@ 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
+from execsql.utils.auth import (
+    begin_login,
+    clear_stored_password,
+    get_password,
+    is_login_failure,
+    password_from_keyring,
+    remember_password,
+)
 import execsql.state as _state
 
 __all__ = ["OracleDatabase"]
 
 
+def _oracle_driver() -> Any:
+    """The Oracle driver module: python-oracledb, or else the legacy cx_Oracle.
+
+    ``execsql2[oracle]`` installs oracledb.  cx_Oracle, the driver it replaced
+    (same ``makedsn`` / ``connect`` calls), is used only when it is the one
+    installed.  ``None`` if neither is.
+    """
+    try:
+        import oracledb
+
+        return oracledb
+    except ImportError:
+        pass
+    try:
+        import cx_Oracle
+
+        return cx_Oracle
+    except ImportError:
+        return None
+
+
 class OracleDatabase(Database):
-    """Oracle adapter using the cx_Oracle (python-oracledb) driver."""
+    """Oracle adapter using the python-oracledb driver."""
 
     #: Oracle commits every DDL statement at once, together with everything
     #: before it, including CREATE GLOBAL TEMPORARY TABLE.
@@ -46,11 +74,9 @@ class OracleDatabase(Database):
         encoding: str | None = "UTF8",
         password: str | None = None,
     ) -> None:
-        try:
-            import cx_Oracle  # noqa: F401
-        except Exception:
+        if _oracle_driver() is None:
             fatal_error(
-                "The cx-Oracle module is required to connect to Oracle.   See https://pypi.org/project/cx-Oracle/",
+                'The oracledb module is required to connect to Oracle. Install it with: pip install "execsql2[oracle]"',
             )
         from execsql.types import dbt_oracle
 
@@ -64,7 +90,6 @@ class OracleDatabase(Database):
         self.type = dbt_oracle
         self.password = password
         self.encoding = encoding or "UTF8"
-        self.encode_commands = False
         self.paramstr = ":1"
         self.open_db()
         self.password = None  # Clear cleartext password after successful connection
@@ -77,39 +102,45 @@ class OracleDatabase(Database):
 
     def open_db(self) -> None:
         """Open a connection to the Oracle database."""
-        import cx_Oracle
+        driver = _oracle_driver()
 
         def db_conn(db: OracleDatabase, db_name: str):
-            dsn = cx_Oracle.makedsn(db.server_name, db.port, service_name=db_name)
+            dsn = driver.makedsn(db.server_name, db.port, service_name=db_name)
             if db.user and db.password:
-                return cx_Oracle.connect(user=db.user, password=db.password, dsn=dsn)
+                return driver.connect(user=db.user, password=db.password, dsn=dsn)
             else:
-                return cx_Oracle.connect(dsn=dsn)
+                return driver.connect(dsn=dsn)
 
         if self.conn is None:
             try:
+                begin_login()
                 if self.user and self.need_passwd and not self.password:
                     self.password = get_password(
                         "Oracle",
                         self.db_name,
                         self.user,
                         server_name=self.server_name,
+                        port=self.port,
                     )
                 try:
                     self.conn = db_conn(self, self.db_name)
-                except Exception:
-                    if not password_from_keyring():
+                except Exception as e:
+                    # Only a rejected password means the stored one is stale;
+                    # a timeout or a missing database leaves it alone.
+                    if not (password_from_keyring() and is_login_failure(e)):
                         raise
-                    clear_stored_password("Oracle", self.db_name, self.user, self.server_name)
+                    clear_stored_password("Oracle", self.db_name, self.user, self.server_name, port=self.port)
                     self.password = get_password(
                         "Oracle",
                         self.db_name,
                         self.user,
                         server_name=self.server_name,
+                        port=self.port,
                         skip_keyring=True,
                         other_msg="(stored credential failed — enter current password)",
                     )
                     self.conn = db_conn(self, self.db_name)
+                remember_password("Oracle", self.db_name, self.user, self.server_name, port=self.port)
             except SystemExit:
                 # If the user canceled the password prompt.
                 raise
@@ -153,6 +184,9 @@ class OracleDatabase(Database):
 
         raise DatabaseNotImplementedError(self.name(), "schema_exists")
 
+    def current_schema(self) -> str | None:
+        return self._query_current_schema("select sys_context('USERENV', 'CURRENT_SCHEMA') from dual")
+
     def table_exists(self, table_name: str, schema_name: str | None = None) -> bool:
         """Return True if the named table exists in the Oracle database."""
         # Oracle folds unquoted identifiers to uppercase; normalise so a lookup
@@ -288,8 +322,7 @@ class OracleDatabase(Database):
         return len(rows) > 0
 
     def drop_table(self, tablename: str) -> None:
-        """Drop the named table with cascade constraints."""
-        tablename = self.type.quoted(tablename)
+        """Drop *tablename* (schema-qualified and quoted by the caller) with cascade constraints."""
         self.execute(f"drop table {tablename} cascade constraints")
 
     def paramsubs(self, paramcount: int) -> str:

execsql/db/postgres.py

@@ -16,7 +16,14 @@ from typing import Any
 from execsql.db.base import Database
 from execsql.exceptions import ErrInfo
 from execsql.utils.errors import exception_desc, fatal_error
-from execsql.utils.auth import clear_stored_password, get_password, password_from_keyring
+from execsql.utils.auth import (
+    begin_login,
+    clear_stored_password,
+    get_password,
+    is_login_failure,
+    password_from_keyring,
+    remember_password,
+)
 from execsql.utils.strings import encodings_match
 import execsql.state as _state
 
@@ -60,7 +67,6 @@ class PostgresDatabase(Database):
         self.type = dbt_postgres
         self.password = password
         self.new_db = new_db
-        self.encode_commands = False
         self.paramstr = "%s"
         self.connect_timeout = connect_timeout
         self.open_db()
@@ -123,31 +129,37 @@ class PostgresDatabase(Database):
 
         if self.conn is None:
             try:
+                begin_login()
                 if self.user and self.need_passwd and not self.password:
                     self.password = get_password(
                         "PostgreSQL",
                         self.db_name,
                         self.user,
                         server_name=self.server_name,
+                        port=self.port,
                     )
                 if self.new_db:
                     create_db(self)
                 try:
                     self.conn = db_conn(self, self.db_name)
-                except (ErrInfo, Exception):
-                    if not password_from_keyring():
+                except (ErrInfo, Exception) as e:
+                    # Only a rejected password means the stored one is stale;
+                    # a timeout or a missing database leaves it alone.
+                    if not (password_from_keyring() and is_login_failure(e)):
                         raise
                     # Stored credential is stale — clear it and re-prompt.
-                    clear_stored_password("PostgreSQL", self.db_name, self.user, self.server_name)
+                    clear_stored_password("PostgreSQL", self.db_name, self.user, self.server_name, port=self.port)
                     self.password = get_password(
                         "PostgreSQL",
                         self.db_name,
                         self.user,
                         server_name=self.server_name,
+                        port=self.port,
                         skip_keyring=True,
                         other_msg="(stored credential failed — enter current password)",
                     )
                     self.conn = db_conn(self, self.db_name)
+                remember_password("PostgreSQL", self.db_name, self.user, self.server_name, port=self.port)
             except SystemExit:
                 # If the user canceled the password prompt.
                 raise
@@ -178,6 +190,9 @@ class PostgresDatabase(Database):
             rows = curs.fetchall()
         return len(rows) > 0
 
+    # table_exists() without a schema looks only where CREATE TABLE puts a table: it searches the temp schema and the search path.
+    unqualified_lookup_is_scoped = True
+
     def table_exists(self, table_name: str, schema_name: str | None = None) -> bool:
         """Return True if the named table exists in the PostgreSQL database."""
         if schema_name is not None:
@@ -336,6 +351,8 @@ class PostgresDatabase(Database):
             and not _state.conf.trim_strings
             and not _state.conf.replace_newlines
         ):
+            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")
             if skipheader:
@@ -364,7 +381,14 @@ class PostgresDatabase(Database):
             with self._cursor() as curs:
                 try:
                     with curs.copy(copy_cmd) as copy:
-                        while chunk := rf.read(_state.conf.import_buffer):
+                        # COPY rejects a blank line; the row path reads it as an empty row.
+                        for chunk in blank_lines_as_empty_rows(
+                            rf,
+                            delim,
+                            csv_file_obj.quotechar,
+                            len(csv_file_cols),
+                            _state.conf.import_buffer,
+                        ):
                             copy.write(chunk)
                 except ErrInfo:
                     raise

execsql/db/sqlite.py

@@ -45,7 +45,6 @@ class SQLiteDatabase(Database):
             encoding="UTF-8",
         )
         self.type = dbt_sqlite
-        self.encode_commands = False
         self.timeout = timeout
         self.open_db()
 
@@ -95,6 +94,9 @@ class SQLiteDatabase(Database):
                 self.rollback()
                 raise
 
+    # table_exists() without a schema looks only where CREATE TABLE puts a table: one namespace.
+    unqualified_lookup_is_scoped = True
+
     def table_exists(self, table_name: str, schema_name: str | None = None) -> bool:
         """Return True if the named table exists in the SQLite database."""
         # SQLite stores names as-created; match case-insensitively so a lookup
@@ -170,8 +172,7 @@ class SQLiteDatabase(Database):
         return False
 
     def drop_table(self, tablename: str) -> None:
-        """Drop the named table from the SQLite database if it exists."""
-        tablename = self.type.quoted(tablename)
+        """Drop *tablename* (schema-qualified and quoted by the caller) if it exists."""
         self.execute(f"drop table if exists {tablename};")
 
     def populate_table(
@@ -237,14 +238,11 @@ class SQLiteDatabase(Database):
 
         last_line: list[Any] = []
         try:
-            for datalineno, line in enumerate(rowsource):
+            for line in rowsource:
                 # Skip empty rows.
                 if not (len(line) == 1 and line[0] is None):
-                    if len(line) < len(columns):
-                        raise ErrInfo(
-                            type="error",
-                            other_msg=f"Too few values on data line {datalineno} of input.",
-                        )
+                    # Trailing values left off the line are NULL.
+                    line = list(line) + [None] * (len(ts_colnames) - len(line))
                     if _state.conf.trim_strings or _state.conf.replace_newlines or not _state.conf.empty_strings:
                         for i in range(len(line)):
                             if line[i] is not None and isinstance(line[i], _state.stringtypes):

execsql/db/sqlserver.py

@@ -12,7 +12,14 @@ import re
 from execsql.db.base import Database
 from execsql.exceptions import ErrInfo
 from execsql.utils.errors import fatal_error
-from execsql.utils.auth import clear_stored_password, get_password, password_from_keyring
+from execsql.utils.auth import (
+    begin_login,
+    clear_stored_password,
+    get_password,
+    is_login_failure,
+    password_from_keyring,
+    remember_password,
+)
 import execsql.state as _state
 
 __all__ = ["SqlServerDatabase"]
@@ -47,11 +54,13 @@ class SqlServerDatabase(Database):
         self.type = dbt_sqlserver
         self.password = password
         self.encoding = encoding or "latin1"  # Default on installation of SQL Server
-        self.encode_commands = True
         self.paramstr = "?"
         self.open_db()
         self.password = None  # Clear cleartext password after successful connection
 
+    def current_schema(self) -> str | None:
+        return self._query_current_schema("select schema_name()")
+
     def __repr__(self) -> str:
         return (
             f"SqlServerDatabase({self.server_name!r}, {self.db_name!r}, {self.user!r}, "
@@ -75,12 +84,14 @@ class SqlServerDatabase(Database):
         import pyodbc
 
         if self.conn is None:
+            begin_login()
             if self.user and self.need_passwd and not self.password:
                 self.password = get_password(
                     "SQL Server",
                     self.db_name,
                     self.user,
                     server_name=self.server_name,
+                    port=self.port,
                 )
             # Use pyodbc to connect.  Try different driver versions from newest to oldest.
             ssdrivers = (
@@ -94,6 +105,8 @@ class SqlServerDatabase(Database):
                 "SQL Server",
             )
 
+            errors: list[BaseException] = []
+
             def _try_drivers():
                 for drv in ssdrivers:
                     if self.user:
@@ -117,7 +130,8 @@ class SqlServerDatabase(Database):
                         # default; pyodbc treats `timeout` as the login-and-
                         # query timeout on the connection.
                         self.conn = pyodbc.connect(connstr, timeout=30)
-                    except Exception:
+                    except Exception as e:
+                        errors.append(e)
                         if _state.exec_log is not None:
                             _state.exec_log.log_status_info(
                                 f"Could not connect using: {re.sub(r'Pwd=[^;]*', 'Pwd=***', connstr)}",
@@ -130,18 +144,22 @@ class SqlServerDatabase(Database):
                         return True
                 return False
 
-            if not _try_drivers() and password_from_keyring():
-                # Stored credential is stale — clear it and re-prompt.
-                clear_stored_password("SQL Server", self.db_name, self.user, self.server_name)
+            # Only a rejected password means the stored one is stale; a
+            # timeout or a missing database leaves it alone.
+            if not _try_drivers() and password_from_keyring() and any(is_login_failure(e) for e in errors):
+                clear_stored_password("SQL Server", self.db_name, self.user, self.server_name, port=self.port)
                 self.password = get_password(
                     "SQL Server",
                     self.db_name,
                     self.user,
                     server_name=self.server_name,
+                    port=self.port,
                     skip_keyring=True,
                     other_msg="(stored credential failed — enter current password)",
                 )
                 _try_drivers()
+            if self.conn:
+                remember_password("SQL Server", self.db_name, self.user, self.server_name, port=self.port)
 
             if not self.conn:
                 raise ErrInfo(
@@ -193,9 +211,8 @@ class SqlServerDatabase(Database):
         return len(rows) > 0
 
     def drop_table(self, tablename: str) -> None:
-        """Drop the named table from the SQL Server database."""
+        """Drop *tablename*, schema-qualified and quoted by the caller."""
         # SQL Server and Firebird will throw an error if there are foreign keys to the table.
-        tablename = self.type.quoted(tablename)
         self.execute(f"drop table {tablename};")
 
     def import_entire_file(