update

.bumpversion.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 0.4.11
+current_version = 0.4.10
 commit = True
 message = Bump version: {current_version} → {new_version}
 tag = True
@@ -9,4 +9,4 @@ tag_name = v{new_version}
 
 [bumpversion:file:rust/ffi/node/Cargo.toml]
 
-[bumpversion:file:rust/lancedb/Cargo.toml]
+[bumpversion:file:rust/vectordb/Cargo.toml]

.cargo/config.toml

@@ -33,8 +33,3 @@ rustflags = ["-C", "target-cpu=haswell", "-C", "target-feature=+avx2,+fma,+f16c"
 
 [target.aarch64-apple-darwin]
 rustflags = ["-C", "target-cpu=apple-m1", "-C", "target-feature=+neon,+fp16,+fhm,+dotprod"]
-
-# Not all Windows systems have the C runtime installed, so this avoids library
-# not found errors on systems that are missing it.
-[target.x86_64-pc-windows-msvc]
-rustflags = ["-Ctarget-feature=+crt-static"]

.github/workflows/build_linux_wheel/action.yml

@@ -1,58 +0,0 @@
-# We create a composite action to be re-used both for testing and for releasing
-name: build-linux-wheel
-description: "Build a manylinux wheel for lance"
-inputs:
-  python-minor-version:
-    description: "8, 9, 10, 11, 12"
-    required: true
-  args:
-    description: "--release"
-    required: false
-    default: ""
-  arm-build:
-    description: "Build for arm64 instead of x86_64"
-    # Note: this does *not* mean the host is arm64, since we might be cross-compiling.
-    required: false
-    default: "false"
-runs:
-  using: "composite"
-  steps:
-    - name: CONFIRM ARM BUILD
-      shell: bash
-      run: |
-        echo "ARM BUILD: ${{ inputs.arm-build }}"
-    - name: Build x86_64 Manylinux wheel
-      if: ${{ inputs.arm-build == 'false' }}
-      uses: PyO3/maturin-action@v1
-      with:
-        command: build
-        working-directory: python
-        target: x86_64-unknown-linux-gnu
-        manylinux: "2_17"
-        args: ${{ inputs.args }}
-        before-script-linux: |
-          set -e
-          yum install -y openssl-devel \
-            && curl -L https://github.com/protocolbuffers/protobuf/releases/download/v24.4/protoc-24.4-linux-$(uname -m).zip > /tmp/protoc.zip \
-            && unzip /tmp/protoc.zip -d /usr/local \
-            && rm /tmp/protoc.zip
-    - name: Build Arm Manylinux Wheel
-      if: ${{ inputs.arm-build == 'true' }}
-      uses: PyO3/maturin-action@v1
-      with:
-        command: build
-        working-directory: python
-        target: aarch64-unknown-linux-gnu
-        manylinux: "2_24"
-        args: ${{ inputs.args }}
-        before-script-linux: |
-          set -e
-          apt install -y unzip
-          if [ $(uname -m) = "x86_64" ]; then
-            PROTOC_ARCH="x86_64"
-          else
-            PROTOC_ARCH="aarch_64"
-          fi
-          curl -L https://github.com/protocolbuffers/protobuf/releases/download/v24.4/protoc-24.4-linux-$PROTOC_ARCH.zip > /tmp/protoc.zip \
-            && unzip /tmp/protoc.zip -d /usr/local \
-            && rm /tmp/protoc.zip

.github/workflows/build_mac_wheel/action.yml

@@ -1,25 +0,0 @@
-# We create a composite action to be re-used both for testing and for releasing
-name: build_wheel
-description: "Build a lance wheel"
-inputs:
-  python-minor-version:
-    description: "8, 9, 10, 11"
-    required: true
-  args:
-    description: "--release"
-    required: false
-    default: ""
-runs:
-  using: "composite"
-  steps:
-    - name: Install macos dependency
-      shell: bash
-      run: |
-        brew install protobuf
-    - name: Build wheel
-      uses: PyO3/maturin-action@v1
-      with:
-        command: build
-        args: ${{ inputs.args }}
-        working-directory: python
-        interpreter: 3.${{ inputs.python-minor-version }}

.github/workflows/build_windows_wheel/action.yml

@@ -1,33 +0,0 @@
-# We create a composite action to be re-used both for testing and for releasing
-name: build_wheel
-description: "Build a lance wheel"
-inputs:
-  python-minor-version:
-    description: "8, 9, 10, 11"
-    required: true
-  args:
-    description: "--release"
-    required: false
-    default: ""
-runs:
-  using: "composite"
-  steps:
-    - name: Install Protoc v21.12
-      working-directory: C:\
-      run: |
-        New-Item -Path 'C:\protoc' -ItemType Directory
-        Set-Location C:\protoc
-        Invoke-WebRequest https://github.com/protocolbuffers/protobuf/releases/download/v21.12/protoc-21.12-win64.zip -OutFile C:\protoc\protoc.zip
-        7z x protoc.zip
-        Add-Content $env:GITHUB_PATH "C:\protoc\bin"
-      shell: powershell
-    - name: Build wheel
-      uses: PyO3/maturin-action@v1
-      with:
-        command: build
-        args: ${{ inputs.args }}
-        working-directory: python
-    - uses: actions/upload-artifact@v3
-      with:
-        name: windows-wheels
-        path: python\target\wheels

.github/workflows/cargo-publish.yml

@@ -26,4 +26,4 @@ jobs:
           sudo apt install -y protobuf-compiler libssl-dev
       - name: Publish the package
         run: |
-          cargo publish -p lancedb --all-features --token ${{ secrets.CARGO_REGISTRY_TOKEN }}
+          cargo publish -p vectordb --all-features --token ${{ secrets.CARGO_REGISTRY_TOKEN }}

.github/workflows/docs.yml

@@ -24,14 +24,10 @@ jobs:
     environment:
       name: github-pages
       url: ${{ steps.deployment.outputs.page_url }}
-    runs-on: buildjet-8vcpu-ubuntu-2204
+    runs-on: ubuntu-22.04
     steps:
       - name: Checkout
         uses: actions/checkout@v4
-      - name: Install dependecies needed for ubuntu
-        run: |
-          sudo apt install -y protobuf-compiler libssl-dev
-          rustup update && rustup default        
       - name: Set up Python
         uses: actions/setup-python@v5
         with:

.github/workflows/docs_test.yml

@@ -24,22 +24,16 @@ env:
 jobs:
   test-python:
     name: Test doc python code
-    runs-on: "buildjet-8vcpu-ubuntu-2204"
+    runs-on: "ubuntu-latest"
     steps:
     - name: Checkout
       uses: actions/checkout@v4
-    - name: Install dependecies needed for ubuntu
-      run: |
-        sudo apt install -y protobuf-compiler libssl-dev
-        rustup update && rustup default
     - name: Set up Python
       uses: actions/setup-python@v5
       with:
         python-version: 3.11
         cache: "pip"
         cache-dependency-path: "docs/test/requirements.txt"
-    - name: Rust cache
-      uses: swatinem/rust-cache@v2        
     - name: Build Python
       working-directory: docs/test
       run:
@@ -54,8 +48,8 @@ jobs:
         for d in *; do cd "$d"; echo "$d".py; python "$d".py; cd ..; done
   test-node:
     name: Test doc nodejs code
-    runs-on: "buildjet-8vcpu-ubuntu-2204"
-    timeout-minutes: 60
+    runs-on: "ubuntu-latest"
+    timeout-minutes: 45
     strategy:
       fail-fast: false
     steps:
@@ -71,7 +65,6 @@ jobs:
     - name: Install dependecies needed for ubuntu
       run: |
         sudo apt install -y protobuf-compiler libssl-dev
-        rustup update && rustup default
     - name: Rust cache
       uses: swatinem/rust-cache@v2
     - name: Install node dependencies

.github/workflows/node.yml

@@ -24,6 +24,27 @@ env:
   RUST_BACKTRACE: "1"
 
 jobs:
+  lint:
+    name: Lint
+    runs-on: ubuntu-22.04
+    defaults:
+      run:
+        shell: bash
+        working-directory: node
+    steps:
+    - uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
+        lfs: true
+    - uses: actions/setup-node@v3
+      with:
+        node-version: 20
+        cache: 'npm'
+        cache-dependency-path: node/package-lock.json
+    - name: Lint
+      run: |
+        npm ci
+        npm run lint
   linux:
     name: Linux (Node ${{ matrix.node-version }})
     timeout-minutes: 30

.github/workflows/nodejs.yml

@@ -49,7 +49,6 @@ jobs:
         cargo clippy --all --all-features -- -D warnings
         npm ci
         npm run lint
-        npm run chkformat
   linux:
     name: Linux (NodeJS ${{ matrix.node-version }})
     timeout-minutes: 30
@@ -112,3 +111,4 @@ jobs:
     - name: Test
       run: |
         npm run test
+

.github/workflows/pypi-publish.yml

@@ -2,91 +2,30 @@ name: PyPI Publish
 
 on:
   release:
-    types: [published]
+    types: [ published ]
 
 jobs:
-  linux:
-    timeout-minutes: 60
-    strategy:
-      matrix:
-        python-minor-version: ["8"]
-        platform:
-          - x86_64
-          - aarch64
-    runs-on: "ubuntu-22.04"
+  publish:
+    runs-on: ubuntu-latest
+    # Only runs on tags that matches the python-make-release action
+    if: startsWith(github.ref, 'refs/tags/python-v')
+    defaults:
+      run:
+        shell: bash
+        working-directory: python
     steps:
       - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-          lfs: true
       - name: Set up Python
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
         with:
-          python-version: 3.${{ matrix.python-minor-version }}
-      - uses: ./.github/workflows/build_linux_wheel
+          python-version: "3.8"
+      - name: Build distribution
+        run: |
+          ls -la
+          pip install wheel setuptools --upgrade
+          python setup.py sdist bdist_wheel
+      - name: Publish
+        uses: pypa/gh-action-pypi-publish@v1.8.5
         with:
-          python-minor-version: ${{ matrix.python-minor-version }}
-          args: "--release --strip"
-          arm-build: ${{ matrix.platform == 'aarch64' }}
-      - uses: ./.github/workflows/upload_wheel
-        with:
-          token: ${{ secrets.LANCEDB_PYPI_API_TOKEN }}
-          repo: "pypi"
-  mac:
-    timeout-minutes: 60
-    runs-on: ${{ matrix.config.runner }}
-    strategy:
-      matrix:
-        python-minor-version: ["8"]
-        config:
-          - target: x86_64-apple-darwin
-            runner: macos-13
-          - target: aarch64-apple-darwin
-            runner: macos-14
-    env:
-      MACOSX_DEPLOYMENT_TARGET: 10.15
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          ref: ${{ inputs.ref }}
-          fetch-depth: 0
-          lfs: true
-      - name: Set up Python
-        uses: actions/setup-python@v4
-        with:
-          python-version: 3.12
-      - uses: ./.github/workflows/build_mac_wheel
-        with:
-          python-minor-version: ${{ matrix.python-minor-version }}
-          args: "--release --strip --target ${{ matrix.config.target }}"
-      - uses: ./.github/workflows/upload_wheel
-        with:
-          python-minor-version: ${{ matrix.python-minor-version }}
-          token: ${{ secrets.LANCEDB_PYPI_API_TOKEN }}
-          repo: "pypi"
-  windows:
-    timeout-minutes: 60
-    runs-on: windows-latest
-    strategy:
-      matrix:
-        python-minor-version: ["8"]
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          ref: ${{ inputs.ref }}
-          fetch-depth: 0
-          lfs: true
-      - name: Set up Python
-        uses: actions/setup-python@v4
-        with:
-          python-version: 3.${{ matrix.python-minor-version }}
-      - uses: ./.github/workflows/build_windows_wheel
-        with:
-          python-minor-version: ${{ matrix.python-minor-version }}
-          args: "--release --strip"
-          vcpkg_token: ${{ secrets.VCPKG_GITHUB_PACKAGES }}
-      - uses: ./.github/workflows/upload_wheel
-        with:
-          python-minor-version: ${{ matrix.python-minor-version }}
-          token: ${{ secrets.LANCEDB_PYPI_API_TOKEN }}
-          repo: "pypi"
+          password: ${{ secrets.LANCEDB_PYPI_API_TOKEN }}
+          packages-dir: python/dist

.github/workflows/python.yml

@@ -14,133 +14,49 @@ concurrency:
   cancel-in-progress: true
 
 jobs:
-  lint:
-    name: "Lint"
-    timeout-minutes: 30
-    runs-on: "ubuntu-22.04"
-    defaults:
-      run:
-        shell: bash
-        working-directory: python
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-          lfs: true
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: "3.11"
-      - name: Install ruff
-        run: |
-          pip install ruff==0.2.2
-      - name: Format check
-        run: ruff format --check .
-      - name: Lint
-        run: ruff .
-  doctest:
-    name: "Doctest"
-    timeout-minutes: 30
-    runs-on: "ubuntu-22.04"
-    defaults:
-      run:
-        shell: bash
-        working-directory: python
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-          lfs: true
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: "3.11"
-          cache: "pip"
-      - name: Install protobuf
-        run: |
-          sudo apt update
-          sudo apt install -y protobuf-compiler
-      - uses: Swatinem/rust-cache@v2
-        with:
-          workspaces: python
-      - name: Install
-        run: |
-          pip install -e .[tests,dev,embeddings]
-          pip install tantivy
-          pip install mlx
-      - name: Doctest
-        run: pytest --doctest-modules python/lancedb
   linux:
-    name: "Linux: python-3.${{ matrix.python-minor-version }}"
     timeout-minutes: 30
     strategy:
       matrix:
-        python-minor-version: ["8", "11"]
+        python-minor-version: [ "8", "11" ]
     runs-on: "ubuntu-22.04"
     defaults:
       run:
         shell: bash
         working-directory: python
     steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-          lfs: true
-      - name: Install protobuf
-        run: |
-          sudo apt update
-          sudo apt install -y protobuf-compiler
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: 3.${{ matrix.python-minor-version }}
-      - uses: Swatinem/rust-cache@v2
-        with:
-          workspaces: python
-      - uses: ./.github/workflows/build_linux_wheel
-      - uses: ./.github/workflows/run_tests
-      # Make sure wheels are not included in the Rust cache
-      - name: Delete wheels
-        run: rm -rf target/wheels
+    - uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
+        lfs: true
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: 3.${{ matrix.python-minor-version }}
+    - name: Install lancedb
+      run: |
+        pip install -e .[tests]
+        pip install tantivy@git+https://github.com/quickwit-oss/tantivy-py#164adc87e1a033117001cf70e38c82a53014d985
+        pip install pytest pytest-mock ruff
+    - name: Format check
+      run: ruff format --check .
+    - name: Lint
+      run: ruff .
+    - name: Run tests
+      run: pytest -m "not slow" -x -v --durations=30 tests
+    - name: doctest
+      run: pytest --doctest-modules lancedb
   platform:
-    name: "Mac: ${{ matrix.config.name }}"
+    name: "Platform: ${{ matrix.config.name }}"
     timeout-minutes: 30
     strategy:
       matrix:
         config:
-          - name: x86
+          - name: x86 Mac
             runner: macos-13
-          - name: Arm
+          - name: Arm Mac
             runner: macos-14
-    runs-on: "${{ matrix.config.runner }}"
-    defaults:
-      run:
-        shell: bash
-        working-directory: python
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-          lfs: true
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: "3.11"
-      - uses: Swatinem/rust-cache@v2
-        with:
-          workspaces: python
-      - uses: ./.github/workflows/build_mac_wheel
-      - uses: ./.github/workflows/run_tests
-      # Make sure wheels are not included in the Rust cache
-      - name: Delete wheels
-        run: rm -rf target/wheels
-  windows:
-    name: "Windows: ${{ matrix.config.name }}"
-    timeout-minutes: 30
-    strategy:
-      matrix:
-        config:
-          - name: x86
+          - name: x86 Windows
             runner: windows-latest
     runs-on: "${{ matrix.config.runner }}"
     defaults:
@@ -148,22 +64,21 @@ jobs:
         shell: bash
         working-directory: python
     steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-          lfs: true
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: "3.11"
-      - uses: Swatinem/rust-cache@v2
-        with:
-          workspaces: python
-      - uses: ./.github/workflows/build_windows_wheel
-      - uses: ./.github/workflows/run_tests
-      # Make sure wheels are not included in the Rust cache
-      - name: Delete wheels
-        run: rm -rf target/wheels
+    - uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
+        lfs: true
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: "3.11"
+    - name: Install lancedb
+      run: |
+        pip install -e .[tests]
+        pip install tantivy@git+https://github.com/quickwit-oss/tantivy-py#164adc87e1a033117001cf70e38c82a53014d985
+        pip install pytest pytest-mock
+    - name: Run tests
+      run: pytest -m "not slow" -x -v --durations=30 tests
   pydantic1x:
     timeout-minutes: 30
     runs-on: "ubuntu-22.04"
@@ -172,22 +87,21 @@ jobs:
         shell: bash
         working-directory: python
     steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-          lfs: true
-      - name: Install dependencies
-        run: |
-          sudo apt update
-          sudo apt install -y protobuf-compiler
-      - name: Set up Python
-        uses: actions/setup-python@v5
-        with:
-          python-version: 3.9
-      - name: Install lancedb
-        run: |
-          pip install "pydantic<2"
-          pip install -e .[tests]
-          pip install tantivy
-      - name: Run tests
-        run: pytest -m "not slow" -x -v --durations=30 python/tests
+    - uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
+        lfs: true
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: 3.9
+    - name: Install lancedb
+      run: |
+        pip install "pydantic<2"
+        pip install -e .[tests]
+        pip install tantivy@git+https://github.com/quickwit-oss/tantivy-py#164adc87e1a033117001cf70e38c82a53014d985
+        pip install pytest pytest-mock
+    - name: Run tests
+      run: pytest -m "not slow" -x -v --durations=30 tests
+    - name: doctest
+      run: pytest --doctest-modules lancedb

.github/workflows/remote-integration.yml

@@ -1,37 +0,0 @@
-name: LanceDb Cloud Integration Test
-
-on:
-  workflow_run:
-    workflows: [Rust]
-    types:
-      - completed
-
-env:
-  LANCEDB_PROJECT: ${{ secrets.LANCEDB_PROJECT }}
-  LANCEDB_API_KEY: ${{ secrets.LANCEDB_API_KEY }}
-  LANCEDB_REGION: ${{ secrets.LANCEDB_REGION }}
-
-jobs:
-  test:
-    timeout-minutes: 30
-    runs-on: ubuntu-22.04
-    defaults:
-      run:
-        shell: bash
-        working-directory: rust
-    steps:
-    - uses: actions/checkout@v4
-      with:
-          fetch-depth: 0
-          lfs: true
-    - uses: Swatinem/rust-cache@v2
-      with:
-          workspaces: rust
-    - name: Install dependencies
-      run: |
-          sudo apt update
-          sudo apt install -y protobuf-compiler libssl-dev
-    - name: Build
-      run: cargo build --all-features
-    - name: Run Integration test
-      run: cargo test --tests -- --ignored

.github/workflows/run_tests/action.yml

@@ -1,17 +0,0 @@
-name: run-tests
-
-description: "Install lance wheel and run unit tests"
-inputs:
-  python-minor-version:
-    required: true
-    description: "8 9 10 11 12"
-runs:
-  using: "composite"
-  steps:
-    - name: Install lancedb
-      shell: bash
-      run: |
-        pip3 install $(ls target/wheels/lancedb-*.whl)[tests,dev]
-    - name: pytest
-      shell: bash
-      run: pytest -m "not slow" -x -v --durations=30 python/python/tests

.github/workflows/rust.yml

@@ -119,4 +119,3 @@ jobs:
           $env:VCPKG_ROOT = $env:VCPKG_INSTALLATION_ROOT
           cargo build
           cargo test
-  

.github/workflows/upload_wheel/action.yml

@@ -1,29 +0,0 @@
-name: upload-wheel
-
-description: "Upload wheels to Pypi"
-inputs:
-  os:
-    required: true
-    description: "ubuntu-22.04 or macos-13"
-  repo:
-    required: false
-    description: "pypi or testpypi"
-    default: "pypi"
-  token:
-    required: true
-    description: "release token for the repo"
-
-runs:
-  using: "composite"
-  steps:
-    - name: Install dependencies
-      shell: bash
-      run: |
-        python -m pip install --upgrade pip
-        pip install twine
-    - name: Publish wheel
-      env:
-        TWINE_USERNAME: __token__
-        TWINE_PASSWORD: ${{ inputs.token }}
-      shell: bash
-      run: twine upload --repository ${{ inputs.repo }} target/wheels/lancedb-*.whl

.gitignore

@@ -22,11 +22,6 @@ python/dist
 
 **/.hypothesis
 
-# Compiled Dynamic libraries
-*.so
-*.dylib
-*.dll
-
 ## Javascript
 *.node
 **/node_modules
@@ -39,6 +34,4 @@ dist
 ## Rust
 target
 
-**/sccache.log
-
 Cargo.lock

.pre-commit-config.yaml

@@ -5,14 +5,17 @@ repos:
     -   id: check-yaml
     -   id: end-of-file-fixer
     -   id: trailing-whitespace
+-   repo: https://github.com/psf/black
+    rev: 22.12.0
+    hooks:
+    -   id: black
 -   repo: https://github.com/astral-sh/ruff-pre-commit
     # Ruff version.
-    rev: v0.2.2
+    rev: v0.0.277
     hooks:
     - id: ruff
-- repo: https://github.com/pre-commit/mirrors-prettier
-  rev: v3.1.0
-  hooks:
-    - id: prettier
-      files: "nodejs/.*"
-      exclude: nodejs/lancedb/native.d.ts|nodejs/dist/.*
+-   repo: https://github.com/pycqa/isort
+    rev: 5.12.0
+    hooks:
+    - id: isort
+      name: isort (python)

Cargo.toml

@@ -1,5 +1,5 @@
 [workspace]
-members = ["rust/ffi/node", "rust/lancedb", "nodejs", "python"]
+members = ["rust/ffi/node", "rust/vectordb", "nodejs"]
 # Python package needs to be built by maturin.
 exclude = ["python"]
 resolver = "2"
@@ -14,10 +14,10 @@ keywords = ["lancedb", "lance", "database", "vector", "search"]
 categories = ["database-implementations"]
 
 [workspace.dependencies]
-lance = { "version" = "=0.10.2", "features" = ["dynamodb"] }
-lance-index = { "version" = "=0.10.2" }
-lance-linalg = { "version" = "=0.10.2" }
-lance-testing = { "version" = "=0.10.2" }
+lance = { "version" = "=0.9.16", "features" = ["dynamodb"] }
+lance-index = { "version" = "=0.9.16" }
+lance-linalg = { "version" = "=0.9.16" }
+lance-testing = { "version" = "=0.9.16" }
 # Note that this one does not include pyarrow
 arrow = { version = "50.0", optional = false }
 arrow-array = "50.0"

dockerfiles/Dockerfile

@@ -1,27 +0,0 @@
-#Simple base dockerfile that supports basic dependencies required to run lance with FTS and Hybrid Search
-#Usage docker build -t lancedb:latest -f Dockerfile .
-FROM python:3.10-slim-buster
-
-# Install Rust
-RUN apt-get update && apt-get install -y curl build-essential && \
-  curl https://sh.rustup.rs -sSf | sh -s -- -y
-
-# Set the environment variable for Rust
-ENV PATH="/root/.cargo/bin:${PATH}"
-
-# Install protobuf compiler
-RUN apt-get install -y protobuf-compiler && \
-  apt-get clean && \
-  rm -rf /var/lib/apt/lists/*
-
-RUN apt-get -y update &&\
-  apt-get -y upgrade && \
-  apt-get -y install git
-
-
-# Verify installations
-RUN python --version && \
-  rustc --version && \
-  protoc --version
-
-RUN pip install tantivy lancedb

docs/mkdocs.yml

@@ -57,16 +57,6 @@ plugins:
           - https://arrow.apache.org/docs/objects.inv
           - https://pandas.pydata.org/docs/objects.inv
 - mkdocs-jupyter
-- ultralytics:
-    verbose: True
-    enabled: True
-    default_image: "assets/lancedb_and_lance.png" # Default image for all pages
-    add_image: True # Automatically add meta image
-    add_keywords: True # Add page keywords in the header tag
-    add_share_buttons: True # Add social share buttons
-    add_authors: False # Display page authors 
-    add_desc: False
-    add_dates: False
 
 markdown_extensions:
 - admonition
@@ -109,9 +99,10 @@ nav:
     - Configuring Storage: guides/storage.md
   - 🧬 Managing embeddings:
     - Overview: embeddings/index.md
-    - Embedding functions: embeddings/embedding_functions.md
-    - Available models: embeddings/default_embedding_functions.md
-    - User-defined embedding functions: embeddings/custom_embedding_function.md
+    - Explicit management: embeddings/embedding_explicit.md
+    - Implicit management: embeddings/embedding_functions.md
+    - Available Functions: embeddings/default_embedding_functions.md
+    - Custom Embedding Functions: embeddings/api.md
     - "Example: Multi-lingual semantic search": notebooks/multi_lingual_example.ipynb
     - "Example: MultiModal CLIP Embeddings": notebooks/DisappearingEmbeddingFunction.ipynb
   - 🔌 Integrations:
@@ -173,9 +164,10 @@ nav:
     - Configuring Storage: guides/storage.md
 - Managing Embeddings:
   - Overview: embeddings/index.md
-  - Embedding functions: embeddings/embedding_functions.md
-  - Available models: embeddings/default_embedding_functions.md
-  - User-defined embedding functions: embeddings/custom_embedding_function.md
+  - Explicit management: embeddings/embedding_explicit.md
+  - Implicit management: embeddings/embedding_functions.md
+  - Available Functions: embeddings/default_embedding_functions.md
+  - Custom Embedding Functions: embeddings/api.md
   - "Example: Multi-lingual semantic search": notebooks/multi_lingual_example.ipynb
   - "Example: MultiModal CLIP Embeddings": notebooks/DisappearingEmbeddingFunction.ipynb
 - Integrations:

docs/requirements.txt

@@ -2,5 +2,4 @@ mkdocs==1.5.3
 mkdocs-jupyter==0.24.1
 mkdocs-material==9.5.3
 mkdocstrings[python]==0.20.0
-pydantic
-mkdocs-ultralytics-plugin==0.0.44
+pydantic

docs/src/ann_indexes.md

@@ -7,11 +7,20 @@ for brute-force scanning of the entire vector space.
 A vector index is faster but less accurate than exhaustive search (kNN or flat search).
 LanceDB provides many parameters to fine-tune the index's size, the speed of queries, and the accuracy of results.
 
-## Disk-based Index
+Currently, LanceDB does _not_ automatically create the ANN index.
+LanceDB has optimized code for kNN as well. For many use-cases, datasets under 100K vectors won't require index creation at all.
+If you can live with <100ms latency, skipping index creation is a simpler workflow while guaranteeing 100% recall.
 
-Lance provides an `IVF_PQ` disk-based index. It uses **Inverted File Index (IVF)** to first divide
-the dataset into `N` partitions, and then applies **Product Quantization** to compress vectors in each partition.
-See the [indexing](concepts/index_ivfpq.md) concepts guide for more information on how this works.
+In the future we will look to automatically create and configure the ANN index as data comes in.
+
+## Types of Index
+
+Lance can support multiple index types, the most widely used one is `IVF_PQ`.
+
+- `IVF_PQ`: use **Inverted File Index (IVF)** to first divide the dataset into `N` partitions,
+  and then use **Product Quantization** to compress vectors in each partition.
+- `DiskANN` (**Experimental**): organize the vector as a on-disk graph, where the vertices approximately
+  represent the nearest neighbors of each vector.
 
 ## Creating an IVF_PQ Index
 
@@ -79,7 +88,7 @@ You can specify the GPU device to train IVF partitions via
      )
      ```
 
-=== "MacOS"
+=== "Macos"
 
      <!-- skip-test -->
      ```python
@@ -91,7 +100,7 @@ You can specify the GPU device to train IVF partitions via
      )
      ```
 
-Troubleshooting:
+Trouble shootings:
 
 If you see `AssertionError: Torch not compiled with CUDA enabled`, you need to [install
 PyTorch with CUDA support](https://pytorch.org/get-started/locally/).
@@ -178,21 +187,13 @@ You can select the columns returned by the query using a select clause.
 
 ## FAQ
 
-### Why do I need to manually create an index?
-
-Currently, LanceDB does _not_ automatically create the ANN index.
-LanceDB is well-optimized for kNN (exhaustive search) via a disk-based  index. For many use-cases,
-datasets of the order of ~100K vectors don't require index creation. If you can live with up to
-100ms latency, skipping index creation is a simpler workflow while guaranteeing 100% recall.
-
 ### When is it necessary to create an ANN vector index?
 
-`LanceDB` comes out-of-the-box with highly optimized SIMD code for computing vector similarity.
-In our benchmarks, computing distances for 100K pairs of 1K dimension vectors takes **less than 20ms**.
-We observe that for small datasets (~100K rows) or for applications that can accept 100ms latency,
-vector indices are usually not necessary.
+`LanceDB` has manually-tuned SIMD code for computing vector distances.
+In our benchmarks, computing 100K pairs of 1K dimension vectors takes **less than 20ms**.
+For small datasets (< 100K rows) or applications that can accept 100ms latency, vector indices are usually not necessary.
 
-For large-scale or higher dimension vectors, it can beneficial to create vector index for performance.
+For large-scale or higher dimension vectors, it is beneficial to create vector index.
 
 ### How big is my index, and how many memory will it take?
 

docs/src/basic.md

@@ -46,7 +46,7 @@
 
     !!! info "Please also make sure you're using the same version of Arrow as in the [vectordb crate](https://github.com/lancedb/lancedb/blob/main/Cargo.toml)"
 
-## Connect to a database
+## How to connect to a database
 
 === "Python"
 
@@ -69,22 +69,17 @@
     ```rust
     #[tokio::main]
     async fn main() -> Result<()> {
-        --8<-- "rust/lancedb/examples/simple.rs:connect"
+        --8<-- "rust/vectordb/examples/simple.rs:connect"
     }
     ```
 
-    !!! info "See [examples/simple.rs](https://github.com/lancedb/lancedb/tree/main/rust/lancedb/examples/simple.rs) for a full working example."
+    !!! info "See [examples/simple.rs](https://github.com/lancedb/lancedb/tree/main/rust/vectordb/examples/simple.rs) for a full working example."
 
 LanceDB will create the directory if it doesn't exist (including parent directories).
 
 If you need a reminder of the uri, you can call `db.uri()`.
 
-## Create a table
-
-### Directly insert data to a new table
-
-If you have data to insert into the table at creation time, you can simultaneously create a 
-table and insert the data to it.
+## How to create a table
 
 === "Python"
 
@@ -123,18 +118,17 @@ table and insert the data to it.
     use arrow_schema::{DataType, Schema, Field};
     use arrow_array::{RecordBatch, RecordBatchIterator};
 
-    --8<-- "rust/lancedb/examples/simple.rs:create_table"
+    --8<-- "rust/vectordb/examples/simple.rs:create_table"
     ```
 
     If the table already exists, LanceDB will raise an error by default.
 
-!!! info "Under the hood, LanceDB converts the input data into an Apache Arrow table and persists it to disk using the [Lance format](https://www.github.com/lancedb/lance)."
+!!! info "Under the hood, LanceDB is converting the input data into an Apache Arrow table and persisting it to disk in [Lance format](https://www.github.com/lancedb/lance)."
 
-### Create an empty table
+### Creating an empty table
 
 Sometimes you may not have the data to insert into the table at creation time.
-In this case, you can create an empty table and specify the schema, so that you can add
-data to the table at a later time (such that it conforms to the schema).
+In this case, you can create an empty table and specify the schema.
 
 === "Python"
 
@@ -153,12 +147,12 @@ data to the table at a later time (such that it conforms to the schema).
 === "Rust"
 
     ```rust
-    --8<-- "rust/lancedb/examples/simple.rs:create_empty_table"
+    --8<-- "rust/vectordb/examples/simple.rs:create_empty_table"
     ```
 
-## Open an existing table
+## How to open an existing table
 
-Once created, you can open a table as follows:
+Once created, you can open a table using the following code:
 
 === "Python"
 
@@ -175,7 +169,7 @@ Once created, you can open a table as follows:
 === "Rust"
 
     ```rust
-    --8<-- "rust/lancedb/examples/simple.rs:open_with_existing_file"
+    --8<-- "rust/vectordb/examples/simple.rs:open_with_existing_file"
     ```
 
 If you forget the name of your table, you can always get a listing of all table names:
@@ -195,12 +189,12 @@ If you forget the name of your table, you can always get a listing of all table
 === "Rust"
 
     ```rust
-    --8<-- "rust/lancedb/examples/simple.rs:list_names"
+    --8<-- "rust/vectordb/examples/simple.rs:list_names"
     ```
 
-## Add data to a table
+## How to add data to a table
 
-After a table has been created, you can always add more data to it as follows:
+After a table has been created, you can always add more data to it using
 
 === "Python"
 
@@ -225,12 +219,12 @@ After a table has been created, you can always add more data to it as follows:
 === "Rust"
 
     ```rust
-    --8<-- "rust/lancedb/examples/simple.rs:add"
+    --8<-- "rust/vectordb/examples/simple.rs:add"
     ```
 
-## Search for nearest neighbors
+## How to search for (approximate) nearest neighbors
 
-Once you've embedded the query, you can find its nearest neighbors as follows:
+Once you've embedded the query, you can find its nearest neighbors using the following code:
 
 === "Python"
 
@@ -251,12 +245,11 @@ Once you've embedded the query, you can find its nearest neighbors as follows:
     ```rust
     use futures::TryStreamExt;
 
-    --8<-- "rust/lancedb/examples/simple.rs:search"
+    --8<-- "rust/vectordb/examples/simple.rs:search"
     ```
 
 By default, LanceDB runs a brute-force scan over dataset to find the K nearest neighbours (KNN).
 For tables with more than 50K vectors, creating an ANN index is recommended to speed up search performance.
-LanceDB allows you to create an ANN index on a table as follows:
 
 === "Python"
 
@@ -273,17 +266,12 @@ LanceDB allows you to create an ANN index on a table as follows:
 === "Rust"
 
     ```rust
-     --8<-- "rust/lancedb/examples/simple.rs:create_index"
+     --8<-- "rust/vectordb/examples/simple.rs:create_index"
     ```
 
-!!! note "Why do I need to create an index manually?"
-    LanceDB does not automatically create the ANN index, for two reasons. The first is that it's optimized
-    for really fast retrievals via a disk-based index, and the second is that data and query workloads can
-    be very diverse, so there's no one-size-fits-all index configuration. LanceDB provides many parameters
-    to fine-tune index size, query latency and accuracy. See the section on
-    [ANN indexes](ann_indexes.md) for more details.
+Check [Approximate Nearest Neighbor (ANN) Indexes](/ann_indices.md) section for more details.
 
-## Delete rows from a table
+## How to delete rows from a table
 
 Use the `delete()` method on tables to delete rows from a table. To choose
 which rows to delete, provide a filter that matches on the metadata columns.
@@ -304,7 +292,7 @@ This can delete any number of rows that match the filter.
 === "Rust"
 
     ```rust
-    --8<-- "rust/lancedb/examples/simple.rs:delete"
+    --8<-- "rust/vectordb/examples/simple.rs:delete"
     ```
 
 The deletion predicate is a SQL expression that supports the same expressions
@@ -319,7 +307,7 @@ To see what expressions are supported, see the [SQL filters](sql.md) section.
 
       Read more: [vectordb.Table.delete](javascript/interfaces/Table.md#delete)
 
-## Drop a table
+## How to remove a table
 
 Use the `drop_table()` method on the database to remove a table.
 
@@ -345,7 +333,7 @@ Use the `drop_table()` method on the database to remove a table.
 === "Rust"
 
     ```rust
-    --8<-- "rust/lancedb/examples/simple.rs:drop_table"
+    --8<-- "rust/vectordb/examples/simple.rs:drop_table"
     ```
 
 !!! note "Bundling `vectordb` apps with Webpack"

docs/src/concepts/index_ivfpq.md

@@ -81,4 +81,24 @@ The above query will perform a search on the table `tbl` using the given query v
 * `to_pandas()`: Convert the results to a pandas DataFrame
 
 And there you have it! You now understand what an IVF-PQ index is, and how to create and query it in LanceDB.
-To see how to create an IVF-PQ index in LanceDB, take a look at the [ANN indexes](../ann_indexes.md) section.
+
+
+## FAQ
+
+### When is it necessary to create a vector index?
+
+LanceDB has manually-tuned SIMD code for computing vector distances. In our benchmarks, computing 100K pairs of 1K dimension vectors takes **<20ms**. For small datasets (<100K rows) or applications that can accept up to 100ms latency, vector indices are usually not necessary.
+
+For large-scale or higher dimension vectors, it is beneficial to create vector index.
+
+### How big is my index, and how much memory will it take?
+
+In LanceDB, all vector indices are disk-based, meaning that when responding to a vector query, only the relevant pages from the index file are loaded from disk and cached in memory. Additionally, each sub-vector is usually encoded into 1 byte PQ code.
+
+For example, with 1024-dimension vectors, if we choose `num_sub_vectors = 64`, each sub-vector has `1024 / 64 = 16` float32 numbers. Product quantization can lead to approximately `16 * sizeof(float32) / 1 = 64` times of space reduction.
+
+### How to choose `num_partitions` and `num_sub_vectors` for IVF_PQ index?
+
+`num_partitions` is used to decide how many partitions the first level IVF index uses. Higher number of partitions could lead to more efficient I/O during queries and better accuracy, but it takes much more time to train. On SIFT-1M dataset, our benchmark shows that keeping each partition 1K-4K rows lead to a good latency/recall.
+
+`num_sub_vectors` specifies how many PQ short codes to generate on each vector. Because PQ is a lossy compression of the original vector, a higher `num_sub_vectors` usually results in less space distortion, and thus yields better accuracy. However, a higher `num_sub_vectors` also causes heavier I/O and more PQ computation, and thus, higher latency. `dimension / num_sub_vectors` should be a multiple of 8 for optimum SIMD efficiency.

docs/src/embeddings/default_embedding_functions.md

@@ -175,8 +175,7 @@ Supported Embedding modelIDs are:
 * `cohere.embed-english-v3`
 * `cohere.embed-multilingual-v3`
 
-Supported parameters (to be passed in `create` method) are:
-
+Supported paramters (to be passed in `create` method) are:
 | Parameter | Type | Default Value | Description |
 |---|---|---|---|
 | **name** | str | "amazon.titan-embed-text-v1" | The model ID of the bedrock model to use. Supported base models for Text Embeddings: amazon.titan-embed-text-v1, cohere.embed-english-v3, cohere.embed-multilingual-v3 |

docs/src/embeddings/embedding_explicit.md

@@ -0,0 +1,141 @@
+In this workflow, you define your own embedding function and pass it as a callable to LanceDB, invoking it in your code to generate the embeddings. Let's look at some examples.
+
+### Hugging Face
+
+!!! note
+    Currently, the Hugging Face method is only supported in the Python SDK.
+
+=== "Python"
+    The most popular open source option is to use the [sentence-transformers](https://www.sbert.net/) 
+    library, which can be installed via pip.
+
+    ```bash
+    pip install sentence-transformers
+    ```
+
+    The example below shows how to use the `paraphrase-albert-small-v2` model to generate embeddings 
+    for a given document.
+
+    ```python
+    from sentence_transformers import SentenceTransformer
+
+    name="paraphrase-albert-small-v2"
+    model = SentenceTransformer(name)
+
+    # used for both training and querying
+    def embed_func(batch):
+        return [model.encode(sentence) for sentence in batch]
+    ```
+
+### OpenAI
+
+Another popular alternative is to use an external API like OpenAI's [embeddings API](https://platform.openai.com/docs/guides/embeddings/what-are-embeddings).
+
+=== "Python"
+      ```python
+        import openai
+        import os
+
+        # Configuring the environment variable OPENAI_API_KEY
+        if "OPENAI_API_KEY" not in os.environ:
+        # OR set the key here as a variable
+        openai.api_key = "sk-..."
+
+        # verify that the API key is working
+        assert len(openai.Model.list()["data"]) > 0
+
+        def embed_func(c):
+            rs = openai.Embedding.create(input=c, engine="text-embedding-ada-002")
+            return [record["embedding"] for record in rs["data"]]
+      ```
+
+=== "JavaScript"
+      ```javascript
+        const lancedb = require("vectordb");
+
+        // You need to provide an OpenAI API key
+        const apiKey = "sk-..."
+        // The embedding function will create embeddings for the 'text' column
+        const embedding = new lancedb.OpenAIEmbeddingFunction('text', apiKey)
+      ```
+
+## Applying an embedding function to data
+
+=== "Python"
+    Using an embedding function, you can apply it to raw data
+    to generate embeddings for each record.
+
+    Say you have a pandas DataFrame with a `text` column that you want embedded,
+    you can use the `with_embeddings` function to generate embeddings and add them to 
+    an existing table.
+
+    ```python
+     import pandas as pd
+     from lancedb.embeddings import with_embeddings
+
+     df = pd.DataFrame(
+        [
+            {"text": "pepperoni"},
+            {"text": "pineapple"}
+        ]
+    )
+     data = with_embeddings(embed_func, df)
+
+     # The output is used to create / append to a table
+     # db.create_table("my_table", data=data)
+    ```
+
+    If your data is in a different column, you can specify the `column` kwarg to `with_embeddings`.
+
+    By default, LanceDB calls the function with batches of 1000 rows. This can be configured
+    using the `batch_size` parameter to `with_embeddings`.
+
+    LanceDB automatically wraps the function with retry and rate-limit logic to ensure the OpenAI
+    API call is reliable.
+
+=== "JavaScript"
+    Using an embedding function, you can apply it to raw data
+    to generate embeddings for each record.
+
+    Simply pass the embedding function created above and LanceDB will use it to generate
+    embeddings for your data.
+
+    ```javascript
+    const db = await lancedb.connect("data/sample-lancedb");
+    const data = [
+    { text: "pepperoni"},
+    { text: "pineapple"}
+    ]
+
+    const table = await db.createTable("vectors", data, embedding)
+    ```
+
+## Querying using an embedding function
+
+!!! warning
+    At query time, you **must** use the same embedding function you used to vectorize your data.
+    If you use a different embedding function, the embeddings will not reside in the same vector
+    space and the results will be nonsensical.
+
+=== "Python"
+     ```python
+     query = "What's the best pizza topping?"
+     query_vector = embed_func([query])[0]
+     results = (
+        tbl.search(query_vector)
+        .limit(10)
+        .to_pandas()
+     )
+     ```
+
+     The above snippet returns a pandas DataFrame with the 10 closest vectors to the query.
+
+=== "JavaScript"
+     ```javascript
+      const results = await table
+        .search("What's the best pizza topping?")
+        .limit(10)
+        .execute()
+     ```
+
+     The above snippet returns an array of records with the top 10 nearest neighbors to the query.

docs/src/embeddings/embedding_functions.md

@@ -3,126 +3,61 @@ Representing multi-modal data as vector embeddings is becoming a standard practi
 For this purpose, LanceDB introduces an **embedding functions API**, that allow you simply set up once, during the configuration stage of your project. After this, the table remembers it, effectively making the embedding functions *disappear in the background* so you don't have to worry about manually passing callables, and instead, simply focus on the rest of your data engineering pipeline.
 
 !!! warning
-    Using the embedding function registry means that you don't have to explicitly generate the embeddings yourself. 
-    However, if your embedding function changes, you'll have to re-configure your table with the new embedding function 
-    and regenerate the embeddings. In the future, we plan to support the ability to change the embedding function via
-    table metadata and have LanceDB automatically take care of regenerating the embeddings.
-
+    Using the implicit embeddings management approach means that you can forget about the manually passing around embedding
+    functions in your code, as long as you don't intend to change it at a later time. If your embedding function changes,
+    you'll have to re-configure your table with the new embedding function and regenerate the embeddings.
 
 ## 1. Define the embedding function
+We have some pre-defined embedding functions in the global registry, with more coming soon. Here's let's an implementation of CLIP as example.
+```
+registry = EmbeddingFunctionRegistry.get_instance()
+clip = registry.get("open-clip").create()
 
-=== "Python"
-    In the LanceDB python SDK, we define a global embedding function registry with
-    many different embedding models and even more coming soon. 
-    Here's let's an implementation of CLIP as example.
-
-    ```python
-    from lancedb.embeddings import get_registry
-
-    registry = get_registry()
-    clip = registry.get("open-clip").create()
-    ```
-
-    You can also define your own embedding function by implementing the `EmbeddingFunction` 
-    abstract base interface. It subclasses Pydantic Model which can be utilized to write complex schemas simply as we'll see next!
-
-=== "JavaScript""
-    In the TypeScript SDK, the choices are more limited. For now, only the OpenAI
-    embedding function is available.
-
-    ```javascript
-    const lancedb = require("vectordb");
-
-    // You need to provide an OpenAI API key
-    const apiKey = "sk-..."
-    // The embedding function will create embeddings for the 'text' column
-    const embedding = new lancedb.OpenAIEmbeddingFunction('text', apiKey)
-    ```
+```
+You can also define your own embedding function by implementing the `EmbeddingFunction` abstract base interface. It subclasses Pydantic Model which can be utilized to write complex schemas simply as we'll see next!
 
 ## 2. Define the data model or schema
+The embedding function defined above abstracts away all the details about the models and dimensions required to define the schema. You can simply set a field as **source** or **vector** column. Here's how:
 
-=== "Python"
-    The embedding function defined above abstracts away all the details about the models and dimensions required to define the schema. You can simply set a field as **source** or **vector** column. Here's how:
+```python
+class Pets(LanceModel):
+    vector: Vector(clip.ndims) = clip.VectorField()
+    image_uri: str = clip.SourceField()
+```
 
-    ```python
-    class Pets(LanceModel):
-        vector: Vector(clip.ndims) = clip.VectorField()
-        image_uri: str = clip.SourceField()
-    ```
+`VectorField` tells LanceDB to use the clip embedding function to generate query embeddings for the `vector` column and `SourceField` ensures that when adding data, we automatically use the specified embedding function to encode `image_uri`.
 
-    `VectorField` tells LanceDB to use the clip embedding function to generate query embeddings for the `vector` column and `SourceField` ensures that when adding data, we automatically use the specified embedding function to encode `image_uri`.
+## 3. Create LanceDB table
+Now that we have chosen/defined our embedding function and the schema, we can create the table:
 
-=== "JavaScript"
+```python
+db = lancedb.connect("~/lancedb")
+table = db.create_table("pets", schema=Pets)
 
-    For the TypeScript SDK, a schema can be inferred from input data, or an explicit
-    Arrow schema can be provided.
+```
 
-## 3. Create table and add data
+That's it! We've provided all the information needed to embed the source and query inputs. We can now forget about the model and dimension details and start to build our VectorDB pipeline.
 
-Now that we have chosen/defined our embedding function and the schema, 
-we can create the table and ingest data without needing to explicitly generate
-the embeddings at all:
+## 4. Ingest lots of data and query your table
+Any new or incoming data can just be added and it'll be vectorized automatically.
 
-=== "Python"
-    ```python
-    db = lancedb.connect("~/lancedb")
-    table = db.create_table("pets", schema=Pets)
+```python
+table.add([{"image_uri": u} for u in uris])
+```
 
-    table.add([{"image_uri": u} for u in uris])
-    ```
+Our OpenCLIP query embedding function supports querying via both text and images:
 
-=== "JavaScript"
+```python
+result = table.search("dog")
+```
 
-    ```javascript
-    const db = await lancedb.connect("data/sample-lancedb");
-    const data = [
-    { text: "pepperoni"},
-    { text: "pineapple"}
-    ]
+Let's query an image:
 
-    const table = await db.createTable("vectors", data, embedding)
-    ```
-
-## 4. Querying your table
-Not only can you forget about the embeddings during ingestion, you also don't
-need to worry about it when you query the table:
-
-=== "Python"
-
-    Our OpenCLIP query embedding function supports querying via both text and images:
-
-    ```python
-    results = (
-        table.search("dog")
-        .limit(10)
-        .to_pandas()
-    )
-    ```
-
-    Or we can search using an image:
-
-    ```python
-    p = Path("path/to/images/samoyed_100.jpg")
-    query_image = Image.open(p)
-    results = (
-        table.search(query_image)
-        .limit(10)
-        .to_pandas()
-    )
-    ```
-
-    Both of the above snippet returns a pandas DataFrame with the 10 closest vectors to the query.
-
-=== "JavaScript"
-
-    ```javascript
-    const results = await table
-    .search("What's the best pizza topping?")
-    .limit(10)
-    .execute()
-    ```    
-    
-    The above snippet returns an array of records with the top 10 nearest neighbors to the query.
+```python
+p = Path("path/to/images/samoyed_100.jpg")
+query_image = Image.open(p)
+table.search(query_image)
+```
 
 ---
 
@@ -165,5 +100,4 @@ rs[2].image
 
 ![](../assets/dog_clip_output.png)
 
-Now that you have the basic idea about LanceDB embedding functions and the embedding function registry,
-let's dive deeper into defining your own [custom functions](./custom_embedding_function.md).
+Now that you have the basic idea about implicit management via embedding functions, let's dive deeper into a [custom API](./api.md) that you can use to implement your own embedding functions.

docs/src/embeddings/index.md

@@ -1,14 +1,8 @@
-Due to the nature of vector embeddings, they can be used to represent any kind of data, from text to images to audio. 
-This makes them a very powerful tool for machine learning practitioners. 
-However, there's no one-size-fits-all solution for generating embeddings - there are many different libraries and APIs 
-(both commercial and open source) that can be used to generate embeddings from structured/unstructured data.
+Due to the nature of vector embeddings, they can be used to represent any kind of data, from text to images to audio. This makes them a very powerful tool for machine learning practitioners. However, there's no one-size-fits-all solution for generating embeddings - there are many different libraries and APIs (both commercial and open source) that can be used to generate embeddings from structured/unstructured data.
 
-LanceDB supports 3 methods of working with embeddings.
+LanceDB supports 2 methods of vectorizing your raw data into embeddings.
 
-1. You can manually generate embeddings for the data and queries. This is done outside of LanceDB.
-2. You can use the built-in [embedding functions](./embedding_functions.md) to embed the data and queries in the background.
-3. For python users, you can define your own [custom embedding function](./custom_embedding_function.md)
-   that extends the default embedding functions.
+1. **Explicit**: By manually calling LanceDB's `with_embedding` function to vectorize your data via an `embed_func` of your choice
+2. **Implicit**: Allow LanceDB to embed the data and queries in the background as they come in, by using the table's `EmbeddingRegistry` information
 
-For python users, there is also a legacy [with_embeddings API](./legacy.md).
-It is retained for compatibility and will be removed in a future version.
+See the [explicit](embedding_explicit.md) and [implicit](embedding_functions.md) embedding sections for more details.

docs/src/embeddings/legacy.md

@@ -1,99 +0,0 @@
-The legacy `with_embeddings` API is for Python only and is deprecated.
-
-### Hugging Face
-
-The most popular open source option is to use the [sentence-transformers](https://www.sbert.net/) 
-library, which can be installed via pip.
-
-```bash
-pip install sentence-transformers
-```
-
-The example below shows how to use the `paraphrase-albert-small-v2` model to generate embeddings 
-for a given document.
-
-```python
-from sentence_transformers import SentenceTransformer
-
-name="paraphrase-albert-small-v2"
-model = SentenceTransformer(name)
-
-# used for both training and querying
-def embed_func(batch):
-    return [model.encode(sentence) for sentence in batch]
-```
-
-
-### OpenAI
-
-Another popular alternative is to use an external API like OpenAI's [embeddings API](https://platform.openai.com/docs/guides/embeddings/what-are-embeddings).
-
-```python
-import openai
-import os
-
-# Configuring the environment variable OPENAI_API_KEY
-if "OPENAI_API_KEY" not in os.environ:
-# OR set the key here as a variable
-openai.api_key = "sk-..."
-
-client = openai.OpenAI()
-
-def embed_func(c):    
-    rs = client.embeddings.create(input=c, model="text-embedding-ada-002")
-    return [record.embedding for record in rs["data"]]
-```
-
-
-## Applying an embedding function to data
-
-Using an embedding function, you can apply it to raw data
-to generate embeddings for each record.
-
-Say you have a pandas DataFrame with a `text` column that you want embedded,
-you can use the `with_embeddings` function to generate embeddings and add them to 
-an existing table.
-
-```python
-    import pandas as pd
-    from lancedb.embeddings import with_embeddings
-
-    df = pd.DataFrame(
-        [
-            {"text": "pepperoni"},
-            {"text": "pineapple"}
-        ]
-    )
-    data = with_embeddings(embed_func, df)
-
-    # The output is used to create / append to a table
-    tbl = db.create_table("my_table", data=data)
-```
-
-If your data is in a different column, you can specify the `column` kwarg to `with_embeddings`.
-
-By default, LanceDB calls the function with batches of 1000 rows. This can be configured
-using the `batch_size` parameter to `with_embeddings`.
-
-LanceDB automatically wraps the function with retry and rate-limit logic to ensure the OpenAI
-API call is reliable.
-
-## Querying using an embedding function
-
-!!! warning
-    At query time, you **must** use the same embedding function you used to vectorize your data.
-    If you use a different embedding function, the embeddings will not reside in the same vector
-    space and the results will be nonsensical.
-
-=== "Python"
-     ```python
-     query = "What's the best pizza topping?"
-     query_vector = embed_func([query])[0]
-     results = (
-        tbl.search(query_vector)
-        .limit(10)
-        .to_pandas()
-     )
-     ```
-
-     The above snippet returns a pandas DataFrame with the 10 closest vectors to the query.

docs/src/examples/image_embeddings_roboflow.md

@@ -43,7 +43,7 @@ pip install lancedb
 We also need to install a specific commit of `tantivy`, a dependency of the LanceDB full text search engine we will use later in this guide:
 
 ```
-pip install tantivy
+pip install tantivy@git+https://github.com/quickwit-oss/tantivy-py#164adc87e1a033117001cf70e38c82a53014d985
 ```
 
 Create a new Python file and add the following code:

docs/src/examples/modal_langchain.py

@@ -1,5 +1,6 @@
 import pickle
 import re
+import sys
 import zipfile
 from pathlib import Path
 

docs/src/faq.md

@@ -40,7 +40,7 @@ LanceDB and its underlying data format, Lance, are built to scale to really larg
 
 No. LanceDB is blazing fast (due to its disk-based index) for even brute force kNN search, within reason. In our benchmarks, computing 100K pairs of 1000-dimension vectors takes less than 20ms. For small datasets of ~100K records or applications that can accept ~100ms latency, an ANN index is usually not necessary.
 
-For large-scale (>1M) or higher dimension vectors, it is beneficial to create an ANN index. See the [ANN indexes](ann_indexes.md) section for more details.
+For large-scale (>1M) or higher dimension vectors, it is beneficial to create an ANN index.
 
 ### Does LanceDB support full-text search?
 

docs/src/fts.md

@@ -75,40 +75,21 @@ applied on top of the full text search results. This can be invoked via the fami
 table.search("puppy").limit(10).where("meta='foo'").to_list()
 ```
 
-## Phrase queries vs. terms queries
+## Syntax
 
-For full-text search you can specify either a **phrase** query like `"the old man and the sea"`, 
-or a **terms** search query like `"(Old AND Man) AND Sea"`. For more details on the terms
-query syntax, see Tantivy's [query parser rules](https://docs.rs/tantivy/latest/tantivy/query/struct.QueryParser.html).
+For full-text search you can perform either a phrase query like "the old man and the sea", 
+or a structured search query like "(Old AND Man) AND Sea".
+Double quotes are used to disambiguate.
 
-!!! tip "Note"
-    The query parser will raise an exception on queries that are ambiguous. For example, in the query `they could have been dogs OR cats`, `OR` is capitalized so it's considered a keyword query operator. But it's ambiguous how the left part should be treated. So if you submit this search query as is, you'll get `Syntax Error: they could have been dogs OR cats`.
+For example: 
 
-    ```py
-    # This raises a syntax error
-    table.search("they could have been dogs OR cats")
-    ```
+If you intended "they could have been dogs OR cats" as a phrase query, this actually
+raises a syntax error since `OR` is a recognized operator. If you make `or` lower case,
+this avoids the syntax error. However, it is cumbersome to have to remember what will
+conflict with the query syntax. Instead, if you search using 
+`table.search('"they could have been dogs OR cats"')`, then the syntax checker avoids
+checking inside the quotes.
 
-    On the other hand, lowercasing `OR` to `or` will work, because there are no capitalized logical operators and
-    the query is treated as a phrase query.
-
-    ```py
-    # This works!
-    table.search("they could have been dogs or cats")
-    ```
-
-It can be cumbersome to have to remember what will cause a syntax error depending on the type of
-query you want to perform. To make this simpler, when you want to perform a phrase query, you can
-enforce it in one of two ways:
-
-1. Place the double-quoted query inside single quotes. For example, `table.search('"they could have been dogs OR cats"')` is treated as
-a phrase query.
-2. Explicitly declare the `phrase_query()` method. This is useful when you have a phrase query that
-itself contains double quotes. For example, `table.search('the cats OR dogs were not really "pets" at all').phrase_query()`
-is treated as a phrase query.
-
-In general, a query that's declared as a phrase query will be wrapped in double quotes during parsing, with nested
-double quotes replaced by single quotes.
 
 ## Configurations
 

docs/src/guides/tables.md

@@ -636,70 +636,6 @@ The `values` parameter is used to provide the new values for the columns as lite
 
     When rows are updated, they are moved out of the index. The row will still show up in ANN queries, but the query will not be as fast as it would be if the row was in the index. If you update a large proportion of rows, consider rebuilding the index afterwards.
 
-## Consistency
-
-In LanceDB OSS, users can set the `read_consistency_interval` parameter on connections to achieve different levels of read consistency. This parameter determines how frequently the database synchronizes with the underlying storage system to check for updates made by other processes. If another process updates a table, the database will not see the changes until the next synchronization.
-
-There are three possible settings for `read_consistency_interval`:
-
-1. **Unset (default)**: The database does not check for updates to tables made by other processes. This provides the best query performance, but means that clients may not see the most up-to-date data. This setting is suitable for applications where the data does not change during the lifetime of the table reference.
-2. **Zero seconds (Strong consistency)**: The database checks for updates on every read. This provides the strongest consistency guarantees, ensuring that all clients see the latest committed data. However, it has the most overhead. This setting is suitable when consistency matters more than having high QPS.
-3. **Custom interval (Eventual consistency)**: The database checks for updates at a custom interval, such as every 5 seconds. This provides eventual consistency, allowing for some lag between write and read operations. Performance wise, this is a middle ground between strong consistency and no consistency check. This setting is suitable for applications where immediate consistency is not critical, but clients should see updated data eventually.
-
-!!! tip "Consistency in LanceDB Cloud"
-
-    This is only tune-able in LanceDB OSS. In LanceDB Cloud, readers are always eventually consistent.
-
-=== "Python"
-    
-    To set strong consistency, use `timedelta(0)`:
-
-    ```python
-    from datetime import timedelta
-    db = lancedb.connect("./.lancedb",. read_consistency_interval=timedelta(0))
-    table = db.open_table("my_table")
-    ```
-
-    For eventual consistency, use a custom `timedelta`:
-
-    ```python
-    from datetime import timedelta
-    db = lancedb.connect("./.lancedb", read_consistency_interval=timedelta(seconds=5))
-    table = db.open_table("my_table")
-    ```
-
-    By default, a `Table` will never check for updates from other writers. To manually check for updates you can use `checkout_latest`:
-
-    ```python
-    db = lancedb.connect("./.lancedb")
-    table = db.open_table("my_table")
-    
-    # (Other writes happen to my_table from another process)
-
-    # Check for updates
-    table.checkout_latest()
-    ```
-
-=== "JavaScript/Typescript"
-
-    To set strong consistency, use `0`:
-
-    ```javascript
-    const db = await lancedb.connect({ uri: "./.lancedb", readConsistencyInterval: 0 });
-    const table = await db.openTable("my_table");
-    ```
-
-    For eventual consistency, specify the update interval as seconds:
-
-    ```javascript
-    const db = await lancedb.connect({ uri: "./.lancedb", readConsistencyInterval: 5 });
-    const table = await db.openTable("my_table");
-    ```
-
-<!-- Node doesn't yet support the version time travel: https://github.com/lancedb/lancedb/issues/1007 
-    Once it does, we can show manual consistency check for Node as well.
--->
-
 ## What's next?
 
 Learn the best practices on creating an ANN index and getting the most out of it.

docs/src/integrations/index.md

@@ -13,7 +13,7 @@ Get started using these examples and quick links.
 | Integrations | |
 |---|---:|
 | <h3> LlamaIndex </h3>LlamaIndex is a simple, flexible data framework for connecting custom data sources to large language models. Llama index integrates with LanceDB as the serverless VectorDB. <h3>[Lean More](https://gpt-index.readthedocs.io/en/latest/examples/vector_stores/LanceDBIndexDemo.html) </h3> |<img src="../assets/llama-index.jpg" alt="image" width="150" height="auto">|
-| <h3>Langchain</h3>Langchain allows building applications with LLMs through composability <h3>[Lean More](https://python.langchain.com/docs/integrations/vectorstores/lancedb) | <img src="../assets/langchain.png" alt="image" width="150" height="auto">|
+| <h3>Langchain</h3>Langchain allows building applications with LLMs through composability <h3>[Lean More](https://python.langchain.com/en/latest/modules/indexes/vectorstores/examples/lancedb.html) | <img src="../assets/langchain.png" alt="image" width="150" height="auto">|
 | <h3>Langchain TS</h3> Javascript bindings for Langchain. It integrates with LanceDB's serverless vectordb allowing you to build powerful AI applications through composibility using only serverless functions. <h3>[Learn More]( https://js.langchain.com/docs/modules/data_connection/vectorstores/integrations/lancedb) | <img src="../assets/langchain.png" alt="image" width="150" height="auto">|
 | <h3>Voxel51</h3>  It is an open source toolkit that enables you to build better computer vision workflows by improving the quality of your datasets and delivering insights about your models.<h3>[Learn More](./voxel51.md) | <img src="../assets/voxel.gif" alt="image" width="150" height="auto">|
 | <h3>PromptTools</h3>  Offers a set of free, open-source tools for testing and experimenting with models, prompts, and configurations. The core idea is to enable developers to evaluate prompts using familiar interfaces like code and notebooks. You can use it to experiment with different configurations of LanceDB, and test how LanceDB integrates with the LLM of your choice.<h3>[Learn More](./prompttools.md) | <img src="../assets/prompttools.jpeg" alt="image" width="150" height="auto">|

docs/src/notebooks/DisappearingEmbeddingFunction.ipynb

@@ -290,7 +290,7 @@
         "from lancedb.pydantic import LanceModel, Vector\n",
         "\n",
         "class Pets(LanceModel):\n",
-        "    vector: Vector(clip.ndims()) = clip.VectorField()\n",
+        "    vector: Vector(clip.ndims) = clip.VectorField()\n",
         "    image_uri: str = clip.SourceField()\n",
         "\n",
         "    @property\n",
@@ -360,7 +360,7 @@
         "    table = db.create_table(\"pets\", schema=Pets)\n",
         "    # use a sampling of 1000 images\n",
         "    p = Path(\"~/Downloads/images\").expanduser()\n",
-        "    uris = [str(f) for f in p.glob(\"*.jpg\")]\n",
+        "    uris = [str(f) for f in p.iterdir()]\n",
         "    uris = sample(uris, 1000)\n",
         "    table.add(pd.DataFrame({\"image_uri\": uris}))"
       ]
@@ -543,7 +543,7 @@
       ],
       "source": [
         "from PIL import Image\n",
-        "p = Path(\"~/Downloads/images/samoyed_100.jpg\").expanduser()\n",
+        "p = Path(\"/Users/changshe/Downloads/images/samoyed_100.jpg\")\n",
         "query_image = Image.open(p)\n",
         "query_image"
       ]

docs/src/notebooks/diffusiondb/datagen.py

@@ -23,8 +23,10 @@ from multiprocessing import Pool
 import lance
 import pyarrow as pa
 from datasets import load_dataset
+from PIL import Image
 from transformers import CLIPModel, CLIPProcessor, CLIPTokenizerFast
 
+import lancedb
 
 MODEL_ID = "openai/clip-vit-base-patch32"
 

docs/src/python/duckdb.md

@@ -1,9 +1,6 @@
 # DuckDB
 
-In Python, LanceDB tables can also be queried with [DuckDB](https://duckdb.org/), an in-process SQL OLAP database. This means you can write complex SQL queries to analyze your data in LanceDB.
-
-This integration is done via [Apache Arrow](https://duckdb.org/docs/guides/python/sql_on_arrow), which provides zero-copy data sharing between LanceDB and DuckDB. DuckDB is capable of passing down column selections and basic filters to LanceDB, reducing the amount of data that needs to be scanned to perform your query. Finally, the integration allows streaming data from LanceDB tables, allowing you to aggregate tables that won't fit into memory. All of this uses the same mechanism described in DuckDB's blog post *[DuckDB quacks Arrow](https://duckdb.org/2021/12/03/duck-arrow.html)*.
-
+LanceDB is very well-integrated with [DuckDB](https://duckdb.org/), an in-process SQL OLAP database. This integration is done via [Arrow](https://duckdb.org/docs/guides/python/sql_on_arrow) .
 
 We can demonstrate this by first installing `duckdb` and `lancedb`.
 
@@ -22,15 +19,14 @@ data = [
     {"vector": [5.9, 26.5], "item": "bar", "price": 20.0}
 ]
 table = db.create_table("pd_table", data=data)
+arrow_table = table.to_arrow()
 ```
 
-To query the table, first call `to_lance` to convert the table to a "dataset", which is an object that can be queried by DuckDB. Then all you need to do is reference that dataset by the same name in your SQL query.
+DuckDB can directly query the `pyarrow.Table` object:
 
 ```python
 import duckdb
 
-arrow_table = table.to_lance()
-
 duckdb.query("SELECT * FROM arrow_table")
 ```
 

docs/src/python/python.md

@@ -24,12 +24,6 @@ pip install lancedb
 
 ::: lancedb.query.LanceQueryBuilder
 
-::: lancedb.query.LanceVectorQueryBuilder
-
-::: lancedb.query.LanceFtsQueryBuilder
-
-::: lancedb.query.LanceHybridQueryBuilder
-
 ## Embeddings
 
 ::: lancedb.embeddings.registry.EmbeddingFunctionRegistry
@@ -68,22 +62,10 @@ pip install lancedb
 
 ## Integrations
 
-## Pydantic
+### Pydantic
 
 ::: lancedb.pydantic.pydantic_to_schema
 
 ::: lancedb.pydantic.vector
 
 ::: lancedb.pydantic.LanceModel
-
-## Reranking
-
-::: lancedb.rerankers.linear_combination.LinearCombinationReranker
-
-::: lancedb.rerankers.cohere.CohereReranker
-
-::: lancedb.rerankers.colbert.ColbertReranker
-
-::: lancedb.rerankers.cross_encoder.CrossEncoderReranker
-
-::: lancedb.rerankers.openai.OpenaiReranker

node/.eslintrc.js

@@ -13,10 +13,5 @@ module.exports = {
   },
   rules: {
     "@typescript-eslint/method-signature-style": "off",
-    "@typescript-eslint/quotes": "off",
-    "@typescript-eslint/semi": "off",
-    "@typescript-eslint/explicit-function-return-type": "off",
-    "@typescript-eslint/space-before-function-paren": "off",
-    "@typescript-eslint/indent": "off",
   }
 }

node/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "vectordb",
-  "version": "0.4.11",
+  "version": "0.4.10",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "vectordb",
-      "version": "0.4.11",
+      "version": "0.4.10",
       "cpu": [
         "x64",
         "arm64"
@@ -18,7 +18,9 @@
         "win32"
       ],
       "dependencies": {
+        "@apache-arrow/ts": "^14.0.2",
         "@neon-rs/load": "^0.0.74",
+        "apache-arrow": "^14.0.2",
         "axios": "^1.4.0"
       },
       "devDependencies": {
@@ -31,7 +33,6 @@
         "@types/temp": "^0.9.1",
         "@types/uuid": "^9.0.3",
         "@typescript-eslint/eslint-plugin": "^5.59.1",
-        "apache-arrow-old": "npm:apache-arrow@13.0.0",
         "cargo-cp-artifact": "^0.1",
         "chai": "^4.3.7",
         "chai-as-promised": "^7.1.1",
@@ -52,15 +53,11 @@
         "uuid": "^9.0.0"
       },
       "optionalDependencies": {
-        "@lancedb/vectordb-darwin-arm64": "0.4.11",
-        "@lancedb/vectordb-darwin-x64": "0.4.11",
-        "@lancedb/vectordb-linux-arm64-gnu": "0.4.11",
-        "@lancedb/vectordb-linux-x64-gnu": "0.4.11",
-        "@lancedb/vectordb-win32-x64-msvc": "0.4.11"
-      },
-      "peerDependencies": {
-        "@apache-arrow/ts": "^14.0.2",
-        "apache-arrow": "^14.0.2"
+        "@lancedb/vectordb-darwin-arm64": "0.4.10",
+        "@lancedb/vectordb-darwin-x64": "0.4.10",
+        "@lancedb/vectordb-linux-arm64-gnu": "0.4.10",
+        "@lancedb/vectordb-linux-x64-gnu": "0.4.10",
+        "@lancedb/vectordb-win32-x64-msvc": "0.4.10"
       }
     },
     "node_modules/@75lb/deep-merge": {
@@ -96,7 +93,6 @@
       "version": "14.0.2",
       "resolved": "https://registry.npmjs.org/@apache-arrow/ts/-/ts-14.0.2.tgz",
       "integrity": "sha512-CtwAvLkK0CZv7xsYeCo91ml6PvlfzAmAJZkRYuz2GNBwfYufj5SVi0iuSMwIMkcU/szVwvLdzORSLa5PlF/2ug==",
-      "peer": true,
       "dependencies": {
         "@types/command-line-args": "5.2.0",
         "@types/command-line-usage": "5.0.2",
@@ -113,8 +109,7 @@
     "node_modules/@apache-arrow/ts/node_modules/@types/node": {
       "version": "20.3.0",
       "resolved": "https://registry.npmjs.org/@types/node/-/node-20.3.0.tgz",
-      "integrity": "sha512-cumHmIAf6On83X7yP+LrsEyUOf/YlociZelmpRYaGFydoaPdxdt80MAbu6vWerQT2COCp2nPvHdsbD7tHn/YlQ==",
-      "peer": true
+      "integrity": "sha512-cumHmIAf6On83X7yP+LrsEyUOf/YlociZelmpRYaGFydoaPdxdt80MAbu6vWerQT2COCp2nPvHdsbD7tHn/YlQ=="
     },
     "node_modules/@cargo-messages/android-arm-eabi": {
       "version": "0.0.160",
@@ -334,9 +329,9 @@
       }
     },
     "node_modules/@lancedb/vectordb-darwin-arm64": {
-      "version": "0.4.11",
-      "resolved": "https://registry.npmjs.org/@lancedb/vectordb-darwin-arm64/-/vectordb-darwin-arm64-0.4.11.tgz",
-      "integrity": "sha512-JDOKmFnuJPFkA7ZmrzBJolROwSjWr7yMvAbi40uLBc25YbbVezodd30u2EFtIwWwtk1GqNYRZ49FZOElKYeC/Q==",
+      "version": "0.4.10",
+      "resolved": "https://registry.npmjs.org/@lancedb/vectordb-darwin-arm64/-/vectordb-darwin-arm64-0.4.10.tgz",
+      "integrity": "sha512-y/uHOGb0g15pvqv5tdTyZ6oN+0QVpBmZDzKFWW6pPbuSZjB2uPqcs+ti0RB+AUdmS21kavVQqaNsw/HLKEGrHA==",
       "cpu": [
         "arm64"
       ],
@@ -346,9 +341,9 @@
       ]
     },
     "node_modules/@lancedb/vectordb-darwin-x64": {
-      "version": "0.4.11",
-      "resolved": "https://registry.npmjs.org/@lancedb/vectordb-darwin-x64/-/vectordb-darwin-x64-0.4.11.tgz",
-      "integrity": "sha512-iy6r+8tp2v1EFgJV52jusXtxgO6NY6SkpOdX41xPqN2mQWMkfUAR9Xtks1mgknjPOIKH4MRc8ZS0jcW/UWmilQ==",
+      "version": "0.4.10",
+      "resolved": "https://registry.npmjs.org/@lancedb/vectordb-darwin-x64/-/vectordb-darwin-x64-0.4.10.tgz",
+      "integrity": "sha512-XbfR58OkQpAe0xMSTrwJh9ZjGSzG9EZ7zwO6HfYem8PxcLYAcC6eWRWoSG/T0uObyrPTcYYyvHsp0eNQWYBFAQ==",
       "cpu": [
         "x64"
       ],
@@ -358,9 +353,9 @@
       ]
     },
     "node_modules/@lancedb/vectordb-linux-arm64-gnu": {
-      "version": "0.4.11",
-      "resolved": "https://registry.npmjs.org/@lancedb/vectordb-linux-arm64-gnu/-/vectordb-linux-arm64-gnu-0.4.11.tgz",
-      "integrity": "sha512-5K6IVcTMuH0SZBjlqB5Gg39WC889FpTwIWKufxzQMMXrzxo5J3lKUHVoR28RRlNhDF2d9kZXBEyCpIfDFsV9iQ==",
+      "version": "0.4.10",
+      "resolved": "https://registry.npmjs.org/@lancedb/vectordb-linux-arm64-gnu/-/vectordb-linux-arm64-gnu-0.4.10.tgz",
+      "integrity": "sha512-x40WKH9b+KxorRmKr9G7fv8p5mMj8QJQvRMA0v6v+nbZHr2FLlAZV+9mvhHOnm4AGIkPP5335cUgv6Qz6hgwkQ==",
       "cpu": [
         "arm64"
       ],
@@ -370,9 +365,9 @@
       ]
     },
     "node_modules/@lancedb/vectordb-linux-x64-gnu": {
-      "version": "0.4.11",
-      "resolved": "https://registry.npmjs.org/@lancedb/vectordb-linux-x64-gnu/-/vectordb-linux-x64-gnu-0.4.11.tgz",
-      "integrity": "sha512-hF9ZChsdqKqqnivOzd9mE7lC3PmhZadXtwThi2RrsPiOLoEaGDfmr6Ni3amVQnB3bR8YEJtTxdQxe0NC4uW/8g==",
+      "version": "0.4.10",
+      "resolved": "https://registry.npmjs.org/@lancedb/vectordb-linux-x64-gnu/-/vectordb-linux-x64-gnu-0.4.10.tgz",
+      "integrity": "sha512-CTGPpuzlqq2nVjUxI9gAJOT1oBANIovtIaFsOmBSnEAHgX7oeAxKy2b6L/kJzsgqSzvR5vfLwYcWFrr6ZmBxSA==",
       "cpu": [
         "x64"
       ],
@@ -382,9 +377,9 @@
       ]
     },
     "node_modules/@lancedb/vectordb-win32-x64-msvc": {
-      "version": "0.4.11",
-      "resolved": "https://registry.npmjs.org/@lancedb/vectordb-win32-x64-msvc/-/vectordb-win32-x64-msvc-0.4.11.tgz",
-      "integrity": "sha512-0+9ut1ccKoqIyGxsVixwx3771Z+DXpl5WfSmOeA8kf3v3jlOg2H+0YUahiXLDid2ju+yeLPrAUYm7A1gKHVhew==",
+      "version": "0.4.10",
+      "resolved": "https://registry.npmjs.org/@lancedb/vectordb-win32-x64-msvc/-/vectordb-win32-x64-msvc-0.4.10.tgz",
+      "integrity": "sha512-Fd7r74coZyrKzkfXg4WthqOL+uKyJyPTia6imcrMNqKOlTGdKmHf02Qi2QxWZrFaabkRYo4Tpn5FeRJ3yYX8CA==",
       "cpu": [
         "x64"
       ],
@@ -953,7 +948,6 @@
       "version": "14.0.2",
       "resolved": "https://registry.npmjs.org/apache-arrow/-/apache-arrow-14.0.2.tgz",
       "integrity": "sha512-EBO2xJN36/XoY81nhLcwCJgFwkboDZeyNQ+OPsG7bCoQjc2BT0aTyH/MR6SrL+LirSNz+cYqjGRlupMMlP1aEg==",
-      "peer": true,
       "dependencies": {
         "@types/command-line-args": "5.2.0",
         "@types/command-line-usage": "5.0.2",
@@ -970,39 +964,10 @@
         "arrow2csv": "bin/arrow2csv.js"
       }
     },
-    "node_modules/apache-arrow-old": {
-      "name": "apache-arrow",
-      "version": "13.0.0",
-      "resolved": "https://registry.npmjs.org/apache-arrow/-/apache-arrow-13.0.0.tgz",
-      "integrity": "sha512-3gvCX0GDawWz6KFNC28p65U+zGh/LZ6ZNKWNu74N6CQlKzxeoWHpi4CgEQsgRSEMuyrIIXi1Ea2syja7dwcHvw==",
-      "dev": true,
-      "dependencies": {
-        "@types/command-line-args": "5.2.0",
-        "@types/command-line-usage": "5.0.2",
-        "@types/node": "20.3.0",
-        "@types/pad-left": "2.1.1",
-        "command-line-args": "5.2.1",
-        "command-line-usage": "7.0.1",
-        "flatbuffers": "23.5.26",
-        "json-bignum": "^0.0.3",
-        "pad-left": "^2.1.0",
-        "tslib": "^2.5.3"
-      },
-      "bin": {
-        "arrow2csv": "bin/arrow2csv.js"
-      }
-    },
-    "node_modules/apache-arrow-old/node_modules/@types/node": {
-      "version": "20.3.0",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-20.3.0.tgz",
-      "integrity": "sha512-cumHmIAf6On83X7yP+LrsEyUOf/YlociZelmpRYaGFydoaPdxdt80MAbu6vWerQT2COCp2nPvHdsbD7tHn/YlQ==",
-      "dev": true
-    },
     "node_modules/apache-arrow/node_modules/@types/node": {
       "version": "20.3.0",
       "resolved": "https://registry.npmjs.org/@types/node/-/node-20.3.0.tgz",
-      "integrity": "sha512-cumHmIAf6On83X7yP+LrsEyUOf/YlociZelmpRYaGFydoaPdxdt80MAbu6vWerQT2COCp2nPvHdsbD7tHn/YlQ==",
-      "peer": true
+      "integrity": "sha512-cumHmIAf6On83X7yP+LrsEyUOf/YlociZelmpRYaGFydoaPdxdt80MAbu6vWerQT2COCp2nPvHdsbD7tHn/YlQ=="
     },
     "node_modules/arg": {
       "version": "4.1.3",

node/package.json

@@ -1,12 +1,12 @@
 {
   "name": "vectordb",
-  "version": "0.4.11",
+  "version": "0.4.10",
   "description": " Serverless, low-latency vector database for AI applications",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
     "tsc": "tsc -b",
-    "build": "npm run tsc && cargo-cp-artifact --artifact cdylib lancedb-node index.node -- cargo build --message-format=json",
+    "build": "npm run tsc && cargo-cp-artifact --artifact cdylib vectordb-node index.node -- cargo build --message-format=json",
     "build-release": "npm run build -- --release",
     "test": "npm run tsc && mocha -recursive dist/test",
     "integration-test": "npm run tsc && mocha -recursive dist/integration_test",
@@ -41,7 +41,6 @@
     "@types/temp": "^0.9.1",
     "@types/uuid": "^9.0.3",
     "@typescript-eslint/eslint-plugin": "^5.59.1",
-    "apache-arrow-old": "npm:apache-arrow@13.0.0",
     "cargo-cp-artifact": "^0.1",
     "chai": "^4.3.7",
     "chai-as-promised": "^7.1.1",
@@ -62,12 +61,10 @@
     "uuid": "^9.0.0"
   },
   "dependencies": {
-    "@neon-rs/load": "^0.0.74",
-    "axios": "^1.4.0"
-  },
-  "peerDependencies": {
     "@apache-arrow/ts": "^14.0.2",
-    "apache-arrow": "^14.0.2"
+    "@neon-rs/load": "^0.0.74",
+    "apache-arrow": "^14.0.2",
+    "axios": "^1.4.0"
   },
   "os": [
     "darwin",
@@ -88,10 +85,10 @@
     }
   },
   "optionalDependencies": {
-    "@lancedb/vectordb-darwin-arm64": "0.4.11",
-    "@lancedb/vectordb-darwin-x64": "0.4.11",
-    "@lancedb/vectordb-linux-arm64-gnu": "0.4.11",
-    "@lancedb/vectordb-linux-x64-gnu": "0.4.11",
-    "@lancedb/vectordb-win32-x64-msvc": "0.4.11"
+    "@lancedb/vectordb-darwin-arm64": "0.4.10",
+    "@lancedb/vectordb-darwin-x64": "0.4.10",
+    "@lancedb/vectordb-linux-arm64-gnu": "0.4.10",
+    "@lancedb/vectordb-linux-x64-gnu": "0.4.10",
+    "@lancedb/vectordb-win32-x64-msvc": "0.4.10"
   }
 }

node/src/arrow.ts

@@ -20,20 +20,19 @@ import {
   type Vector,
   FixedSizeList,
   vectorFromArray,
-  Schema,
+  type Schema,
   Table as ArrowTable,
   RecordBatchStreamWriter,
   List,
   RecordBatch,
   makeData,
   Struct,
-  Float,
+  type Float,
   DataType,
   Binary,
   Float32
 } from 'apache-arrow'
 import { type EmbeddingFunction } from './index'
-import { sanitizeSchema } from './sanitize'
 
 /*
  * Options to control how a column should be converted to a vector array
@@ -202,13 +201,10 @@ export function makeArrowTable (
   }
 
   const opt = new MakeArrowTableOptions(options !== undefined ? options : {})
-  if (opt.schema !== undefined && opt.schema !== null) {
-    opt.schema = sanitizeSchema(opt.schema)
-  }
   const columns: Record<string, Vector> = {}
   // TODO: sample dataset to find missing columns
   // Prefer the field ordering of the schema, if present
-  const columnNames = ((opt.schema) != null) ? (opt.schema.names as string[]) : Object.keys(data[0])
+  const columnNames = ((options?.schema) != null) ? (options?.schema?.names as string[]) : Object.keys(data[0])
   for (const colName of columnNames) {
     if (data.length !== 0 && !Object.prototype.hasOwnProperty.call(data[0], colName)) {
       // The field is present in the schema, but not in the data, skip it
@@ -333,9 +329,6 @@ async function applyEmbeddings<T> (table: ArrowTable, embeddings?: EmbeddingFunc
   if (embeddings == null) {
     return table
   }
-  if (schema !== undefined && schema !== null) {
-    schema = sanitizeSchema(schema)
-  }
 
   // Convert from ArrowTable to Record<String, Vector>
   const colEntries = [...Array(table.numCols).keys()].map((_, idx) => {
@@ -446,9 +439,6 @@ export async function fromRecordsToBuffer<T> (
   embeddings?: EmbeddingFunction<T>,
   schema?: Schema
 ): Promise<Buffer> {
-  if (schema !== undefined && schema !== null) {
-    schema = sanitizeSchema(schema)
-  }
   const table = await convertToTable(data, embeddings, { schema })
   const writer = RecordBatchFileWriter.writeAll(table)
   return Buffer.from(await writer.toUint8Array())
@@ -466,9 +456,6 @@ export async function fromRecordsToStreamBuffer<T> (
   embeddings?: EmbeddingFunction<T>,
   schema?: Schema
 ): Promise<Buffer> {
-  if (schema !== null && schema !== undefined) {
-    schema = sanitizeSchema(schema)
-  }
   const table = await convertToTable(data, embeddings, { schema })
   const writer = RecordBatchStreamWriter.writeAll(table)
   return Buffer.from(await writer.toUint8Array())
@@ -487,9 +474,6 @@ export async function fromTableToBuffer<T> (
   embeddings?: EmbeddingFunction<T>,
   schema?: Schema
 ): Promise<Buffer> {
-  if (schema !== null && schema !== undefined) {
-    schema = sanitizeSchema(schema)
-  }
   const tableWithEmbeddings = await applyEmbeddings(table, embeddings, schema)
   const writer = RecordBatchFileWriter.writeAll(tableWithEmbeddings)
   return Buffer.from(await writer.toUint8Array())
@@ -508,9 +492,6 @@ export async function fromTableToStreamBuffer<T> (
   embeddings?: EmbeddingFunction<T>,
   schema?: Schema
 ): Promise<Buffer> {
-  if (schema !== null && schema !== undefined) {
-    schema = sanitizeSchema(schema)
-  }
   const tableWithEmbeddings = await applyEmbeddings(table, embeddings, schema)
   const writer = RecordBatchStreamWriter.writeAll(tableWithEmbeddings)
   return Buffer.from(await writer.toUint8Array())
@@ -547,5 +528,5 @@ function alignTable (table: ArrowTable, schema: Schema): ArrowTable {
 
 // Creates an empty Arrow Table
 export function createEmptyTable (schema: Schema): ArrowTable {
-  return new ArrowTable(sanitizeSchema(schema))
+  return new ArrowTable(schema)
 }

node/src/index.ts

@@ -42,10 +42,7 @@ const {
   tableCompactFiles,
   tableListIndices,
   tableIndexStats,
-  tableSchema,
-  tableAddColumns,
-  tableAlterColumns,
-  tableDropColumns
+  tableSchema
   // eslint-disable-next-line @typescript-eslint/no-var-requires
 } = require('../native.js')
 
@@ -99,19 +96,6 @@ export interface ConnectionOptions {
    * This is useful for local testing.
    */
   hostOverride?: string
-
-  /**
-   * (For LanceDB OSS only): The interval, in seconds, at which to check for
-   * updates to the table from other processes. If None, then consistency is not
-   * checked. For performance reasons, this is the default. For strong
-   * consistency, set this to zero seconds. Then every read will check for
-   * updates from other processes. As a compromise, you can set this to a
-   * non-zero value for eventual consistency. If more than that interval
-   * has passed since the last check, then the table will be checked for updates.
-   * Note: this consistency only applies to read operations. Write operations are
-   * always consistent.
-   */
-  readConsistencyInterval?: number
 }
 
 function getAwsArgs (opts: ConnectionOptions): any[] {
@@ -197,8 +181,7 @@ export async function connect (
     opts.awsCredentials?.accessKeyId,
     opts.awsCredentials?.secretKey,
     opts.awsCredentials?.sessionToken,
-    opts.awsRegion,
-    opts.readConsistencyInterval
+    opts.awsRegion
   )
   return new LocalConnection(db, opts)
 }
@@ -341,7 +324,6 @@ export interface Table<T = number[]> {
    *
    * @param column The column to index
    * @param replace If false, fail if an index already exists on the column
-   * it is always set to true for remote connections
    *
    * Scalar indices, like vector indices, can be used to speed up scans.  A scalar
    * index can speed up scans that contain filter expressions on the indexed column.
@@ -385,7 +367,7 @@ export interface Table<T = number[]> {
    * await table.createScalarIndex('my_col')
    * ```
    */
-  createScalarIndex: (column: string, replace?: boolean) => Promise<void>
+  createScalarIndex: (column: string, replace: boolean) => Promise<void>
 
   /**
    * Returns the number of rows in this table.
@@ -504,59 +486,6 @@ export interface Table<T = number[]> {
   filter(value: string): Query<T>
 
   schema: Promise<Schema>
-
-  // TODO: Support BatchUDF
-  /**
-   * Add new columns with defined values.
-   *
-   * @param newColumnTransforms pairs of column names and the SQL expression to use
-   *                            to calculate the value of the new column. These
-   *                            expressions will be evaluated for each row in the
-   *                            table, and can reference existing columns in the table.
-   */
-  addColumns(newColumnTransforms: Array<{ name: string, valueSql: string }>): Promise<void>
-
-  /**
-   * Alter the name or nullability of columns.
-   *
-   * @param columnAlterations One or more alterations to apply to columns.
-   */
-  alterColumns(columnAlterations: ColumnAlteration[]): Promise<void>
-
-  /**
-   * Drop one or more columns from the dataset
-   *
-   * This is a metadata-only operation and does not remove the data from the
-   * underlying storage. In order to remove the data, you must subsequently
-   * call ``compact_files`` to rewrite the data without the removed columns and
-   * then call ``cleanup_files`` to remove the old files.
-   *
-   * @param columnNames The names of the columns to drop. These can be nested
-   *                    column references (e.g. "a.b.c") or top-level column
-   *                    names (e.g. "a").
-   */
-  dropColumns(columnNames: string[]): Promise<void>
-}
-
-/**
- * A definition of a column alteration. The alteration changes the column at
- * `path` to have the new name `name`, to be nullable if `nullable` is true,
- * and to have the data type `data_type`. At least one of `rename` or `nullable`
- * must be provided.
- */
-export interface ColumnAlteration {
-  /**
-   * The path to the column to alter. This is a dot-separated path to the column.
-   * If it is a top-level column then it is just the name of the column. If it is
-   * a nested column then it is the path to the column, e.g. "a.b.c" for a column
-   * `c` nested inside a column `b` nested inside a column `a`.
-   */
-  path: string
-  rename?: string
-  /**
-   * Set the new nullability. Note that a nullable column cannot be made non-nullable.
-   */
-  nullable?: boolean
 }
 
 export interface UpdateArgs {
@@ -915,10 +844,7 @@ export class LocalTable<T = number[]> implements Table<T> {
       })
   }
 
-  async createScalarIndex (column: string, replace?: boolean): Promise<void> {
-    if (replace === undefined) {
-      replace = true
-    }
+  async createScalarIndex (column: string, replace: boolean): Promise<void> {
     return tableCreateScalarIndex.call(this._tbl, column, replace)
   }
 
@@ -1088,18 +1014,6 @@ export class LocalTable<T = number[]> implements Table<T> {
       return false
     }
   }
-
-  async addColumns (newColumnTransforms: Array<{ name: string, valueSql: string }>): Promise<void> {
-    return tableAddColumns.call(this._tbl, newColumnTransforms)
-  }
-
-  async alterColumns (columnAlterations: ColumnAlteration[]): Promise<void> {
-    return tableAlterColumns.call(this._tbl, columnAlterations)
-  }
-
-  async dropColumns (columnNames: string[]): Promise<void> {
-    return tableDropColumns.call(this._tbl, columnNames)
-  }
 }
 
 export interface CleanupStats {

node/src/remote/index.ts

@@ -25,8 +25,7 @@ import {
   type UpdateArgs,
   type UpdateSqlArgs,
   makeArrowTable,
-  type MergeInsertArgs,
-  type ColumnAlteration
+  type MergeInsertArgs
 } from '../index'
 import { Query } from '../query'
 
@@ -397,7 +396,7 @@ export class RemoteTable<T = number[]> implements Table<T> {
     }
 
     const column = indexParams.column ?? 'vector'
-    const indexType = 'vector'
+    const indexType = 'vector' // only vector index is supported for remote connections
     const metricType = indexParams.metric_type ?? 'L2'
     const indexCacheSize = indexParams.index_cache_size ?? null
 
@@ -420,25 +419,8 @@ export class RemoteTable<T = number[]> implements Table<T> {
     }
   }
 
-  async createScalarIndex (column: string): Promise<void> {
-    const indexType = 'scalar'
-
-    const data = {
-      column,
-      index_type: indexType,
-      replace: true
-    }
-    const res = await this._client.post(
-      `/v1/table/${this._name}/create_scalar_index/`,
-      data
-    )
-    if (res.status !== 200) {
-      throw new Error(
-        `Server Error, status: ${res.status}, ` +
-          // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-          `message: ${res.statusText}: ${res.data}`
-      )
-    }
+  async createScalarIndex (column: string, replace: boolean): Promise<void> {
+    throw new Error('Not implemented')
   }
 
   async countRows (): Promise<number> {
@@ -492,16 +474,4 @@ export class RemoteTable<T = number[]> implements Table<T> {
       numUnindexedRows: results.data.num_unindexed_rows
     }
   }
-
-  async addColumns (newColumnTransforms: Array<{ name: string, valueSql: string }>): Promise<void> {
-    throw new Error('Add columns is not yet supported in LanceDB Cloud.')
-  }
-
-  async alterColumns (columnAlterations: ColumnAlteration[]): Promise<void> {
-    throw new Error('Alter columns is not yet supported in LanceDB Cloud.')
-  }
-
-  async dropColumns (columnNames: string[]): Promise<void> {
-    throw new Error('Drop columns is not yet supported in LanceDB Cloud.')
-  }
 }

node/src/sanitize.ts

@@ -1,501 +0,0 @@
-// Copyright 2023 LanceDB Developers.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// 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.
-
-import {
-  Field,
-  Utf8,
-  FixedSizeBinary,
-  FixedSizeList,
-  Schema,
-  List,
-  Struct,
-  Float,
-  Bool,
-  Date_,
-  Decimal,
-  DataType,
-  Dictionary,
-  Binary,
-  Float32,
-  Interval,
-  Map_,
-  Duration,
-  Union,
-  Time,
-  Timestamp,
-  Type,
-  Null,
-  Int,
-  type Precision,
-  type DateUnit,
-  Int8,
-  Int16,
-  Int32,
-  Int64,
-  Uint8,
-  Uint16,
-  Uint32,
-  Uint64,
-  Float16,
-  Float64,
-  DateDay,
-  DateMillisecond,
-  DenseUnion,
-  SparseUnion,
-  TimeNanosecond,
-  TimeMicrosecond,
-  TimeMillisecond,
-  TimeSecond,
-  TimestampNanosecond,
-  TimestampMicrosecond,
-  TimestampMillisecond,
-  TimestampSecond,
-  IntervalDayTime,
-  IntervalYearMonth,
-  DurationNanosecond,
-  DurationMicrosecond,
-  DurationMillisecond,
-  DurationSecond,
-} from "apache-arrow";
-import type { IntBitWidth, TimeBitWidth } from "apache-arrow/type";
-
-function sanitizeMetadata(
-  metadataLike?: unknown
-): Map<string, string> | undefined {
-  if (metadataLike === undefined || metadataLike === null) {
-    return undefined;
-  }
-  if (!(metadataLike instanceof Map)) {
-    throw Error("Expected metadata, if present, to be a Map<string, string>");
-  }
-  for (const item of metadataLike) {
-    if (!(typeof item[0] === "string" || !(typeof item[1] === "string"))) {
-      throw Error(
-        "Expected metadata, if present, to be a Map<string, string> but it had non-string keys or values"
-      );
-    }
-  }
-  return metadataLike as Map<string, string>;
-}
-
-function sanitizeInt(typeLike: object) {
-  if (
-    !("bitWidth" in typeLike) ||
-    typeof typeLike.bitWidth !== "number" ||
-    !("isSigned" in typeLike) ||
-    typeof typeLike.isSigned !== "boolean"
-  ) {
-    throw Error(
-      "Expected an Int Type to have a `bitWidth` and `isSigned` property"
-    );
-  }
-  return new Int(typeLike.isSigned, typeLike.bitWidth as IntBitWidth);
-}
-
-function sanitizeFloat(typeLike: object) {
-  if (!("precision" in typeLike) || typeof typeLike.precision !== "number") {
-    throw Error("Expected a Float Type to have a `precision` property");
-  }
-  return new Float(typeLike.precision as Precision);
-}
-
-function sanitizeDecimal(typeLike: object) {
-  if (
-    !("scale" in typeLike) ||
-    typeof typeLike.scale !== "number" ||
-    !("precision" in typeLike) ||
-    typeof typeLike.precision !== "number" ||
-    !("bitWidth" in typeLike) ||
-    typeof typeLike.bitWidth !== "number"
-  ) {
-    throw Error(
-      "Expected a Decimal Type to have `scale`, `precision`, and `bitWidth` properties"
-    );
-  }
-  return new Decimal(typeLike.scale, typeLike.precision, typeLike.bitWidth);
-}
-
-function sanitizeDate(typeLike: object) {
-  if (!("unit" in typeLike) || typeof typeLike.unit !== "number") {
-    throw Error("Expected a Date type to have a `unit` property");
-  }
-  return new Date_(typeLike.unit as DateUnit);
-}
-
-function sanitizeTime(typeLike: object) {
-  if (
-    !("unit" in typeLike) ||
-    typeof typeLike.unit !== "number" ||
-    !("bitWidth" in typeLike) ||
-    typeof typeLike.bitWidth !== "number"
-  ) {
-    throw Error(
-      "Expected a Time type to have `unit` and `bitWidth` properties"
-    );
-  }
-  return new Time(typeLike.unit, typeLike.bitWidth as TimeBitWidth);
-}
-
-function sanitizeTimestamp(typeLike: object) {
-  if (!("unit" in typeLike) || typeof typeLike.unit !== "number") {
-    throw Error("Expected a Timestamp type to have a `unit` property");
-  }
-  let timezone = null;
-  if ("timezone" in typeLike && typeof typeLike.timezone === "string") {
-    timezone = typeLike.timezone;
-  }
-  return new Timestamp(typeLike.unit, timezone);
-}
-
-function sanitizeTypedTimestamp(
-  typeLike: object,
-  Datatype:
-    | typeof TimestampNanosecond
-    | typeof TimestampMicrosecond
-    | typeof TimestampMillisecond
-    | typeof TimestampSecond
-) {
-  let timezone = null;
-  if ("timezone" in typeLike && typeof typeLike.timezone === "string") {
-    timezone = typeLike.timezone;
-  }
-  return new Datatype(timezone);
-}
-
-function sanitizeInterval(typeLike: object) {
-  if (!("unit" in typeLike) || typeof typeLike.unit !== "number") {
-    throw Error("Expected an Interval type to have a `unit` property");
-  }
-  return new Interval(typeLike.unit);
-}
-
-function sanitizeList(typeLike: object) {
-  if (!("children" in typeLike) || !Array.isArray(typeLike.children)) {
-    throw Error(
-      "Expected a List type to have an array-like `children` property"
-    );
-  }
-  if (typeLike.children.length !== 1) {
-    throw Error("Expected a List type to have exactly one child");
-  }
-  return new List(sanitizeField(typeLike.children[0]));
-}
-
-function sanitizeStruct(typeLike: object) {
-  if (!("children" in typeLike) || !Array.isArray(typeLike.children)) {
-    throw Error(
-      "Expected a Struct type to have an array-like `children` property"
-    );
-  }
-  return new Struct(typeLike.children.map((child) => sanitizeField(child)));
-}
-
-function sanitizeUnion(typeLike: object) {
-  if (
-    !("typeIds" in typeLike) ||
-    !("mode" in typeLike) ||
-    typeof typeLike.mode !== "number"
-  ) {
-    throw Error(
-      "Expected a Union type to have `typeIds` and `mode` properties"
-    );
-  }
-  if (!("children" in typeLike) || !Array.isArray(typeLike.children)) {
-    throw Error(
-      "Expected a Union type to have an array-like `children` property"
-    );
-  }
-
-  return new Union(
-    typeLike.mode,
-    typeLike.typeIds as any,
-    typeLike.children.map((child) => sanitizeField(child))
-  );
-}
-
-function sanitizeTypedUnion(
-  typeLike: object,
-  UnionType: typeof DenseUnion | typeof SparseUnion
-) {
-  if (!("typeIds" in typeLike)) {
-    throw Error(
-      "Expected a DenseUnion/SparseUnion type to have a `typeIds` property"
-    );
-  }
-  if (!("children" in typeLike) || !Array.isArray(typeLike.children)) {
-    throw Error(
-      "Expected a DenseUnion/SparseUnion type to have an array-like `children` property"
-    );
-  }
-
-  return new UnionType(
-    typeLike.typeIds as any,
-    typeLike.children.map((child) => sanitizeField(child))
-  );
-}
-
-function sanitizeFixedSizeBinary(typeLike: object) {
-  if (!("byteWidth" in typeLike) || typeof typeLike.byteWidth !== "number") {
-    throw Error(
-      "Expected a FixedSizeBinary type to have a `byteWidth` property"
-    );
-  }
-  return new FixedSizeBinary(typeLike.byteWidth);
-}
-
-function sanitizeFixedSizeList(typeLike: object) {
-  if (!("listSize" in typeLike) || typeof typeLike.listSize !== "number") {
-    throw Error("Expected a FixedSizeList type to have a `listSize` property");
-  }
-  if (!("children" in typeLike) || !Array.isArray(typeLike.children)) {
-    throw Error(
-      "Expected a FixedSizeList type to have an array-like `children` property"
-    );
-  }
-  if (typeLike.children.length !== 1) {
-    throw Error("Expected a FixedSizeList type to have exactly one child");
-  }
-  return new FixedSizeList(
-    typeLike.listSize,
-    sanitizeField(typeLike.children[0])
-  );
-}
-
-function sanitizeMap(typeLike: object) {
-  if (!("children" in typeLike) || !Array.isArray(typeLike.children)) {
-    throw Error(
-      "Expected a Map type to have an array-like `children` property"
-    );
-  }
-  if (!("keysSorted" in typeLike) || typeof typeLike.keysSorted !== "boolean") {
-    throw Error("Expected a Map type to have a `keysSorted` property");
-  }
-  return new Map_(
-    typeLike.children.map((field) => sanitizeField(field)) as any,
-    typeLike.keysSorted
-  );
-}
-
-function sanitizeDuration(typeLike: object) {
-  if (!("unit" in typeLike) || typeof typeLike.unit !== "number") {
-    throw Error("Expected a Duration type to have a `unit` property");
-  }
-  return new Duration(typeLike.unit);
-}
-
-function sanitizeDictionary(typeLike: object) {
-  if (!("id" in typeLike) || typeof typeLike.id !== "number") {
-    throw Error("Expected a Dictionary type to have an `id` property");
-  }
-  if (!("indices" in typeLike) || typeof typeLike.indices !== "object") {
-    throw Error("Expected a Dictionary type to have an `indices` property");
-  }
-  if (!("dictionary" in typeLike) || typeof typeLike.dictionary !== "object") {
-    throw Error("Expected a Dictionary type to have an `dictionary` property");
-  }
-  if (!("isOrdered" in typeLike) || typeof typeLike.isOrdered !== "boolean") {
-    throw Error("Expected a Dictionary type to have an `isOrdered` property");
-  }
-  return new Dictionary(
-    sanitizeType(typeLike.dictionary),
-    sanitizeType(typeLike.indices) as any,
-    typeLike.id,
-    typeLike.isOrdered
-  );
-}
-
-function sanitizeType(typeLike: unknown): DataType<any> {
-  if (typeof typeLike !== "object" || typeLike === null) {
-    throw Error("Expected a Type but object was null/undefined");
-  }
-  if (!("typeId" in typeLike) || !(typeof typeLike.typeId !== "function")) {
-    throw Error("Expected a Type to have a typeId function");
-  }
-  let typeId: Type;
-  if (typeof typeLike.typeId === "function") {
-    typeId = (typeLike.typeId as () => unknown)() as Type;
-  } else if (typeof typeLike.typeId === "number") {
-    typeId = typeLike.typeId as Type;
-  } else {
-    throw Error("Type's typeId property was not a function or number");
-  }
-
-  switch (typeId) {
-    case Type.NONE:
-      throw Error("Received a Type with a typeId of NONE");
-    case Type.Null:
-      return new Null();
-    case Type.Int:
-      return sanitizeInt(typeLike);
-    case Type.Float:
-      return sanitizeFloat(typeLike);
-    case Type.Binary:
-      return new Binary();
-    case Type.Utf8:
-      return new Utf8();
-    case Type.Bool:
-      return new Bool();
-    case Type.Decimal:
-      return sanitizeDecimal(typeLike);
-    case Type.Date:
-      return sanitizeDate(typeLike);
-    case Type.Time:
-      return sanitizeTime(typeLike);
-    case Type.Timestamp:
-      return sanitizeTimestamp(typeLike);
-    case Type.Interval:
-      return sanitizeInterval(typeLike);
-    case Type.List:
-      return sanitizeList(typeLike);
-    case Type.Struct:
-      return sanitizeStruct(typeLike);
-    case Type.Union:
-      return sanitizeUnion(typeLike);
-    case Type.FixedSizeBinary:
-      return sanitizeFixedSizeBinary(typeLike);
-    case Type.FixedSizeList:
-      return sanitizeFixedSizeList(typeLike);
-    case Type.Map:
-      return sanitizeMap(typeLike);
-    case Type.Duration:
-      return sanitizeDuration(typeLike);
-    case Type.Dictionary:
-      return sanitizeDictionary(typeLike);
-    case Type.Int8:
-      return new Int8();
-    case Type.Int16:
-      return new Int16();
-    case Type.Int32:
-      return new Int32();
-    case Type.Int64:
-      return new Int64();
-    case Type.Uint8:
-      return new Uint8();
-    case Type.Uint16:
-      return new Uint16();
-    case Type.Uint32:
-      return new Uint32();
-    case Type.Uint64:
-      return new Uint64();
-    case Type.Float16:
-      return new Float16();
-    case Type.Float32:
-      return new Float32();
-    case Type.Float64:
-      return new Float64();
-    case Type.DateMillisecond:
-      return new DateMillisecond();
-    case Type.DateDay:
-      return new DateDay();
-    case Type.TimeNanosecond:
-      return new TimeNanosecond();
-    case Type.TimeMicrosecond:
-      return new TimeMicrosecond();
-    case Type.TimeMillisecond:
-      return new TimeMillisecond();
-    case Type.TimeSecond:
-      return new TimeSecond();
-    case Type.TimestampNanosecond:
-      return sanitizeTypedTimestamp(typeLike, TimestampNanosecond);
-    case Type.TimestampMicrosecond:
-      return sanitizeTypedTimestamp(typeLike, TimestampMicrosecond);
-    case Type.TimestampMillisecond:
-      return sanitizeTypedTimestamp(typeLike, TimestampMillisecond);
-    case Type.TimestampSecond:
-      return sanitizeTypedTimestamp(typeLike, TimestampSecond);
-    case Type.DenseUnion:
-      return sanitizeTypedUnion(typeLike, DenseUnion);
-    case Type.SparseUnion:
-      return sanitizeTypedUnion(typeLike, SparseUnion);
-    case Type.IntervalDayTime:
-      return new IntervalDayTime();
-    case Type.IntervalYearMonth:
-      return new IntervalYearMonth();
-    case Type.DurationNanosecond:
-      return new DurationNanosecond();
-    case Type.DurationMicrosecond:
-      return new DurationMicrosecond();
-    case Type.DurationMillisecond:
-      return new DurationMillisecond();
-    case Type.DurationSecond:
-      return new DurationSecond();
-  }
-}
-
-function sanitizeField(fieldLike: unknown): Field {
-  if (fieldLike instanceof Field) {
-    return fieldLike;
-  }
-  if (typeof fieldLike !== "object" || fieldLike === null) {
-    throw Error("Expected a Field but object was null/undefined");
-  }
-  if (
-    !("type" in fieldLike) ||
-    !("name" in fieldLike) ||
-    !("nullable" in fieldLike)
-  ) {
-    throw Error(
-      "The field passed in is missing a `type`/`name`/`nullable` property"
-    );
-  }
-  const type = sanitizeType(fieldLike.type);
-  const name = fieldLike.name;
-  if (!(typeof name === "string")) {
-    throw Error("The field passed in had a non-string `name` property");
-  }
-  const nullable = fieldLike.nullable;
-  if (!(typeof nullable === "boolean")) {
-    throw Error("The field passed in had a non-boolean `nullable` property");
-  }
-  let metadata;
-  if ("metadata" in fieldLike) {
-    metadata = sanitizeMetadata(fieldLike.metadata);
-  }
-  return new Field(name, type, nullable, metadata);
-}
-
-export function sanitizeSchema(schemaLike: unknown): Schema {
-  if (schemaLike instanceof Schema) {
-    return schemaLike;
-  }
-  if (typeof schemaLike !== "object" || schemaLike === null) {
-    throw Error("Expected a Schema but object was null/undefined");
-  }
-  if (!("fields" in schemaLike)) {
-    throw Error(
-      "The schema passed in does not appear to be a schema (no 'fields' property)"
-    );
-  }
-  let metadata;
-  if ("metadata" in schemaLike) {
-    metadata = sanitizeMetadata(schemaLike.metadata);
-  }
-  if (!Array.isArray(schemaLike.fields)) {
-    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 Schema(sanitizedFields, metadata);
-}

node/src/test/arrow.test.ts

@@ -34,20 +34,8 @@ import {
   List,
   DataType,
   Dictionary,
-  Int64,
-  MetadataVersion
+  Int64
 } from 'apache-arrow'
-import {
-  Dictionary as OldDictionary,
-  Field as OldField,
-  FixedSizeList as OldFixedSizeList,
-  Float32 as OldFloat32,
-  Int32 as OldInt32,
-  Struct as OldStruct,
-  Schema as OldSchema,
-  TimestampNanosecond as OldTimestampNanosecond,
-  Utf8 as OldUtf8
-} from 'apache-arrow-old'
 import { type EmbeddingFunction } from '../embedding/embedding_function'
 
 chaiUse(chaiAsPromised)
@@ -330,31 +318,3 @@ describe('makeEmptyTable', function () {
     await checkTableCreation(async (_, __, schema) => makeEmptyTable(schema))
   })
 })
-
-describe('when using two versions of arrow', function () {
-  it('can still import data', async function() {
-    const schema = new OldSchema([
-      new OldField('id', new OldInt32()),
-      new OldField('vector', new OldFixedSizeList(1024, new OldField("item", new OldFloat32(), true))),
-      new OldField('struct', new OldStruct([
-        new OldField('nested', new OldDictionary(new OldUtf8(), new OldInt32(), 1, true)),
-        new OldField('ts_with_tz', new OldTimestampNanosecond("some_tz")),
-        new OldField('ts_no_tz', new OldTimestampNanosecond(null))
-      ]))
-    ]) as any
-    // We use arrow version 13 to emulate a "foreign arrow" and this version doesn't have metadataVersion
-    // In theory, this wouldn't matter.  We don't rely on that property.  However, it causes deepEqual to
-    // fail so we patch it back in
-    schema.metadataVersion = MetadataVersion.V5
-    const table = makeArrowTable(
-      [],
-      { schema }
-    )
-
-    const buf = await fromTableToBuffer(table)
-    assert.isAbove(buf.byteLength, 0)
-    const actual = tableFromIPC(buf)
-    const actualSchema = actual.schema
-    assert.deepEqual(actualSchema, schema)
-  })
-})

node/src/test/test.ts

@@ -37,10 +37,8 @@ import {
   Utf8,
   Table as ArrowTable,
   vectorFromArray,
-  Float64,
   Float32,
-  Float16,
-  Int64
+  Float16
 } from 'apache-arrow'
 
 const expect = chai.expect
@@ -198,7 +196,7 @@ describe('LanceDB client', function () {
       const table = await con.openTable('vectors')
       const results = await table
         .search([0.1, 0.1])
-        .select(['is_active', 'vector'])
+        .select(['is_active'])
         .execute()
       assert.equal(results.length, 2)
       // vector and _distance are always returned
@@ -1059,63 +1057,3 @@ describe('Compact and cleanup', function () {
     assert.equal(await table.countRows(), 3)
   })
 })
-
-describe('schema evolution', function () {
-  // Create a new sample table
-  it('can add a new column to the schema', async function () {
-    const dir = await track().mkdir('lancejs')
-    const con = await lancedb.connect(dir)
-    const table = await con.createTable('vectors', [
-      { id: 1n, vector: [0.1, 0.2] }
-    ])
-
-    await table.addColumns([{ name: 'price', valueSql: 'cast(10.0 as float)' }])
-
-    const expectedSchema = new Schema([
-      new Field('id', new Int64()),
-      new Field('vector', new FixedSizeList(2, new Field('item', new Float32(), true))),
-      new Field('price', new Float32())
-    ])
-    expect(await table.schema).to.deep.equal(expectedSchema)
-  })
-
-  it('can alter the columns in the schema', async function () {
-    const dir = await track().mkdir('lancejs')
-    const con = await lancedb.connect(dir)
-    const schema = new Schema([
-      new Field('id', new Int64(), false),
-      new Field('vector', new FixedSizeList(2, new Field('item', new Float32(), true))),
-      new Field('price', new Float64(), false)
-    ])
-    const table = await con.createTable('vectors', [
-      { id: 1n, vector: [0.1, 0.2], price: 10.0 }
-    ])
-    expect(await table.schema).to.deep.equal(schema)
-
-    await table.alterColumns([
-      { path: 'id', rename: 'new_id' },
-      { path: 'price', nullable: true }
-    ])
-
-    const expectedSchema = new Schema([
-      new Field('new_id', new Int64(), false),
-      new Field('vector', new FixedSizeList(2, new Field('item', new Float32(), true))),
-      new Field('price', new Float64(), true)
-    ])
-    expect(await table.schema).to.deep.equal(expectedSchema)
-  })
-
-  it('can drop a column from the schema', async function () {
-    const dir = await track().mkdir('lancejs')
-    const con = await lancedb.connect(dir)
-    const table = await con.createTable('vectors', [
-      { id: 1n, vector: [0.1, 0.2] }
-    ])
-    await table.dropColumns(['vector'])
-
-    const expectedSchema = new Schema([
-      new Field('id', new Int64(), false)
-    ])
-    expect(await table.schema).to.deep.equal(expectedSchema)
-  })
-})

nodejs/.eslintignore

@@ -1,3 +0,0 @@
-**/dist/**/*
-**/native.js
-**/native.d.ts

nodejs/.eslintrc.js

@@ -0,0 +1,22 @@
+module.exports = {
+  env: {
+    browser: true,
+    es2021: true,
+  },
+  extends: [
+    "eslint:recommended",
+    "plugin:@typescript-eslint/recommended-type-checked",
+    "plugin:@typescript-eslint/stylistic-type-checked",
+  ],
+  overrides: [],
+  parserOptions: {
+    project: "./tsconfig.json",
+    ecmaVersion: "latest",
+    sourceType: "module",
+  },
+  rules: {
+    "@typescript-eslint/method-signature-style": "off",
+    "@typescript-eslint/no-explicit-any": "off",
+  },
+  ignorePatterns: ["node_modules/", "dist/", "build/", "vectordb/native.*"],
+};

nodejs/.prettierignore

@@ -1 +0,0 @@
-.eslintignore

nodejs/Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "lancedb-nodejs"
+name = "vectordb-nodejs"
 edition.workspace = true
 version = "0.0.0"
 license.workspace = true
@@ -16,7 +16,7 @@ arrow-ipc.workspace = true
 futures.workspace = true
 lance-linalg.workspace = true
 lance.workspace = true
-lancedb = { path = "../rust/lancedb" }
+vectordb = { path = "../rust/vectordb" }
 napi = { version = "2.15", default-features = false, features = [
     "napi7",
     "async"

nodejs/README.md

@@ -2,6 +2,7 @@
 
 It will replace the NodeJS SDK when it is ready.
 
+
 ## Development
 
 ```sh
@@ -9,35 +10,9 @@ npm run build
 npm t
 ```
 
-### Running lint / format
+Generating docs
 
-LanceDb uses eslint for linting. VSCode does not need any plugins to use eslint. However, it
-may need some additional configuration. Make sure that eslint.experimental.useFlatConfig is
-set to true. Also, if your vscode root folder is the repo root then you will need to set
-the eslint.workingDirectories to ["nodejs"]. To manually lint your code you can run:
-
-```sh
-npm run lint
 ```
-
-LanceDb uses prettier for formatting. If you are using VSCode you will need to install the
-"Prettier - Code formatter" extension. You should then configure it to be the default formatter
-for typescript and you should enable format on save. To manually check your code's format you
-can run:
-
-```sh
-npm run chkformat
-```
-
-If you need to manually format your code you can run:
-
-```sh
-npx prettier --write .
-```
-
-### Generating docs
-
-```sh
 npm run docs
 
 cd ../docs

nodejs/__test__/arrow.test.ts

@@ -12,13 +12,9 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+import { makeArrowTable, toBuffer } from "../vectordb/arrow";
 import {
-  convertToTable,
-  fromTableToBuffer,
-  makeArrowTable,
-  makeEmptyTable,
-} from "../dist/arrow";
-import {
+  Int64,
   Field,
   FixedSizeList,
   Float16,
@@ -27,444 +23,98 @@ import {
   tableFromIPC,
   Schema,
   Float64,
-  type Table,
-  Binary,
-  Bool,
-  Utf8,
-  Struct,
-  List,
-  DataType,
-  Dictionary,
-  Int64,
-  Float,
-  Precision,
-  MetadataVersion,
 } from "apache-arrow";
-import {
-  Dictionary as OldDictionary,
-  Field as OldField,
-  FixedSizeList as OldFixedSizeList,
-  Float32 as OldFloat32,
-  Int32 as OldInt32,
-  Struct as OldStruct,
-  Schema as OldSchema,
-  TimestampNanosecond as OldTimestampNanosecond,
-  Utf8 as OldUtf8,
-} from "apache-arrow-old";
-import { type EmbeddingFunction } from "../dist/embedding/embedding_function";
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function sampleRecords(): Array<Record<string, any>> {
-  return [
-    {
-      binary: Buffer.alloc(5),
-      boolean: false,
-      number: 7,
-      string: "hello",
-      struct: { x: 0, y: 0 },
-      list: ["anime", "action", "comedy"],
-    },
-  ];
-}
-
-// Helper method to verify various ways to create a table
-async function checkTableCreation(
-  tableCreationMethod: (
-    records: Record<string, unknown>[],
-    recordsReversed: Record<string, unknown>[],
-    schema: Schema,
-  ) => Promise<Table>,
-  infersTypes: boolean,
-): Promise<void> {
-  const records = sampleRecords();
-  const recordsReversed = [
-    {
-      list: ["anime", "action", "comedy"],
-      struct: { x: 0, y: 0 },
-      string: "hello",
-      number: 7,
-      boolean: false,
-      binary: Buffer.alloc(5),
-    },
-  ];
+test("customized schema", function () {
   const schema = new Schema([
-    new Field("binary", new Binary(), false),
-    new Field("boolean", new Bool(), false),
-    new Field("number", new Float64(), false),
-    new Field("string", new Utf8(), false),
+    new Field("a", new Int32(), true),
+    new Field("b", new Float32(), true),
     new Field(
-      "struct",
-      new Struct([
-        new Field("x", new Float64(), false),
-        new Field("y", new Float64(), false),
-      ]),
+      "c",
+      new FixedSizeList(3, new Field("item", new Float16())),
+      true
     ),
-    new Field("list", new List(new Field("item", new Utf8(), false)), false),
+  ]);
+  const table = makeArrowTable(
+    [
+      { a: 1, b: 2, c: [1, 2, 3] },
+      { a: 4, b: 5, c: [4, 5, 6] },
+      { a: 7, b: 8, c: [7, 8, 9] },
+    ],
+    { schema }
+  );
+
+  expect(table.schema.toString()).toEqual(schema.toString());
+
+  const buf = toBuffer(table);
+  expect(buf.byteLength).toBeGreaterThan(0);
+
+  const actual = tableFromIPC(buf);
+  expect(actual.numRows).toBe(3);
+  const actualSchema = actual.schema;
+  expect(actualSchema.toString()).toStrictEqual(schema.toString());
+});
+
+test("default vector column", function () {
+  const schema = new Schema([
+    new Field("a", new Float64(), true),
+    new Field("b", new Float64(), true),
+    new Field("vector", new FixedSizeList(3, new Field("item", new Float32()))),
+  ]);
+  const table = makeArrowTable([
+    { a: 1, b: 2, vector: [1, 2, 3] },
+    { a: 4, b: 5, vector: [4, 5, 6] },
+    { a: 7, b: 8, vector: [7, 8, 9] },
   ]);
 
-  const table = await tableCreationMethod(records, recordsReversed, schema);
-  schema.fields.forEach((field, idx) => {
-    const actualField = table.schema.fields[idx];
-    // Type inference always assumes nullable=true
-    if (infersTypes) {
-      expect(actualField.nullable).toBe(true);
-    } else {
-      expect(actualField.nullable).toBe(false);
-    }
-    expect(table.getChild(field.name)?.type.toString()).toEqual(
-      field.type.toString(),
-    );
-    expect(table.getChildAt(idx)?.type.toString()).toEqual(
-      field.type.toString(),
-    );
-  });
-}
+  const buf = toBuffer(table);
+  expect(buf.byteLength).toBeGreaterThan(0);
 
-describe("The function makeArrowTable", function () {
-  it("will use data types from a provided schema instead of inference", async function () {
-    const schema = new Schema([
-      new Field("a", new Int32()),
-      new Field("b", new Float32()),
-      new Field("c", new FixedSizeList(3, new Field("item", new Float16()))),
-      new Field("d", new Int64()),
-    ]);
-    const table = makeArrowTable(
-      [
-        { a: 1, b: 2, c: [1, 2, 3], d: 9 },
-        { a: 4, b: 5, c: [4, 5, 6], d: 10 },
-        { a: 7, b: 8, c: [7, 8, 9], d: null },
-      ],
-      { schema },
-    );
+  const actual = tableFromIPC(buf);
+  expect(actual.numRows).toBe(3);
+  const actualSchema = actual.schema;
+  expect(actualSchema.toString()).toEqual(actualSchema.toString());
+});
 
-    const buf = await fromTableToBuffer(table);
-    expect(buf.byteLength).toBeGreaterThan(0);
-
-    const actual = tableFromIPC(buf);
-    expect(actual.numRows).toBe(3);
-    const actualSchema = actual.schema;
-    expect(actualSchema).toEqual(schema);
-  });
-
-  it("will assume the column `vector` is FixedSizeList<Float32> by default", async function () {
-    const schema = new Schema([
-      new Field("a", new Float(Precision.DOUBLE), true),
-      new Field("b", new Float(Precision.DOUBLE), true),
-      new Field(
-        "vector",
-        new FixedSizeList(
-          3,
-          new Field("item", new Float(Precision.SINGLE), true),
-        ),
-        true,
-      ),
-    ]);
-    const table = makeArrowTable([
-      { a: 1, b: 2, vector: [1, 2, 3] },
-      { a: 4, b: 5, vector: [4, 5, 6] },
-      { a: 7, b: 8, vector: [7, 8, 9] },
-    ]);
-
-    const buf = await fromTableToBuffer(table);
-    expect(buf.byteLength).toBeGreaterThan(0);
-
-    const actual = tableFromIPC(buf);
-    expect(actual.numRows).toBe(3);
-    const actualSchema = actual.schema;
-    expect(actualSchema).toEqual(schema);
-  });
-
-  it("can support multiple vector columns", async function () {
-    const schema = new Schema([
-      new Field("a", new Float(Precision.DOUBLE), true),
-      new Field("b", new Float(Precision.DOUBLE), true),
-      new Field(
-        "vec1",
-        new FixedSizeList(3, new Field("item", new Float16(), true)),
-        true,
-      ),
-      new Field(
-        "vec2",
-        new FixedSizeList(3, new Field("item", new Float16(), true)),
-        true,
-      ),
-    ]);
-    const table = makeArrowTable(
-      [
-        { a: 1, b: 2, vec1: [1, 2, 3], vec2: [2, 4, 6] },
-        { a: 4, b: 5, vec1: [4, 5, 6], vec2: [8, 10, 12] },
-        { a: 7, b: 8, vec1: [7, 8, 9], vec2: [14, 16, 18] },
-      ],
-      {
-        vectorColumns: {
-          vec1: { type: new Float16() },
-          vec2: { type: new Float16() },
-        },
-      },
-    );
-
-    const buf = await fromTableToBuffer(table);
-    expect(buf.byteLength).toBeGreaterThan(0);
-
-    const actual = tableFromIPC(buf);
-    expect(actual.numRows).toBe(3);
-    const actualSchema = actual.schema;
-    expect(actualSchema).toEqual(schema);
-  });
-
-  it("will allow different vector column types", async function () {
-    const table = makeArrowTable([{ fp16: [1], fp32: [1], fp64: [1] }], {
+test("2 vector columns", function () {
+  const schema = new Schema([
+    new Field("a", new Float64()),
+    new Field("b", new Float64()),
+    new Field("vec1", new FixedSizeList(3, new Field("item", new Float16()))),
+    new Field("vec2", new FixedSizeList(3, new Field("item", new Float16()))),
+  ]);
+  const table = makeArrowTable(
+    [
+      { a: 1, b: 2, vec1: [1, 2, 3], vec2: [2, 4, 6] },
+      { a: 4, b: 5, vec1: [4, 5, 6], vec2: [8, 10, 12] },
+      { a: 7, b: 8, vec1: [7, 8, 9], vec2: [14, 16, 18] },
+    ],
+    {
       vectorColumns: {
-        fp16: { type: new Float16() },
-        fp32: { type: new Float32() },
-        fp64: { type: new Float64() },
+        vec1: { type: new Float16() },
+        vec2: { type: new Float16() },
       },
-    });
-
-    expect(table.getChild("fp16")?.type.children[0].type.toString()).toEqual(
-      new Float16().toString(),
-    );
-    expect(table.getChild("fp32")?.type.children[0].type.toString()).toEqual(
-      new Float32().toString(),
-    );
-    expect(table.getChild("fp64")?.type.children[0].type.toString()).toEqual(
-      new Float64().toString(),
-    );
-  });
-
-  it("will use dictionary encoded strings if asked", async function () {
-    const table = makeArrowTable([{ str: "hello" }]);
-    expect(DataType.isUtf8(table.getChild("str")?.type)).toBe(true);
-
-    const tableWithDict = makeArrowTable([{ str: "hello" }], {
-      dictionaryEncodeStrings: true,
-    });
-    expect(DataType.isDictionary(tableWithDict.getChild("str")?.type)).toBe(
-      true,
-    );
-
-    const schema = new Schema([
-      new Field("str", new Dictionary(new Utf8(), new Int32())),
-    ]);
-
-    const tableWithDict2 = makeArrowTable([{ str: "hello" }], { schema });
-    expect(DataType.isDictionary(tableWithDict2.getChild("str")?.type)).toBe(
-      true,
-    );
-  });
-
-  it("will infer data types correctly", async function () {
-    await checkTableCreation(async (records) => makeArrowTable(records), true);
-  });
-
-  it("will allow a schema to be provided", async function () {
-    await checkTableCreation(
-      async (records, _, schema) => makeArrowTable(records, { schema }),
-      false,
-    );
-  });
-
-  it("will use the field order of any provided schema", async function () {
-    await checkTableCreation(
-      async (_, recordsReversed, schema) =>
-        makeArrowTable(recordsReversed, { schema }),
-      false,
-    );
-  });
-
-  it("will make an empty table", async function () {
-    await checkTableCreation(
-      async (_, __, schema) => makeArrowTable([], { schema }),
-      false,
-    );
-  });
-});
-
-class DummyEmbedding implements EmbeddingFunction<string> {
-  public readonly sourceColumn = "string";
-  public readonly embeddingDimension = 2;
-  public readonly embeddingDataType = new Float16();
-
-  async embed(data: string[]): Promise<number[][]> {
-    return data.map(() => [0.0, 0.0]);
-  }
-}
-
-class DummyEmbeddingWithNoDimension implements EmbeddingFunction<string> {
-  public readonly sourceColumn = "string";
-
-  async embed(data: string[]): Promise<number[][]> {
-    return data.map(() => [0.0, 0.0]);
-  }
-}
-
-describe("convertToTable", function () {
-  it("will infer data types correctly", async function () {
-    await checkTableCreation(
-      async (records) => await convertToTable(records),
-      true,
-    );
-  });
-
-  it("will allow a schema to be provided", async function () {
-    await checkTableCreation(
-      async (records, _, schema) =>
-        await convertToTable(records, undefined, { schema }),
-      false,
-    );
-  });
-
-  it("will use the field order of any provided schema", async function () {
-    await checkTableCreation(
-      async (_, recordsReversed, schema) =>
-        await convertToTable(recordsReversed, undefined, { schema }),
-      false,
-    );
-  });
-
-  it("will make an empty table", async function () {
-    await checkTableCreation(
-      async (_, __, schema) => await convertToTable([], undefined, { schema }),
-      false,
-    );
-  });
-
-  it("will apply embeddings", async function () {
-    const records = sampleRecords();
-    const table = await convertToTable(records, new DummyEmbedding());
-    expect(DataType.isFixedSizeList(table.getChild("vector")?.type)).toBe(true);
-    expect(table.getChild("vector")?.type.children[0].type.toString()).toEqual(
-      new Float16().toString(),
-    );
-  });
-
-  it("will fail if missing the embedding source column", async function () {
-    await expect(
-      convertToTable([{ id: 1 }], new DummyEmbedding()),
-    ).rejects.toThrow("'string' was not present");
-  });
-
-  it("use embeddingDimension if embedding missing from table", async function () {
-    const schema = new Schema([new Field("string", new Utf8(), false)]);
-    // Simulate getting an empty Arrow table (minus embedding) from some other source
-    // In other words, we aren't starting with records
-    const table = makeEmptyTable(schema);
-
-    // If the embedding specifies the dimension we are fine
-    await fromTableToBuffer(table, new DummyEmbedding());
-
-    // We can also supply a schema and should be ok
-    const schemaWithEmbedding = new Schema([
-      new Field("string", new Utf8(), false),
-      new Field(
-        "vector",
-        new FixedSizeList(2, new Field("item", new Float16(), false)),
-        false,
-      ),
-    ]);
-    await fromTableToBuffer(
-      table,
-      new DummyEmbeddingWithNoDimension(),
-      schemaWithEmbedding,
-    );
-
-    // Otherwise we will get an error
-    await expect(
-      fromTableToBuffer(table, new DummyEmbeddingWithNoDimension()),
-    ).rejects.toThrow("does not specify `embeddingDimension`");
-  });
-
-  it("will apply embeddings to an empty table", async function () {
-    const schema = new Schema([
-      new Field("string", new Utf8(), false),
-      new Field(
-        "vector",
-        new FixedSizeList(2, new Field("item", new Float16(), false)),
-        false,
-      ),
-    ]);
-    const table = await convertToTable([], new DummyEmbedding(), { schema });
-    expect(DataType.isFixedSizeList(table.getChild("vector")?.type)).toBe(true);
-    expect(table.getChild("vector")?.type.children[0].type.toString()).toEqual(
-      new Float16().toString(),
-    );
-  });
-
-  it("will complain if embeddings present but schema missing embedding column", async function () {
-    const schema = new Schema([new Field("string", new Utf8(), false)]);
-    await expect(
-      convertToTable([], new DummyEmbedding(), { schema }),
-    ).rejects.toThrow("column vector was missing");
-  });
-
-  it("will provide a nice error if run twice", async function () {
-    const records = sampleRecords();
-    const table = await convertToTable(records, new DummyEmbedding());
-    // fromTableToBuffer will try and apply the embeddings again
-    await expect(
-      fromTableToBuffer(table, new DummyEmbedding()),
-    ).rejects.toThrow("already existed");
-  });
-});
-
-describe("makeEmptyTable", function () {
-  it("will make an empty table", async function () {
-    await checkTableCreation(
-      async (_, __, schema) => makeEmptyTable(schema),
-      false,
-    );
-  });
-});
-
-describe("when using two versions of arrow", function () {
-  it("can still import data", async function () {
-    const schema = new OldSchema([
-      new OldField("id", new OldInt32()),
-      new OldField(
-        "vector",
-        new OldFixedSizeList(
-          1024,
-          new OldField("item", new OldFloat32(), true),
-        ),
-      ),
-      new OldField(
-        "struct",
-        new OldStruct([
-          new OldField(
-            "nested",
-            new OldDictionary(new OldUtf8(), new OldInt32(), 1, true),
-          ),
-          new OldField("ts_with_tz", new OldTimestampNanosecond("some_tz")),
-          new OldField("ts_no_tz", new OldTimestampNanosecond(null)),
-        ]),
-      ),
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    ]) as any;
-    schema.metadataVersion = MetadataVersion.V5;
-    const table = makeArrowTable([], { schema });
-
-    const buf = await fromTableToBuffer(table);
-    expect(buf.byteLength).toBeGreaterThan(0);
-    const actual = tableFromIPC(buf);
-    const actualSchema = actual.schema;
-    expect(actualSchema.fields.length).toBe(3);
-
-    // Deep equality gets hung up on some very minor unimportant differences
-    // between arrow version 13 and 15 which isn't really what we're testing for
-    // and so we do our own comparison that just checks name/type/nullability
-    function compareFields(lhs: Field, rhs: Field) {
-      expect(lhs.name).toEqual(rhs.name);
-      expect(lhs.nullable).toEqual(rhs.nullable);
-      expect(lhs.typeId).toEqual(rhs.typeId);
-      if ("children" in lhs.type && lhs.type.children !== null) {
-        const lhsChildren = lhs.type.children as Field[];
-        lhsChildren.forEach((child: Field, idx) => {
-          compareFields(child, rhs.type.children[idx]);
-        });
-      }
     }
-    actualSchema.fields.forEach((field, idx) => {
-      compareFields(field, actualSchema.fields[idx]);
-    });
-  });
+  );
+
+  const buf = toBuffer(table);
+  expect(buf.byteLength).toBeGreaterThan(0);
+
+  const actual = tableFromIPC(buf);
+  expect(actual.numRows).toBe(3);
+  const actualSchema = actual.schema;
+  expect(actualSchema.toString()).toEqual(schema.toString());
 });
+
+test("handles int64", function() {
+  // https://github.com/lancedb/lancedb/issues/960
+  const schema = new Schema([
+    new Field("x", new Int64(), true)
+  ]);
+  const table = makeArrowTable([
+    { x: 1 },
+    { x: 2 },
+    { x: 3 }
+  ], { schema });
+  expect(table.schema).toEqual(schema);
+})

nodejs/__test__/connection.test.ts

@@ -1,88 +0,0 @@
-// Copyright 2024 Lance Developers.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-import * as tmp from "tmp";
-
-import { Connection, connect } from "../dist/index.js";
-
-describe("when connecting", () => {
-  let tmpDir: tmp.DirResult;
-  beforeEach(() => (tmpDir = tmp.dirSync({ unsafeCleanup: true })));
-  afterEach(() => tmpDir.removeCallback());
-
-  it("should connect", async () => {
-    const db = await connect(tmpDir.name);
-    expect(db.display()).toBe(
-      `NativeDatabase(uri=${tmpDir.name}, read_consistency_interval=None)`,
-    );
-  });
-
-  it("should allow read consistency interval to be specified", async () => {
-    const db = await connect(tmpDir.name, { readConsistencyInterval: 5 });
-    expect(db.display()).toBe(
-      `NativeDatabase(uri=${tmpDir.name}, read_consistency_interval=5s)`,
-    );
-  });
-});
-
-describe("given a connection", () => {
-  let tmpDir: tmp.DirResult;
-  let db: Connection;
-  beforeEach(async () => {
-    tmpDir = tmp.dirSync({ unsafeCleanup: true });
-    db = await connect(tmpDir.name);
-  });
-  afterEach(() => tmpDir.removeCallback());
-
-  it("should raise an error if opening a non-existent table", async () => {
-    await expect(db.openTable("non-existent")).rejects.toThrow("was not found");
-  });
-
-  it("should raise an error if any operation is tried after it is closed", async () => {
-    expect(db.isOpen()).toBe(true);
-    await db.close();
-    expect(db.isOpen()).toBe(false);
-    await expect(db.tableNames()).rejects.toThrow("Connection is closed");
-  });
-
-  it("should fail if creating table twice, unless overwrite is true", async () => {
-    let tbl = await db.createTable("test", [{ id: 1 }, { id: 2 }]);
-    await expect(tbl.countRows()).resolves.toBe(2);
-    await expect(
-      db.createTable("test", [{ id: 1 }, { id: 2 }]),
-    ).rejects.toThrow();
-    tbl = await db.createTable("test", [{ id: 3 }], { mode: "overwrite" });
-    await expect(tbl.countRows()).resolves.toBe(1);
-  });
-
-  it("should respect limit and page token when listing tables", async () => {
-    const db = await connect(tmpDir.name);
-
-    await db.createTable("b", [{ id: 1 }]);
-    await db.createTable("a", [{ id: 1 }]);
-    await db.createTable("c", [{ id: 1 }]);
-
-    let tables = await db.tableNames();
-    expect(tables).toEqual(["a", "b", "c"]);
-
-    tables = await db.tableNames({ limit: 1 });
-    expect(tables).toEqual(["a"]);
-
-    tables = await db.tableNames({ limit: 1, startAfter: "a" });
-    expect(tables).toEqual(["b"]);
-
-    tables = await db.tableNames({ startAfter: "a" });
-    expect(tables).toEqual(["b", "c"]);
-  });
-});

nodejs/__test__/index.test.ts

@@ -0,0 +1,34 @@
+// Copyright 2024 Lance Developers.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import * as os from "os";
+import * as path from "path";
+import * as fs from "fs";
+
+import { Schema, Field, Float64 } from "apache-arrow";
+import { connect } from "../dist/index.js";
+
+test("open database", async () => {
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "test-open"));
+
+  const db = await connect(tmpDir);
+  let tableNames = await db.tableNames();
+  expect(tableNames).toStrictEqual([]);
+
+  const tbl = await db.createTable("test", [{ id: 1 }, { id: 2 }]);
+  expect(await db.tableNames()).toStrictEqual(["test"]);
+
+  const schema = tbl.schema;
+  expect(schema).toEqual(new Schema([new Field("id", new Float64(), true)]));
+});

nodejs/__test__/table.test.ts

@@ -12,75 +12,27 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-import * as fs from "fs";
+import * as os from "os";
 import * as path from "path";
-import * as tmp from "tmp";
+import * as fs from "fs";
 
-import { Table, connect } from "../dist";
-import {
-  Schema,
-  Field,
-  Float32,
-  Int32,
-  FixedSizeList,
-  Int64,
-  Float64,
-} from "apache-arrow";
+import { connect } from "../dist";
+import { Schema, Field, Float32, Int32, FixedSizeList } from "apache-arrow";
 import { makeArrowTable } from "../dist/arrow";
 
-describe("Given a table", () => {
-  let tmpDir: tmp.DirResult;
-  let table: Table;
-  const schema = new Schema([new Field("id", new Float64(), true)]);
-  beforeEach(async () => {
-    tmpDir = tmp.dirSync({ unsafeCleanup: true });
-    const conn = await connect(tmpDir.name);
-    table = await conn.createEmptyTable("some_table", schema);
-  });
-  afterEach(() => tmpDir.removeCallback());
-
-  it("be displayable", async () => {
-    expect(table.display()).toMatch(
-      /NativeTable\(some_table, uri=.*, read_consistency_interval=None\)/,
-    );
-    table.close();
-    expect(table.display()).toBe("ClosedTable(some_table)");
-  });
-
-  it("should let me add data", async () => {
-    await table.add([{ id: 1 }, { id: 2 }]);
-    await table.add([{ id: 1 }]);
-    await expect(table.countRows()).resolves.toBe(3);
-  });
-
-  it("should overwrite data if asked", async () => {
-    await table.add([{ id: 1 }, { id: 2 }]);
-    await table.add([{ id: 1 }], { mode: "overwrite" });
-    await expect(table.countRows()).resolves.toBe(1);
-  });
-
-  it("should let me close the table", async () => {
-    expect(table.isOpen()).toBe(true);
-    table.close();
-    expect(table.isOpen()).toBe(false);
-    expect(table.countRows()).rejects.toThrow("Table some_table is closed");
-  });
-});
-
 describe("Test creating index", () => {
-  let tmpDir: tmp.DirResult;
+  let tmpDir: string;
   const schema = new Schema([
     new Field("id", new Int32(), true),
     new Field("vec", new FixedSizeList(32, new Field("item", new Float32()))),
   ]);
 
   beforeEach(() => {
-    tmpDir = tmp.dirSync({ unsafeCleanup: true });
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "index-"));
   });
-  afterEach(() => tmpDir.removeCallback());
 
   test("create vector index with no column", async () => {
-    const db = await connect(tmpDir.name);
+    const db = await connect(tmpDir);
     const data = makeArrowTable(
       Array(300)
         .fill(1)
@@ -92,42 +44,42 @@ describe("Test creating index", () => {
         })),
       {
         schema,
-      },
+      }
     );
     const tbl = await db.createTable("test", data);
     await tbl.createIndex().build();
 
     // check index directory
-    const indexDir = path.join(tmpDir.name, "test.lance", "_indices");
+    const indexDir = path.join(tmpDir, "test.lance", "_indices");
     expect(fs.readdirSync(indexDir)).toHaveLength(1);
     // TODO: check index type.
 
     // Search without specifying the column
-    const queryVector = data.toArray()[5].vec.toJSON();
-    const rst = await tbl.query().nearestTo(queryVector).limit(2).toArrow();
+    let query_vector = data.toArray()[5].vec.toJSON();
+    let rst = await tbl.query().nearestTo(query_vector).limit(2).toArrow();
     expect(rst.numRows).toBe(2);
 
     // Search with specifying the column
-    const rst2 = await tbl.search(queryVector, "vec").limit(2).toArrow();
+    let rst2 = await tbl.search(query_vector, "vec").limit(2).toArrow();
     expect(rst2.numRows).toBe(2);
     expect(rst.toString()).toEqual(rst2.toString());
   });
 
   test("no vector column available", async () => {
-    const db = await connect(tmpDir.name);
+    const db = await connect(tmpDir);
     const tbl = await db.createTable(
       "no_vec",
       makeArrowTable([
         { id: 1, val: 2 },
         { id: 2, val: 3 },
-      ]),
+      ])
     );
     await expect(tbl.createIndex().build()).rejects.toThrow(
-      "No vector column found",
+      "No vector column found"
     );
 
     await tbl.createIndex("val").build();
-    const indexDir = path.join(tmpDir.name, "no_vec.lance", "_indices");
+    const indexDir = path.join(tmpDir, "no_vec.lance", "_indices");
     expect(fs.readdirSync(indexDir)).toHaveLength(1);
 
     for await (const r of tbl.query().filter("id > 1").select(["id"])) {
@@ -136,13 +88,13 @@ describe("Test creating index", () => {
   });
 
   test("two columns with different dimensions", async () => {
-    const db = await connect(tmpDir.name);
+    const db = await connect(tmpDir);
     const schema = new Schema([
       new Field("id", new Int32(), true),
       new Field("vec", new FixedSizeList(32, new Field("item", new Float32()))),
       new Field(
         "vec2",
-        new FixedSizeList(64, new Field("item", new Float32())),
+        new FixedSizeList(64, new Field("item", new Float32()))
       ),
     ]);
     const tbl = await db.createTable(
@@ -159,17 +111,16 @@ describe("Test creating index", () => {
               .fill(1)
               .map(() => Math.random()),
           })),
-        { schema },
-      ),
+        { schema }
+      )
     );
 
     // Only build index over v1
     await expect(tbl.createIndex().build()).rejects.toThrow(
-      /.*More than one vector columns found.*/,
+      /.*More than one vector columns found.*/
     );
     tbl
       .createIndex("vec")
-      // eslint-disable-next-line @typescript-eslint/naming-convention
       .ivf_pq({ num_partitions: 2, num_sub_vectors: 2 })
       .build();
 
@@ -178,7 +129,7 @@ describe("Test creating index", () => {
       .nearestTo(
         Array(32)
           .fill(1)
-          .map(() => Math.random()),
+          .map(() => Math.random())
       )
       .limit(2)
       .toArrow();
@@ -191,23 +142,23 @@ describe("Test creating index", () => {
           Array(64)
             .fill(1)
             .map(() => Math.random()),
-          "vec",
+          "vec"
         )
         .limit(2)
-        .toArrow(),
+        .toArrow()
     ).rejects.toThrow(/.*does not match the dimension.*/);
 
     const query64 = Array(64)
       .fill(1)
       .map(() => Math.random());
-    const rst64Query = await tbl.query().nearestTo(query64).limit(2).toArrow();
-    const rst64Search = await tbl.search(query64, "vec2").limit(2).toArrow();
-    expect(rst64Query.toString()).toEqual(rst64Search.toString());
-    expect(rst64Query.numRows).toBe(2);
+    const rst64_1 = await tbl.query().nearestTo(query64).limit(2).toArrow();
+    const rst64_2 = await tbl.search(query64, "vec2").limit(2).toArrow();
+    expect(rst64_1.toString()).toEqual(rst64_2.toString());
+    expect(rst64_1.numRows).toBe(2);
   });
 
   test("create scalar index", async () => {
-    const db = await connect(tmpDir.name);
+    const db = await connect(tmpDir);
     const data = makeArrowTable(
       Array(300)
         .fill(1)
@@ -219,132 +170,14 @@ describe("Test creating index", () => {
         })),
       {
         schema,
-      },
+      }
     );
     const tbl = await db.createTable("test", data);
     await tbl.createIndex("id").build();
 
     // check index directory
-    const indexDir = path.join(tmpDir.name, "test.lance", "_indices");
+    const indexDir = path.join(tmpDir, "test.lance", "_indices");
     expect(fs.readdirSync(indexDir)).toHaveLength(1);
     // TODO: check index type.
   });
 });
-
-describe("Read consistency interval", () => {
-  let tmpDir: tmp.DirResult;
-  beforeEach(() => {
-    tmpDir = tmp.dirSync({ unsafeCleanup: true });
-  });
-  afterEach(() => tmpDir.removeCallback());
-
-  // const intervals = [undefined, 0, 0.1];
-  const intervals = [0];
-  test.each(intervals)("read consistency interval %p", async (interval) => {
-    const db = await connect(tmpDir.name);
-    const table = await db.createTable("my_table", [{ id: 1 }]);
-
-    const db2 = await connect(tmpDir.name, {
-      readConsistencyInterval: interval,
-    });
-    const table2 = await db2.openTable("my_table");
-    expect(await table2.countRows()).toEqual(await table.countRows());
-
-    await table.add([{ id: 2 }]);
-
-    if (interval === undefined) {
-      expect(await table2.countRows()).toEqual(1);
-      // TODO: once we implement time travel we can uncomment this part of the test.
-      // await table2.checkout_latest();
-      // expect(await table2.countRows()).toEqual(2);
-    } else if (interval === 0) {
-      expect(await table2.countRows()).toEqual(2);
-    } else {
-      // interval == 0.1
-      expect(await table2.countRows()).toEqual(1);
-      await new Promise((r) => setTimeout(r, 100));
-      expect(await table2.countRows()).toEqual(2);
-    }
-  });
-});
-
-describe("schema evolution", function () {
-  let tmpDir: tmp.DirResult;
-  beforeEach(() => {
-    tmpDir = tmp.dirSync({ unsafeCleanup: true });
-  });
-  afterEach(() => {
-    tmpDir.removeCallback();
-  });
-
-  // Create a new sample table
-  it("can add a new column to the schema", async function () {
-    const con = await connect(tmpDir.name);
-    const table = await con.createTable("vectors", [
-      { id: 1n, vector: [0.1, 0.2] },
-    ]);
-
-    await table.addColumns([
-      { name: "price", valueSql: "cast(10.0 as float)" },
-    ]);
-
-    const expectedSchema = new Schema([
-      new Field("id", new Int64(), true),
-      new Field(
-        "vector",
-        new FixedSizeList(2, new Field("item", new Float32(), true)),
-        true,
-      ),
-      new Field("price", new Float32(), false),
-    ]);
-    expect(await table.schema()).toEqual(expectedSchema);
-  });
-
-  it("can alter the columns in the schema", async function () {
-    const con = await connect(tmpDir.name);
-    const schema = new Schema([
-      new Field("id", new Int64(), true),
-      new Field(
-        "vector",
-        new FixedSizeList(2, new Field("item", new Float32(), true)),
-        true,
-      ),
-      new Field("price", new Float64(), false),
-    ]);
-    const table = await con.createTable("vectors", [
-      { id: 1n, vector: [0.1, 0.2] },
-    ]);
-    // Can create a non-nullable column only through addColumns at the moment.
-    await table.addColumns([
-      { name: "price", valueSql: "cast(10.0 as double)" },
-    ]);
-    expect(await table.schema()).toEqual(schema);
-
-    await table.alterColumns([
-      { path: "id", rename: "new_id" },
-      { path: "price", nullable: true },
-    ]);
-
-    const expectedSchema = new Schema([
-      new Field("new_id", new Int64(), true),
-      new Field(
-        "vector",
-        new FixedSizeList(2, new Field("item", new Float32(), true)),
-        true,
-      ),
-      new Field("price", new Float64(), true),
-    ]);
-    expect(await table.schema()).toEqual(expectedSchema);
-  });
-
-  it("can drop a column from the schema", async function () {
-    const con = await connect(tmpDir.name);
-    const table = await con.createTable("vectors", [
-      { id: 1n, vector: [0.1, 0.2] },
-    ]);
-    await table.dropColumns(["vector"]);
-
-    const expectedSchema = new Schema([new Field("id", new Int64(), true)]);
-    expect(await table.schema()).toEqual(expectedSchema);
-  });
-});

nodejs/__test__/tsconfig.json

@@ -1,10 +0,0 @@
-{
-  "extends": "../tsconfig.json",
-  "compilerOptions": {
-    "outDir": "./dist/spec",
-    "module": "commonjs",
-    "target": "es2022",
-    "types": ["jest", "node"]
-  },
-  "include": ["**/*"]
-}

nodejs/eslint.config.js

@@ -1,17 +0,0 @@
-/* eslint-disable @typescript-eslint/naming-convention */
-// @ts-check
-
-const eslint = require("@eslint/js");
-const tseslint = require("typescript-eslint");
-const eslintConfigPrettier = require("eslint-config-prettier");
-
-module.exports = tseslint.config(
-  eslint.configs.recommended,
-  eslintConfigPrettier,
-  ...tseslint.configs.recommended,
-  {
-    rules: {
-      "@typescript-eslint/naming-convention": "error",
-    },
-  },
-);

nodejs/jest.config.js

@@ -1,7 +1,7 @@
 /** @type {import('ts-jest').JestConfigWithTsJest} */
 module.exports = {
-  preset: "ts-jest",
-  testEnvironment: "node",
+  preset: 'ts-jest',
+  testEnvironment: 'node',
   moduleDirectories: ["node_modules", "./dist"],
   moduleFileExtensions: ["js", "ts"],
 };

nodejs/lancedb/arrow.ts

@@ -1,634 +0,0 @@
-// Copyright 2023 Lance Developers.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-import {
-  Field,
-  makeBuilder,
-  RecordBatchFileWriter,
-  Utf8,
-  type Vector,
-  FixedSizeList,
-  vectorFromArray,
-  type Schema,
-  Table as ArrowTable,
-  RecordBatchStreamWriter,
-  List,
-  RecordBatch,
-  makeData,
-  Struct,
-  type Float,
-  DataType,
-  Binary,
-  Float32,
-} from "apache-arrow";
-import { type EmbeddingFunction } from "./embedding/embedding_function";
-import { sanitizeSchema } from "./sanitize";
-
-/** Data type accepted by NodeJS SDK */
-export type Data = Record<string, unknown>[] | ArrowTable;
-
-/*
- * Options to control how a column should be converted to a vector array
- */
-export class VectorColumnOptions {
-  /** Vector column type. */
-  type: Float = new Float32();
-
-  constructor(values?: Partial<VectorColumnOptions>) {
-    Object.assign(this, values);
-  }
-}
-
-/** Options to control the makeArrowTable call. */
-export class MakeArrowTableOptions {
-  /*
-   * Schema of the data.
-   *
-   * If this is not provided then the data type will be inferred from the
-   * JS type.  Integer numbers will become int64, floating point numbers
-   * will become float64 and arrays will become variable sized lists with
-   * the data type inferred from the first element in the array.
-   *
-   * The schema must be specified if there are no records (e.g. to make
-   * an empty table)
-   */
-  schema?: Schema;
-
-  /*
-   * Mapping from vector column name to expected type
-   *
-   * Lance expects vector columns to be fixed size list arrays (i.e. tensors)
-   * However, `makeArrowTable` will not infer this by default (it creates
-   * variable size list arrays).  This field can be used to indicate that a column
-   * should be treated as a vector column and converted to a fixed size list.
-   *
-   * The keys should be the names of the vector columns.  The value specifies the
-   * expected data type of the vector columns.
-   *
-   * If `schema` is provided then this field is ignored.
-   *
-   * By default, the column named "vector" will be assumed to be a float32
-   * vector column.
-   */
-  vectorColumns: Record<string, VectorColumnOptions> = {
-    vector: new VectorColumnOptions(),
-  };
-
-  /**
-   * If true then string columns will be encoded with dictionary encoding
-   *
-   * Set this to true if your string columns tend to repeat the same values
-   * often.  For more precise control use the `schema` property to specify the
-   * data type for individual columns.
-   *
-   * If `schema` is provided then this property is ignored.
-   */
-  dictionaryEncodeStrings: boolean = false;
-
-  constructor(values?: Partial<MakeArrowTableOptions>) {
-    Object.assign(this, values);
-  }
-}
-
-/**
- * An enhanced version of the {@link makeTable} function from Apache Arrow
- * that supports nested fields and embeddings columns.
- *
- * This function converts an array of Record<String, any> (row-major JS objects)
- * to an Arrow Table (a columnar structure)
- *
- * Note that it currently does not support nulls.
- *
- * If a schema is provided then it will be used to determine the resulting array
- * types.  Fields will also be reordered to fit the order defined by the schema.
- *
- * If a schema is not provided then the types will be inferred and the field order
- * will be controlled by the order of properties in the first record.  If a type
- * is inferred it will always be nullable.
- *
- * If the input is empty then a schema must be provided to create an empty table.
- *
- * When a schema is not specified then data types will be inferred.  The inference
- * rules are as follows:
- *
- *  - boolean => Bool
- *  - number => Float64
- *  - String => Utf8
- *  - Buffer => Binary
- *  - Record<String, any> => Struct
- *  - Array<any> => List
- *
- * @param data input data
- * @param options options to control the makeArrowTable call.
- *
- * @example
- *
- * ```ts
- *
- * import { fromTableToBuffer, makeArrowTable } from "../arrow";
- * import { Field, FixedSizeList, Float16, Float32, Int32, Schema } from "apache-arrow";
- *
- * const schema = new Schema([
- *   new Field("a", new Int32()),
- *   new Field("b", new Float32()),
- *   new Field("c", new FixedSizeList(3, new Field("item", new Float16()))),
- *  ]);
- *  const table = makeArrowTable([
- *    { a: 1, b: 2, c: [1, 2, 3] },
- *    { a: 4, b: 5, c: [4, 5, 6] },
- *    { a: 7, b: 8, c: [7, 8, 9] },
- *  ], { schema });
- * ```
- *
- * By default it assumes that the column named `vector` is a vector column
- * and it will be converted into a fixed size list array of type float32.
- * The `vectorColumns` option can be used to support other vector column
- * names and data types.
- *
- * ```ts
- *
- * const schema = new Schema([
-    new Field("a", new Float64()),
-    new Field("b", new Float64()),
-    new Field(
-      "vector",
-      new FixedSizeList(3, new Field("item", new Float32()))
-    ),
-  ]);
-  const table = makeArrowTable([
-    { a: 1, b: 2, vector: [1, 2, 3] },
-    { a: 4, b: 5, vector: [4, 5, 6] },
-    { a: 7, b: 8, vector: [7, 8, 9] },
-  ]);
-  assert.deepEqual(table.schema, schema);
- * ```
- *
- * You can specify the vector column types and names using the options as well
- *
- * ```typescript
- *
- * const schema = new Schema([
-    new Field('a', new Float64()),
-    new Field('b', new Float64()),
-    new Field('vec1', new FixedSizeList(3, new Field('item', new Float16()))),
-    new Field('vec2', new FixedSizeList(3, new Field('item', new Float16())))
-  ]);
- * const table = makeArrowTable([
-    { a: 1, b: 2, vec1: [1, 2, 3], vec2: [2, 4, 6] },
-    { a: 4, b: 5, vec1: [4, 5, 6], vec2: [8, 10, 12] },
-    { a: 7, b: 8, vec1: [7, 8, 9], vec2: [14, 16, 18] }
-  ], {
-    vectorColumns: {
-      vec1: { type: new Float16() },
-      vec2: { type: new Float16() }
-    }
-  }
- * assert.deepEqual(table.schema, schema)
- * ```
- */
-export function makeArrowTable(
-  data: Array<Record<string, unknown>>,
-  options?: Partial<MakeArrowTableOptions>,
-): ArrowTable {
-  if (
-    data.length === 0 &&
-    (options?.schema === undefined || options?.schema === null)
-  ) {
-    throw new Error("At least one record or a schema needs to be provided");
-  }
-
-  const opt = new MakeArrowTableOptions(options !== undefined ? options : {});
-  if (opt.schema !== undefined && opt.schema !== null) {
-    opt.schema = sanitizeSchema(opt.schema);
-  }
-  const columns: Record<string, Vector> = {};
-  // TODO: sample dataset to find missing columns
-  // Prefer the field ordering of the schema, if present
-  const columnNames =
-    opt.schema != null ? (opt.schema.names as string[]) : Object.keys(data[0]);
-  for (const colName of columnNames) {
-    if (
-      data.length !== 0 &&
-      !Object.prototype.hasOwnProperty.call(data[0], colName)
-    ) {
-      // The field is present in the schema, but not in the data, skip it
-      continue;
-    }
-    // Extract a single column from the records (transpose from row-major to col-major)
-    let values = data.map((datum) => datum[colName]);
-
-    // By default (type === undefined) arrow will infer the type from the JS type
-    let type;
-    if (opt.schema !== undefined) {
-      // If there is a schema provided, then use that for the type instead
-      type = opt.schema?.fields.filter((f) => f.name === colName)[0]?.type;
-      if (DataType.isInt(type) && type.bitWidth === 64) {
-        // wrap in BigInt to avoid bug: https://github.com/apache/arrow/issues/40051
-        values = values.map((v) => {
-          if (v === null) {
-            return v;
-          }
-          if (typeof v === "bigint") {
-            return v;
-          }
-          if (typeof v === "number") {
-            return BigInt(v);
-          }
-          throw new Error(
-            `Expected BigInt or number for column ${colName}, got ${typeof v}`,
-          );
-        });
-      }
-    } else {
-      // Otherwise, check to see if this column is one of the vector columns
-      // defined by opt.vectorColumns and, if so, use the fixed size list type
-      const vectorColumnOptions = opt.vectorColumns[colName];
-      if (vectorColumnOptions !== undefined) {
-        const firstNonNullValue = values.find((v) => v !== null);
-        if (Array.isArray(firstNonNullValue)) {
-          type = newVectorType(
-            firstNonNullValue.length,
-            vectorColumnOptions.type,
-          );
-        } else {
-          throw new Error(
-            `Column ${colName} is expected to be a vector column but first non-null value is not an array.  Could not determine size of vector column`,
-          );
-        }
-      }
-    }
-
-    try {
-      // Convert an Array of JS values to an arrow vector
-      columns[colName] = makeVector(values, type, opt.dictionaryEncodeStrings);
-    } catch (error: unknown) {
-      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-      throw Error(`Could not convert column "${colName}" to Arrow: ${error}`);
-    }
-  }
-
-  if (opt.schema != null) {
-    // `new ArrowTable(columns)` infers a schema which may sometimes have
-    // incorrect nullability (it assumes nullable=true always)
-    //
-    // `new ArrowTable(schema, columns)` will also fail because it will create a
-    // batch with an inferred schema and then complain that the batch schema
-    // does not match the provided schema.
-    //
-    // To work around this we first create a table with the wrong schema and
-    // then patch the schema of the batches so we can use
-    // `new ArrowTable(schema, batches)` which does not do any schema inference
-    const firstTable = new ArrowTable(columns);
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    const batchesFixed = firstTable.batches.map(
-      (batch) => new RecordBatch(opt.schema!, batch.data),
-    );
-    return new ArrowTable(opt.schema, batchesFixed);
-  } else {
-    return new ArrowTable(columns);
-  }
-}
-
-/**
- * Create an empty Arrow table with the provided schema
- */
-export function makeEmptyTable(schema: Schema): ArrowTable {
-  return makeArrowTable([], { schema });
-}
-
-// Helper function to convert Array<Array<any>> to a variable sized list array
-// @ts-expect-error (Vector<unknown> is not assignable to Vector<any>)
-function makeListVector(lists: unknown[][]): Vector<unknown> {
-  if (lists.length === 0 || lists[0].length === 0) {
-    throw Error("Cannot infer list vector from empty array or empty list");
-  }
-  const sampleList = lists[0];
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  let inferredType: any;
-  try {
-    const sampleVector = makeVector(sampleList);
-    inferredType = sampleVector.type;
-  } catch (error: unknown) {
-    // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-    throw Error(`Cannot infer list vector.  Cannot infer inner type: ${error}`);
-  }
-
-  const listBuilder = makeBuilder({
-    type: new List(new Field("item", inferredType, true)),
-  });
-  for (const list of lists) {
-    listBuilder.append(list);
-  }
-  return listBuilder.finish().toVector();
-}
-
-// Helper function to convert an Array of JS values to an Arrow Vector
-function makeVector(
-  values: unknown[],
-  type?: DataType,
-  stringAsDictionary?: boolean,
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-): Vector<any> {
-  if (type !== undefined) {
-    // No need for inference, let Arrow create it
-    return vectorFromArray(values, type);
-  }
-  if (values.length === 0) {
-    throw Error(
-      "makeVector requires at least one value or the type must be specfied",
-    );
-  }
-  const sampleValue = values.find((val) => val !== null && val !== undefined);
-  if (sampleValue === undefined) {
-    throw Error(
-      "makeVector cannot infer the type if all values are null or undefined",
-    );
-  }
-  if (Array.isArray(sampleValue)) {
-    // Default Arrow inference doesn't handle list types
-    return makeListVector(values as unknown[][]);
-  } else if (Buffer.isBuffer(sampleValue)) {
-    // Default Arrow inference doesn't handle Buffer
-    return vectorFromArray(values, new Binary());
-  } else if (
-    !(stringAsDictionary ?? false) &&
-    (typeof sampleValue === "string" || sampleValue instanceof String)
-  ) {
-    // If the type is string then don't use Arrow's default inference unless dictionaries are requested
-    // because it will always use dictionary encoding for strings
-    return vectorFromArray(values, new Utf8());
-  } else {
-    // Convert a JS array of values to an arrow vector
-    return vectorFromArray(values);
-  }
-}
-
-async function applyEmbeddings<T>(
-  table: ArrowTable,
-  embeddings?: EmbeddingFunction<T>,
-  schema?: Schema,
-): Promise<ArrowTable> {
-  if (embeddings == null) {
-    return table;
-  }
-
-  if (schema !== undefined && schema !== null) {
-    schema = sanitizeSchema(schema);
-  }
-
-  // Convert from ArrowTable to Record<String, Vector>
-  const colEntries = [...Array(table.numCols).keys()].map((_, idx) => {
-    const name = table.schema.fields[idx].name;
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    const vec = table.getChildAt(idx)!;
-    return [name, vec];
-  });
-  const newColumns = Object.fromEntries(colEntries);
-
-  const sourceColumn = newColumns[embeddings.sourceColumn];
-  const destColumn = embeddings.destColumn ?? "vector";
-  const innerDestType = embeddings.embeddingDataType ?? new Float32();
-  if (sourceColumn === undefined) {
-    throw new Error(
-      `Cannot apply embedding function because the source column '${embeddings.sourceColumn}' was not present in the data`,
-    );
-  }
-
-  if (table.numRows === 0) {
-    if (Object.prototype.hasOwnProperty.call(newColumns, destColumn)) {
-      // We have an empty table and it already has the embedding column so no work needs to be done
-      // Note: we don't return an error like we did below because this is a common occurrence.  For example,
-      // if we call convertToTable with 0 records and a schema that includes the embedding
-      return table;
-    }
-    if (embeddings.embeddingDimension !== undefined) {
-      const destType = newVectorType(
-        embeddings.embeddingDimension,
-        innerDestType,
-      );
-      newColumns[destColumn] = makeVector([], destType);
-    } else if (schema != null) {
-      const destField = schema.fields.find((f) => f.name === destColumn);
-      if (destField != null) {
-        newColumns[destColumn] = makeVector([], destField.type);
-      } else {
-        throw new Error(
-          `Attempt to apply embeddings to an empty table failed because schema was missing embedding column '${destColumn}'`,
-        );
-      }
-    } else {
-      throw new Error(
-        "Attempt to apply embeddings to an empty table when the embeddings function does not specify `embeddingDimension`",
-      );
-    }
-  } else {
-    if (Object.prototype.hasOwnProperty.call(newColumns, destColumn)) {
-      throw new Error(
-        `Attempt to apply embeddings to table failed because column ${destColumn} already existed`,
-      );
-    }
-    if (table.batches.length > 1) {
-      throw new Error(
-        "Internal error: `makeArrowTable` unexpectedly created a table with more than one batch",
-      );
-    }
-    const values = sourceColumn.toArray();
-    const vectors = await embeddings.embed(values as T[]);
-    if (vectors.length !== values.length) {
-      throw new Error(
-        "Embedding function did not return an embedding for each input element",
-      );
-    }
-    const destType = newVectorType(vectors[0].length, innerDestType);
-    newColumns[destColumn] = makeVector(vectors, destType);
-  }
-
-  const newTable = new ArrowTable(newColumns);
-  if (schema != null) {
-    if (schema.fields.find((f) => f.name === destColumn) === undefined) {
-      throw new Error(
-        `When using embedding functions and specifying a schema the schema should include the embedding column but the column ${destColumn} was missing`,
-      );
-    }
-    return alignTable(newTable, schema);
-  }
-  return newTable;
-}
-
-/*
- * Convert an Array of records into an Arrow Table, optionally applying an
- * embeddings function to it.
- *
- * This function calls `makeArrowTable` first to create the Arrow Table.
- * Any provided `makeTableOptions` (e.g. a schema) will be passed on to
- * that call.
- *
- * The embedding function will be passed a column of values (based on the
- * `sourceColumn` of the embedding function) and expects to receive back
- * number[][] which will be converted into a fixed size list column.  By
- * default this will be a fixed size list of Float32 but that can be
- * customized by the `embeddingDataType` property of the embedding function.
- *
- * If a schema is provided in `makeTableOptions` then it should include the
- * embedding columns.  If no schema is provded then embedding columns will
- * be placed at the end of the table, after all of the input columns.
- */
-export async function convertToTable<T>(
-  data: Array<Record<string, unknown>>,
-  embeddings?: EmbeddingFunction<T>,
-  makeTableOptions?: Partial<MakeArrowTableOptions>,
-): Promise<ArrowTable> {
-  const table = makeArrowTable(data, makeTableOptions);
-  return await applyEmbeddings(table, embeddings, makeTableOptions?.schema);
-}
-
-// Creates the Arrow Type for a Vector column with dimension `dim`
-function newVectorType<T extends Float>(
-  dim: number,
-  innerType: T,
-): FixedSizeList<T> {
-  // in Lance we always default to have the elements nullable, so we need to set it to true
-  // otherwise we often get schema mismatches because the stored data always has schema with nullable elements
-  const children = new Field<T>("item", innerType, true);
-  return new FixedSizeList(dim, children);
-}
-
-/**
- * Serialize an Array of records into a buffer using the Arrow IPC File serialization
- *
- * This function will call `convertToTable` and pass on `embeddings` and `schema`
- *
- * `schema` is required if data is empty
- */
-export async function fromRecordsToBuffer<T>(
-  data: Array<Record<string, unknown>>,
-  embeddings?: EmbeddingFunction<T>,
-  schema?: Schema,
-): Promise<Buffer> {
-  if (schema !== undefined && schema !== null) {
-    schema = sanitizeSchema(schema);
-  }
-  const table = await convertToTable(data, embeddings, { schema });
-  const writer = RecordBatchFileWriter.writeAll(table);
-  return Buffer.from(await writer.toUint8Array());
-}
-
-/**
- * Serialize an Array of records into a buffer using the Arrow IPC Stream serialization
- *
- * This function will call `convertToTable` and pass on `embeddings` and `schema`
- *
- * `schema` is required if data is empty
- */
-export async function fromRecordsToStreamBuffer<T>(
-  data: Array<Record<string, unknown>>,
-  embeddings?: EmbeddingFunction<T>,
-  schema?: Schema,
-): Promise<Buffer> {
-  if (schema !== undefined && schema !== null) {
-    schema = sanitizeSchema(schema);
-  }
-  const table = await convertToTable(data, embeddings, { schema });
-  const writer = RecordBatchStreamWriter.writeAll(table);
-  return Buffer.from(await writer.toUint8Array());
-}
-
-/**
- * Serialize an Arrow Table into a buffer using the Arrow IPC File serialization
- *
- * This function will apply `embeddings` to the table in a manner similar to
- * `convertToTable`.
- *
- * `schema` is required if the table is empty
- */
-export async function fromTableToBuffer<T>(
-  table: ArrowTable,
-  embeddings?: EmbeddingFunction<T>,
-  schema?: Schema,
-): Promise<Buffer> {
-  if (schema !== undefined && schema !== null) {
-    schema = sanitizeSchema(schema);
-  }
-  const tableWithEmbeddings = await applyEmbeddings(table, embeddings, schema);
-  const writer = RecordBatchFileWriter.writeAll(tableWithEmbeddings);
-  return Buffer.from(await writer.toUint8Array());
-}
-
-export async function fromDataToBuffer<T>(
-  data: Data,
-  embeddings?: EmbeddingFunction<T>,
-  schema?: Schema,
-): Promise<Buffer> {
-  if (schema !== undefined && schema !== null) {
-    schema = sanitizeSchema(schema);
-  }
-  if (data instanceof ArrowTable) {
-    return fromTableToBuffer(data, embeddings, schema);
-  } else {
-    const table = await convertToTable(data);
-    return fromTableToBuffer(table, embeddings, schema);
-  }
-}
-
-/**
- * Serialize an Arrow Table into a buffer using the Arrow IPC Stream serialization
- *
- * This function will apply `embeddings` to the table in a manner similar to
- * `convertToTable`.
- *
- * `schema` is required if the table is empty
- */
-export async function fromTableToStreamBuffer<T>(
-  table: ArrowTable,
-  embeddings?: EmbeddingFunction<T>,
-  schema?: Schema,
-): Promise<Buffer> {
-  const tableWithEmbeddings = await applyEmbeddings(table, embeddings, schema);
-  const writer = RecordBatchStreamWriter.writeAll(tableWithEmbeddings);
-  return Buffer.from(await writer.toUint8Array());
-}
-
-function alignBatch(batch: RecordBatch, schema: Schema): RecordBatch {
-  const alignedChildren = [];
-  for (const field of schema.fields) {
-    const indexInBatch = batch.schema.fields?.findIndex(
-      (f) => f.name === field.name,
-    );
-    if (indexInBatch < 0) {
-      throw new Error(
-        `The column ${field.name} was not found in the Arrow Table`,
-      );
-    }
-    alignedChildren.push(batch.data.children[indexInBatch]);
-  }
-  const newData = makeData({
-    type: new Struct(schema.fields),
-    length: batch.numRows,
-    nullCount: batch.nullCount,
-    children: alignedChildren,
-  });
-  return new RecordBatch(schema, newData);
-}
-
-function alignTable(table: ArrowTable, schema: Schema): ArrowTable {
-  const alignedBatches = table.batches.map((batch) =>
-    alignBatch(batch, schema),
-  );
-  return new ArrowTable(schema, alignedBatches);
-}
-
-// Creates an empty Arrow Table
-export function createEmptyTable(schema: Schema): ArrowTable {
-  return new ArrowTable(sanitizeSchema(schema));
-}

nodejs/lancedb/connection.ts

@@ -1,177 +0,0 @@
-// Copyright 2024 Lance Developers.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-import { fromTableToBuffer, makeArrowTable, makeEmptyTable } from "./arrow";
-import { Connection as LanceDbConnection } from "./native";
-import { Table } from "./table";
-import { Table as ArrowTable, Schema } from "apache-arrow";
-
-export interface CreateTableOptions {
-  /**
-   * The mode to use when creating the table.
-   *
-   * If this is set to "create" and the table already exists then either
-   * an error will be thrown or, if existOk is true, then nothing will
-   * happen.  Any provided data will be ignored.
-   *
-   * If this is set to "overwrite" then any existing table will be replaced.
-   */
-  mode: "create" | "overwrite";
-  /**
-   * If this is true and the table already exists and the mode is "create"
-   * then no error will be raised.
-   */
-  existOk: boolean;
-}
-
-export interface TableNamesOptions {
-  /**
-   * If present, only return names that come lexicographically after the
-   * supplied value.
-   *
-   * This can be combined with limit to implement pagination by setting this to
-   * the last table name from the previous page.
-   */
-  startAfter?: string;
-  /** An optional limit to the number of results to return. */
-  limit?: number;
-}
-
-/**
- * A LanceDB Connection that allows you to open tables and create new ones.
- *
- * Connection could be local against filesystem or remote against a server.
- *
- * A Connection is intended to be a long lived object and may hold open
- * resources such as HTTP connection pools.  This is generally fine and
- * a single connection should be shared if it is going to be used many
- * times. However, if you are finished with a connection, you may call
- * close to eagerly free these resources.  Any call to a Connection
- * method after it has been closed will result in an error.
- *
- * Closing a connection is optional.  Connections will automatically
- * be closed when they are garbage collected.
- *
- * Any created tables are independent and will continue to work even if
- * the underlying connection has been closed.
- */
-export class Connection {
-  readonly inner: LanceDbConnection;
-
-  constructor(inner: LanceDbConnection) {
-    this.inner = inner;
-  }
-
-  /** Return true if the connection has not been closed */
-  isOpen(): boolean {
-    return this.inner.isOpen();
-  }
-
-  /** Close the connection, releasing any underlying resources.
-   *
-   * It is safe to call this method multiple times.
-   *
-   * Any attempt to use the connection after it is closed will result in an error.
-   */
-  close(): void {
-    this.inner.close();
-  }
-
-  /** Return a brief description of the connection */
-  display(): string {
-    return this.inner.display();
-  }
-
-  /** List all the table names in this database.
-   *
-   * Tables will be returned in lexicographical order.
-   *
-   * @param options Optional parameters to control the listing.
-   */
-  async tableNames(options?: Partial<TableNamesOptions>): Promise<string[]> {
-    return this.inner.tableNames(options?.startAfter, options?.limit);
-  }
-
-  /**
-   * Open a table in the database.
-   *
-   * @param name The name of the table.
-   * @param embeddings An embedding function to use on this table
-   */
-  async openTable(name: string): Promise<Table> {
-    const innerTable = await this.inner.openTable(name);
-    return new Table(innerTable);
-  }
-
-  /**
-   * Creates a new Table and initialize it with new data.
-   *
-   * @param {string} name - The name of the table.
-   * @param data - Non-empty Array of Records to be inserted into the table
-   */
-  async createTable(
-    name: string,
-    data: Record<string, unknown>[] | ArrowTable,
-    options?: Partial<CreateTableOptions>,
-  ): Promise<Table> {
-    let mode: string = options?.mode ?? "create";
-    const existOk = options?.existOk ?? false;
-
-    if (mode === "create" && existOk) {
-      mode = "exist_ok";
-    }
-
-    let table: ArrowTable;
-    if (data instanceof ArrowTable) {
-      table = data;
-    } else {
-      table = makeArrowTable(data);
-    }
-    const buf = await fromTableToBuffer(table);
-    const innerTable = await this.inner.createTable(name, buf, mode);
-    return new Table(innerTable);
-  }
-
-  /**
-   * Creates a new empty Table
-   *
-   * @param {string} name - The name of the table.
-   * @param schema - The schema of the table
-   */
-  async createEmptyTable(
-    name: string,
-    schema: Schema,
-    options?: Partial<CreateTableOptions>,
-  ): Promise<Table> {
-    let mode: string = options?.mode ?? "create";
-    const existOk = options?.existOk ?? false;
-
-    if (mode === "create" && existOk) {
-      mode = "exist_ok";
-    }
-
-    const table = makeEmptyTable(schema);
-    const buf = await fromTableToBuffer(table);
-    const innerTable = await this.inner.createEmptyTable(name, buf, mode);
-    return new Table(innerTable);
-  }
-
-  /**
-   * Drop an existing table.
-   * @param name The name of the table to drop.
-   */
-  async dropTable(name: string): Promise<void> {
-    return this.inner.dropTable(name);
-  }
-}

nodejs/lancedb/embedding/embedding_function.ts

@@ -1,77 +0,0 @@
-// Copyright 2023 Lance Developers.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-import { type Float } from "apache-arrow";
-
-/**
- * An embedding function that automatically creates vector representation for a given column.
- */
-export interface EmbeddingFunction<T> {
-  /**
-   * The name of the column that will be used as input for the Embedding Function.
-   */
-  sourceColumn: string;
-
-  /**
-   * The data type of the embedding
-   *
-   * The embedding function should return `number`.  This will be converted into
-   * an Arrow float array.  By default this will be Float32 but this property can
-   * be used to control the conversion.
-   */
-  embeddingDataType?: Float;
-
-  /**
-   * The dimension of the embedding
-   *
-   * This is optional, normally this can be determined by looking at the results of
-   * `embed`.  If this is not specified, and there is an attempt to apply the embedding
-   * to an empty table, then that process will fail.
-   */
-  embeddingDimension?: number;
-
-  /**
-   * The name of the column that will contain the embedding
-   *
-   * By default this is "vector"
-   */
-  destColumn?: string;
-
-  /**
-   * Should the source column be excluded from the resulting table
-   *
-   * By default the source column is included.  Set this to true and
-   * only the embedding will be stored.
-   */
-  excludeSource?: boolean;
-
-  /**
-   * Creates a vector representation for the given values.
-   */
-  embed: (data: T[]) => Promise<number[][]>;
-}
-
-export function isEmbeddingFunction<T>(
-  value: unknown,
-): value is EmbeddingFunction<T> {
-  if (typeof value !== "object" || value === null) {
-    return false;
-  }
-  if (!("sourceColumn" in value) || !("embed" in value)) {
-    return false;
-  }
-  return (
-    typeof value.sourceColumn === "string" && typeof value.embed === "function"
-  );
-}

nodejs/lancedb/embedding/openai.ts

@@ -1,62 +0,0 @@
-// Copyright 2023 Lance Developers.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-import { type EmbeddingFunction } from "./embedding_function";
-import type OpenAI from "openai";
-
-export class OpenAIEmbeddingFunction implements EmbeddingFunction<string> {
-  private readonly _openai: OpenAI;
-  private readonly _modelName: string;
-
-  constructor(
-    sourceColumn: string,
-    openAIKey: string,
-    modelName: string = "text-embedding-ada-002",
-  ) {
-    /**
-     * @type {import("openai").default}
-     */
-    // eslint-disable-next-line @typescript-eslint/naming-convention
-    let Openai;
-    try {
-      // eslint-disable-next-line @typescript-eslint/no-var-requires
-      Openai = require("openai");
-    } catch {
-      throw new Error("please install openai@^4.24.1 using npm install openai");
-    }
-
-    this.sourceColumn = sourceColumn;
-    const configuration = {
-      apiKey: openAIKey,
-    };
-
-    this._openai = new Openai(configuration);
-    this._modelName = modelName;
-  }
-
-  async embed(data: string[]): Promise<number[][]> {
-    const response = await this._openai.embeddings.create({
-      model: this._modelName,
-      input: data,
-    });
-
-    const embeddings: number[][] = [];
-    for (let i = 0; i < response.data.length; i++) {
-      embeddings.push(response.data[i].embedding);
-    }
-    return embeddings;
-  }
-
-  sourceColumn: string;
-}

nodejs/lancedb/native.d.ts

@@ -1,133 +0,0 @@
-/* tslint:disable */
-/* eslint-disable */
-
-/* auto-generated by NAPI-RS */
-
-export const enum IndexType {
-  Scalar = 0,
-  IvfPq = 1
-}
-export const enum MetricType {
-  L2 = 0,
-  Cosine = 1,
-  Dot = 2
-}
-/**
- *  A definition of a column alteration. The alteration changes the column at
- * `path` to have the new name `name`, to be nullable if `nullable` is true,
- * and to have the data type `data_type`. At least one of `rename` or `nullable`
- * must be provided.
- */
-export interface ColumnAlteration {
-  /**
-   * The path to the column to alter. This is a dot-separated path to the column.
-   * If it is a top-level column then it is just the name of the column. If it is
-   * a nested column then it is the path to the column, e.g. "a.b.c" for a column
-   * `c` nested inside a column `b` nested inside a column `a`.
-   */
-  path: string
-  /**
-   * The new name of the column. If not provided then the name will not be changed.
-   * This must be distinct from the names of all other columns in the table.
-   */
-  rename?: string
-  /** Set the new nullability. Note that a nullable column cannot be made non-nullable. */
-  nullable?: boolean
-}
-/** A definition of a new column to add to a table. */
-export interface AddColumnsSql {
-  /** The name of the new column. */
-  name: string
-  /**
-   * The values to populate the new column with, as a SQL expression.
-   * The expression can reference other columns in the table.
-   */
-  valueSql: string
-}
-export interface ConnectionOptions {
-  apiKey?: string
-  hostOverride?: string
-  /**
-   * (For LanceDB OSS only): The interval, in seconds, at which to check for
-   * updates to the table from other processes. If None, then consistency is not
-   * checked. For performance reasons, this is the default. For strong
-   * consistency, set this to zero seconds. Then every read will check for
-   * updates from other processes. As a compromise, you can set this to a
-   * non-zero value for eventual consistency. If more than that interval
-   * has passed since the last check, then the table will be checked for updates.
-   * Note: this consistency only applies to read operations. Write operations are
-   * always consistent.
-   */
-  readConsistencyInterval?: number
-}
-/** Write mode for writing a table. */
-export const enum WriteMode {
-  Create = 'Create',
-  Append = 'Append',
-  Overwrite = 'Overwrite'
-}
-/** Write options when creating a Table. */
-export interface WriteOptions {
-  mode?: WriteMode
-}
-export function connect(uri: string, options: ConnectionOptions): Promise<Connection>
-export class Connection {
-  /** Create a new Connection instance from the given URI. */
-  static new(uri: string, options: ConnectionOptions): Promise<Connection>
-  display(): string
-  isOpen(): boolean
-  close(): void
-  /** List all tables in the dataset. */
-  tableNames(startAfter?: string | undefined | null, limit?: number | undefined | null): Promise<Array<string>>
-  /**
-   * Create table from a Apache Arrow IPC (file) buffer.
-   *
-   * Parameters:
-   * - name: The name of the table.
-   * - buf: The buffer containing the IPC file.
-   *
-   */
-  createTable(name: string, buf: Buffer, mode: string): Promise<Table>
-  createEmptyTable(name: string, schemaBuf: Buffer, mode: string): Promise<Table>
-  openTable(name: string): Promise<Table>
-  /** Drop table with the name. Or raise an error if the table does not exist. */
-  dropTable(name: string): Promise<void>
-}
-export class IndexBuilder {
-  replace(v: boolean): void
-  column(c: string): void
-  name(name: string): void
-  ivfPq(metricType?: MetricType | undefined | null, numPartitions?: number | undefined | null, numSubVectors?: number | undefined | null, numBits?: number | undefined | null, maxIterations?: number | undefined | null, sampleRate?: number | undefined | null): void
-  scalar(): void
-  build(): Promise<void>
-}
-/** Typescript-style Async Iterator over RecordBatches  */
-export class RecordBatchIterator {
-  next(): Promise<Buffer | null>
-}
-export class Query {
-  column(column: string): void
-  filter(filter: string): void
-  select(columns: Array<string>): void
-  limit(limit: number): void
-  prefilter(prefilter: boolean): void
-  nearestTo(vector: Float32Array): void
-  refineFactor(refineFactor: number): void
-  nprobes(nprobe: number): void
-  executeStream(): Promise<RecordBatchIterator>
-}
-export class Table {
-  display(): string
-  isOpen(): boolean
-  close(): void
-  /** Return Schema as empty Arrow IPC file. */
-  schema(): Promise<Buffer>
-  add(buf: Buffer, mode: string): Promise<void>
-  countRows(filter?: string | undefined | null): Promise<number>
-  delete(predicate: string): Promise<void>
-  createIndex(): IndexBuilder
-  query(): Query
-  addColumns(transforms: Array<AddColumnsSql>): Promise<void>
-  alterColumns(alterations: Array<ColumnAlteration>): Promise<void>
-  dropColumns(columns: Array<string>): Promise<void>
-}

nodejs/lancedb/sanitize.ts

@@ -1,509 +0,0 @@
-// Copyright 2023 LanceDB Developers.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// 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.
-
-import {
-  Field,
-  Utf8,
-  FixedSizeBinary,
-  FixedSizeList,
-  Schema,
-  List,
-  Struct,
-  Float,
-  Bool,
-  Date_,
-  Decimal,
-  DataType,
-  Dictionary,
-  Binary,
-  Float32,
-  Interval,
-  Map_,
-  Duration,
-  Union,
-  Time,
-  Timestamp,
-  Type,
-  Null,
-  Int,
-  type Precision,
-  type DateUnit,
-  Int8,
-  Int16,
-  Int32,
-  Int64,
-  Uint8,
-  Uint16,
-  Uint32,
-  Uint64,
-  Float16,
-  Float64,
-  DateDay,
-  DateMillisecond,
-  DenseUnion,
-  SparseUnion,
-  TimeNanosecond,
-  TimeMicrosecond,
-  TimeMillisecond,
-  TimeSecond,
-  TimestampNanosecond,
-  TimestampMicrosecond,
-  TimestampMillisecond,
-  TimestampSecond,
-  IntervalDayTime,
-  IntervalYearMonth,
-  DurationNanosecond,
-  DurationMicrosecond,
-  DurationMillisecond,
-  DurationSecond,
-} from "apache-arrow";
-import type { IntBitWidth, TKeys, TimeBitWidth } from "apache-arrow/type";
-
-function sanitizeMetadata(
-  metadataLike?: unknown,
-): Map<string, string> | undefined {
-  if (metadataLike === undefined || metadataLike === null) {
-    return undefined;
-  }
-  if (!(metadataLike instanceof Map)) {
-    throw Error("Expected metadata, if present, to be a Map<string, string>");
-  }
-  for (const item of metadataLike) {
-    if (!(typeof item[0] === "string" || !(typeof item[1] === "string"))) {
-      throw Error(
-        "Expected metadata, if present, to be a Map<string, string> but it had non-string keys or values",
-      );
-    }
-  }
-  return metadataLike as Map<string, string>;
-}
-
-function sanitizeInt(typeLike: object) {
-  if (
-    !("bitWidth" in typeLike) ||
-    typeof typeLike.bitWidth !== "number" ||
-    !("isSigned" in typeLike) ||
-    typeof typeLike.isSigned !== "boolean"
-  ) {
-    throw Error(
-      "Expected an Int Type to have a `bitWidth` and `isSigned` property",
-    );
-  }
-  return new Int(typeLike.isSigned, typeLike.bitWidth as IntBitWidth);
-}
-
-function sanitizeFloat(typeLike: object) {
-  if (!("precision" in typeLike) || typeof typeLike.precision !== "number") {
-    throw Error("Expected a Float Type to have a `precision` property");
-  }
-  return new Float(typeLike.precision as Precision);
-}
-
-function sanitizeDecimal(typeLike: object) {
-  if (
-    !("scale" in typeLike) ||
-    typeof typeLike.scale !== "number" ||
-    !("precision" in typeLike) ||
-    typeof typeLike.precision !== "number" ||
-    !("bitWidth" in typeLike) ||
-    typeof typeLike.bitWidth !== "number"
-  ) {
-    throw Error(
-      "Expected a Decimal Type to have `scale`, `precision`, and `bitWidth` properties",
-    );
-  }
-  return new Decimal(typeLike.scale, typeLike.precision, typeLike.bitWidth);
-}
-
-function sanitizeDate(typeLike: object) {
-  if (!("unit" in typeLike) || typeof typeLike.unit !== "number") {
-    throw Error("Expected a Date type to have a `unit` property");
-  }
-  return new Date_(typeLike.unit as DateUnit);
-}
-
-function sanitizeTime(typeLike: object) {
-  if (
-    !("unit" in typeLike) ||
-    typeof typeLike.unit !== "number" ||
-    !("bitWidth" in typeLike) ||
-    typeof typeLike.bitWidth !== "number"
-  ) {
-    throw Error(
-      "Expected a Time type to have `unit` and `bitWidth` properties",
-    );
-  }
-  return new Time(typeLike.unit, typeLike.bitWidth as TimeBitWidth);
-}
-
-function sanitizeTimestamp(typeLike: object) {
-  if (!("unit" in typeLike) || typeof typeLike.unit !== "number") {
-    throw Error("Expected a Timestamp type to have a `unit` property");
-  }
-  let timezone = null;
-  if ("timezone" in typeLike && typeof typeLike.timezone === "string") {
-    timezone = typeLike.timezone;
-  }
-  return new Timestamp(typeLike.unit, timezone);
-}
-
-function sanitizeTypedTimestamp(
-  typeLike: object,
-  // eslint-disable-next-line @typescript-eslint/naming-convention
-  Datatype:
-    | typeof TimestampNanosecond
-    | typeof TimestampMicrosecond
-    | typeof TimestampMillisecond
-    | typeof TimestampSecond,
-) {
-  let timezone = null;
-  if ("timezone" in typeLike && typeof typeLike.timezone === "string") {
-    timezone = typeLike.timezone;
-  }
-  return new Datatype(timezone);
-}
-
-function sanitizeInterval(typeLike: object) {
-  if (!("unit" in typeLike) || typeof typeLike.unit !== "number") {
-    throw Error("Expected an Interval type to have a `unit` property");
-  }
-  return new Interval(typeLike.unit);
-}
-
-function sanitizeList(typeLike: object) {
-  if (!("children" in typeLike) || !Array.isArray(typeLike.children)) {
-    throw Error(
-      "Expected a List type to have an array-like `children` property",
-    );
-  }
-  if (typeLike.children.length !== 1) {
-    throw Error("Expected a List type to have exactly one child");
-  }
-  return new List(sanitizeField(typeLike.children[0]));
-}
-
-function sanitizeStruct(typeLike: object) {
-  if (!("children" in typeLike) || !Array.isArray(typeLike.children)) {
-    throw Error(
-      "Expected a Struct type to have an array-like `children` property",
-    );
-  }
-  return new Struct(typeLike.children.map((child) => sanitizeField(child)));
-}
-
-function sanitizeUnion(typeLike: object) {
-  if (
-    !("typeIds" in typeLike) ||
-    !("mode" in typeLike) ||
-    typeof typeLike.mode !== "number"
-  ) {
-    throw Error(
-      "Expected a Union type to have `typeIds` and `mode` properties",
-    );
-  }
-  if (!("children" in typeLike) || !Array.isArray(typeLike.children)) {
-    throw Error(
-      "Expected a Union type to have an array-like `children` property",
-    );
-  }
-
-  return new Union(
-    typeLike.mode,
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    typeLike.typeIds as any,
-    typeLike.children.map((child) => sanitizeField(child)),
-  );
-}
-
-function sanitizeTypedUnion(
-  typeLike: object,
-  // eslint-disable-next-line @typescript-eslint/naming-convention
-  UnionType: typeof DenseUnion | typeof SparseUnion,
-) {
-  if (!("typeIds" in typeLike)) {
-    throw Error(
-      "Expected a DenseUnion/SparseUnion type to have a `typeIds` property",
-    );
-  }
-  if (!("children" in typeLike) || !Array.isArray(typeLike.children)) {
-    throw Error(
-      "Expected a DenseUnion/SparseUnion type to have an array-like `children` property",
-    );
-  }
-
-  return new UnionType(
-    typeLike.typeIds as Int32Array | number[],
-    typeLike.children.map((child) => sanitizeField(child)),
-  );
-}
-
-function sanitizeFixedSizeBinary(typeLike: object) {
-  if (!("byteWidth" in typeLike) || typeof typeLike.byteWidth !== "number") {
-    throw Error(
-      "Expected a FixedSizeBinary type to have a `byteWidth` property",
-    );
-  }
-  return new FixedSizeBinary(typeLike.byteWidth);
-}
-
-function sanitizeFixedSizeList(typeLike: object) {
-  if (!("listSize" in typeLike) || typeof typeLike.listSize !== "number") {
-    throw Error("Expected a FixedSizeList type to have a `listSize` property");
-  }
-  if (!("children" in typeLike) || !Array.isArray(typeLike.children)) {
-    throw Error(
-      "Expected a FixedSizeList type to have an array-like `children` property",
-    );
-  }
-  if (typeLike.children.length !== 1) {
-    throw Error("Expected a FixedSizeList type to have exactly one child");
-  }
-  return new FixedSizeList(
-    typeLike.listSize,
-    sanitizeField(typeLike.children[0]),
-  );
-}
-
-function sanitizeMap(typeLike: object) {
-  if (!("children" in typeLike) || !Array.isArray(typeLike.children)) {
-    throw Error(
-      "Expected a Map type to have an array-like `children` property",
-    );
-  }
-  if (!("keysSorted" in typeLike) || typeof typeLike.keysSorted !== "boolean") {
-    throw Error("Expected a Map type to have a `keysSorted` property");
-  }
-
-  return new Map_(
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    typeLike.children.map((field) => sanitizeField(field)) as any,
-    typeLike.keysSorted,
-  );
-}
-
-function sanitizeDuration(typeLike: object) {
-  if (!("unit" in typeLike) || typeof typeLike.unit !== "number") {
-    throw Error("Expected a Duration type to have a `unit` property");
-  }
-  return new Duration(typeLike.unit);
-}
-
-function sanitizeDictionary(typeLike: object) {
-  if (!("id" in typeLike) || typeof typeLike.id !== "number") {
-    throw Error("Expected a Dictionary type to have an `id` property");
-  }
-  if (!("indices" in typeLike) || typeof typeLike.indices !== "object") {
-    throw Error("Expected a Dictionary type to have an `indices` property");
-  }
-  if (!("dictionary" in typeLike) || typeof typeLike.dictionary !== "object") {
-    throw Error("Expected a Dictionary type to have an `dictionary` property");
-  }
-  if (!("isOrdered" in typeLike) || typeof typeLike.isOrdered !== "boolean") {
-    throw Error("Expected a Dictionary type to have an `isOrdered` property");
-  }
-  return new Dictionary(
-    sanitizeType(typeLike.dictionary),
-    sanitizeType(typeLike.indices) as TKeys,
-    typeLike.id,
-    typeLike.isOrdered,
-  );
-}
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function sanitizeType(typeLike: unknown): DataType<any> {
-  if (typeof typeLike !== "object" || typeLike === null) {
-    throw Error("Expected a Type but object was null/undefined");
-  }
-  if (!("typeId" in typeLike) || !(typeof typeLike.typeId !== "function")) {
-    throw Error("Expected a Type to have a typeId function");
-  }
-  let typeId: Type;
-  if (typeof typeLike.typeId === "function") {
-    typeId = (typeLike.typeId as () => unknown)() as Type;
-  } else if (typeof typeLike.typeId === "number") {
-    typeId = typeLike.typeId as Type;
-  } else {
-    throw Error("Type's typeId property was not a function or number");
-  }
-
-  switch (typeId) {
-    case Type.NONE:
-      throw Error("Received a Type with a typeId of NONE");
-    case Type.Null:
-      return new Null();
-    case Type.Int:
-      return sanitizeInt(typeLike);
-    case Type.Float:
-      return sanitizeFloat(typeLike);
-    case Type.Binary:
-      return new Binary();
-    case Type.Utf8:
-      return new Utf8();
-    case Type.Bool:
-      return new Bool();
-    case Type.Decimal:
-      return sanitizeDecimal(typeLike);
-    case Type.Date:
-      return sanitizeDate(typeLike);
-    case Type.Time:
-      return sanitizeTime(typeLike);
-    case Type.Timestamp:
-      return sanitizeTimestamp(typeLike);
-    case Type.Interval:
-      return sanitizeInterval(typeLike);
-    case Type.List:
-      return sanitizeList(typeLike);
-    case Type.Struct:
-      return sanitizeStruct(typeLike);
-    case Type.Union:
-      return sanitizeUnion(typeLike);
-    case Type.FixedSizeBinary:
-      return sanitizeFixedSizeBinary(typeLike);
-    case Type.FixedSizeList:
-      return sanitizeFixedSizeList(typeLike);
-    case Type.Map:
-      return sanitizeMap(typeLike);
-    case Type.Duration:
-      return sanitizeDuration(typeLike);
-    case Type.Dictionary:
-      return sanitizeDictionary(typeLike);
-    case Type.Int8:
-      return new Int8();
-    case Type.Int16:
-      return new Int16();
-    case Type.Int32:
-      return new Int32();
-    case Type.Int64:
-      return new Int64();
-    case Type.Uint8:
-      return new Uint8();
-    case Type.Uint16:
-      return new Uint16();
-    case Type.Uint32:
-      return new Uint32();
-    case Type.Uint64:
-      return new Uint64();
-    case Type.Float16:
-      return new Float16();
-    case Type.Float32:
-      return new Float32();
-    case Type.Float64:
-      return new Float64();
-    case Type.DateMillisecond:
-      return new DateMillisecond();
-    case Type.DateDay:
-      return new DateDay();
-    case Type.TimeNanosecond:
-      return new TimeNanosecond();
-    case Type.TimeMicrosecond:
-      return new TimeMicrosecond();
-    case Type.TimeMillisecond:
-      return new TimeMillisecond();
-    case Type.TimeSecond:
-      return new TimeSecond();
-    case Type.TimestampNanosecond:
-      return sanitizeTypedTimestamp(typeLike, TimestampNanosecond);
-    case Type.TimestampMicrosecond:
-      return sanitizeTypedTimestamp(typeLike, TimestampMicrosecond);
-    case Type.TimestampMillisecond:
-      return sanitizeTypedTimestamp(typeLike, TimestampMillisecond);
-    case Type.TimestampSecond:
-      return sanitizeTypedTimestamp(typeLike, TimestampSecond);
-    case Type.DenseUnion:
-      return sanitizeTypedUnion(typeLike, DenseUnion);
-    case Type.SparseUnion:
-      return sanitizeTypedUnion(typeLike, SparseUnion);
-    case Type.IntervalDayTime:
-      return new IntervalDayTime();
-    case Type.IntervalYearMonth:
-      return new IntervalYearMonth();
-    case Type.DurationNanosecond:
-      return new DurationNanosecond();
-    case Type.DurationMicrosecond:
-      return new DurationMicrosecond();
-    case Type.DurationMillisecond:
-      return new DurationMillisecond();
-    case Type.DurationSecond:
-      return new DurationSecond();
-    default:
-      throw new Error("Unrecoginized type id in schema: " + typeId);
-  }
-}
-
-function sanitizeField(fieldLike: unknown): Field {
-  if (fieldLike instanceof Field) {
-    return fieldLike;
-  }
-  if (typeof fieldLike !== "object" || fieldLike === null) {
-    throw Error("Expected a Field but object was null/undefined");
-  }
-  if (
-    !("type" in fieldLike) ||
-    !("name" in fieldLike) ||
-    !("nullable" in fieldLike)
-  ) {
-    throw Error(
-      "The field passed in is missing a `type`/`name`/`nullable` property",
-    );
-  }
-  const type = sanitizeType(fieldLike.type);
-  const name = fieldLike.name;
-  if (!(typeof name === "string")) {
-    throw Error("The field passed in had a non-string `name` property");
-  }
-  const nullable = fieldLike.nullable;
-  if (!(typeof nullable === "boolean")) {
-    throw Error("The field passed in had a non-boolean `nullable` property");
-  }
-  let metadata;
-  if ("metadata" in fieldLike) {
-    metadata = sanitizeMetadata(fieldLike.metadata);
-  }
-  return new Field(name, type, nullable, metadata);
-}
-
-export function sanitizeSchema(schemaLike: unknown): Schema {
-  if (schemaLike instanceof Schema) {
-    return schemaLike;
-  }
-  if (typeof schemaLike !== "object" || schemaLike === null) {
-    throw Error("Expected a Schema but object was null/undefined");
-  }
-  if (!("fields" in schemaLike)) {
-    throw Error(
-      "The schema passed in does not appear to be a schema (no 'fields' property)",
-    );
-  }
-  let metadata;
-  if ("metadata" in schemaLike) {
-    metadata = sanitizeMetadata(schemaLike.metadata);
-  }
-  if (!Array.isArray(schemaLike.fields)) {
-    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 Schema(sanitizedFields, metadata);
-}

nodejs/npm/darwin-arm64/README.md

@@ -1,3 +1,3 @@
-# `lancedb-darwin-arm64`
+# `vectordb-darwin-arm64`
 
-This is the **aarch64-apple-darwin** binary for `lancedb`
+This is the **aarch64-apple-darwin** binary for `vectordb`

nodejs/npm/darwin-arm64/package.json

@@ -1,5 +1,5 @@
 {
-  "name": "lancedb-darwin-arm64",
+  "name": "vectordb-darwin-arm64",
   "version": "0.4.3",
   "os": [
     "darwin"
@@ -7,12 +7,12 @@
   "cpu": [
     "arm64"
   ],
-  "main": "lancedb.darwin-arm64.node",
+  "main": "vectordb.darwin-arm64.node",
   "files": [
-    "lancedb.darwin-arm64.node"
+    "vectordb.darwin-arm64.node"
   ],
   "license": "MIT",
   "engines": {
     "node": ">= 18"
   }
-}
+}

nodejs/npm/darwin-x64/README.md

@@ -1,3 +1,3 @@
-# `lancedb-darwin-x64`
+# `vectordb-darwin-x64`
 
-This is the **x86_64-apple-darwin** binary for `lancedb`
+This is the **x86_64-apple-darwin** binary for `vectordb`

nodejs/npm/darwin-x64/package.json

@@ -1,5 +1,5 @@
 {
-  "name": "lancedb-darwin-x64",
+  "name": "vectordb-darwin-x64",
   "version": "0.4.3",
   "os": [
     "darwin"
@@ -7,12 +7,12 @@
   "cpu": [
     "x64"
   ],
-  "main": "lancedb.darwin-x64.node",
+  "main": "vectordb.darwin-x64.node",
   "files": [
-    "lancedb.darwin-x64.node"
+    "vectordb.darwin-x64.node"
   ],
   "license": "MIT",
   "engines": {
     "node": ">= 18"
   }
-}
+}

nodejs/npm/linux-arm64-gnu/README.md

@@ -1,3 +1,3 @@
-# `lancedb-linux-arm64-gnu`
+# `vectordb-linux-arm64-gnu`
 
-This is the **aarch64-unknown-linux-gnu** binary for `lancedb`
+This is the **aarch64-unknown-linux-gnu** binary for `vectordb`

nodejs/npm/linux-arm64-gnu/package.json

@@ -1,5 +1,5 @@
 {
-  "name": "lancedb-linux-arm64-gnu",
+  "name": "vectordb-linux-arm64-gnu",
   "version": "0.4.3",
   "os": [
     "linux"
@@ -7,9 +7,9 @@
   "cpu": [
     "arm64"
   ],
-  "main": "lancedb.linux-arm64-gnu.node",
+  "main": "vectordb.linux-arm64-gnu.node",
   "files": [
-    "lancedb.linux-arm64-gnu.node"
+    "vectordb.linux-arm64-gnu.node"
   ],
   "license": "MIT",
   "engines": {
@@ -18,4 +18,4 @@
   "libc": [
     "glibc"
   ]
-}
+}

nodejs/npm/linux-x64-gnu/README.md

@@ -1,3 +1,3 @@
-# `lancedb-linux-x64-gnu`
+# `vectordb-linux-x64-gnu`
 
-This is the **x86_64-unknown-linux-gnu** binary for `lancedb`
+This is the **x86_64-unknown-linux-gnu** binary for `vectordb`

nodejs/npm/linux-x64-gnu/package.json

@@ -1,5 +1,5 @@
 {
-  "name": "lancedb-linux-x64-gnu",
+  "name": "vectordb-linux-x64-gnu",
   "version": "0.4.3",
   "os": [
     "linux"
@@ -7,9 +7,9 @@
   "cpu": [
     "x64"
   ],
-  "main": "lancedb.linux-x64-gnu.node",
+  "main": "vectordb.linux-x64-gnu.node",
   "files": [
-    "lancedb.linux-x64-gnu.node"
+    "vectordb.linux-x64-gnu.node"
   ],
   "license": "MIT",
   "engines": {
@@ -18,4 +18,4 @@
   "libc": [
     "glibc"
   ]
-}
+}

nodejs/package.json

@@ -1,10 +1,10 @@
 {
-  "name": "lancedb",
+  "name": "vectordb",
   "version": "0.4.3",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "napi": {
-    "name": "lancedb-nodejs",
+    "name": "vectordb-nodejs",
     "triples": {
       "defaults": false,
       "additional": [
@@ -18,21 +18,15 @@
   "license": "Apache 2.0",
   "devDependencies": {
     "@napi-rs/cli": "^2.18.0",
-    "@types/jest": "^29.1.2",
-    "@types/tmp": "^0.2.6",
+    "@types/jest": "^29.5.11",
     "@typescript-eslint/eslint-plugin": "^6.19.0",
     "@typescript-eslint/parser": "^6.19.0",
-    "apache-arrow-old": "npm:apache-arrow@13.0.0",
-    "eslint": "^8.57.0",
-    "eslint-config-prettier": "^9.1.0",
+    "eslint": "^8.56.0",
     "jest": "^29.7.0",
-    "prettier": "^3.1.0",
-    "tmp": "^0.2.3",
     "ts-jest": "^29.1.2",
     "typedoc": "^0.25.7",
     "typedoc-plugin-markdown": "^3.17.1",
-    "typescript": "^5.3.3",
-    "typescript-eslint": "^7.1.0"
+    "typescript": "^5.3.3"
   },
   "ava": {
     "timeout": "3m"
@@ -51,25 +45,23 @@
   ],
   "scripts": {
     "artifacts": "napi artifacts",
-    "build:native": "napi build --platform --release --js lancedb/native.js --dts lancedb/native.d.ts dist/",
-    "build:debug": "napi build --platform --dts ../lancedb/native.d.ts --js ../lancedb/native.js dist/",
+    "build:native": "napi build --platform --release --js vectordb/native.js --dts vectordb/native.d.ts dist/",
+    "build:debug": "napi build --platform --dts ../vectordb/native.d.ts --js ../vectordb/native.js dist/",
     "build": "npm run build:debug && tsc -b",
-    "chkformat": "prettier . --check",
-    "docs": "typedoc --plugin typedoc-plugin-markdown lancedb/index.ts",
-    "lint": "eslint lancedb && eslint __test__",
+    "docs": "typedoc --plugin typedoc-plugin-markdown vectordb/index.ts",
+    "lint": "eslint vectordb --ext .js,.ts",
     "prepublishOnly": "napi prepublish -t npm",
-    "test": "npm run build && jest --verbose",
+    "test": "npm run build && jest",
     "universal": "napi universal",
     "version": "napi version"
   },
   "optionalDependencies": {
-    "lancedb-darwin-arm64": "0.4.3",
-    "lancedb-darwin-x64": "0.4.3",
-    "lancedb-linux-arm64-gnu": "0.4.3",
-    "lancedb-linux-x64-gnu": "0.4.3",
-    "openai": "^4.28.4"
+    "vectordb-darwin-arm64": "0.4.3",
+    "vectordb-darwin-x64": "0.4.3",
+    "vectordb-linux-arm64-gnu": "0.4.3",
+    "vectordb-linux-x64-gnu": "0.4.3"
   },
-  "peerDependencies": {
+  "dependencies": {
     "apache-arrow": "^15.0.0"
   }
 }

nodejs/src/connection.rs

@@ -12,96 +12,37 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+use std::sync::Arc;
+
 use napi::bindgen_prelude::*;
 use napi_derive::*;
 
 use crate::table::Table;
-use crate::ConnectionOptions;
-use lancedb::connection::{ConnectBuilder, Connection as LanceDBConnection, CreateTableMode};
-use lancedb::ipc::{ipc_file_to_batches, ipc_file_to_schema};
+use vectordb::connection::{Connection as LanceDBConnection, Database};
+use vectordb::ipc::ipc_file_to_batches;
 
 #[napi]
 pub struct Connection {
-    inner: Option<LanceDBConnection>,
-}
-
-impl Connection {
-    pub(crate) fn inner_new(inner: LanceDBConnection) -> Self {
-        Self { inner: Some(inner) }
-    }
-
-    fn get_inner(&self) -> napi::Result<&LanceDBConnection> {
-        self.inner
-            .as_ref()
-            .ok_or_else(|| napi::Error::from_reason("Connection is closed"))
-    }
-}
-
-impl Connection {
-    fn parse_create_mode_str(mode: &str) -> napi::Result<CreateTableMode> {
-        match mode {
-            "create" => Ok(CreateTableMode::Create),
-            "overwrite" => Ok(CreateTableMode::Overwrite),
-            "exist_ok" => Ok(CreateTableMode::exist_ok(|builder| builder)),
-            _ => Err(napi::Error::from_reason(format!("Invalid mode {}", mode))),
-        }
-    }
+    conn: Arc<dyn LanceDBConnection>,
 }
 
 #[napi]
 impl Connection {
     /// Create a new Connection instance from the given URI.
     #[napi(factory)]
-    pub async fn new(uri: String, options: ConnectionOptions) -> napi::Result<Self> {
-        let mut builder = ConnectBuilder::new(&uri);
-        if let Some(api_key) = options.api_key {
-            builder = builder.api_key(&api_key);
-        }
-        if let Some(host_override) = options.host_override {
-            builder = builder.host_override(&host_override);
-        }
-        if let Some(interval) = options.read_consistency_interval {
-            builder =
-                builder.read_consistency_interval(std::time::Duration::from_secs_f64(interval));
-        }
-        Ok(Self::inner_new(
-            builder
-                .execute()
-                .await
-                .map_err(|e| napi::Error::from_reason(format!("{}", e)))?,
-        ))
-    }
-
-    #[napi]
-    pub fn display(&self) -> napi::Result<String> {
-        Ok(self.get_inner()?.to_string())
-    }
-
-    #[napi]
-    pub fn is_open(&self) -> bool {
-        self.inner.is_some()
-    }
-
-    #[napi]
-    pub fn close(&mut self) {
-        self.inner.take();
+    pub async fn new(uri: String) -> napi::Result<Self> {
+        Ok(Self {
+            conn: Arc::new(Database::connect(&uri).await.map_err(|e| {
+                napi::Error::from_reason(format!("Failed to connect to database: {}", e))
+            })?),
+        })
     }
 
     /// List all tables in the dataset.
     #[napi]
-    pub async fn table_names(
-        &self,
-        start_after: Option<String>,
-        limit: Option<u32>,
-    ) -> napi::Result<Vec<String>> {
-        let mut op = self.get_inner()?.table_names();
-        if let Some(start_after) = start_after {
-            op = op.start_after(start_after);
-        }
-        if let Some(limit) = limit {
-            op = op.limit(limit);
-        }
-        op.execute()
+    pub async fn table_names(&self) -> napi::Result<Vec<String>> {
+        self.conn
+            .table_names()
             .await
             .map_err(|e| napi::Error::from_reason(format!("{}", e)))
     }
@@ -113,41 +54,12 @@ impl Connection {
     /// - buf: The buffer containing the IPC file.
     ///
     #[napi]
-    pub async fn create_table(
-        &self,
-        name: String,
-        buf: Buffer,
-        mode: String,
-    ) -> napi::Result<Table> {
+    pub async fn create_table(&self, name: String, buf: Buffer) -> napi::Result<Table> {
         let batches = ipc_file_to_batches(buf.to_vec())
             .map_err(|e| napi::Error::from_reason(format!("Failed to read IPC file: {}", e)))?;
-        let mode = Self::parse_create_mode_str(&mode)?;
         let tbl = self
-            .get_inner()?
-            .create_table(&name, Box::new(batches))
-            .mode(mode)
-            .execute()
-            .await
-            .map_err(|e| napi::Error::from_reason(format!("{}", e)))?;
-        Ok(Table::new(tbl))
-    }
-
-    #[napi]
-    pub async fn create_empty_table(
-        &self,
-        name: String,
-        schema_buf: Buffer,
-        mode: String,
-    ) -> napi::Result<Table> {
-        let schema = ipc_file_to_schema(schema_buf.to_vec()).map_err(|e| {
-            napi::Error::from_reason(format!("Failed to marshal schema from JS to Rust: {}", e))
-        })?;
-        let mode = Self::parse_create_mode_str(&mode)?;
-        let tbl = self
-            .get_inner()?
-            .create_empty_table(&name, schema)
-            .mode(mode)
-            .execute()
+            .conn
+            .create_table(&name, Box::new(batches), None)
             .await
             .map_err(|e| napi::Error::from_reason(format!("{}", e)))?;
         Ok(Table::new(tbl))
@@ -156,9 +68,8 @@ impl Connection {
     #[napi]
     pub async fn open_table(&self, name: String) -> napi::Result<Table> {
         let tbl = self
-            .get_inner()?
+            .conn
             .open_table(&name)
-            .execute()
             .await
             .map_err(|e| napi::Error::from_reason(format!("{}", e)))?;
         Ok(Table::new(tbl))
@@ -167,7 +78,7 @@ impl Connection {
     /// Drop table with the name. Or raise an error if the table does not exist.
     #[napi]
     pub async fn drop_table(&self, name: String) -> napi::Result<()> {
-        self.get_inner()?
+        self.conn
             .drop_table(&name)
             .await
             .map_err(|e| napi::Error::from_reason(format!("{}", e)))

nodejs/src/index.rs

@@ -12,11 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use std::sync::Mutex;
-
 use lance_linalg::distance::MetricType as LanceMetricType;
-use lancedb::index::IndexBuilder as LanceDbIndexBuilder;
-use lancedb::Table as LanceDbTable;
 use napi_derive::napi;
 
 #[napi]
@@ -44,93 +40,58 @@ impl From<MetricType> for LanceMetricType {
 
 #[napi]
 pub struct IndexBuilder {
-    inner: Mutex<Option<LanceDbIndexBuilder>>,
-}
-
-impl IndexBuilder {
-    fn modify(
-        &self,
-        mod_fn: impl Fn(LanceDbIndexBuilder) -> LanceDbIndexBuilder,
-    ) -> napi::Result<()> {
-        let mut inner = self.inner.lock().unwrap();
-        let inner_builder = inner.take().ok_or_else(|| {
-            napi::Error::from_reason("IndexBuilder has already been consumed".to_string())
-        })?;
-        let inner_builder = mod_fn(inner_builder);
-        inner.replace(inner_builder);
-        Ok(())
-    }
+    inner: vectordb::index::IndexBuilder,
 }
 
 #[napi]
 impl IndexBuilder {
-    pub fn new(tbl: &LanceDbTable) -> Self {
+    pub fn new(tbl: &dyn vectordb::Table) -> Self {
         let inner = tbl.create_index(&[]);
-        Self {
-            inner: Mutex::new(Some(inner)),
-        }
+        Self { inner }
     }
 
     #[napi]
-    pub fn replace(&self, v: bool) -> napi::Result<()> {
-        self.modify(|b| b.replace(v))
+    pub unsafe fn replace(&mut self, v: bool) {
+        self.inner.replace(v);
     }
 
     #[napi]
-    pub fn column(&self, c: String) -> napi::Result<()> {
-        self.modify(|b| b.columns(&[c.as_str()]))
+    pub unsafe fn column(&mut self, c: String) {
+        self.inner.columns(&[c.as_str()]);
     }
 
     #[napi]
-    pub fn name(&self, name: String) -> napi::Result<()> {
-        self.modify(|b| b.name(name.as_str()))
+    pub unsafe fn name(&mut self, name: String) {
+        self.inner.name(name.as_str());
     }
 
     #[napi]
-    pub fn ivf_pq(
-        &self,
+    pub unsafe fn ivf_pq(
+        &mut self,
         metric_type: Option<MetricType>,
         num_partitions: Option<u32>,
         num_sub_vectors: Option<u32>,
         num_bits: Option<u32>,
         max_iterations: Option<u32>,
         sample_rate: Option<u32>,
-    ) -> napi::Result<()> {
-        self.modify(|b| {
-            let mut b = b.ivf_pq();
-            if let Some(metric_type) = metric_type {
-                b = b.metric_type(metric_type.into());
-            }
-            if let Some(num_partitions) = num_partitions {
-                b = b.num_partitions(num_partitions);
-            }
-            if let Some(num_sub_vectors) = num_sub_vectors {
-                b = b.num_sub_vectors(num_sub_vectors);
-            }
-            if let Some(num_bits) = num_bits {
-                b = b.num_bits(num_bits);
-            }
-            if let Some(max_iterations) = max_iterations {
-                b = b.max_iterations(max_iterations);
-            }
-            if let Some(sample_rate) = sample_rate {
-                b = b.sample_rate(sample_rate);
-            }
-            b
-        })
+    ) {
+        self.inner.ivf_pq();
+        metric_type.map(|m| self.inner.metric_type(m.into()));
+        num_partitions.map(|p| self.inner.num_partitions(p));
+        num_sub_vectors.map(|s| self.inner.num_sub_vectors(s));
+        num_bits.map(|b| self.inner.num_bits(b));
+        max_iterations.map(|i| self.inner.max_iterations(i));
+        sample_rate.map(|s| self.inner.sample_rate(s));
     }
 
     #[napi]
-    pub fn scalar(&self) -> napi::Result<()> {
-        self.modify(|b| b.scalar())
+    pub unsafe fn scalar(&mut self) {
+        self.inner.scalar();
     }
 
     #[napi]
     pub async fn build(&self) -> napi::Result<()> {
-        let inner = self.inner.lock().unwrap().take().ok_or_else(|| {
-            napi::Error::from_reason("IndexBuilder has already been consumed".to_string())
-        })?;
-        inner
+        self.inner
             .build()
             .await
             .map_err(|e| napi::Error::from_reason(format!("Failed to build index: {}", e)))?;

nodejs/src/iterator.rs

@@ -14,9 +14,9 @@
 
 use futures::StreamExt;
 use lance::io::RecordBatchStream;
-use lancedb::ipc::batches_to_ipc_file;
 use napi::bindgen_prelude::*;
 use napi_derive::napi;
+use vectordb::ipc::batches_to_ipc_file;
 
 /** Typescript-style Async Iterator over RecordBatches */
 #[napi]

nodejs/src/lib.rs

@@ -22,20 +22,10 @@ mod query;
 mod table;
 
 #[napi(object)]
-#[derive(Debug)]
 pub struct ConnectionOptions {
+    pub uri: String,
     pub api_key: Option<String>,
     pub host_override: Option<String>,
-    /// (For LanceDB OSS only): The interval, in seconds, at which to check for
-    /// updates to the table from other processes. If None, then consistency is not
-    /// checked. For performance reasons, this is the default. For strong
-    /// consistency, set this to zero seconds. Then every read will check for
-    /// updates from other processes. As a compromise, you can set this to a
-    /// non-zero value for eventual consistency. If more than that interval
-    /// has passed since the last check, then the table will be checked for updates.
-    /// Note: this consistency only applies to read operations. Write operations are
-    /// always consistent.
-    pub read_consistency_interval: Option<f64>,
 }
 
 /// Write mode for writing a table.
@@ -53,6 +43,6 @@ pub struct WriteOptions {
 }
 
 #[napi]
-pub async fn connect(uri: String, options: ConnectionOptions) -> napi::Result<Connection> {
-    Connection::new(uri, options).await
+pub async fn connect(options: ConnectionOptions) -> napi::Result<Connection> {
+    Connection::new(options.uri.clone()).await
 }

nodejs/src/query.rs

@@ -12,11 +12,11 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use lancedb::query::Query as LanceDBQuery;
 use napi::bindgen_prelude::*;
 use napi_derive::napi;
+use vectordb::query::Query as LanceDBQuery;
 
-use crate::iterator::RecordBatchIterator;
+use crate::{iterator::RecordBatchIterator, table::Table};
 
 #[napi]
 pub struct Query {
@@ -25,8 +25,10 @@ pub struct Query {
 
 #[napi]
 impl Query {
-    pub fn new(query: LanceDBQuery) -> Self {
-        Self { inner: query }
+    pub fn new(table: &Table) -> Self {
+        Self {
+            inner: table.table.query(),
+        }
     }
 
     #[napi]

nodejs/src/table.rs

@@ -13,66 +13,28 @@
 // limitations under the License.
 
 use arrow_ipc::writer::FileWriter;
-use lance::dataset::ColumnAlteration as LanceColumnAlteration;
-use lancedb::ipc::ipc_file_to_batches;
-use lancedb::table::{AddDataMode, Table as LanceDbTable};
 use napi::bindgen_prelude::*;
 use napi_derive::napi;
+use vectordb::{ipc::ipc_file_to_batches, table::TableRef};
 
 use crate::index::IndexBuilder;
 use crate::query::Query;
 
 #[napi]
 pub struct Table {
-    // We keep a duplicate of the table name so we can use it for error
-    // messages even if the table has been closed
-    name: String,
-    pub(crate) inner: Option<LanceDbTable>,
-}
-
-impl Table {
-    fn inner_ref(&self) -> napi::Result<&LanceDbTable> {
-        self.inner
-            .as_ref()
-            .ok_or_else(|| napi::Error::from_reason(format!("Table {} is closed", self.name)))
-    }
+    pub(crate) table: TableRef,
 }
 
 #[napi]
 impl Table {
-    pub(crate) fn new(table: LanceDbTable) -> Self {
-        Self {
-            name: table.name().to_string(),
-            inner: Some(table),
-        }
-    }
-
-    #[napi]
-    pub fn display(&self) -> String {
-        match &self.inner {
-            None => format!("ClosedTable({})", self.name),
-            Some(inner) => inner.to_string(),
-        }
-    }
-
-    #[napi]
-    pub fn is_open(&self) -> bool {
-        self.inner.is_some()
-    }
-
-    #[napi]
-    pub fn close(&mut self) {
-        self.inner.take();
+    pub(crate) fn new(table: TableRef) -> Self {
+        Self { table }
     }
 
     /// Return Schema as empty Arrow IPC file.
     #[napi]
-    pub async fn schema(&self) -> napi::Result<Buffer> {
-        let schema =
-            self.inner_ref()?.schema().await.map_err(|e| {
-                napi::Error::from_reason(format!("Failed to create IPC file: {}", e))
-            })?;
-        let mut writer = FileWriter::try_new(vec![], &schema)
+    pub fn schema(&self) -> napi::Result<Buffer> {
+        let mut writer = FileWriter::try_new(vec![], &self.table.schema())
             .map_err(|e| napi::Error::from_reason(format!("Failed to create IPC file: {}", e)))?;
         writer
             .finish()
@@ -83,163 +45,44 @@ impl Table {
     }
 
     #[napi]
-    pub async fn add(&self, buf: Buffer, mode: String) -> napi::Result<()> {
+    pub async fn add(&self, buf: Buffer) -> napi::Result<()> {
         let batches = ipc_file_to_batches(buf.to_vec())
             .map_err(|e| napi::Error::from_reason(format!("Failed to read IPC file: {}", e)))?;
-        let mut op = self.inner_ref()?.add(Box::new(batches));
-
-        op = if mode == "append" {
-            op.mode(AddDataMode::Append)
-        } else if mode == "overwrite" {
-            op.mode(AddDataMode::Overwrite)
-        } else {
-            return Err(napi::Error::from_reason(format!("Invalid mode: {}", mode)));
-        };
-
-        op.execute().await.map_err(|e| {
+        self.table.add(Box::new(batches), None).await.map_err(|e| {
             napi::Error::from_reason(format!(
                 "Failed to add batches to table {}: {}",
-                self.name, e
+                self.table, e
             ))
         })
     }
 
     #[napi]
-    pub async fn count_rows(&self, filter: Option<String>) -> napi::Result<i64> {
-        self.inner_ref()?
-            .count_rows(filter)
-            .await
-            .map(|val| val as i64)
-            .map_err(|e| {
-                napi::Error::from_reason(format!(
-                    "Failed to count rows in table {}: {}",
-                    self.name, e
-                ))
-            })
+    pub async fn count_rows(&self, filter: Option<String>) -> napi::Result<usize> {
+        self.table.count_rows(filter).await.map_err(|e| {
+            napi::Error::from_reason(format!(
+                "Failed to count rows in table {}: {}",
+                self.table, e
+            ))
+        })
     }
 
     #[napi]
     pub async fn delete(&self, predicate: String) -> napi::Result<()> {
-        self.inner_ref()?.delete(&predicate).await.map_err(|e| {
+        self.table.delete(&predicate).await.map_err(|e| {
             napi::Error::from_reason(format!(
                 "Failed to delete rows in table {}: predicate={}",
-                self.name, e
+                self.table, e
             ))
         })
     }
 
     #[napi]
-    pub fn create_index(&self) -> napi::Result<IndexBuilder> {
-        Ok(IndexBuilder::new(self.inner_ref()?))
+    pub fn create_index(&self) -> IndexBuilder {
+        IndexBuilder::new(self.table.as_ref())
     }
 
     #[napi]
-    pub fn query(&self) -> napi::Result<Query> {
-        Ok(Query::new(self.inner_ref()?.query()))
-    }
-
-    #[napi]
-    pub async fn add_columns(&self, transforms: Vec<AddColumnsSql>) -> napi::Result<()> {
-        let transforms = transforms
-            .into_iter()
-            .map(|sql| (sql.name, sql.value_sql))
-            .collect::<Vec<_>>();
-        let transforms = lance::dataset::NewColumnTransform::SqlExpressions(transforms);
-        self.inner_ref()?
-            .add_columns(transforms, None)
-            .await
-            .map_err(|err| {
-                napi::Error::from_reason(format!(
-                    "Failed to add columns to table {}: {}",
-                    self.name, err
-                ))
-            })?;
-        Ok(())
-    }
-
-    #[napi]
-    pub async fn alter_columns(&self, alterations: Vec<ColumnAlteration>) -> napi::Result<()> {
-        for alteration in &alterations {
-            if alteration.rename.is_none() && alteration.nullable.is_none() {
-                return Err(napi::Error::from_reason(
-                    "Alteration must have a 'rename' or 'nullable' field.",
-                ));
-            }
-        }
-        let alterations = alterations
-            .into_iter()
-            .map(LanceColumnAlteration::from)
-            .collect::<Vec<_>>();
-
-        self.inner_ref()?
-            .alter_columns(&alterations)
-            .await
-            .map_err(|err| {
-                napi::Error::from_reason(format!(
-                    "Failed to alter columns in table {}: {}",
-                    self.name, err
-                ))
-            })?;
-        Ok(())
-    }
-
-    #[napi]
-    pub async fn drop_columns(&self, columns: Vec<String>) -> napi::Result<()> {
-        let col_refs = columns.iter().map(String::as_str).collect::<Vec<_>>();
-        self.inner_ref()?
-            .drop_columns(&col_refs)
-            .await
-            .map_err(|err| {
-                napi::Error::from_reason(format!(
-                    "Failed to drop columns from table {}: {}",
-                    self.name, err
-                ))
-            })?;
-        Ok(())
+    pub fn query(&self) -> Query {
+        Query::new(self)
     }
 }
-
-///  A definition of a column alteration. The alteration changes the column at
-/// `path` to have the new name `name`, to be nullable if `nullable` is true,
-/// and to have the data type `data_type`. At least one of `rename` or `nullable`
-/// must be provided.
-#[napi(object)]
-pub struct ColumnAlteration {
-    /// The path to the column to alter. This is a dot-separated path to the column.
-    /// If it is a top-level column then it is just the name of the column. If it is
-    /// a nested column then it is the path to the column, e.g. "a.b.c" for a column
-    /// `c` nested inside a column `b` nested inside a column `a`.
-    pub path: String,
-    /// The new name of the column. If not provided then the name will not be changed.
-    /// This must be distinct from the names of all other columns in the table.
-    pub rename: Option<String>,
-    /// Set the new nullability. Note that a nullable column cannot be made non-nullable.
-    pub nullable: Option<bool>,
-}
-
-impl From<ColumnAlteration> for LanceColumnAlteration {
-    fn from(js: ColumnAlteration) -> Self {
-        let ColumnAlteration {
-            path,
-            rename,
-            nullable,
-        } = js;
-        Self {
-            path,
-            rename,
-            nullable,
-            // TODO: wire up this field
-            data_type: None,
-        }
-    }
-}
-
-/// A definition of a new column to add to a table.
-#[napi(object)]
-pub struct AddColumnsSql {
-    /// The name of the new column.
-    pub name: String,
-    /// The values to populate the new column with, as a SQL expression.
-    /// The expression can reference other columns in the table.
-    pub value_sql: String,
-}

nodejs/tsconfig.json

@@ -1,5 +1,9 @@
 {
-  "include": ["lancedb/*.ts", "lancedb/**/*.ts", "lancedb/*.js"],
+  "include": [
+    "vectordb/*.ts",
+    "vectordb/**/*.ts",
+    "vectordb/*.js",
+  ],
   "compilerOptions": {
     "target": "es2022",
     "module": "commonjs",
@@ -7,17 +11,21 @@
     "outDir": "./dist",
     "strict": true,
     "allowJs": true,
-    "resolveJsonModule": true
+    "resolveJsonModule": true,
   },
-  "exclude": ["./dist/*"],
+  "exclude": [
+    "./dist/*",
+  ],
   "typedocOptions": {
-    "entryPoints": ["lancedb/index.ts"],
+    "entryPoints": [
+      "vectordb/index.ts"
+    ],
     "out": "../docs/src/javascript/",
     "visibilityFilters": {
       "protected": false,
       "private": false,
       "inherited": true,
-      "external": false
+      "external": false,
     }
   }
-}
+}

nodejs/vectordb/arrow.ts

@@ -0,0 +1,188 @@
+// Copyright 2024 Lance Developers.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import {
+  Int64,
+  Field,
+  FixedSizeList,
+  Float,
+  Float32,
+  Schema,
+  Table as ArrowTable,
+  Table,
+  Vector,
+  vectorFromArray,
+  tableToIPC,
+  DataType,
+} from "apache-arrow";
+
+/** Data type accepted by NodeJS SDK */
+export type Data = Record<string, unknown>[] | ArrowTable;
+
+export class VectorColumnOptions {
+  /** Vector column type. */
+  type: Float = new Float32();
+
+  constructor(values?: Partial<VectorColumnOptions>) {
+    Object.assign(this, values);
+  }
+}
+
+/** Options to control the makeArrowTable call. */
+export class MakeArrowTableOptions {
+  /** Provided schema. */
+  schema?: Schema;
+
+  /** Vector columns */
+  vectorColumns: Record<string, VectorColumnOptions> = {
+    vector: new VectorColumnOptions(),
+  };
+
+  constructor(values?: Partial<MakeArrowTableOptions>) {
+    Object.assign(this, values);
+  }
+}
+
+/**
+ * An enhanced version of the {@link makeTable} function from Apache Arrow
+ * that supports nested fields and embeddings columns.
+ *
+ * Note that it currently does not support nulls.
+ *
+ * @param data input data
+ * @param options options to control the makeArrowTable call.
+ *
+ * @example
+ *
+ * ```ts
+ *
+ * import { fromTableToBuffer, makeArrowTable } from "../arrow";
+ * import { Field, FixedSizeList, Float16, Float32, Int32, Schema } from "apache-arrow";
+ *
+ * const schema = new Schema([
+ *   new Field("a", new Int32()),
+ *   new Field("b", new Float32()),
+ *   new Field("c", new FixedSizeList(3, new Field("item", new Float16()))),
+ *  ]);
+ *  const table = makeArrowTable([
+ *    { a: 1, b: 2, c: [1, 2, 3] },
+ *    { a: 4, b: 5, c: [4, 5, 6] },
+ *    { a: 7, b: 8, c: [7, 8, 9] },
+ *  ], { schema });
+ * ```
+ *
+ * It guesses the vector columns if the schema is not provided. For example,
+ * by default it assumes that the column named `vector` is a vector column.
+ *
+ * ```ts
+ *
+ * const schema = new Schema([
+ new Field("a", new Float64()),
+ new Field("b", new Float64()),
+ new Field(
+ "vector",
+ new FixedSizeList(3, new Field("item", new Float32()))
+ ),
+ ]);
+ const table = makeArrowTable([
+ { a: 1, b: 2, vector: [1, 2, 3] },
+ { a: 4, b: 5, vector: [4, 5, 6] },
+ { a: 7, b: 8, vector: [7, 8, 9] },
+ ]);
+ assert.deepEqual(table.schema, schema);
+ * ```
+ *
+ * You can specify the vector column types and names using the options as well
+ *
+ * ```typescript
+ *
+ * const schema = new Schema([
+ new Field('a', new Float64()),
+ new Field('b', new Float64()),
+ new Field('vec1', new FixedSizeList(3, new Field('item', new Float16()))),
+ new Field('vec2', new FixedSizeList(3, new Field('item', new Float16())))
+ ]);
+ * const table = makeArrowTable([
+ { a: 1, b: 2, vec1: [1, 2, 3], vec2: [2, 4, 6] },
+ { a: 4, b: 5, vec1: [4, 5, 6], vec2: [8, 10, 12] },
+ { a: 7, b: 8, vec1: [7, 8, 9], vec2: [14, 16, 18] }
+ ], {
+ vectorColumns: {
+ vec1: { type: new Float16() },
+ vec2: { type: new Float16() }
+ }
+ }
+ * assert.deepEqual(table.schema, schema)
+ * ```
+ */
+export function makeArrowTable(
+  data: Record<string, any>[],
+  options?: Partial<MakeArrowTableOptions>
+): Table {
+  if (data.length === 0) {
+    throw new Error("At least one record needs to be provided");
+  }
+  const opt = new MakeArrowTableOptions(options ?? {});
+  const columns: Record<string, Vector> = {};
+  // TODO: sample dataset to find missing columns
+  const columnNames = Object.keys(data[0]);
+  for (const colName of columnNames) {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    let values = data.map((datum) => datum[colName]);
+    let vector: Vector;
+
+    if (opt.schema !== undefined) {
+      // Explicit schema is provided, highest priority
+      const fieldType: DataType | undefined = opt.schema.fields.filter((f) => f.name === colName)[0]?.type as DataType;
+      if (fieldType instanceof Int64) {
+        // wrap in BigInt to avoid bug: https://github.com/apache/arrow/issues/40051
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+        values = values.map((v) => BigInt(v));
+      }
+      vector = vectorFromArray(values, fieldType);
+    } else {
+      const vectorColumnOptions = opt.vectorColumns[colName];
+      if (vectorColumnOptions !== undefined) {
+        const fslType = new FixedSizeList(
+          (values[0] as any[]).length,
+          new Field("item", vectorColumnOptions.type, false)
+        );
+        vector = vectorFromArray(values, fslType);
+      } else {
+        // Normal case
+        vector = vectorFromArray(values);
+      }
+    }
+    columns[colName] = vector;
+  }
+
+  return new Table(columns);
+}
+
+/**
+ * Convert an Arrow Table to a Buffer.
+ *
+ * @param data Arrow Table
+ * @param schema Arrow Schema, optional
+ * @returns Buffer node
+ */
+export function toBuffer(data: Data, schema?: Schema): Buffer {
+  let tbl: Table;
+  if (data instanceof Table) {
+    tbl = data;
+  } else {
+    tbl = makeArrowTable(data, { schema });
+  }
+  return Buffer.from(tableToIPC(tbl));
+}

nodejs/vectordb/connection.ts

@@ -0,0 +1,70 @@
+// Copyright 2024 Lance Developers.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import { toBuffer } from "./arrow";
+import { Connection as _NativeConnection } from "./native";
+import { Table } from "./table";
+import { Table as ArrowTable } from "apache-arrow";
+
+/**
+ * A LanceDB Connection that allows you to open tables and create new ones.
+ *
+ * Connection could be local against filesystem or remote against a server.
+ */
+export class Connection {
+  readonly inner: _NativeConnection;
+
+  constructor(inner: _NativeConnection) {
+    this.inner = inner;
+  }
+
+  /** List all the table names in this database. */
+  async tableNames(): Promise<string[]> {
+    return this.inner.tableNames();
+  }
+
+  /**
+   * Open a table in the database.
+   *
+   * @param name The name of the table.
+   * @param embeddings An embedding function to use on this table
+   */
+  async openTable(name: string): Promise<Table> {
+    const innerTable = await this.inner.openTable(name);
+    return new Table(innerTable);
+  }
+
+  /**
+   * Creates a new Table and initialize it with new data.
+   *
+   * @param {string} name - The name of the table.
+   * @param data - Non-empty Array of Records to be inserted into the table
+   */
+  async createTable(
+    name: string,
+    data: Record<string, unknown>[] | ArrowTable
+  ): Promise<Table> {
+    const buf = toBuffer(data);
+    const innerTable = await this.inner.createTable(name, buf);
+    return new Table(innerTable);
+  }
+
+  /**
+   * Drop an existing table.
+   * @param name The name of the table to drop.
+   */
+  async dropTable(name: string): Promise<void> {
+    return this.inner.dropTable(name);
+  }
+}

nodejs/vectordb/index.ts

@@ -13,10 +13,7 @@
 // limitations under the License.
 
 import { Connection } from "./connection";
-import {
-  Connection as LanceDbConnection,
-  ConnectionOptions,
-} from "./native.js";
+import { Connection as NativeConnection, ConnectionOptions } from "./native.js";
 
 export {
   ConnectionOptions,
@@ -26,6 +23,7 @@ export {
 } from "./native.js";
 export { Connection } from "./connection";
 export { Table } from "./table";
+export { Data } from "./arrow";
 export { IvfPQOptions, IndexBuilder } from "./indexer";
 
 /**
@@ -41,11 +39,26 @@ export { IvfPQOptions, IndexBuilder } from "./indexer";
  *
  * @see {@link ConnectionOptions} for more details on the URI format.
  */
+export async function connect(uri: string): Promise<Connection>;
 export async function connect(
-  uri: string,
-  opts?: Partial<ConnectionOptions>,
+  opts: Partial<ConnectionOptions>
+): Promise<Connection>;
+export async function connect(
+  args: string | Partial<ConnectionOptions>
 ): Promise<Connection> {
-  opts = opts ?? {};
-  const nativeConn = await LanceDbConnection.new(uri, opts);
+  let opts: ConnectionOptions;
+  if (typeof args === "string") {
+    opts = { uri: args };
+  } else {
+    opts = Object.assign(
+      {
+        uri: "",
+        apiKey: "",
+        hostOverride: "",
+      },
+      args
+    );
+  }
+  const nativeConn = await NativeConnection.new(opts.uri);
   return new Connection(nativeConn);
 }

nodejs/vectordb/indexer.ts

@@ -12,9 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-// TODO: Re-enable this as part of https://github.com/lancedb/lancedb/pull/1052
-/* eslint-disable @typescript-eslint/naming-convention */
-
 import {
   MetricType,
   IndexBuilder as NativeBuilder,
@@ -69,7 +66,7 @@ export class IndexBuilder {
       options?.num_sub_vectors,
       options?.num_bits,
       options?.max_iterations,
-      options?.sample_rate,
+      options?.sample_rate
     );
     return this;
   }

nodejs/vectordb/native.d.ts

@@ -0,0 +1,80 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/* auto-generated by NAPI-RS */
+
+export const enum IndexType {
+  Scalar = 0,
+  IvfPq = 1
+}
+export const enum MetricType {
+  L2 = 0,
+  Cosine = 1,
+  Dot = 2
+}
+export interface ConnectionOptions {
+  uri: string
+  apiKey?: string
+  hostOverride?: string
+}
+/** Write mode for writing a table. */
+export const enum WriteMode {
+  Create = 'Create',
+  Append = 'Append',
+  Overwrite = 'Overwrite'
+}
+/** Write options when creating a Table. */
+export interface WriteOptions {
+  mode?: WriteMode
+}
+export function connect(options: ConnectionOptions): Promise<Connection>
+export class Connection {
+  /** Create a new Connection instance from the given URI. */
+  static new(uri: string): Promise<Connection>
+  /** List all tables in the dataset. */
+  tableNames(): Promise<Array<string>>
+  /**
+   * Create table from a Apache Arrow IPC (file) buffer.
+   *
+   * Parameters:
+   * - name: The name of the table.
+   * - buf: The buffer containing the IPC file.
+   *
+   */
+  createTable(name: string, buf: Buffer): Promise<Table>
+  openTable(name: string): Promise<Table>
+  /** Drop table with the name. Or raise an error if the table does not exist. */
+  dropTable(name: string): Promise<void>
+}
+export class IndexBuilder {
+  replace(v: boolean): void
+  column(c: string): void
+  name(name: string): void
+  ivfPq(metricType?: MetricType | undefined | null, numPartitions?: number | undefined | null, numSubVectors?: number | undefined | null, numBits?: number | undefined | null, maxIterations?: number | undefined | null, sampleRate?: number | undefined | null): void
+  scalar(): void
+  build(): Promise<void>
+}
+/** Typescript-style Async Iterator over RecordBatches  */
+export class RecordBatchIterator {
+  next(): Promise<Buffer | null>
+}
+export class Query {
+  column(column: string): void
+  filter(filter: string): void
+  select(columns: Array<string>): void
+  limit(limit: number): void
+  prefilter(prefilter: boolean): void
+  nearestTo(vector: Float32Array): void
+  refineFactor(refineFactor: number): void
+  nprobes(nprobe: number): void
+  executeStream(): Promise<RecordBatchIterator>
+}
+export class Table {
+  /** Return Schema as empty Arrow IPC file. */
+  schema(): Buffer
+  add(buf: Buffer): Promise<void>
+  countRows(filter?: string | undefined | null): Promise<bigint>
+  delete(predicate: string): Promise<void>
+  createIndex(): IndexBuilder
+  query(): Query
+}

nodejs/vectordb/native.js

@@ -32,24 +32,24 @@ switch (platform) {
   case 'android':
     switch (arch) {
       case 'arm64':
-        localFileExisted = existsSync(join(__dirname, 'lancedb-nodejs.android-arm64.node'))
+        localFileExisted = existsSync(join(__dirname, 'vectordb-nodejs.android-arm64.node'))
         try {
           if (localFileExisted) {
-            nativeBinding = require('./lancedb-nodejs.android-arm64.node')
+            nativeBinding = require('./vectordb-nodejs.android-arm64.node')
           } else {
-            nativeBinding = require('lancedb-android-arm64')
+            nativeBinding = require('vectordb-android-arm64')
           }
         } catch (e) {
           loadError = e
         }
         break
       case 'arm':
-        localFileExisted = existsSync(join(__dirname, 'lancedb-nodejs.android-arm-eabi.node'))
+        localFileExisted = existsSync(join(__dirname, 'vectordb-nodejs.android-arm-eabi.node'))
         try {
           if (localFileExisted) {
-            nativeBinding = require('./lancedb-nodejs.android-arm-eabi.node')
+            nativeBinding = require('./vectordb-nodejs.android-arm-eabi.node')
           } else {
-            nativeBinding = require('lancedb-android-arm-eabi')
+            nativeBinding = require('vectordb-android-arm-eabi')
           }
         } catch (e) {
           loadError = e
@@ -63,13 +63,13 @@ switch (platform) {
     switch (arch) {
       case 'x64':
         localFileExisted = existsSync(
-          join(__dirname, 'lancedb-nodejs.win32-x64-msvc.node')
+          join(__dirname, 'vectordb-nodejs.win32-x64-msvc.node')
         )
         try {
           if (localFileExisted) {
-            nativeBinding = require('./lancedb-nodejs.win32-x64-msvc.node')
+            nativeBinding = require('./vectordb-nodejs.win32-x64-msvc.node')
           } else {
-            nativeBinding = require('lancedb-win32-x64-msvc')
+            nativeBinding = require('vectordb-win32-x64-msvc')
           }
         } catch (e) {
           loadError = e
@@ -77,13 +77,13 @@ switch (platform) {
         break
       case 'ia32':
         localFileExisted = existsSync(
-          join(__dirname, 'lancedb-nodejs.win32-ia32-msvc.node')
+          join(__dirname, 'vectordb-nodejs.win32-ia32-msvc.node')
         )
         try {
           if (localFileExisted) {
-            nativeBinding = require('./lancedb-nodejs.win32-ia32-msvc.node')
+            nativeBinding = require('./vectordb-nodejs.win32-ia32-msvc.node')
           } else {
-            nativeBinding = require('lancedb-win32-ia32-msvc')
+            nativeBinding = require('vectordb-win32-ia32-msvc')
           }
         } catch (e) {
           loadError = e
@@ -91,13 +91,13 @@ switch (platform) {
         break
       case 'arm64':
         localFileExisted = existsSync(
-          join(__dirname, 'lancedb-nodejs.win32-arm64-msvc.node')
+          join(__dirname, 'vectordb-nodejs.win32-arm64-msvc.node')
         )
         try {
           if (localFileExisted) {
-            nativeBinding = require('./lancedb-nodejs.win32-arm64-msvc.node')
+            nativeBinding = require('./vectordb-nodejs.win32-arm64-msvc.node')
           } else {
-            nativeBinding = require('lancedb-win32-arm64-msvc')
+            nativeBinding = require('vectordb-win32-arm64-msvc')
           }
         } catch (e) {
           loadError = e
@@ -108,23 +108,23 @@ switch (platform) {
     }
     break
   case 'darwin':
-    localFileExisted = existsSync(join(__dirname, 'lancedb-nodejs.darwin-universal.node'))
+    localFileExisted = existsSync(join(__dirname, 'vectordb-nodejs.darwin-universal.node'))
     try {
       if (localFileExisted) {
-        nativeBinding = require('./lancedb-nodejs.darwin-universal.node')
+        nativeBinding = require('./vectordb-nodejs.darwin-universal.node')
       } else {
-        nativeBinding = require('lancedb-darwin-universal')
+        nativeBinding = require('vectordb-darwin-universal')
       }
       break
     } catch {}
     switch (arch) {
       case 'x64':
-        localFileExisted = existsSync(join(__dirname, 'lancedb-nodejs.darwin-x64.node'))
+        localFileExisted = existsSync(join(__dirname, 'vectordb-nodejs.darwin-x64.node'))
         try {
           if (localFileExisted) {
-            nativeBinding = require('./lancedb-nodejs.darwin-x64.node')
+            nativeBinding = require('./vectordb-nodejs.darwin-x64.node')
           } else {
-            nativeBinding = require('lancedb-darwin-x64')
+            nativeBinding = require('vectordb-darwin-x64')
           }
         } catch (e) {
           loadError = e
@@ -132,13 +132,13 @@ switch (platform) {
         break
       case 'arm64':
         localFileExisted = existsSync(
-          join(__dirname, 'lancedb-nodejs.darwin-arm64.node')
+          join(__dirname, 'vectordb-nodejs.darwin-arm64.node')
         )
         try {
           if (localFileExisted) {
-            nativeBinding = require('./lancedb-nodejs.darwin-arm64.node')
+            nativeBinding = require('./vectordb-nodejs.darwin-arm64.node')
           } else {
-            nativeBinding = require('lancedb-darwin-arm64')
+            nativeBinding = require('vectordb-darwin-arm64')
           }
         } catch (e) {
           loadError = e
@@ -152,12 +152,12 @@ switch (platform) {
     if (arch !== 'x64') {
       throw new Error(`Unsupported architecture on FreeBSD: ${arch}`)
     }
-    localFileExisted = existsSync(join(__dirname, 'lancedb-nodejs.freebsd-x64.node'))
+    localFileExisted = existsSync(join(__dirname, 'vectordb-nodejs.freebsd-x64.node'))
     try {
       if (localFileExisted) {
-        nativeBinding = require('./lancedb-nodejs.freebsd-x64.node')
+        nativeBinding = require('./vectordb-nodejs.freebsd-x64.node')
       } else {
-        nativeBinding = require('lancedb-freebsd-x64')
+        nativeBinding = require('vectordb-freebsd-x64')
       }
     } catch (e) {
       loadError = e
@@ -168,26 +168,26 @@ switch (platform) {
       case 'x64':
         if (isMusl()) {
           localFileExisted = existsSync(
-            join(__dirname, 'lancedb-nodejs.linux-x64-musl.node')
+            join(__dirname, 'vectordb-nodejs.linux-x64-musl.node')
           )
           try {
             if (localFileExisted) {
-              nativeBinding = require('./lancedb-nodejs.linux-x64-musl.node')
+              nativeBinding = require('./vectordb-nodejs.linux-x64-musl.node')
             } else {
-              nativeBinding = require('lancedb-linux-x64-musl')
+              nativeBinding = require('vectordb-linux-x64-musl')
             }
           } catch (e) {
             loadError = e
           }
         } else {
           localFileExisted = existsSync(
-            join(__dirname, 'lancedb-nodejs.linux-x64-gnu.node')
+            join(__dirname, 'vectordb-nodejs.linux-x64-gnu.node')
           )
           try {
             if (localFileExisted) {
-              nativeBinding = require('./lancedb-nodejs.linux-x64-gnu.node')
+              nativeBinding = require('./vectordb-nodejs.linux-x64-gnu.node')
             } else {
-              nativeBinding = require('lancedb-linux-x64-gnu')
+              nativeBinding = require('vectordb-linux-x64-gnu')
             }
           } catch (e) {
             loadError = e
@@ -197,26 +197,26 @@ switch (platform) {
       case 'arm64':
         if (isMusl()) {
           localFileExisted = existsSync(
-            join(__dirname, 'lancedb-nodejs.linux-arm64-musl.node')
+            join(__dirname, 'vectordb-nodejs.linux-arm64-musl.node')
           )
           try {
             if (localFileExisted) {
-              nativeBinding = require('./lancedb-nodejs.linux-arm64-musl.node')
+              nativeBinding = require('./vectordb-nodejs.linux-arm64-musl.node')
             } else {
-              nativeBinding = require('lancedb-linux-arm64-musl')
+              nativeBinding = require('vectordb-linux-arm64-musl')
             }
           } catch (e) {
             loadError = e
           }
         } else {
           localFileExisted = existsSync(
-            join(__dirname, 'lancedb-nodejs.linux-arm64-gnu.node')
+            join(__dirname, 'vectordb-nodejs.linux-arm64-gnu.node')
           )
           try {
             if (localFileExisted) {
-              nativeBinding = require('./lancedb-nodejs.linux-arm64-gnu.node')
+              nativeBinding = require('./vectordb-nodejs.linux-arm64-gnu.node')
             } else {
-              nativeBinding = require('lancedb-linux-arm64-gnu')
+              nativeBinding = require('vectordb-linux-arm64-gnu')
             }
           } catch (e) {
             loadError = e
@@ -225,13 +225,13 @@ switch (platform) {
         break
       case 'arm':
         localFileExisted = existsSync(
-          join(__dirname, 'lancedb-nodejs.linux-arm-gnueabihf.node')
+          join(__dirname, 'vectordb-nodejs.linux-arm-gnueabihf.node')
         )
         try {
           if (localFileExisted) {
-            nativeBinding = require('./lancedb-nodejs.linux-arm-gnueabihf.node')
+            nativeBinding = require('./vectordb-nodejs.linux-arm-gnueabihf.node')
           } else {
-            nativeBinding = require('lancedb-linux-arm-gnueabihf')
+            nativeBinding = require('vectordb-linux-arm-gnueabihf')
           }
         } catch (e) {
           loadError = e
@@ -240,26 +240,26 @@ switch (platform) {
       case 'riscv64':
         if (isMusl()) {
           localFileExisted = existsSync(
-            join(__dirname, 'lancedb-nodejs.linux-riscv64-musl.node')
+            join(__dirname, 'vectordb-nodejs.linux-riscv64-musl.node')
           )
           try {
             if (localFileExisted) {
-              nativeBinding = require('./lancedb-nodejs.linux-riscv64-musl.node')
+              nativeBinding = require('./vectordb-nodejs.linux-riscv64-musl.node')
             } else {
-              nativeBinding = require('lancedb-linux-riscv64-musl')
+              nativeBinding = require('vectordb-linux-riscv64-musl')
             }
           } catch (e) {
             loadError = e
           }
         } else {
           localFileExisted = existsSync(
-            join(__dirname, 'lancedb-nodejs.linux-riscv64-gnu.node')
+            join(__dirname, 'vectordb-nodejs.linux-riscv64-gnu.node')
           )
           try {
             if (localFileExisted) {
-              nativeBinding = require('./lancedb-nodejs.linux-riscv64-gnu.node')
+              nativeBinding = require('./vectordb-nodejs.linux-riscv64-gnu.node')
             } else {
-              nativeBinding = require('lancedb-linux-riscv64-gnu')
+              nativeBinding = require('vectordb-linux-riscv64-gnu')
             }
           } catch (e) {
             loadError = e
@@ -268,13 +268,13 @@ switch (platform) {
         break
       case 's390x':
         localFileExisted = existsSync(
-          join(__dirname, 'lancedb-nodejs.linux-s390x-gnu.node')
+          join(__dirname, 'vectordb-nodejs.linux-s390x-gnu.node')
         )
         try {
           if (localFileExisted) {
-            nativeBinding = require('./lancedb-nodejs.linux-s390x-gnu.node')
+            nativeBinding = require('./vectordb-nodejs.linux-s390x-gnu.node')
           } else {
-            nativeBinding = require('lancedb-linux-s390x-gnu')
+            nativeBinding = require('vectordb-linux-s390x-gnu')
           }
         } catch (e) {
           loadError = e

nodejs/vectordb/query.ts

@@ -20,22 +20,21 @@ import {
 } from "./native";
 
 class RecordBatchIterator implements AsyncIterator<RecordBatch> {
-  private promisedInner?: Promise<NativeBatchIterator>;
+  private promised_inner?: Promise<NativeBatchIterator>;
   private inner?: NativeBatchIterator;
 
   constructor(
     inner?: NativeBatchIterator,
-    promise?: Promise<NativeBatchIterator>,
+    promise?: Promise<NativeBatchIterator>
   ) {
     // TODO: check promise reliably so we dont need to pass two arguments.
     this.inner = inner;
-    this.promisedInner = promise;
+    this.promised_inner = promise;
   }
 
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  async next(): Promise<IteratorResult<RecordBatch<any>>> {
+  async next(): Promise<IteratorResult<RecordBatch<any>, any>> {
     if (this.inner === undefined) {
-      this.inner = await this.promisedInner;
+      this.inner = await this.promised_inner;
     }
     if (this.inner === undefined) {
       throw new Error("Invalid iterator state state");
@@ -115,8 +114,8 @@ export class Query implements AsyncIterable<RecordBatch> {
   /**
    * Set the refine factor for the query.
    */
-  refineFactor(refineFactor: number): Query {
-    this.inner.refineFactor(refineFactor);
+  refineFactor(refine_factor: number): Query {
+    this.inner.refineFactor(refine_factor);
     return this;
   }
 
@@ -140,13 +139,12 @@ export class Query implements AsyncIterable<RecordBatch> {
   /** Returns a JSON Array of All results.
    *
    */
-  async toArray(): Promise<unknown[]> {
+  async toArray(): Promise<any[]> {
     const tbl = await this.toArrow();
     // eslint-disable-next-line @typescript-eslint/no-unsafe-return
     return tbl.toArray();
   }
 
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   [Symbol.asyncIterator](): AsyncIterator<RecordBatch<any>> {
     const promise = this.inner.executeStream();
     return new RecordBatchIterator(undefined, promise);

nodejs/vectordb/table.ts

@@ -13,37 +13,15 @@
 // limitations under the License.
 
 import { Schema, tableFromIPC } from "apache-arrow";
-import {
-  AddColumnsSql,
-  ColumnAlteration,
-  Table as _NativeTable,
-} from "./native";
+import { Table as _NativeTable } from "./native";
+import { toBuffer, Data } from "./arrow";
 import { Query } from "./query";
 import { IndexBuilder } from "./indexer";
-import { Data, fromDataToBuffer } from "./arrow";
 
 /**
- * Options for adding data to a table.
- */
-export interface AddDataOptions {
-  /** If "append" (the default) then the new data will be added to the table
-   *
-   * If "overwrite" then the new data will replace the existing data in the table.
-   */
-  mode: "append" | "overwrite";
-}
-
-/**
- * A Table is a collection of Records in a LanceDB Database.
+ * A LanceDB Table is the collection of Records.
  *
- * A Table object is expected to be long lived and reused for multiple operations.
- * Table objects will cache a certain amount of index data in memory.  This cache
- * will be freed when the Table is garbage collected.  To eagerly free the cache you
- * can call the `close` method.  Once the Table is closed, it cannot be used for any
- * further operations.
- *
- * Closing a table is optional.  It not closed, it will be closed when it is garbage
- * collected.
+ * Each Record has one or more vector fields.
  */
 export class Table {
   private readonly inner: _NativeTable;
@@ -53,29 +31,9 @@ export class Table {
     this.inner = inner;
   }
 
-  /** Return true if the table has not been closed */
-  isOpen(): boolean {
-    return this.inner.isOpen();
-  }
-
-  /** Close the table, releasing any underlying resources.
-   *
-   * It is safe to call this method multiple times.
-   *
-   * Any attempt to use the table after it is closed will result in an error.
-   */
-  close(): void {
-    this.inner.close();
-  }
-
-  /** Return a brief description of the table */
-  display(): string {
-    return this.inner.display();
-  }
-
   /** Get the schema of the table. */
-  async schema(): Promise<Schema> {
-    const schemaBuf = await this.inner.schema();
+  get schema(): Schema {
+    const schemaBuf = this.inner.schema();
     const tbl = tableFromIPC(schemaBuf);
     return tbl.schema;
   }
@@ -86,15 +44,13 @@ export class Table {
    * @param {Data} data Records to be inserted into the Table
    * @return The number of rows added to the table
    */
-  async add(data: Data, options?: Partial<AddDataOptions>): Promise<void> {
-    const mode = options?.mode ?? "append";
-
-    const buffer = await fromDataToBuffer(data);
-    await this.inner.add(buffer, mode);
+  async add(data: Data): Promise<void> {
+    const buffer = toBuffer(data);
+    await this.inner.add(buffer);
   }
 
   /** Count the total number of rows in the dataset. */
-  async countRows(filter?: string): Promise<number> {
+  async countRows(filter?: string): Promise<bigint> {
     return await this.inner.countRows(filter);
   }
 
@@ -194,42 +150,4 @@ export class Table {
     }
     return q;
   }
-
-  // TODO: Support BatchUDF
-  /**
-   * Add new columns with defined values.
-   *
-   * @param newColumnTransforms pairs of column names and the SQL expression to use
-   *                            to calculate the value of the new column. These
-   *                            expressions will be evaluated for each row in the
-   *                            table, and can reference existing columns in the table.
-   */
-  async addColumns(newColumnTransforms: AddColumnsSql[]): Promise<void> {
-    await this.inner.addColumns(newColumnTransforms);
-  }
-
-  /**
-   * Alter the name or nullability of columns.
-   *
-   * @param columnAlterations One or more alterations to apply to columns.
-   */
-  async alterColumns(columnAlterations: ColumnAlteration[]): Promise<void> {
-    await this.inner.alterColumns(columnAlterations);
-  }
-
-  /**
-   * Drop one or more columns from the dataset
-   *
-   * This is a metadata-only operation and does not remove the data from the
-   * underlying storage. In order to remove the data, you must subsequently
-   * call ``compact_files`` to rewrite the data without the removed columns and
-   * then call ``cleanup_files`` to remove the old files.
-   *
-   * @param columnNames The names of the columns to drop. These can be nested
-   *                    column references (e.g. "a.b.c") or top-level column
-   *                    names (e.g. "a").
-   */
-  async dropColumns(columnNames: string[]): Promise<void> {
-    await this.inner.dropColumns(columnNames);
-  }
 }

python/.bumpversion.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 0.6.2
+current_version = 0.5.5
 commit = True
 message = [python] Bump version: {current_version} → {new_version}
 tag = True

python/ASYNC_MIGRATION.md

@@ -1,38 +0,0 @@
-# Migration from Sync to Async API
-
-A new asynchronous API has been added to LanceDb.  This API is built
-on top of the rust lancedb crate (instead of being built on top of
-pylance).  This will help keep the various language bindings in sync.
-There are some slight changes between the synchronous and the asynchronous
-APIs.  This document will help you migrate.  These changes relate mostly
-to the Connection and Table classes.
-
-## Almost all functions are async
-
-The most important change is that almost all functions are now async.
-This means the functions now return `asyncio` coroutines.  You will
-need to use `await` to call these functions.
-
-## Connection
-
-* The connection now has a `close` method.  You can call this when
-  you are done with the connection to eagerly free resources.  Currently
-  this is limited to freeing/closing the HTTP connection for remote
-  connections.  In the future we may add caching or other resources to
-  native connections so this is probably a good practice even if you aren't using remote connections.
-
-  In addition, the connection can be used as a context manager which may
-  be a more convenient way to ensure the connection is closed.
-
-  It is not mandatory to call the `close` method.  If you don't call it
-  the connection will be closed when the object is garbage collected.
-
-## Table
-
-* The table now has a `close` method, similar to the connection.  This
-  can be used to eagerly free the cache used by a Table object.  Similar
-  to the connection, it can be used as a context manager and it is not
-  mandatory to call the `close` method.
-* Previously `Table.schema` was a property.  Now it is an async method.
-* The method `Table.__len__` was removed and `len(table)` will no longer
-  work.  Use `Table.count_rows` instead.

python/Cargo.toml

@@ -1,30 +0,0 @@
-[package]
-name = "lancedb-python"
-version = "0.4.10"
-edition.workspace = true
-description = "Python bindings for LanceDB"
-license.workspace = true
-repository.workspace = true
-keywords.workspace = true
-categories.workspace = true
-rust-version = "1.75.0"
-
-[lib]
-name = "_lancedb"
-crate-type = ["cdylib"]
-
-[dependencies]
-arrow = { version = "50.0.0", features = ["pyarrow"] }
-lancedb = { path = "../rust/lancedb" }
-env_logger = "0.10"
-pyo3 = { version = "0.20", features = ["extension-module", "abi3-py38"] }
-pyo3-asyncio = { version = "0.20", features = ["attributes", "tokio-runtime"] }
-
-# Prevent dynamic linking of lzma, which comes from datafusion
-lzma-sys = { version = "*", features = ["static"] }
-
-[build-dependencies]
-pyo3-build-config = { version = "0.20.3", features = [
-    "extension-module",
-    "abi3-py38",
-] }

python/README.md

@@ -20,10 +20,10 @@ results = table.search([0.1, 0.3]).limit(20).to_list()
 print(results)
 ```
 
+
 ## Development
 
-LanceDb is based on the rust crate `lancedb` and is built with maturin.  In order to build with maturin
-you will either need a conda environment or a virtual environment (venv).
+Create a virtual environment and activate it:
 
 ```bash
 python -m venv venv
@@ -33,15 +33,7 @@ python -m venv venv
 Install the necessary packages:
 
 ```bash
-python -m pip install .[tests,dev]
-```
-
-To build the python package you can use maturin:
-
-```bash
-# This will build the rust bindings and place them in the appropriate place
-# in your venv or conda environment
-matruin develop
+python -m pip install .
 ```
 
 To run the unit tests:
@@ -53,7 +45,7 @@ pytest
 To run the doc tests:
 
 ```bash
-pytest --doctest-modules python/lancedb
+pytest --doctest-modules lancedb
 ```
 
 To run linter and automatically fix all errors:
@@ -69,27 +61,31 @@ If any packages are missing, install them with:
 pip install <PACKAGE_NAME>
 ```
 
+
 ___
 For **Windows** users, there may be errors when installing packages, so these commands may be helpful:
 
 Activate the virtual environment:
-
 ```bash
 . .\venv\Scripts\activate
 ```
 
 You may need to run the installs separately:
-
 ```bash
 pip install -e .[tests]
 pip install -e .[dev]
 ```
 
-`tantivy` requires `rust` to be installed, so install it with `conda`, as it doesn't support windows installation:
 
+`tantivy` requires `rust` to be installed, so install it with `conda`, as it doesn't support windows installation:
 ```bash
 pip install wheel
 pip install cargo
 conda install rust
 pip install tantivy
 ```
+
+To run the unit tests:
+```bash
+pytest
+```

python/build.rs

@@ -1,3 +0,0 @@
-fn main() {
-    pyo3_build_config::add_extension_module_link_args();
-}

python/lancedb/__init__.py

@@ -0,0 +1,90 @@
+#  Copyright 2023 LanceDB Developers
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+import importlib.metadata
+import os
+from datetime import timedelta
+from typing import Optional
+
+__version__ = importlib.metadata.version("lancedb")
+
+from .common import URI
+from .db import DBConnection, LanceDBConnection
+from .remote.db import RemoteDBConnection
+from .schema import vector  # noqa: F401
+from .utils import sentry_log  # noqa: F401
+
+
+def connect(
+    uri: URI,
+    *,
+    api_key: Optional[str] = None,
+    region: str = "us-east-1",
+    host_override: Optional[str] = None,
+    read_consistency_interval: Optional[timedelta] = None,
+) -> DBConnection:
+    """Connect to a LanceDB database.
+
+    Parameters
+    ----------
+    uri: str or Path
+        The uri of the database.
+    api_key: str, optional
+        If presented, connect to LanceDB cloud.
+        Otherwise, connect to a database on file system or cloud storage.
+        Can be set via environment variable `LANCEDB_API_KEY`.
+    region: str, default "us-east-1"
+        The region to use for LanceDB Cloud.
+    host_override: str, optional
+        The override url for LanceDB Cloud.
+    read_consistency_interval: timedelta, default None
+        (For LanceDB OSS only)
+        The interval at which to check for updates to the table from other
+        processes. If None, then consistency is not checked. For performance
+        reasons, this is the default. For strong consistency, set this to
+        zero seconds. Then every read will check for updates from other
+        processes. As a compromise, you can set this to a non-zero timedelta
+        for eventual consistency. If more than that interval has passed since
+        the last check, then the table will be checked for updates. Note: this
+        consistency only applies to read operations. Write operations are
+        always consistent.
+
+
+    Examples
+    --------
+
+    For a local directory, provide a path for the database:
+
+    >>> import lancedb
+    >>> db = lancedb.connect("~/.lancedb")
+
+    For object storage, use a URI prefix:
+
+    >>> db = lancedb.connect("s3://my-bucket/lancedb")
+
+    Connect to LancdDB cloud:
+
+    >>> db = lancedb.connect("db://my_database", api_key="ldb_...")
+
+    Returns
+    -------
+    conn : DBConnection
+        A connection to a LanceDB database.
+    """
+    if isinstance(uri, str) and uri.startswith("db://"):
+        if api_key is None:
+            api_key = os.environ.get("LANCEDB_API_KEY")
+        if api_key is None:
+            raise ValueError(f"api_key is required to connected LanceDB cloud: {uri}")
+        return RemoteDBConnection(uri, api_key, region, host_override)
+    return LanceDBConnection(uri, read_consistency_interval=read_consistency_interval)