@lancedb/lancedb 0.5.0 → 0.5.2

package/dist/query.js

@@ -14,7 +14,7 @@
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Query = exports.VectorQuery = exports.QueryBase = exports.RecordBatchIterator = void 0;
-const apache_arrow_1 = require("apache-arrow");
+const arrow_1 = require("./arrow");
 class RecordBatchIterator {
     promisedInner;
     inner;
@@ -34,7 +34,7 @@ class RecordBatchIterator {
         if (n == null) {
             return Promise.resolve({ done: true, value: null });
         }
-        const tbl = (0, apache_arrow_1.tableFromIPC)(n);
+        const tbl = (0, arrow_1.tableFromIPC)(n);
         if (tbl.batches.length != 1) {
             throw new Error("Expected only one batch");
         }
@@ -43,6 +43,18 @@ class RecordBatchIterator {
 }
 exports.RecordBatchIterator = RecordBatchIterator;
 /* eslint-enable */
+class RecordBatchIterable {
+    inner;
+    options;
+    constructor(inner, options) {
+        this.inner = inner;
+        this.options = options;
+    }
+    // biome-ignore lint/suspicious/noExplicitAny: skip
+    [Symbol.asyncIterator]() {
+        return new RecordBatchIterator(this.inner.execute(this.options?.maxBatchLength));
+    }
+}
 /** Common methods supported by all query types */
 class QueryBase {
     inner;
@@ -98,6 +110,9 @@ class QueryBase {
      */
     select(columns) {
         let columnTuples;
+        if (typeof columns === "string") {
+            columns = [columns];
+        }
         if (Array.isArray(columns)) {
             columnTuples = columns.map((c) => [c, c]);
         }
@@ -120,8 +135,8 @@ class QueryBase {
         this.inner.limit(limit);
         return this;
     }
-    nativeExecute() {
-        return this.inner.execute();
+    nativeExecute(options) {
+        return this.inner.execute(options?.maxBatchLength);
     }
     /**
      * Execute the query and return the results as an @see {@link AsyncIterator}
@@ -134,8 +149,8 @@ class QueryBase {
      * single query)
      *
      */
-    execute() {
-        return new RecordBatchIterator(this.nativeExecute());
+    execute(options) {
+        return new RecordBatchIterator(this.nativeExecute(options));
     }
     // biome-ignore lint/suspicious/noExplicitAny: skip
     [Symbol.asyncIterator]() {
@@ -143,17 +158,17 @@ class QueryBase {
         return new RecordBatchIterator(promise);
     }
     /** Collect the results as an Arrow @see {@link ArrowTable}. */
-    async toArrow() {
+    async toArrow(options) {
         const batches = [];
-        for await (const batch of this) {
+        for await (const batch of new RecordBatchIterable(this.inner, options)) {
             batches.push(batch);
         }
-        return new apache_arrow_1.Table(batches);
+        return new arrow_1.Table(batches);
     }
     /** Collect the results as an array of objects. */
-    async toArray() {
-        const tbl = await this.toArrow();
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    // biome-ignore lint/suspicious/noExplicitAny: arrow.toArrow() returns any[]
+    async toArray(options) {
+        const tbl = await this.toArrow(options);
         return tbl.toArray();
     }
 }
@@ -339,7 +354,6 @@ class Query extends QueryBase {
      * a default `limit` of 10 will be used.  @see {@link Query#limit}
      */
     nearestTo(vector) {
-        // biome-ignore lint/suspicious/noExplicitAny: skip
         const vectorQuery = this.inner.nearestTo(Float32Array.from(vector));
         return new VectorQuery(vectorQuery);
     }

package/dist/sanitize.d.ts

@@ -1,4 +1,25 @@
-import { Schema } from "apache-arrow";
+import type { TKeys } from "apache-arrow/type";
+import { DataType, Date_, Decimal, DenseUnion, Dictionary, Duration, Field, FixedSizeBinary, FixedSizeList, Float, Int, Interval, List, Map_, Schema, SparseUnion, Struct, Time, Timestamp, TimestampMicrosecond, TimestampMillisecond, TimestampNanosecond, TimestampSecond, Type, Union } from "./arrow";
+export declare function sanitizeMetadata(metadataLike?: unknown): Map<string, string> | undefined;
+export declare function sanitizeInt(typeLike: object): Int<Type.Int | Type.Int8 | Type.Int16 | Type.Int32 | Type.Int64 | Type.Uint8 | Type.Uint16 | Type.Uint32 | Type.Uint64>;
+export declare function sanitizeFloat(typeLike: object): Float<Type.Float | Type.Float16 | Type.Float32 | Type.Float64>;
+export declare function sanitizeDecimal(typeLike: object): Decimal;
+export declare function sanitizeDate(typeLike: object): Date_<import("apache-arrow/type").Dates>;
+export declare function sanitizeTime(typeLike: object): Time<Type.Time | Type.TimeSecond | Type.TimeMillisecond | Type.TimeMicrosecond | Type.TimeNanosecond>;
+export declare function sanitizeTimestamp(typeLike: object): Timestamp<Type.Timestamp | Type.TimestampSecond | Type.TimestampMillisecond | Type.TimestampMicrosecond | Type.TimestampNanosecond>;
+export declare function sanitizeTypedTimestamp(typeLike: object, Datatype: typeof TimestampNanosecond | typeof TimestampMicrosecond | typeof TimestampMillisecond | typeof TimestampSecond): TimestampSecond | TimestampMillisecond | TimestampMicrosecond | TimestampNanosecond;
+export declare function sanitizeInterval(typeLike: object): Interval<Type.Interval | Type.IntervalDayTime | Type.IntervalYearMonth>;
+export declare function sanitizeList(typeLike: object): List<any>;
+export declare function sanitizeStruct(typeLike: object): Struct<any>;
+export declare function sanitizeUnion(typeLike: object): Union<Type.Union | Type.DenseUnion | Type.SparseUnion>;
+export declare function sanitizeTypedUnion(typeLike: object, UnionType: typeof DenseUnion | typeof SparseUnion): SparseUnion | DenseUnion;
+export declare function sanitizeFixedSizeBinary(typeLike: object): FixedSizeBinary;
+export declare function sanitizeFixedSizeList(typeLike: object): FixedSizeList<any>;
+export declare function sanitizeMap(typeLike: object): Map_<any, any>;
+export declare function sanitizeDuration(typeLike: object): Duration<Type.Duration | Type.DurationSecond | Type.DurationMillisecond | Type.DurationMicrosecond | Type.DurationNanosecond>;
+export declare function sanitizeDictionary(typeLike: object): Dictionary<DataType<any, any>, TKeys>;
+export declare function sanitizeType(typeLike: unknown): DataType<any>;
+export declare function sanitizeField(fieldLike: unknown): Field;
 /**
  * Convert something schemaLike into a Schema instance
  *

package/dist/sanitize.js

@@ -13,15 +13,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sanitizeSchema = void 0;
-// 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
-// even multiple copies of the same version) to be installed at the same
-// time.  However, arrow-js uses instanceof which expected that the input
-// comes from the exact same library instance.  This is not always the case
-// and so we must sanitize the input to ensure that it is compatible.
-const apache_arrow_1 = require("apache-arrow");
+exports.sanitizeSchema = exports.sanitizeField = exports.sanitizeType = exports.sanitizeDictionary = exports.sanitizeDuration = exports.sanitizeMap = exports.sanitizeFixedSizeList = exports.sanitizeFixedSizeBinary = exports.sanitizeTypedUnion = exports.sanitizeUnion = exports.sanitizeStruct = exports.sanitizeList = exports.sanitizeInterval = exports.sanitizeTypedTimestamp = exports.sanitizeTimestamp = exports.sanitizeTime = exports.sanitizeDate = exports.sanitizeDecimal = exports.sanitizeFloat = exports.sanitizeInt = exports.sanitizeMetadata = void 0;
+const arrow_1 = require("./arrow");
 function sanitizeMetadata(metadataLike) {
     if (metadataLike === undefined || metadataLike === null) {
         return undefined;
@@ -36,6 +29,7 @@ function sanitizeMetadata(metadataLike) {
     }
     return metadataLike;
 }
+exports.sanitizeMetadata = sanitizeMetadata;
 function sanitizeInt(typeLike) {
     if (!("bitWidth" in typeLike) ||
         typeof typeLike.bitWidth !== "number" ||
@@ -43,14 +37,16 @@ function sanitizeInt(typeLike) {
         typeof typeLike.isSigned !== "boolean") {
         throw Error("Expected an Int Type to have a `bitWidth` and `isSigned` property");
     }
-    return new apache_arrow_1.Int(typeLike.isSigned, typeLike.bitWidth);
+    return new arrow_1.Int(typeLike.isSigned, typeLike.bitWidth);
 }
+exports.sanitizeInt = sanitizeInt;
 function sanitizeFloat(typeLike) {
     if (!("precision" in typeLike) || typeof typeLike.precision !== "number") {
         throw Error("Expected a Float Type to have a `precision` property");
     }
-    return new apache_arrow_1.Float(typeLike.precision);
+    return new arrow_1.Float(typeLike.precision);
 }
+exports.sanitizeFloat = sanitizeFloat;
 function sanitizeDecimal(typeLike) {
     if (!("scale" in typeLike) ||
         typeof typeLike.scale !== "number" ||
@@ -60,14 +56,16 @@ function sanitizeDecimal(typeLike) {
         typeof typeLike.bitWidth !== "number") {
         throw Error("Expected a Decimal Type to have `scale`, `precision`, and `bitWidth` properties");
     }
-    return new apache_arrow_1.Decimal(typeLike.scale, typeLike.precision, typeLike.bitWidth);
+    return new arrow_1.Decimal(typeLike.scale, typeLike.precision, typeLike.bitWidth);
 }
+exports.sanitizeDecimal = sanitizeDecimal;
 function sanitizeDate(typeLike) {
     if (!("unit" in typeLike) || typeof typeLike.unit !== "number") {
         throw Error("Expected a Date type to have a `unit` property");
     }
-    return new apache_arrow_1.Date_(typeLike.unit);
+    return new arrow_1.Date_(typeLike.unit);
 }
+exports.sanitizeDate = sanitizeDate;
 function sanitizeTime(typeLike) {
     if (!("unit" in typeLike) ||
         typeof typeLike.unit !== "number" ||
@@ -75,8 +73,9 @@ function sanitizeTime(typeLike) {
         typeof typeLike.bitWidth !== "number") {
         throw Error("Expected a Time type to have `unit` and `bitWidth` properties");
     }
-    return new apache_arrow_1.Time(typeLike.unit, typeLike.bitWidth);
+    return new arrow_1.Time(typeLike.unit, typeLike.bitWidth);
 }
+exports.sanitizeTime = sanitizeTime;
 function sanitizeTimestamp(typeLike) {
     if (!("unit" in typeLike) || typeof typeLike.unit !== "number") {
         throw Error("Expected a Timestamp type to have a `unit` property");
@@ -85,8 +84,9 @@ function sanitizeTimestamp(typeLike) {
     if ("timezone" in typeLike && typeof typeLike.timezone === "string") {
         timezone = typeLike.timezone;
     }
-    return new apache_arrow_1.Timestamp(typeLike.unit, timezone);
+    return new arrow_1.Timestamp(typeLike.unit, timezone);
 }
+exports.sanitizeTimestamp = sanitizeTimestamp;
 function sanitizeTypedTimestamp(typeLike, 
 // eslint-disable-next-line @typescript-eslint/naming-convention
 Datatype) {
@@ -96,12 +96,14 @@ Datatype) {
     }
     return new Datatype(timezone);
 }
+exports.sanitizeTypedTimestamp = sanitizeTypedTimestamp;
 function sanitizeInterval(typeLike) {
     if (!("unit" in typeLike) || typeof typeLike.unit !== "number") {
         throw Error("Expected an Interval type to have a `unit` property");
     }
-    return new apache_arrow_1.Interval(typeLike.unit);
+    return new arrow_1.Interval(typeLike.unit);
 }
+exports.sanitizeInterval = sanitizeInterval;
 function sanitizeList(typeLike) {
     if (!("children" in typeLike) || !Array.isArray(typeLike.children)) {
         throw Error("Expected a List type to have an array-like `children` property");
@@ -109,14 +111,16 @@ function sanitizeList(typeLike) {
     if (typeLike.children.length !== 1) {
         throw Error("Expected a List type to have exactly one child");
     }
-    return new apache_arrow_1.List(sanitizeField(typeLike.children[0]));
+    return new arrow_1.List(sanitizeField(typeLike.children[0]));
 }
+exports.sanitizeList = sanitizeList;
 function sanitizeStruct(typeLike) {
     if (!("children" in typeLike) || !Array.isArray(typeLike.children)) {
         throw Error("Expected a Struct type to have an array-like `children` property");
     }
-    return new apache_arrow_1.Struct(typeLike.children.map((child) => sanitizeField(child)));
+    return new arrow_1.Struct(typeLike.children.map((child) => sanitizeField(child)));
 }
+exports.sanitizeStruct = sanitizeStruct;
 function sanitizeUnion(typeLike) {
     if (!("typeIds" in typeLike) ||
         !("mode" in typeLike) ||
@@ -126,10 +130,11 @@ function sanitizeUnion(typeLike) {
     if (!("children" in typeLike) || !Array.isArray(typeLike.children)) {
         throw Error("Expected a Union type to have an array-like `children` property");
     }
-    return new apache_arrow_1.Union(typeLike.mode, 
+    return new arrow_1.Union(typeLike.mode, 
     // biome-ignore lint/suspicious/noExplicitAny: skip
     typeLike.typeIds, typeLike.children.map((child) => sanitizeField(child)));
 }
+exports.sanitizeUnion = sanitizeUnion;
 function sanitizeTypedUnion(typeLike, 
 // eslint-disable-next-line @typescript-eslint/naming-convention
 UnionType) {
@@ -141,12 +146,14 @@ UnionType) {
     }
     return new UnionType(typeLike.typeIds, typeLike.children.map((child) => sanitizeField(child)));
 }
+exports.sanitizeTypedUnion = sanitizeTypedUnion;
 function sanitizeFixedSizeBinary(typeLike) {
     if (!("byteWidth" in typeLike) || typeof typeLike.byteWidth !== "number") {
         throw Error("Expected a FixedSizeBinary type to have a `byteWidth` property");
     }
-    return new apache_arrow_1.FixedSizeBinary(typeLike.byteWidth);
+    return new arrow_1.FixedSizeBinary(typeLike.byteWidth);
 }
+exports.sanitizeFixedSizeBinary = sanitizeFixedSizeBinary;
 function sanitizeFixedSizeList(typeLike) {
     if (!("listSize" in typeLike) || typeof typeLike.listSize !== "number") {
         throw Error("Expected a FixedSizeList type to have a `listSize` property");
@@ -157,8 +164,9 @@ function sanitizeFixedSizeList(typeLike) {
     if (typeLike.children.length !== 1) {
         throw Error("Expected a FixedSizeList type to have exactly one child");
     }
-    return new apache_arrow_1.FixedSizeList(typeLike.listSize, sanitizeField(typeLike.children[0]));
+    return new arrow_1.FixedSizeList(typeLike.listSize, sanitizeField(typeLike.children[0]));
 }
+exports.sanitizeFixedSizeList = sanitizeFixedSizeList;
 function sanitizeMap(typeLike) {
     if (!("children" in typeLike) || !Array.isArray(typeLike.children)) {
         throw Error("Expected a Map type to have an array-like `children` property");
@@ -166,16 +174,18 @@ function sanitizeMap(typeLike) {
     if (!("keysSorted" in typeLike) || typeof typeLike.keysSorted !== "boolean") {
         throw Error("Expected a Map type to have a `keysSorted` property");
     }
-    return new apache_arrow_1.Map_(
+    return new arrow_1.Map_(
     // biome-ignore lint/suspicious/noExplicitAny: skip
     typeLike.children.map((field) => sanitizeField(field)), typeLike.keysSorted);
 }
+exports.sanitizeMap = sanitizeMap;
 function sanitizeDuration(typeLike) {
     if (!("unit" in typeLike) || typeof typeLike.unit !== "number") {
         throw Error("Expected a Duration type to have a `unit` property");
     }
-    return new apache_arrow_1.Duration(typeLike.unit);
+    return new arrow_1.Duration(typeLike.unit);
 }
+exports.sanitizeDuration = sanitizeDuration;
 function sanitizeDictionary(typeLike) {
     if (!("id" in typeLike) || typeof typeLike.id !== "number") {
         throw Error("Expected a Dictionary type to have an `id` property");
@@ -189,8 +199,9 @@ function sanitizeDictionary(typeLike) {
     if (!("isOrdered" in typeLike) || typeof typeLike.isOrdered !== "boolean") {
         throw Error("Expected a Dictionary type to have an `isOrdered` property");
     }
-    return new apache_arrow_1.Dictionary(sanitizeType(typeLike.dictionary), sanitizeType(typeLike.indices), typeLike.id, typeLike.isOrdered);
+    return new arrow_1.Dictionary(sanitizeType(typeLike.dictionary), sanitizeType(typeLike.indices), typeLike.id, typeLike.isOrdered);
 }
+exports.sanitizeDictionary = sanitizeDictionary;
 // biome-ignore lint/suspicious/noExplicitAny: skip
 function sanitizeType(typeLike) {
     if (typeof typeLike !== "object" || typeLike === null) {
@@ -210,110 +221,111 @@ function sanitizeType(typeLike) {
         throw Error("Type's typeId property was not a function or number");
     }
     switch (typeId) {
-        case apache_arrow_1.Type.NONE:
+        case arrow_1.Type.NONE:
             throw Error("Received a Type with a typeId of NONE");
-        case apache_arrow_1.Type.Null:
-            return new apache_arrow_1.Null();
-        case apache_arrow_1.Type.Int:
+        case arrow_1.Type.Null:
+            return new arrow_1.Null();
+        case arrow_1.Type.Int:
             return sanitizeInt(typeLike);
-        case apache_arrow_1.Type.Float:
+        case arrow_1.Type.Float:
             return sanitizeFloat(typeLike);
-        case apache_arrow_1.Type.Binary:
-            return new apache_arrow_1.Binary();
-        case apache_arrow_1.Type.Utf8:
-            return new apache_arrow_1.Utf8();
-        case apache_arrow_1.Type.Bool:
-            return new apache_arrow_1.Bool();
-        case apache_arrow_1.Type.Decimal:
+        case arrow_1.Type.Binary:
+            return new arrow_1.Binary();
+        case arrow_1.Type.Utf8:
+            return new arrow_1.Utf8();
+        case arrow_1.Type.Bool:
+            return new arrow_1.Bool();
+        case arrow_1.Type.Decimal:
             return sanitizeDecimal(typeLike);
-        case apache_arrow_1.Type.Date:
+        case arrow_1.Type.Date:
             return sanitizeDate(typeLike);
-        case apache_arrow_1.Type.Time:
+        case arrow_1.Type.Time:
             return sanitizeTime(typeLike);
-        case apache_arrow_1.Type.Timestamp:
+        case arrow_1.Type.Timestamp:
             return sanitizeTimestamp(typeLike);
-        case apache_arrow_1.Type.Interval:
+        case arrow_1.Type.Interval:
             return sanitizeInterval(typeLike);
-        case apache_arrow_1.Type.List:
+        case arrow_1.Type.List:
             return sanitizeList(typeLike);
-        case apache_arrow_1.Type.Struct:
+        case arrow_1.Type.Struct:
             return sanitizeStruct(typeLike);
-        case apache_arrow_1.Type.Union:
+        case arrow_1.Type.Union:
             return sanitizeUnion(typeLike);
-        case apache_arrow_1.Type.FixedSizeBinary:
+        case arrow_1.Type.FixedSizeBinary:
             return sanitizeFixedSizeBinary(typeLike);
-        case apache_arrow_1.Type.FixedSizeList:
+        case arrow_1.Type.FixedSizeList:
             return sanitizeFixedSizeList(typeLike);
-        case apache_arrow_1.Type.Map:
+        case arrow_1.Type.Map:
             return sanitizeMap(typeLike);
-        case apache_arrow_1.Type.Duration:
+        case arrow_1.Type.Duration:
             return sanitizeDuration(typeLike);
-        case apache_arrow_1.Type.Dictionary:
+        case arrow_1.Type.Dictionary:
             return sanitizeDictionary(typeLike);
-        case apache_arrow_1.Type.Int8:
-            return new apache_arrow_1.Int8();
-        case apache_arrow_1.Type.Int16:
-            return new apache_arrow_1.Int16();
-        case apache_arrow_1.Type.Int32:
-            return new apache_arrow_1.Int32();
-        case apache_arrow_1.Type.Int64:
-            return new apache_arrow_1.Int64();
-        case apache_arrow_1.Type.Uint8:
-            return new apache_arrow_1.Uint8();
-        case apache_arrow_1.Type.Uint16:
-            return new apache_arrow_1.Uint16();
-        case apache_arrow_1.Type.Uint32:
-            return new apache_arrow_1.Uint32();
-        case apache_arrow_1.Type.Uint64:
-            return new apache_arrow_1.Uint64();
-        case apache_arrow_1.Type.Float16:
-            return new apache_arrow_1.Float16();
-        case apache_arrow_1.Type.Float32:
-            return new apache_arrow_1.Float32();
-        case apache_arrow_1.Type.Float64:
-            return new apache_arrow_1.Float64();
-        case apache_arrow_1.Type.DateMillisecond:
-            return new apache_arrow_1.DateMillisecond();
-        case apache_arrow_1.Type.DateDay:
-            return new apache_arrow_1.DateDay();
-        case apache_arrow_1.Type.TimeNanosecond:
-            return new apache_arrow_1.TimeNanosecond();
-        case apache_arrow_1.Type.TimeMicrosecond:
-            return new apache_arrow_1.TimeMicrosecond();
-        case apache_arrow_1.Type.TimeMillisecond:
-            return new apache_arrow_1.TimeMillisecond();
-        case apache_arrow_1.Type.TimeSecond:
-            return new apache_arrow_1.TimeSecond();
-        case apache_arrow_1.Type.TimestampNanosecond:
-            return sanitizeTypedTimestamp(typeLike, apache_arrow_1.TimestampNanosecond);
-        case apache_arrow_1.Type.TimestampMicrosecond:
-            return sanitizeTypedTimestamp(typeLike, apache_arrow_1.TimestampMicrosecond);
-        case apache_arrow_1.Type.TimestampMillisecond:
-            return sanitizeTypedTimestamp(typeLike, apache_arrow_1.TimestampMillisecond);
-        case apache_arrow_1.Type.TimestampSecond:
-            return sanitizeTypedTimestamp(typeLike, apache_arrow_1.TimestampSecond);
-        case apache_arrow_1.Type.DenseUnion:
-            return sanitizeTypedUnion(typeLike, apache_arrow_1.DenseUnion);
-        case apache_arrow_1.Type.SparseUnion:
-            return sanitizeTypedUnion(typeLike, apache_arrow_1.SparseUnion);
-        case apache_arrow_1.Type.IntervalDayTime:
-            return new apache_arrow_1.IntervalDayTime();
-        case apache_arrow_1.Type.IntervalYearMonth:
-            return new apache_arrow_1.IntervalYearMonth();
-        case apache_arrow_1.Type.DurationNanosecond:
-            return new apache_arrow_1.DurationNanosecond();
-        case apache_arrow_1.Type.DurationMicrosecond:
-            return new apache_arrow_1.DurationMicrosecond();
-        case apache_arrow_1.Type.DurationMillisecond:
-            return new apache_arrow_1.DurationMillisecond();
-        case apache_arrow_1.Type.DurationSecond:
-            return new apache_arrow_1.DurationSecond();
+        case arrow_1.Type.Int8:
+            return new arrow_1.Int8();
+        case arrow_1.Type.Int16:
+            return new arrow_1.Int16();
+        case arrow_1.Type.Int32:
+            return new arrow_1.Int32();
+        case arrow_1.Type.Int64:
+            return new arrow_1.Int64();
+        case arrow_1.Type.Uint8:
+            return new arrow_1.Uint8();
+        case arrow_1.Type.Uint16:
+            return new arrow_1.Uint16();
+        case arrow_1.Type.Uint32:
+            return new arrow_1.Uint32();
+        case arrow_1.Type.Uint64:
+            return new arrow_1.Uint64();
+        case arrow_1.Type.Float16:
+            return new arrow_1.Float16();
+        case arrow_1.Type.Float32:
+            return new arrow_1.Float32();
+        case arrow_1.Type.Float64:
+            return new arrow_1.Float64();
+        case arrow_1.Type.DateMillisecond:
+            return new arrow_1.DateMillisecond();
+        case arrow_1.Type.DateDay:
+            return new arrow_1.DateDay();
+        case arrow_1.Type.TimeNanosecond:
+            return new arrow_1.TimeNanosecond();
+        case arrow_1.Type.TimeMicrosecond:
+            return new arrow_1.TimeMicrosecond();
+        case arrow_1.Type.TimeMillisecond:
+            return new arrow_1.TimeMillisecond();
+        case arrow_1.Type.TimeSecond:
+            return new arrow_1.TimeSecond();
+        case arrow_1.Type.TimestampNanosecond:
+            return sanitizeTypedTimestamp(typeLike, arrow_1.TimestampNanosecond);
+        case arrow_1.Type.TimestampMicrosecond:
+            return sanitizeTypedTimestamp(typeLike, arrow_1.TimestampMicrosecond);
+        case arrow_1.Type.TimestampMillisecond:
+            return sanitizeTypedTimestamp(typeLike, arrow_1.TimestampMillisecond);
+        case arrow_1.Type.TimestampSecond:
+            return sanitizeTypedTimestamp(typeLike, arrow_1.TimestampSecond);
+        case arrow_1.Type.DenseUnion:
+            return sanitizeTypedUnion(typeLike, arrow_1.DenseUnion);
+        case arrow_1.Type.SparseUnion:
+            return sanitizeTypedUnion(typeLike, arrow_1.SparseUnion);
+        case arrow_1.Type.IntervalDayTime:
+            return new arrow_1.IntervalDayTime();
+        case arrow_1.Type.IntervalYearMonth:
+            return new arrow_1.IntervalYearMonth();
+        case arrow_1.Type.DurationNanosecond:
+            return new arrow_1.DurationNanosecond();
+        case arrow_1.Type.DurationMicrosecond:
+            return new arrow_1.DurationMicrosecond();
+        case arrow_1.Type.DurationMillisecond:
+            return new arrow_1.DurationMillisecond();
+        case arrow_1.Type.DurationSecond:
+            return new arrow_1.DurationSecond();
         default:
             throw new Error("Unrecoginized type id in schema: " + typeId);
     }
 }
+exports.sanitizeType = sanitizeType;
 function sanitizeField(fieldLike) {
-    if (fieldLike instanceof apache_arrow_1.Field) {
+    if (fieldLike instanceof arrow_1.Field) {
         return fieldLike;
     }
     if (typeof fieldLike !== "object" || fieldLike === null) {
@@ -337,8 +349,9 @@ function sanitizeField(fieldLike) {
     if ("metadata" in fieldLike) {
         metadata = sanitizeMetadata(fieldLike.metadata);
     }
-    return new apache_arrow_1.Field(name, type, nullable, metadata);
+    return new arrow_1.Field(name, type, nullable, metadata);
 }
+exports.sanitizeField = sanitizeField;
 /**
  * Convert something schemaLike into a Schema instance
  *
@@ -347,7 +360,7 @@ function sanitizeField(fieldLike) {
  * than lancedb is using.
  */
 function sanitizeSchema(schemaLike) {
-    if (schemaLike instanceof apache_arrow_1.Schema) {
+    if (schemaLike instanceof arrow_1.Schema) {
         return schemaLike;
     }
     if (typeof schemaLike !== "object" || schemaLike === null) {
@@ -364,6 +377,6 @@ function sanitizeSchema(schemaLike) {
         throw Error("The schema passed in had a 'fields' property but it was not an array");
     }
     const sanitizedFields = schemaLike.fields.map((field) => sanitizeField(field));
-    return new apache_arrow_1.Schema(sanitizedFields, metadata);
+    return new arrow_1.Schema(sanitizedFields, metadata);
 }
 exports.sanitizeSchema = sanitizeSchema;

package/dist/table.d.ts

@@ -1,5 +1,4 @@
-import { Schema } from "apache-arrow";
-import { Data } from "./arrow";
+import { Table as ArrowTable, Data, IntoVector, Schema } from "./arrow";
 import { IndexOptions } from "./indices";
 import { AddColumnsSql, ColumnAlteration, IndexConfig, OptimizeStats, Table as _NativeTable } from "./native";
 import { Query, VectorQuery } from "./query";
@@ -57,6 +56,7 @@ export interface OptimizeOptions {
  * collected.
  */
 export declare class Table {
+    #private;
     private readonly inner;
     /** Construct a Table. Internal use only. */
     constructor(inner: _NativeTable);
@@ -187,6 +187,19 @@ export declare class Table {
      * @returns {Query} A builder that can be used to parameterize the query
      */
     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
+     */
+    search(query: string): Promise<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;
     /**
      * Search the table with a given query vector.
      *
@@ -194,7 +207,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: unknown): VectorQuery;
+    vectorSearch(vector: IntoVector): VectorQuery;
     /**
      * Add new columns with defined values.
      * @param {AddColumnsSql[]} newColumnTransforms pairs of column names and
@@ -302,4 +315,6 @@ export declare class Table {
     optimize(options?: Partial<OptimizeOptions>): Promise<OptimizeStats>;
     /** List all indices that have been created with {@link Table.createIndex} */
     listIndices(): Promise<IndexConfig[]>;
+    /** Return the table as an arrow table */
+    toArrow(): Promise<ArrowTable>;
 }

package/dist/table.js

@@ -14,8 +14,8 @@
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Table = void 0;
-const apache_arrow_1 = require("apache-arrow");
 const arrow_1 = require("./arrow");
+const registry_1 = require("./embedding/registry");
 const query_1 = require("./query");
 /**
  * A Table is a collection of Records in a LanceDB Database.
@@ -53,10 +53,15 @@ class Table {
     display() {
         return this.inner.display();
     }
+    async #getEmbeddingFunctions() {
+        const schema = await this.schema();
+        const registry = (0, registry_1.getRegistry)();
+        return registry.parseFunctions(schema.metadata);
+    }
     /** Get the schema of the table. */
     async schema() {
         const schemaBuf = await this.inner.schema();
-        const tbl = (0, apache_arrow_1.tableFromIPC)(schemaBuf);
+        const tbl = (0, arrow_1.tableFromIPC)(schemaBuf);
         return tbl.schema;
     }
     /**
@@ -65,7 +70,10 @@ class Table {
      */
     async add(data, options) {
         const mode = options?.mode ?? "append";
-        const buffer = await (0, arrow_1.fromDataToBuffer)(data);
+        const schema = await this.schema();
+        const registry = (0, registry_1.getRegistry)();
+        const functions = registry.parseFunctions(schema.metadata);
+        const buffer = await (0, arrow_1.fromDataToBuffer)(data, functions.values().next().value, schema);
         await this.inner.add(buffer, mode);
     }
     /**
@@ -197,6 +205,24 @@ class Table {
     query() {
         return new query_1.Query(this.inner);
     }
+    search(query) {
+        if (typeof query !== "string") {
+            return this.vectorSearch(query);
+        }
+        else {
+            return this.#getEmbeddingFunctions().then(async (functions) => {
+                // TODO: Support multiple embedding functions
+                const embeddingFunc = functions
+                    .values()
+                    .next().value;
+                if (!embeddingFunc) {
+                    return Promise.reject(new Error("No embedding functions are defined in the table"));
+                }
+                const embeddings = await embeddingFunc.function.computeQueryEmbeddings(query);
+                return this.query().nearestTo(embeddings);
+            });
+        }
+    }
     /**
      * Search the table with a given query vector.
      *
@@ -339,5 +365,9 @@ class Table {
     async listIndices() {
         return await this.inner.listIndices();
     }
+    /** Return the table as an arrow table */
+    async toArrow() {
+        return await this.query().toArrow();
+    }
 }
 exports.Table = Table;