execsql2 2.6.0__py3-none-any.whl → 2.8.0__py3-none-any.whl

execsql/cli/__init__.py

@@ -254,6 +254,11 @@ def main(
         "--dump-keywords",
         help="Dump all metacommand keywords as JSON and exit.",
     ),
+    profile: bool = typer.Option(
+        False,
+        "--profile",
+        help="Record per-statement execution times and print a timing summary after the script completes.",
+    ),
     version: bool | None = typer.Option(
         None,
         "--version",
@@ -415,6 +420,7 @@ def main(
         dsn=dsn,
         output_dir=output_dir,
         progress=progress,
+        profile=profile,
     )
 
 

execsql/cli/run.py

@@ -20,11 +20,11 @@ from execsql.cli.dsn import _parse_connection_string
 from execsql.cli.help import _console, _err_console
 from execsql.config import ConfigData, StatObj
 from execsql.exceptions import ConfigError, ErrInfo
-from execsql.script import SubVarSet, current_script_line, read_sqlfile, read_sqlstring, runscripts
+from execsql.script import SubVarSet, current_script_line, read_sqlfile, read_sqlstring, runscripts, substitute_vars
 from execsql.utils.fileio import FileWriter, Logger, filewriter_end
 from execsql.utils.gui import gui_connect, gui_console_isrunning, gui_console_off, gui_console_on, gui_console_wait_user
 
-__all__ = ["_connect_initial_db", "_print_dry_run", "_run"]
+__all__ = ["_connect_initial_db", "_print_dry_run", "_print_profile", "_run"]
 
 
 # ---------------------------------------------------------------------------
@@ -33,7 +33,16 @@ __all__ = ["_connect_initial_db", "_print_dry_run", "_run"]
 
 
 def _print_dry_run(cmdlist: object) -> None:
-    """Print the parsed command list for --dry-run mode."""
+    """Print the parsed command list for --dry-run mode.
+
+    Substitution variables (``$VAR``, ``&ENV``, ``@COUNTER``) that are already
+    populated — from environment variables, ``--assign-arg`` values, or config —
+    are expanded in the displayed text.  System variables that are set at
+    execution time (e.g. ``$CURRENT_TIME``, ``$DB_NAME``, ``$TIMER``) will
+    appear unexpanded because ``set_system_vars()`` has not yet been called.
+    Local ``~``-prefixed script-scope variables are also not expanded (no script
+    execution context exists in dry-run mode).
+    """
     if cmdlist is None or not cmdlist.cmdlist:
         _console.print("[yellow]No commands found in script.[/yellow]")
         return
@@ -43,7 +52,71 @@ def _print_dry_run(cmdlist: object) -> None:
     for i, cmd in enumerate(cmdlist.cmdlist, 1):
         ctype = "SQL    " if cmd.command_type == "sql" else "METACMD"
         source_info = f"[dim]{cmd.source}:{cmd.line_no}[/dim]"
-        _console.print(f"  [dim]{i:>4}[/dim]  [bold green]{ctype}[/bold green]  {source_info}  {cmd.commandline()}")
+        raw = cmd.commandline()
+        try:
+            expanded = substitute_vars(raw)
+        except Exception:
+            # Cycle detection or other expansion errors — fall back to raw text.
+            expanded = raw
+        _console.print(f"  [dim]{i:>4}[/dim]  [bold green]{ctype}[/bold green]  {source_info}  {expanded}")
+
+
+# ---------------------------------------------------------------------------
+# Profile report helper
+# ---------------------------------------------------------------------------
+
+
+def _print_profile(profile_data: list[tuple]) -> None:
+    """Print a per-statement timing summary to stdout.
+
+    Args:
+        profile_data: List of ``(source, line_no, command_type, elapsed_secs,
+            command_text_preview)`` tuples collected during execution.
+    """
+    if not profile_data:
+        _console.print("[dim]Profile: no statements recorded.[/dim]")
+        return
+
+    total_secs = sum(row[3] for row in profile_data)
+    n = len(profile_data)
+
+    # Sort descending by elapsed time; show top 20 (or all if <= 20).
+    sorted_data = sorted(profile_data, key=lambda r: r[3], reverse=True)
+    display = sorted_data[:20]
+
+    _console.print()
+    _console.print(f"[bold cyan]Profile:[/bold cyan] {n} statement{'s' if n != 1 else ''} in {total_secs:.3f}s")
+    _console.print()
+
+    header = f"  {'Time (s)':<10}  {'Pct':<7}  {'Source:Line':<20}  {'Type':<7}  Command"
+    sep = f"  {'-' * 10}  {'-' * 7}  {'-' * 20}  {'-' * 7}  {'-' * 40}"
+    _console.print(f"[dim]{header}[/dim]")
+    _console.print(f"[dim]{sep}[/dim]")
+
+    for source, line_no, command_type, elapsed, preview in display:
+        pct = (elapsed / total_secs * 100) if total_secs > 0 else 0.0
+        source_col = f"{source}:{line_no}"
+        if len(source_col) > 20:
+            source_col = "..." + source_col[-17:]
+        ctype_label = "SQL    " if command_type == "sql" else "METACMD"
+        preview_short = preview[:50].replace("\n", " ").strip()
+        if len(preview) > 50:
+            preview_short += "..."
+        _console.print(
+            f"  [yellow]{elapsed:<10.3f}[/yellow]  "
+            f"[dim]{pct:<6.1f}%[/dim]  "
+            f"[cyan]{source_col:<20}[/cyan]  "
+            f"[green]{ctype_label:<7}[/green]  "
+            f"{preview_short}",
+        )
+
+    if len(sorted_data) > 20:
+        omitted = len(sorted_data) - 20
+        _console.print(
+            f"[dim]  ... {omitted} more statement{'s' if omitted != 1 else ''} not shown (top 20 by time)[/dim]",
+        )
+
+    _console.print()
 
 
 # ---------------------------------------------------------------------------
@@ -76,6 +149,7 @@ def _run(
     dsn: str | None = None,
     output_dir: str | None = None,
     progress: bool = False,
+    profile: bool = False,
 ) -> None:
     """Initialise state, connect to the database, load the script, and run it.
 
@@ -378,7 +452,10 @@ def _run(
     atexit.register(_state.dbs.closeall)
     _state.dbs.do_rollback = True
 
-    _execute_script_direct(conf)
+    if profile:
+        _state.profile_data = []
+
+    _execute_script_direct(conf, profile=profile)
 
 
 # ---------------------------------------------------------------------------
@@ -437,8 +514,15 @@ def _execute_script_textual_console(conf: ConfigData) -> None:
     _state.exec_log.log_exit_end()
 
 
-def _execute_script_direct(conf: ConfigData) -> None:
-    """Run runscripts() in the current (main) thread — used when Textual is not active."""
+def _execute_script_direct(conf: ConfigData, *, profile: bool = False) -> None:
+    """Run runscripts() in the current (main) thread — used when Textual is not active.
+
+    Args:
+        conf: The active configuration object.
+        profile: When ``True``, print a per-statement timing summary after the
+            script completes.  Timing data must already have been activated on
+            ``_state.profile_data`` before this function is called.
+    """
     import execsql.state as _state
     import execsql.utils.gui as _gui
 
@@ -463,6 +547,8 @@ def _execute_script_direct(conf: ConfigData) -> None:
             if gui_console_isrunning():
                 gui_console_off()
         _state.exec_log.log_status_info(f"{_state.cmds_run} commands run")
+        if profile and _state.profile_data is not None:
+            _print_profile(_state.profile_data)
         sys.exit(exc.code)
     except ConfigError:
         raise
@@ -489,6 +575,8 @@ def _execute_script_direct(conf: ConfigData) -> None:
         if gui_console_isrunning():
             gui_console_off()
     _state.exec_log.log_status_info(f"{_state.cmds_run} commands run")
+    if profile and _state.profile_data is not None:
+        _print_profile(_state.profile_data)
     _state.exec_log.log_exit_end()
 
 

execsql/exporters/__init__.py

@@ -9,9 +9,9 @@ handlers can access them via ``_state.write_query_to_csv`` etc. without
 importing directly from here.
 
 Sub-modules: ``base``, ``delimited``, ``json``, ``xml``, ``html``,
-``latex``, ``ods``, ``xls``, ``zip``, ``raw``, ``pretty``, ``values``,
-``templates``, ``feather``, ``parquet``, ``duckdb``, ``sqlite``,
-``protocol``.
+``latex``, ``markdown``, ``ods``, ``xls``, ``zip``, ``raw``, ``pretty``,
+``values``, ``templates``, ``feather``, ``parquet``, ``duckdb``,
+``sqlite``, ``protocol``.
 """
 
 from execsql.exporters.protocol import QueryExporter, RowsetExporter

execsql/exporters/delimited.py

@@ -27,7 +27,7 @@ from execsql.exceptions import ErrInfo
 from execsql.models import DataTable
 from execsql.utils.errors import exception_desc
 from execsql.utils.fileio import filewriter_close
-from execsql.utils.strings import clean_words, fold_words
+from execsql.utils.strings import clean_words, dedup_words, fold_words
 
 __all__ = ["LineDelimiter", "CsvFile", "CsvWriter", "DelimitedWriter", "write_delimited_file"]
 
@@ -677,7 +677,7 @@ class CsvFile(EncodedFile):
         if conf.fold_col_hdrs != "no":
             colnames = fold_words(colnames, conf.fold_col_hdrs)
         if conf.dedup_col_hdrs:
-            colnames = _state.dedup_words(colnames)
+            colnames = dedup_words(colnames)
         return colnames
 
     def column_headers(self) -> list[str]:

execsql/exporters/markdown.py

@@ -0,0 +1,126 @@
+from __future__ import annotations
+
+"""
+GitHub-Flavored Markdown (GFM) pipe table export for execsql.
+
+Provides :func:`write_query_to_markdown`, which serializes a query result
+set as a GFM pipe table suitable for inclusion in GitHub README files,
+wikis, and any Markdown renderer that supports the pipe-table extension.
+
+Example output::
+
+    | id | name   | score |
+    |----|--------|-------|
+    | 1  | Alice  | 95.2  |
+    | 2  | Bob    | 87.0  |
+
+No optional dependencies — pure Python.
+"""
+
+from typing import Any
+
+import execsql.state as _state
+from execsql.exceptions import ErrInfo
+from execsql.exporters.zip import ZipWriter
+from execsql.utils.errors import exception_desc
+from execsql.utils.fileio import filewriter_close
+
+__all__ = ["write_query_to_markdown"]
+
+_PIPE_ESCAPE = str.maketrans({"|": r"\|", "\\": "\\\\"})
+
+
+def _cell(value: Any) -> str:
+    """Render a single cell value as a Markdown-safe string.
+
+    Args:
+        value: The cell value from the result set.  ``None`` is rendered as
+            an empty string.  Pipe characters are escaped so they do not
+            break the table structure.
+
+    Returns:
+        A string safe to embed between pipe characters in a GFM table row.
+    """
+    if value is None:
+        return ""
+    return str(value).translate(_PIPE_ESCAPE)
+
+
+def write_query_to_markdown(
+    select_stmt: str,
+    db: Any,
+    outfile: str,
+    append: bool = False,
+    desc: str | None = None,
+    zipfile: str | None = None,
+) -> None:
+    """Execute *select_stmt* and write the result set as a GFM pipe table.
+
+    Writes a GitHub-Flavored Markdown pipe table to *outfile* (or into
+    *zipfile* when provided).  Column widths are derived from the widest
+    value in each column (including the header), so the table renders
+    legibly in plain-text editors as well as in Markdown renderers.
+
+    Args:
+        select_stmt: SQL SELECT statement to execute.
+        db: Database connection object exposing ``select_rowsource()``.
+        outfile: Destination file path, or ``"stdout"`` for console output.
+        append: When ``True`` open the file in append mode.  A blank line
+            is written before the table so consecutive appended tables are
+            visually separated.
+        desc: Optional human-readable description.  When provided it is
+            written as an HTML comment (``<!-- desc -->``), which is valid
+            Markdown and invisible in rendered output.
+        zipfile: When set, write into this ZIP archive instead of a plain
+            file.  *outfile* becomes the entry name inside the archive.
+    """
+    conf = _state.conf
+    try:
+        hdrs, rows = db.select_rowsource(select_stmt)
+    except ErrInfo:
+        raise
+    except Exception as e:
+        raise ErrInfo("db", select_stmt, exception_msg=exception_desc()) from e
+
+    # Materialise the full result set so we can compute column widths in one
+    # pass before writing.  GFM tables require consistent column widths for
+    # readability; width computation requires seeing all rows first.
+    str_hdrs: list[str] = [_cell(h) for h in hdrs]
+    str_rows: list[list[str]] = [[_cell(v) for v in row] for row in rows]
+
+    # Minimum separator width is 3 dashes (GFM spec minimum for alignment row).
+    col_widths: list[int] = [max(3, len(h)) for h in str_hdrs]
+    for row in str_rows:
+        for i, cell in enumerate(row):
+            if len(cell) > col_widths[i]:
+                col_widths[i] = len(cell)
+
+    def _format_row(cells: list[str]) -> str:
+        padded = (f" {c:<{col_widths[i]}} " for i, c in enumerate(cells))
+        return "|" + "|".join(padded) + "|\n"
+
+    def _format_separator() -> str:
+        dashes = (f" {'-' * col_widths[i]} " for i in range(len(str_hdrs)))
+        return "|" + "|".join(dashes) + "|\n"
+
+    if zipfile is None:
+        filewriter_close(outfile)
+        from execsql.utils.fileio import EncodedFile
+
+        ef = EncodedFile(outfile, conf.output_encoding)
+        f = ef.open("at" if append else "wt")
+    else:
+        f = ZipWriter(zipfile, outfile, append)
+
+    try:
+        if append:
+            # Blank line separates consecutive tables when appending.
+            f.write("\n")
+        if desc is not None:
+            f.write(f"<!-- {desc} -->\n\n")
+        f.write(_format_row(str_hdrs))
+        f.write(_format_separator())
+        for row in str_rows:
+            f.write(_format_row(row))
+    finally:
+        f.close()

execsql/exporters/xlsx.py

@@ -0,0 +1,317 @@
+from __future__ import annotations
+
+"""
+XLSX (Excel Open XML) export for execsql.
+
+Provides :func:`write_query_to_xlsx` (single-sheet export) and
+:func:`write_queries_to_xlsx` (multi-sheet export).  Requires the
+``openpyxl`` package (``execsql2[excel]``).
+"""
+
+import datetime
+import getpass
+import os
+from pathlib import Path
+from typing import Any
+
+import execsql.state as _state
+from execsql.exceptions import ErrInfo
+from execsql.exporters.base import ExportRecord
+from execsql.exporters.pretty import prettyprint_query
+from execsql.script import current_script_line
+from execsql.utils.errors import exception_desc, fatal_error
+from execsql.utils.fileio import filewriter_close
+from execsql.utils.strings import unquoted
+
+__all__ = ["write_query_to_xlsx", "write_queries_to_xlsx"]
+
+# ---------------------------------------------------------------------------
+# Internal helpers
+# ---------------------------------------------------------------------------
+
+
+def _require_openpyxl() -> Any:
+    """Import and return the openpyxl module, raising a fatal error if absent."""
+    try:
+        import openpyxl
+
+        return openpyxl
+    except ImportError:
+        fatal_error("The openpyxl library is needed to write Excel (.xlsx) spreadsheets (install execsql2[excel]).")
+
+
+def _cell_value(item: Any) -> Any:
+    """Return a value suitable for writing directly to an openpyxl cell.
+
+    openpyxl natively handles int, float, bool, str, datetime.datetime,
+    datetime.date, and None.  datetime.time is converted to a string because
+    openpyxl does not have a native time-only cell type.
+    """
+    if item is None:
+        return None
+    if isinstance(item, bool):
+        # bool must be checked before int — bool is a subclass of int.
+        return item
+    if isinstance(item, int | float):
+        return item
+    if isinstance(item, datetime.datetime):
+        return item
+    if isinstance(item, datetime.date):
+        return item
+    if isinstance(item, datetime.time):
+        # openpyxl has no native time-only type; store as HH:MM:SS string.
+        return item.strftime("%H:%M:%S")
+    return str(item)
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+
+def write_query_to_xlsx(
+    select_stmt: str,
+    db: Any,
+    outfile: str,
+    append: bool = False,
+    desc: str | None = None,
+    sheetname: str | None = None,
+) -> None:
+    """Execute *select_stmt* and write the result to a single worksheet in an XLSX file.
+
+    Args:
+        select_stmt: SQL SELECT statement to execute.
+        db: An execsql database adapter with a ``select_rowsource()`` method.
+        outfile: Destination ``.xlsx`` file path.
+        append: If ``True`` and *outfile* exists, add a new sheet to the
+            existing workbook.  If ``False``, overwrite any existing file.
+        desc: Optional human-readable description stored in the inventory sheet.
+        sheetname: Name for the new worksheet.  Defaults to ``"Sheet1"``
+            (or ``"Sheet2"``, ``"Sheet3"``, etc. when appending to avoid
+            name collisions).
+    """
+    openpyxl = _require_openpyxl()
+
+    try:
+        hdrs, rows = db.select_rowsource(select_stmt)
+    except ErrInfo:
+        raise
+    except Exception as e:
+        raise ErrInfo("db", select_stmt, exception_msg=exception_desc()) from e
+
+    # ------------------------------------------------------------------
+    # Determine sheet name and open/create workbook
+    # ------------------------------------------------------------------
+    if append and Path(outfile).is_file():
+        wb = openpyxl.load_workbook(outfile)
+        existing_names = wb.sheetnames
+        base = sheetname or "Sheet"
+        sheet_name = base
+        sheet_no = 1
+        while sheet_name in existing_names:
+            sheet_no += 1
+            sheet_name = f"{base}{sheet_no}"
+    else:
+        sheet_name = sheetname or "Sheet1"
+        if Path(outfile).is_file():
+            filewriter_close(outfile)
+            os.unlink(outfile)
+        wb = openpyxl.Workbook()
+        # openpyxl creates a default sheet named "Sheet"; remove it so we
+        # start with a clean workbook.
+        if wb.sheetnames:
+            del wb[wb.sheetnames[0]]
+
+    # ------------------------------------------------------------------
+    # Ensure the inventory sheet exists
+    # ------------------------------------------------------------------
+    inventory_name = "Datasheets"
+    if inventory_name not in wb.sheetnames:
+        inv_ws = wb.create_sheet(inventory_name)
+        bold_font = openpyxl.styles.Font(bold=True)
+        for col_idx, hdr in enumerate(
+            ("datasheet_name", "created_on", "created_by", "description", "source"),
+            start=1,
+        ):
+            cell = inv_ws.cell(row=1, column=col_idx, value=hdr)
+            cell.font = bold_font
+    else:
+        inv_ws = wb[inventory_name]
+
+    # ------------------------------------------------------------------
+    # Write data to a new sheet
+    # ------------------------------------------------------------------
+    ws = wb.create_sheet(sheet_name)
+    bold_font = openpyxl.styles.Font(bold=True)
+
+    # Header row
+    for col_idx, hdr in enumerate(hdrs, start=1):
+        cell = ws.cell(row=1, column=col_idx, value=str(hdr))
+        cell.font = bold_font
+
+    # Data rows
+    for row_idx, row in enumerate(rows, start=2):
+        for col_idx, item in enumerate(row, start=1):
+            ws.cell(row=row_idx, column=col_idx, value=_cell_value(item))
+
+    # ------------------------------------------------------------------
+    # Update inventory sheet
+    # ------------------------------------------------------------------
+    script, lno = current_script_line()
+    src = (
+        f"{select_stmt} with database {_state.dbs.current().name()}, "
+        f"with script {str(Path(script).resolve())}, line {lno}"
+    )
+    next_row = inv_ws.max_row + 1
+    for col_idx, value in enumerate(
+        (
+            sheet_name,
+            datetime.datetime.now().strftime("%Y-%m-%d %H:%M"),
+            getpass.getuser(),
+            desc,
+            src,
+        ),
+        start=1,
+    ):
+        inv_ws.cell(row=next_row, column=col_idx, value=value)
+
+    wb.save(outfile)
+    wb.close()
+
+
+def write_queries_to_xlsx(
+    table_list: str,
+    db: Any,
+    outfile: str,
+    append: bool = False,
+    tee: bool = False,
+    desc: str | None = None,
+) -> None:
+    """Write multiple tables/queries to separate worksheets in a single XLSX workbook.
+
+    Args:
+        table_list: Comma-separated list of table names (optionally schema-qualified).
+        db: An execsql database adapter with a ``select_rowsource()`` method.
+        outfile: Destination ``.xlsx`` file path.
+        append: If ``True`` and *outfile* exists, add new sheets to the existing
+            workbook rather than replacing it.
+        tee: If ``True``, also pretty-print each query result to stdout.
+        desc: Optional description(s).  A single string is applied to every
+            sheet; a comma-separated string with the same count as *table_list*
+            assigns individual descriptions per sheet.
+    """
+    openpyxl = _require_openpyxl()
+
+    tables = [t.strip() for t in table_list.split(",")]
+    if desc is not None:
+        descriptions = [d.strip() for d in desc.split(",")]
+        one_desc = len(descriptions) != len(tables)
+    else:
+        descriptions = []
+        one_desc = False
+
+    # ------------------------------------------------------------------
+    # Open or create workbook
+    # ------------------------------------------------------------------
+    if Path(outfile).is_file() and not append:
+        filewriter_close(outfile)
+        os.unlink(outfile)
+
+    if Path(outfile).is_file():
+        wb = openpyxl.load_workbook(outfile)
+    else:
+        wb = openpyxl.Workbook()
+        # Remove the default empty sheet created by openpyxl.
+        if wb.sheetnames:
+            del wb[wb.sheetnames[0]]
+
+    # ------------------------------------------------------------------
+    # Ensure the inventory sheet exists
+    # ------------------------------------------------------------------
+    inventory_name = "Datasheets"
+    if inventory_name not in wb.sheetnames:
+        inv_ws = wb.create_sheet(inventory_name)
+        bold_font = openpyxl.styles.Font(bold=True)
+        for col_idx, hdr in enumerate(
+            ("datasheet_name", "created_on", "created_by", "description", "source"),
+            start=1,
+        ):
+            cell = inv_ws.cell(row=1, column=col_idx, value=hdr)
+            cell.font = bold_font
+    else:
+        inv_ws = wb[inventory_name]
+
+    # ------------------------------------------------------------------
+    # Write each table to its own sheet
+    # ------------------------------------------------------------------
+    bold_font = openpyxl.styles.Font(bold=True)
+
+    for i, t in enumerate(tables):
+        # Determine the table name used for the sheet label.
+        if "." in t:
+            st = t.split(".")
+            if len(st) != 2:
+                raise ErrInfo("cmd", other_msg=f"Unrecognized table specification in <{t}>")
+            tblname = unquoted(st[1])
+        else:
+            tblname = unquoted(t)
+
+        # Avoid duplicate sheet names.
+        existing_names = wb.sheetnames
+        sheet_name = tblname
+        sheet_no = 1
+        while sheet_name in existing_names:
+            sheet_name = f"{tblname}_{sheet_no}"
+            sheet_no += 1
+
+        # Fetch data.
+        select_stmt = f"select * from {t};"
+        try:
+            hdrs, rows = db.select_rowsource(select_stmt)
+        except ErrInfo:
+            raise
+        except Exception as e:
+            raise ErrInfo("db", select_stmt, exception_msg=exception_desc()) from e
+
+        # Write data sheet.
+        ws = wb.create_sheet(sheet_name)
+
+        for col_idx, hdr in enumerate(hdrs, start=1):
+            cell = ws.cell(row=1, column=col_idx, value=str(hdr))
+            cell.font = bold_font
+
+        for row_idx, row in enumerate(rows, start=2):
+            for col_idx, item in enumerate(row, start=1):
+                ws.cell(row=row_idx, column=col_idx, value=_cell_value(item))
+
+        # Determine per-sheet description.
+        if desc is None:
+            d = None
+        elif one_desc:
+            d = desc
+        else:
+            d = descriptions[i]
+
+        # Update inventory sheet.
+        script, lno = current_script_line()
+        src = f"From database {_state.dbs.current().name()}, with script {str(Path(script).resolve())}, line {lno}"
+        next_row = inv_ws.max_row + 1
+        for col_idx, value in enumerate(
+            (
+                sheet_name,
+                datetime.datetime.now().strftime("%Y-%m-%d %H:%M"),
+                getpass.getuser(),
+                d,
+                src,
+            ),
+            start=1,
+        ):
+            inv_ws.cell(row=next_row, column=col_idx, value=value)
+
+        if tee and outfile.lower() != "stdout":
+            prettyprint_query(select_stmt, db, "stdout", False, desc=d)
+
+        _state.export_metadata.add(ExportRecord(queryname=select_stmt, outfile=outfile, zipfile=None, description=d))
+
+    wb.save(outfile)
+    wb.close()