execsql2 2.0.1__py3-none-any.whl → 2.1.2__py3-none-any.whl

execsql/db/firebird.py

@@ -7,12 +7,11 @@ Implements :class:`FirebirdDatabase`, which connects to Firebird databases
 via the ``firebird-driver`` package.  Corresponds to ``-t f`` on the CLI.
 """
 
-from typing import List, Optional
 
 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 get_password
+from execsql.utils.auth import clear_stored_password, get_password, password_from_keyring
 import execsql.state as _state
 
 
@@ -21,11 +20,11 @@ class FirebirdDatabase(Database):
         self,
         server_name: str,
         db_name: str,
-        user_name: Optional[str],
+        user_name: str | None,
         need_passwd: bool = False,
-        port: Optional[int] = 3050,
-        encoding: Optional[str] = "latin1",
-        password: Optional[str] = None,
+        port: int | None = 3050,
+        encoding: str | None = "latin1",
+        password: str | None = None,
     ) -> None:
         try:
             import fdb as firebird_lib  # noqa: F401
@@ -41,7 +40,7 @@ class FirebirdDatabase(Database):
         self.user = str(user_name)
         self.need_passwd = need_passwd
         self.password = password
-        self.port = 3050 if not port else port
+        self.port = port if port else 3050
         self.encoding = encoding or "latin1"
         self.encode_commands = True
         self.paramstr = "?"
@@ -85,7 +84,21 @@ class FirebirdDatabase(Database):
                         self.user,
                         server_name=self.server_name,
                     )
-                self.conn = db_conn()
+                try:
+                    self.conn = db_conn()
+                except Exception:
+                    if not password_from_keyring():
+                        raise
+                    clear_stored_password("Firebird", self.db_name, self.user, self.server_name)
+                    self.password = get_password(
+                        "Firebird",
+                        self.db_name,
+                        self.user,
+                        server_name=self.server_name,
+                        skip_keyring=True,
+                        other_msg="(stored credential failed — enter current password)",
+                    )
+                    self.conn = db_conn()
             except SystemExit:
                 # If the user canceled the password prompt.
                 raise
@@ -106,7 +119,7 @@ class FirebirdDatabase(Database):
             raise
         _state.subvars.add_substitution("$LAST_ROWCOUNT", curs.rowcount)
 
-    def table_exists(self, table_name: str, schema_name: Optional[str] = None) -> bool:
+    def table_exists(self, table_name: str, schema_name: str | None = None) -> bool:
         curs = self.cursor()
         sql = (
             f"SELECT RDB$RELATION_NAME FROM RDB$RELATIONS "
@@ -118,17 +131,16 @@ class FirebirdDatabase(Database):
         except ErrInfo:
             raise
         except Exception:
-            e = ErrInfo(
+            try:
+                self.rollback()
+            except Exception:
+                pass  # Rollback is best-effort after a failed query.
+            raise ErrInfo(
                 type="db",
                 command_text=sql,
                 exception_msg=exception_desc(),
                 other_msg=f"Failed test for existence of Firebird table {table_name}",
             )
-            try:
-                self.rollback()
-            except Exception:
-                pass
-            raise e
         rows = curs.fetchall()
         self.conn.commit()
         curs.close()
@@ -138,7 +150,7 @@ class FirebirdDatabase(Database):
         self,
         table_name: str,
         column_name: str,
-        schema_name: Optional[str] = None,
+        schema_name: str | None = None,
     ) -> bool:
         curs = self.cursor()
         sql = f"select first 1 {column_name} from {table_name};"
@@ -148,7 +160,7 @@ class FirebirdDatabase(Database):
             return False
         return True
 
-    def table_columns(self, table_name: str, schema_name: Optional[str] = None) -> List[str]:
+    def table_columns(self, table_name: str, schema_name: str | None = None) -> list[str]:
         curs = self.cursor()
         sql = f"select first 1 * from {table_name};"
         try:
@@ -165,7 +177,7 @@ class FirebirdDatabase(Database):
             )
         return [d[0] for d in curs.description]
 
-    def view_exists(self, view_name: str, schema_name: Optional[str] = None) -> bool:
+    def view_exists(self, view_name: str, schema_name: str | None = None) -> bool:
         curs = self.cursor()
         sql = f"select distinct rdb$view_name from rdb$view_relations where rdb$view_name = '{view_name}';"
         try:

execsql/db/mysql.py

@@ -8,12 +8,12 @@ servers via ``pymysql``.  Corresponds to ``-t m`` on the CLI.
 """
 
 import re
-from typing import Any, List, Optional
+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 get_password
+from execsql.utils.auth import clear_stored_password, get_password, password_from_keyring
 import execsql.state as _state
 
 
@@ -22,11 +22,11 @@ class MySQLDatabase(Database):
         self,
         server_name: str,
         db_name: str,
-        user_name: Optional[str],
+        user_name: str | None,
         need_passwd: bool = False,
-        port: Optional[int] = 3306,
-        encoding: Optional[str] = "latin1",
-        password: Optional[str] = None,
+        port: int | None = 3306,
+        encoding: str | None = "latin1",
+        password: str | None = None,
     ) -> None:
         try:
             import pymysql as mysql_lib  # noqa: F401
@@ -42,7 +42,7 @@ class MySQLDatabase(Database):
         self.user = str(user_name)
         self.need_passwd = need_passwd
         self.password = password
-        self.port = 3306 if not port else port
+        self.port = port if port else 3306
         self.encoding = encoding or "latin1"
         self.encode_commands = True
         self.paramstr = "%s"
@@ -88,7 +88,21 @@ class MySQLDatabase(Database):
                         self.user,
                         server_name=self.server_name,
                     )
-                self.conn = db_conn()
+                try:
+                    self.conn = db_conn()
+                except Exception:
+                    if not password_from_keyring():
+                        raise
+                    clear_stored_password("MySQL", self.db_name, self.user, self.server_name)
+                    self.password = get_password(
+                        "MySQL",
+                        self.db_name,
+                        self.user,
+                        server_name=self.server_name,
+                        skip_keyring=True,
+                        other_msg="(stored credential failed — enter current password)",
+                    )
+                    self.conn = db_conn()
                 self.execute("set session sql_mode='ANSI';")
             except SystemExit:
                 # If the user canceled the password prompt.
@@ -126,7 +140,7 @@ class MySQLDatabase(Database):
 
     def import_tabular_file(
         self,
-        schema_name: Optional[str],
+        schema_name: str | None,
         table_name: str,
         csv_file_obj: Any,
         skipheader: bool,
@@ -193,9 +207,10 @@ class MySQLDatabase(Database):
                 next(f)
             curs = self.cursor()
             eof = False
+            total_rows = 0
             while True:
                 b: list = []
-                for j in range(_state.conf.import_row_buffer):
+                for _j in range(_state.conf.import_row_buffer):
                     try:
                         line = next(f)
                     except StopIteration:
@@ -244,15 +259,14 @@ class MySQLDatabase(Database):
                                                 " ",
                                                 line[i],
                                             )
-                                        if not _state.conf.empty_strings:
-                                            if line[i].strip() == "":
-                                                line[i] = None
+                                        if not _state.conf.empty_strings and line[i].strip() == "":
+                                            line[i] = None
                             # Pad short line with nulls
                             line.extend([None] * (len(import_cols) - len(line)))
                             linedata = [line[ix] for ix in data_indexes]
                             add_line = True
                             if not _state.conf.empty_rows:
-                                add_line = not all([c is None for c in linedata])
+                                add_line = not all(c is None for c in linedata)
                             if add_line:
                                 b.append(linedata)
                 if len(b) > 0:
@@ -268,5 +282,15 @@ class MySQLDatabase(Database):
                             exception_msg=exception_desc(),
                             other_msg=f"Import from file into table {sq_name}, line {{{line}}}",
                         )
+                    total_rows += len(b)
+                    interval = _state.conf.import_progress_interval
+                    if _state.exec_log and interval > 0 and total_rows % interval == 0:
+                        _state.exec_log.log_status_info(
+                            f"IMPORT into {sq_name}: {total_rows} rows imported so far.",
+                        )
                 if eof:
                     break
+            if _state.exec_log:
+                _state.exec_log.log_status_info(
+                    f"IMPORT into {sq_name} complete: {total_rows} rows imported.",
+                )

execsql/db/oracle.py

@@ -8,12 +8,12 @@ via the ``oracledb`` driver (python-oracledb).  Corresponds to ``-t o``
 on the CLI.
 """
 
-from typing import Any, List, Optional, Tuple
+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 get_password
+from execsql.utils.auth import clear_stored_password, get_password, password_from_keyring
 import execsql.state as _state
 
 
@@ -22,11 +22,11 @@ class OracleDatabase(Database):
         self,
         server_name: str,
         db_name: str,
-        user_name: Optional[str],
+        user_name: str | None,
         need_passwd: bool = False,
-        port: Optional[int] = 5432,
-        encoding: Optional[str] = "UTF8",
-        password: Optional[str] = None,
+        port: int | None = 5432,
+        encoding: str | None = "UTF8",
+        password: str | None = None,
     ) -> None:
         try:
             import cx_Oracle  # noqa: F401
@@ -75,7 +75,21 @@ class OracleDatabase(Database):
                         self.user,
                         server_name=self.server_name,
                     )
-                self.conn = db_conn(self, self.db_name)
+                try:
+                    self.conn = db_conn(self, self.db_name)
+                except Exception:
+                    if not password_from_keyring():
+                        raise
+                    clear_stored_password("Oracle", self.db_name, self.user, self.server_name)
+                    self.password = get_password(
+                        "Oracle",
+                        self.db_name,
+                        self.user,
+                        server_name=self.server_name,
+                        skip_keyring=True,
+                        other_msg="(stored credential failed — enter current password)",
+                    )
+                    self.conn = db_conn(self, self.db_name)
             except SystemExit:
                 # If the user canceled the password prompt.
                 raise
@@ -85,14 +99,14 @@ class OracleDatabase(Database):
                 msg = f"Failed to open Oracle database {self.db_name} on {self.server_name}"
                 raise ErrInfo(type="exception", exception_msg=exception_desc(), other_msg=msg)
 
-    def execute(self, sql: Any, paramlist: Optional[list] = None) -> None:
+    def execute(self, sql: Any, paramlist: list | None = None) -> None:
         # Strip any semicolon off the end and pass to the parent method.
         if sql[-1:] == ";":
             super().execute(sql[:-1], paramlist)
         else:
             super().execute(sql, paramlist)
 
-    def select_data(self, sql: str) -> Tuple[List[str], list]:
+    def select_data(self, sql: str) -> tuple[list[str], list]:
         if sql[-1:] == ";":
             return super().select_data(sql[:-1])
         else:
@@ -115,12 +129,16 @@ class OracleDatabase(Database):
 
         raise DatabaseNotImplementedError(self.name(), "schema_exists")
 
-    def table_exists(self, table_name: str, schema_name: Optional[str] = None) -> bool:
+    def table_exists(self, table_name: str, schema_name: str | None = None) -> bool:
         curs = self.cursor()
-        owner_clause = "" if not schema_name else f" and owner ='{schema_name}'"
-        sql = f"select table_name from sys.all_tables where table_name = '{table_name}'{owner_clause}"
+        params = {"tname": table_name}
+        owner_clause = ""
+        if schema_name:
+            owner_clause = " and owner = :owner"
+            params["owner"] = schema_name
+        sql = f"select table_name from sys.all_tables where table_name = :tname{owner_clause}"
         try:
-            curs.execute(sql)
+            curs.execute(sql, params)
         except ErrInfo:
             raise
         except Exception:
@@ -139,17 +157,17 @@ class OracleDatabase(Database):
         self,
         table_name: str,
         column_name: str,
-        schema_name: Optional[str] = None,
+        schema_name: str | None = None,
     ) -> bool:
         curs = self.cursor()
-        owner_clause = "" if not schema_name else f" and owner ='{schema_name}'"
-        sql = (
-            f"select column_name from all_tab_columns "
-            f"where table_name='{table_name}'{owner_clause} "
-            f"and column_name='{column_name}'"
-        )
+        params = {"tname": table_name, "cname": column_name}
+        owner_clause = ""
+        if schema_name:
+            owner_clause = " and owner = :owner"
+            params["owner"] = schema_name
+        sql = f"select column_name from all_tab_columns where table_name=:tname{owner_clause} and column_name=:cname"
         try:
-            curs.execute(sql)
+            curs.execute(sql, params)
         except ErrInfo:
             raise
         except Exception:
@@ -164,14 +182,16 @@ class OracleDatabase(Database):
         curs.close()
         return len(rows) > 0
 
-    def table_columns(self, table_name: str, schema_name: Optional[str] = None) -> List[str]:
+    def table_columns(self, table_name: str, schema_name: str | None = None) -> list[str]:
         curs = self.cursor()
-        owner_clause = "" if not schema_name else f" and owner='{schema_name}'"
-        sql = (
-            f"select column_name from all_tab_columns where table_name='{table_name}'{owner_clause} order by column_id"
-        )
+        params = {"tname": table_name}
+        owner_clause = ""
+        if schema_name:
+            owner_clause = " and owner=:owner"
+            params["owner"] = schema_name
+        sql = f"select column_name from all_tab_columns where table_name=:tname{owner_clause} order by column_id"
         try:
-            curs.execute(sql)
+            curs.execute(sql, params)
         except ErrInfo:
             raise
         except Exception:
@@ -186,12 +206,16 @@ class OracleDatabase(Database):
         curs.close()
         return [row[0] for row in rows]
 
-    def view_exists(self, view_name: str, schema_name: Optional[str] = None) -> bool:
+    def view_exists(self, view_name: str, schema_name: str | None = None) -> bool:
         curs = self.cursor()
-        owner_clause = "" if not schema_name else f" and owner ='{schema_name}'"
-        sql = f"select view_name from sys.all_views where view_name = '{view_name}'{owner_clause}"
+        params = {"vname": view_name}
+        owner_clause = ""
+        if schema_name:
+            owner_clause = " and owner = :owner"
+            params["owner"] = schema_name
+        sql = f"select view_name from sys.all_views where view_name = :vname{owner_clause}"
         try:
-            curs.execute(sql)
+            curs.execute(sql, params)
         except ErrInfo:
             raise
         except Exception:
@@ -209,8 +233,9 @@ class OracleDatabase(Database):
     def role_exists(self, rolename: str) -> bool:
         curs = self.cursor()
         curs.execute(
-            f"select role from dba_roles where role = '{rolename}' union "
-            f" select username from all_users where username = '{rolename}';",
+            "select role from dba_roles where role = :rname union "
+            " select username from all_users where username = :rname",
+            {"rname": rolename},
         )
         rows = curs.fetchall()
         curs.close()

execsql/db/postgres.py

@@ -9,29 +9,32 @@ supporting schema-qualified tables, server-side ``COPY``, ``LISTEN``/
 ``-t p`` on the CLI.
 """
 
-import io
 import re
-from typing import Any, List, Optional, Tuple
+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 get_password
+from execsql.utils.auth import clear_stored_password, get_password, password_from_keyring
 from execsql.utils.strings import encodings_match
 import execsql.state as _state
 
 
+DEFAULT_CONNECT_TIMEOUT = 30  # seconds
+
+
 class PostgresDatabase(Database):
     def __init__(
         self,
         server_name: str,
         db_name: str,
-        user_name: Optional[str],
+        user_name: str | None,
         need_passwd: bool = False,
-        port: Optional[int] = 5432,
+        port: int | None = 5432,
         new_db: bool = False,
-        encoding: Optional[str] = "UTF8",
-        password: Optional[str] = None,
+        encoding: str | None = "UTF8",
+        password: str | None = None,
+        connect_timeout: int = DEFAULT_CONNECT_TIMEOUT,
     ) -> None:
         try:
             import psycopg2  # noqa: F401
@@ -52,6 +55,7 @@ class PostgresDatabase(Database):
         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()
@@ -74,12 +78,14 @@ class PostgresDatabase(Database):
                         port=db.port,
                         user=db.user,
                         password=db.password,
+                        connect_timeout=db.connect_timeout,
                     )
                 else:
                     return psycopg2.connect(
                         host=str(db.server_name),
                         database=db_name,
                         port=db.port,
+                        connect_timeout=db.connect_timeout,
                     )
             except Exception:
                 msg = (
@@ -106,7 +112,22 @@ class PostgresDatabase(Database):
                     )
                 if self.new_db:
                     create_db(self)
-                self.conn = db_conn(self, self.db_name)
+                try:
+                    self.conn = db_conn(self, self.db_name)
+                except (ErrInfo, Exception):
+                    if not password_from_keyring():
+                        raise
+                    # Stored credential is stale — clear it and re-prompt.
+                    clear_stored_password("PostgreSQL", self.db_name, self.user, self.server_name)
+                    self.password = get_password(
+                        "PostgreSQL",
+                        self.db_name,
+                        self.user,
+                        server_name=self.server_name,
+                        skip_keyring=True,
+                        other_msg="(stored credential failed — enter current password)",
+                    )
+                    self.conn = db_conn(self, self.db_name)
             except SystemExit:
                 # If the user canceled the password prompt.
                 raise
@@ -131,24 +152,29 @@ class PostgresDatabase(Database):
 
     def role_exists(self, rolename: str) -> bool:
         curs = self.cursor()
-        curs.execute(f"select rolname from pg_roles where rolname = '{rolename}';")
+        curs.execute("select rolname from pg_roles where rolname = %s;", (rolename,))
         rows = curs.fetchall()
         curs.close()
         return len(rows) > 0
 
-    def table_exists(self, table_name: str, schema_name: Optional[str] = None) -> bool:
+    def table_exists(self, table_name: str, schema_name: str | None = None) -> bool:
         curs = self.cursor()
         if schema_name is not None:
-            schema_clause = "" if not schema_name else f" and table_schema='{schema_name}'"
-            sql = f"select table_name from information_schema.tables where table_name = '{table_name}'{schema_clause};"
+            params: list = [table_name]
+            schema_clause = ""
+            if schema_name:
+                schema_clause = " and table_schema=%s"
+                params.append(schema_name)
+            sql = f"select table_name from information_schema.tables where table_name = %s{schema_clause};"
         else:
-            sql = f"""select table_name from information_schema.tables where table_name = '{table_name}' and
+            params = [table_name]
+            sql = """select table_name from information_schema.tables where table_name = %s and
 \t         table_schema in (select nspname from pg_namespace where oid = pg_my_temp_schema()
                      union
                      select trim(unnest(string_to_array(replace(setting, '"$user"', CURRENT_USER), ',')))
                      from pg_settings where name = 'search_path');"""
         try:
-            curs.execute(sql)
+            curs.execute(sql, params)
         except ErrInfo:
             raise
         except Exception:
@@ -163,19 +189,24 @@ class PostgresDatabase(Database):
         curs.close()
         return len(rows) > 0
 
-    def view_exists(self, view_name: str, schema_name: Optional[str] = None) -> bool:
+    def view_exists(self, view_name: str, schema_name: str | None = None) -> bool:
         curs = self.cursor()
         if schema_name is not None:
-            schema_clause = "" if not schema_name else f" and table_schema='{schema_name}'"
-            sql = f"select table_name from information_schema.views where table_name = '{view_name}'{schema_clause};"
+            params: list = [view_name]
+            schema_clause = ""
+            if schema_name:
+                schema_clause = " and table_schema=%s"
+                params.append(schema_name)
+            sql = f"select table_name from information_schema.views where table_name = %s{schema_clause};"
         else:
-            sql = f"""select table_name from information_schema.views where table_name = '{view_name}' and
+            params = [view_name]
+            sql = """select table_name from information_schema.views where table_name = %s and
 \t         table_schema in (select nspname from pg_namespace where oid = pg_my_temp_schema()
                      union
                      select trim(unnest(string_to_array(replace(setting, '"$user"', CURRENT_USER), ',')))
                      from pg_settings where name = 'search_path');"""
         try:
-            curs.execute(sql)
+            curs.execute(sql, params)
         except ErrInfo:
             raise
         except Exception:
@@ -198,7 +229,7 @@ class PostgresDatabase(Database):
 
     def import_tabular_file(
         self,
-        schema_name: Optional[str],
+        schema_name: str | None,
         table_name: str,
         csv_file_obj: Any,
         skipheader: bool,
@@ -254,7 +285,6 @@ class PostgresDatabase(Database):
         input_enc = csv_file_obj.encoding.lower()
         if input_enc in enc_xlates:
             input_enc = enc_xlates[input_enc]
-        enc_match = encodings_match(csv_file_obj.encoding, self.encoding)
         if (
             encodings_match(input_enc, self.encoding)
             and data_table_cols == csv_file_cols
@@ -301,9 +331,10 @@ class PostgresDatabase(Database):
                 next(f)
             curs = self.cursor()
             eof = False
+            total_rows = 0
             while True:
                 b: list = []
-                for j in range(_state.conf.import_row_buffer):
+                for _j in range(_state.conf.import_row_buffer):
                     try:
                         line = next(f)
                     except StopIteration:
@@ -352,15 +383,14 @@ class PostgresDatabase(Database):
                                                 " ",
                                                 line[i],
                                             )
-                                        if not _state.conf.empty_strings:
-                                            if line[i].strip() == "":
-                                                line[i] = None
+                                        if not _state.conf.empty_strings and line[i].strip() == "":
+                                            line[i] = None
                             # Pad short line with nulls
                             line.extend([None] * (len(import_cols) - len(line)))
                             linedata = [line[ix] for ix in data_indexes]
                             add_line = True
                             if not _state.conf.empty_rows:
-                                add_line = not all([c is None for c in linedata])
+                                add_line = not all(c is None for c in linedata)
                             if add_line:
                                 b.append(linedata)
                 if len(b) > 0:
@@ -376,19 +406,29 @@ class PostgresDatabase(Database):
                             exception_msg=exception_desc(),
                             other_msg=f"Can't load data into table {sq_name} of {self.name()} from line {{{line}}}",
                         )
+                    total_rows += len(b)
+                    interval = _state.conf.import_progress_interval
+                    if _state.exec_log and interval > 0 and total_rows % interval == 0:
+                        _state.exec_log.log_status_info(
+                            f"IMPORT into {sq_name}: {total_rows} rows imported so far.",
+                        )
                 if eof:
                     break
+            if _state.exec_log:
+                _state.exec_log.log_status_info(
+                    f"IMPORT into {sq_name} complete: {total_rows} rows imported.",
+                )
 
     def import_entire_file(
         self,
-        schema_name: Optional[str],
+        schema_name: str | None,
         table_name: str,
         column_name: str,
         file_name: str,
     ) -> None:
         import psycopg2
 
-        with io.open(file_name, "rb") as f:
+        with open(file_name, "rb") as f:
             filedata = f.read()
         sq_name = self.schema_qualified_table_name(schema_name, table_name)
         sql = f"insert into {sq_name} ({column_name}) values ({self.paramsubs(1)});"