execsql2 2.15.5__py3-none-any.whl → 2.15.7__py3-none-any.whl

execsql/config.py

@@ -290,8 +290,11 @@ class ConfigData:
             config_files = [sys_config_file, user_config_file, script_config_file, startdir_config_file]
         else:
             config_files = [sys_config_file, user_config_file, startdir_config_file]
+        _MAX_CONFIG_CHAIN = 20  # Guard against circular config_file references.
         self.files_read: list = []
         for ix, configfile in enumerate(config_files):
+            if len(self.files_read) >= _MAX_CONFIG_CHAIN:
+                break
             if configfile not in self.files_read and Path(configfile).is_file():
                 self.files_read.append(configfile)
                 cp = ConfigParser()

execsql/db/access.py

@@ -243,16 +243,16 @@ class AccessDatabase(Database):
                     self.temp_query_names.append(qn)
             else:
                 self.dao_flush_check()
-                curs = self.cursor()
-                if self.jet4:
-                    encoded_sql = str(sql)
-                else:
-                    encoded_sql = str(sql).encode(self.encoding)
-                if paramlist is None:
-                    curs.execute(encoded_sql)
-                else:
-                    curs.execute(encoded_sql, paramlist)
-                _state.subvars.add_substitution("$LAST_ROWCOUNT", curs.rowcount)
+                with self._cursor() as curs:
+                    if self.jet4:
+                        encoded_sql = str(sql)
+                    else:
+                        encoded_sql = str(sql).encode(self.encoding)
+                    if paramlist is None:
+                        curs.execute(encoded_sql)
+                    else:
+                        curs.execute(encoded_sql, paramlist)
+                    _state.subvars.add_substitution("$LAST_ROWCOUNT", curs.rowcount)
 
         if type(sqlcmd) in (list, tuple):
             for sql in sqlcmd:
@@ -269,10 +269,10 @@ class AccessDatabase(Database):
         # Returns the results of the sql select statement.
         # The Access driver returns data as unicode, so no decoding is necessary.
         self.dao_flush_check()
-        curs = self.cursor()
-        curs.execute(sql)
-        rows = curs.fetchall()
-        return [d[0] for d in curs.description], rows
+        with self._cursor() as curs:
+            curs.execute(sql)
+            rows = curs.fetchall()
+            return [d[0] for d in curs.description], rows
 
     def select_rowsource(self, sql: str) -> tuple[list[str], Any]:
         """Return column names and an iterable that yields rows one at a time."""
@@ -308,20 +308,20 @@ class AccessDatabase(Database):
     def table_exists(self, table_name: str, schema_name: str | None = None) -> bool:
         """Return True if the named table exists in the Access database."""
         self.dao_flush_check()
-        curs = self.cursor()
-        try:
-            sql = "select Name from MSysObjects where Name=? And Type In (1,4,6);"
-            curs.execute(sql, (table_name,))
-        except ErrInfo:
-            raise
-        except Exception as e:
-            raise ErrInfo(
-                type="db",
-                command_text=sql,
-                exception_msg=exception_desc(),
-                other_msg=f"Failure on test for existence of Access table {table_name}",
-            ) from e
-        rows = curs.fetchall()
+        sql = "select Name from MSysObjects where Name=? And Type In (1,4,6);"
+        with self._cursor() as curs:
+            try:
+                curs.execute(sql, (table_name,))
+            except ErrInfo:
+                raise
+            except Exception as e:
+                raise ErrInfo(
+                    type="db",
+                    command_text=sql,
+                    exception_msg=exception_desc(),
+                    other_msg=f"Failure on test for existence of Access table {table_name}",
+                ) from e
+            rows = curs.fetchall()
         return len(rows) > 0
 
     def column_exists(
@@ -332,41 +332,41 @@ class AccessDatabase(Database):
     ) -> bool:
         """Return True if the named column exists in the given Access table."""
         self.dao_flush_check()
-        curs = self.cursor()
         quoted_col = self.quote_identifier(column_name)
         quoted_tbl = self.quote_identifier(table_name)
         sql = f"select top 1 {quoted_col} from {quoted_tbl};"
-        try:
-            curs.execute(sql)
-        except Exception:
-            return False
+        with self._cursor() as curs:
+            try:
+                curs.execute(sql)
+            except Exception:
+                return False
         return True
 
     def table_columns(self, table_name: str, schema_name: str | None = None) -> list[str]:
         """Return a list of column names for the given Access table."""
         self.dao_flush_check()
-        curs = self.cursor()
         quoted_tbl = self.quote_identifier(table_name)
-        curs.execute(f"select top 1 * from {quoted_tbl};")
-        return [d[0] for d in curs.description]
+        with self._cursor() as curs:
+            curs.execute(f"select top 1 * from {quoted_tbl};")
+            return [d[0] for d in curs.description]
 
     def view_exists(self, view_name: str, schema_name: str | None = None) -> bool:
         """Return True if the named view or query exists in the Access database."""
         self.dao_flush_check()
-        curs = self.cursor()
-        try:
-            sql = "select Name from MSysObjects where Name=? And Type = 5;"
-            curs.execute(sql, (view_name,))
-        except ErrInfo:
-            raise
-        except Exception as e:
-            raise ErrInfo(
-                type="db",
-                command_text=sql,
-                exception_msg=exception_desc(),
-                other_msg=f"Test for existence of Access view/query {view_name}",
-            ) from e
-        rows = curs.fetchall()
+        sql = "select Name from MSysObjects where Name=? And Type = 5;"
+        with self._cursor() as curs:
+            try:
+                curs.execute(sql, (view_name,))
+            except ErrInfo:
+                raise
+            except Exception as e:
+                raise ErrInfo(
+                    type="db",
+                    command_text=sql,
+                    exception_msg=exception_desc(),
+                    other_msg=f"Test for existence of Access view/query {view_name}",
+                ) from e
+            rows = curs.fetchall()
         return len(rows) > 0
 
     def schema_exists(self, schema_name: str) -> bool:
@@ -447,4 +447,5 @@ class AccessDatabase(Database):
         sq_name = self.schema_qualified_table_name(schema_name, table_name)
         quoted_col = self.quote_identifier(column_name)
         sql = f"insert into {sq_name} ({quoted_col}) values ({self.paramsubs(1)});"
-        self.cursor().execute(sql, (pyodbc.Binary(filedata),))
+        with self._cursor() as curs:
+            curs.execute(sql, (pyodbc.Binary(filedata),))

execsql/db/base.py

@@ -460,7 +460,6 @@ class Database(ABC):
         paramspec = self.paramsubs(len(columns))
         sql = f"insert into {sq_name} ({colspec}) values ({paramspec});"
         rows = iter(rowsource)
-        curs = self.cursor()
         eof = False
         total_rows = 0
 
@@ -483,7 +482,7 @@ class Database(ABC):
             except ImportError:
                 use_progress = False
 
-        def _import_loop() -> int:
+        def _import_loop(curs) -> int:
             nonlocal eof, total_rows, task_id
             while True:
                 b = []
@@ -575,12 +574,13 @@ class Database(ABC):
                     break
             return total_rows
 
-        if use_progress and progress_ctx is not None:
-            with progress_ctx:
-                task_id = progress_ctx.add_task(sq_name, total=None)
-                _import_loop()
-        else:
-            _import_loop()
+        with self._cursor() as curs:
+            if use_progress and progress_ctx is not None:
+                with progress_ctx:
+                    task_id = progress_ctx.add_task(sq_name, total=None)
+                    _import_loop(curs)
+            else:
+                _import_loop(curs)
 
         if _state.exec_log:
             _state.exec_log.log_status_info(

execsql/db/dsn.py

@@ -145,4 +145,5 @@ class DsnDatabase(Database):
         sq_name = self.schema_qualified_table_name(schema_name, table_name)
         quoted_col = self.quote_identifier(column_name)
         sql = f"insert into {sq_name} ({quoted_col}) values ({self.paramsubs(1)});"
-        self.cursor().execute(sql, (pyodbc.Binary(filedata),))
+        with self._cursor() as curs:
+            curs.execute(sql, (pyodbc.Binary(filedata),))

execsql/db/duckdb.py

@@ -67,7 +67,7 @@ class DuckDBDatabase(Database):
         with self._cursor() as curs:
             cmd = f"select * from {querycommand};"
             try:
-                curs.execute(cmd.encode(self.encoding))
+                curs.execute(cmd)
                 _state.subvars.add_substitution("$LAST_ROWCOUNT", curs.rowcount)
             except Exception:
                 self.rollback()

execsql/db/firebird.py

@@ -127,30 +127,29 @@ class FirebirdDatabase(Database):
 
     def table_exists(self, table_name: str, schema_name: str | None = None) -> bool:
         """Return True if the named table exists in the Firebird database."""
-        curs = self.cursor()
         sql = (
             "SELECT RDB$RELATION_NAME FROM RDB$RELATIONS "
             "WHERE RDB$SYSTEM_FLAG=0 AND RDB$VIEW_BLR IS NULL "
             "AND RDB$RELATION_NAME=?;"
         )
-        try:
-            curs.execute(sql, (table_name.upper(),))
-        except ErrInfo:
-            raise
-        except Exception as e:
+        with self._cursor() as curs:
             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}",
-            ) from e
-        rows = curs.fetchall()
+                curs.execute(sql, (table_name.upper(),))
+            except ErrInfo:
+                raise
+            except Exception as e:
+                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}",
+                ) from e
+            rows = curs.fetchall()
         self.conn.commit()
-        curs.close()
         return len(rows) > 0
 
     def column_exists(
@@ -160,53 +159,52 @@ class FirebirdDatabase(Database):
         schema_name: str | None = None,
     ) -> bool:
         """Return True if the named column exists in the given Firebird table."""
-        curs = self.cursor()
         quoted_col = self.quote_identifier(column_name)
         quoted_tbl = self.quote_identifier(table_name)
         sql = f"select first 1 {quoted_col} from {quoted_tbl};"
-        try:
-            curs.execute(sql)
-        except Exception:
-            return False
+        with self._cursor() as curs:
+            try:
+                curs.execute(sql)
+            except Exception:
+                return False
         return True
 
     def table_columns(self, table_name: str, schema_name: str | None = None) -> list[str]:
         """Return a list of column names for the given Firebird table."""
-        curs = self.cursor()
         quoted_tbl = self.quote_identifier(table_name)
         sql = f"select first 1 * from {quoted_tbl};"
-        try:
-            curs.execute(sql)
-        except ErrInfo:
-            raise
-        except Exception as e:
-            self.rollback()
-            raise ErrInfo(
-                type="db",
-                command_text=sql,
-                exception_msg=exception_desc(),
-                other_msg=f"Failed to get column names for table {table_name} of {self.name()}",
-            ) from e
-        return [d[0] for d in curs.description]
+        with self._cursor() as curs:
+            try:
+                curs.execute(sql)
+            except ErrInfo:
+                raise
+            except Exception as e:
+                self.rollback()
+                raise ErrInfo(
+                    type="db",
+                    command_text=sql,
+                    exception_msg=exception_desc(),
+                    other_msg=f"Failed to get column names for table {table_name} of {self.name()}",
+                ) from e
+            return [d[0] for d in curs.description]
 
     def view_exists(self, view_name: str, schema_name: str | None = None) -> bool:
         """Return True if the named view exists in the Firebird database."""
-        curs = self.cursor()
         sql = "select distinct rdb$view_name from rdb$view_relations where rdb$view_name = ?;"
-        try:
-            curs.execute(sql, (view_name,))
-        except ErrInfo:
-            raise
-        except Exception as e:
-            self.rollback()
-            raise ErrInfo(
-                type="db",
-                command_text=sql,
-                exception_msg=exception_desc(),
-                other_msg=f"Failed test for existence of Firebird view {view_name}",
-            ) from e
-        rows = curs.fetchall()
-        curs.close()
+        with self._cursor() as curs:
+            try:
+                curs.execute(sql, (view_name,))
+            except ErrInfo:
+                raise
+            except Exception as e:
+                self.rollback()
+                raise ErrInfo(
+                    type="db",
+                    command_text=sql,
+                    exception_msg=exception_desc(),
+                    other_msg=f"Failed test for existence of Firebird view {view_name}",
+                ) from e
+            rows = curs.fetchall()
         return len(rows) > 0
 
     def schema_exists(self, schema_name: str) -> bool:
@@ -215,14 +213,13 @@ class FirebirdDatabase(Database):
 
     def role_exists(self, rolename: str) -> bool:
         """Return True if the named role or user exists in the Firebird database."""
-        curs = self.cursor()
-        curs.execute(
-            "SELECT DISTINCT USER FROM RDB$USER_PRIVILEGES WHERE USER = ? union "
-            " SELECT DISTINCT RDB$ROLE_NAME FROM RDB$ROLES WHERE RDB$ROLE_NAME = ?;",
-            (rolename, rolename),
-        )
-        rows = curs.fetchall()
-        curs.close()
+        with self._cursor() as curs:
+            curs.execute(
+                "SELECT DISTINCT USER FROM RDB$USER_PRIVILEGES WHERE USER = ? union "
+                " SELECT DISTINCT RDB$ROLE_NAME FROM RDB$ROLES WHERE RDB$ROLE_NAME = ?;",
+                (rolename, rolename),
+            )
+            rows = curs.fetchall()
         return len(rows) > 0
 
     def drop_table(self, tablename: str) -> None:

execsql/db/mysql.py

@@ -53,9 +53,9 @@ class MySQLDatabase(Database):
         from execsql.types import dbt_mysql
 
         self.type = dbt_mysql
-        self.server_name = str(server_name)
-        self.db_name = str(db_name)
-        self.user = str(user_name)
+        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
@@ -148,15 +148,14 @@ class MySQLDatabase(Database):
 
     def role_exists(self, rolename: str) -> bool:
         """Return True if the named role or user exists in the MySQL server."""
-        curs = self.cursor()
-        curs.execute(
-            "select distinct user as role from mysql.user where user = %s"
-            " union select distinct role_name as role from information_schema.applicable_roles"
-            " where role_name = %s",
-            (rolename, rolename),
-        )
-        rows = curs.fetchall()
-        curs.close()
+        with self._cursor() as curs:
+            curs.execute(
+                "select distinct user as role from mysql.user where user = %s"
+                " union select distinct role_name as role from information_schema.applicable_roles"
+                " where role_name = %s",
+                (rolename, rolename),
+            )
+            rows = curs.fetchall()
         return len(rows) > 0
 
     def import_tabular_file(
@@ -205,16 +204,19 @@ class MySQLDatabase(Database):
             and not _state.conf.trim_strings
             and not _state.conf.replace_newlines
         ):
-            import_sql = f"load data local infile '{csv_file_obj.csvfname}' into table {sq_name}"
+            safe_fname = csv_file_obj.csvfname.replace("'", "''")
+            import_sql = f"load data local infile '{safe_fname}' 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:
-                    import_sql = f"{import_sql} terminated by '{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:
-                    import_sql = f"{import_sql} optionally enclosed by '{csv_file_obj.quotechar}'"
+                    safe_quote = csv_file_obj.quotechar.replace("'", "''")
+                    import_sql = f"{import_sql} optionally enclosed by '{safe_quote}'"
             import_sql = f"{import_sql} ignore {1 + csv_file_obj.junk_header_lines} lines"
             import_sql = f"{import_sql} ({input_col_list});"
             _state.exec_log.log_status_info(
@@ -228,91 +230,91 @@ class MySQLDatabase(Database):
             f = csv_file_obj.reader()
             if skipheader:
                 next(f)
-            curs = self.cursor()
             eof = False
             total_rows = 0
-            while True:
-                b: list = []
-                for _j in range(_state.conf.import_row_buffer):
-                    try:
-                        line = next(f)
-                    except StopIteration:
-                        eof = True
-                    else:
-                        if len(line) > len(csv_file_cols):
-                            extra_err = True
-                            if _state.conf.del_empty_cols:
-                                any_non_empty = False
-                                for cno in range(len(csv_file_cols), len(line)):
-                                    if not (
-                                        line[cno] is None
-                                        or (
-                                            not _state.conf.empty_strings
-                                            and isinstance(line[cno], _state.stringtypes)
-                                            and len(line[cno].strip()) == 0
-                                        )
-                                        and _state.conf.del_empty_cols
-                                    ):
-                                        any_non_empty = True
-                                        break
-                                extra_err = any_non_empty
-                            if extra_err:
-                                raise ErrInfo(
-                                    type="error",
-                                    other_msg=f"Too many data columns on line {{{line}}}",
-                                )
-                            else:
-                                line = line[: len(csv_file_cols)]
-                        if not (len(line) == 1 and line[0] is None):
-                            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,
-                                    ):
-                                        if _state.conf.trim_strings:
-                                            line[i] = line[i].strip()
-                                        if _state.conf.replace_newlines:
-                                            line[i] = re.sub(
-                                                r"[\s\t]*[\r\n]+[\s\t]*",
-                                                " ",
-                                                line[i],
+            with self._cursor() as curs:
+                while True:
+                    b: list = []
+                    for _j in range(_state.conf.import_row_buffer):
+                        try:
+                            line = next(f)
+                        except StopIteration:
+                            eof = True
+                        else:
+                            if len(line) > len(csv_file_cols):
+                                extra_err = True
+                                if _state.conf.del_empty_cols:
+                                    any_non_empty = False
+                                    for cno in range(len(csv_file_cols), len(line)):
+                                        if not (
+                                            line[cno] is None
+                                            or (
+                                                not _state.conf.empty_strings
+                                                and isinstance(line[cno], _state.stringtypes)
+                                                and len(line[cno].strip()) == 0
                                             )
-                                        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)
-                            if add_line:
-                                b.append(linedata)
-                if len(b) > 0:
-                    try:
-                        curs.executemany(sql_template, b)
-                    except ErrInfo:
-                        raise
-                    except Exception as e:
-                        self.rollback()
-                        raise ErrInfo(
-                            type="db",
-                            command_text=sql_template,
-                            exception_msg=exception_desc(),
-                            other_msg=f"Import from file into table {sq_name}, line {{{line}}}",
-                        ) from e
-                    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
+                                            and _state.conf.del_empty_cols
+                                        ):
+                                            any_non_empty = True
+                                            break
+                                    extra_err = any_non_empty
+                                if extra_err:
+                                    raise ErrInfo(
+                                        type="error",
+                                        other_msg=f"Too many data columns on line {{{line}}}",
+                                    )
+                                else:
+                                    line = line[: len(csv_file_cols)]
+                            if not (len(line) == 1 and line[0] is None):
+                                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,
+                                        ):
+                                            if _state.conf.trim_strings:
+                                                line[i] = line[i].strip()
+                                            if _state.conf.replace_newlines:
+                                                line[i] = re.sub(
+                                                    r"[\s\t]*[\r\n]+[\s\t]*",
+                                                    " ",
+                                                    line[i],
+                                                )
+                                            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)
+                                if add_line:
+                                    b.append(linedata)
+                    if len(b) > 0:
+                        try:
+                            curs.executemany(sql_template, b)
+                        except ErrInfo:
+                            raise
+                        except Exception as e:
+                            self.rollback()
+                            raise ErrInfo(
+                                type="db",
+                                command_text=sql_template,
+                                exception_msg=exception_desc(),
+                                other_msg=f"Import from file into table {sq_name}, line {{{line}}}",
+                            ) from e
+                        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.",