@nshiab/simple-data-analysis 5.19.8

package/esm/methods/hybridSearch.js

@@ -0,0 +1,235 @@
+import { prettyDuration } from "../deps/jsr.io/@nshiab/journalism-format/1.1.5/src/index.js";
+import getRRFRanking from "../helpers/getRRFRanking.js";
+import { parseValue } from "../deps/jsr.io/@nshiab/simple-data-analysis-core/0.0.17/src/helpers/index.js";
+export default async function hybridSearch(table, query, columnId, columnText, nbResults, options = {}) {
+    const enableVectorSearch = options.vectorSearch !== false;
+    const enableBm25 = options.bm25 !== false;
+    if (!enableVectorSearch && !enableBm25) {
+        throw new Error("At least one search method must be enabled. Set vectorSearch=true or bm25=true.");
+    }
+    const times = options.times ?? {
+        start: Date.now(),
+        embeddingStart: 0,
+        embeddingEnd: 0,
+        vectorSearchStart: 0,
+        vectorSearchEnd: 0,
+        bm25Start: 0,
+        bm25End: 0,
+    };
+    const embeddingColumn = `${columnText}_embeddings`;
+    // Only generate embeddings if vector search is enabled
+    if (enableVectorSearch) {
+        if (options.verbose) {
+            times.embeddingStart = Date.now();
+        }
+        if (await table.hasColumn(embeddingColumn)) {
+            if (options.verbose) {
+                console.log(`"${embeddingColumn}" in table "${table.name}" already exist. Reusing embeddings...`);
+            }
+        }
+        else {
+            const previousCacheVerbose = table.sdb.cacheVerbose;
+            if (options.verbose) {
+                console.log(`"${embeddingColumn}" in table "${table.name}" does not exist. Generating embeddings...`);
+                table.sdb.cacheVerbose = true;
+            }
+            options.cache
+                ? await table.cache(async () => {
+                    await table.aiEmbeddings(columnText, embeddingColumn, {
+                        createIndex: options.createIndex ?? false,
+                        cache: true,
+                        verbose: options.verbose,
+                        ollama: options.ollamaEmbeddings,
+                        model: options.embeddingsModel,
+                        contextWindow: options.embeddingsModelContextWindow,
+                        concurrent: options.embeddingsConcurrent,
+                        efConstruction: options.efConstruction,
+                        efSearch: options.efSearch,
+                        M: options.M,
+                    });
+                })
+                : await table.aiEmbeddings(columnText, embeddingColumn, {
+                    createIndex: options.createIndex ?? false,
+                    verbose: options.verbose,
+                    ollama: options.ollamaEmbeddings,
+                    model: options.embeddingsModel,
+                    contextWindow: options.embeddingsModelContextWindow,
+                    concurrent: options.embeddingsConcurrent,
+                    efConstruction: options.efConstruction,
+                    efSearch: options.efSearch,
+                    M: options.M,
+                });
+            table.sdb.cacheVerbose = previousCacheVerbose;
+        }
+        if (options.verbose) {
+            times.embeddingEnd = Date.now();
+        }
+    }
+    // Run searches based on enabled methods
+    async function vectorSearch() {
+        if (options.verbose) {
+            times.vectorSearchStart = Date.now();
+        }
+        const vectorSearchResult = await table.aiVectorSimilarity(query, embeddingColumn, nbResults, {
+            createIndex: options.createIndex ?? false,
+            cache: options.cache,
+            outputTable: `${table.name}_vector_search_results`,
+            ollama: options.ollamaEmbeddings,
+            model: options.embeddingsModel,
+            contextWindow: options.embeddingsModelContextWindow,
+            verbose: options.verbose,
+            efConstruction: options.efConstruction,
+            efSearch: options.efSearch,
+            M: options.M,
+            minSimilarity: options.vectorMinSimilarity,
+            similarityColumn: options.vectorSimilarityColumn,
+        });
+        if (options.verbose) {
+            times.vectorSearchEnd = Date.now();
+        }
+        return vectorSearchResult;
+    }
+    async function bm25Search() {
+        if (options.verbose) {
+            times.bm25Start = Date.now();
+        }
+        const bm25SearchResult = await table.bm25(query, columnId, columnText, nbResults, {
+            stemmer: options.stemmer,
+            stopwords: options.stopwords,
+            ignore: options.ignore,
+            stripAccents: options.stripAccents,
+            lower: options.lower,
+            k: options.k,
+            b: options.b,
+            conjunctive: options.conjunctive,
+            outputTable: `${table.name}_bm25_search_results`,
+            verbose: options.verbose,
+            minScore: options.bm25MinScore,
+            scoreColumn: options.bm25ScoreColumn,
+        });
+        if (options.verbose) {
+            times.bm25End = Date.now();
+        }
+        return bm25SearchResult;
+    }
+    let finalIds;
+    let vectorSearchSimilarity = [];
+    let bm25SearchScores = [];
+    if (enableVectorSearch && enableBm25) {
+        // Both methods enabled: run in parallel and fuse results
+        const [vectorSearchResult, bm25SearchResult] = await Promise.all([
+            vectorSearch(),
+            bm25Search(),
+        ]);
+        const vectorSearchResultsIds = await vectorSearchResult.getValues(columnId);
+        if (options.vectorSimilarityColumn) {
+            vectorSearchSimilarity = await vectorSearchResult.getData({
+                columns: [columnId, options.vectorSimilarityColumn],
+            });
+        }
+        const bm25SearchResultsIds = await bm25SearchResult.getValues(columnId);
+        if (options.bm25ScoreColumn) {
+            bm25SearchScores = await bm25SearchResult.getData({
+                columns: [columnId, options.bm25ScoreColumn],
+            });
+        }
+        await vectorSearchResult.removeTable();
+        await bm25SearchResult.removeTable();
+        if (options.verbose) {
+            console.log(`Vector search results IDs:`, vectorSearchResultsIds);
+            console.log(`BM25 search results IDs:`, bm25SearchResultsIds);
+        }
+        finalIds = getRRFRanking([vectorSearchResultsIds, bm25SearchResultsIds]);
+        if (options.verbose) {
+            console.log(`Fused results IDs:`, finalIds);
+        }
+    }
+    else if (enableVectorSearch) {
+        // Only vector search enabled
+        const vectorSearchResult = await vectorSearch();
+        finalIds = await vectorSearchResult.getValues(columnId);
+        if (options.vectorSimilarityColumn) {
+            vectorSearchSimilarity = await vectorSearchResult.getData({
+                columns: [columnId, options.vectorSimilarityColumn],
+            });
+        }
+        await vectorSearchResult.removeTable();
+        if (options.verbose) {
+            console.log(`Vector search results IDs:`, finalIds);
+        }
+    }
+    else {
+        // Only BM25 enabled
+        const bm25SearchResult = await bm25Search();
+        finalIds = await bm25SearchResult.getValues(columnId);
+        if (options.bm25ScoreColumn) {
+            bm25SearchScores = await bm25SearchResult.getData({
+                columns: [columnId, options.bm25ScoreColumn],
+            });
+        }
+        await bm25SearchResult.removeTable();
+        if (options.verbose) {
+            console.log(`BM25 search results IDs:`, finalIds);
+        }
+    }
+    const finalIdsSliced = finalIds.slice(0, nbResults);
+    if (finalIdsSliced.length === 0) {
+        // If there are no results, create an empty table with the same structure
+        await table.sdb.customQuery(`CREATE OR REPLACE TABLE "${options.outputTable ?? table.name}" AS SELECT * FROM "${table.name}" WHERE 1=0`);
+    }
+    else {
+        await table.sdb.customQuery(`CREATE OR REPLACE TABLE "${options.outputTable ?? table.name}" AS SELECT * FROM "${table.name}" WHERE "${columnId}" IN (${finalIdsSliced
+            .map((id) => parseValue(id))
+            .join(", ")})`);
+    }
+    let outputTableInstance;
+    if (typeof options.outputTable === "string") {
+        outputTableInstance = table.sdb.newTable(options.outputTable, structuredClone(table.projections));
+    }
+    else {
+        outputTableInstance = table;
+    }
+    if (options.vectorSimilarityColumn) {
+        if (vectorSearchSimilarity.length === 0) {
+            // If there are no similarity scores (e.g. all results were filtered out by minSimilarity), add the column with NULL values
+            await outputTableInstance.addColumn(options.vectorSimilarityColumn, "number", `NULL`);
+        }
+        else {
+            await outputTableInstance.addColumn(options.vectorSimilarityColumn, "number", `CASE ${vectorSearchSimilarity.map((d) => `WHEN "${columnId}" = ${parseValue(d[columnId])} THEN ${d[options.vectorSimilarityColumn]}`).join(" ")} ELSE NULL END`);
+            await outputTableInstance.round(options.vectorSimilarityColumn, {
+                decimals: 4,
+            });
+        }
+    }
+    if (options.bm25ScoreColumn) {
+        if (bm25SearchScores.length === 0) {
+            // If there are no BM25 scores (e.g. all results were filtered out by minScore), add the column with NULL values
+            await outputTableInstance.addColumn(options.bm25ScoreColumn, "number", `NULL`);
+        }
+        else {
+            await outputTableInstance.addColumn(options.bm25ScoreColumn, "number", `CASE ${bm25SearchScores.map((d) => `WHEN "${columnId}" = ${parseValue(d[columnId])} THEN ${d[options.bm25ScoreColumn]}`).join(" ")} ELSE NULL END`);
+            await outputTableInstance.round(options.bm25ScoreColumn, {
+                decimals: 4,
+            });
+        }
+    }
+    if (options.verbose) {
+        await outputTableInstance.logTable("all");
+        const logParts = [`\nHybrid search times:`];
+        if (enableVectorSearch) {
+            logParts.push(`- Embedding: ${prettyDuration(times.embeddingStart, { end: times.embeddingEnd })}`);
+        }
+        const parallelLabel = enableVectorSearch && enableBm25 ? " (parallel)" : "";
+        logParts.push(enableVectorSearch
+            ? `- Vector Search${parallelLabel}: ${prettyDuration(times.vectorSearchStart, {
+                end: times.vectorSearchEnd,
+            })}`
+            : `- Vector Search: disabled`);
+        logParts.push(enableBm25
+            ? `- BM25 Search${parallelLabel}: ${prettyDuration(times.bm25Start, { end: times.bm25End })}`
+            : `- BM25 Search: disabled`);
+        logParts.push(`- Total: ${prettyDuration(times.start)} (verbose adds some overhead)`);
+        console.log(logParts.join("\n") + "\n");
+    }
+    return outputTableInstance;
+}

package/esm/methods/logHistogram.d.ts

@@ -0,0 +1,8 @@
+import type SimpleTable from "../class/SimpleTable.js";
+export default function logHistogram(simpleTable: SimpleTable, values: string, options?: {
+    bins?: number;
+    formatLabels?: (a: number, b: number) => string;
+    compact?: boolean;
+    width?: number;
+}): Promise<void>;
+//# sourceMappingURL=logHistogram.d.ts.map

package/esm/methods/logHistogram.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logHistogram.d.ts","sourceRoot":"","sources":["../../src/methods/logHistogram.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,WAAW,MAAM,yBAAyB,CAAC;AAEvD,wBAA8B,YAAY,CACxC,WAAW,EAAE,WAAW,EACxB,MAAM,EAAE,MAAM,EACd,OAAO,GAAE;IACP,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,YAAY,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;IAChD,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;CACX,iBAmDP"}

package/esm/methods/logHistogram.js

@@ -0,0 +1,39 @@
+import { logBarChart } from "../deps/jsr.io/@nshiab/journalism-dataviz/1.0.10/src/index.js";
+export default async function logHistogram(simpleTable, values, options = {}) {
+    const bins = options.bins ?? 10;
+    const formatLabels = options.formatLabels ?? ((a, b) => `[${a} | ${b})`);
+    const data = await simpleTable.sdb.customQuery(`
+WITH params AS (
+  SELECT 
+    ${bins} AS N_BINS,
+    min("${values}") AS min_distance,
+    max("${values}") AS max_distance,
+    (max("${values}") - min("${values}")) / ${bins} AS bin_size
+  FROM "${simpleTable.name}"
+),
+histogram AS (
+  SELECT 
+    floor(("${values}" - min_distance) / bin_size) AS bin_number,
+    min_distance + floor(("${values}" - min_distance) / bin_size) * bin_size AS bin_start,
+    min_distance + (floor(("${values}" - min_distance) / bin_size) + 1) * bin_size AS bin_end,
+    CAST(count(*) AS INTEGER) AS frequency
+  FROM "${simpleTable.name}", params
+  WHERE "${values}" >= min_distance AND "${values}" < max_distance
+  GROUP BY 1, 2, 3
+)
+SELECT 
+  bin_start,
+  bin_end,
+  frequency
+FROM histogram
+ORDER BY bin_start;`, { returnDataFrom: "query" });
+    logBarChart(data.map((d) => ({
+        binRange: formatLabels(parseFloat(d.bin_start.toFixed(10)), parseFloat(d.bin_end.toFixed(10))),
+        frequency: d.frequency,
+    })), "binRange", "frequency", {
+        title: `Distribution of "${values}"`,
+        totalLabel: "Number of data points",
+        compact: options.compact,
+        width: options.width,
+    });
+}

package/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@nshiab/simple-data-analysis",
+  "version": "5.19.8",
+  "description": "Easy-to-use and high-performance TypeScript library for data analysis. Works with tabular, geospatial and vector data.",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nshiab/simple-data-analysis"
+  },
+  "license": "MIT",
+  "main": "./script/index.js",
+  "module": "./esm/index.js",
+  "exports": {
+    ".": {
+      "import": "./esm/index.js",
+      "require": "./script/index.js"
+    }
+  },
+  "scripts": {},
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@duckdb/node-api": "1.4.4-r.1",
+    "@google-cloud/storage": "^7.19.0",
+    "@google/genai": "^1.46.0",
+    "@napi-rs/canvas": "^0.1.65",
+    "@observablehq/plot": "^0.6.17",
+    "@resvg/resvg-js": "^2.6.2",
+    "@types/d3-geo": "^3.1.0",
+    "d3-array": "^3.2.4",
+    "d3-dsv": "^3.0.1",
+    "d3-geo": "^3.1.1",
+    "date-fns-tz": "^3.2.0",
+    "google-auth-library": "^10.6.2",
+    "google-spreadsheet": "^5.2.0",
+    "jsonrepair": "^3.13.3",
+    "linkedom": "^0.18.5",
+    "ollama": "^0.6.3",
+    "zod": "^4.4.3"
+  },
+  "_generatedBy": "dnt@dev"
+}

package/script/_dnt.shims.d.ts

@@ -0,0 +1,2 @@
+export declare const dntGlobalThis: Omit<typeof globalThis, never>;
+//# sourceMappingURL=_dnt.shims.d.ts.map

package/script/_dnt.shims.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"_dnt.shims.d.ts","sourceRoot":"","sources":["../src/_dnt.shims.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,aAAa,gCAA2C,CAAC"}

package/script/_dnt.shims.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dntGlobalThis = void 0;
+const dntGlobals = {};
+exports.dntGlobalThis = createMergeProxy(globalThis, dntGlobals);
+function createMergeProxy(baseObj, extObj) {
+    return new Proxy(baseObj, {
+        get(_target, prop, _receiver) {
+            if (prop in extObj) {
+                return extObj[prop];
+            }
+            else {
+                return baseObj[prop];
+            }
+        },
+        set(_target, prop, value) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            baseObj[prop] = value;
+            return true;
+        },
+        deleteProperty(_target, prop) {
+            let success = false;
+            if (prop in extObj) {
+                delete extObj[prop];
+                success = true;
+            }
+            if (prop in baseObj) {
+                delete baseObj[prop];
+                success = true;
+            }
+            return success;
+        },
+        ownKeys(_target) {
+            const baseKeys = Reflect.ownKeys(baseObj);
+            const extKeys = Reflect.ownKeys(extObj);
+            const extKeysSet = new Set(extKeys);
+            return [...baseKeys.filter((k) => !extKeysSet.has(k)), ...extKeys];
+        },
+        defineProperty(_target, prop, desc) {
+            if (prop in extObj) {
+                delete extObj[prop];
+            }
+            Reflect.defineProperty(baseObj, prop, desc);
+            return true;
+        },
+        getOwnPropertyDescriptor(_target, prop) {
+            if (prop in extObj) {
+                return Reflect.getOwnPropertyDescriptor(extObj, prop);
+            }
+            else {
+                return Reflect.getOwnPropertyDescriptor(baseObj, prop);
+            }
+        },
+        has(_target, prop) {
+            return prop in extObj || prop in baseObj;
+        },
+    });
+}

package/script/class/SimpleDB.d.ts

@@ -0,0 +1,78 @@
+import { SimpleDB as SimpleDBCore } from "../deps/jsr.io/@nshiab/simple-data-analysis-core/0.0.17/src/index.js";
+import SimpleTable from "./SimpleTable.js";
+/**
+ * Manages a DuckDB database instance, providing a simplified interface for database operations.
+ * Extends the core [`SimpleDB`](https://github.com/nshiab/simple-data-analysis-core) class
+ * from [`simple-data-analysis-core`](https://github.com/nshiab/simple-data-analysis-core) to use
+ * our extended SimpleTable class which includes additional AI, Google Sheets, and charting methods.
+ *
+ * @example
+ * ```ts
+ * // Create an in-memory database instance
+ * const sdb = new SimpleDB();
+ * // Create a new table named "employees"
+ * const employees = sdb.newTable("employees");
+ * // Load data from a CSV file into the "employees" table
+ * await employees.loadData("./employees.csv");
+ * // Log the first few rows of the "employees" table to the console
+ * await employees.logTable();
+ * // Close the database connection and clean up resources
+ * await sdb.done();
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Create a persistent database instance, saving data to a file
+ * // To load an existing database, use the `loadDB` method instead
+ * const sdb = new SimpleDB({ file: "./my_database.db" });
+ * // Perform database operations...
+ * // Close the database connection, which saves changes to the specified file
+ * await sdb.done();
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Create a database instance with custom options
+ * const sdb = new SimpleDB({
+ *   debug: true, // Enable debugging output
+ *   nbRowsToLog: 20 // Set the number of rows to log by default
+ * });
+ * ```
+ */
+export default class SimpleDB extends SimpleDBCore<SimpleTable> {
+    /**
+     * The class used to create new table instances. Set to our extended SimpleTable
+     * which includes additional AI, Google Sheets, and charting methods.
+     * @internal
+     */
+    tableClass: typeof SimpleTable;
+    /**
+     * Creates a new SimpleDB instance.
+     *
+     * @param options - Configuration options for the SimpleDB instance.
+     * @param options.file - The path to the database file. If not provided, an in-memory database is used.
+     * @param options.overwrite - A flag indicating whether to overwrite the database file if it already exists.
+     * @param options.logDuration - A flag indicating whether to log the total execution duration.
+     * @param options.nbRowsToLog - The number of rows to display when logging a table.
+     * @param options.nbCharactersToLog - The maximum number of characters to display for text-based cells.
+     * @param options.types - A flag indicating whether to include data types when logging a table.
+     * @param options.cacheVerbose - A flag indicating whether to log verbose cache-related messages.
+     * @param options.debug - A flag indicating whether to log debugging information.
+     * @param options.duckDbCache - A flag indicating whether to use DuckDB's external file cache.
+     * @param options.progressBar - A flag indicating whether to display a progress bar for long-running operations.
+     * @category Constructor
+     */
+    constructor(options?: {
+        file?: string;
+        overwrite?: boolean;
+        logDuration?: boolean;
+        nbRowsToLog?: number;
+        nbCharactersToLog?: number;
+        types?: boolean;
+        cacheVerbose?: boolean;
+        debug?: boolean;
+        duckDbCache?: boolean | null;
+        progressBar?: boolean;
+    });
+}
+//# sourceMappingURL=SimpleDB.d.ts.map

package/script/class/SimpleDB.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SimpleDB.d.ts","sourceRoot":"","sources":["../../src/class/SimpleDB.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,IAAI,YAAY,EAAE,MAAM,sEAAsE,CAAC;AAChH,OAAO,WAAW,MAAM,kBAAkB,CAAC;AAE3C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,MAAM,CAAC,OAAO,OAAO,QAAS,SAAQ,YAAY,CAAC,WAAW,CAAC;IAC7D;;;;OAIG;IACM,UAAU,EAAE,OAAO,WAAW,CAAC;IAExC;;;;;;;;;;;;;;;OAeG;gBAED,OAAO,GAAE;QACP,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,SAAS,CAAC,EAAE,OAAO,CAAC;QACpB,WAAW,CAAC,EAAE,OAAO,CAAC;QACtB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,iBAAiB,CAAC,EAAE,MAAM,CAAC;QAC3B,KAAK,CAAC,EAAE,OAAO,CAAC;QAChB,YAAY,CAAC,EAAE,OAAO,CAAC;QACvB,KAAK,CAAC,EAAE,OAAO,CAAC;QAChB,WAAW,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;QAC7B,WAAW,CAAC,EAAE,OAAO,CAAC;KAClB;CAMT"}

package/script/class/SimpleDB.js

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("../deps/jsr.io/@nshiab/simple-data-analysis-core/0.0.17/src/index.js");
+const SimpleTable_js_1 = __importDefault(require("./SimpleTable.js"));
+/**
+ * Manages a DuckDB database instance, providing a simplified interface for database operations.
+ * Extends the core [`SimpleDB`](https://github.com/nshiab/simple-data-analysis-core) class
+ * from [`simple-data-analysis-core`](https://github.com/nshiab/simple-data-analysis-core) to use
+ * our extended SimpleTable class which includes additional AI, Google Sheets, and charting methods.
+ *
+ * @example
+ * ```ts
+ * // Create an in-memory database instance
+ * const sdb = new SimpleDB();
+ * // Create a new table named "employees"
+ * const employees = sdb.newTable("employees");
+ * // Load data from a CSV file into the "employees" table
+ * await employees.loadData("./employees.csv");
+ * // Log the first few rows of the "employees" table to the console
+ * await employees.logTable();
+ * // Close the database connection and clean up resources
+ * await sdb.done();
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Create a persistent database instance, saving data to a file
+ * // To load an existing database, use the `loadDB` method instead
+ * const sdb = new SimpleDB({ file: "./my_database.db" });
+ * // Perform database operations...
+ * // Close the database connection, which saves changes to the specified file
+ * await sdb.done();
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Create a database instance with custom options
+ * const sdb = new SimpleDB({
+ *   debug: true, // Enable debugging output
+ *   nbRowsToLog: 20 // Set the number of rows to log by default
+ * });
+ * ```
+ */
+class SimpleDB extends index_js_1.SimpleDB {
+    /**
+     * Creates a new SimpleDB instance.
+     *
+     * @param options - Configuration options for the SimpleDB instance.
+     * @param options.file - The path to the database file. If not provided, an in-memory database is used.
+     * @param options.overwrite - A flag indicating whether to overwrite the database file if it already exists.
+     * @param options.logDuration - A flag indicating whether to log the total execution duration.
+     * @param options.nbRowsToLog - The number of rows to display when logging a table.
+     * @param options.nbCharactersToLog - The maximum number of characters to display for text-based cells.
+     * @param options.types - A flag indicating whether to include data types when logging a table.
+     * @param options.cacheVerbose - A flag indicating whether to log verbose cache-related messages.
+     * @param options.debug - A flag indicating whether to log debugging information.
+     * @param options.duckDbCache - A flag indicating whether to use DuckDB's external file cache.
+     * @param options.progressBar - A flag indicating whether to display a progress bar for long-running operations.
+     * @category Constructor
+     */
+    constructor(options = {}) {
+        super(options);
+        /**
+         * The class used to create new table instances. Set to our extended SimpleTable
+         * which includes additional AI, Google Sheets, and charting methods.
+         * @internal
+         */
+        Object.defineProperty(this, "tableClass", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // Use our extended SimpleTable which includes AI, Google Sheets, and charting methods
+        this.tableClass = SimpleTable_js_1.default;
+    }
+}
+exports.default = SimpleDB;