@lancedb/lancedb 0.22.2-beta.1 → 0.22.2

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/arrow.js

@@ -1048,17 +1048,33 @@ function validateSchemaEmbeddings(schema, data, embeddings) {
         if (isFixedSizeList(field.type)) {
             field = (0, sanitize_1.sanitizeField)(field);
             if (data.length !== 0 && data?.[0]?.[field.name] === undefined) {
+                // Check if there's an embedding function registered for this field
+                let hasEmbeddingFunction = false;
+                // Check schema metadata for embedding functions
                 if (schema.metadata.has("embedding_functions")) {
                     const embeddings = JSON.parse(schema.metadata.get("embedding_functions"));
-                    if (
                     // biome-ignore lint/suspicious/noExplicitAny: we don't know the type of `f`
-                    embeddings.find((f) => f["vectorColumn"] === field.name) ===
-                        undefined) {
-                        missingEmbeddingFields.push(field);
+                    if (embeddings.find((f) => f["vectorColumn"] === field.name)) {
+                        hasEmbeddingFunction = true;
                     }
                 }
+                // Check passed embedding function parameter
+                if (embeddings && embeddings.vectorColumn === field.name) {
+                    hasEmbeddingFunction = true;
+                }
+                // If the field is nullable AND there's no embedding function, allow undefined/omitted values
+                if (field.nullable && !hasEmbeddingFunction) {
+                    fields.push(field);
+                }
                 else {
-                    missingEmbeddingFields.push(field);
+                    // Either not nullable OR has embedding function - require explicit values
+                    if (hasEmbeddingFunction) {
+                        // Don't add to missingEmbeddingFields since this is expected to be filled by embedding function
+                        fields.push(field);
+                    }
+                    else {
+                        missingEmbeddingFields.push(field);
+                    }
                 }
             }
             else {

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.1",
+  "version": "0.22.2",
   "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.1",
-    "@lancedb/lancedb-darwin-arm64": "0.22.2-beta.1",
-    "@lancedb/lancedb-linux-x64-gnu": "0.22.2-beta.1",
-    "@lancedb/lancedb-linux-arm64-gnu": "0.22.2-beta.1",
-    "@lancedb/lancedb-linux-x64-musl": "0.22.2-beta.1",
-    "@lancedb/lancedb-linux-arm64-musl": "0.22.2-beta.1",
-    "@lancedb/lancedb-win32-x64-msvc": "0.22.2-beta.1",
-    "@lancedb/lancedb-win32-arm64-msvc": "0.22.2-beta.1"
+    "@lancedb/lancedb-darwin-x64": "0.22.2",
+    "@lancedb/lancedb-darwin-arm64": "0.22.2",
+    "@lancedb/lancedb-linux-x64-gnu": "0.22.2",
+    "@lancedb/lancedb-linux-arm64-gnu": "0.22.2",
+    "@lancedb/lancedb-linux-x64-musl": "0.22.2",
+    "@lancedb/lancedb-linux-arm64-musl": "0.22.2",
+    "@lancedb/lancedb-win32-x64-msvc": "0.22.2",
+    "@lancedb/lancedb-win32-arm64-msvc": "0.22.2"
   },
   "peerDependencies": {
     "apache-arrow": ">=15.0.0 <=18.1.0"