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

execsql/db/oracle.py

@@ -24,7 +24,7 @@ class OracleDatabase(Database):
         db_name: str,
         user_name: str | None,
         need_passwd: bool = False,
-        port: int | None = 5432,
+        port: int | None = 1521,
         encoding: str | None = "UTF8",
         password: str | None = None,
     ) -> None:
@@ -95,9 +95,9 @@ class OracleDatabase(Database):
                 raise
             except ErrInfo:
                 raise
-            except Exception:
+            except Exception as e:
                 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)
+                raise ErrInfo(type="exception", exception_msg=exception_desc(), other_msg=msg) from e
 
     def execute(self, sql: Any, paramlist: list | None = None) -> None:
         # Strip any semicolon off the end and pass to the parent method.
@@ -141,14 +141,14 @@ class OracleDatabase(Database):
             curs.execute(sql, params)
         except ErrInfo:
             raise
-        except Exception:
+        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 table {table_name} in {self.name()}",
-            )
+            ) from e
         rows = curs.fetchall()
         curs.close()
         return len(rows) > 0
@@ -170,14 +170,14 @@ class OracleDatabase(Database):
             curs.execute(sql, params)
         except ErrInfo:
             raise
-        except Exception:
+        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 column {column_name} in table {table_name} of {self.name()}",
-            )
+            ) from e
         rows = curs.fetchall()
         curs.close()
         return len(rows) > 0
@@ -194,14 +194,14 @@ class OracleDatabase(Database):
             curs.execute(sql, params)
         except ErrInfo:
             raise
-        except Exception:
+        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
         rows = curs.fetchall()
         curs.close()
         return [row[0] for row in rows]
@@ -218,14 +218,14 @@ class OracleDatabase(Database):
             curs.execute(sql, params)
         except ErrInfo:
             raise
-        except Exception:
+        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 view {view_name} in {self.name()}",
-            )
+            ) from e
         rows = curs.fetchall()
         curs.close()
         return len(rows) > 0

execsql/db/postgres.py

@@ -87,18 +87,20 @@ class PostgresDatabase(Database):
                         port=db.port,
                         connect_timeout=db.connect_timeout,
                     )
-            except Exception:
+            except Exception as e:
                 msg = (
                     f"Failed to open PostgreSQL database {self.db_name} on {self.server_name}; "
                     "check server and database name, and validity of credentials"
                 )
-                raise ErrInfo(type="exception", exception_msg=exception_desc(), other_msg=msg)
+                raise ErrInfo(type="exception", exception_msg=exception_desc(), other_msg=msg) from e
 
         def create_db(db: PostgresDatabase) -> None:
             conn = db_conn(db, "postgres")
             conn.autocommit = True
             curs = conn.cursor()
-            curs.execute(f"create database {db.db_name} encoding '{db.encoding}';")
+            quoted_name = db.quote_identifier(db.db_name)
+            quoted_enc = db.quote_identifier(db.encoding)
+            curs.execute(f"create database {quoted_name} encoding {quoted_enc};")
             conn.close()
 
         if self.conn is None:
@@ -133,9 +135,9 @@ class PostgresDatabase(Database):
                 raise
             except ErrInfo:
                 raise
-            except Exception:
+            except Exception as e:
                 msg = f"Failed to open PostgreSQL database {self.db_name} on {self.server_name}"
-                raise ErrInfo(type="exception", exception_msg=exception_desc(), other_msg=msg)
+                raise ErrInfo(type="exception", exception_msg=exception_desc(), other_msg=msg) from e
             # (Re)set the encoding to match the database.
             self.encoding = self.conn.encoding
 
@@ -177,14 +179,14 @@ class PostgresDatabase(Database):
             curs.execute(sql, params)
         except ErrInfo:
             raise
-        except Exception:
+        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 table {table_name} in {self.name()}",
-            )
+            ) from e
         rows = curs.fetchall()
         curs.close()
         return len(rows) > 0
@@ -209,14 +211,14 @@ class PostgresDatabase(Database):
             curs.execute(sql, params)
         except ErrInfo:
             raise
-        except Exception:
+        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 view {view_name} in {self.name()}",
-            )
+            ) from e
         rows = curs.fetchall()
         curs.close()
         return len(rows) > 0
@@ -304,9 +306,18 @@ class PostgresDatabase(Database):
             # ASCII unit separator, which, if it had been used for its intended purpose,
             # should have been identified as the delimiter, so presumably it has not been used.
             delim = csv_file_obj.delimiter if csv_file_obj.delimiter else chr(31)
-            copy_cmd = f"copy {sq_name} ({input_col_list}) from stdin with (format csv, null '', delimiter '{delim}'"
+            if len(delim) != 1:
+                raise ErrInfo(
+                    type="error",
+                    other_msg=f"Invalid delimiter for COPY: expected single character, got {len(delim)} characters",
+                )
+            safe_delim = delim.replace("'", "''")
+            copy_cmd = (
+                f"copy {sq_name} ({input_col_list}) from stdin with (format csv, null '', delimiter '{safe_delim}'"
+            )
             if csv_file_obj.quotechar:
-                copy_cmd = copy_cmd + f", quote '{csv_file_obj.quotechar}'"
+                safe_quote = csv_file_obj.quotechar.replace("'", "''")
+                copy_cmd = copy_cmd + f", quote '{safe_quote}'"
             copy_cmd = copy_cmd + ")"
             _state.exec_log.log_status_info(
                 f"IMPORTing {csv_file_obj.csvfname} using Postgres' fast file reading routine",
@@ -315,13 +326,13 @@ class PostgresDatabase(Database):
                 curs.copy_expert(copy_cmd, rf, _state.conf.import_buffer)
             except ErrInfo:
                 raise
-            except Exception:
+            except Exception as e:
                 self.rollback()
                 raise ErrInfo(
                     type="exception",
                     exception_msg=exception_desc(),
                     other_msg=f"Can't import from file to table {sq_name}",
-                )
+                ) from e
         else:
             data_indexes = [csv_file_cols_q.index(col) for col in import_cols]
             paramspec = ",".join(["%s"] * len(import_cols))
@@ -398,14 +409,14 @@ class PostgresDatabase(Database):
                         curs.executemany(sql_template, b)
                     except ErrInfo:
                         raise
-                    except Exception:
+                    except Exception as e:
                         self.rollback()
                         raise ErrInfo(
                             type="db",
                             command_text=sql_template,
                             exception_msg=exception_desc(),
                             other_msg=f"Can't load data into table {sq_name} of {self.name()} from 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:
@@ -431,5 +442,6 @@ class PostgresDatabase(Database):
         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)});"
+        quoted_col = self.quote_identifier(column_name)
+        sql = f"insert into {sq_name} ({quoted_col}) values ({self.paramsubs(1)});"
         self.cursor().execute(sql, (psycopg2.Binary(filedata),))

execsql/db/sqlite.py

@@ -54,12 +54,12 @@ class SQLiteDatabase(Database):
                 self.conn = sqlite3.connect(self.db_name, timeout=self.timeout)
             except ErrInfo:
                 raise
-            except Exception:
+            except Exception as e:
                 raise ErrInfo(
                     type="exception",
                     exception_msg=exception_desc(),
                     other_msg=f"Can't open SQLite database {self.db_name}",
-                )
+                ) from e
         pragma_cols, pragma_data = self.select_data("pragma encoding;")
         self.encoding = pragma_data[0][0]
 
@@ -82,14 +82,14 @@ class SQLiteDatabase(Database):
             curs.execute(sql, (table_name,))
         except ErrInfo:
             raise
-        except Exception:
+        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 SQLite table "{table_name}";',
-            )
+            ) from e
         rows = curs.fetchall()
         return len(rows) > 0
 
@@ -110,14 +110,14 @@ class SQLiteDatabase(Database):
             curs.execute(sql)
         except ErrInfo:
             raise
-        except Exception:
+        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) -> bool:
@@ -127,14 +127,14 @@ class SQLiteDatabase(Database):
             curs.execute(sql, (view_name,))
         except ErrInfo:
             raise
-        except Exception:
+        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 SQLite view "{view_name}";',
-            )
+            ) from e
         rows = curs.fetchall()
         return len(rows) > 0
 
@@ -204,14 +204,14 @@ class SQLiteDatabase(Database):
                         curs.execute(sql, linedata)
                     except ErrInfo:
                         raise
-                    except Exception:
+                    except Exception as e:
                         self.rollback()
                         raise ErrInfo(
                             type="db",
                             command_text=sql,
                             exception_msg=exception_desc(),
                             other_msg=f"Can't load data into table {sq_name} from line {{{line}}}",
-                        )
+                        ) from e
                     total_rows += 1
                     interval = getattr(_state.conf, "import_progress_interval", 0)
                     if _state.exec_log and interval > 0 and total_rows % interval == 0:
@@ -235,5 +235,6 @@ class SQLiteDatabase(Database):
         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)});"
+        quoted_col = self.quote_identifier(column_name)
+        sql = f"insert into {sq_name} ({quoted_col}) values ({self.paramsubs(1)});"
         self.cursor().execute(sql, (sqlite3.Binary(filedata),))

execsql/db/sqlserver.py

@@ -141,7 +141,7 @@ class SqlServerDatabase(Database):
 
     def schema_exists(self, schema_name: str) -> bool:
         curs = self.cursor()
-        curs.execute(f"select * from sys.schemas where name = '{schema_name}';")
+        curs.execute("select * from sys.schemas where name = ?;", (schema_name,))
         rows = curs.fetchall()
         curs.close()
         return len(rows) > 0
@@ -149,7 +149,8 @@ class SqlServerDatabase(Database):
     def role_exists(self, rolename: str) -> bool:
         curs = self.cursor()
         curs.execute(
-            f"select name from sys.database_principals where type in ('R', 'S') and name = '{rolename}';",
+            "select name from sys.database_principals where type in ('R', 'S') and name = ?;",
+            (rolename,),
         )
         rows = curs.fetchall()
         curs.close()
@@ -172,5 +173,6 @@ class SqlServerDatabase(Database):
         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)});"
+        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),))

execsql/exceptions.py

@@ -58,7 +58,7 @@ class ExecSqlTimeoutError(ExecSqlError):
         super().__init__(errmsg)
 
 
-class ErrInfo(Exception):
+class ErrInfo(ExecSqlError):
     """Rich exception and error-data carrier for execsql.
 
     ``str(e)`` returns the most informative available message (``other_msg``,
@@ -152,11 +152,11 @@ class ErrInfo(Exception):
         return self.eval_err()
 
 
-class DataTypeError(Exception):
+class DataTypeError(ExecSqlError):
     def __init__(self, data_type_name: str, error_msg: str) -> None:
         self.data_type_name = data_type_name or "Unspecified data type"
         self.error_msg = error_msg or "Unspecified error"
-        super().__init__(str(self))
+        Exception.__init__(self, str(self))
 
     def __repr__(self) -> str:
         return f"DataTypeError({self.data_type_name!r}, {self.error_msg!r})"
@@ -165,12 +165,12 @@ class DataTypeError(Exception):
         return f"{self.data_type_name}: {self.error_msg}"
 
 
-class DbTypeError(Exception):
+class DbTypeError(ExecSqlError):
     def __init__(self, dbms_id: str, data_type: object, error_msg: str) -> None:
         self.dbms_id = dbms_id
         self.data_type = data_type
         self.error_msg = error_msg or "Unspecified error"
-        super().__init__(str(self))
+        Exception.__init__(self, str(self))
 
     def __repr__(self) -> str:
         return f"DbTypeError({self.dbms_id!r}, {self.data_type!r}, {self.error_msg!r})"
@@ -190,11 +190,11 @@ class DataTableError(ExecSqlError):
     """Raised for DataTable-level errors."""
 
 
-class DatabaseNotImplementedError(Exception):
+class DatabaseNotImplementedError(ExecSqlError):
     def __init__(self, db_name: str, method: str) -> None:
         self.db_name = db_name
         self.method = method
-        super().__init__(str(self))
+        Exception.__init__(self, str(self))
 
     def __repr__(self) -> str:
         return f"DatabaseNotImplementedError({self.db_name!r}, {self.method!r})"

execsql/exporters/base.py

@@ -143,7 +143,12 @@ class WriteSpec:
             if self.outfile:
                 from execsql.utils.fileio import EncodedFile
 
-                EncodedFile(self.outfile, conf.output_encoding).open("a").write(msg)
+                ef = EncodedFile(self.outfile, conf.output_encoding)
+                fh = ef.open("a")
+                try:
+                    fh.write(msg)
+                finally:
+                    fh.close()
             if (not self.outfile) or self.tee:
                 try:
                     _state.output.write(msg.encode(conf.output_encoding))

execsql/exporters/delimited.py

@@ -415,7 +415,11 @@ class CsvFile(EncodedFile):
     def evaluate_line_format(self) -> None:
         # Scans the file to determine the delimiter, quote character, and escapechar.
         if not self.lineformat_set:
-            self.delimiter, self.quotechar, self.escapechar = self.diagnose_delim(self.openclean("rt"))
+            f = self.openclean("rt")
+            try:
+                self.delimiter, self.quotechar, self.escapechar = self.diagnose_delim(f)
+            finally:
+                f.close()
             self.lineformat_set = True
 
     def _record_format_error(self, pos_no: int, errmsg: str) -> None:
@@ -571,24 +575,26 @@ class CsvFile(EncodedFile):
         self.evaluate_line_format()
         f = self.openclean("rt")
         line_no = 0
-        while True:
-            line_no += 1
-            try:
-                elements = self.read_and_parse_line(f)
-            except ErrInfo as e:
-                raise ErrInfo("error", other_msg=f"{e.other} on line {line_no}.") from e
-            except:
-                raise
-            if len(elements) > 0:
-                if conf.del_empty_cols and len(self.blank_cols) > 0:
-                    blanks = copy.copy(self.blank_cols)
-                    while len(blanks) > 0:
-                        b = blanks.pop()
-                        del elements[b]
-                yield elements
-            else:
-                break
-        f.close()
+        try:
+            while True:
+                line_no += 1
+                try:
+                    elements = self.read_and_parse_line(f)
+                except ErrInfo as e:
+                    raise ErrInfo("error", other_msg=f"{e.other} on line {line_no}.") from e
+                except:
+                    raise
+                if len(elements) > 0:
+                    if conf.del_empty_cols and len(self.blank_cols) > 0:
+                        blanks = copy.copy(self.blank_cols)
+                        while len(blanks) > 0:
+                            b = blanks.pop()
+                            del elements[b]
+                    yield elements
+                else:
+                    break
+        finally:
+            f.close()
 
     def writer(self, append: bool = False) -> CsvWriter:
         return CsvWriter(self.filename, self.encoding, self.delimiter, self.quotechar, self.escapechar, append)
@@ -600,12 +606,12 @@ class CsvFile(EncodedFile):
         except ErrInfo as e:
             e.other = f"Can't read column header line from {self.filename}.  {e.other or ''}"
             raise
-        except Exception:
+        except Exception as e:
             raise ErrInfo(
                 type="exception",
                 exception_msg=exception_desc(),
                 other_msg=f"Can't read column header line from {self.filename}",
-            )
+            ) from e
         if any(x is None or len(x) == 0 for x in colnames):
             if conf.del_empty_cols:
                 self.blank_cols = [
@@ -700,18 +706,21 @@ def write_delimited_file(
         filewriter_close(outfile)
         ofile = EncodedFile(outfile, file_encoding).open(mode=fmode)
         fdesc = outfile
-    if not (filefmt.lower() == "plain" or (append and zipfile is None)):
-        datarow = line_delimiter.delimited(column_headers)
-        ofile.write(datarow)
-    for rec in rowsource:
-        try:
-            datarow = line_delimiter.delimited(rec)
+    try:
+        if not (filefmt.lower() == "plain" or (append and zipfile is None)):
+            datarow = line_delimiter.delimited(column_headers)
             ofile.write(datarow)
-        except ErrInfo:
-            raise
-        except Exception:
-            raise ErrInfo(
-                "exception",
-                exception_msg=exception_desc(),
-                other_msg=f"Can't write output to file {fdesc}.",
-            )
+        for rec in rowsource:
+            try:
+                datarow = line_delimiter.delimited(rec)
+                ofile.write(datarow)
+            except ErrInfo:
+                raise
+            except Exception as e:
+                raise ErrInfo(
+                    "exception",
+                    exception_msg=exception_desc(),
+                    other_msg=f"Can't write output to file {fdesc}.",
+                ) from e
+    finally:
+        ofile.close()

execsql/exporters/duckdb.py

@@ -85,6 +85,6 @@ def write_query_to_duckdb(
         hdrs, rows = db.select_rowsource(select_stmt)
     except ErrInfo:
         raise
-    except Exception:
-        raise ErrInfo("db", select_stmt, exception_msg=exception_desc())
+    except Exception as e:
+        raise ErrInfo("db", select_stmt, exception_msg=exception_desc()) from e
     export_duckdb(outfile, hdrs, rows, append, tablename)

execsql/exporters/feather.py

@@ -22,12 +22,12 @@ from execsql.utils.fileio import filewriter_close
 def write_query_to_feather(outfile: str, headers: list[str], rows: Any) -> None:
     try:
         import polars as pl
-    except ImportError:
+    except ImportError as e:
         raise ErrInfo(
             "exception",
             exception_msg=exception_desc(),
             other_msg="The polars Python package must be installed to export data to the feather format.",
-        )
+        ) from e
     rows_list = list(rows)
     if rows_list:
         df = pl.DataFrame(rows_list, schema=headers, orient="row")
@@ -47,18 +47,18 @@ def write_query_to_hdf5(
 ) -> None:
     try:
         import tables
-    except ImportError:
+    except ImportError as e:
         raise ErrInfo(
             "exception",
             exception_msg=exception_desc(),
             other_msg="The tables Python library must be installed to export data to the HDF5 format.",
-        )
+        ) from e
     try:
         hdrs, rows = db.select_rowsource(select_stmt)
     except ErrInfo:
         raise
-    except Exception:
-        raise ErrInfo("db", select_stmt, exception_msg=exception_desc())
+    except Exception as e:
+        raise ErrInfo("db", select_stmt, exception_msg=exception_desc()) from e
 
     def h5type(datatype, size):
         if datatype in (_state.DT_Varchar, _state.DT_Text):