@lancedb/lancedb 0.22.2-beta.2 → 0.22.3-beta.0

package/dist/arrow.d.ts

@@ -11,7 +11,7 @@ export type SchemaLike = Schema | {
 export type FieldLike = Field | {
     type: string;
     name: string;
-    nullable?: boolean;
+    nullable: boolean;
     metadata?: Map<string, string>;
 };
 export type DataLike = import("apache-arrow").Data<Struct<any>> | {

package/dist/index.d.ts

@@ -2,16 +2,17 @@ import { Connection } from "./connection";
 import { ConnectionOptions, Session } from "./native.js";
 import { HeaderProvider } from "./header";
 export { JsHeaderProvider as NativeJsHeaderProvider } from "./native.js";
-export { AddColumnsSql, ConnectionOptions, IndexStatistics, IndexConfig, ClientConfig, TimeoutConfig, RetryConfig, TlsConfig, OptimizeStats, CompactionStats, RemovalStats, TableStatistics, FragmentStatistics, FragmentSummaryStats, Tags, TagContents, MergeResult, AddResult, AddColumnsResult, AlterColumnsResult, DeleteResult, DropColumnsResult, UpdateResult, } from "./native.js";
+export { AddColumnsSql, ConnectionOptions, IndexStatistics, IndexConfig, ClientConfig, TimeoutConfig, RetryConfig, TlsConfig, OptimizeStats, CompactionStats, RemovalStats, TableStatistics, FragmentStatistics, FragmentSummaryStats, Tags, TagContents, MergeResult, AddResult, AddColumnsResult, AlterColumnsResult, DeleteResult, DropColumnsResult, UpdateResult, SplitRandomOptions, SplitHashOptions, SplitSequentialOptions, ShuffleOptions, } from "./native.js";
 export { makeArrowTable, MakeArrowTableOptions, Data, VectorColumnOptions, } from "./arrow";
 export { Connection, CreateTableOptions, TableNamesOptions, OpenTableOptions, } from "./connection";
 export { Session } from "./native.js";
 export { ExecutableQuery, Query, QueryBase, VectorQuery, TakeQuery, QueryExecutionOptions, FullTextSearchOptions, RecordBatchIterator, FullTextQuery, MatchQuery, PhraseQuery, BoostQuery, MultiMatchQuery, BooleanQuery, FullTextQueryType, Operator, Occur, } from "./query";
-export { Index, IndexOptions, IvfPqOptions, IvfFlatOptions, HnswPqOptions, HnswSqOptions, FtsOptions, } from "./indices";
+export { Index, IndexOptions, IvfPqOptions, IvfRqOptions, IvfFlatOptions, HnswPqOptions, HnswSqOptions, FtsOptions, } from "./indices";
 export { Table, AddDataOptions, UpdateOptions, OptimizeOptions, Version, ColumnAlteration, } from "./table";
 export { HeaderProvider, StaticHeaderProvider, OAuthHeaderProvider, TokenResponse, } from "./header";
 export { MergeInsertBuilder, WriteExecutionOptions } from "./merge";
 export * as embedding from "./embedding";
+export { permutationBuilder, PermutationBuilder } from "./permutation";
 export * as rerankers from "./rerankers";
 export { SchemaLike, TableLike, FieldLike, RecordBatchLike, DataLike, IntoVector, MultiVector, } from "./arrow";
 export { IntoSql, packBits } from "./util";

package/dist/index.js

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright The LanceDB Authors
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.packBits = exports.rerankers = exports.embedding = exports.MergeInsertBuilder = exports.OAuthHeaderProvider = exports.StaticHeaderProvider = exports.HeaderProvider = exports.Table = exports.Index = exports.Occur = exports.Operator = exports.FullTextQueryType = exports.BooleanQuery = exports.MultiMatchQuery = exports.BoostQuery = exports.PhraseQuery = exports.MatchQuery = exports.RecordBatchIterator = exports.TakeQuery = exports.VectorQuery = exports.QueryBase = exports.Query = exports.Session = exports.Connection = exports.VectorColumnOptions = exports.MakeArrowTableOptions = exports.makeArrowTable = exports.TagContents = exports.Tags = exports.NativeJsHeaderProvider = void 0;
+exports.packBits = exports.rerankers = exports.PermutationBuilder = exports.permutationBuilder = exports.embedding = exports.MergeInsertBuilder = exports.OAuthHeaderProvider = exports.StaticHeaderProvider = exports.HeaderProvider = exports.Table = exports.Index = exports.Occur = exports.Operator = exports.FullTextQueryType = exports.BooleanQuery = exports.MultiMatchQuery = exports.BoostQuery = exports.PhraseQuery = exports.MatchQuery = exports.RecordBatchIterator = exports.TakeQuery = exports.VectorQuery = exports.QueryBase = exports.Query = exports.Session = exports.Connection = exports.VectorColumnOptions = exports.MakeArrowTableOptions = exports.makeArrowTable = exports.TagContents = exports.Tags = exports.NativeJsHeaderProvider = void 0;
 exports.connect = connect;
 const connection_1 = require("./connection");
 const native_js_1 = require("./native.js");
@@ -45,6 +45,9 @@ Object.defineProperty(exports, "OAuthHeaderProvider", { enumerable: true, get: f
 var merge_1 = require("./merge");
 Object.defineProperty(exports, "MergeInsertBuilder", { enumerable: true, get: function () { return merge_1.MergeInsertBuilder; } });
 exports.embedding = require("./embedding");
+var permutation_1 = require("./permutation");
+Object.defineProperty(exports, "permutationBuilder", { enumerable: true, get: function () { return permutation_1.permutationBuilder; } });
+Object.defineProperty(exports, "PermutationBuilder", { enumerable: true, get: function () { return permutation_1.PermutationBuilder; } });
 exports.rerankers = require("./rerankers");
 var util_1 = require("./util");
 Object.defineProperty(exports, "packBits", { enumerable: true, get: function () { return util_1.packBits; } });

package/dist/indices.d.ts

@@ -101,6 +101,72 @@ export interface IvfPqOptions {
      */
     sampleRate?: number;
 }
+export interface IvfRqOptions {
+    /**
+     * The number of IVF partitions to create.
+     *
+     * This value should generally scale with the number of rows in the dataset.
+     * By default the number of partitions is the square root of the number of
+     * rows.
+     *
+     * If this value is too large then the first part of the search (picking the
+     * right partition) will be slow. If this value is too small then the second
+     * part of the search (searching within a partition) will be slow.
+     */
+    numPartitions?: number;
+    /**
+     * Number of bits per dimension for residual quantization.
+     *
+     * This value controls how much each residual component is compressed. The more
+     * bits, the more accurate the index will be but the slower search. Typical values
+     * are small integers; the default is 1 bit per dimension.
+     */
+    numBits?: number;
+    /**
+     * Distance type to use to build the index.
+     *
+     * Default value is "l2".
+     *
+     * This is used when training the index to calculate the IVF partitions
+     * (vectors are grouped in partitions with similar vectors according to this
+     * distance type) and during quantization.
+     *
+     * The distance type used to train an index MUST match the distance type used
+     * to search the index. Failure to do so will yield inaccurate results.
+     *
+     * The following distance types are available:
+     *
+     * "l2" - Euclidean distance.
+     * "cosine" - Cosine distance.
+     * "dot" - Dot product.
+     */
+    distanceType?: "l2" | "cosine" | "dot";
+    /**
+     * Max iterations to train IVF kmeans.
+     *
+     * When training an IVF index we use kmeans to calculate the partitions. This parameter
+     * controls how many iterations of kmeans to run.
+     *
+     * The default value is 50.
+     */
+    maxIterations?: number;
+    /**
+     * The number of vectors, per partition, to sample when training IVF kmeans.
+     *
+     * When an IVF index is trained, we need to calculate partitions. These are groups
+     * of vectors that are similar to each other. To do this we use an algorithm called kmeans.
+     *
+     * Running kmeans on a large dataset can be slow. To speed this up we run kmeans on a
+     * random sample of the data. This parameter controls the size of the sample. The total
+     * number of vectors used to train the index is `sample_rate * num_partitions`.
+     *
+     * Increasing this value might improve the quality of the index but in most cases the
+     * default should be sufficient.
+     *
+     * The default value is 256.
+     */
+    sampleRate?: number;
+}
 /**
  * Options to create an `HNSW_PQ` index
  */
@@ -476,6 +542,23 @@ export declare class Index {
      * currently is also a memory intensive operation.
      */
     static ivfPq(options?: Partial<IvfPqOptions>): Index;
+    /**
+     * Create an IvfRq index
+     *
+     * IVF-RQ (RabitQ Quantization) compresses vectors using RabitQ quantization
+     * and organizes them into IVF partitions.
+     *
+     * The compression scheme is called RabitQ quantization. Each dimension is quantized into a small number of bits.
+     * The parameters `num_bits` and `num_partitions` control this process, providing a tradeoff
+     * between index size (and thus search speed) and index accuracy.
+     *
+     * The partitioning process is called IVF and the `num_partitions` parameter controls how
+     * many groups to create.
+     *
+     * Note that training an IVF RQ index on a large dataset is a slow operation and
+     * currently is also a memory intensive operation.
+     */
+    static ivfRq(options?: Partial<IvfRqOptions>): Index;
     /**
      * Create an IvfFlat index
      *

package/dist/indices.js

@@ -32,7 +32,26 @@ class Index {
      * currently is also a memory intensive operation.
      */
     static ivfPq(options) {
-        return new Index(native_1.Index.ivfPq(options?.distanceType, options?.numPartitions, options?.numSubVectors, options?.maxIterations, options?.sampleRate));
+        return new Index(native_1.Index.ivfPq(options?.distanceType, options?.numPartitions, options?.numSubVectors, options?.numBits, options?.maxIterations, options?.sampleRate));
+    }
+    /**
+     * Create an IvfRq index
+     *
+     * IVF-RQ (RabitQ Quantization) compresses vectors using RabitQ quantization
+     * and organizes them into IVF partitions.
+     *
+     * The compression scheme is called RabitQ quantization. Each dimension is quantized into a small number of bits.
+     * The parameters `num_bits` and `num_partitions` control this process, providing a tradeoff
+     * between index size (and thus search speed) and index accuracy.
+     *
+     * The partitioning process is called IVF and the `num_partitions` parameter controls how
+     * many groups to create.
+     *
+     * Note that training an IVF RQ index on a large dataset is a slow operation and
+     * currently is also a memory intensive operation.
+     */
+    static ivfRq(options) {
+        return new Index(native_1.Index.ivfRq(options?.distanceType, options?.numPartitions, options?.numBits, options?.maxIterations, options?.sampleRate));
     }
     /**
      * Create an IvfFlat index

package/dist/native.d.ts

@@ -3,6 +3,28 @@
 
 /* auto-generated by NAPI-RS */
 
+export interface SplitRandomOptions {
+  ratios?: Array<number>
+  counts?: Array<number>
+  fixed?: number
+  seed?: number
+}
+export interface SplitHashOptions {
+  columns: Array<string>
+  splitWeights: Array<number>
+  discardWeight?: number
+}
+export interface SplitSequentialOptions {
+  ratios?: Array<number>
+  counts?: Array<number>
+  fixed?: number
+}
+export interface ShuffleOptions {
+  seed?: number
+  clumpSize?: number
+}
+/** Create a permutation builder for the given table */
+export declare function permutationBuilder(table: Table, destTableName: string): PermutationBuilder
 /** Timeout configuration for remote HTTP client. */
 export interface TimeoutConfig {
   /**
@@ -357,6 +379,7 @@ export class JsHeaderProvider {
 }
 export class Index {
   static ivfPq(distanceType?: string | undefined | null, numPartitions?: number | undefined | null, numSubVectors?: number | undefined | null, numBits?: number | undefined | null, maxIterations?: number | undefined | null, sampleRate?: number | undefined | null): Index
+  static ivfRq(distanceType?: string | undefined | null, numPartitions?: number | undefined | null, numBits?: number | undefined | null, maxIterations?: number | undefined | null, sampleRate?: number | undefined | null): Index
   static ivfFlat(distanceType?: string | undefined | null, numPartitions?: number | undefined | null, maxIterations?: number | undefined | null, sampleRate?: number | undefined | null): Index
   static btree(): Index
   static bitmap(): Index
@@ -378,6 +401,22 @@ export class NativeMergeInsertBuilder {
   useIndex(useIndex: boolean): NativeMergeInsertBuilder
   execute(buf: Buffer): Promise<MergeResult>
 }
+export class PermutationBuilder {
+  /** Configure random splits */
+  splitRandom(options: SplitRandomOptions): PermutationBuilder
+  /** Configure hash-based splits */
+  splitHash(options: SplitHashOptions): PermutationBuilder
+  /** Configure sequential splits */
+  splitSequential(options: SplitSequentialOptions): PermutationBuilder
+  /** Configure calculated splits */
+  splitCalculated(calculation: string): PermutationBuilder
+  /** Configure shuffling */
+  shuffle(options: ShuffleOptions): PermutationBuilder
+  /** Configure filtering */
+  filter(filter: string): PermutationBuilder
+  /** Execute the permutation builder and create the table */
+  execute(): Promise<Table>
+}
 export class Query {
   onlyIf(predicate: string): void
   fullTextSearch(query: object): void

package/dist/native.js

@@ -319,12 +319,14 @@ if (!nativeBinding) {
     }
     throw new Error(`Failed to load native binding`);
 }
-const { Connection, JsHeaderProvider, Index, RecordBatchIterator, NativeMergeInsertBuilder, Query, VectorQuery, TakeQuery, JsFullTextQuery, Reranker, RrfReranker, Session, Table, TagContents, Tags } = nativeBinding;
+const { Connection, JsHeaderProvider, Index, RecordBatchIterator, NativeMergeInsertBuilder, PermutationBuilder, permutationBuilder, Query, VectorQuery, TakeQuery, JsFullTextQuery, Reranker, RrfReranker, Session, Table, TagContents, Tags } = nativeBinding;
 module.exports.Connection = Connection;
 module.exports.JsHeaderProvider = JsHeaderProvider;
 module.exports.Index = Index;
 module.exports.RecordBatchIterator = RecordBatchIterator;
 module.exports.NativeMergeInsertBuilder = NativeMergeInsertBuilder;
+module.exports.PermutationBuilder = PermutationBuilder;
+module.exports.permutationBuilder = permutationBuilder;
 module.exports.Query = Query;
 module.exports.VectorQuery = VectorQuery;
 module.exports.TakeQuery = TakeQuery;

package/dist/permutation.d.ts

@@ -0,0 +1,131 @@
+import { PermutationBuilder as NativePermutationBuilder, ShuffleOptions, SplitHashOptions, SplitRandomOptions, SplitSequentialOptions } from "./native.js";
+import { Table } from "./table";
+/**
+ * A PermutationBuilder for creating data permutations with splits, shuffling, and filtering.
+ *
+ * This class provides a TypeScript wrapper around the native Rust PermutationBuilder,
+ * offering methods to configure data splits, shuffling, and filtering before executing
+ * the permutation to create a new table.
+ */
+export declare class PermutationBuilder {
+    private inner;
+    /**
+     * @hidden
+     */
+    constructor(inner: NativePermutationBuilder);
+    /**
+     * Configure random splits for the permutation.
+     *
+     * @param options - Configuration for random splitting
+     * @returns A new PermutationBuilder instance
+     * @example
+     * ```ts
+     * // Split by ratios
+     * builder.splitRandom({ ratios: [0.7, 0.3], seed: 42 });
+     *
+     * // Split by counts
+     * builder.splitRandom({ counts: [1000, 500], seed: 42 });
+     *
+     * // Split with fixed size
+     * builder.splitRandom({ fixed: 100, seed: 42 });
+     * ```
+     */
+    splitRandom(options: SplitRandomOptions): PermutationBuilder;
+    /**
+     * Configure hash-based splits for the permutation.
+     *
+     * @param options - Configuration for hash-based splitting
+     * @returns A new PermutationBuilder instance
+     * @example
+     * ```ts
+     * builder.splitHash({
+     *   columns: ["user_id"],
+     *   splitWeights: [70, 30],
+     *   discardWeight: 0
+     * });
+     * ```
+     */
+    splitHash(options: SplitHashOptions): PermutationBuilder;
+    /**
+     * Configure sequential splits for the permutation.
+     *
+     * @param options - Configuration for sequential splitting
+     * @returns A new PermutationBuilder instance
+     * @example
+     * ```ts
+     * // Split by ratios
+     * builder.splitSequential({ ratios: [0.8, 0.2] });
+     *
+     * // Split by counts
+     * builder.splitSequential({ counts: [800, 200] });
+     *
+     * // Split with fixed size
+     * builder.splitSequential({ fixed: 1000 });
+     * ```
+     */
+    splitSequential(options: SplitSequentialOptions): PermutationBuilder;
+    /**
+     * Configure calculated splits for the permutation.
+     *
+     * @param calculation - SQL expression for calculating splits
+     * @returns A new PermutationBuilder instance
+     * @example
+     * ```ts
+     * builder.splitCalculated("user_id % 3");
+     * ```
+     */
+    splitCalculated(calculation: string): PermutationBuilder;
+    /**
+     * Configure shuffling for the permutation.
+     *
+     * @param options - Configuration for shuffling
+     * @returns A new PermutationBuilder instance
+     * @example
+     * ```ts
+     * // Basic shuffle
+     * builder.shuffle({ seed: 42 });
+     *
+     * // Shuffle with clump size
+     * builder.shuffle({ seed: 42, clumpSize: 10 });
+     * ```
+     */
+    shuffle(options: ShuffleOptions): PermutationBuilder;
+    /**
+     * Configure filtering for the permutation.
+     *
+     * @param filter - SQL filter expression
+     * @returns A new PermutationBuilder instance
+     * @example
+     * ```ts
+     * builder.filter("age > 18 AND status = 'active'");
+     * ```
+     */
+    filter(filter: string): PermutationBuilder;
+    /**
+     * Execute the permutation and create the destination table.
+     *
+     * @returns A Promise that resolves to the new Table instance
+     * @example
+     * ```ts
+     * const permutationTable = await builder.execute();
+     * console.log(`Created table: ${permutationTable.name}`);
+     * ```
+     */
+    execute(): Promise<Table>;
+}
+/**
+ * Create a permutation builder for the given table.
+ *
+ * @param table - The source table to create a permutation from
+ * @param destTableName - The name for the destination permutation table
+ * @returns A PermutationBuilder instance
+ * @example
+ * ```ts
+ * const builder = permutationBuilder(sourceTable, "training_data")
+ *   .splitRandom({ ratios: [0.8, 0.2], seed: 42 })
+ *   .shuffle({ seed: 123 });
+ *
+ * const trainingTable = await builder.execute();
+ * ```
+ */
+export declare function permutationBuilder(table: Table, destTableName: string): PermutationBuilder;

package/dist/permutation.js

@@ -0,0 +1,169 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright The LanceDB Authors
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PermutationBuilder = void 0;
+exports.permutationBuilder = permutationBuilder;
+const native_js_1 = require("./native.js");
+const table_1 = require("./table");
+/**
+ * A PermutationBuilder for creating data permutations with splits, shuffling, and filtering.
+ *
+ * This class provides a TypeScript wrapper around the native Rust PermutationBuilder,
+ * offering methods to configure data splits, shuffling, and filtering before executing
+ * the permutation to create a new table.
+ */
+class PermutationBuilder {
+    inner;
+    /**
+     * @hidden
+     */
+    constructor(inner) {
+        this.inner = inner;
+    }
+    /**
+     * Configure random splits for the permutation.
+     *
+     * @param options - Configuration for random splitting
+     * @returns A new PermutationBuilder instance
+     * @example
+     * ```ts
+     * // Split by ratios
+     * builder.splitRandom({ ratios: [0.7, 0.3], seed: 42 });
+     *
+     * // Split by counts
+     * builder.splitRandom({ counts: [1000, 500], seed: 42 });
+     *
+     * // Split with fixed size
+     * builder.splitRandom({ fixed: 100, seed: 42 });
+     * ```
+     */
+    splitRandom(options) {
+        const newInner = this.inner.splitRandom(options);
+        return new PermutationBuilder(newInner);
+    }
+    /**
+     * Configure hash-based splits for the permutation.
+     *
+     * @param options - Configuration for hash-based splitting
+     * @returns A new PermutationBuilder instance
+     * @example
+     * ```ts
+     * builder.splitHash({
+     *   columns: ["user_id"],
+     *   splitWeights: [70, 30],
+     *   discardWeight: 0
+     * });
+     * ```
+     */
+    splitHash(options) {
+        const newInner = this.inner.splitHash(options);
+        return new PermutationBuilder(newInner);
+    }
+    /**
+     * Configure sequential splits for the permutation.
+     *
+     * @param options - Configuration for sequential splitting
+     * @returns A new PermutationBuilder instance
+     * @example
+     * ```ts
+     * // Split by ratios
+     * builder.splitSequential({ ratios: [0.8, 0.2] });
+     *
+     * // Split by counts
+     * builder.splitSequential({ counts: [800, 200] });
+     *
+     * // Split with fixed size
+     * builder.splitSequential({ fixed: 1000 });
+     * ```
+     */
+    splitSequential(options) {
+        const newInner = this.inner.splitSequential(options);
+        return new PermutationBuilder(newInner);
+    }
+    /**
+     * Configure calculated splits for the permutation.
+     *
+     * @param calculation - SQL expression for calculating splits
+     * @returns A new PermutationBuilder instance
+     * @example
+     * ```ts
+     * builder.splitCalculated("user_id % 3");
+     * ```
+     */
+    splitCalculated(calculation) {
+        const newInner = this.inner.splitCalculated(calculation);
+        return new PermutationBuilder(newInner);
+    }
+    /**
+     * Configure shuffling for the permutation.
+     *
+     * @param options - Configuration for shuffling
+     * @returns A new PermutationBuilder instance
+     * @example
+     * ```ts
+     * // Basic shuffle
+     * builder.shuffle({ seed: 42 });
+     *
+     * // Shuffle with clump size
+     * builder.shuffle({ seed: 42, clumpSize: 10 });
+     * ```
+     */
+    shuffle(options) {
+        const newInner = this.inner.shuffle(options);
+        return new PermutationBuilder(newInner);
+    }
+    /**
+     * Configure filtering for the permutation.
+     *
+     * @param filter - SQL filter expression
+     * @returns A new PermutationBuilder instance
+     * @example
+     * ```ts
+     * builder.filter("age > 18 AND status = 'active'");
+     * ```
+     */
+    filter(filter) {
+        const newInner = this.inner.filter(filter);
+        return new PermutationBuilder(newInner);
+    }
+    /**
+     * Execute the permutation and create the destination table.
+     *
+     * @returns A Promise that resolves to the new Table instance
+     * @example
+     * ```ts
+     * const permutationTable = await builder.execute();
+     * console.log(`Created table: ${permutationTable.name}`);
+     * ```
+     */
+    async execute() {
+        const nativeTable = await this.inner.execute();
+        return new table_1.LocalTable(nativeTable);
+    }
+}
+exports.PermutationBuilder = PermutationBuilder;
+/**
+ * Create a permutation builder for the given table.
+ *
+ * @param table - The source table to create a permutation from
+ * @param destTableName - The name for the destination permutation table
+ * @returns A PermutationBuilder instance
+ * @example
+ * ```ts
+ * const builder = permutationBuilder(sourceTable, "training_data")
+ *   .splitRandom({ ratios: [0.8, 0.2], seed: 42 })
+ *   .shuffle({ seed: 123 });
+ *
+ * const trainingTable = await builder.execute();
+ * ```
+ */
+function permutationBuilder(table, destTableName) {
+    // Extract the inner native table from the TypeScript wrapper
+    const localTable = table;
+    // Access inner through type assertion since it's private
+    const nativeBuilder = (0, native_js_1.permutationBuilder)(
+    // biome-ignore lint/suspicious/noExplicitAny: need access to private variable
+    localTable.inner, destTableName);
+    return new PermutationBuilder(nativeBuilder);
+}

package/dist/sanitize.d.ts

@@ -29,3 +29,4 @@ export declare function sanitizeField(fieldLike: unknown): Field;
  */
 export declare function sanitizeSchema(schemaLike: SchemaLike): Schema;
 export declare function sanitizeTable(tableLike: TableLike): Table;
+export declare function dataTypeFromName(typeName: string): DataType;

package/dist/sanitize.js

@@ -24,6 +24,7 @@ exports.sanitizeType = sanitizeType;
 exports.sanitizeField = sanitizeField;
 exports.sanitizeSchema = sanitizeSchema;
 exports.sanitizeTable = sanitizeTable;
+exports.dataTypeFromName = dataTypeFromName;
 // The utilities in this file help sanitize data from the user's arrow
 // library into the types expected by vectordb's arrow library.  Node
 // generally allows for mulitple versions of the same library (and sometimes
@@ -204,6 +205,9 @@ function sanitizeDictionary(typeLike) {
 }
 // biome-ignore lint/suspicious/noExplicitAny: skip
 function sanitizeType(typeLike) {
+    if (typeof typeLike === "string") {
+        return dataTypeFromName(typeLike);
+    }
     if (typeof typeLike !== "object" || typeLike === null) {
         throw Error("Expected a Type but object was null/undefined");
     }
@@ -322,7 +326,7 @@ function sanitizeType(typeLike) {
         case arrow_1.Type.DurationSecond:
             return new arrow_1.DurationSecond();
         default:
-            throw new Error("Unrecoginized type id in schema: " + typeId);
+            throw new Error("Unrecognized type id in schema: " + typeId);
     }
 }
 function sanitizeField(fieldLike) {
@@ -337,7 +341,13 @@ function sanitizeField(fieldLike) {
         !("nullable" in fieldLike)) {
         throw Error("The field passed in is missing a `type`/`name`/`nullable` property");
     }
-    const type = sanitizeType(fieldLike.type);
+    let type;
+    try {
+        type = sanitizeType(fieldLike.type);
+    }
+    catch (error) {
+        throw Error(`Unable to sanitize type for field: ${fieldLike.name} due to error: ${error}`, { cause: error });
+    }
     const name = fieldLike.name;
     if (!(typeof name === "string")) {
         throw Error("The field passed in had a non-string `name` property");
@@ -424,3 +434,40 @@ function sanitizeData(dataLike) {
         [apache_arrow_1.BufferType.TYPE]: dataLike.typeIds,
     });
 }
+const constructorsByTypeName = {
+    null: () => new arrow_1.Null(),
+    binary: () => new arrow_1.Binary(),
+    utf8: () => new arrow_1.Utf8(),
+    bool: () => new arrow_1.Bool(),
+    int8: () => new arrow_1.Int8(),
+    int16: () => new arrow_1.Int16(),
+    int32: () => new arrow_1.Int32(),
+    int64: () => new arrow_1.Int64(),
+    uint8: () => new arrow_1.Uint8(),
+    uint16: () => new arrow_1.Uint16(),
+    uint32: () => new arrow_1.Uint32(),
+    uint64: () => new arrow_1.Uint64(),
+    float16: () => new arrow_1.Float16(),
+    float32: () => new arrow_1.Float32(),
+    float64: () => new arrow_1.Float64(),
+    datemillisecond: () => new arrow_1.DateMillisecond(),
+    dateday: () => new arrow_1.DateDay(),
+    timenanosecond: () => new arrow_1.TimeNanosecond(),
+    timemicrosecond: () => new arrow_1.TimeMicrosecond(),
+    timemillisecond: () => new arrow_1.TimeMillisecond(),
+    timesecond: () => new arrow_1.TimeSecond(),
+    intervaldaytime: () => new arrow_1.IntervalDayTime(),
+    intervalyearmonth: () => new arrow_1.IntervalYearMonth(),
+    durationnanosecond: () => new arrow_1.DurationNanosecond(),
+    durationmicrosecond: () => new arrow_1.DurationMicrosecond(),
+    durationmillisecond: () => new arrow_1.DurationMillisecond(),
+    durationsecond: () => new arrow_1.DurationSecond(),
+};
+function dataTypeFromName(typeName) {
+    const normalizedTypeName = typeName.toLowerCase();
+    const _constructor = constructorsByTypeName[normalizedTypeName];
+    if (!_constructor) {
+        throw new Error("Unrecognized type name in schema: " + typeName);
+    }
+    return _constructor();
+}

package/package.json

@@ -11,7 +11,7 @@
     "ann"
   ],
   "private": false,
-  "version": "0.22.2-beta.2",
+  "version": "0.22.3-beta.0",
   "main": "dist/index.js",
   "exports": {
     ".": "./dist/index.js",
@@ -100,14 +100,14 @@
     "reflect-metadata": "^0.2.2"
   },
   "optionalDependencies": {
-    "@lancedb/lancedb-darwin-x64": "0.22.2-beta.2",
-    "@lancedb/lancedb-darwin-arm64": "0.22.2-beta.2",
-    "@lancedb/lancedb-linux-x64-gnu": "0.22.2-beta.2",
-    "@lancedb/lancedb-linux-arm64-gnu": "0.22.2-beta.2",
-    "@lancedb/lancedb-linux-x64-musl": "0.22.2-beta.2",
-    "@lancedb/lancedb-linux-arm64-musl": "0.22.2-beta.2",
-    "@lancedb/lancedb-win32-x64-msvc": "0.22.2-beta.2",
-    "@lancedb/lancedb-win32-arm64-msvc": "0.22.2-beta.2"
+    "@lancedb/lancedb-darwin-x64": "0.22.3-beta.0",
+    "@lancedb/lancedb-darwin-arm64": "0.22.3-beta.0",
+    "@lancedb/lancedb-linux-x64-gnu": "0.22.3-beta.0",
+    "@lancedb/lancedb-linux-arm64-gnu": "0.22.3-beta.0",
+    "@lancedb/lancedb-linux-x64-musl": "0.22.3-beta.0",
+    "@lancedb/lancedb-linux-arm64-musl": "0.22.3-beta.0",
+    "@lancedb/lancedb-win32-x64-msvc": "0.22.3-beta.0",
+    "@lancedb/lancedb-win32-arm64-msvc": "0.22.3-beta.0"
   },
   "peerDependencies": {
     "apache-arrow": ">=15.0.0 <=18.1.0"