@lancedb/lancedb 0.5.2 → 0.7.0

package/dist/table.d.ts

@@ -1,7 +1,11 @@
-import { Table as ArrowTable, Data, IntoVector, Schema } from "./arrow";
+/// <reference types="node" />
+import { Table as ArrowTable, Data, IntoVector, Schema, TableLike } from "./arrow";
+import { CreateTableOptions } from "./connection";
 import { IndexOptions } from "./indices";
-import { AddColumnsSql, ColumnAlteration, IndexConfig, OptimizeStats, Table as _NativeTable } from "./native";
+import { MergeInsertBuilder } from "./merge";
+import { AddColumnsSql, ColumnAlteration, IndexConfig, IndexStatistics, OptimizeStats, Table as _NativeTable } from "./native";
 import { Query, VectorQuery } from "./query";
+import { IntoSql } from "./util";
 export { IndexConfig } from "./native";
 /**
  * Options for adding data to a table.
@@ -55,13 +59,11 @@ export interface OptimizeOptions {
  * Closing a table is optional.  It not closed, it will be closed when it is garbage
  * collected.
  */
-export declare class Table {
-    #private;
-    private readonly inner;
-    /** Construct a Table. Internal use only. */
-    constructor(inner: _NativeTable);
+export declare abstract class Table {
+    /** Returns the name of the table */
+    abstract get name(): string;
     /** Return true if the table has not been closed */
-    isOpen(): boolean;
+    abstract isOpen(): boolean;
     /**
      * Close the table, releasing any underlying resources.
      *
@@ -69,16 +71,40 @@ export declare class Table {
      *
      * Any attempt to use the table after it is closed will result in an error.
      */
-    close(): void;
+    abstract close(): void;
     /** Return a brief description of the table */
-    display(): string;
+    abstract display(): string;
     /** Get the schema of the table. */
-    schema(): Promise<Schema>;
+    abstract schema(): Promise<Schema>;
     /**
      * Insert records into this Table.
      * @param {Data} data Records to be inserted into the Table
      */
-    add(data: Data, options?: Partial<AddDataOptions>): Promise<void>;
+    abstract add(data: Data, options?: Partial<AddDataOptions>): Promise<void>;
+    /**
+     * Update existing records in the Table
+     * @param opts.values The values to update. The keys are the column names and the values
+     * are the values to set.
+     * @example
+     * ```ts
+     * table.update({where:"x = 2", values:{"vector": [10, 10]}})
+     * ```
+     */
+    abstract update(opts: {
+        values: Map<string, IntoSql> | Record<string, IntoSql>;
+    } & Partial<UpdateOptions>): Promise<void>;
+    /**
+     * Update existing records in the Table
+     * @param opts.valuesSql The values to update. The keys are the column names and the values
+     * are the values to set. The values are SQL expressions.
+     * @example
+     * ```ts
+     * table.update({where:"x = 2", valuesSql:{"x": "x + 1"}})
+     * ```
+     */
+    abstract update(opts: {
+        valuesSql: Map<string, string> | Record<string, string>;
+    } & Partial<UpdateOptions>): Promise<void>;
     /**
      * Update existing records in the Table
      *
@@ -104,11 +130,11 @@ export declare class Table {
      * @param {Partial<UpdateOptions>} options - additional options to control
      * the update behavior
      */
-    update(updates: Map<string, string> | Record<string, string>, options?: Partial<UpdateOptions>): Promise<void>;
+    abstract update(updates: Map<string, string> | Record<string, string>, options?: Partial<UpdateOptions>): Promise<void>;
     /** Count the total number of rows in the dataset. */
-    countRows(filter?: string): Promise<number>;
+    abstract countRows(filter?: string): Promise<number>;
     /** Delete the rows that satisfy the predicate. */
-    delete(predicate: string): Promise<void>;
+    abstract delete(predicate: string): Promise<void>;
     /**
      * Create an index to speed up queries.
      *
@@ -116,6 +142,9 @@ export declare class Table {
      * Indices on vector columns will speed up vector searches.
      * Indices on scalar columns will speed up filtering (in both
      * vector and non-vector searches)
+     *
+     * @note We currently don't support custom named indexes,
+     * The index name will always be `${column}_idx`
      * @example
      * // If the column has a vector (fixed size list) data type then
      * // an IvfPq vector index will be created.
@@ -135,7 +164,7 @@ export declare class Table {
      * // Or create a Scalar index
      * await table.createIndex("my_float_col");
      */
-    createIndex(column: string, options?: Partial<IndexOptions>): Promise<void>;
+    abstract createIndex(column: string, options?: Partial<IndexOptions>): Promise<void>;
     /**
      * Create a {@link Query} Builder.
      *
@@ -186,20 +215,20 @@ export declare class Table {
      * }
      * @returns {Query} A builder that can be used to parameterize the query
      */
-    query(): Query;
+    abstract query(): Query;
     /**
      * Create a search query to find the nearest neighbors
      * of the given query vector
      * @param {string} query - the query. This will be converted to a vector using the table's provided embedding function
-     * @rejects {Error} If no embedding functions are defined in the table
+     * @note  If no embedding functions are defined in the table, this will error when collecting the results.
      */
-    search(query: string): Promise<VectorQuery>;
+    abstract search(query: string): VectorQuery;
     /**
      * Create a search query to find the nearest neighbors
      * of the given query vector
      * @param {IntoVector} query - the query vector
      */
-    search(query: IntoVector): VectorQuery;
+    abstract search(query: IntoVector): VectorQuery;
     /**
      * Search the table with a given query vector.
      *
@@ -207,7 +236,7 @@ export declare class Table {
      * is the same thing as calling `nearestTo` on the builder returned
      * by `query`.  @see {@link Query#nearestTo} for more details.
      */
-    vectorSearch(vector: IntoVector): VectorQuery;
+    abstract vectorSearch(vector: IntoVector): VectorQuery;
     /**
      * Add new columns with defined values.
      * @param {AddColumnsSql[]} newColumnTransforms pairs of column names and
@@ -215,13 +244,13 @@ export declare class Table {
      * expressions will be evaluated for each row in the table, and can
      * reference existing columns in the table.
      */
-    addColumns(newColumnTransforms: AddColumnsSql[]): Promise<void>;
+    abstract addColumns(newColumnTransforms: AddColumnsSql[]): Promise<void>;
     /**
      * Alter the name or nullability of columns.
      * @param {ColumnAlteration[]} columnAlterations One or more alterations to
      * apply to columns.
      */
-    alterColumns(columnAlterations: ColumnAlteration[]): Promise<void>;
+    abstract alterColumns(columnAlterations: ColumnAlteration[]): Promise<void>;
     /**
      * Drop one or more columns from the dataset
      *
@@ -233,9 +262,9 @@ export declare class Table {
      * be nested column references (e.g. "a.b.c") or top-level column names
      * (e.g. "a").
      */
-    dropColumns(columnNames: string[]): Promise<void>;
+    abstract dropColumns(columnNames: string[]): Promise<void>;
     /** Retrieve the version of the table */
-    version(): Promise<number>;
+    abstract version(): Promise<number>;
     /**
      * Checks out a specific version of the table _This is an in-place operation._
      *
@@ -261,14 +290,14 @@ export declare class Table {
      * console.log(await table.version()); // 2
      * ```
      */
-    checkout(version: number): Promise<void>;
+    abstract checkout(version: number): Promise<void>;
     /**
      * Checkout the latest version of the table. _This is an in-place operation._
      *
      * The table will be set back into standard mode, and will track the latest
      * version of the table.
      */
-    checkoutLatest(): Promise<void>;
+    abstract checkoutLatest(): Promise<void>;
     /**
      * Restore the table to the currently checked out version
      *
@@ -281,7 +310,7 @@ export declare class Table {
      * Once the operation concludes the table will no longer be in a checked
      * out state and the read_consistency_interval, if any, will apply.
      */
-    restore(): Promise<void>;
+    abstract restore(): Promise<void>;
     /**
      * Optimize the on-disk data and indices for better performance.
      *
@@ -312,9 +341,55 @@ export declare class Table {
      *  you have added or modified 100,000 or more records or run more than 20 data
      *  modification operations.
      */
-    optimize(options?: Partial<OptimizeOptions>): Promise<OptimizeStats>;
+    abstract optimize(options?: Partial<OptimizeOptions>): Promise<OptimizeStats>;
     /** List all indices that have been created with {@link Table.createIndex} */
-    listIndices(): Promise<IndexConfig[]>;
+    abstract listIndices(): Promise<IndexConfig[]>;
     /** Return the table as an arrow table */
+    abstract toArrow(): Promise<ArrowTable>;
+    abstract mergeInsert(on: string | string[]): MergeInsertBuilder;
+    /** List all the stats of a specified index
+     *
+     * @param {string} name The name of the index.
+     * @returns {IndexStatistics | undefined} The stats of the index. If the index does not exist, it will return undefined
+     */
+    abstract indexStats(name: string): Promise<IndexStatistics | undefined>;
+    static parseTableData(data: Record<string, unknown>[] | TableLike, options?: Partial<CreateTableOptions>, streaming?: boolean): Promise<{
+        buf: Buffer;
+        mode: string;
+    }>;
+}
+export declare class LocalTable extends Table {
+    private readonly inner;
+    constructor(inner: _NativeTable);
+    get name(): string;
+    isOpen(): boolean;
+    close(): void;
+    display(): string;
+    private getEmbeddingFunctions;
+    /** Get the schema of the table. */
+    schema(): Promise<Schema>;
+    add(data: Data, options?: Partial<AddDataOptions>): Promise<void>;
+    update(optsOrUpdates: (Map<string, string> | Record<string, string>) | ({
+        values: Map<string, IntoSql> | Record<string, IntoSql>;
+    } & Partial<UpdateOptions>) | ({
+        valuesSql: Map<string, string> | Record<string, string>;
+    } & Partial<UpdateOptions>), options?: Partial<UpdateOptions>): Promise<void>;
+    countRows(filter?: string): Promise<number>;
+    delete(predicate: string): Promise<void>;
+    createIndex(column: string, options?: Partial<IndexOptions>): Promise<void>;
+    query(): Query;
+    search(query: string | IntoVector): VectorQuery;
+    vectorSearch(vector: IntoVector): VectorQuery;
+    addColumns(newColumnTransforms: AddColumnsSql[]): Promise<void>;
+    alterColumns(columnAlterations: ColumnAlteration[]): Promise<void>;
+    dropColumns(columnNames: string[]): Promise<void>;
+    version(): Promise<number>;
+    checkout(version: number): Promise<void>;
+    checkoutLatest(): Promise<void>;
+    restore(): Promise<void>;
+    optimize(options?: Partial<OptimizeOptions>): Promise<OptimizeStats>;
+    listIndices(): Promise<IndexConfig[]>;
     toArrow(): Promise<ArrowTable>;
+    indexStats(name: string): Promise<IndexStatistics | undefined>;
+    mergeInsert(on: string | string[]): MergeInsertBuilder;
 }