@nshiab/simple-data-analysis-core 1.0.1 → 2.0.0

package/esm/class/SimpleDB.d.ts

@@ -7,36 +7,57 @@ import Simple from "./Simple.js";
  * ```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();
+ * // Create a table, load a CSV file, and log its first few rows
+ * const employees = await sdb
+ *   .newTable("employees")
+ *   .loadData("./employees.csv")
+ *   .log();
  * // Close the database connection and clean up resources
- * await sdb.done();
+ * await sdb.close();
  * ```
  *
  * @example
  * ```ts
- * // Create a persistent database instance, saving data to a file
- * // To load an existing database, use the `loadDB` method instead
+ * // Open or create a persistent DuckDB database. Changes persist in this file.
  * 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();
+ * // Execute pending work, save SDA metadata, and close the database connection
+ * await sdb.close();
  * ```
  *
  * @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
+ *   logSQL: true, // Log SQL immediately before it runs
+ *   rowsToLog: 20 // Set the number of rows to log by default
  * });
  * ```
  */
 export default class SimpleDB<Table extends SimpleTable = SimpleTable> extends Simple {
+    #private;
+    /**
+     * Whether to log each SQL statement immediately before execution.
+     *
+     * @defaultValue `false`
+     * @category Properties
+     * @example
+     * ```ts
+     * const sdb = new SimpleDB({ logSQL: true });
+     * ```
+     */
+    logSQL: boolean;
+    /**
+     * Whether to log DuckDB query plans before supported statements execute.
+     *
+     * @defaultValue `false`
+     * @category Properties
+     * @example
+     * ```ts
+     * const sdb = new SimpleDB({ explainSQL: true });
+     * ```
+     */
+    explainSQL: boolean;
     /**
      * An array of paths to the data sources used in the cache.
      *
@@ -66,14 +87,8 @@ export default class SimpleDB<Table extends SimpleTable = SimpleTable> extends S
      */
     logDuration: boolean;
     /**
-     * An array of table instances associated with this database.
-     *
-     * @defaultValue `[]`
-     * @category Properties
-     */
-    tables: Table[];
-    /**
-     * A flag indicating whether to log verbose cache-related messages.
+     * Whether to log cache hits and misses, code and input changes, TTL status,
+     * and cache read/write timing.
      *
      * @defaultValue `false`
      * @category Properties
@@ -100,6 +115,47 @@ export default class SimpleDB<Table extends SimpleTable = SimpleTable> extends S
      * @category Properties
      */
     progressBar: boolean;
+    /**
+     * The in-flight flush of the pending chains, if one is running. Concurrent
+     * observers await it instead of reading mid-flush state. This is for
+     * internal use only.
+     *
+     * @defaultValue `null`
+     * @internal
+     */
+    flushPromise: Promise<void> | null;
+    /**
+     * The database lifecycle state. This is for internal use only.
+     *
+     * @internal
+     */
+    lifecycleState: "open" | "closing" | "closed";
+    /**
+     * The number of queued operations across all tables, so query execution
+     * points skip the flush entirely when nothing is pending. This is for
+     * internal use only.
+     *
+     * @defaultValue `0`
+     * @internal
+     */
+    pendingCount: number;
+    /**
+     * A counter stamping queued operations with their position in program
+     * order across all tables, so flushes replay them in the order they were
+     * queued. This is for internal use only.
+     *
+     * @defaultValue `0`
+     * @internal
+     */
+    opSequence: number;
+    /**
+     * A flag indicating that the spatial extension has been loaded on this
+     * connection, so it's only loaded once. This is for internal use only.
+     *
+     * @defaultValue `false`
+     * @internal
+     */
+    spatialLoaded: boolean;
     /**
      * A flag indicating whether to use DuckDB's external file cache.
      *
@@ -115,30 +171,46 @@ export default class SimpleDB<Table extends SimpleTable = SimpleTable> extends S
      */
     memoryLimit: string | undefined;
     /**
-     * The path to the directory used for temporary files when data exceeds the memory limit (e.g., `'/tmp/duckdb_swap'`). Defaults to `.tmp` for in-memory databases or `<file>.tmp` for file-based databases. Temporary directories are automatically removed when calling `done()`.
+     * The path to the directory used for temporary files when data exceeds the memory limit (e.g., `'/tmp/duckdb_swap'`). Defaults to `.tmp` for in-memory databases or `<file>.tmp` for file-based databases. Temporary directories are automatically removed when calling `close()`.
      *
      * @defaultValue `undefined`
      * @category Properties
      */
-    tempDirectory: string | undefined;
+    tempDir: string | undefined;
     /**
-     * The path to the database file. If not provided, an in-memory database is used.
+     * The path to the persistent DuckDB database, opened or created on first use.
+     * If not provided, an in-memory database is used. Imports and exports do not change this path.
      *
      * @defaultValue `:memory:`
      * @category Properties
      */
     file: string;
     /**
-     * A flag indicating whether to overwrite the database file if it already exists.
+     * Whether to replace an existing DuckDB file on first use instead of opening it.
      *
      * @defaultValue `false`
      * @category Properties
      */
     overwrite: boolean;
+    /**
+     * Whether the persistent DuckDB file is opened read-only. Requires an existing
+     * file and cannot be combined with `overwrite`. DuckDB rejects writes to it.
+     *
+     * @defaultValue `false`
+     * @category Properties
+     * @example
+     * ```ts
+     * const sdb = new SimpleDB({ file: "./archive.duckdb", readOnly: true });
+     * const table = await sdb.getTable("employees");
+     * await table.log();
+     * await sdb.close();
+     * ```
+     */
+    readOnly: boolean;
     /**
      * The class used to create table instances. Defaults to `SimpleTable`.
      * Override this property when subclassing to ensure all table-creating
-     * methods (e.g., `newTable()`, `cloneTable()`) return instances of your
+     * methods (e.g., `newTable()`, `clone()`) return instances of your
      * custom table class.
      *
      * @defaultValue `SimpleTable`
@@ -163,42 +235,60 @@ export default class SimpleDB<Table extends SimpleTable = SimpleTable> extends S
      * ```
      */
     tableClass: new (name: string, sdb: SimpleDB, options?: {
-        debug?: boolean;
-        nbRowsToLog?: number;
-        nbCharactersToLog?: number;
-        types?: boolean;
+        rowsToLog?: number;
+        charsToLog?: number;
+        typesToLog?: boolean;
     }) => Table;
     /**
      * Creates a new SimpleDB instance.
      *
+     * DuckDB sessions use UTC so temporal parsing, extraction, and returned
+     * `TIMESTAMP WITH TIME ZONE` strings are consistent across environments.
+     *
+     * Existing tables and SDA index metadata are restored on first use. The
+     * `__sda` schema is reserved for versioned SDA metadata. SQLite files can be
+     * imported with `loadDB()` but cannot be used as the persistent database.
+     *
      * @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.file - A `.db` or `.duckdb` file to open or create. Defaults to an in-memory database.
+     * @param options.overwrite - If true, replaces an existing file on first use. Defaults to false, which opens the existing file.
+     * @param options.readOnly - Opens an existing DuckDB file read-only. Defaults to false. Requires a file and cannot be combined with overwrite.
      * @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.rowsToLog - The number of rows to display when logging a table.
+     * @param options.charsToLog - The maximum number of characters to display for text-based cells.
+     * @param options.typesToLog - A flag indicating whether to include data types when logging a table.
+     * @param options.cacheVerbose - Whether to log cache hits and misses, code and input changes, TTL status, and cache read/write timing.
+     * @param options.logSQL - A flag indicating whether to log SQL immediately before execution.
+     * @param options.explainSQL - A flag indicating whether to log DuckDB query plans for supported statements.
      * @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.
      * @param options.memoryLimit - The maximum amount of memory DuckDB is allowed to use (e.g., `'4GB'`). Defaults to 80% of system RAM.
-     * @param options.tempDirectory - The path to the directory used for temporary files when data exceeds the memory limit (e.g., `'/tmp/duckdb_swap'`). Defaults to `.tmp` for in-memory databases or `<file>.tmp` for file-based databases. Automatically removed when calling `done()`.
+     * @param options.tempDir - The path to the directory used for temporary files when data exceeds the memory limit (e.g., `'/tmp/duckdb_swap'`). Defaults to `.tmp` for in-memory databases or `<file>.tmp` for file-based databases. Automatically removed when calling `close()`.
      * @category Constructor
+     *
+     * @example
+     * ```ts
+     * const sdb = new SimpleDB({
+     *   logSQL: true,
+     *   explainSQL: true,
+     * });
+     * ```
      */
     constructor(options?: {
         file?: string;
         overwrite?: boolean;
+        readOnly?: boolean;
         logDuration?: boolean;
-        nbRowsToLog?: number;
-        nbCharactersToLog?: number;
-        types?: boolean;
+        rowsToLog?: number;
+        charsToLog?: number;
+        typesToLog?: boolean;
         cacheVerbose?: boolean;
-        debug?: boolean;
+        logSQL?: boolean;
+        explainSQL?: boolean;
         duckDbCache?: boolean | null;
         progressBar?: boolean;
         memoryLimit?: string;
-        tempDirectory?: string;
+        tempDir?: string;
     });
     /**
      * Initializes the DuckDB database instance and connection.
@@ -208,14 +298,6 @@ export default class SimpleDB<Table extends SimpleTable = SimpleTable> extends S
      * @category Lifecycle
      */
     start(): Promise<SimpleDB>;
-    /**
-     * Adds a SimpleTable instance to the internal list of tables.
-     *
-     * @param table - The SimpleTable instance to add.
-     * @internal
-     * @category Table Management
-     */
-    pushTable(table: Table): void;
     /**
      * Creates a new SimpleTable instance within the database.
      *
@@ -226,13 +308,19 @@ export default class SimpleDB<Table extends SimpleTable = SimpleTable> extends S
      * @example
      * ```ts
      * // Create a table with a default name (e.g., "table1", "table2", etc.)
-     * const dataTable = sdb.newTable();
+     * const dataTable = await sdb
+     *   .newTable()
+     *   .loadArray([{ value: 1 }])
+     *   .log();
      * ```
      *
      * @example
      * ```ts
      * // Create a table with a specific name
-     * const employees = sdb.newTable("employees");
+     * const employees = await sdb
+     *   .newTable("employees")
+     *   .loadData("employees.csv")
+     *   .log();
      * ```
      */
     newTable(name?: string): Table;
@@ -247,6 +335,7 @@ export default class SimpleDB<Table extends SimpleTable = SimpleTable> extends S
      * ```ts
      * // Retrieve the "employees" table
      * const employees = await sdb.getTable("employees");
+     * await employees.log();
      * ```
      */
     getTable(name: string): Promise<Table>;
@@ -254,7 +343,7 @@ export default class SimpleDB<Table extends SimpleTable = SimpleTable> extends S
      * Removes one or more tables from the database.
      *
      * @param tables - A single table or an array of tables to remove, specified by name or as SimpleTable instances. Pass `"all"` to remove all tables.
-     * @returns A promise that resolves when the tables have been removed.
+     * @returns A promise that resolves to the database, so methods can be chained.
      * @category Table Management
      *
      * @example
@@ -283,12 +372,12 @@ export default class SimpleDB<Table extends SimpleTable = SimpleTable> extends S
      * await sdb.removeTables("all");
      * ```
      */
-    removeTables(tables: Table | string | (Table | string)[]): Promise<void>;
+    removeTables(tables: Table | string | (Table | string)[]): Promise<this>;
     /**
      * Selects one or more tables to keep in the database, removing all others.
      *
      * @param tables - A single table or an array of tables to select, specified by name or as SimpleTable instances.
-     * @returns A promise that resolves when the tables have been selected.
+     * @returns A promise that resolves to the database, so methods can be chained.
      * @category Table Management
      *
      * @example
@@ -311,7 +400,7 @@ export default class SimpleDB<Table extends SimpleTable = SimpleTable> extends S
      * await sdb.selectTables(employeesTable);
      * ```
      */
-    selectTables(tables: Table | string | (Table | string)[]): Promise<void>;
+    selectTables(tables: Table | string | (Table | string)[]): Promise<this>;
     /**
      * Returns an array of all table names in the database, sorted alphabetically.
      *
@@ -329,7 +418,7 @@ export default class SimpleDB<Table extends SimpleTable = SimpleTable> extends S
     /**
      * Logs the names of all tables in the database to the console, sorted alphabetically.
      *
-     * @returns A promise that resolves when the table names have been logged.
+     * @returns A promise that resolves to the database, so methods can be chained.
      * @category Table Management
      *
      * @example
@@ -339,20 +428,23 @@ export default class SimpleDB<Table extends SimpleTable = SimpleTable> extends S
      * // Example output: SimpleDB - Tables:  ["employees","customers"]
      * ```
      */
-    logTableNames(): Promise<void>;
+    logTableNames(): Promise<this>;
     /**
      * Returns an array of all SimpleTable instances in the database.
      *
-     * @returns A promise that resolves to an array of SimpleTable instances.
+     * The returned array is a snapshot and cannot mutate the database's internal
+     * table registry.
+     *
+     * @returns A read-only array of SimpleTable instances.
      * @category Table Management
      *
      * @example
      * ```ts
      * // Get all SimpleTable instances
-     * const tables = await sdb.getTables();
+     * const tables = sdb.getTables();
      * ```
      */
-    getTables(): Promise<Table[]>;
+    getTables(): readonly Table[];
     /**
      * Checks if a table exists in the database.
      *
@@ -390,19 +482,24 @@ export default class SimpleDB<Table extends SimpleTable = SimpleTable> extends S
      * ```
      */
     getExtensions(): Promise<{
-        [key: string]: string | number | boolean | Date | null;
+        [key: string]: unknown;
     }[]>;
     /**
      * Executes a custom SQL query directly against the DuckDB instance.
+     * Queries run in UTC. When data is returned, temporal values use the same
+     * JavaScript representations as `SimpleTable.getData()`.
      *
-     * If you want to force the returned data to match the types of the columns, you can use the `types` option.
+     * `customQuery()` bypasses the dependency and table-generation tracking used
+     * by `SimpleTable.cache()`. Reading or changing a table with `customQuery()`
+     * can therefore cause `cache()` to return stale data. Include a value that
+     * identifies the custom query's dependencies in the cache's `options.inputs`
+     * (such as a table content hash), or use tracked `SimpleTable` methods.
      *
      * @param query - The SQL query string to execute.
      * @param options - Configuration options for the query.
-     * @param options.returnDataFrom - Specifies whether to return data from the query. Can be `"query"` to return data or `"none"` (default) to not return data.
+     * @param options.returnData - If `true`, the query result is returned. Defaults to `false`.
      * @param options.table - The name of the table associated with the query, primarily used for debugging and logging.
-     * @param options.types - An optional object specifying data types for the query parameters.
-     * @returns A promise that resolves to the query result as an array of objects if `returnDataFrom` is `"query"`, otherwise `null`.
+     * @returns A promise that resolves to the query result as an array of objects if `returnData` is `true`, otherwise `null`.
      * @category DuckDB
      *
      * @example
@@ -416,29 +513,31 @@ export default class SimpleDB<Table extends SimpleTable = SimpleTable> extends S
      * // Execute a query and return the results
      * const youngEmployees = await sdb.customQuery(
      *   "SELECT * FROM employees WHERE age < 30",
-     *   { returnDataFrom: "query" }
+     *   { returnData: true }
      * );
      * console.log(youngEmployees);
      * ```
      */
     customQuery(query: string, options?: {
-        returnDataFrom?: "query" | "none";
+        returnData?: boolean;
         table?: string;
-        types?: {
-            [key: string]: string;
-        };
     }): Promise<{
-        [key: string]: string | number | boolean | Date | null;
+        [key: string]: unknown;
     }[] | null>;
     /**
-     * Loads a database from a specified file into the current SimpleDB instance.
-     * Supported file types are `.db` (DuckDB) and `.sqlite` (SQLite).
-     *
-     * @param file - The absolute path to the database file (e.g., "./my_database.db").
-     * @param options - Configuration options for loading the database.
-     * @param options.name - The name to assign to the loaded database within the DuckDB instance. Defaults to the file name without extension.
-     * @param options.detach - If `true` (default), the database is detached after loading its contents into memory. If `false`, the database remains attached.
-     * @returns A promise that resolves when the database has been loaded.
+     * Imports a copy of a `.db` or `.duckdb` (DuckDB) or `.sqlite` (SQLite)
+     * file into the current database. The source is opened read-only and detached
+     * after importing; subsequent transformations do not modify the source file.
+     * Imports work with in-memory and writable persistent databases. Existing
+     * table-name conflicts are rejected and a failed copy is rolled back.
+     *
+     * DuckDB files restore embedded SDA index definitions when present. SQLite
+     * imports copy data without SDA index metadata. The `__sda` schema is reserved
+     * for SDA metadata.
+     * To edit an existing DuckDB file in place, use `new SimpleDB({ file })`.
+     *
+     * @param file - The relative or absolute path to the database file.
+     * @returns A promise that resolves to the database, so methods can be chained.
      * @category File Operations
      *
      * @example
@@ -449,28 +548,39 @@ export default class SimpleDB<Table extends SimpleTable = SimpleTable> extends S
      *
      * @example
      * ```ts
-     * // Load a SQLite database file and keep it attached
-     * await sdb.loadDB("./my_database.sqlite", { detach: false });
+     * // Import SQLite tables without modifying the original file
+     * await sdb.loadDB("./my_database.sqlite");
      * ```
      *
      * @example
      * ```ts
-     * // Load a database with a custom name
-     * await sdb.loadDB("./archive.db", { name: "archive_db" });
+     * // Import a copy into a persistent DuckDB database
+     * const sdb = new SimpleDB({ file: "./analysis.duckdb" });
+     * await sdb.loadDB("./archive.db");
+     * await sdb.close();
      * ```
      */
-    loadDB(file: string, options?: {
-        name?: string;
-        detach?: boolean;
-    }): Promise<void>;
+    loadDB(file: string): Promise<this>;
     /**
-     * Writes the current state of the database to a specified file.
-     * Supported output file types are `.db` (DuckDB) and `.sqlite` (SQLite).
+     * Exports a snapshot of the current database after executing pending work.
+     * Does not change the working database or where subsequent changes persist.
+     * DuckDB outputs (`.db` and `.duckdb`) preserve database objects and embed SDA
+     * index definitions in the reserved `__sda` schema.
      *
-     * @param file - The absolute path to the output file (e.g., "./my_exported_database.db").
+     * SQLite output (`.sqlite`) materializes main-schema tables and views as
+     * tables. It does not preserve DuckDB schemas, indexes, constraints, or SDA
+     * metadata, and SQLite type conversion may lose type information. Unsupported
+     * conversions fail without replacing an existing destination.
+     *
+     * Existing files require explicit overwrite permission. The completed export
+     * is published only after its connection is detached. Database files attached
+     * to this instance, directories, and symbolic links cannot be replaced.
+     *
+     * @param file - The relative or absolute path to the output file.
      * @param options - Configuration options for writing the database.
-     * @param options.noMetaData - If `true`, metadata files (indexes) are not created alongside the database file. Defaults to `false`.
-     * @returns A promise that resolves when the database has been written to the file.
+     * @param options.overwrite - If true, permits atomic replacement of an existing output file. Defaults to false.
+     * @param options.metadata - If false, omits logical SDA index definitions from DuckDB exports. Defaults to true. Does not control physical indexes; SQLite exports never include SDA metadata.
+     * @returns A promise that resolves to the database, so methods can be chained.
      * @category File Operations
      *
      * @example
@@ -481,26 +591,60 @@ export default class SimpleDB<Table extends SimpleTable = SimpleTable> extends S
      *
      * @example
      * ```ts
-     * // Write the current database to a SQLite file without metadata
-     * await sdb.writeDB("./my_exported_database.sqlite", { noMetaData: true });
+     * // Explicitly replace an earlier snapshot
+     * await sdb.writeDB("./my_exported_database.duckdb", { overwrite: true });
+     * ```
+     *
+     * @example
+     * ```ts
+     * // Export table data for use with SQLite
+     * await sdb.writeDB("./my_exported_database.sqlite");
      * ```
      */
     writeDB(file: string, options?: {
-        noMetaData?: boolean;
-    }): Promise<void>;
+        overwrite?: boolean;
+        metadata?: boolean;
+    }): Promise<this>;
+    /**
+     * Executes all queued methods across every table in the database. Sync
+     * builder methods (like `filter()` or `convert()`) only queue their
+     * operation; execution happens when an async observer method (like
+     * `getData()`, `log()`, or `writeData()`) is awaited. Use `run()` when
+     * your script ends in pure mutations with nothing to observe and you want
+     * the work done now.
+     *
+     * The whole database is flushed in program order, so operations on
+     * different tables execute exactly in the order they were queued. This is
+     * the database-level counterpart to `SimpleTable.run()`.
+     *
+     * @returns A promise that resolves to the SimpleDB instance once the queued methods have been executed.
+     * @category Lifecycle
+     *
+     * @example
+     * ```ts
+     * // Nothing is observed after the mutations, so run() executes them.
+     * table1.loadData("data1.csv").convert({ price: "number" });
+     * table2.loadData("data2.csv").filter(`price > 0`);
+     * await sdb.run();
+     * ```
+     */
+    run(): Promise<SimpleDB>;
     /**
-     * Frees up memory by closing the database connection and instance, and cleans up the cache.
-     * If the database is file-based, it also compacts the database file to optimize storage.
+     * Executes pending transformations, saves SDA metadata for writable persistent
+     * databases, and closes the connection and instance. Also cleans up temporary
+     * files and the cache. Does not copy, compact, or replace the database file.
      *
      * @returns A promise that resolves to the SimpleDB instance after cleanup.
+     * @throws An error after cleanup when pending execution or cleanup fails.
      * @category Lifecycle
      *
      * @example
      * ```ts
-     * // Close the database and clean up resources
-     * await sdb.done();
+     * // close() executes queued transformations before cleaning up resources.
+     * table.loadData("data.csv").convert({ price: "number" });
+     * await sdb.close();
      * ```
      */
-    done(): Promise<SimpleDB>;
+    close(): Promise<SimpleDB>;
 }
 //# sourceMappingURL=SimpleDB.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"SimpleDB.d.ts","sourceRoot":"","sources":["../../src/class/SimpleDB.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"SimpleDB.d.ts","sourceRoot":"","sources":["../../src/class/SimpleDB.ts"],"names":[],"mappings":"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"}