@cereusdb/minimal 0.3.0 → 0.4.0

package/README.md

@@ -37,6 +37,30 @@ Not included in this package:
 
 Browser object stores are not included in `@cereusdb/minimal`. Use `@cereusdb/standard`, `@cereusdb/global`, or `@cereusdb/full` when you need `registerObjectStores()` and `registerParquetTable()`.
 
+## Persistent databases (OPFS)
+
+Tables normally live in memory. Persistent databases are stored in the browser's Origin Private File System and survive page reloads:
+
+```ts
+const db = await CereusDB.create({ attach: ['opfs://mydb'] }); // opens or creates mydb
+
+await db.sqlJSON(`CREATE TABLE mydb.public.cities AS SELECT 1 AS id, 'Berlin' AS name, ST_Point(13.4, 52.5) AS geom`);
+await db.sqlJSON(`INSERT INTO mydb.public.cities VALUES (2, 'Paris', ST_Point(2.35, 48.86))`);
+await db.sqlJSON(`USE mydb`); // `cities` now resolves to mydb.public.cities
+```
+
+SQL: `CREATE DATABASE 'opfs://mydb'`, `ATTACH 'opfs://mydb' [AS name]`, `DETACH name`, `DROP DATABASE name`, `USE name`, `ALTER TABLE ... RENAME TO | ADD COLUMN | DROP COLUMN | RENAME COLUMN`, and `SELECT * FROM cereusdb_databases()`. Databases appear as catalogs in `information_schema` and `db.catalog()`. A table's data is loaded the first time it is used. See the [persistent databases guide](https://github.com/tobilg/cereusdb/blob/main/packages/documentation/guides/persistent-databases.md).
+
+## GeoParquet export
+
+```ts
+const bytes = await db.exportGeoParquet('mydb.public.cities'); // Uint8Array
+await db.downloadGeoParquet('mydb.public.cities');            // downloads cities.parquet
+await db.sqlJSON(`COPY (SELECT * FROM cities WHERE id > 1) TO 'some.parquet'`);
+```
+
+See the [GeoParquet export guide](https://github.com/tobilg/cereusdb/blob/main/packages/documentation/guides/geoparquet-export.md).
+
 ## Loading the WASM module
 
 The wasm binary ships as a separate file, `dist/wasm/cereusdb_bg.wasm`. The default entry finds it automatically, and bundlers emit it as an asset.
@@ -63,10 +87,49 @@ Exports:
 - `RegisterParquetTableOptions`
 - `RasterFormat`
 - `QueryResult`
+- `MemoryStorageBackend`, `OPFSStorageBackend`, `StorageBackend`, `StorageOptions`
+- `CreateDatabaseOptions`, `AttachDatabaseOptions`, `DatabaseListing`
+- `CatalogDatabase`, `CatalogSchema`, `CatalogTable`, `CatalogColumn`
+- `CreateTableDefinition`, `CreateTableOptions`, `AlterTableOperation`
+- `GeoParquetExportOptions`, `DownloadGeoParquetOptions`, `ExportHandler`
+- `downloadFile`, `PARQUET_MIME_TYPE`
 
 Main types:
 
 ```ts
+interface StorageOptions {
+  opfs?: StorageBackend | false; // default: OPFSStorageBackend when the browser has OPFS
+  [scheme: string]: StorageBackend | false | undefined;
+}
+
+interface StorageBackend {
+  readFile(path: string): Promise<Uint8Array | null>;
+  writeFile(path: string, data: Uint8Array): Promise<void>;
+  remove(path: string): Promise<void>;
+  list(path: string): Promise<string[]>;
+  lock?(name: string): Promise<void>;
+  unlock?(name: string): Promise<void>;
+}
+
+type ExportHandler = (filename: string, data: Uint8Array, mimeType: string) => void | Promise<void>;
+
+type CreateTableDefinition = { columns: Record<string, string> } | { as: string };
+
+type AlterTableOperation =
+  | { renameTo: string }
+  | { addColumn: { name: string; type: string; notNull?: boolean; default?: string }; ifNotExists?: boolean }
+  | { dropColumn: string | string[]; ifExists?: boolean }
+  | { renameColumn: { from: string; to: string } };
+
+interface GeoParquetExportOptions {
+  compression?: 'zstd' | 'snappy' | 'lz4' | 'gzip' | 'brotli' | 'uncompressed';
+  rowGroupSize?: number;
+}
+
+interface DownloadGeoParquetOptions extends GeoParquetExportOptions {
+  filename?: string;
+}
+
 type RasterFormat = 'geotiff' | 'tiff';
 type ObjectStoreProvider = 'http' | 's3' | 'gcs' | 'azure';
 
@@ -80,6 +143,9 @@ interface CereusDBOptions {
     | WebAssembly.Module
     | Promise<Response>;
   objectStores?: ObjectStoreRegistryConfig;
+  storage?: StorageOptions;
+  attach?: string[];
+  onExport?: ExportHandler | false;
 }
 
 interface ObjectStoreRegistryConfig {
@@ -118,8 +184,22 @@ class CereusDB {
   registerGeoJSON(name: string, geojson: string | object): void;
   registerRaster(name: string, data: BufferSource, format: RasterFormat): void;
   registerGeoTIFF(name: string, data: BufferSource): void;
-  dropTable(name: string): void;
-  tables(): string[];
+  dropTable(name: string): Promise<void>;
+  catalog(): Promise<CatalogDatabase[]>;
+  createDatabase(location: string, options?: CreateDatabaseOptions): Promise<string>;
+  attachDatabase(location: string, options?: AttachDatabaseOptions): Promise<string>;
+  detachDatabase(name: string, options?: { ifExists?: boolean }): Promise<void>;
+  dropDatabase(nameOrLocation: string, options?: { ifExists?: boolean }): Promise<void>;
+  useDatabase(database: string, schema?: string): Promise<void>;
+  listDatabases(): Promise<DatabaseListing[]>;
+  createTable(name: string, definition: CreateTableDefinition, options?: CreateTableOptions): Promise<void>;
+  alterTable(name: string, operation: AlterTableOperation): Promise<void>;
+  insertArrow(table: string, data: BufferSource): Promise<number>;
+  compactDatabase(name: string): Promise<void>;
+  flush(): Promise<void>;
+  exportGeoParquet(queryOrTable: string, options?: GeoParquetExportOptions): Promise<Uint8Array>;
+  downloadGeoParquet(queryOrTable: string, options?: DownloadGeoParquetOptions): Promise<string>;
+  tables(options?: { qualified?: boolean }): string[];
   version(): string;
 }
 ```
@@ -131,6 +211,8 @@ API notes:
 - `registerFile()` supports `.parquet`, `.geoparquet`, `.geojson`, and `.json` in this package.
 - Browser object-store methods are part of the shared wrapper, but object-store registration requires `@cereusdb/standard`, `@cereusdb/global`, or `@cereusdb/full`.
 - `registerRaster()` and `registerGeoTIFF()` are part of the shared wrapper, but raster registration requires `@cereusdb/full`.
+- Persistent databases (`createDatabase()` and related methods), `ALTER TABLE`, `insertArrow()`, `catalog()` and GeoParquet export are available in every package.
+- `downloadGeoParquet()` and `COPY ... TO` pass the file to the `onExport` handler: a browser download by default on the main thread; pass your own handler in Web Workers or Node.js. Exporting a CRS other than OGC:CRS84 needs PROJ, which this package does not include.
 
 ## Example
 

package/dist/external.d.ts

@@ -1,3 +1,5 @@
+import { type StorageBackend } from './storage.js';
+export { MemoryStorageBackend, OPFSStorageBackend, type OPFSStorageBackendOptions, type StorageBackend, } from './storage.js';
 export interface QueryResult {
     /** Raw JSON data parsed from query */
     data: Record<string, unknown>[];
@@ -15,7 +17,127 @@ export interface CereusDBOptions {
     wasmSource?: RequestInfo | URL | Response | BufferSource | WebAssembly.Module | Promise<Response>;
     /** Browser-backed object stores to register at startup. */
     objectStores?: ObjectStoreRegistryConfig;
+    /**
+     * Storage backends for persistent databases, by URL scheme. `opfs` defaults
+     * to an {@link OPFSStorageBackend} when the browser supports OPFS; pass
+     * `false` to disable it.
+     */
+    storage?: StorageOptions;
+    /**
+     * Persistent databases to open at startup, for example `['opfs://mydb']`.
+     * Each is created if it does not exist yet.
+     */
+    attach?: string[];
+    /**
+     * Receives files written by `COPY ... TO '<file>'` and
+     * {@link CereusDB.downloadGeoParquet}. Defaults to {@link downloadFile}
+     * (a browser download) when a DOM `document` is available; pass `false` to
+     * disable exports or a function to handle them yourself (for example in a
+     * Web Worker or in Node.js).
+     */
+    onExport?: ExportHandler | false;
+}
+/** Receives an exported file. */
+export type ExportHandler = (filename: string, data: Uint8Array, mimeType: string) => void | Promise<void>;
+/** MIME type of GeoParquet exports. */
+export declare const PARQUET_MIME_TYPE = "application/vnd.apache.parquet";
+/**
+ * Save a file with the browser's download mechanism. Needs a DOM `document`
+ * (the main thread); it does not work in Web Workers or Node.js.
+ */
+export declare function downloadFile(filename: string, data: Uint8Array, mimeType?: string): void;
+export interface StorageOptions {
+    opfs?: StorageBackend | false;
+    [scheme: string]: StorageBackend | false | undefined;
+}
+export interface CreateDatabaseOptions {
+    /** Database (catalog) name. Defaults to the lowercased name in the location URL. */
+    name?: string;
+    /** Open the database if it already exists instead of failing. */
+    ifNotExists?: boolean;
+}
+export interface AttachDatabaseOptions {
+    /** Database (catalog) name. Defaults to the lowercased name in the location URL. */
+    name?: string;
+    /** Succeed if the database is already attached under this name. */
+    ifNotExists?: boolean;
+}
+export interface DatabaseListing {
+    /** Catalog name, or `null` for stored databases that are not attached. */
+    name: string | null;
+    /** `memory` or the storage scheme, for example `opfs`. */
+    storage: string;
+    /** Location URL for persistent databases. */
+    location: string | null;
+    attached: boolean;
+}
+export interface CatalogColumn {
+    name: string;
+    /** Arrow data type. */
+    type: string;
+    nullable: boolean;
+    /** Arrow extension type, for example `geoarrow.wkb` for geometry columns. */
+    extension?: string;
+}
+export interface CatalogTable {
+    name: string;
+    type: 'BASE TABLE' | 'VIEW' | 'LOCAL TEMPORARY';
+    columns: CatalogColumn[];
+}
+export interface CatalogSchema {
+    name: string;
+    tables: CatalogTable[];
+}
+export interface CatalogDatabase {
+    name: string;
+    storage: string;
+    location: string | null;
+    schemas: CatalogSchema[];
+}
+/** Columns as `{ name: 'SQL type' }`, or a query for CREATE TABLE ... AS. */
+export type CreateTableDefinition = {
+    columns: Record<string, string>;
+} | {
+    as: string;
+};
+export interface GeoParquetExportOptions {
+    /** Parquet compression codec. Defaults to `zstd`. */
+    compression?: 'zstd' | 'snappy' | 'lz4' | 'gzip' | 'brotli' | 'uncompressed';
+    /** Maximum number of rows per row group. */
+    rowGroupSize?: number;
+}
+export interface DownloadGeoParquetOptions extends GeoParquetExportOptions {
+    /**
+     * File name. Defaults to `<table>.parquet` for a table and
+     * `export.parquet` for a query.
+     */
+    filename?: string;
 }
+export interface CreateTableOptions {
+    ifNotExists?: boolean;
+    orReplace?: boolean;
+}
+export type AlterTableOperation = {
+    renameTo: string;
+} | {
+    addColumn: {
+        name: string;
+        /** SQL type, for example `VARCHAR` or `DOUBLE`. */
+        type: string;
+        notNull?: boolean;
+        /** SQL expression used for existing rows and as column default. */
+        default?: string;
+    };
+    ifNotExists?: boolean;
+} | {
+    dropColumn: string | string[];
+    ifExists?: boolean;
+} | {
+    renameColumn: {
+        from: string;
+        to: string;
+    };
+};
 export type RasterFormat = 'geotiff' | 'tiff';
 export type ObjectStoreProvider = 'http' | 's3' | 'gcs' | 'azure';
 export interface ObjectStoreRegistryConfig {
@@ -42,6 +164,8 @@ export interface RegisterParquetTableOptions {
 }
 export declare class CereusDB {
     private inner;
+    private storageBackends;
+    private exportHandler?;
     private constructor();
     /**
      * Create and initialize a new CereusDB instance.
@@ -88,10 +212,81 @@ export declare class CereusDB {
      * Requires the full GDAL-enabled package build.
      */
     registerGeoTIFF(name: string, data: BufferSource): void;
-    /** Drop a table. */
-    dropTable(name: string): void;
-    /** List registered tables. */
-    tables(): string[];
+    /**
+     * Drop a table. The table is removed immediately; for tables of persistent
+     * databases the returned promise resolves once the change is written.
+     */
+    dropTable(name: string): Promise<void>;
+    /**
+     * Create a persistent database, for example `opfs://mydb`, and attach it
+     * as a catalog. Equivalent to `CREATE DATABASE 'opfs://mydb'`.
+     * Resolves to the database name.
+     */
+    createDatabase(location: string, options?: CreateDatabaseOptions): Promise<string>;
+    /**
+     * Open an existing persistent database. Equivalent to
+     * `ATTACH 'opfs://mydb' [AS name]`. Resolves to the database name.
+     */
+    attachDatabase(location: string, options?: AttachDatabaseOptions): Promise<string>;
+    /** Write pending changes and close a persistent database. Equivalent to `DETACH name`. */
+    detachDatabase(name: string, options?: {
+        ifExists?: boolean;
+    }): Promise<void>;
+    /**
+     * Drop a database by name or location. Persistent databases are deleted
+     * from storage. Equivalent to `DROP DATABASE`.
+     */
+    dropDatabase(nameOrLocation: string, options?: {
+        ifExists?: boolean;
+    }): Promise<void>;
+    /** Set the default database (and schema). Equivalent to `USE database[.schema]`. */
+    useDatabase(database: string, schema?: string): Promise<void>;
+    /** Attached databases plus stored databases that are not attached. */
+    listDatabases(): Promise<DatabaseListing[]>;
+    /** Describe all databases, schemas, tables and views. */
+    catalog(): Promise<CatalogDatabase[]>;
+    /**
+     * Create a table from column definitions or a query. `name` may be
+     * qualified (`mydb.public.cities`).
+     */
+    createTable(name: string, definition: CreateTableDefinition, options?: CreateTableOptions): Promise<void>;
+    /** Rename a table or add, drop, or rename a column. */
+    alterTable(name: string, operation: AlterTableOperation): Promise<void>;
+    /**
+     * Insert Arrow IPC data (stream or file format, for example from
+     * `tableToIPC()` of apache-arrow) into a table. Columns are matched by
+     * name; missing columns are filled with NULL. Resolves to the number of
+     * inserted rows.
+     */
+    insertArrow(table: string, data: BufferSource): Promise<number>;
+    /**
+     * Export a table or query result as a GeoParquet (1.1) file. Geometry and
+     * geography columns are described in the file's `geo` metadata.
+     *
+     * @param queryOrTable A query (`SELECT ...`, `WITH ...`) or a table name.
+     */
+    exportGeoParquet(queryOrTable: string, options?: GeoParquetExportOptions): Promise<Uint8Array>;
+    /**
+     * Export a table or query result as GeoParquet and pass it to the export
+     * handler: a browser download by default (see `onExport` in
+     * {@link CereusDBOptions}). Resolves to the file name.
+     *
+     * @param queryOrTable A query (`SELECT ...`, `WITH ...`) or a table name.
+     */
+    downloadGeoParquet(queryOrTable: string, options?: DownloadGeoParquetOptions): Promise<string>;
+    /** Rewrite all tables of a persistent database into one segment each. */
+    compactDatabase(name: string): Promise<void>;
+    /** Write pending changes of persistent databases (for example after registerGeoJSON()). */
+    flush(): Promise<void>;
+    /**
+     * List the tables and views of all databases. By default only the table
+     * names are returned, which is ambiguous when databases contain tables with
+     * the same name; pass `{ qualified: true }` for `database.schema.table`
+     * names, or use {@link CereusDB.catalog} for full details.
+     */
+    tables(options?: {
+        qualified?: boolean;
+    }): string[];
     /** Version string. */
     version(): string;
     private objectStoreApi;

package/dist/external.js

@@ -1,4 +1,80 @@
 import init, { CereusDB as WasmCereusDB } from './wasm/cereusdb-external.js';
+import { OPFSStorageBackend } from './storage.js';
+export { MemoryStorageBackend, OPFSStorageBackend, } from './storage.js';
+/** MIME type of GeoParquet exports. */
+export const PARQUET_MIME_TYPE = 'application/vnd.apache.parquet';
+/**
+ * Save a file with the browser's download mechanism. Needs a DOM `document`
+ * (the main thread); it does not work in Web Workers or Node.js.
+ */
+export function downloadFile(filename, data, mimeType = 'application/octet-stream') {
+    if (typeof document === 'undefined') {
+        throw new Error('downloadFile() needs a browser document; pass CereusDB.create({ onExport }) to handle exports elsewhere');
+    }
+    const url = URL.createObjectURL(new Blob([data], { type: mimeType }));
+    const link = document.createElement('a');
+    link.href = url;
+    link.download = filename;
+    link.style.display = 'none';
+    document.body.appendChild(link);
+    try {
+        link.click();
+    }
+    finally {
+        link.remove();
+        // Revoking right away can cancel the download in some browsers.
+        setTimeout(() => URL.revokeObjectURL(url), 60000);
+    }
+}
+const QUERY_PATTERN = /^\s*(select|with|values|\()/i;
+function resolveExportHandler(option) {
+    if (option === false) {
+        return undefined;
+    }
+    if (option !== undefined) {
+        return option;
+    }
+    return typeof document !== 'undefined' ? downloadFile : undefined;
+}
+function defaultExportFilename(queryOrTable) {
+    if (QUERY_PATTERN.test(queryOrTable)) {
+        return 'export.parquet';
+    }
+    const name = queryOrTable.trim().split('.').pop()?.replace(/^"|"$/g, '');
+    return `${name || 'export'}.parquet`;
+}
+function resolveStorageBackends(options) {
+    const backends = {};
+    for (const [scheme, backend] of Object.entries(options ?? {})) {
+        if (backend) {
+            backends[scheme.toLowerCase()] = backend;
+        }
+    }
+    if (options?.opfs === undefined && OPFSStorageBackend.isSupported()) {
+        backends.opfs = new OPFSStorageBackend();
+    }
+    return backends;
+}
+function alterTableClause(operation) {
+    if ('renameTo' in operation) {
+        return `RENAME TO ${operation.renameTo}`;
+    }
+    if ('addColumn' in operation) {
+        const column = operation.addColumn;
+        const notNull = column.notNull ? ' NOT NULL' : '';
+        const defaultValue = column.default !== undefined ? ` DEFAULT ${column.default}` : '';
+        const ifNotExists = operation.ifNotExists ? 'IF NOT EXISTS ' : '';
+        return `ADD COLUMN ${ifNotExists}${column.name} ${column.type}${notNull}${defaultValue}`;
+    }
+    if ('dropColumn' in operation) {
+        const columns = Array.isArray(operation.dropColumn)
+            ? operation.dropColumn
+            : [operation.dropColumn];
+        const ifExists = operation.ifExists ? 'IF EXISTS ' : '';
+        return columns.map((column) => `DROP COLUMN ${ifExists}${column}`).join(', ');
+    }
+    return `RENAME COLUMN ${operation.renameColumn.from} TO ${operation.renameColumn.to}`;
+}
 function toUint8Array(data) {
     if (ArrayBuffer.isView(data)) {
         return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
@@ -14,6 +90,7 @@ function normalizeRasterFormat(format) {
 }
 export class CereusDB {
     constructor(inner) {
+        this.storageBackends = {};
         this.inner = inner;
     }
     /**
@@ -33,6 +110,17 @@ export class CereusDB {
         if (options?.objectStores !== undefined) {
             db.registerObjectStores(options.objectStores);
         }
+        db.exportHandler = resolveExportHandler(options?.onExport);
+        if (db.exportHandler !== undefined) {
+            inner.register_export_handler(db.exportHandler);
+        }
+        db.storageBackends = resolveStorageBackends(options?.storage);
+        for (const [scheme, backend] of Object.entries(db.storageBackends)) {
+            inner.register_storage_backend(scheme, backend);
+        }
+        for (const location of options?.attach ?? []) {
+            await db.createDatabase(location, { ifNotExists: true });
+        }
         return db;
     }
     /**
@@ -109,13 +197,140 @@ export class CereusDB {
     registerGeoTIFF(name, data) {
         this.registerRaster(name, data, 'geotiff');
     }
-    /** Drop a table. */
+    /**
+     * Drop a table. The table is removed immediately; for tables of persistent
+     * databases the returned promise resolves once the change is written.
+     */
     dropTable(name) {
         this.inner.drop_table(name);
+        return this.inner.flush();
+    }
+    /**
+     * Create a persistent database, for example `opfs://mydb`, and attach it
+     * as a catalog. Equivalent to `CREATE DATABASE 'opfs://mydb'`.
+     * Resolves to the database name.
+     */
+    async createDatabase(location, options = {}) {
+        return await this.inner.attach_database(location, options.name, true, options.ifNotExists ?? false);
+    }
+    /**
+     * Open an existing persistent database. Equivalent to
+     * `ATTACH 'opfs://mydb' [AS name]`. Resolves to the database name.
+     */
+    async attachDatabase(location, options = {}) {
+        return await this.inner.attach_database(location, options.name, false, options.ifNotExists ?? false);
+    }
+    /** Write pending changes and close a persistent database. Equivalent to `DETACH name`. */
+    async detachDatabase(name, options = {}) {
+        await this.inner.detach_database(name, options.ifExists ?? false);
+    }
+    /**
+     * Drop a database by name or location. Persistent databases are deleted
+     * from storage. Equivalent to `DROP DATABASE`.
+     */
+    async dropDatabase(nameOrLocation, options = {}) {
+        await this.inner.drop_database(nameOrLocation, options.ifExists ?? false);
+    }
+    /** Set the default database (and schema). Equivalent to `USE database[.schema]`. */
+    async useDatabase(database, schema) {
+        await this.inner.sql_json(schema === undefined ? `USE ${database}` : `USE ${database}.${schema}`);
+    }
+    /** Attached databases plus stored databases that are not attached. */
+    async listDatabases() {
+        const rows = (await this.sqlJSON('SELECT database_name, storage, location FROM cereusdb_databases()'));
+        const databases = rows.map((row) => ({
+            name: row.database_name,
+            storage: row.storage,
+            location: row.location ?? null,
+            attached: true,
+        }));
+        for (const scheme of Object.keys(this.storageBackends)) {
+            const locations = (await this.inner.list_database_locations(scheme));
+            for (const location of locations) {
+                if (!databases.some((database) => database.location === location)) {
+                    databases.push({ name: null, storage: scheme, location, attached: false });
+                }
+            }
+        }
+        return databases;
+    }
+    /** Describe all databases, schemas, tables and views. */
+    async catalog() {
+        return JSON.parse(await this.inner.catalog_json());
     }
-    /** List registered tables. */
-    tables() {
-        return this.inner.tables();
+    /**
+     * Create a table from column definitions or a query. `name` may be
+     * qualified (`mydb.public.cities`).
+     */
+    async createTable(name, definition, options = {}) {
+        const orReplace = options.orReplace ? 'OR REPLACE ' : '';
+        const ifNotExists = options.ifNotExists ? 'IF NOT EXISTS ' : '';
+        const body = 'as' in definition
+            ? `AS ${definition.as}`
+            : `(${Object.entries(definition.columns)
+                .map(([column, type]) => `${column} ${type}`)
+                .join(', ')})`;
+        await this.inner.sql_json(`CREATE ${orReplace}TABLE ${ifNotExists}${name} ${body}`);
+    }
+    /** Rename a table or add, drop, or rename a column. */
+    async alterTable(name, operation) {
+        await this.inner.sql_json(`ALTER TABLE ${name} ${alterTableClause(operation)}`);
+    }
+    /**
+     * Insert Arrow IPC data (stream or file format, for example from
+     * `tableToIPC()` of apache-arrow) into a table. Columns are matched by
+     * name; missing columns are filled with NULL. Resolves to the number of
+     * inserted rows.
+     */
+    async insertArrow(table, data) {
+        return await this.inner.insert_arrow(table, toUint8Array(data));
+    }
+    /**
+     * Export a table or query result as a GeoParquet (1.1) file. Geometry and
+     * geography columns are described in the file's `geo` metadata.
+     *
+     * @param queryOrTable A query (`SELECT ...`, `WITH ...`) or a table name.
+     */
+    async exportGeoParquet(queryOrTable, options = {}) {
+        const query = QUERY_PATTERN.test(queryOrTable)
+            ? queryOrTable
+            : `SELECT * FROM ${queryOrTable}`;
+        return await this.inner.export_geoparquet(query, options);
+    }
+    /**
+     * Export a table or query result as GeoParquet and pass it to the export
+     * handler: a browser download by default (see `onExport` in
+     * {@link CereusDBOptions}). Resolves to the file name.
+     *
+     * @param queryOrTable A query (`SELECT ...`, `WITH ...`) or a table name.
+     */
+    async downloadGeoParquet(queryOrTable, options = {}) {
+        const { filename, ...exportOptions } = options;
+        const handler = this.exportHandler;
+        if (handler === undefined) {
+            throw new Error('No export handler: downloads need a browser document; pass CereusDB.create({ onExport }) elsewhere');
+        }
+        const data = await this.exportGeoParquet(queryOrTable, exportOptions);
+        const name = filename ?? defaultExportFilename(queryOrTable);
+        await handler(name, data, PARQUET_MIME_TYPE);
+        return name;
+    }
+    /** Rewrite all tables of a persistent database into one segment each. */
+    async compactDatabase(name) {
+        await this.inner.compact_database(name);
+    }
+    /** Write pending changes of persistent databases (for example after registerGeoJSON()). */
+    async flush() {
+        await this.inner.flush();
+    }
+    /**
+     * List the tables and views of all databases. By default only the table
+     * names are returned, which is ambiguous when databases contain tables with
+     * the same name; pass `{ qualified: true }` for `database.schema.table`
+     * names, or use {@link CereusDB.catalog} for full details.
+     */
+    tables(options = {}) {
+        return options.qualified ? this.inner.qualified_tables() : this.inner.tables();
     }
     /** Version string. */
     version() {