Bump version: 0.25.2-beta.3 → 0.25.2

Expand the custom redirection links list to include storage page

.bumpversion.toml

@@ -1,5 +1,5 @@
 [tool.bumpversion]
-current_version = "0.22.0-beta.1"
+current_version = "0.22.2-beta.2"
 parse = """(?x)
     (?P<major>0|[1-9]\\d*)\\.
     (?P<minor>0|[1-9]\\d*)\\.

.github/actions/create-failure-issue/action.yml

@@ -0,0 +1,45 @@
+name: Create Failure Issue
+description: Creates a GitHub issue if any jobs in the workflow failed
+
+inputs:
+  job-results:
+    description: 'JSON string of job results from needs context'
+    required: true
+  workflow-name:
+    description: 'Name of the workflow'
+    required: true
+
+runs:
+  using: composite
+  steps:
+    - name: Check for failures and create issue
+      shell: bash
+      env:
+        JOB_RESULTS: ${{ inputs.job-results }}
+        WORKFLOW_NAME: ${{ inputs.workflow-name }}
+        RUN_URL: ${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}
+        GH_TOKEN: ${{ github.token }}
+      run: |
+        # Check if any job failed
+        if echo "$JOB_RESULTS" | jq -e 'to_entries | any(.value.result == "failure")' > /dev/null; then
+          echo "Detected job failures, creating issue..."
+
+          # Extract failed job names
+          FAILED_JOBS=$(echo "$JOB_RESULTS" | jq -r 'to_entries | map(select(.value.result == "failure")) | map(.key) | join(", ")')
+
+          # Create issue with workflow name, failed jobs, and run URL
+          gh issue create \
+            --title "$WORKFLOW_NAME Failed ($FAILED_JOBS)" \
+            --body "The workflow **$WORKFLOW_NAME** failed during execution.
+
+        **Failed jobs:** $FAILED_JOBS
+
+        **Run URL:** $RUN_URL
+
+        Please investigate the failed jobs and address any issues." \
+            --label "ci"
+
+          echo "Issue created successfully"
+        else
+          echo "No job failures detected, skipping issue creation"
+        fi

.github/workflows/cargo-publish.yml

@@ -38,3 +38,17 @@ jobs:
       - name: Publish the package
         run: |
           cargo publish -p lancedb --all-features --token ${{ steps.auth.outputs.token }}
+  report-failure:
+    name: Report Workflow Failure
+    runs-on: ubuntu-latest
+    needs: [build]
+    if: always() && (github.event_name == 'release' || github.event_name == 'workflow_dispatch')
+    permissions:
+      contents: read
+      issues: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ./.github/actions/create-failure-issue
+        with:
+          job-results: ${{ toJSON(needs) }}
+          workflow-name: ${{ github.workflow }}

.github/workflows/docs.yml

@@ -56,8 +56,9 @@ jobs:
         with:
           node-version: 20
           cache: 'npm'
+          cache-dependency-path: docs/package-lock.json
       - name: Install node dependencies
-        working-directory: node
+        working-directory: nodejs
         run: |
           sudo apt update
           sudo apt install -y protobuf-compiler libssl-dev

.github/workflows/docs_test.yml

@@ -24,7 +24,8 @@ env:
 jobs:
   test-python:
     name: Test doc python code
-    runs-on: ubuntu-24.04
+    runs-on: warp-ubuntu-2204-x64-8x
+    timeout-minutes: 60
     steps:
     - name: Checkout
       uses: actions/checkout@v4

.github/workflows/java-publish.yml

@@ -43,7 +43,6 @@ jobs:
       - uses: Swatinem/rust-cache@v2
       - uses: actions-rust-lang/setup-rust-toolchain@v1
         with:
-          toolchain: "1.81.0"
           cache-workspaces: "./java/core/lancedb-jni"
           # Disable full debug symbol generation to speed up CI build and keep memory down
           # "1" means line tables only, which is useful for panic tracebacks.
@@ -112,3 +111,17 @@ jobs:
         env:
           SONATYPE_USER: ${{ secrets.SONATYPE_USER }}
           SONATYPE_TOKEN: ${{ secrets.SONATYPE_TOKEN }}
+  report-failure:
+    name: Report Workflow Failure
+    runs-on: ubuntu-latest
+    needs: [linux-arm64, linux-x86, macos-arm64]
+    if: always() && (github.event_name == 'release' || github.event_name == 'workflow_dispatch')
+    permissions:
+      contents: read
+      issues: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ./.github/actions/create-failure-issue
+        with:
+          job-results: ${{ toJSON(needs) }}
+          workflow-name: ${{ github.workflow }}

.github/workflows/nodejs.yml

@@ -6,6 +6,7 @@ on:
       - main
   pull_request:
     paths:
+      - Cargo.toml
       - nodejs/**
       - .github/workflows/nodejs.yml
       - docker-compose.yml
@@ -116,7 +117,7 @@ jobs:
         set -e
         npm ci
         npm run docs
-        if ! git diff --exit-code -- . ':(exclude)Cargo.lock'; then
+        if ! git diff --exit-code -- ../ ':(exclude)Cargo.lock'; then
           echo "Docs need to be updated"
           echo "Run 'npm run docs', fix any warnings, and commit the changes."
           exit 1

.github/workflows/npm-publish.yml

@@ -365,3 +365,17 @@ jobs:
             ARGS="$ARGS --tag preview"
           fi
           npm publish $ARGS
+  report-failure:
+    name: Report Workflow Failure
+    runs-on: ubuntu-latest
+    needs: [build-lancedb, test-lancedb, publish]
+    if: always() && (github.event_name == 'release' || github.event_name == 'workflow_dispatch')
+    permissions:
+      contents: read
+      issues: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ./.github/actions/create-failure-issue
+        with:
+          job-results: ${{ toJSON(needs) }}
+          workflow-name: ${{ github.workflow }}

.github/workflows/pypi-publish.yml

@@ -56,7 +56,7 @@ jobs:
           pypi_token: ${{ secrets.LANCEDB_PYPI_API_TOKEN }}
           fury_token: ${{ secrets.FURY_TOKEN }}
   mac:
-    timeout-minutes: 60
+    timeout-minutes: 90
     runs-on: ${{ matrix.config.runner }}
     strategy:
       matrix:
@@ -64,7 +64,7 @@ jobs:
           - target: x86_64-apple-darwin
             runner: macos-13
           - target: aarch64-apple-darwin
-            runner: macos-14
+            runner: warp-macos-14-arm64-6x
     env:
       MACOSX_DEPLOYMENT_TARGET: 10.15
     steps:
@@ -173,3 +173,17 @@ jobs:
           generate_release_notes: false
           name: Python LanceDB v${{ steps.extract_version.outputs.version }}
           body: ${{ steps.python_release_notes.outputs.changelog }}
+  report-failure:
+    name: Report Workflow Failure
+    runs-on: ubuntu-latest
+    needs: [linux, mac, windows]
+    permissions:
+      contents: read
+      issues: write
+    if: always() && (github.event_name == 'release' || github.event_name == 'workflow_dispatch')
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ./.github/actions/create-failure-issue
+        with:
+          job-results: ${{ toJSON(needs) }}
+          workflow-name: ${{ github.workflow }}

.github/workflows/python.yml

@@ -6,6 +6,7 @@ on:
       - main
   pull_request:
     paths:
+      - Cargo.toml
       - python/**
       - .github/workflows/python.yml
 

.github/workflows/rust.yml

@@ -96,6 +96,7 @@ jobs:
       # Need up-to-date compilers for kernels
       CC: clang-18
       CXX: clang++-18
+      GH_TOKEN: ${{ secrets.SOPHON_READ_TOKEN }}
     steps:
       - uses: actions/checkout@v4
         with:
@@ -117,15 +118,17 @@ jobs:
           sudo chmod 600 /swapfile
           sudo mkswap /swapfile
           sudo swapon /swapfile
-      - name: Start S3 integration test environment
-        working-directory: .
-        run: docker compose up --detach --wait
       - name: Build
         run: cargo build --all-features --tests --locked --examples
-      - name: Run tests
-        run: cargo test --all-features --locked
+      - name: Run feature tests
+        run: make -C ./lancedb feature-tests
       - name: Run examples
         run: cargo run --example simple --locked
+      - name: Run remote tests
+        # Running this requires access to secrets, so skip if this is
+        # a PR from a fork.
+        if: github.event_name != 'pull_request' || !github.event.pull_request.head.repo.fork
+        run: make -C ./lancedb remote-tests
 
   macos:
     timeout-minutes: 30

.github/workflows/trigger-vectordb-recipes.yml

@@ -1,26 +0,0 @@
-name: Trigger vectordb-recipers workflow
-on:
-  push:
-    branches: [ main ]
-  pull_request:
-    paths:
-      - .github/workflows/trigger-vectordb-recipes.yml
-  workflow_dispatch:
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Trigger vectordb-recipes workflow
-        uses: actions/github-script@v6
-        with:
-          github-token: ${{ secrets.VECTORDB_RECIPES_ACTION_TOKEN }}
-          script: |
-            const result = await github.rest.actions.createWorkflowDispatch({
-                owner: 'lancedb',
-                repo: 'vectordb-recipes',
-                workflow_id: 'examples-test.yml',
-                ref: 'main'
-            });
-            console.log(result);

Cargo.toml

@@ -15,30 +15,30 @@ categories = ["database-implementations"]
 rust-version = "1.78.0"
 
 [workspace.dependencies]
-lance = { "version" = "=0.35.0", default-features = false, "features" = ["dynamodb"] }
-lance-io = { "version" = "=0.35.0", default-features = false }
-lance-index = { "version" = "=0.35.0" }
-lance-linalg = { "version" = "=0.35.0" }
-lance-table = { "version" = "=0.35.0" }
-lance-testing = { "version" = "=0.35.0" }
-lance-datafusion = { "version" = "=0.35.0" }
-lance-encoding = { "version" = "=0.35.0" }
+lance = { "version" = "=0.38.2", default-features = false, "features" = ["dynamodb"] }
+lance-io = { "version" = "=0.38.2", default-features = false }
+lance-index = "=0.38.2"
+lance-linalg = "=0.38.2"
+lance-table = "=0.38.2"
+lance-testing = "=0.38.2"
+lance-datafusion = "=0.38.2"
+lance-encoding = "=0.38.2"
+lance-namespace = "0.0.18"
 # Note that this one does not include pyarrow
-arrow = { version = "55.1", optional = false }
-arrow-array = "55.1"
-arrow-data = "55.1"
-arrow-ipc = "55.1"
-arrow-ord = "55.1"
-arrow-schema = "55.1"
-arrow-arith = "55.1"
-arrow-cast = "55.1"
+arrow = { version = "56.2", optional = false }
+arrow-array = "56.2"
+arrow-data = "56.2"
+arrow-ipc = "56.2"
+arrow-ord = "56.2"
+arrow-schema = "56.2"
+arrow-cast = "56.2"
 async-trait = "0"
-datafusion = { version = "48.0", default-features = false }
-datafusion-catalog = "48.0"
-datafusion-common = { version = "48.0", default-features = false }
-datafusion-execution = "48.0"
-datafusion-expr = "48.0"
-datafusion-physical-plan = "48.0"
+datafusion = { version = "50.1", default-features = false }
+datafusion-catalog = "50.1"
+datafusion-common = { version = "50.1", default-features = false }
+datafusion-execution = "50.1"
+datafusion-expr = "50.1"
+datafusion-physical-plan = "50.1"
 env_logger = "0.11"
 half = { "version" = "2.6.0", default-features = false, features = [
     "num-traits",
@@ -51,7 +51,6 @@ pin-project = "1.0.7"
 snafu = "0.8"
 url = "2"
 num-traits = "0.2"
-rand = "0.9"
 regex = "1.10"
 lazy_static = "1"
 semver = "1.0.25"
@@ -59,7 +58,17 @@ crunchy = "0.2.4"
 # Temporary pins to work around downstream issues
 # https://github.com/apache/arrow-rs/commit/2fddf85afcd20110ce783ed5b4cdeb82293da30b
 chrono = "=0.4.41"
-# https://github.com/RustCrypto/formats/issues/1684
-base64ct = "=1.6.0"
 # Workaround for: https://github.com/Lokathor/bytemuck/issues/306
 bytemuck_derive = ">=1.8.1, <1.9.0"
+
+# This is only needed when we reference preview releases of lance
+# [patch.crates-io]
+# # Force to use the same lance version as the rest of the project to avoid duplicate dependencies
+# lance = { "version" = "=0.38.0", "tag" = "v0.38.0", "git" = "https://github.com/lancedb/lance.git" }
+# lance-io = { "version" = "=0.38.0", "tag" = "v0.38.0", "git" = "https://github.com/lancedb/lance.git" }
+# lance-index = { "version" = "=0.38.0", "tag" = "v0.38.0", "git" = "https://github.com/lancedb/lance.git" }
+# lance-linalg = { "version" = "=0.38.0", "tag" = "v0.38.0", "git" = "https://github.com/lancedb/lance.git" }
+# lance-table = { "version" = "=0.38.0", "tag" = "v0.38.0", "git" = "https://github.com/lancedb/lance.git" }
+# lance-testing = { "version" = "=0.38.0", "tag" = "v0.38.0", "git" = "https://github.com/lancedb/lance.git" }
+# lance-datafusion = { "version" = "=0.38.0", "tag" = "v0.38.0", "git" = "https://github.com/lancedb/lance.git" }
+# lance-encoding = { "version" = "=0.38.0", "tag" = "v0.38.0", "git" = "https://github.com/lancedb/lance.git" }

ci/create_lancedb_test_connection.sh

@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+
+export RUST_LOG=info
+exec ./lancedb server --port 0 --sql-port 0  --data-dir "${1}"

ci/run_with_docker_compose.sh

@@ -0,0 +1,18 @@
+#!/usr/bin/env bash
+
+#
+# A script for running the given command together with a docker compose environment.
+#
+
+# Bring down the docker setup once the command is done running.
+tear_down() {
+    docker compose -p fixture down
+}
+trap tear_down EXIT
+
+set +xe
+
+# Clean up any existing docker setup and bring up a new one.
+docker compose -p fixture up --detach --wait || exit 1
+
+"${@}"

ci/run_with_test_connection.sh

@@ -0,0 +1,68 @@
+#!/usr/bin/env bash
+
+#
+# A script for running the given command together with the lancedb cli.
+#
+
+die() {
+    echo $?
+    exit 1
+}
+
+check_command_exists() {
+    command="${1}"
+    which ${command} &> /dev/null || \
+        die "Unable to locate command: ${command}. Did you install it?"
+}
+
+if [[ ! -e ./lancedb ]]; then
+    if [[ -v SOPHON_READ_TOKEN ]]; then
+        INPUT="lancedb-linux-x64"
+        gh release \
+            --repo lancedb/lancedb \
+            download ci-support-binaries \
+            --pattern "${INPUT}" \
+            || die "failed to fetch cli."
+        check_command_exists openssl
+        openssl enc -aes-256-cbc \
+            -d -pbkdf2 \
+            -pass "env:SOPHON_READ_TOKEN" \
+            -in "${INPUT}" \
+            -out ./lancedb-linux-x64.tar.gz \
+            || die "openssl failed"
+        TARGET="${INPUT}.tar.gz"
+    else
+        ARCH="x64"
+        if [[ $OSTYPE == 'darwin'* ]]; then
+            UNAME=$(uname -m)
+            if [[ $UNAME == 'arm64' ]]; then
+                ARCH='arm64'
+            fi
+            OSTYPE="macos"
+        elif [[ $OSTYPE == 'linux'* ]]; then
+            if [[ $UNAME == 'aarch64' ]]; then
+                ARCH='arm64'
+            fi
+            OSTYPE="linux"
+        else
+            die "unknown OSTYPE: $OSTYPE"
+        fi
+
+        check_command_exists gh
+        TARGET="lancedb-${OSTYPE}-${ARCH}.tar.gz"
+        gh release \
+            --repo lancedb/sophon \
+            download lancedb-cli-v0.0.3 \
+            --pattern "${TARGET}" \
+            || die "failed to fetch cli."
+    fi
+
+    check_command_exists tar
+    tar xvf "${TARGET}" || die "tar failed."
+    [[ -e ./lancedb ]] || die "failed to extract lancedb."
+fi
+
+SCRIPT_DIR=$(dirname "$(readlink -f "$0")")
+export CREATE_LANCEDB_TEST_CONNECTION_SCRIPT="${SCRIPT_DIR}/create_lancedb_test_connection.sh"
+
+"${@}"

ci/set_lance_version.py

@@ -1,4 +1,5 @@
 import argparse
+import re
 import sys
 import json
 
@@ -18,8 +19,12 @@ def run_command(command: str) -> str:
 
 def get_latest_stable_version() -> str:
     version_line = run_command("cargo info lance | grep '^version:'")
-    version = version_line.split(" ")[1].strip()
-    return version
+    # Example output: "version: 0.35.0 (latest 0.37.0)"
+    match = re.search(r'\(latest ([0-9.]+)\)', version_line)
+    if match:
+        return match.group(1)
+    # Fallback: use the first version after 'version:'
+    return version_line.split("version:")[1].split()[0].strip()
 
 
 def get_latest_preview_version() -> str:
@@ -112,7 +117,7 @@ def update_cargo_toml(line_updater):
     lance_line = ""
     is_parsing_lance_line = False
     for line in lines:
-        if line.startswith("lance"):
+        if line.startswith("lance") and not line.startswith("lance-namespace"):
             # Check if this is a single-line or multi-line entry
             # Single-line entries either:
             # 1. End with } (complete inline table)

docs/mkdocs.yml

@@ -70,6 +70,23 @@ plugins:
   - mkdocs-jupyter
   - render_swagger:
       allow_arbitrary_locations: true
+  - redirects:
+      redirect_maps:
+        # Redirect the home page and other top-level markdown files. This enables maximum SEO benefit
+        # other sub-pages are handled by the ingected js in overrides/partials/header.html
+        'index.md': 'https://lancedb.com/docs/'
+        'guides/tables.md': 'https://lancedb.com/docs/tables/'
+        'ann_indexes.md': 'https://lancedb.com/docs/indexing/'
+        'basic.md': 'https://lancedb.com/docs/quickstart/'
+        'faq.md': 'https://lancedb.com/docs/faq/'
+        'embeddings/understanding_embeddings.md': 'https://lancedb.com/docs/embedding/'
+        'integrations.md': 'https://lancedb.com/docs/integrations/'
+        'examples.md': 'https://lancedb.com/docs/tutorials/'
+        'concepts/vector_search.md': 'https://lancedb.com/docs/search/vector-search/'
+        'troubleshooting.md': 'https://lancedb.com/docs/troubleshooting/'
+        'guides/storage.md': 'https://lancedb.com/docs/storage/integrations'
+
+
 
 markdown_extensions:
   - admonition

docs/overrides/partials/header.html

@@ -19,7 +19,13 @@
   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
   IN THE SOFTWARE.
 -->
-
+<div id="deprecation-banner" style="background-color: #f8d7da; color: #721c24; padding: 1em; text-align: center;">                                                           
+    <p style="margin: 0; font-size: 1.1em;">                                                                                                           
+        <strong>This documentation site is deprecated.</strong>                                                                           
+        Please visit our new documentation site at <a href="https://lancedb.com/docs" style="color: #721c24; text-decoration: underline;">
+          lancedb.com/docs</a> for the latest information.                                                                                        
+    </p>                                                                                                                                               
+  </div>  
 {% set class = "md-header" %}
 {% if "navigation.tabs.sticky" in features %}
   {% set class = class ~ " md-header--shadow md-header--lifted" %}
@@ -150,9 +156,9 @@
 
     <div style="margin-left: 10px; margin-right: 5px;">
         <a href="https://discord.com/invite/zMM32dvNtd" target="_blank" rel="noopener noreferrer">
-            <svg fill="#FFFFFF" xmlns="http://www.w3.org/2000/svg"  viewBox="0 0 50 50" width="25px" height="25px"><path d="M 41.625 10.769531 C 37.644531 7.566406 31.347656 7.023438 31.078125 7.003906 C 30.660156 6.96875 30.261719 7.203125 30.089844 7.589844 C 30.074219 7.613281 29.9375 7.929688 29.785156 8.421875 C 32.417969 8.867188 35.652344 9.761719 38.578125 11.578125 C 39.046875 11.867188 39.191406 12.484375 38.902344 12.953125 C 38.710938 13.261719 38.386719 13.429688 38.050781 13.429688 C 37.871094 13.429688 37.6875 13.378906 37.523438 13.277344 C 32.492188 10.15625 26.210938 10 25 10 C 23.789063 10 17.503906 10.15625 12.476563 13.277344 C 12.007813 13.570313 11.390625 13.425781 11.101563 12.957031 C 10.808594 12.484375 10.953125 11.871094 11.421875 11.578125 C 14.347656 9.765625 17.582031 8.867188 20.214844 8.425781 C 20.0625 7.929688 19.925781 7.617188 19.914063 7.589844 C 19.738281 7.203125 19.34375 6.960938 18.921875 7.003906 C 18.652344 7.023438 12.355469 7.566406 8.320313 10.8125 C 6.214844 12.761719 2 24.152344 2 34 C 2 34.175781 2.046875 34.34375 2.132813 34.496094 C 5.039063 39.605469 12.972656 40.941406 14.78125 41 C 14.789063 41 14.800781 41 14.8125 41 C 15.132813 41 15.433594 40.847656 15.621094 40.589844 L 17.449219 38.074219 C 12.515625 36.800781 9.996094 34.636719 9.851563 34.507813 C 9.4375 34.144531 9.398438 33.511719 9.765625 33.097656 C 10.128906 32.683594 10.761719 32.644531 11.175781 33.007813 C 11.234375 33.0625 15.875 37 25 37 C 34.140625 37 38.78125 33.046875 38.828125 33.007813 C 39.242188 32.648438 39.871094 32.683594 40.238281 33.101563 C 40.601563 33.515625 40.5625 34.144531 40.148438 34.507813 C 40.003906 34.636719 37.484375 36.800781 32.550781 38.074219 L 34.378906 40.589844 C 34.566406 40.847656 34.867188 41 35.1875 41 C 35.199219 41 35.210938 41 35.21875 41 C 37.027344 40.941406 44.960938 39.605469 47.867188 34.496094 C 47.953125 34.34375 48 34.175781 48 34 C 48 24.152344 43.785156 12.761719 41.625 10.769531 Z M 18.5 30 C 16.566406 30 15 28.210938 15 26 C 15 23.789063 16.566406 22 18.5 22 C 20.433594 22 22 23.789063 22 26 C 22 28.210938 20.433594 30 18.5 30 Z M 31.5 30 C 29.566406 30 28 28.210938 28 26 C 28 23.789063 29.566406 22 31.5 22 C 33.433594 22 35 23.789063 35 26 C 35 28.210938 33.433594 30 31.5 30 Z"/></svg>
-        </a>
-    </div>
+          <svg fill="#FFFFFF" xmlns="http://www.w3.org/2000/svg"  viewBox="0 0 50 50" width="25px" height="25px"><path d="M 41.625 10.769531 C 37.644531 7.566406 31.347656 7.023438 31.078125 7.003906 C 30.660156 6.96875 30.261719 7.203125 30.089844 7.589844 C 30.074219 7.613281 29.9375 7.929688 29.785156 8.421875 C 32.417969 8.867188 35.652344 9.761719 38.578125 11.578125 C 39.046875 11.867188 39.191406 12.484375 38.902344 12.953125 C 38.710938 13.261719 38.386719 13.429688 38.050781 13.429688 C 37.871094 13.429688 37.6875 13.378906 37.523438 13.277344 C 32.492188 10.15625 26.210938 10 25 10 C 23.789063 10 17.503906 10.15625 12.476563 13.277344 C 12.007813 13.570313 11.390625 13.425781 11.101563 12.957031 C 10.808594 12.484375 10.953125 11.871094 11.421875 11.578125 C 14.347656 9.765625 17.582031 8.867188 20.214844 8.425781 C 20.0625 7.929688 19.925781 7.617188 19.914063 7.589844 C 19.738281 7.203125 19.34375 6.960938 18.921875 7.003906 C 18.652344 7.023438 12.355469 7.566406 8.320313 10.8125 C 6.214844 12.761719 2 24.152344 2 34 C 2 34.175781 2.046875 34.34375 2.132813 34.496094 C 5.039063 39.605469 12.972656 40.941406 14.78125 41 C 14.789063 41 14.800781 41 14.8125 41 C 15.132813 41 15.433594 40.847656 15.621094 40.589844 L 17.449219 38.074219 C 12.515625 36.800781 9.996094 34.636719 9.851563 34.507813 C 9.4375 34.144531 9.398438 33.511719 9.765625 33.097656 C 10.128906 32.683594 10.761719 32.644531 11.175781 33.007813 C 11.234375 33.0625 15.875 37 25 37 C 34.140625 37 38.78125 33.046875 38.828125 33.007813 C 39.242188 32.648438 39.871094 32.683594 40.238281 33.101563 C 40.601563 33.515625 40.5625 34.144531 40.148438 34.507813 C 40.003906 34.636719 37.484375 36.800781 32.550781 38.074219 L 34.378906 40.589844 C 34.566406 40.847656 34.867188 41 35.1875 41 C 35.199219 41 35.210938 41 35.21875 41 C 37.027344 40.941406 44.960938 39.605469 47.867188 34.496094 C 47.953125 34.34375 48 34.175781 48 34 C 48 24.152344 43.785156 12.761719 41.625 10.769531 Z M 18.5 30 C 16.566406 30 15 28.210938 15 26 C 15 23.789063 16.566406 22 18.5 22 C 20.433594 22 22 23.789063 22 26 C 22 28.210938 20.433594 30 18.5 30 Z M 31.5 30 C 29.566406 30 28 28.210938 28 26 C 28 23.789063 29.566406 22 31.5 22 C 33.433594 22 35 23.789063 35 26 C 35 28.210938 33.433594 30 31.5 30 Z"/></svg>
+      </a>
+  </div>
     <div style="margin-left: 5px; margin-right: 5px;">
         <a href="https://twitter.com/lancedb" target="_blank" rel="noopener noreferrer">
             <svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" viewBox="0,0,256,256" width="25px" height="25px" fill-rule="nonzero"><g fill-opacity="0" fill="#ffffff" fill-rule="nonzero" stroke="none" stroke-width="1" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="10" stroke-dasharray="" stroke-dashoffset="0" font-family="none" font-weight="none" font-size="none" text-anchor="none" style="mix-blend-mode: normal"><path d="M0,256v-256h256v256z" id="bgRectangle"></path></g><g fill="#ffffff" fill-rule="nonzero" stroke="none" stroke-width="1" stroke-linecap="butt" stroke-linejoin="miter" stroke-miterlimit="10" stroke-dasharray="" stroke-dashoffset="0" font-family="none" font-weight="none" font-size="none" text-anchor="none" style="mix-blend-mode: normal"><g transform="scale(4,4)"><path d="M57,17.114c-1.32,1.973 -2.991,3.707 -4.916,5.097c0.018,0.423 0.028,0.847 0.028,1.274c0,13.013 -9.902,28.018 -28.016,28.018c-5.562,0 -12.81,-1.948 -15.095,-4.423c0.772,0.092 1.556,0.138 2.35,0.138c4.615,0 8.861,-1.575 12.23,-4.216c-4.309,-0.079 -7.946,-2.928 -9.199,-6.84c1.96,0.308 4.447,-0.17 4.447,-0.17c0,0 -7.7,-1.322 -7.899,-9.779c2.226,1.291 4.46,1.231 4.46,1.231c0,0 -4.441,-2.734 -4.379,-8.195c0.037,-3.221 1.331,-4.953 1.331,-4.953c8.414,10.361 20.298,10.29 20.298,10.29c0,0 -0.255,-1.471 -0.255,-2.243c0,-5.437 4.408,-9.847 9.847,-9.847c2.832,0 5.391,1.196 7.187,3.111c2.245,-0.443 4.353,-1.263 6.255,-2.391c-0.859,3.44 -4.329,5.448 -4.329,5.448c0,0 2.969,-0.329 5.655,-1.55z"></path></g></g></svg>
@@ -173,4 +179,77 @@
       {% include "partials/tabs.html" %}
     {% endif %}
   {% endif %}
-</header>
+</header>
+
+<script>
+  (function() {
+    function checkPathAndRedirect() {
+      var banner = document.getElementById('deprecation-banner');
+
+      if (document.querySelector('meta[http-equiv="refresh"]')) {
+        return; // The redirects plugin is already handling this page.
+      }
+
+      var currentPath = window.location.pathname;
+
+      var cleanPath = currentPath.endsWith('/') && currentPath.length > 1
+        ? currentPath.slice(0, -1)
+        : currentPath;
+
+      // These are the ONLY paths that should remain on the old site
+      var apiPaths = [
+        '/lancedb/python', 
+        '/lancedb/javascript', 
+        '/lancedb/js',
+        '/lancedb/api_reference'
+      ];
+      
+      var isApiPage = apiPaths.some(function(apiPath) {
+        return cleanPath.startsWith(apiPath);
+      });
+
+      if (isApiPage) {
+        if (banner) {
+          banner.style.display = 'none';
+        }
+      } else {
+        if (banner) {
+          banner.style.display = 'block';
+        }
+        
+        // Add noindex meta tag to prevent indexing of old docs for seo
+        var noindexMeta = document.createElement('meta');
+        noindexMeta.setAttribute('name', 'robots');
+        noindexMeta.setAttribute('content', 'noindex, follow');
+        document.head.appendChild(noindexMeta);
+
+        // Add canonical link to point to the new docs to reward new site for seo
+        var canonicalLink = document.createElement('link');
+        canonicalLink.setAttribute('rel', 'canonical');
+        canonicalLink.setAttribute('href', 'https://lancedb.com/docs');
+        document.head.appendChild(canonicalLink);
+        
+        window.location.replace('https://lancedb.com/docs');
+      }
+    }
+
+    // Run the check only if doc is ready. This makes sure we catch the initial load
+    // and redirect.
+    if (document.readyState === 'loading') {
+      document.addEventListener('DOMContentLoaded', checkPathAndRedirect);
+    } else {
+      checkPathAndRedirect();
+    }
+
+    // Use an interval to handle subsequent navigation clicks.
+    var lastPath = window.location.pathname;
+    setInterval(function() {
+      if (window.location.pathname !== lastPath) {
+        lastPath = window.location.pathname;
+        checkPathAndRedirect();
+      }
+    }, 2000); // keeping it 2 second to make it easy for user to understand
+              // what's happening
+
+  })();
+</script>

docs/requirements.txt

@@ -5,3 +5,4 @@ mkdocstrings[python]==0.25.2
 griffe
 mkdocs-render-swagger-plugin
 pydantic
+mkdocs-redirects

docs/src/js/classes/Connection.md

@@ -25,6 +25,51 @@ the underlying connection has been closed.
 
 ## Methods
 
+### cloneTable()
+
+```ts
+abstract cloneTable(
+   targetTableName,
+   sourceUri,
+   options?): Promise<Table>
+```
+
+Clone a table from a source table.
+
+A shallow clone creates a new table that shares the underlying data files
+with the source table but has its own independent manifest. This allows
+both the source and cloned tables to evolve independently while initially
+sharing the same data, deletion, and index files.
+
+#### Parameters
+
+* **targetTableName**: `string`
+    The name of the target table to create.
+
+* **sourceUri**: `string`
+    The URI of the source table to clone from.
+
+* **options?**
+    Clone options.
+
+* **options.isShallow?**: `boolean`
+    Whether to perform a shallow clone (defaults to true).
+
+* **options.sourceTag?**: `string`
+    The tag of the source table to clone.
+
+* **options.sourceVersion?**: `number`
+    The version of the source table to clone.
+
+* **options.targetNamespace?**: `string`[]
+    The namespace for the target table (defaults to root namespace).
+
+#### Returns
+
+`Promise`&lt;[`Table`](Table.md)&gt;
+
+***
+
 ### close()
 
 ```ts
@@ -45,6 +90,8 @@ Any attempt to use the connection after it is closed will result in an error.
 
 ### createEmptyTable()
 
+#### createEmptyTable(name, schema, options)
+
 ```ts
 abstract createEmptyTable(
    name,
@@ -54,7 +101,7 @@ abstract createEmptyTable(
 
 Creates a new empty Table
 
-#### Parameters
+##### Parameters
 
 * **name**: `string`
     The name of the table.
@@ -63,8 +110,39 @@ Creates a new empty Table
     The schema of the table
 
 * **options?**: `Partial`&lt;[`CreateTableOptions`](../interfaces/CreateTableOptions.md)&gt;
+    Additional options (backwards compatibility)
 
-#### Returns
+##### Returns
+
+`Promise`&lt;[`Table`](Table.md)&gt;
+
+#### createEmptyTable(name, schema, namespace, options)
+
+```ts
+abstract createEmptyTable(
+   name,
+   schema,
+   namespace?,
+   options?): Promise<Table>
+```
+
+Creates a new empty Table
+
+##### Parameters
+
+* **name**: `string`
+    The name of the table.
+
+* **schema**: [`SchemaLike`](../type-aliases/SchemaLike.md)
+    The schema of the table
+
+* **namespace?**: `string`[]
+    The namespace to create the table in (defaults to root namespace)
+
+* **options?**: `Partial`&lt;[`CreateTableOptions`](../interfaces/CreateTableOptions.md)&gt;
+    Additional options
+
+##### Returns
 
 `Promise`&lt;[`Table`](Table.md)&gt;
 
@@ -72,10 +150,10 @@ Creates a new empty Table
 
 ### createTable()
 
-#### createTable(options)
+#### createTable(options, namespace)
 
 ```ts
-abstract createTable(options): Promise<Table>
+abstract createTable(options, namespace?): Promise<Table>
 ```
 
 Creates a new Table and initialize it with new data.
@@ -85,6 +163,9 @@ Creates a new Table and initialize it with new data.
 * **options**: `object` & `Partial`&lt;[`CreateTableOptions`](../interfaces/CreateTableOptions.md)&gt;
     The options object.
 
+* **namespace?**: `string`[]
+    The namespace to create the table in (defaults to root namespace)
+
 ##### Returns
 
 `Promise`&lt;[`Table`](Table.md)&gt;
@@ -110,6 +191,38 @@ Creates a new Table and initialize it with new data.
     to be inserted into the table
 
 * **options?**: `Partial`&lt;[`CreateTableOptions`](../interfaces/CreateTableOptions.md)&gt;
+    Additional options (backwards compatibility)
+
+##### Returns
+
+`Promise`&lt;[`Table`](Table.md)&gt;
+
+#### createTable(name, data, namespace, options)
+
+```ts
+abstract createTable(
+   name,
+   data,
+   namespace?,
+   options?): Promise<Table>
+```
+
+Creates a new Table and initialize it with new data.
+
+##### Parameters
+
+* **name**: `string`
+    The name of the table.
+
+* **data**: [`TableLike`](../type-aliases/TableLike.md) \| `Record`&lt;`string`, `unknown`&gt;[]
+    Non-empty Array of Records
+    to be inserted into the table
+
+* **namespace?**: `string`[]
+    The namespace to create the table in (defaults to root namespace)
+
+* **options?**: `Partial`&lt;[`CreateTableOptions`](../interfaces/CreateTableOptions.md)&gt;
+    Additional options
 
 ##### Returns
 
@@ -134,11 +247,16 @@ Return a brief description of the connection
 ### dropAllTables()
 
 ```ts
-abstract dropAllTables(): Promise<void>
+abstract dropAllTables(namespace?): Promise<void>
 ```
 
 Drop all tables in the database.
 
+#### Parameters
+
+* **namespace?**: `string`[]
+    The namespace to drop tables from (defaults to root namespace).
+
 #### Returns
 
 `Promise`&lt;`void`&gt;
@@ -148,7 +266,7 @@ Drop all tables in the database.
 ### dropTable()
 
 ```ts
-abstract dropTable(name): Promise<void>
+abstract dropTable(name, namespace?): Promise<void>
 ```
 
 Drop an existing table.
@@ -158,6 +276,9 @@ Drop an existing table.
 * **name**: `string`
     The name of the table to drop.
 
+* **namespace?**: `string`[]
+    The namespace of the table (defaults to root namespace).
+
 #### Returns
 
 `Promise`&lt;`void`&gt;
@@ -181,7 +302,10 @@ Return true if the connection has not been closed
 ### openTable()
 
 ```ts
-abstract openTable(name, options?): Promise<Table>
+abstract openTable(
+   name,
+   namespace?,
+   options?): Promise<Table>
 ```
 
 Open a table in the database.
@@ -191,7 +315,11 @@ Open a table in the database.
 * **name**: `string`
     The name of the table
 
+* **namespace?**: `string`[]
+    The namespace of the table (defaults to root namespace)
+
 * **options?**: `Partial`&lt;[`OpenTableOptions`](../interfaces/OpenTableOptions.md)&gt;
+    Additional options
 
 #### Returns
 
@@ -201,6 +329,8 @@ Open a table in the database.
 
 ### tableNames()
 
+#### tableNames(options)
+
 ```ts
 abstract tableNames(options?): Promise<string[]>
 ```
@@ -209,12 +339,35 @@ List all the table names in this database.
 
 Tables will be returned in lexicographical order.
 
-#### Parameters
+##### Parameters
+
+* **options?**: `Partial`&lt;[`TableNamesOptions`](../interfaces/TableNamesOptions.md)&gt;
+    options to control the
+    paging / start point (backwards compatibility)
+
+##### Returns
+
+`Promise`&lt;`string`[]&gt;
+
+#### tableNames(namespace, options)
+
+```ts
+abstract tableNames(namespace?, options?): Promise<string[]>
+```
+
+List all the table names in this database.
+
+Tables will be returned in lexicographical order.
+
+##### Parameters
+
+* **namespace?**: `string`[]
+    The namespace to list tables from (defaults to root namespace)
 
 * **options?**: `Partial`&lt;[`TableNamesOptions`](../interfaces/TableNamesOptions.md)&gt;
     options to control the
     paging / start point
 
-#### Returns
+##### Returns
 
 `Promise`&lt;`string`[]&gt;

docs/src/js/classes/HeaderProvider.md

@@ -0,0 +1,85 @@
+[**@lancedb/lancedb**](../README.md) • **Docs**
+
+***
+
+[@lancedb/lancedb](../globals.md) / HeaderProvider
+
+# Class: `abstract` HeaderProvider
+
+Abstract base class for providing custom headers for each request.
+
+Users can implement this interface to provide dynamic headers for various purposes
+such as authentication (OAuth tokens, API keys), request tracking (correlation IDs),
+custom metadata, or any other header-based requirements. The provider is called
+before each request to ensure fresh header values are always used.
+
+## Examples
+
+Simple JWT token provider:
+```typescript
+class JWTProvider extends HeaderProvider {
+  constructor(private token: string) {
+    super();
+  }
+
+  getHeaders(): Record<string, string> {
+    return { authorization: `Bearer ${this.token}` };
+  }
+}
+```
+
+Provider with request tracking:
+```typescript
+class RequestTrackingProvider extends HeaderProvider {
+  constructor(private sessionId: string) {
+    super();
+  }
+
+  getHeaders(): Record<string, string> {
+    return {
+      "X-Session-Id": this.sessionId,
+      "X-Request-Id": `req-${Date.now()}`
+    };
+  }
+}
+```
+
+## Extended by
+
+- [`StaticHeaderProvider`](StaticHeaderProvider.md)
+- [`OAuthHeaderProvider`](OAuthHeaderProvider.md)
+
+## Constructors
+
+### new HeaderProvider()
+
+```ts
+new HeaderProvider(): HeaderProvider
+```
+
+#### Returns
+
+[`HeaderProvider`](HeaderProvider.md)
+
+## Methods
+
+### getHeaders()
+
+```ts
+abstract getHeaders(): Record<string, string>
+```
+
+Get the latest headers to be added to requests.
+
+This method is called before each request to the remote LanceDB server.
+Implementations should return headers that will be merged with existing headers.
+
+#### Returns
+
+`Record`&lt;`string`, `string`&gt;
+
+Dictionary of header names to values to add to the request.
+
+#### Throws
+
+If unable to fetch headers, the exception will be propagated and the request will fail.

docs/src/js/classes/MergeInsertBuilder.md

@@ -52,6 +52,30 @@ the merge result
 
 ***
 
+### useIndex()
+
+```ts
+useIndex(useIndex): MergeInsertBuilder
+```
+
+Controls whether to use indexes for the merge operation.
+
+When set to `true` (the default), the operation will use an index if available
+on the join key for improved performance. When set to `false`, it forces a full
+table scan even if an index exists. This can be useful for benchmarking or when
+the query optimizer chooses a suboptimal path.
+
+#### Parameters
+
+* **useIndex**: `boolean`
+    Whether to use indices for the merge operation. Defaults to `true`.
+
+#### Returns
+
+[`MergeInsertBuilder`](MergeInsertBuilder.md)
+
+***
+
 ### whenMatchedUpdateAll()
 
 ```ts

docs/src/js/classes/NativeJsHeaderProvider.md

@@ -0,0 +1,29 @@
+[**@lancedb/lancedb**](../README.md) • **Docs**
+
+***
+
+[@lancedb/lancedb](../globals.md) / NativeJsHeaderProvider
+
+# Class: NativeJsHeaderProvider
+
+JavaScript HeaderProvider implementation that wraps a JavaScript callback.
+This is the only native header provider - all header provider implementations
+should provide a JavaScript function that returns headers.
+
+## Constructors
+
+### new NativeJsHeaderProvider()
+
+```ts
+new NativeJsHeaderProvider(getHeadersCallback): NativeJsHeaderProvider
+```
+
+Create a new JsHeaderProvider from a JavaScript callback
+
+#### Parameters
+
+* **getHeadersCallback**
+
+#### Returns
+
+[`NativeJsHeaderProvider`](NativeJsHeaderProvider.md)

docs/src/js/classes/OAuthHeaderProvider.md

@@ -0,0 +1,108 @@
+[**@lancedb/lancedb**](../README.md) • **Docs**
+
+***
+
+[@lancedb/lancedb](../globals.md) / OAuthHeaderProvider
+
+# Class: OAuthHeaderProvider
+
+Example implementation: OAuth token provider with automatic refresh.
+
+This is an example implementation showing how to manage OAuth tokens
+with automatic refresh when they expire.
+
+## Example
+
+```typescript
+async function fetchToken(): Promise<TokenResponse> {
+  const response = await fetch("https://oauth.example.com/token", {
+    method: "POST",
+    body: JSON.stringify({
+      grant_type: "client_credentials",
+      client_id: "your-client-id",
+      client_secret: "your-client-secret"
+    }),
+    headers: { "Content-Type": "application/json" }
+  });
+  const data = await response.json();
+  return {
+    accessToken: data.access_token,
+    expiresIn: data.expires_in
+  };
+}
+
+const provider = new OAuthHeaderProvider(fetchToken);
+const headers = provider.getHeaders();
+// Returns: {"authorization": "Bearer <your-token>"}
+```
+
+## Extends
+
+- [`HeaderProvider`](HeaderProvider.md)
+
+## Constructors
+
+### new OAuthHeaderProvider()
+
+```ts
+new OAuthHeaderProvider(tokenFetcher, refreshBufferSeconds): OAuthHeaderProvider
+```
+
+Initialize the OAuth provider.
+
+#### Parameters
+
+* **tokenFetcher**
+    Function to fetch new tokens. Should return object with 'accessToken' and optionally 'expiresIn'.
+
+* **refreshBufferSeconds**: `number` = `300`
+    Seconds before expiry to refresh token. Default 300 (5 minutes).
+
+#### Returns
+
+[`OAuthHeaderProvider`](OAuthHeaderProvider.md)
+
+#### Overrides
+
+[`HeaderProvider`](HeaderProvider.md).[`constructor`](HeaderProvider.md#constructors)
+
+## Methods
+
+### getHeaders()
+
+```ts
+getHeaders(): Record<string, string>
+```
+
+Get OAuth headers, refreshing token if needed.
+Note: This is synchronous for now as the Rust implementation expects sync.
+In a real implementation, this would need to handle async properly.
+
+#### Returns
+
+`Record`&lt;`string`, `string`&gt;
+
+Headers with Bearer token authorization.
+
+#### Throws
+
+If unable to fetch or refresh token.
+
+#### Overrides
+
+[`HeaderProvider`](HeaderProvider.md).[`getHeaders`](HeaderProvider.md#getheaders)
+
+***
+
+### refreshToken()
+
+```ts
+refreshToken(): Promise<void>
+```
+
+Manually refresh the token.
+Call this before using getHeaders() to ensure token is available.
+
+#### Returns
+
+`Promise`&lt;`void`&gt;

docs/src/js/classes/StaticHeaderProvider.md

@@ -0,0 +1,70 @@
+[**@lancedb/lancedb**](../README.md) • **Docs**
+
+***
+
+[@lancedb/lancedb](../globals.md) / StaticHeaderProvider
+
+# Class: StaticHeaderProvider
+
+Example implementation: A simple header provider that returns static headers.
+
+This is an example implementation showing how to create a HeaderProvider
+for cases where headers don't change during the session.
+
+## Example
+
+```typescript
+const provider = new StaticHeaderProvider({
+  authorization: "Bearer my-token",
+  "X-Custom-Header": "custom-value"
+});
+const headers = provider.getHeaders();
+// Returns: {authorization: 'Bearer my-token', 'X-Custom-Header': 'custom-value'}
+```
+
+## Extends
+
+- [`HeaderProvider`](HeaderProvider.md)
+
+## Constructors
+
+### new StaticHeaderProvider()
+
+```ts
+new StaticHeaderProvider(headers): StaticHeaderProvider
+```
+
+Initialize with static headers.
+
+#### Parameters
+
+* **headers**: `Record`<`string`, `string`>
+    Headers to return for every request.
+
+#### Returns
+
+[`StaticHeaderProvider`](StaticHeaderProvider.md)
+
+#### Overrides
+
+[`HeaderProvider`](HeaderProvider.md).[`constructor`](HeaderProvider.md#constructors)
+
+## Methods
+
+### getHeaders()
+
+```ts
+getHeaders(): Record<string, string>
+```
+
+Return the static headers.
+
+#### Returns
+
+`Record`&lt;`string`, `string`&gt;
+
+Copy of the static headers.
+
+#### Overrides
+
+[`HeaderProvider`](HeaderProvider.md).[`getHeaders`](HeaderProvider.md#getheaders)

docs/src/js/functions/connect.md

@@ -6,13 +6,14 @@
 
 # Function: connect()
 
-## connect(uri, options, session)
+## connect(uri, options, session, headerProvider)
 
 ```ts
 function connect(
    uri,
    options?,
-   session?): Promise<Connection>
+   session?,
+   headerProvider?): Promise<Connection>
 ```
 
 Connect to a LanceDB instance at the given URI.
@@ -34,6 +35,8 @@ Accepted formats:
 
 * **session?**: [`Session`](../classes/Session.md)
 
+* **headerProvider?**: [`HeaderProvider`](../classes/HeaderProvider.md) \| () => `Record`&lt;`string`, `string`&gt; \| () => `Promise`&lt;`Record`&lt;`string`, `string`&gt;&gt;
+
 ### Returns
 
 `Promise`&lt;[`Connection`](../classes/Connection.md)&gt;
@@ -55,6 +58,18 @@ const conn = await connect(
 });
 ```
 
+Using with a header provider for per-request authentication:
+```ts
+const provider = new StaticHeaderProvider({
+  "X-API-Key": "my-key"
+});
+const conn = await connectWithHeaderProvider(
+  "db://host:port",
+  options,
+  provider
+);
+```
+
 ## connect(options)
 
 ```ts

docs/src/js/functions/makeArrowTable.md

@@ -13,7 +13,7 @@ function makeArrowTable(
    metadata?): ArrowTable
 ```
 
-An enhanced version of the makeTable function from Apache Arrow
+An enhanced version of the apache-arrow makeTable function from Apache Arrow
 that supports nested fields and embeddings columns.
 
 (typically you do not need to call this function.  It will be called automatically

docs/src/js/globals.md

@@ -20,16 +20,20 @@
 - [BooleanQuery](classes/BooleanQuery.md)
 - [BoostQuery](classes/BoostQuery.md)
 - [Connection](classes/Connection.md)
+- [HeaderProvider](classes/HeaderProvider.md)
 - [Index](classes/Index.md)
 - [MakeArrowTableOptions](classes/MakeArrowTableOptions.md)
 - [MatchQuery](classes/MatchQuery.md)
 - [MergeInsertBuilder](classes/MergeInsertBuilder.md)
 - [MultiMatchQuery](classes/MultiMatchQuery.md)
+- [NativeJsHeaderProvider](classes/NativeJsHeaderProvider.md)
+- [OAuthHeaderProvider](classes/OAuthHeaderProvider.md)
 - [PhraseQuery](classes/PhraseQuery.md)
 - [Query](classes/Query.md)
 - [QueryBase](classes/QueryBase.md)
 - [RecordBatchIterator](classes/RecordBatchIterator.md)
 - [Session](classes/Session.md)
+- [StaticHeaderProvider](classes/StaticHeaderProvider.md)
 - [Table](classes/Table.md)
 - [TagContents](classes/TagContents.md)
 - [Tags](classes/Tags.md)
@@ -74,6 +78,8 @@
 - [TableNamesOptions](interfaces/TableNamesOptions.md)
 - [TableStatistics](interfaces/TableStatistics.md)
 - [TimeoutConfig](interfaces/TimeoutConfig.md)
+- [TlsConfig](interfaces/TlsConfig.md)
+- [TokenResponse](interfaces/TokenResponse.md)
 - [UpdateOptions](interfaces/UpdateOptions.md)
 - [UpdateResult](interfaces/UpdateResult.md)
 - [Version](interfaces/Version.md)

docs/src/js/interfaces/ClientConfig.md

@@ -16,6 +16,14 @@ optional extraHeaders: Record<string, string>;
 
 ***
 
+### idDelimiter?
+
+```ts
+optional idDelimiter: string;
+```
+
+***
+
 ### retryConfig?
 
 ```ts
@@ -32,6 +40,14 @@ optional timeoutConfig: TimeoutConfig;
 
 ***
 
+### tlsConfig?
+
+```ts
+optional tlsConfig: TlsConfig;
+```
+
+***
+
 ### userAgent?
 
 ```ts

docs/src/js/interfaces/TlsConfig.md

@@ -0,0 +1,49 @@
+[**@lancedb/lancedb**](../README.md) • **Docs**
+
+***
+
+[@lancedb/lancedb](../globals.md) / TlsConfig
+
+# Interface: TlsConfig
+
+TLS/mTLS configuration for the remote HTTP client.
+
+## Properties
+
+### assertHostname?
+
+```ts
+optional assertHostname: boolean;
+```
+
+Whether to verify the hostname in the server's certificate.
+
+***
+
+### certFile?
+
+```ts
+optional certFile: string;
+```
+
+Path to the client certificate file (PEM format) for mTLS authentication.
+
+***
+
+### keyFile?
+
+```ts
+optional keyFile: string;
+```
+
+Path to the client private key file (PEM format) for mTLS authentication.
+
+***
+
+### sslCaCert?
+
+```ts
+optional sslCaCert: string;
+```
+
+Path to the CA certificate file (PEM format) for server verification.

docs/src/js/interfaces/TokenResponse.md

@@ -0,0 +1,25 @@
+[**@lancedb/lancedb**](../README.md) • **Docs**
+
+***
+
+[@lancedb/lancedb](../globals.md) / TokenResponse
+
+# Interface: TokenResponse
+
+Token response from OAuth provider.
+
+## Properties
+
+### accessToken
+
+```ts
+accessToken: string;
+```
+
+***
+
+### expiresIn?
+
+```ts
+optional expiresIn: number;
+```

java/core/lancedb-jni/src/ffi.rs

@@ -16,6 +16,7 @@ pub trait JNIEnvExt {
     fn get_integers(&mut self, obj: &JObject) -> Result<Vec<i32>>;
 
     /// Get strings from Java List<String> object.
+    #[allow(dead_code)]
     fn get_strings(&mut self, obj: &JObject) -> Result<Vec<String>>;
 
     /// Get strings from Java String[] object.

java/core/lancedb-jni/src/traits.rs

@@ -6,6 +6,7 @@ use jni::JNIEnv;
 
 use crate::Result;
 
+#[allow(dead_code)]
 pub trait FromJObject<T> {
     fn extract(&self) -> Result<T>;
 }
@@ -39,6 +40,7 @@ impl FromJObject<f64> for JObject<'_> {
     }
 }
 
+#[allow(dead_code)]
 pub trait FromJString {
     fn extract(&self, env: &mut JNIEnv) -> Result<String>;
 }
@@ -66,6 +68,7 @@ pub trait JMapExt {
     fn get_f64(&self, env: &mut JNIEnv, key: &str) -> Result<Option<f64>>;
 }
 
+#[allow(dead_code)]
 fn get_map_value<T>(env: &mut JNIEnv, map: &JMap, key: &str) -> Result<Option<T>>
 where
     for<'a> JObject<'a>: FromJObject<T>,

java/core/pom.xml

@@ -8,7 +8,7 @@
     <parent>
         <groupId>com.lancedb</groupId>
         <artifactId>lancedb-parent</artifactId>
-        <version>0.22.0-beta.1</version>
+        <version>0.22.2-beta.2</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
 

java/lance-namespace/pom.xml

@@ -8,7 +8,7 @@
     <parent>
         <groupId>com.lancedb</groupId>
         <artifactId>lancedb-parent</artifactId>
-        <version>0.22.0-beta.1</version>
+        <version>0.22.2-beta.2</version>
         <relativePath>../pom.xml</relativePath>
     </parent>
 

java/pom.xml

@@ -6,7 +6,7 @@
 
     <groupId>com.lancedb</groupId>
     <artifactId>lancedb-parent</artifactId>
-    <version>0.22.0-beta.1</version>
+    <version>0.22.2-beta.2</version>
     <packaging>pom</packaging>
     <name>${project.artifactId}</name>
     <description>LanceDB Java SDK Parent POM</description>

nodejs/Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "lancedb-nodejs"
 edition.workspace = true
-version = "0.22.0-beta.1"
+version = "0.22.2-beta.2"
 license.workspace = true
 description.workspace = true
 repository.workspace = true

nodejs/__test__/arrow.test.ts

@@ -1,17 +1,5 @@
 // SPDX-License-Identifier: Apache-2.0
 // SPDX-FileCopyrightText: Copyright The LanceDB Authors
-
-import {
-  Bool,
-  Field,
-  Int32,
-  List,
-  Schema,
-  Struct,
-  Uint8,
-  Utf8,
-} from "apache-arrow";
-
 import * as arrow15 from "apache-arrow-15";
 import * as arrow16 from "apache-arrow-16";
 import * as arrow17 from "apache-arrow-17";
@@ -25,11 +13,9 @@ import {
   fromTableToBuffer,
   makeArrowTable,
   makeEmptyTable,
-  tableFromIPC,
 } from "../lancedb/arrow";
 import {
   EmbeddingFunction,
-  FieldOptions,
   FunctionOptions,
 } from "../lancedb/embedding/embedding_function";
 import { EmbeddingFunctionConfig } from "../lancedb/embedding/registry";
@@ -1008,5 +994,64 @@ describe.each([arrow15, arrow16, arrow17, arrow18])(
         expect(result).toEqual(null);
       });
     });
+
+    describe("boolean null handling", function () {
+      it("should handle null values in nullable boolean fields", () => {
+        const { makeArrowTable } = require("../lancedb/arrow");
+        const schema = new Schema([new Field("test", new arrow.Bool(), true)]);
+
+        // Test with all null values
+        const data = [{ test: null }];
+        const table = makeArrowTable(data, { schema });
+
+        expect(table.numRows).toBe(1);
+        expect(table.schema.names).toEqual(["test"]);
+        expect(table.getChild("test")!.get(0)).toBeNull();
+      });
+
+      it("should handle mixed null and non-null boolean values", () => {
+        const { makeArrowTable } = require("../lancedb/arrow");
+        const schema = new Schema([new Field("test", new Bool(), true)]);
+
+        // Test with mixed values
+        const data = [{ test: true }, { test: null }, { test: false }];
+        const table = makeArrowTable(data, { schema });
+
+        expect(table.numRows).toBe(3);
+        expect(table.getChild("test")!.get(0)).toBe(true);
+        expect(table.getChild("test")!.get(1)).toBeNull();
+        expect(table.getChild("test")!.get(2)).toBe(false);
+      });
+    });
+
+    // Test for the undefined values bug fix
+    describe("undefined values handling", () => {
+      it("should handle mixed undefined and actual values", () => {
+        const schema = new Schema([
+          new Field("text", new Utf8(), true), // nullable
+          new Field("number", new Int32(), true), // nullable
+          new Field("bool", new Bool(), true), // nullable
+        ]);
+
+        const data = [
+          { text: undefined, number: 42, bool: true },
+          { text: "hello", number: undefined, bool: false },
+          { text: "world", number: 123, bool: undefined },
+        ];
+        const table = makeArrowTable(data, { schema });
+
+        const result = table.toArray();
+        expect(result).toHaveLength(3);
+        expect(result[0].text).toBe(null);
+        expect(result[0].number).toBe(42);
+        expect(result[0].bool).toBe(true);
+        expect(result[1].text).toBe("hello");
+        expect(result[1].number).toBe(null);
+        expect(result[1].bool).toBe(false);
+        expect(result[2].text).toBe("world");
+        expect(result[2].number).toBe(123);
+        expect(result[2].bool).toBe(null);
+      });
+    });
   },
 );

nodejs/__test__/connection.test.ts

@@ -203,3 +203,106 @@ describe("given a connection", () => {
     });
   });
 });
+
+describe("clone table functionality", () => {
+  let tmpDir: tmp.DirResult;
+  let db: Connection;
+  beforeEach(async () => {
+    tmpDir = tmp.dirSync({ unsafeCleanup: true });
+    db = await connect(tmpDir.name);
+  });
+  afterEach(() => tmpDir.removeCallback());
+
+  it("should clone a table with latest version (default behavior)", async () => {
+    // Create source table with some data
+    const data = [
+      { id: 1, text: "hello", vector: [1.0, 2.0] },
+      { id: 2, text: "world", vector: [3.0, 4.0] },
+    ];
+    const sourceTable = await db.createTable("source", data);
+
+    // Add more data to create a new version
+    const moreData = [{ id: 3, text: "test", vector: [5.0, 6.0] }];
+    await sourceTable.add(moreData);
+
+    // Clone the table (should get latest version with 3 rows)
+    const sourceUri = `${tmpDir.name}/source.lance`;
+    const clonedTable = await db.cloneTable("cloned", sourceUri);
+
+    // Verify cloned table has all 3 rows
+    expect(await clonedTable.countRows()).toBe(3);
+    expect((await db.tableNames()).includes("cloned")).toBe(true);
+  });
+
+  it("should clone a table from a specific version", async () => {
+    // Create source table with initial data
+    const data = [
+      { id: 1, text: "hello", vector: [1.0, 2.0] },
+      { id: 2, text: "world", vector: [3.0, 4.0] },
+    ];
+    const sourceTable = await db.createTable("source", data);
+
+    // Get the initial version
+    const initialVersion = await sourceTable.version();
+
+    // Add more data to create a new version
+    const moreData = [{ id: 3, text: "test", vector: [5.0, 6.0] }];
+    await sourceTable.add(moreData);
+
+    // Verify source now has 3 rows
+    expect(await sourceTable.countRows()).toBe(3);
+
+    // Clone from the initial version (should have only 2 rows)
+    const sourceUri = `${tmpDir.name}/source.lance`;
+    const clonedTable = await db.cloneTable("cloned", sourceUri, {
+      sourceVersion: initialVersion,
+    });
+
+    // Verify cloned table has only the initial 2 rows
+    expect(await clonedTable.countRows()).toBe(2);
+  });
+
+  it("should clone a table from a tagged version", async () => {
+    // Create source table with initial data
+    const data = [
+      { id: 1, text: "hello", vector: [1.0, 2.0] },
+      { id: 2, text: "world", vector: [3.0, 4.0] },
+    ];
+    const sourceTable = await db.createTable("source", data);
+
+    // Create a tag for the current version
+    const tags = await sourceTable.tags();
+    await tags.create("v1.0", await sourceTable.version());
+
+    // Add more data after the tag
+    const moreData = [{ id: 3, text: "test", vector: [5.0, 6.0] }];
+    await sourceTable.add(moreData);
+
+    // Verify source now has 3 rows
+    expect(await sourceTable.countRows()).toBe(3);
+
+    // Clone from the tagged version (should have only 2 rows)
+    const sourceUri = `${tmpDir.name}/source.lance`;
+    const clonedTable = await db.cloneTable("cloned", sourceUri, {
+      sourceTag: "v1.0",
+    });
+
+    // Verify cloned table has only the tagged version's 2 rows
+    expect(await clonedTable.countRows()).toBe(2);
+  });
+
+  it("should fail when attempting deep clone", async () => {
+    // Create source table with some data
+    const data = [
+      { id: 1, text: "hello", vector: [1.0, 2.0] },
+      { id: 2, text: "world", vector: [3.0, 4.0] },
+    ];
+    await db.createTable("source", data);
+
+    // Try to create a deep clone (should fail)
+    const sourceUri = `${tmpDir.name}/source.lance`;
+    await expect(
+      db.cloneTable("cloned", sourceUri, { isShallow: false }),
+    ).rejects.toThrow("Deep clone is not yet implemented");
+  });
+});

nodejs/__test__/embedding.test.ts

@@ -256,6 +256,60 @@ describe("embedding functions", () => {
     expect(actual).toHaveProperty("text");
   });
 
+  it("should handle undefined vector field with embedding function correctly", async () => {
+    @register("undefined_test")
+    class MockEmbeddingFunction extends EmbeddingFunction<string> {
+      ndims() {
+        return 3;
+      }
+      embeddingDataType(): Float {
+        return new Float32();
+      }
+      async computeQueryEmbeddings(_data: string) {
+        return [1, 2, 3];
+      }
+      async computeSourceEmbeddings(data: string[]) {
+        return Array.from({ length: data.length }).fill([
+          1, 2, 3,
+        ]) as number[][];
+      }
+    }
+    const func = getRegistry()
+      .get<MockEmbeddingFunction>("undefined_test")!
+      .create();
+    const schema = new Schema([
+      new Field("text", new Utf8(), true),
+      new Field(
+        "vector",
+        new FixedSizeList(3, new Field("item", new Float32(), true)),
+        true,
+      ),
+    ]);
+
+    const db = await connect(tmpDir.name);
+    const table = await db.createEmptyTable("test_undefined", schema, {
+      embeddingFunction: {
+        function: func,
+        sourceColumn: "text",
+        vectorColumn: "vector",
+      },
+    });
+
+    // Test that undefined, null, and omitted vector fields all work
+    await table.add([{ text: "test1", vector: undefined }]);
+    await table.add([{ text: "test2", vector: null }]);
+    await table.add([{ text: "test3" }]);
+
+    const rows = await table.query().toArray();
+    expect(rows.length).toBe(3);
+
+    // All rows should have vectors computed by the embedding function
+    for (const row of rows) {
+      expect(row.vector).toBeDefined();
+      expect(JSON.parse(JSON.stringify(row.vector))).toEqual([1, 2, 3]);
+    }
+  });
+
   test.each([new Float16(), new Float32(), new Float64()])(
     "should be able to provide manual embeddings with multiple float datatype",
     async (floatType) => {

nodejs/__test__/remote.test.ts

@@ -3,7 +3,49 @@
 
 import * as http from "http";
 import { RequestListener } from "http";
-import { Connection, ConnectionOptions, connect } from "../lancedb";
+import {
+  ClientConfig,
+  Connection,
+  ConnectionOptions,
+  TlsConfig,
+  connect,
+} from "../lancedb";
+import {
+  HeaderProvider,
+  OAuthHeaderProvider,
+  StaticHeaderProvider,
+} from "../lancedb/header";
+
+// Test-only header providers
+class CustomProvider extends HeaderProvider {
+  getHeaders(): Record<string, string> {
+    return { "X-Custom": "custom-value" };
+  }
+}
+
+class ErrorProvider extends HeaderProvider {
+  private errorMessage: string;
+  public callCount: number = 0;
+
+  constructor(errorMessage: string = "Test error") {
+    super();
+    this.errorMessage = errorMessage;
+  }
+
+  getHeaders(): Record<string, string> {
+    this.callCount++;
+    throw new Error(this.errorMessage);
+  }
+}
+
+class ConcurrentProvider extends HeaderProvider {
+  private counter: number = 0;
+
+  getHeaders(): Record<string, string> {
+    this.counter++;
+    return { "X-Request-Id": String(this.counter) };
+  }
+}
 
 async function withMockDatabase(
   listener: RequestListener,
@@ -148,4 +190,431 @@ describe("remote connection", () => {
       },
     );
   });
+
+  describe("TlsConfig", () => {
+    it("should create TlsConfig with all fields", () => {
+      const tlsConfig: TlsConfig = {
+        certFile: "/path/to/cert.pem",
+        keyFile: "/path/to/key.pem",
+        sslCaCert: "/path/to/ca.pem",
+        assertHostname: false,
+      };
+
+      expect(tlsConfig.certFile).toBe("/path/to/cert.pem");
+      expect(tlsConfig.keyFile).toBe("/path/to/key.pem");
+      expect(tlsConfig.sslCaCert).toBe("/path/to/ca.pem");
+      expect(tlsConfig.assertHostname).toBe(false);
+    });
+
+    it("should create TlsConfig with partial fields", () => {
+      const tlsConfig: TlsConfig = {
+        certFile: "/path/to/cert.pem",
+        keyFile: "/path/to/key.pem",
+      };
+
+      expect(tlsConfig.certFile).toBe("/path/to/cert.pem");
+      expect(tlsConfig.keyFile).toBe("/path/to/key.pem");
+      expect(tlsConfig.sslCaCert).toBeUndefined();
+      expect(tlsConfig.assertHostname).toBeUndefined();
+    });
+
+    it("should create ClientConfig with TlsConfig", () => {
+      const tlsConfig: TlsConfig = {
+        certFile: "/path/to/cert.pem",
+        keyFile: "/path/to/key.pem",
+        sslCaCert: "/path/to/ca.pem",
+        assertHostname: true,
+      };
+
+      const clientConfig: ClientConfig = {
+        userAgent: "test-agent",
+        tlsConfig: tlsConfig,
+      };
+
+      expect(clientConfig.userAgent).toBe("test-agent");
+      expect(clientConfig.tlsConfig).toBeDefined();
+      expect(clientConfig.tlsConfig?.certFile).toBe("/path/to/cert.pem");
+      expect(clientConfig.tlsConfig?.keyFile).toBe("/path/to/key.pem");
+      expect(clientConfig.tlsConfig?.sslCaCert).toBe("/path/to/ca.pem");
+      expect(clientConfig.tlsConfig?.assertHostname).toBe(true);
+    });
+
+    it("should handle empty TlsConfig", () => {
+      const tlsConfig: TlsConfig = {};
+
+      expect(tlsConfig.certFile).toBeUndefined();
+      expect(tlsConfig.keyFile).toBeUndefined();
+      expect(tlsConfig.sslCaCert).toBeUndefined();
+      expect(tlsConfig.assertHostname).toBeUndefined();
+    });
+
+    it("should accept TlsConfig in connection options", () => {
+      const tlsConfig: TlsConfig = {
+        certFile: "/path/to/cert.pem",
+        keyFile: "/path/to/key.pem",
+        sslCaCert: "/path/to/ca.pem",
+        assertHostname: false,
+      };
+
+      // Just verify that the ClientConfig accepts the TlsConfig
+      const clientConfig: ClientConfig = {
+        tlsConfig: tlsConfig,
+      };
+
+      const connectionOptions: ConnectionOptions = {
+        apiKey: "fake",
+        clientConfig: clientConfig,
+      };
+
+      // Verify the configuration structure is correct
+      expect(connectionOptions.clientConfig).toBeDefined();
+      expect(connectionOptions.clientConfig?.tlsConfig).toBeDefined();
+      expect(connectionOptions.clientConfig?.tlsConfig?.certFile).toBe(
+        "/path/to/cert.pem",
+      );
+    });
+  });
+
+  describe("header providers", () => {
+    it("should work with StaticHeaderProvider", async () => {
+      const provider = new StaticHeaderProvider({
+        authorization: "Bearer test-token",
+        "X-Custom": "value",
+      });
+
+      const headers = provider.getHeaders();
+      expect(headers).toEqual({
+        authorization: "Bearer test-token",
+        "X-Custom": "value",
+      });
+
+      // Test that it returns a copy
+      headers["X-Modified"] = "modified";
+      const headers2 = provider.getHeaders();
+      expect(headers2).not.toHaveProperty("X-Modified");
+    });
+
+    it("should pass headers from StaticHeaderProvider to requests", async () => {
+      const provider = new StaticHeaderProvider({
+        "X-Custom-Auth": "secret-token",
+        "X-Request-Source": "test-suite",
+      });
+
+      await withMockDatabase(
+        (req, res) => {
+          expect(req.headers["x-custom-auth"]).toEqual("secret-token");
+          expect(req.headers["x-request-source"]).toEqual("test-suite");
+
+          const body = JSON.stringify({ tables: [] });
+          res.writeHead(200, { "Content-Type": "application/json" }).end(body);
+        },
+        async () => {
+          // Use actual header provider mechanism instead of extraHeaders
+          const conn = await connect(
+            "db://dev",
+            {
+              apiKey: "fake",
+              hostOverride: "http://localhost:8000",
+            },
+            undefined, // session
+            provider, // headerProvider
+          );
+
+          const tableNames = await conn.tableNames();
+          expect(tableNames).toEqual([]);
+        },
+      );
+    });
+
+    it("should work with CustomProvider", () => {
+      const provider = new CustomProvider();
+      const headers = provider.getHeaders();
+      expect(headers).toEqual({ "X-Custom": "custom-value" });
+    });
+
+    it("should handle ErrorProvider errors", () => {
+      const provider = new ErrorProvider("Authentication failed");
+
+      expect(() => provider.getHeaders()).toThrow("Authentication failed");
+      expect(provider.callCount).toBe(1);
+
+      // Test that error is thrown each time
+      expect(() => provider.getHeaders()).toThrow("Authentication failed");
+      expect(provider.callCount).toBe(2);
+    });
+
+    it("should work with ConcurrentProvider", () => {
+      const provider = new ConcurrentProvider();
+
+      const headers1 = provider.getHeaders();
+      const headers2 = provider.getHeaders();
+      const headers3 = provider.getHeaders();
+
+      expect(headers1).toEqual({ "X-Request-Id": "1" });
+      expect(headers2).toEqual({ "X-Request-Id": "2" });
+      expect(headers3).toEqual({ "X-Request-Id": "3" });
+    });
+
+    describe("OAuthHeaderProvider", () => {
+      it("should initialize correctly", () => {
+        const fetcher = () => ({
+          accessToken: "token123",
+          expiresIn: 3600,
+        });
+
+        const provider = new OAuthHeaderProvider(fetcher);
+        expect(provider).toBeInstanceOf(HeaderProvider);
+      });
+
+      it("should fetch token on first use", async () => {
+        let callCount = 0;
+        const fetcher = () => {
+          callCount++;
+          return {
+            accessToken: "token123",
+            expiresIn: 3600,
+          };
+        };
+
+        const provider = new OAuthHeaderProvider(fetcher);
+
+        // Need to manually refresh first due to sync limitation
+        await provider.refreshToken();
+
+        const headers = provider.getHeaders();
+        expect(headers).toEqual({ authorization: "Bearer token123" });
+        expect(callCount).toBe(1);
+
+        // Second call should not fetch again
+        const headers2 = provider.getHeaders();
+        expect(headers2).toEqual({ authorization: "Bearer token123" });
+        expect(callCount).toBe(1);
+      });
+
+      it("should handle tokens without expiry", async () => {
+        const fetcher = () => ({
+          accessToken: "permanent_token",
+        });
+
+        const provider = new OAuthHeaderProvider(fetcher);
+        await provider.refreshToken();
+
+        const headers = provider.getHeaders();
+        expect(headers).toEqual({ authorization: "Bearer permanent_token" });
+      });
+
+      it("should throw error when access_token is missing", async () => {
+        const fetcher = () =>
+          ({
+            expiresIn: 3600,
+          }) as { accessToken?: string; expiresIn?: number };
+
+        const provider = new OAuthHeaderProvider(
+          fetcher as () => {
+            accessToken: string;
+            expiresIn?: number;
+          },
+        );
+
+        await expect(provider.refreshToken()).rejects.toThrow(
+          "Token fetcher did not return 'accessToken'",
+        );
+      });
+
+      it("should handle async token fetchers", async () => {
+        const fetcher = async () => {
+          // Simulate async operation
+          await new Promise((resolve) => setTimeout(resolve, 10));
+          return {
+            accessToken: "async_token",
+            expiresIn: 3600,
+          };
+        };
+
+        const provider = new OAuthHeaderProvider(fetcher);
+        await provider.refreshToken();
+
+        const headers = provider.getHeaders();
+        expect(headers).toEqual({ authorization: "Bearer async_token" });
+      });
+    });
+
+    it("should merge header provider headers with extra headers", async () => {
+      const provider = new StaticHeaderProvider({
+        "X-From-Provider": "provider-value",
+      });
+
+      await withMockDatabase(
+        (req, res) => {
+          expect(req.headers["x-from-provider"]).toEqual("provider-value");
+          expect(req.headers["x-extra-header"]).toEqual("extra-value");
+
+          const body = JSON.stringify({ tables: [] });
+          res.writeHead(200, { "Content-Type": "application/json" }).end(body);
+        },
+        async () => {
+          // Use header provider with additional extraHeaders
+          const conn = await connect(
+            "db://dev",
+            {
+              apiKey: "fake",
+              hostOverride: "http://localhost:8000",
+              clientConfig: {
+                extraHeaders: {
+                  "X-Extra-Header": "extra-value",
+                },
+              },
+            },
+            undefined, // session
+            provider, // headerProvider
+          );
+
+          const tableNames = await conn.tableNames();
+          expect(tableNames).toEqual([]);
+        },
+      );
+    });
+  });
+
+  describe("header provider integration", () => {
+    it("should work with TypeScript StaticHeaderProvider", async () => {
+      let requestCount = 0;
+
+      await withMockDatabase(
+        (req, res) => {
+          requestCount++;
+
+          // Check headers are present on each request
+          expect(req.headers["authorization"]).toEqual("Bearer test-token-123");
+          expect(req.headers["x-custom"]).toEqual("custom-value");
+
+          // Return different responses based on the endpoint
+          if (req.url === "/v1/table/test_table/describe/") {
+            const body = JSON.stringify({
+              name: "test_table",
+              schema: { fields: [] },
+            });
+            res
+              .writeHead(200, { "Content-Type": "application/json" })
+              .end(body);
+          } else {
+            const body = JSON.stringify({ tables: ["test_table"] });
+            res
+              .writeHead(200, { "Content-Type": "application/json" })
+              .end(body);
+          }
+        },
+        async () => {
+          // Create provider with static headers
+          const provider = new StaticHeaderProvider({
+            authorization: "Bearer test-token-123",
+            "X-Custom": "custom-value",
+          });
+
+          // Connect with the provider
+          const conn = await connect(
+            "db://dev",
+            {
+              apiKey: "fake",
+              hostOverride: "http://localhost:8000",
+            },
+            undefined, // session
+            provider, // headerProvider
+          );
+
+          // Make multiple requests to verify headers are sent each time
+          const tables1 = await conn.tableNames();
+          expect(tables1).toEqual(["test_table"]);
+
+          const tables2 = await conn.tableNames();
+          expect(tables2).toEqual(["test_table"]);
+
+          // Verify headers were sent with each request
+          expect(requestCount).toBeGreaterThanOrEqual(2);
+        },
+      );
+    });
+
+    it("should work with JavaScript function provider", async () => {
+      let requestId = 0;
+
+      await withMockDatabase(
+        (req, res) => {
+          // Check dynamic header is present
+          expect(req.headers["x-request-id"]).toBeDefined();
+          expect(req.headers["x-request-id"]).toMatch(/^req-\d+$/);
+
+          const body = JSON.stringify({ tables: [] });
+          res.writeHead(200, { "Content-Type": "application/json" }).end(body);
+        },
+        async () => {
+          // Create a JavaScript function that returns dynamic headers
+          const getHeaders = async () => {
+            requestId++;
+            return {
+              "X-Request-Id": `req-${requestId}`,
+              "X-Timestamp": new Date().toISOString(),
+            };
+          };
+
+          // Connect with the function directly
+          const conn = await connect(
+            "db://dev",
+            {
+              apiKey: "fake",
+              hostOverride: "http://localhost:8000",
+            },
+            undefined, // session
+            getHeaders, // headerProvider
+          );
+
+          // Make requests - each should have different headers
+          const tables = await conn.tableNames();
+          expect(tables).toEqual([]);
+        },
+      );
+    });
+
+    it("should support OAuth-like token refresh pattern", async () => {
+      let tokenVersion = 0;
+
+      await withMockDatabase(
+        (req, res) => {
+          // Verify authorization header
+          const authHeader = req.headers["authorization"];
+          expect(authHeader).toBeDefined();
+          expect(authHeader).toMatch(/^Bearer token-v\d+$/);
+
+          const body = JSON.stringify({ tables: [] });
+          res.writeHead(200, { "Content-Type": "application/json" }).end(body);
+        },
+        async () => {
+          // Simulate OAuth token fetcher
+          const fetchToken = async () => {
+            tokenVersion++;
+            return {
+              authorization: `Bearer token-v${tokenVersion}`,
+            };
+          };
+
+          // Connect with the function directly
+          const conn = await connect(
+            "db://dev",
+            {
+              apiKey: "fake",
+              hostOverride: "http://localhost:8000",
+            },
+            undefined, // session
+            fetchToken, // headerProvider
+          );
+
+          // Each request will fetch a new token
+          await conn.tableNames();
+
+          // Token should be different on next request
+          await conn.tableNames();
+        },
+      );
+    });
+  });
 });

nodejs/__test__/sanitize.test.ts

@@ -0,0 +1,184 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright The LanceDB Authors
+
+import * as arrow from "../lancedb/arrow";
+import { sanitizeField, sanitizeType } from "../lancedb/sanitize";
+
+describe("sanitize", function () {
+  describe("sanitizeType function", function () {
+    it("should handle type objects", function () {
+      const type = new arrow.Int32();
+      const result = sanitizeType(type);
+
+      expect(result.typeId).toBe(arrow.Type.Int);
+      expect((result as arrow.Int).bitWidth).toBe(32);
+      expect((result as arrow.Int).isSigned).toBe(true);
+
+      const floatType = {
+        typeId: 3, // Type.Float = 3
+        precision: 2,
+        toString: () => "Float",
+        isFloat: true,
+        isFixedWidth: true,
+      };
+
+      const floatResult = sanitizeType(floatType);
+      expect(floatResult).toBeInstanceOf(arrow.DataType);
+      expect(floatResult.typeId).toBe(arrow.Type.Float);
+
+      const floatResult2 = sanitizeType({ ...floatType, typeId: () => 3 });
+      expect(floatResult2).toBeInstanceOf(arrow.DataType);
+      expect(floatResult2.typeId).toBe(arrow.Type.Float);
+    });
+
+    const allTypeNameTestCases = [
+      ["null", new arrow.Null()],
+      ["binary", new arrow.Binary()],
+      ["utf8", new arrow.Utf8()],
+      ["bool", new arrow.Bool()],
+      ["int8", new arrow.Int8()],
+      ["int16", new arrow.Int16()],
+      ["int32", new arrow.Int32()],
+      ["int64", new arrow.Int64()],
+      ["uint8", new arrow.Uint8()],
+      ["uint16", new arrow.Uint16()],
+      ["uint32", new arrow.Uint32()],
+      ["uint64", new arrow.Uint64()],
+      ["float16", new arrow.Float16()],
+      ["float32", new arrow.Float32()],
+      ["float64", new arrow.Float64()],
+      ["datemillisecond", new arrow.DateMillisecond()],
+      ["dateday", new arrow.DateDay()],
+      ["timenanosecond", new arrow.TimeNanosecond()],
+      ["timemicrosecond", new arrow.TimeMicrosecond()],
+      ["timemillisecond", new arrow.TimeMillisecond()],
+      ["timesecond", new arrow.TimeSecond()],
+      ["intervaldaytime", new arrow.IntervalDayTime()],
+      ["intervalyearmonth", new arrow.IntervalYearMonth()],
+      ["durationnanosecond", new arrow.DurationNanosecond()],
+      ["durationmicrosecond", new arrow.DurationMicrosecond()],
+      ["durationmillisecond", new arrow.DurationMillisecond()],
+      ["durationsecond", new arrow.DurationSecond()],
+    ] as const;
+
+    it.each(allTypeNameTestCases)(
+      'should map type name "%s" to %s',
+      function (name, expected) {
+        const result = sanitizeType(name);
+        expect(result).toBeInstanceOf(expected.constructor);
+      },
+    );
+
+    const caseVariationTestCases = [
+      ["NULL", new arrow.Null()],
+      ["Utf8", new arrow.Utf8()],
+      ["FLOAT32", new arrow.Float32()],
+      ["DaTedAy", new arrow.DateDay()],
+    ] as const;
+
+    it.each(caseVariationTestCases)(
+      'should be case insensitive for type name "%s" mapped to %s',
+      function (name, expected) {
+        const result = sanitizeType(name);
+        expect(result).toBeInstanceOf(expected.constructor);
+      },
+    );
+
+    it("should throw error for unrecognized type name", function () {
+      expect(() => sanitizeType("invalid_type")).toThrow(
+        "Unrecognized type name in schema: invalid_type",
+      );
+    });
+  });
+
+  describe("sanitizeField function", function () {
+    it("should handle field with string type name", function () {
+      const field = sanitizeField({
+        name: "string_field",
+        type: "utf8",
+        nullable: true,
+        metadata: new Map([["key", "value"]]),
+      });
+
+      expect(field).toBeInstanceOf(arrow.Field);
+      expect(field.name).toBe("string_field");
+      expect(field.type).toBeInstanceOf(arrow.Utf8);
+      expect(field.nullable).toBe(true);
+      expect(field.metadata?.get("key")).toBe("value");
+    });
+
+    it("should handle field with type object", function () {
+      const floatType = {
+        typeId: 3, // Float
+        precision: 32,
+      };
+
+      const field = sanitizeField({
+        name: "float_field",
+        type: floatType,
+        nullable: false,
+      });
+
+      expect(field).toBeInstanceOf(arrow.Field);
+      expect(field.name).toBe("float_field");
+      expect(field.type).toBeInstanceOf(arrow.DataType);
+      expect(field.type.typeId).toBe(arrow.Type.Float);
+      expect((field.type as arrow.Float64).precision).toBe(32);
+      expect(field.nullable).toBe(false);
+    });
+
+    it("should handle field with direct Type instance", function () {
+      const field = sanitizeField({
+        name: "bool_field",
+        type: new arrow.Bool(),
+        nullable: true,
+      });
+
+      expect(field).toBeInstanceOf(arrow.Field);
+      expect(field.name).toBe("bool_field");
+      expect(field.type).toBeInstanceOf(arrow.Bool);
+      expect(field.nullable).toBe(true);
+    });
+
+    it("should throw error for invalid field object", function () {
+      expect(() =>
+        sanitizeField({
+          type: "int32",
+          nullable: true,
+        }),
+      ).toThrow(
+        "The field passed in is missing a `type`/`name`/`nullable` property",
+      );
+
+      // Invalid type
+      expect(() =>
+        sanitizeField({
+          name: "invalid",
+          type: { invalid: true },
+          nullable: true,
+        }),
+      ).toThrow("Expected a Type to have a typeId property");
+
+      // Invalid nullable
+      expect(() =>
+        sanitizeField({
+          name: "invalid_nullable",
+          type: "int32",
+          nullable: "not a boolean",
+        }),
+      ).toThrow("The field passed in had a non-boolean `nullable` property");
+    });
+
+    it("should report error for invalid type name", function () {
+      expect(() =>
+        sanitizeField({
+          name: "invalid_field",
+          type: "invalid_type",
+          nullable: true,
+        }),
+      ).toThrow(
+        "Unable to sanitize type for field: invalid_field due to error: Error: Unrecognized type name in schema: invalid_type",
+      );
+    });
+  });
+});

nodejs/__test__/table.test.ts

@@ -10,7 +10,13 @@ import * as arrow16 from "apache-arrow-16";
 import * as arrow17 from "apache-arrow-17";
 import * as arrow18 from "apache-arrow-18";
 
-import { MatchQuery, PhraseQuery, Table, connect } from "../lancedb";
+import {
+  Connection,
+  MatchQuery,
+  PhraseQuery,
+  Table,
+  connect,
+} from "../lancedb";
 import {
   Table as ArrowTable,
   Field,
@@ -21,6 +27,8 @@ import {
   Int64,
   List,
   Schema,
+  SchemaLike,
+  Type,
   Uint8,
   Utf8,
   makeArrowTable,
@@ -39,7 +47,6 @@ import {
   Operator,
   instanceOfFullTextQuery,
 } from "../lancedb/query";
-import exp = require("constants");
 
 describe.each([arrow15, arrow16, arrow17, arrow18])(
   "Given a table",
@@ -212,8 +219,7 @@ describe.each([arrow15, arrow16, arrow17, arrow18])(
       },
     );
 
-    // TODO: https://github.com/lancedb/lancedb/issues/1832
-    it.skip("should be able to omit nullable fields", async () => {
+    it("should be able to omit nullable fields", async () => {
       const db = await connect(tmpDir.name);
       const schema = new arrow.Schema([
         new arrow.Field(
@@ -237,23 +243,36 @@ describe.each([arrow15, arrow16, arrow17, arrow18])(
       await table.add([data3]);
 
       let res = await table.query().limit(10).toArray();
-      const resVector = res.map((r) => r.get("vector").toArray());
+      const resVector = res.map((r) =>
+        r.vector ? Array.from(r.vector) : null,
+      );
       expect(resVector).toEqual([null, data2.vector, data3.vector]);
-      const resItem = res.map((r) => r.get("item").toArray());
+      const resItem = res.map((r) => r.item);
       expect(resItem).toEqual(["foo", null, "bar"]);
-      const resPrice = res.map((r) => r.get("price").toArray());
+      const resPrice = res.map((r) => r.price);
       expect(resPrice).toEqual([10.0, 2.0, 3.0]);
 
       const data4 = { item: "foo" };
       // We can't omit a column if it's not nullable
-      await expect(table.add([data4])).rejects.toThrow("Invalid user input");
+      await expect(table.add([data4])).rejects.toThrow(
+        "Append with different schema",
+      );
 
       // But we can alter columns to make them nullable
       await table.alterColumns([{ path: "price", nullable: true }]);
       await table.add([data4]);
 
-      res = (await table.query().limit(10).toArray()).map((r) => r.toJSON());
-      expect(res).toEqual([data1, data2, data3, data4]);
+      res = (await table.query().limit(10).toArray()).map((r) => ({
+        ...r.toJSON(),
+        vector: r.vector ? Array.from(r.vector) : null,
+      }));
+      // Rust fills missing nullable fields with null
+      expect(res).toEqual([
+        { ...data1, vector: null },
+        { ...data2, item: null },
+        data3,
+        { ...data4, price: null, vector: null },
+      ]);
     });
 
     it("should be able to insert nullable data for non-nullable fields", async () => {
@@ -331,6 +350,43 @@ describe.each([arrow15, arrow16, arrow17, arrow18])(
       const table = await db.createTable("my_table", data);
       expect(await table.countRows()).toEqual(2);
     });
+
+    it("should allow undefined and omitted nullable vector fields", async () => {
+      // Test for the bug: can't pass undefined or omit vector column
+      const db = await connect("memory://");
+      const schema = new arrow.Schema([
+        new arrow.Field("id", new arrow.Int32(), true),
+        new arrow.Field(
+          "vector",
+          new arrow.FixedSizeList(
+            32,
+            new arrow.Field("item", new arrow.Float32(), true),
+          ),
+          true, // nullable = true
+        ),
+      ]);
+      const table = await db.createEmptyTable("test_table", schema);
+
+      // Should not throw error for undefined value
+      await table.add([{ id: 0, vector: undefined }]);
+
+      // Should not throw error for omitted field
+      await table.add([{ id: 1 }]);
+
+      // Should still work for null
+      await table.add([{ id: 2, vector: null }]);
+
+      // Should still work for actual vector
+      const testVector = new Array(32).fill(0.5);
+      await table.add([{ id: 3, vector: testVector }]);
+      expect(await table.countRows()).toEqual(4);
+
+      const res = await table.query().limit(10).toArray();
+      const resVector = res.map((r) =>
+        r.vector ? Array.from(r.vector) : null,
+      );
+      expect(resVector).toEqual([null, null, null, testVector]);
+    });
   },
 );
 
@@ -488,6 +544,32 @@ describe("merge insert", () => {
         .execute(newData, { timeoutMs: 0 }),
     ).rejects.toThrow("merge insert timed out");
   });
+
+  test("useIndex", async () => {
+    const newData = [
+      { a: 2, b: "x" },
+      { a: 4, b: "z" },
+    ];
+
+    // Test with useIndex(true) - should work fine
+    const result1 = await table
+      .mergeInsert("a")
+      .whenNotMatchedInsertAll()
+      .useIndex(true)
+      .execute(newData);
+
+    expect(result1.numInsertedRows).toBe(1); // Only a=4 should be inserted
+
+    // Test with useIndex(false) - should also work fine
+    const newData2 = [{ a: 5, b: "w" }];
+    const result2 = await table
+      .mergeInsert("a")
+      .whenNotMatchedInsertAll()
+      .useIndex(false)
+      .execute(newData2);
+
+    expect(result2.numInsertedRows).toBe(1); // a=5 should be inserted
+  });
 });
 
 describe("When creating an index", () => {
@@ -1429,7 +1511,9 @@ describe("when optimizing a dataset", () => {
 
   it("delete unverified", async () => {
     const version = await table.version();
-    const versionFile = `${tmpDir.name}/${table.name}.lance/_versions/${version - 1}.manifest`;
+    const versionFile = `${tmpDir.name}/${table.name}.lance/_versions/${
+      version - 1
+    }.manifest`;
     fs.rmSync(versionFile);
 
     let stats = await table.optimize({ deleteUnverified: false });
@@ -1943,3 +2027,52 @@ describe("column name options", () => {
     expect(results2.length).toBe(10);
   });
 });
+
+describe("when creating an empty table", () => {
+  let con: Connection;
+  beforeEach(async () => {
+    const tmpDir = tmp.dirSync({ unsafeCleanup: true });
+    con = await connect(tmpDir.name);
+  });
+  afterEach(() => {
+    con.close();
+  });
+
+  it("can create an empty table from an arrow Schema", async () => {
+    const schema = new Schema([
+      new Field("id", new Int64()),
+      new Field("vector", new Float64()),
+    ]);
+    const table = await con.createEmptyTable("test", schema);
+    const actualSchema = await table.schema();
+    expect(actualSchema.fields[0].type.typeId).toBe(Type.Int);
+    expect((actualSchema.fields[0].type as Int64).bitWidth).toBe(64);
+    expect(actualSchema.fields[1].type.typeId).toBe(Type.Float);
+    expect((actualSchema.fields[1].type as Float64).precision).toBe(2);
+  });
+
+  it("can create an empty table from schema that specifies field types by name", async () => {
+    const schemaLike = {
+      fields: [
+        {
+          name: "id",
+          type: "int64",
+          nullable: true,
+        },
+        {
+          name: "vector",
+          type: "float64",
+          nullable: true,
+        },
+      ],
+      metadata: new Map(),
+      names: ["id", "vector"],
+    } satisfies SchemaLike;
+    const table = await con.createEmptyTable("test", schemaLike);
+    const actualSchema = await table.schema();
+    expect(actualSchema.fields[0].type.typeId).toBe(Type.Int);
+    expect((actualSchema.fields[0].type as Int64).bitWidth).toBe(64);
+    expect(actualSchema.fields[1].type.typeId).toBe(Type.Float);
+    expect((actualSchema.fields[1].type as Float64).precision).toBe(2);
+  });
+});

nodejs/biome.json

@@ -48,6 +48,7 @@
         "noUnreachableSuper": "error",
         "noUnsafeFinally": "error",
         "noUnsafeOptionalChaining": "error",
+        "noUnusedImports": "error",
         "noUnusedLabels": "error",
         "noUnusedVariables": "warn",
         "useIsNan": "error",

nodejs/lancedb/arrow.ts

@@ -41,7 +41,6 @@ import {
   vectorFromArray as badVectorFromArray,
   makeBuilder,
   makeData,
-  makeTable,
 } from "apache-arrow";
 import { Buffers } from "apache-arrow/data";
 import { type EmbeddingFunction } from "./embedding/embedding_function";
@@ -74,7 +73,7 @@ export type FieldLike =
   | {
       type: string;
       name: string;
-      nullable?: boolean;
+      nullable: boolean;
       metadata?: Map<string, string>;
     };
 
@@ -279,7 +278,7 @@ export class MakeArrowTableOptions {
 }
 
 /**
- * An enhanced version of the {@link makeTable} function from Apache Arrow
+ * An enhanced version of the apache-arrow makeTable function from Apache Arrow
  * that supports nested fields and embeddings columns.
  *
  * (typically you do not need to call this function.  It will be called automatically
@@ -512,7 +511,11 @@ function* rowPathsAndValues(
     if (isObject(value)) {
       yield* rowPathsAndValues(value, [...basePath, key]);
     } else {
-      yield [[...basePath, key], value];
+      // Skip undefined values - they should be treated the same as missing fields
+      // for embedding function purposes
+      if (value !== undefined) {
+        yield [[...basePath, key], value];
+      }
     }
   }
 }
@@ -701,7 +704,7 @@ function transposeData(
       }
       return current;
     });
-    return makeVector(values, field.type);
+    return makeVector(values, field.type, undefined, field.nullable);
   }
 }
 
@@ -748,9 +751,30 @@ function makeVector(
   values: unknown[],
   type?: DataType,
   stringAsDictionary?: boolean,
+  nullable?: boolean,
   // biome-ignore lint/suspicious/noExplicitAny: skip
 ): Vector<any> {
   if (type !== undefined) {
+    // Convert undefined values to null for nullable fields
+    if (nullable) {
+      values = values.map((v) => (v === undefined ? null : v));
+    }
+
+    // workaround for: https://github.com/apache/arrow-js/issues/68
+    if (DataType.isBool(type)) {
+      const hasNonNullValue = values.some((v) => v !== null && v !== undefined);
+      if (!hasNonNullValue) {
+        const nullBitmap = new Uint8Array(Math.ceil(values.length / 8));
+        const data = makeData({
+          type: type,
+          length: values.length,
+          nullCount: values.length,
+          nullBitmap,
+        });
+        return arrowMakeVector(data);
+      }
+    }
+
     // No need for inference, let Arrow create it
     if (type instanceof Int) {
       if (DataType.isInt(type) && type.bitWidth === 64) {
@@ -875,7 +899,12 @@ async function applyEmbeddingsFromMetadata(
   for (const field of schema.fields) {
     if (!(field.name in columns)) {
       const nullValues = new Array(table.numRows).fill(null);
-      columns[field.name] = makeVector(nullValues, field.type);
+      columns[field.name] = makeVector(
+        nullValues,
+        field.type,
+        undefined,
+        field.nullable,
+      );
     }
   }
 
@@ -939,7 +968,12 @@ async function applyEmbeddings<T>(
     } else if (schema != null) {
       const destField = schema.fields.find((f) => f.name === destColumn);
       if (destField != null) {
-        newColumns[destColumn] = makeVector([], destField.type);
+        newColumns[destColumn] = makeVector(
+          [],
+          destField.type,
+          undefined,
+          destField.nullable,
+        );
       } else {
         throw new Error(
           `Attempt to apply embeddings to an empty table failed because schema was missing embedding column '${destColumn}'`,
@@ -1251,19 +1285,36 @@ function validateSchemaEmbeddings(
     if (isFixedSizeList(field.type)) {
       field = sanitizeField(field);
       if (data.length !== 0 && data?.[0]?.[field.name] === undefined) {
+        // Check if there's an embedding function registered for this field
+        let hasEmbeddingFunction = false;
+
+        // Check schema metadata for embedding functions
         if (schema.metadata.has("embedding_functions")) {
           const embeddings = JSON.parse(
             schema.metadata.get("embedding_functions")!,
           );
-          if (
-            // biome-ignore lint/suspicious/noExplicitAny: we don't know the type of `f`
-            embeddings.find((f: any) => f["vectorColumn"] === field.name) ===
-            undefined
-          ) {
+          // biome-ignore lint/suspicious/noExplicitAny: we don't know the type of `f`
+          if (embeddings.find((f: any) => f["vectorColumn"] === field.name)) {
+            hasEmbeddingFunction = true;
+          }
+        }
+
+        // Check passed embedding function parameter
+        if (embeddings && embeddings.vectorColumn === field.name) {
+          hasEmbeddingFunction = true;
+        }
+
+        // If the field is nullable AND there's no embedding function, allow undefined/omitted values
+        if (field.nullable && !hasEmbeddingFunction) {
+          fields.push(field);
+        } else {
+          // Either not nullable OR has embedding function - require explicit values
+          if (hasEmbeddingFunction) {
+            // Don't add to missingEmbeddingFields since this is expected to be filled by embedding function
+            fields.push(field);
+          } else {
             missingEmbeddingFields.push(field);
           }
-        } else {
-          missingEmbeddingFields.push(field);
         }
       } else {
         fields.push(field);

nodejs/lancedb/connection.ts

@@ -3,7 +3,6 @@
 
 import {
   Data,
-  Schema,
   SchemaLike,
   TableLike,
   fromTableToStreamBuffer,
@@ -268,6 +267,33 @@ export abstract class Connection {
    * @param {string[]} namespace The namespace to drop tables from (defaults to root namespace).
    */
   abstract dropAllTables(namespace?: string[]): Promise<void>;
+
+  /**
+   * Clone a table from a source table.
+   *
+   * A shallow clone creates a new table that shares the underlying data files
+   * with the source table but has its own independent manifest. This allows
+   * both the source and cloned tables to evolve independently while initially
+   * sharing the same data, deletion, and index files.
+   *
+   * @param {string} targetTableName - The name of the target table to create.
+   * @param {string} sourceUri - The URI of the source table to clone from.
+   * @param {object} options - Clone options.
+   * @param {string[]} options.targetNamespace - The namespace for the target table (defaults to root namespace).
+   * @param {number} options.sourceVersion - The version of the source table to clone.
+   * @param {string} options.sourceTag - The tag of the source table to clone.
+   * @param {boolean} options.isShallow - Whether to perform a shallow clone (defaults to true).
+   */
+  abstract cloneTable(
+    targetTableName: string,
+    sourceUri: string,
+    options?: {
+      targetNamespace?: string[];
+      sourceVersion?: number;
+      sourceTag?: string;
+      isShallow?: boolean;
+    },
+  ): Promise<Table>;
 }
 
 /** @hideconstructor */
@@ -332,6 +358,28 @@ export class LocalConnection extends Connection {
     return new LocalTable(innerTable);
   }
 
+  async cloneTable(
+    targetTableName: string,
+    sourceUri: string,
+    options?: {
+      targetNamespace?: string[];
+      sourceVersion?: number;
+      sourceTag?: string;
+      isShallow?: boolean;
+    },
+  ): Promise<Table> {
+    const innerTable = await this.inner.cloneTable(
+      targetTableName,
+      sourceUri,
+      options?.targetNamespace ?? [],
+      options?.sourceVersion ?? null,
+      options?.sourceTag ?? null,
+      options?.isShallow ?? true,
+    );
+
+    return new LocalTable(innerTable);
+  }
+
   private getStorageOptions(
     options?: Partial<CreateTableOptions>,
   ): Record<string, string> | undefined {

nodejs/lancedb/header.ts

@@ -0,0 +1,253 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright The LanceDB Authors
+
+/**
+ * Header providers for LanceDB remote connections.
+ *
+ * This module provides a flexible header management framework for LanceDB remote
+ * connections, allowing users to implement custom header strategies for
+ * authentication, request tracking, custom metadata, or any other header-based
+ * requirements.
+ *
+ * @module header
+ */
+
+/**
+ * Abstract base class for providing custom headers for each request.
+ *
+ * Users can implement this interface to provide dynamic headers for various purposes
+ * such as authentication (OAuth tokens, API keys), request tracking (correlation IDs),
+ * custom metadata, or any other header-based requirements. The provider is called
+ * before each request to ensure fresh header values are always used.
+ *
+ * @example
+ * Simple JWT token provider:
+ * ```typescript
+ * class JWTProvider extends HeaderProvider {
+ *   constructor(private token: string) {
+ *     super();
+ *   }
+ *
+ *   getHeaders(): Record<string, string> {
+ *     return { authorization: `Bearer ${this.token}` };
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * Provider with request tracking:
+ * ```typescript
+ * class RequestTrackingProvider extends HeaderProvider {
+ *   constructor(private sessionId: string) {
+ *     super();
+ *   }
+ *
+ *   getHeaders(): Record<string, string> {
+ *     return {
+ *       "X-Session-Id": this.sessionId,
+ *       "X-Request-Id": `req-${Date.now()}`
+ *     };
+ *   }
+ * }
+ * ```
+ */
+export abstract class HeaderProvider {
+  /**
+   * Get the latest headers to be added to requests.
+   *
+   * This method is called before each request to the remote LanceDB server.
+   * Implementations should return headers that will be merged with existing headers.
+   *
+   * @returns Dictionary of header names to values to add to the request.
+   * @throws If unable to fetch headers, the exception will be propagated and the request will fail.
+   */
+  abstract getHeaders(): Record<string, string>;
+}
+
+/**
+ * Example implementation: A simple header provider that returns static headers.
+ *
+ * This is an example implementation showing how to create a HeaderProvider
+ * for cases where headers don't change during the session.
+ *
+ * @example
+ * ```typescript
+ * const provider = new StaticHeaderProvider({
+ *   authorization: "Bearer my-token",
+ *   "X-Custom-Header": "custom-value"
+ * });
+ * const headers = provider.getHeaders();
+ * // Returns: {authorization: 'Bearer my-token', 'X-Custom-Header': 'custom-value'}
+ * ```
+ */
+export class StaticHeaderProvider extends HeaderProvider {
+  private _headers: Record<string, string>;
+
+  /**
+   * Initialize with static headers.
+   * @param headers - Headers to return for every request.
+   */
+  constructor(headers: Record<string, string>) {
+    super();
+    this._headers = { ...headers };
+  }
+
+  /**
+   * Return the static headers.
+   * @returns Copy of the static headers.
+   */
+  getHeaders(): Record<string, string> {
+    return { ...this._headers };
+  }
+}
+
+/**
+ * Token response from OAuth provider.
+ * @public
+ */
+export interface TokenResponse {
+  accessToken: string;
+  expiresIn?: number;
+}
+
+/**
+ * Example implementation: OAuth token provider with automatic refresh.
+ *
+ * This is an example implementation showing how to manage OAuth tokens
+ * with automatic refresh when they expire.
+ *
+ * @example
+ * ```typescript
+ * async function fetchToken(): Promise<TokenResponse> {
+ *   const response = await fetch("https://oauth.example.com/token", {
+ *     method: "POST",
+ *     body: JSON.stringify({
+ *       grant_type: "client_credentials",
+ *       client_id: "your-client-id",
+ *       client_secret: "your-client-secret"
+ *     }),
+ *     headers: { "Content-Type": "application/json" }
+ *   });
+ *   const data = await response.json();
+ *   return {
+ *     accessToken: data.access_token,
+ *     expiresIn: data.expires_in
+ *   };
+ * }
+ *
+ * const provider = new OAuthHeaderProvider(fetchToken);
+ * const headers = provider.getHeaders();
+ * // Returns: {"authorization": "Bearer <your-token>"}
+ * ```
+ */
+export class OAuthHeaderProvider extends HeaderProvider {
+  private _tokenFetcher: () => Promise<TokenResponse> | TokenResponse;
+  private _refreshBufferSeconds: number;
+  private _currentToken: string | null = null;
+  private _tokenExpiresAt: number | null = null;
+  private _refreshPromise: Promise<void> | null = null;
+
+  /**
+   * Initialize the OAuth provider.
+   * @param tokenFetcher - Function to fetch new tokens. Should return object with 'accessToken' and optionally 'expiresIn'.
+   * @param refreshBufferSeconds - Seconds before expiry to refresh token. Default 300 (5 minutes).
+   */
+  constructor(
+    tokenFetcher: () => Promise<TokenResponse> | TokenResponse,
+    refreshBufferSeconds: number = 300,
+  ) {
+    super();
+    this._tokenFetcher = tokenFetcher;
+    this._refreshBufferSeconds = refreshBufferSeconds;
+  }
+
+  /**
+   * Check if token needs refresh.
+   */
+  private _needsRefresh(): boolean {
+    if (this._currentToken === null) {
+      return true;
+    }
+
+    if (this._tokenExpiresAt === null) {
+      // No expiration info, assume token is valid
+      return false;
+    }
+
+    // Refresh if we're within the buffer time of expiration
+    const now = Date.now() / 1000;
+    return now >= this._tokenExpiresAt - this._refreshBufferSeconds;
+  }
+
+  /**
+   * Refresh the token if it's expired or close to expiring.
+   */
+  private async _refreshTokenIfNeeded(): Promise<void> {
+    if (!this._needsRefresh()) {
+      return;
+    }
+
+    // If refresh is already in progress, wait for it
+    if (this._refreshPromise) {
+      await this._refreshPromise;
+      return;
+    }
+
+    // Start refresh
+    this._refreshPromise = (async () => {
+      try {
+        const tokenData = await this._tokenFetcher();
+
+        this._currentToken = tokenData.accessToken;
+        if (!this._currentToken) {
+          throw new Error("Token fetcher did not return 'accessToken'");
+        }
+
+        // Set expiration if provided
+        if (tokenData.expiresIn) {
+          this._tokenExpiresAt = Date.now() / 1000 + tokenData.expiresIn;
+        } else {
+          // Token doesn't expire or expiration unknown
+          this._tokenExpiresAt = null;
+        }
+      } finally {
+        this._refreshPromise = null;
+      }
+    })();
+
+    await this._refreshPromise;
+  }
+
+  /**
+   * Get OAuth headers, refreshing token if needed.
+   * Note: This is synchronous for now as the Rust implementation expects sync.
+   * In a real implementation, this would need to handle async properly.
+   * @returns Headers with Bearer token authorization.
+   * @throws If unable to fetch or refresh token.
+   */
+  getHeaders(): Record<string, string> {
+    // For simplicity in this example, we assume the token is already fetched
+    // In a real implementation, this would need to handle the async nature properly
+    if (!this._currentToken && !this._refreshPromise) {
+      // Synchronously trigger refresh - this is a limitation of the current implementation
+      throw new Error(
+        "Token not initialized. Call refreshToken() first or use async initialization.",
+      );
+    }
+
+    if (!this._currentToken) {
+      throw new Error("Failed to obtain OAuth token");
+    }
+
+    return { authorization: `Bearer ${this._currentToken}` };
+  }
+
+  /**
+   * Manually refresh the token.
+   * Call this before using getHeaders() to ensure token is available.
+   */
+  async refreshToken(): Promise<void> {
+    this._currentToken = null; // Force refresh
+    await this._refreshTokenIfNeeded();
+  }
+}

nodejs/lancedb/index.ts

@@ -10,9 +10,15 @@ import {
 import {
   ConnectionOptions,
   Connection as LanceDbConnection,
+  JsHeaderProvider as NativeJsHeaderProvider,
   Session,
 } from "./native.js";
 
+import { HeaderProvider } from "./header";
+
+// Re-export native header provider for use with connectWithHeaderProvider
+export { JsHeaderProvider as NativeJsHeaderProvider } from "./native.js";
+
 export {
   AddColumnsSql,
   ConnectionOptions,
@@ -21,6 +27,7 @@ export {
   ClientConfig,
   TimeoutConfig,
   RetryConfig,
+  TlsConfig,
   OptimizeStats,
   CompactionStats,
   RemovalStats,
@@ -93,6 +100,13 @@ export {
   ColumnAlteration,
 } from "./table";
 
+export {
+  HeaderProvider,
+  StaticHeaderProvider,
+  OAuthHeaderProvider,
+  TokenResponse,
+} from "./header";
+
 export { MergeInsertBuilder, WriteExecutionOptions } from "./merge";
 
 export * as embedding from "./embedding";
@@ -131,11 +145,27 @@ export { IntoSql, packBits } from "./util";
  *   {storageOptions: {timeout: "60s"}
  * });
  * ```
+ * @example
+ * Using with a header provider for per-request authentication:
+ * ```ts
+ * const provider = new StaticHeaderProvider({
+ *   "X-API-Key": "my-key"
+ * });
+ * const conn = await connectWithHeaderProvider(
+ *   "db://host:port",
+ *   options,
+ *   provider
+ * );
+ * ```
  */
 export async function connect(
   uri: string,
   options?: Partial<ConnectionOptions>,
   session?: Session,
+  headerProvider?:
+    | HeaderProvider
+    | (() => Record<string, string>)
+    | (() => Promise<Record<string, string>>),
 ): Promise<Connection>;
 /**
  * Connect to a LanceDB instance at the given URI.
@@ -169,18 +199,58 @@ export async function connect(
 ): Promise<Connection>;
 export async function connect(
   uriOrOptions: string | (Partial<ConnectionOptions> & { uri: string }),
-  options?: Partial<ConnectionOptions>,
+  optionsOrSession?: Partial<ConnectionOptions> | Session,
+  sessionOrHeaderProvider?:
+    | Session
+    | HeaderProvider
+    | (() => Record<string, string>)
+    | (() => Promise<Record<string, string>>),
+  headerProvider?:
+    | HeaderProvider
+    | (() => Record<string, string>)
+    | (() => Promise<Record<string, string>>),
 ): Promise<Connection> {
   let uri: string | undefined;
   let finalOptions: Partial<ConnectionOptions> = {};
+  let finalHeaderProvider:
+    | HeaderProvider
+    | (() => Record<string, string>)
+    | (() => Promise<Record<string, string>>)
+    | undefined;
 
   if (typeof uriOrOptions !== "string") {
+    // First overload: connect(options)
     const { uri: uri_, ...opts } = uriOrOptions;
     uri = uri_;
     finalOptions = opts;
   } else {
+    // Second overload: connect(uri, options?, session?, headerProvider?)
     uri = uriOrOptions;
-    finalOptions = options || {};
+
+    // Handle optionsOrSession parameter
+    if (optionsOrSession && "inner" in optionsOrSession) {
+      // Second param is session, so no options provided
+      finalOptions = {};
+    } else {
+      // Second param is options
+      finalOptions = (optionsOrSession as Partial<ConnectionOptions>) || {};
+    }
+
+    // Handle sessionOrHeaderProvider parameter
+    if (
+      sessionOrHeaderProvider &&
+      (typeof sessionOrHeaderProvider === "function" ||
+        "getHeaders" in sessionOrHeaderProvider)
+    ) {
+      // Third param is header provider
+      finalHeaderProvider = sessionOrHeaderProvider as
+        | HeaderProvider
+        | (() => Record<string, string>)
+        | (() => Promise<Record<string, string>>);
+    } else {
+      // Third param is session, header provider is fourth param
+      finalHeaderProvider = headerProvider;
+    }
   }
 
   if (!uri) {
@@ -191,6 +261,26 @@ export async function connect(
   (<ConnectionOptions>finalOptions).storageOptions = cleanseStorageOptions(
     (<ConnectionOptions>finalOptions).storageOptions,
   );
-  const nativeConn = await LanceDbConnection.new(uri, finalOptions);
+
+  // Create native header provider if one was provided
+  let nativeProvider: NativeJsHeaderProvider | undefined;
+  if (finalHeaderProvider) {
+    if (typeof finalHeaderProvider === "function") {
+      nativeProvider = new NativeJsHeaderProvider(finalHeaderProvider);
+    } else if (
+      finalHeaderProvider &&
+      typeof finalHeaderProvider.getHeaders === "function"
+    ) {
+      nativeProvider = new NativeJsHeaderProvider(async () =>
+        finalHeaderProvider.getHeaders(),
+      );
+    }
+  }
+
+  const nativeConn = await LanceDbConnection.new(
+    uri,
+    finalOptions,
+    nativeProvider,
+  );
   return new LocalConnection(nativeConn);
 }

nodejs/lancedb/merge.ts

@@ -70,6 +70,23 @@ export class MergeInsertBuilder {
       this.#schema,
     );
   }
+
+  /**
+   * Controls whether to use indexes for the merge operation.
+   *
+   * When set to `true` (the default), the operation will use an index if available
+   * on the join key for improved performance. When set to `false`, it forces a full
+   * table scan even if an index exists. This can be useful for benchmarking or when
+   * the query optimizer chooses a suboptimal path.
+   *
+   * @param useIndex - Whether to use indices for the merge operation. Defaults to `true`.
+   */
+  useIndex(useIndex: boolean): MergeInsertBuilder {
+    return new MergeInsertBuilder(
+      this.#native.useIndex(useIndex),
+      this.#schema,
+    );
+  }
   /**
    * Executes the merge insert operation
    *

nodejs/lancedb/sanitize.ts

@@ -326,6 +326,9 @@ export function sanitizeDictionary(typeLike: object) {
 
 // biome-ignore lint/suspicious/noExplicitAny: skip
 export function sanitizeType(typeLike: unknown): DataType<any> {
+  if (typeof typeLike === "string") {
+    return dataTypeFromName(typeLike);
+  }
   if (typeof typeLike !== "object" || typeLike === null) {
     throw Error("Expected a Type but object was null/undefined");
   }
@@ -447,7 +450,7 @@ export function sanitizeType(typeLike: unknown): DataType<any> {
     case Type.DurationSecond:
       return new DurationSecond();
     default:
-      throw new Error("Unrecoginized type id in schema: " + typeId);
+      throw new Error("Unrecognized type id in schema: " + typeId);
   }
 }
 
@@ -467,7 +470,15 @@ export function sanitizeField(fieldLike: unknown): Field {
       "The field passed in is missing a `type`/`name`/`nullable` property",
     );
   }
-  const type = sanitizeType(fieldLike.type);
+  let type: DataType;
+  try {
+    type = sanitizeType(fieldLike.type);
+  } catch (error: unknown) {
+    throw Error(
+      `Unable to sanitize type for field: ${fieldLike.name} due to error: ${error}`,
+      { cause: error },
+    );
+  }
   const name = fieldLike.name;
   if (!(typeof name === "string")) {
     throw Error("The field passed in had a non-string `name` property");
@@ -581,3 +592,46 @@ function sanitizeData(
     },
   );
 }
+
+const constructorsByTypeName = {
+  null: () => new Null(),
+  binary: () => new Binary(),
+  utf8: () => new Utf8(),
+  bool: () => new Bool(),
+  int8: () => new Int8(),
+  int16: () => new Int16(),
+  int32: () => new Int32(),
+  int64: () => new Int64(),
+  uint8: () => new Uint8(),
+  uint16: () => new Uint16(),
+  uint32: () => new Uint32(),
+  uint64: () => new Uint64(),
+  float16: () => new Float16(),
+  float32: () => new Float32(),
+  float64: () => new Float64(),
+  datemillisecond: () => new DateMillisecond(),
+  dateday: () => new DateDay(),
+  timenanosecond: () => new TimeNanosecond(),
+  timemicrosecond: () => new TimeMicrosecond(),
+  timemillisecond: () => new TimeMillisecond(),
+  timesecond: () => new TimeSecond(),
+  intervaldaytime: () => new IntervalDayTime(),
+  intervalyearmonth: () => new IntervalYearMonth(),
+  durationnanosecond: () => new DurationNanosecond(),
+  durationmicrosecond: () => new DurationMicrosecond(),
+  durationmillisecond: () => new DurationMillisecond(),
+  durationsecond: () => new DurationSecond(),
+} as const;
+
+type MappableTypeName = keyof typeof constructorsByTypeName;
+
+export function dataTypeFromName(typeName: string): DataType {
+  const normalizedTypeName = typeName.toLowerCase() as MappableTypeName;
+  const _constructor = constructorsByTypeName[normalizedTypeName];
+
+  if (!_constructor) {
+    throw new Error("Unrecognized type name in schema: " + typeName);
+  }
+
+  return _constructor();
+}

nodejs/npm/darwin-arm64/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@lancedb/lancedb-darwin-arm64",
-	"version": "0.22.0-beta.1",
+	"version": "0.22.2-beta.2",
 	"os": ["darwin"],
 	"cpu": ["arm64"],
 	"main": "lancedb.darwin-arm64.node",

nodejs/npm/darwin-x64/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@lancedb/lancedb-darwin-x64",
-	"version": "0.22.0-beta.1",
+	"version": "0.22.2-beta.2",
 	"os": ["darwin"],
 	"cpu": ["x64"],
 	"main": "lancedb.darwin-x64.node",

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

@@ -1,6 +1,6 @@
 {
 	"name": "@lancedb/lancedb-linux-arm64-gnu",
-	"version": "0.22.0-beta.1",
+	"version": "0.22.2-beta.2",
 	"os": ["linux"],
 	"cpu": ["arm64"],
 	"main": "lancedb.linux-arm64-gnu.node",

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

@@ -1,6 +1,6 @@
 {
 	"name": "@lancedb/lancedb-linux-arm64-musl",
-	"version": "0.22.0-beta.1",
+	"version": "0.22.2-beta.2",
 	"os": ["linux"],
 	"cpu": ["arm64"],
 	"main": "lancedb.linux-arm64-musl.node",

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

@@ -1,6 +1,6 @@
 {
 	"name": "@lancedb/lancedb-linux-x64-gnu",
-	"version": "0.22.0-beta.1",
+	"version": "0.22.2-beta.2",
 	"os": ["linux"],
 	"cpu": ["x64"],
 	"main": "lancedb.linux-x64-gnu.node",

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

@@ -1,6 +1,6 @@
 {
 	"name": "@lancedb/lancedb-linux-x64-musl",
-	"version": "0.22.0-beta.1",
+	"version": "0.22.2-beta.2",
 	"os": ["linux"],
 	"cpu": ["x64"],
 	"main": "lancedb.linux-x64-musl.node",

nodejs/npm/win32-arm64-msvc/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lancedb/lancedb-win32-arm64-msvc",
-  "version": "0.22.0-beta.1",
+  "version": "0.22.2-beta.2",
   "os": [
     "win32"
   ],

nodejs/npm/win32-x64-msvc/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@lancedb/lancedb-win32-x64-msvc",
-	"version": "0.22.0-beta.1",
+	"version": "0.22.2-beta.2",
 	"os": ["win32"],
 	"cpu": ["x64"],
 	"main": "lancedb.win32-x64-msvc.node",

nodejs/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@lancedb/lancedb",
-  "version": "0.22.0-beta.1",
+  "version": "0.22.2-beta.2",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@lancedb/lancedb",
-      "version": "0.22.0-beta.1",
+      "version": "0.22.2-beta.2",
       "cpu": [
         "x64",
         "arm64"
@@ -5549,10 +5549,11 @@
       "dev": true
     },
     "node_modules/brace-expansion": {
-      "version": "1.1.11",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
-      "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
+      "version": "1.1.12",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz",
+      "integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",
       "dev": true,
+      "license": "MIT",
       "dependencies": {
         "balanced-match": "^1.0.0",
         "concat-map": "0.0.1"
@@ -5629,6 +5630,20 @@
       "integrity": "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==",
       "dev": true
     },
+    "node_modules/call-bind-apply-helpers": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.2.tgz",
+      "integrity": "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==",
+      "devOptional": true,
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "function-bind": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
     "node_modules/camelcase": {
       "version": "5.3.1",
       "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-5.3.1.tgz",
@@ -6032,6 +6047,21 @@
         "node": ">=6.0.0"
       }
     },
+    "node_modules/dunder-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz",
+      "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==",
+      "devOptional": true,
+      "license": "MIT",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "gopd": "^1.2.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
     "node_modules/eastasianwidth": {
       "version": "0.2.0",
       "resolved": "https://registry.npmjs.org/eastasianwidth/-/eastasianwidth-0.2.0.tgz",
@@ -6071,6 +6101,55 @@
         "is-arrayish": "^0.2.1"
       }
     },
+    "node_modules/es-define-property": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz",
+      "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==",
+      "devOptional": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-errors": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz",
+      "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==",
+      "devOptional": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-object-atoms": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.1.1.tgz",
+      "integrity": "sha512-FGgH2h8zKNim9ljj7dankFPcICIK9Cp5bm+c2gQSYePhpaG5+esrLODihIorn+Pe6FGJzWhXQotPv73jTaldXA==",
+      "devOptional": true,
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-set-tostringtag": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/es-set-tostringtag/-/es-set-tostringtag-2.1.0.tgz",
+      "integrity": "sha512-j6vWzfrGVfyXxge+O0x5sh6cvxAog0a/4Rdd2K36zCMV5eJ+/+tOAngRO8cODMNWbVRdVlmGZQL2YS3yR8bIUA==",
+      "devOptional": true,
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.6",
+        "has-tostringtag": "^1.0.2",
+        "hasown": "^2.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
     "node_modules/escalade": {
       "version": "3.1.1",
       "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.1.1.tgz",
@@ -6510,13 +6589,16 @@
       }
     },
     "node_modules/form-data": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.0.tgz",
-      "integrity": "sha512-ETEklSGi5t0QMZuiXoA/Q6vcnxcLQP5vdugSpuAyi6SVGi2clPPp+xgEhuMaHC+zGgn31Kd235W35f7Hykkaww==",
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.4.tgz",
+      "integrity": "sha512-KrGhL9Q4zjj0kiUt5OO4Mr/A/jlI2jDYs5eHBpYHPcBEVSiipAvn2Ko2HnPe20rmcuuvMHNdZFp+4IlGTMF0Ow==",
       "devOptional": true,
+      "license": "MIT",
       "dependencies": {
         "asynckit": "^0.4.0",
         "combined-stream": "^1.0.8",
+        "es-set-tostringtag": "^2.1.0",
+        "hasown": "^2.0.2",
         "mime-types": "^2.1.12"
       },
       "engines": {
@@ -6575,7 +6657,7 @@
       "version": "1.1.2",
       "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
       "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==",
-      "dev": true,
+      "devOptional": true,
       "funding": {
         "url": "https://github.com/sponsors/ljharb"
       }
@@ -6598,6 +6680,31 @@
         "node": "6.* || 8.* || >= 10.*"
       }
     },
+    "node_modules/get-intrinsic": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.3.0.tgz",
+      "integrity": "sha512-9fSjSaos/fRIVIp+xSJlE6lfwhES7LNtKaCBIamHsjr2na1BiABJPo0mOjjz8GJDURarmCPGqaiVg5mfjb98CQ==",
+      "devOptional": true,
+      "license": "MIT",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.2",
+        "es-define-property": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "es-object-atoms": "^1.1.1",
+        "function-bind": "^1.1.2",
+        "get-proto": "^1.0.1",
+        "gopd": "^1.2.0",
+        "has-symbols": "^1.1.0",
+        "hasown": "^2.0.2",
+        "math-intrinsics": "^1.1.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
     "node_modules/get-package-type": {
       "version": "0.1.0",
       "resolved": "https://registry.npmjs.org/get-package-type/-/get-package-type-0.1.0.tgz",
@@ -6607,6 +6714,20 @@
         "node": ">=8.0.0"
       }
     },
+    "node_modules/get-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/get-proto/-/get-proto-1.0.1.tgz",
+      "integrity": "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g==",
+      "devOptional": true,
+      "license": "MIT",
+      "dependencies": {
+        "dunder-proto": "^1.0.1",
+        "es-object-atoms": "^1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
     "node_modules/get-stream": {
       "version": "6.0.1",
       "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-6.0.1.tgz",
@@ -6698,6 +6819,19 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/gopd": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz",
+      "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==",
+      "devOptional": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
     "node_modules/graceful-fs": {
       "version": "4.2.11",
       "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz",
@@ -6724,11 +6858,41 @@
         "node": ">=8"
       }
     },
+    "node_modules/has-symbols": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz",
+      "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==",
+      "devOptional": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/has-tostringtag": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/has-tostringtag/-/has-tostringtag-1.0.2.tgz",
+      "integrity": "sha512-NqADB8VjPFLM2V0VvHUewwwsw0ZWBaIdgo+ieHtK3hasLz4qeCRjYcqfB6AQrBggRKppKF8L52/VqdVsO47Dlw==",
+      "devOptional": true,
+      "license": "MIT",
+      "dependencies": {
+        "has-symbols": "^1.0.3"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
     "node_modules/hasown": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.0.tgz",
-      "integrity": "sha512-vUptKVTpIJhcczKBbgnS+RtcuYMB8+oNzPK2/Hp3hanz8JmpATdmmgLgSaadVREkDm+e2giHwY3ZRkyjSIDDFA==",
-      "dev": true,
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz",
+      "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==",
+      "devOptional": true,
+      "license": "MIT",
       "dependencies": {
         "function-bind": "^1.1.2"
       },
@@ -7943,6 +8107,16 @@
       "integrity": "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q==",
       "dev": true
     },
+    "node_modules/math-intrinsics": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
+      "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==",
+      "devOptional": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
     "node_modules/md5": {
       "version": "2.3.0",
       "resolved": "https://registry.npmjs.org/md5/-/md5-2.3.0.tgz",
@@ -8053,9 +8227,10 @@
       }
     },
     "node_modules/minizlib/node_modules/brace-expansion": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz",
-      "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==",
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.2.tgz",
+      "integrity": "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ==",
+      "license": "MIT",
       "optional": true,
       "dependencies": {
         "balanced-match": "^1.0.0"
@@ -9201,10 +9376,11 @@
       "dev": true
     },
     "node_modules/tmp": {
-      "version": "0.2.3",
-      "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.2.3.tgz",
-      "integrity": "sha512-nZD7m9iCPC5g0pYmcaxogYKggSfLsdxl8of3Q/oIbqCqLLIO9IAF0GWjX1z9NZRHPiXv8Wex4yDCaZsgEw0Y8w==",
+      "version": "0.2.5",
+      "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.2.5.tgz",
+      "integrity": "sha512-voyz6MApa1rQGUxT3E+BK7/ROe8itEx7vD8/HEvt4xwXucvQ5G5oeEiHkmHZJuBO21RpOf+YYm9MOivj709jow==",
       "dev": true,
+      "license": "MIT",
       "engines": {
         "node": ">=14.14"
       }
@@ -9349,10 +9525,11 @@
       }
     },
     "node_modules/typedoc/node_modules/brace-expansion": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz",
-      "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==",
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.2.tgz",
+      "integrity": "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ==",
       "dev": true,
+      "license": "MIT",
       "dependencies": {
         "balanced-match": "^1.0.0"
       }
@@ -9602,10 +9779,11 @@
       }
     },
     "node_modules/typescript-eslint/node_modules/brace-expansion": {
-      "version": "2.0.1",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.1.tgz",
-      "integrity": "sha512-XnAIvQ8eM+kC6aULx6wuQiwVsnzsi9d3WxzV3FpWTGA19F621kwdbsAcFKXgKUHZWsy+mY6iL1sHTxWEFCytDA==",
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.2.tgz",
+      "integrity": "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ==",
       "dev": true,
+      "license": "MIT",
       "dependencies": {
         "balanced-match": "^1.0.0"
       }

nodejs/package.json

@@ -11,7 +11,7 @@
     "ann"
   ],
   "private": false,
-  "version": "0.22.0-beta.1",
+  "version": "0.22.2-beta.2",
   "main": "dist/index.js",
   "exports": {
     ".": "./dist/index.js",

nodejs/src/connection.rs

@@ -2,12 +2,14 @@
 // SPDX-FileCopyrightText: Copyright The LanceDB Authors
 
 use std::collections::HashMap;
+use std::sync::Arc;
 
 use lancedb::database::CreateTableMode;
 use napi::bindgen_prelude::*;
 use napi_derive::*;
 
 use crate::error::NapiErrorExt;
+use crate::header::JsHeaderProvider;
 use crate::table::Table;
 use crate::ConnectionOptions;
 use lancedb::connection::{ConnectBuilder, Connection as LanceDBConnection};
@@ -45,7 +47,11 @@ impl Connection {
 impl Connection {
     /// Create a new Connection instance from the given URI.
     #[napi(factory)]
-    pub async fn new(uri: String, options: ConnectionOptions) -> napi::Result<Self> {
+    pub async fn new(
+        uri: String,
+        options: ConnectionOptions,
+        header_provider: Option<&JsHeaderProvider>,
+    ) -> napi::Result<Self> {
         let mut builder = ConnectBuilder::new(&uri);
         if let Some(interval) = options.read_consistency_interval {
             builder =
@@ -57,8 +63,16 @@ impl Connection {
             }
         }
 
+        // Create client config, optionally with header provider
         let client_config = options.client_config.unwrap_or_default();
-        builder = builder.client_config(client_config.into());
+        let mut rust_config: lancedb::remote::ClientConfig = client_config.into();
+
+        if let Some(provider) = header_provider {
+            rust_config.header_provider =
+                Some(Arc::new(provider.clone()) as Arc<dyn lancedb::remote::HeaderProvider>);
+        }
+
+        builder = builder.client_config(rust_config);
 
         if let Some(api_key) = options.api_key {
             builder = builder.api_key(&api_key);
@@ -199,6 +213,36 @@ impl Connection {
         Ok(Table::new(tbl))
     }
 
+    #[napi(catch_unwind)]
+    pub async fn clone_table(
+        &self,
+        target_table_name: String,
+        source_uri: String,
+        target_namespace: Vec<String>,
+        source_version: Option<i64>,
+        source_tag: Option<String>,
+        is_shallow: bool,
+    ) -> napi::Result<Table> {
+        let mut builder = self
+            .get_inner()?
+            .clone_table(&target_table_name, &source_uri);
+
+        builder = builder.target_namespace(target_namespace);
+
+        if let Some(version) = source_version {
+            builder = builder.source_version(version as u64);
+        }
+
+        if let Some(tag) = source_tag {
+            builder = builder.source_tag(tag);
+        }
+
+        builder = builder.is_shallow(is_shallow);
+
+        let tbl = builder.execute().await.default_error()?;
+        Ok(Table::new(tbl))
+    }
+
     /// Drop table with the name. Or raise an error if the table does not exist.
     #[napi(catch_unwind)]
     pub async fn drop_table(&self, name: String, namespace: Vec<String>) -> napi::Result<()> {

nodejs/src/header.rs

@@ -0,0 +1,71 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright The LanceDB Authors
+
+use napi::{
+    bindgen_prelude::*,
+    threadsafe_function::{ErrorStrategy, ThreadsafeFunction},
+};
+use napi_derive::napi;
+use std::collections::HashMap;
+use std::sync::Arc;
+
+/// JavaScript HeaderProvider implementation that wraps a JavaScript callback.
+/// This is the only native header provider - all header provider implementations
+/// should provide a JavaScript function that returns headers.
+#[napi]
+pub struct JsHeaderProvider {
+    get_headers_fn: Arc<ThreadsafeFunction<(), ErrorStrategy::CalleeHandled>>,
+}
+
+impl Clone for JsHeaderProvider {
+    fn clone(&self) -> Self {
+        Self {
+            get_headers_fn: self.get_headers_fn.clone(),
+        }
+    }
+}
+
+#[napi]
+impl JsHeaderProvider {
+    /// Create a new JsHeaderProvider from a JavaScript callback
+    #[napi(constructor)]
+    pub fn new(get_headers_callback: JsFunction) -> Result<Self> {
+        let get_headers_fn = get_headers_callback
+            .create_threadsafe_function(0, |ctx| Ok(vec![ctx.value]))
+            .map_err(|e| {
+                Error::new(
+                    Status::GenericFailure,
+                    format!("Failed to create threadsafe function: {}", e),
+                )
+            })?;
+
+        Ok(Self {
+            get_headers_fn: Arc::new(get_headers_fn),
+        })
+    }
+}
+
+#[cfg(feature = "remote")]
+#[async_trait::async_trait]
+impl lancedb::remote::HeaderProvider for JsHeaderProvider {
+    async fn get_headers(&self) -> lancedb::error::Result<HashMap<String, String>> {
+        // Call the JavaScript function asynchronously
+        let promise: Promise<HashMap<String, String>> =
+            self.get_headers_fn.call_async(Ok(())).await.map_err(|e| {
+                lancedb::error::Error::Runtime {
+                    message: format!("Failed to call JavaScript get_headers: {}", e),
+                }
+            })?;
+
+        // Await the promise result
+        promise.await.map_err(|e| lancedb::error::Error::Runtime {
+            message: format!("JavaScript get_headers failed: {}", e),
+        })
+    }
+}
+
+impl std::fmt::Debug for JsHeaderProvider {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "JsHeaderProvider")
+    }
+}

nodejs/src/lib.rs

@@ -8,6 +8,7 @@ use napi_derive::*;
 
 mod connection;
 mod error;
+mod header;
 mod index;
 mod iterator;
 pub mod merge;

nodejs/src/merge.rs

@@ -43,6 +43,13 @@ impl NativeMergeInsertBuilder {
         self.inner.timeout(Duration::from_millis(timeout as u64));
     }
 
+    #[napi]
+    pub fn use_index(&self, use_index: bool) -> Self {
+        let mut this = self.clone();
+        this.inner.use_index(use_index);
+        this
+    }
+
     #[napi(catch_unwind)]
     pub async fn execute(&self, buf: Buffer) -> napi::Result<MergeResult> {
         let data = ipc_file_to_batches(buf.to_vec())

nodejs/src/remote.rs

@@ -69,6 +69,20 @@ pub struct RetryConfig {
     pub statuses: Option<Vec<u16>>,
 }
 
+/// TLS/mTLS configuration for the remote HTTP client.
+#[napi(object)]
+#[derive(Debug, Default)]
+pub struct TlsConfig {
+    /// Path to the client certificate file (PEM format) for mTLS authentication.
+    pub cert_file: Option<String>,
+    /// Path to the client private key file (PEM format) for mTLS authentication.
+    pub key_file: Option<String>,
+    /// Path to the CA certificate file (PEM format) for server verification.
+    pub ssl_ca_cert: Option<String>,
+    /// Whether to verify the hostname in the server's certificate.
+    pub assert_hostname: Option<bool>,
+}
+
 #[napi(object)]
 #[derive(Debug, Default)]
 pub struct ClientConfig {
@@ -77,6 +91,7 @@ pub struct ClientConfig {
     pub timeout_config: Option<TimeoutConfig>,
     pub extra_headers: Option<HashMap<String, String>>,
     pub id_delimiter: Option<String>,
+    pub tls_config: Option<TlsConfig>,
 }
 
 impl From<TimeoutConfig> for lancedb::remote::TimeoutConfig {
@@ -107,6 +122,17 @@ impl From<RetryConfig> for lancedb::remote::RetryConfig {
     }
 }
 
+impl From<TlsConfig> for lancedb::remote::TlsConfig {
+    fn from(config: TlsConfig) -> Self {
+        Self {
+            cert_file: config.cert_file,
+            key_file: config.key_file,
+            ssl_ca_cert: config.ssl_ca_cert,
+            assert_hostname: config.assert_hostname.unwrap_or(true),
+        }
+    }
+}
+
 impl From<ClientConfig> for lancedb::remote::ClientConfig {
     fn from(config: ClientConfig) -> Self {
         Self {
@@ -117,6 +143,8 @@ impl From<ClientConfig> for lancedb::remote::ClientConfig {
             timeout_config: config.timeout_config.map(Into::into).unwrap_or_default(),
             extra_headers: config.extra_headers.unwrap_or_default(),
             id_delimiter: config.id_delimiter,
+            tls_config: config.tls_config.map(Into::into),
+            header_provider: None, // the header provider is set separately later
         }
     }
 }

python/.bumpversion.toml

@@ -1,5 +1,5 @@
 [tool.bumpversion]
-current_version = "0.25.0"
+current_version = "0.25.2"
 parse = """(?x)
     (?P<major>0|[1-9]\\d*)\\.
     (?P<minor>0|[1-9]\\d*)\\.

python/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "lancedb-python"
-version = "0.25.0"
+version = "0.25.2"
 edition.workspace = true
 description = "Python bindings for LanceDB"
 license.workspace = true
@@ -14,11 +14,12 @@ name = "_lancedb"
 crate-type = ["cdylib"]
 
 [dependencies]
-arrow = { version = "55.1", features = ["pyarrow"] }
+arrow = { version = "56.2", features = ["pyarrow"] }
+async-trait = "0.1"
 lancedb = { path = "../rust/lancedb", default-features = false }
 env_logger.workspace = true
-pyo3 = { version = "0.24", features = ["extension-module", "abi3-py39"] }
-pyo3-async-runtimes = { version = "0.24", features = [
+pyo3 = { version = "0.25", features = ["extension-module", "abi3-py39"] }
+pyo3-async-runtimes = { version = "0.25", features = [
     "attributes",
     "tokio-runtime",
 ] }
@@ -27,7 +28,7 @@ futures.workspace = true
 tokio = { version = "1.40", features = ["sync"] }
 
 [build-dependencies]
-pyo3-build-config = { version = "0.24", features = [
+pyo3-build-config = { version = "0.25", features = [
     "extension-module",
     "abi3-py39",
 ] }

python/pyproject.toml

@@ -5,12 +5,12 @@ dynamic = ["version"]
 dependencies = [
     "deprecation",
     "numpy",
-    "overrides>=0.7",
+    "overrides>=0.7; python_version<'3.12'",
     "packaging",
     "pyarrow>=16",
     "pydantic>=1.10",
     "tqdm>=4.27.0",
-    "lance-namespace==0.0.6"
+    "lance-namespace>=0.0.16"
 ]
 description = "lancedb"
 authors = [{ name = "LanceDB Devs", email = "dev@lancedb.com" }]

python/python/lancedb/_lancedb.pyi

@@ -60,6 +60,15 @@ class Connection(object):
         storage_options: Optional[Dict[str, str]] = None,
         index_cache_size: Optional[int] = None,
     ) -> Table: ...
+    async def clone_table(
+        self,
+        target_table_name: str,
+        source_uri: str,
+        target_namespace: List[str] = [],
+        source_version: Optional[int] = None,
+        source_tag: Optional[str] = None,
+        is_shallow: bool = True,
+    ) -> Table: ...
     async def rename_table(
         self,
         cur_name: str,
@@ -124,6 +133,7 @@ class Tags:
     async def update(self, tag: str, version: int): ...
 
 class IndexConfig:
+    name: str
     index_type: str
     columns: List[str]
 

python/python/lancedb/db.py

@@ -6,10 +6,18 @@ from __future__ import annotations
 
 from abc import abstractmethod
 from pathlib import Path
+import sys
 from typing import TYPE_CHECKING, Dict, Iterable, List, Literal, Optional, Union
 
+if sys.version_info >= (3, 12):
+    from typing import override
+
+    class EnforceOverrides:
+        pass
+else:
+    from overrides import EnforceOverrides, override  # type: ignore
+
 from lancedb.embeddings.registry import EmbeddingFunctionRegistry
-from overrides import EnforceOverrides, override  # type: ignore
 
 from lancedb.common import data_to_reader, sanitize_uri, validate_schema
 from lancedb.background_loop import LOOP
@@ -665,6 +673,60 @@ class LanceDBConnection(DBConnection):
             index_cache_size=index_cache_size,
         )
 
+    def clone_table(
+        self,
+        target_table_name: str,
+        source_uri: str,
+        *,
+        target_namespace: List[str] = [],
+        source_version: Optional[int] = None,
+        source_tag: Optional[str] = None,
+        is_shallow: bool = True,
+    ) -> LanceTable:
+        """Clone a table from a source table.
+
+        A shallow clone creates a new table that shares the underlying data files
+        with the source table but has its own independent manifest. This allows
+        both the source and cloned tables to evolve independently while initially
+        sharing the same data, deletion, and index files.
+
+        Parameters
+        ----------
+        target_table_name: str
+            The name of the target table to create.
+        source_uri: str
+            The URI of the source table to clone from.
+        target_namespace: List[str], optional
+            The namespace for the target table.
+            None or empty list represents root namespace.
+        source_version: int, optional
+            The version of the source table to clone.
+        source_tag: str, optional
+            The tag of the source table to clone.
+        is_shallow: bool, default True
+            Whether to perform a shallow clone (True) or deep clone (False).
+            Currently only shallow clone is supported.
+
+        Returns
+        -------
+        A LanceTable object representing the cloned table.
+        """
+        LOOP.run(
+            self._conn.clone_table(
+                target_table_name,
+                source_uri,
+                target_namespace=target_namespace,
+                source_version=source_version,
+                source_tag=source_tag,
+                is_shallow=is_shallow,
+            )
+        )
+        return LanceTable.open(
+            self,
+            target_table_name,
+            namespace=target_namespace,
+        )
+
     @override
     def drop_table(
         self,
@@ -1136,6 +1198,54 @@ class AsyncConnection(object):
         )
         return AsyncTable(table)
 
+    async def clone_table(
+        self,
+        target_table_name: str,
+        source_uri: str,
+        *,
+        target_namespace: List[str] = [],
+        source_version: Optional[int] = None,
+        source_tag: Optional[str] = None,
+        is_shallow: bool = True,
+    ) -> AsyncTable:
+        """Clone a table from a source table.
+
+        A shallow clone creates a new table that shares the underlying data files
+        with the source table but has its own independent manifest. This allows
+        both the source and cloned tables to evolve independently while initially
+        sharing the same data, deletion, and index files.
+
+        Parameters
+        ----------
+        target_table_name: str
+            The name of the target table to create.
+        source_uri: str
+            The URI of the source table to clone from.
+        target_namespace: List[str], optional
+            The namespace for the target table.
+            None or empty list represents root namespace.
+        source_version: int, optional
+            The version of the source table to clone.
+        source_tag: str, optional
+            The tag of the source table to clone.
+        is_shallow: bool, default True
+            Whether to perform a shallow clone (True) or deep clone (False).
+            Currently only shallow clone is supported.
+
+        Returns
+        -------
+        An AsyncTable object representing the cloned table.
+        """
+        table = await self._inner.clone_table(
+            target_table_name,
+            source_uri,
+            target_namespace=target_namespace,
+            source_version=source_version,
+            source_tag=source_tag,
+            is_shallow=is_shallow,
+        )
+        return AsyncTable(table)
+
     async def rename_table(
         self,
         cur_name: str,

python/python/lancedb/embeddings/registry.py

@@ -122,7 +122,7 @@ class EmbeddingFunctionRegistry:
             obj["vector_column"]: EmbeddingFunctionConfig(
                 vector_column=obj["vector_column"],
                 source_column=obj["source_column"],
-                function=self.get(obj["name"])(**obj["model"]),
+                function=self.get(obj["name"]).create(**obj["model"]),
             )
             for obj in raw_list
         }

python/python/lancedb/index.py

@@ -251,6 +251,13 @@ class HnswPq:
         results. In most cases, there is no benefit to setting this higher than 500.
         This value should be set to a value that is not less than `ef` in the
         search phase.
+
+    target_partition_size, default is 1,048,576
+
+        The target size of each partition.
+
+        This value controls the tradeoff between search performance and accuracy.
+        faster search but less accurate results as higher value.
     """
 
     distance_type: Literal["l2", "cosine", "dot"] = "l2"
@@ -261,6 +268,7 @@ class HnswPq:
     sample_rate: int = 256
     m: int = 20
     ef_construction: int = 300
+    target_partition_size: Optional[int] = None
 
 
 @dataclass
@@ -351,6 +359,12 @@ class HnswSq:
         This value should be set to a value that is not less than `ef` in the search
         phase.
 
+    target_partition_size, default is 1,048,576
+
+        The target size of each partition.
+
+        This value controls the tradeoff between search performance and accuracy.
+        faster search but less accurate results as higher value.
     """
 
     distance_type: Literal["l2", "cosine", "dot"] = "l2"
@@ -359,6 +373,7 @@ class HnswSq:
     sample_rate: int = 256
     m: int = 20
     ef_construction: int = 300
+    target_partition_size: Optional[int] = None
 
 
 @dataclass
@@ -444,12 +459,20 @@ class IvfFlat:
         cases the default should be sufficient.
 
         The default value is 256.
+
+    target_partition_size, default is 8192
+
+        The target size of each partition.
+
+        This value controls the tradeoff between search performance and accuracy.
+        faster search but less accurate results as higher value.
     """
 
     distance_type: Literal["l2", "cosine", "dot", "hamming"] = "l2"
     num_partitions: Optional[int] = None
     max_iterations: int = 50
     sample_rate: int = 256
+    target_partition_size: Optional[int] = None
 
 
 @dataclass
@@ -564,6 +587,13 @@ class IvfPq:
         cases the default should be sufficient.
 
         The default value is 256.
+
+    target_partition_size, default is 8192
+
+        The target size of each partition.
+
+        This value controls the tradeoff between search performance and accuracy.
+        faster search but less accurate results as higher value.
     """
 
     distance_type: Literal["l2", "cosine", "dot"] = "l2"
@@ -572,6 +602,7 @@ class IvfPq:
     num_bits: int = 8
     max_iterations: int = 50
     sample_rate: int = 256
+    target_partition_size: Optional[int] = None
 
 
 __all__ = [

python/python/lancedb/merge.py

@@ -33,6 +33,7 @@ class LanceMergeInsertBuilder(object):
         self._when_not_matched_by_source_delete = False
         self._when_not_matched_by_source_condition = None
         self._timeout = None
+        self._use_index = True
 
     def when_matched_update_all(
         self, *, where: Optional[str] = None
@@ -78,6 +79,23 @@ class LanceMergeInsertBuilder(object):
             self._when_not_matched_by_source_condition = condition
         return self
 
+    def use_index(self, use_index: bool) -> LanceMergeInsertBuilder:
+        """
+        Controls whether to use indexes for the merge operation.
+
+        When set to `True` (the default), the operation will use an index if available
+        on the join key for improved performance. When set to `False`, it forces a full
+        table scan even if an index exists. This can be useful for benchmarking or when
+        the query optimizer chooses a suboptimal path.
+
+        Parameters
+        ----------
+        use_index: bool
+            Whether to use indices for the merge operation. Defaults to `True`.
+        """
+        self._use_index = use_index
+        return self
+
     def execute(
         self,
         new_data: DATA,

python/python/lancedb/namespace.py

@@ -12,13 +12,18 @@ from __future__ import annotations
 
 from typing import Dict, Iterable, List, Optional, Union
 import os
+import sys
+
+if sys.version_info >= (3, 12):
+    from typing import override
+else:
+    from overrides import override
 
 from lancedb.db import DBConnection
 from lancedb.table import LanceTable, Table
 from lancedb.util import validate_table_name
 from lancedb.common import validate_schema
 from lancedb.table import sanitize_create_table
-from overrides import override
 
 from lance_namespace import LanceNamespace, connect as namespace_connect
 from lance_namespace_urllib3_client.models import (

python/python/lancedb/remote/__init__.py

@@ -8,7 +8,15 @@ from typing import List, Optional
 
 from lancedb import __version__
 
-__all__ = ["TimeoutConfig", "RetryConfig", "ClientConfig"]
+from .header import HeaderProvider
+
+__all__ = [
+    "TimeoutConfig",
+    "RetryConfig",
+    "TlsConfig",
+    "ClientConfig",
+    "HeaderProvider",
+]
 
 
 @dataclass
@@ -112,6 +120,29 @@ class RetryConfig:
     statuses: Optional[List[int]] = None
 
 
+@dataclass
+class TlsConfig:
+    """TLS/mTLS configuration for the remote HTTP client.
+
+    Attributes
+    ----------
+    cert_file: Optional[str]
+        Path to the client certificate file (PEM format) for mTLS authentication.
+    key_file: Optional[str]
+        Path to the client private key file (PEM format) for mTLS authentication.
+    ssl_ca_cert: Optional[str]
+        Path to the CA certificate file (PEM format) for server verification.
+    assert_hostname: bool
+        Whether to verify the hostname in the server's certificate. Default is True.
+        Set to False to disable hostname verification (use with caution).
+    """
+
+    cert_file: Optional[str] = None
+    key_file: Optional[str] = None
+    ssl_ca_cert: Optional[str] = None
+    assert_hostname: bool = True
+
+
 @dataclass
 class ClientConfig:
     user_agent: str = f"LanceDB-Python-Client/{__version__}"
@@ -119,9 +150,13 @@ class ClientConfig:
     timeout_config: Optional[TimeoutConfig] = field(default_factory=TimeoutConfig)
     extra_headers: Optional[dict] = None
     id_delimiter: Optional[str] = None
+    tls_config: Optional[TlsConfig] = None
+    header_provider: Optional["HeaderProvider"] = None
 
     def __post_init__(self):
         if isinstance(self.retry_config, dict):
             self.retry_config = RetryConfig(**self.retry_config)
         if isinstance(self.timeout_config, dict):
             self.timeout_config = TimeoutConfig(**self.timeout_config)
+        if isinstance(self.tls_config, dict):
+            self.tls_config = TlsConfig(**self.tls_config)

python/python/lancedb/remote/db.py

@@ -5,15 +5,20 @@
 from datetime import timedelta
 import logging
 from concurrent.futures import ThreadPoolExecutor
+import sys
 from typing import Any, Dict, Iterable, List, Optional, Union
 from urllib.parse import urlparse
 import warnings
 
+if sys.version_info >= (3, 12):
+    from typing import override
+else:
+    from overrides import override
+
 # Remove this import to fix circular dependency
 # from lancedb import connect_async
 from lancedb.remote import ClientConfig
 import pyarrow as pa
-from overrides import override
 
 from ..common import DATA
 from ..db import DBConnection, LOOP
@@ -212,6 +217,53 @@ class RemoteDBConnection(DBConnection):
         table = LOOP.run(self._conn.open_table(name, namespace=namespace))
         return RemoteTable(table, self.db_name)
 
+    def clone_table(
+        self,
+        target_table_name: str,
+        source_uri: str,
+        *,
+        target_namespace: List[str] = [],
+        source_version: Optional[int] = None,
+        source_tag: Optional[str] = None,
+        is_shallow: bool = True,
+    ) -> Table:
+        """Clone a table from a source table.
+
+        Parameters
+        ----------
+        target_table_name: str
+            The name of the target table to create.
+        source_uri: str
+            The URI of the source table to clone from.
+        target_namespace: List[str], optional
+            The namespace for the target table.
+            None or empty list represents root namespace.
+        source_version: int, optional
+            The version of the source table to clone.
+        source_tag: str, optional
+            The tag of the source table to clone.
+        is_shallow: bool, default True
+            Whether to perform a shallow clone (True) or deep clone (False).
+            Currently only shallow clone is supported.
+
+        Returns
+        -------
+        A RemoteTable object representing the cloned table.
+        """
+        from .table import RemoteTable
+
+        table = LOOP.run(
+            self._conn.clone_table(
+                target_table_name,
+                source_uri,
+                target_namespace=target_namespace,
+                source_version=source_version,
+                source_tag=source_tag,
+                is_shallow=is_shallow,
+            )
+        )
+        return RemoteTable(table, self.db_name)
+
     @override
     def create_table(
         self,

python/python/lancedb/remote/header.py

@@ -0,0 +1,180 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright The LanceDB Authors
+
+"""Header providers for LanceDB remote connections.
+
+This module provides a flexible header management framework for LanceDB remote
+connections, allowing users to implement custom header strategies for
+authentication, request tracking, custom metadata, or any other header-based
+requirements.
+
+The module includes the HeaderProvider abstract base class and example implementations
+(StaticHeaderProvider and OAuthProvider) that demonstrate common patterns.
+
+The HeaderProvider interface is designed to be called before each request to the remote
+server, enabling dynamic header scenarios where values may need to be
+refreshed, rotated, or computed on-demand.
+"""
+
+from abc import ABC, abstractmethod
+from typing import Dict, Optional, Callable, Any
+import time
+import threading
+
+
+class HeaderProvider(ABC):
+    """Abstract base class for providing custom headers for each request.
+
+    Users can implement this interface to provide dynamic headers for various purposes
+    such as authentication (OAuth tokens, API keys), request tracking (correlation IDs),
+    custom metadata, or any other header-based requirements. The provider is called
+    before each request to ensure fresh header values are always used.
+
+    Error Handling
+    --------------
+    If get_headers() raises an exception, the request will fail. Implementations
+    should handle recoverable errors internally (e.g., retry token refresh) and
+    only raise exceptions for unrecoverable errors.
+    """
+
+    @abstractmethod
+    def get_headers(self) -> Dict[str, str]:
+        """Get the latest headers to be added to requests.
+
+        This method is called before each request to the remote LanceDB server.
+        Implementations should return headers that will be merged with existing headers.
+
+        Returns
+        -------
+        Dict[str, str]
+            Dictionary of header names to values to add to the request.
+
+        Raises
+        ------
+        Exception
+            If unable to fetch headers, the exception will be propagated
+            and the request will fail.
+        """
+        pass
+
+
+class StaticHeaderProvider(HeaderProvider):
+    """Example implementation: A simple header provider that returns static headers.
+
+    This is an example implementation showing how to create a HeaderProvider
+    for cases where headers don't change during the session. Users can use this
+    as a reference for implementing their own providers.
+
+    Parameters
+    ----------
+    headers : Dict[str, str]
+        Static headers to return for every request.
+    """
+
+    def __init__(self, headers: Dict[str, str]):
+        """Initialize with static headers.
+
+        Parameters
+        ----------
+        headers : Dict[str, str]
+            Headers to return for every request.
+        """
+        self._headers = headers.copy()
+
+    def get_headers(self) -> Dict[str, str]:
+        """Return the static headers.
+
+        Returns
+        -------
+        Dict[str, str]
+            Copy of the static headers.
+        """
+        return self._headers.copy()
+
+
+class OAuthProvider(HeaderProvider):
+    """Example implementation: OAuth token provider with automatic refresh.
+
+    This is an example implementation showing how to manage OAuth tokens
+    with automatic refresh when they expire. Users can use this as a reference
+    for implementing their own OAuth or token-based authentication providers.
+
+    Parameters
+    ----------
+    token_fetcher : Callable[[], Dict[str, Any]]
+        Function that fetches a new token. Should return a dict with
+        'access_token' and optionally 'expires_in' (seconds until expiration).
+    refresh_buffer_seconds : int, optional
+        Number of seconds before expiration to trigger refresh. Default is 300
+        (5 minutes).
+    """
+
+    def __init__(
+        self, token_fetcher: Callable[[], Any], refresh_buffer_seconds: int = 300
+    ):
+        """Initialize the OAuth provider.
+
+        Parameters
+        ----------
+        token_fetcher : Callable[[], Any]
+            Function to fetch new tokens. Should return dict with
+            'access_token' and optionally 'expires_in'.
+        refresh_buffer_seconds : int, optional
+            Seconds before expiry to refresh token. Default 300.
+        """
+        self._token_fetcher = token_fetcher
+        self._refresh_buffer = refresh_buffer_seconds
+        self._current_token: Optional[str] = None
+        self._token_expires_at: Optional[float] = None
+        self._refresh_lock = threading.Lock()
+
+    def _refresh_token_if_needed(self) -> None:
+        """Refresh the token if it's expired or close to expiring."""
+        with self._refresh_lock:
+            # Check again inside the lock in case another thread refreshed
+            if self._needs_refresh():
+                token_data = self._token_fetcher()
+
+                self._current_token = token_data.get("access_token")
+                if not self._current_token:
+                    raise ValueError("Token fetcher did not return 'access_token'")
+
+                # Set expiration if provided
+                expires_in = token_data.get("expires_in")
+                if expires_in:
+                    self._token_expires_at = time.time() + expires_in
+                else:
+                    # Token doesn't expire or expiration unknown
+                    self._token_expires_at = None
+
+    def _needs_refresh(self) -> bool:
+        """Check if token needs refresh."""
+        if self._current_token is None:
+            return True
+
+        if self._token_expires_at is None:
+            # No expiration info, assume token is valid
+            return False
+
+        # Refresh if we're within the buffer time of expiration
+        return time.time() >= (self._token_expires_at - self._refresh_buffer)
+
+    def get_headers(self) -> Dict[str, str]:
+        """Get OAuth headers, refreshing token if needed.
+
+        Returns
+        -------
+        Dict[str, str]
+            Headers with Bearer token authorization.
+
+        Raises
+        ------
+        Exception
+            If unable to fetch or refresh token.
+        """
+        self._refresh_token_if_needed()
+
+        if not self._current_token:
+            raise RuntimeError("Failed to obtain OAuth token")
+
+        return {"Authorization": f"Bearer {self._current_token}"}

python/python/lancedb/remote/table.py

@@ -114,7 +114,7 @@ class RemoteTable(Table):
         index_type: Literal["BTREE", "BITMAP", "LABEL_LIST", "scalar"] = "scalar",
         *,
         replace: bool = False,
-        wait_timeout: timedelta = None,
+        wait_timeout: Optional[timedelta] = None,
         name: Optional[str] = None,
     ):
         """Creates a scalar index
@@ -153,7 +153,7 @@ class RemoteTable(Table):
         column: str,
         *,
         replace: bool = False,
-        wait_timeout: timedelta = None,
+        wait_timeout: Optional[timedelta] = None,
         with_position: bool = False,
         # tokenizer configs:
         base_tokenizer: str = "simple",

python/python/lancedb/rerankers/__init__.py

@@ -9,6 +9,7 @@ from .linear_combination import LinearCombinationReranker
 from .openai import OpenaiReranker
 from .jinaai import JinaReranker
 from .rrf import RRFReranker
+from .mrr import MRRReranker
 from .answerdotai import AnswerdotaiRerankers
 from .voyageai import VoyageAIReranker
 
@@ -23,4 +24,5 @@ __all__ = [
     "RRFReranker",
     "AnswerdotaiRerankers",
     "VoyageAIReranker",
+    "MRRReranker",
 ]

python/python/lancedb/rerankers/mrr.py

@@ -0,0 +1,169 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright The LanceDB Authors
+
+
+from typing import Union, List, TYPE_CHECKING
+import pyarrow as pa
+import numpy as np
+
+from collections import defaultdict
+from .base import Reranker
+
+if TYPE_CHECKING:
+    from ..table import LanceVectorQueryBuilder
+
+
+class MRRReranker(Reranker):
+    """
+    Reranks the results using Mean Reciprocal Rank (MRR) algorithm based
+    on the scores of vector and FTS search.
+    Algorithm reference - https://en.wikipedia.org/wiki/Mean_reciprocal_rank
+
+    MRR calculates the average of reciprocal ranks across different search results.
+    For each document, it computes the reciprocal of its rank in each system,
+    then takes the mean of these reciprocal ranks as the final score.
+
+    Parameters
+    ----------
+    weight_vector : float, default 0.5
+        Weight for vector search results (0.0 to 1.0)
+    weight_fts : float, default 0.5
+        Weight for FTS search results (0.0 to 1.0)
+        Note: weight_vector + weight_fts should equal 1.0
+    return_score : str, default "relevance"
+        Options are "relevance" or "all"
+        The type of score to return. If "relevance", will return only the relevance
+        score. If "all", will return all scores from the vector and FTS search along
+        with the relevance score.
+    """
+
+    def __init__(
+        self,
+        weight_vector: float = 0.5,
+        weight_fts: float = 0.5,
+        return_score="relevance",
+    ):
+        if not (0.0 <= weight_vector <= 1.0):
+            raise ValueError("weight_vector must be between 0.0 and 1.0")
+        if not (0.0 <= weight_fts <= 1.0):
+            raise ValueError("weight_fts must be between 0.0 and 1.0")
+        if abs(weight_vector + weight_fts - 1.0) > 1e-6:
+            raise ValueError("weight_vector + weight_fts must equal 1.0")
+
+        super().__init__(return_score)
+        self.weight_vector = weight_vector
+        self.weight_fts = weight_fts
+
+    def rerank_hybrid(
+        self,
+        query: str,  # noqa: F821
+        vector_results: pa.Table,
+        fts_results: pa.Table,
+    ):
+        vector_ids = vector_results["_rowid"].to_pylist() if vector_results else []
+        fts_ids = fts_results["_rowid"].to_pylist() if fts_results else []
+
+        # Maps result_id to list of (type, reciprocal_rank)
+        mrr_score_map = defaultdict(list)
+
+        if vector_ids:
+            for rank, result_id in enumerate(vector_ids, 1):
+                reciprocal_rank = 1.0 / rank
+                mrr_score_map[result_id].append(("vector", reciprocal_rank))
+
+        if fts_ids:
+            for rank, result_id in enumerate(fts_ids, 1):
+                reciprocal_rank = 1.0 / rank
+                mrr_score_map[result_id].append(("fts", reciprocal_rank))
+
+        final_mrr_scores = {}
+        for result_id, scores in mrr_score_map.items():
+            vector_rr = 0.0
+            fts_rr = 0.0
+
+            for score_type, reciprocal_rank in scores:
+                if score_type == "vector":
+                    vector_rr = reciprocal_rank
+                elif score_type == "fts":
+                    fts_rr = reciprocal_rank
+
+            # If a document doesn't appear, its reciprocal rank is 0
+            weighted_mrr = self.weight_vector * vector_rr + self.weight_fts * fts_rr
+            final_mrr_scores[result_id] = weighted_mrr
+
+        combined_results = self.merge_results(vector_results, fts_results)
+        combined_row_ids = combined_results["_rowid"].to_pylist()
+        relevance_scores = [final_mrr_scores[row_id] for row_id in combined_row_ids]
+        combined_results = combined_results.append_column(
+            "_relevance_score", pa.array(relevance_scores, type=pa.float32())
+        )
+        combined_results = combined_results.sort_by(
+            [("_relevance_score", "descending")]
+        )
+
+        if self.score == "relevance":
+            combined_results = self._keep_relevance_score(combined_results)
+
+        return combined_results
+
+    def rerank_multivector(
+        self,
+        vector_results: Union[List[pa.Table], List["LanceVectorQueryBuilder"]],
+        query: str = None,
+        deduplicate: bool = True,  # noqa: F821
+    ):
+        """
+        Reranks the results from multiple vector searches using MRR algorithm.
+        Each vector search result is treated as a separate ranking system,
+        and MRR calculates the mean of reciprocal ranks across all systems.
+        This cannot reuse rerank_hybrid because MRR semantics require treating
+        each vector result as a separate ranking system.
+        """
+        if not all(isinstance(v, type(vector_results[0])) for v in vector_results):
+            raise ValueError(
+                "All elements in vector_results should be of the same type"
+            )
+
+        # avoid circular import
+        if type(vector_results[0]).__name__ == "LanceVectorQueryBuilder":
+            vector_results = [result.to_arrow() for result in vector_results]
+        elif not isinstance(vector_results[0], pa.Table):
+            raise ValueError(
+                "vector_results should be a list of pa.Table or LanceVectorQueryBuilder"
+            )
+
+        if not all("_rowid" in result.column_names for result in vector_results):
+            raise ValueError(
+                "'_rowid' is required for deduplication. \
+                    add _rowid to search results like this: \
+                    `search().with_row_id(True)`"
+            )
+
+        mrr_score_map = defaultdict(list)
+
+        for result_table in vector_results:
+            result_ids = result_table["_rowid"].to_pylist()
+            for rank, result_id in enumerate(result_ids, 1):
+                reciprocal_rank = 1.0 / rank
+                mrr_score_map[result_id].append(reciprocal_rank)
+
+        final_mrr_scores = {}
+        for result_id, reciprocal_ranks in mrr_score_map.items():
+            mean_rr = np.mean(reciprocal_ranks)
+            final_mrr_scores[result_id] = mean_rr
+
+        combined = pa.concat_tables(vector_results, **self._concat_tables_args)
+        combined = self._deduplicate(combined)
+
+        combined_row_ids = combined["_rowid"].to_pylist()
+
+        relevance_scores = [final_mrr_scores[row_id] for row_id in combined_row_ids]
+        combined = combined.append_column(
+            "_relevance_score", pa.array(relevance_scores, type=pa.float32())
+        )
+        combined = combined.sort_by([("_relevance_score", "descending")])
+
+        if self.score == "relevance":
+            combined = self._keep_relevance_score(combined)
+
+        return combined

python/python/lancedb/table.py

@@ -691,6 +691,7 @@ class Table(ABC):
         ef_construction: int = 300,
         name: Optional[str] = None,
         train: bool = True,
+        target_partition_size: Optional[int] = None,
     ):
         """Create an index on the table.
 
@@ -1469,10 +1470,7 @@ class Table(ABC):
             be deleted unless they are at least 7 days old. If delete_unverified is True
             then these files will be deleted regardless of their age.
         retrain: bool, default False
-            If True, retrain the vector indices, this would refine the IVF clustering
-            and quantization, which may improve the search accuracy. It's faster than
-            re-creating the index from scratch, so it's recommended to try this first,
-            when the data distribution has changed significantly.
+            This parameter is no longer used and is deprecated.
 
         Experimental API
         ----------------
@@ -2002,6 +2000,7 @@ class LanceTable(Table):
         *,
         name: Optional[str] = None,
         train: bool = True,
+        target_partition_size: Optional[int] = None,
     ):
         """Create an index on the table."""
         if accelerator is not None:
@@ -2018,6 +2017,7 @@ class LanceTable(Table):
                 num_bits=num_bits,
                 m=m,
                 ef_construction=ef_construction,
+                target_partition_size=target_partition_size,
             )
             self.checkout_latest()
             return
@@ -2027,6 +2027,7 @@ class LanceTable(Table):
                 num_partitions=num_partitions,
                 max_iterations=max_iterations,
                 sample_rate=sample_rate,
+                target_partition_size=target_partition_size,
             )
         elif index_type == "IVF_PQ":
             config = IvfPq(
@@ -2036,6 +2037,7 @@ class LanceTable(Table):
                 num_bits=num_bits,
                 max_iterations=max_iterations,
                 sample_rate=sample_rate,
+                target_partition_size=target_partition_size,
             )
         elif index_type == "IVF_HNSW_PQ":
             config = HnswPq(
@@ -2047,6 +2049,7 @@ class LanceTable(Table):
                 sample_rate=sample_rate,
                 m=m,
                 ef_construction=ef_construction,
+                target_partition_size=target_partition_size,
             )
         elif index_type == "IVF_HNSW_SQ":
             config = HnswSq(
@@ -2056,6 +2059,7 @@ class LanceTable(Table):
                 sample_rate=sample_rate,
                 m=m,
                 ef_construction=ef_construction,
+                target_partition_size=target_partition_size,
             )
         else:
             raise ValueError(f"Unknown index type {index_type}")
@@ -2828,10 +2832,7 @@ class LanceTable(Table):
             be deleted unless they are at least 7 days old. If delete_unverified is True
             then these files will be deleted regardless of their age.
         retrain: bool, default False
-            If True, retrain the vector indices, this would refine the IVF clustering
-            and quantization, which may improve the search accuracy. It's faster than
-            re-creating the index from scratch, so it's recommended to try this first,
-            when the data distribution has changed significantly.
+            This parameter is no longer used and is deprecated.
 
         Experimental API
         ----------------
@@ -3919,6 +3920,7 @@ class AsyncTable:
                 when_not_matched_by_source_delete=merge._when_not_matched_by_source_delete,
                 when_not_matched_by_source_condition=merge._when_not_matched_by_source_condition,
                 timeout=merge._timeout,
+                use_index=merge._use_index,
             ),
         )
 
@@ -4291,10 +4293,7 @@ class AsyncTable:
             be deleted unless they are at least 7 days old. If delete_unverified is True
             then these files will be deleted regardless of their age.
         retrain: bool, default False
-            If True, retrain the vector indices, this would refine the IVF clustering
-            and quantization, which may improve the search accuracy. It's faster than
-            re-creating the index from scratch, so it's recommended to try this first,
-            when the data distribution has changed significantly.
+            This parameter is no longer used and is deprecated.
 
         Experimental API
         ----------------
@@ -4317,10 +4316,19 @@ class AsyncTable:
         cleanup_since_ms: Optional[int] = None
         if cleanup_older_than is not None:
             cleanup_since_ms = round(cleanup_older_than.total_seconds() * 1000)
+
+        if retrain:
+            import warnings
+
+            warnings.warn(
+                "The 'retrain' parameter is deprecated and will be removed in a "
+                "future version.",
+                DeprecationWarning,
+            )
+
         return await self._inner.optimize(
             cleanup_since_ms=cleanup_since_ms,
             delete_unverified=delete_unverified,
-            retrain=retrain,
         )
 
     async def list_indices(self) -> Iterable[IndexConfig]:

python/python/tests/test_db.py

@@ -747,15 +747,16 @@ def test_local_namespace_operations(tmp_path):
     # Create a local database connection
     db = lancedb.connect(tmp_path)
 
-    # Test list_namespaces returns empty list
+    # Test list_namespaces returns empty list for root namespace
     namespaces = list(db.list_namespaces())
     assert namespaces == []
 
-    # Test list_namespaces with parameters still returns empty list
-    namespaces_with_params = list(
-        db.list_namespaces(namespace=["test"], page_token="token", limit=5)
-    )
-    assert namespaces_with_params == []
+    # Test list_namespaces with non-empty namespace raises NotImplementedError
+    with pytest.raises(
+        NotImplementedError,
+        match="Namespace operations are not supported for listing database",
+    ):
+        list(db.list_namespaces(namespace=["test"]))
 
 
 def test_local_create_namespace_not_supported(tmp_path):
@@ -830,3 +831,119 @@ def test_local_table_operations_with_namespace_raise_error(tmp_path):
     # Test table_names without namespace - should work normally
     tables_root = list(db.table_names())
     assert "test_table" in tables_root
+
+
+def test_clone_table_latest_version(tmp_path):
+    """Test cloning a table with the latest version (default behavior)"""
+    import os
+
+    db = lancedb.connect(tmp_path)
+
+    # Create source table with some data
+    data = [
+        {"id": 1, "text": "hello", "vector": [1.0, 2.0]},
+        {"id": 2, "text": "world", "vector": [3.0, 4.0]},
+    ]
+    source_table = db.create_table("source", data=data)
+
+    # Add more data to create a new version
+    more_data = [{"id": 3, "text": "test", "vector": [5.0, 6.0]}]
+    source_table.add(more_data)
+
+    # Clone the table (should get latest version with 3 rows)
+    source_uri = os.path.join(tmp_path, "source.lance")
+    cloned_table = db.clone_table("cloned", source_uri)
+
+    # Verify cloned table has all 3 rows
+    assert cloned_table.count_rows() == 3
+    assert "cloned" in db.table_names()
+
+    # Verify data matches
+    cloned_data = cloned_table.to_pandas()
+    assert len(cloned_data) == 3
+    assert set(cloned_data["id"].tolist()) == {1, 2, 3}
+
+
+def test_clone_table_specific_version(tmp_path):
+    """Test cloning a table from a specific version"""
+    import os
+
+    db = lancedb.connect(tmp_path)
+
+    # Create source table with initial data
+    data = [
+        {"id": 1, "text": "hello", "vector": [1.0, 2.0]},
+        {"id": 2, "text": "world", "vector": [3.0, 4.0]},
+    ]
+    source_table = db.create_table("source", data=data)
+
+    # Get the initial version
+    initial_version = source_table.version
+
+    # Add more data to create a new version
+    more_data = [{"id": 3, "text": "test", "vector": [5.0, 6.0]}]
+    source_table.add(more_data)
+
+    # Verify source now has 3 rows
+    assert source_table.count_rows() == 3
+
+    # Clone from the initial version (should have only 2 rows)
+    source_uri = os.path.join(tmp_path, "source.lance")
+    cloned_table = db.clone_table("cloned", source_uri, source_version=initial_version)
+
+    # Verify cloned table has only the initial 2 rows
+    assert cloned_table.count_rows() == 2
+    cloned_data = cloned_table.to_pandas()
+    assert set(cloned_data["id"].tolist()) == {1, 2}
+
+
+def test_clone_table_with_tag(tmp_path):
+    """Test cloning a table from a tagged version"""
+    import os
+
+    db = lancedb.connect(tmp_path)
+
+    # Create source table with initial data
+    data = [
+        {"id": 1, "text": "hello", "vector": [1.0, 2.0]},
+        {"id": 2, "text": "world", "vector": [3.0, 4.0]},
+    ]
+    source_table = db.create_table("source", data=data)
+
+    # Create a tag for the current version
+    source_table.tags.create("v1.0", source_table.version)
+
+    # Add more data after the tag
+    more_data = [{"id": 3, "text": "test", "vector": [5.0, 6.0]}]
+    source_table.add(more_data)
+
+    # Verify source now has 3 rows
+    assert source_table.count_rows() == 3
+
+    # Clone from the tagged version (should have only 2 rows)
+    source_uri = os.path.join(tmp_path, "source.lance")
+    cloned_table = db.clone_table("cloned", source_uri, source_tag="v1.0")
+
+    # Verify cloned table has only the tagged version's 2 rows
+    assert cloned_table.count_rows() == 2
+    cloned_data = cloned_table.to_pandas()
+    assert set(cloned_data["id"].tolist()) == {1, 2}
+
+
+def test_clone_table_deep_clone_fails(tmp_path):
+    """Test that deep clone raises an unsupported error"""
+    import os
+
+    db = lancedb.connect(tmp_path)
+
+    # Create source table with some data
+    data = [
+        {"id": 1, "text": "hello", "vector": [1.0, 2.0]},
+        {"id": 2, "text": "world", "vector": [3.0, 4.0]},
+    ]
+    db.create_table("source", data=data)
+
+    # Try to create a deep clone (should fail)
+    source_uri = os.path.join(tmp_path, "source.lance")
+    with pytest.raises(Exception, match="Deep clone is not yet implemented"):
+        db.clone_table("cloned", source_uri, is_shallow=False)

python/python/tests/test_embeddings.py

@@ -114,6 +114,63 @@ def test_embedding_function_variables():
     assert func.safe_model_dump()["secret_key"] == "$var:secret"
 
 
+def test_parse_functions_with_variables():
+    @register("variable-parsing-test")
+    class VariableParsingFunction(TextEmbeddingFunction):
+        api_key: str
+        base_url: Optional[str] = None
+
+        @staticmethod
+        def sensitive_keys():
+            return ["api_key"]
+
+        def ndims(self):
+            return 10
+
+        def generate_embeddings(self, texts):
+            # Mock implementation that just returns random embeddings
+            # In real usage, this would use the api_key to call an API
+            return [np.random.rand(self.ndims()).tolist() for _ in texts]
+
+    registry = EmbeddingFunctionRegistry.get_instance()
+
+    registry.set_var("test_api_key", "sk-test-key-12345")
+    registry.set_var("test_base_url", "https://api.example.com")
+
+    conf = EmbeddingFunctionConfig(
+        source_column="text",
+        vector_column="vector",
+        function=registry.get("variable-parsing-test").create(
+            api_key="$var:test_api_key", base_url="$var:test_base_url"
+        ),
+    )
+
+    metadata = registry.get_table_metadata([conf])
+
+    # Create a mock arrow table with the metadata
+    schema = pa.schema(
+        [pa.field("text", pa.string()), pa.field("vector", pa.list_(pa.float32(), 10))]
+    )
+    table = pa.table({"text": [], "vector": []}, schema=schema)
+    table = table.replace_schema_metadata(metadata)
+
+    ds = lance.write_dataset(table, "memory://")
+
+    configs = registry.parse_functions(ds.schema.metadata)
+
+    assert "vector" in configs
+    parsed_func = configs["vector"].function
+
+    assert parsed_func.api_key == "sk-test-key-12345"
+    assert parsed_func.base_url == "https://api.example.com"
+
+    embeddings = parsed_func.generate_embeddings(["test text"])
+    assert len(embeddings) == 1
+    assert len(embeddings[0]) == 10
+
+    assert parsed_func.safe_model_dump()["api_key"] == "$var:test_api_key"
+
+
 def test_embedding_with_bad_results(tmp_path):
     @register("null-embedding")
     class NullEmbeddingFunction(TextEmbeddingFunction):

python/python/tests/test_header_provider.py

@@ -0,0 +1,237 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright The LanceDB Authors
+
+import concurrent.futures
+import pytest
+import time
+import threading
+from typing import Dict
+
+from lancedb.remote import ClientConfig, HeaderProvider
+from lancedb.remote.header import StaticHeaderProvider, OAuthProvider
+
+
+class TestStaticHeaderProvider:
+    def test_init(self):
+        """Test StaticHeaderProvider initialization."""
+        headers = {"X-API-Key": "test-key", "X-Custom": "value"}
+        provider = StaticHeaderProvider(headers)
+        assert provider._headers == headers
+
+    def test_get_headers(self):
+        """Test get_headers returns correct headers."""
+        headers = {"X-API-Key": "test-key", "X-Custom": "value"}
+        provider = StaticHeaderProvider(headers)
+
+        result = provider.get_headers()
+        assert result == headers
+
+        # Ensure it returns a copy
+        result["X-Modified"] = "modified"
+        result2 = provider.get_headers()
+        assert "X-Modified" not in result2
+
+
+class TestOAuthProvider:
+    def test_init(self):
+        """Test OAuthProvider initialization."""
+
+        def fetcher():
+            return {"access_token": "token123", "expires_in": 3600}
+
+        provider = OAuthProvider(fetcher)
+        assert provider._token_fetcher is fetcher
+        assert provider._refresh_buffer == 300
+        assert provider._current_token is None
+        assert provider._token_expires_at is None
+
+    def test_get_headers_first_time(self):
+        """Test get_headers fetches token on first call."""
+
+        def fetcher():
+            return {"access_token": "token123", "expires_in": 3600}
+
+        provider = OAuthProvider(fetcher)
+        headers = provider.get_headers()
+
+        assert headers == {"Authorization": "Bearer token123"}
+        assert provider._current_token == "token123"
+        assert provider._token_expires_at is not None
+
+    def test_token_refresh(self):
+        """Test token refresh when expired."""
+        call_count = 0
+        tokens = ["token1", "token2"]
+
+        def fetcher():
+            nonlocal call_count
+            token = tokens[call_count]
+            call_count += 1
+            return {"access_token": token, "expires_in": 1}  # Expires in 1 second
+
+        provider = OAuthProvider(fetcher, refresh_buffer_seconds=0)
+
+        # First call
+        headers1 = provider.get_headers()
+        assert headers1 == {"Authorization": "Bearer token1"}
+
+        # Wait for token to expire
+        time.sleep(1.1)
+
+        # Second call should refresh
+        headers2 = provider.get_headers()
+        assert headers2 == {"Authorization": "Bearer token2"}
+        assert call_count == 2
+
+    def test_no_expiry_info(self):
+        """Test handling tokens without expiry information."""
+
+        def fetcher():
+            return {"access_token": "permanent_token"}
+
+        provider = OAuthProvider(fetcher)
+        headers = provider.get_headers()
+
+        assert headers == {"Authorization": "Bearer permanent_token"}
+        assert provider._token_expires_at is None
+
+        # Should not refresh on second call
+        headers2 = provider.get_headers()
+        assert headers2 == {"Authorization": "Bearer permanent_token"}
+
+    def test_missing_access_token(self):
+        """Test error handling when access_token is missing."""
+
+        def fetcher():
+            return {"expires_in": 3600}  # Missing access_token
+
+        provider = OAuthProvider(fetcher)
+
+        with pytest.raises(
+            ValueError, match="Token fetcher did not return 'access_token'"
+        ):
+            provider.get_headers()
+
+    def test_sync_method(self):
+        """Test synchronous get_headers method."""
+
+        def fetcher():
+            return {"access_token": "sync_token", "expires_in": 3600}
+
+        provider = OAuthProvider(fetcher)
+        headers = provider.get_headers()
+
+        assert headers == {"Authorization": "Bearer sync_token"}
+
+
+class TestClientConfigIntegration:
+    def test_client_config_with_header_provider(self):
+        """Test ClientConfig can accept a HeaderProvider."""
+        provider = StaticHeaderProvider({"X-Test": "value"})
+        config = ClientConfig(header_provider=provider)
+
+        assert config.header_provider is provider
+
+    def test_client_config_without_header_provider(self):
+        """Test ClientConfig works without HeaderProvider."""
+        config = ClientConfig()
+        assert config.header_provider is None
+
+
+class CustomProvider(HeaderProvider):
+    """Custom provider for testing abstract class."""
+
+    def get_headers(self) -> Dict[str, str]:
+        return {"X-Custom": "custom-value"}
+
+
+class TestCustomHeaderProvider:
+    def test_custom_provider(self):
+        """Test custom HeaderProvider implementation."""
+        provider = CustomProvider()
+        headers = provider.get_headers()
+        assert headers == {"X-Custom": "custom-value"}
+
+
+class ErrorProvider(HeaderProvider):
+    """Provider that raises errors for testing error handling."""
+
+    def __init__(self, error_message: str = "Test error"):
+        self.error_message = error_message
+        self.call_count = 0
+
+    def get_headers(self) -> Dict[str, str]:
+        self.call_count += 1
+        raise RuntimeError(self.error_message)
+
+
+class TestErrorHandling:
+    def test_provider_error_propagation(self):
+        """Test that errors from header provider are properly propagated."""
+        provider = ErrorProvider("Authentication failed")
+
+        with pytest.raises(RuntimeError, match="Authentication failed"):
+            provider.get_headers()
+
+        assert provider.call_count == 1
+
+    def test_provider_error(self):
+        """Test that errors are propagated."""
+        provider = ErrorProvider("Sync error")
+
+        with pytest.raises(RuntimeError, match="Sync error"):
+            provider.get_headers()
+
+
+class ConcurrentProvider(HeaderProvider):
+    """Provider for testing thread safety."""
+
+    def __init__(self):
+        self.counter = 0
+        self.lock = threading.Lock()
+
+    def get_headers(self) -> Dict[str, str]:
+        with self.lock:
+            self.counter += 1
+            # Simulate some work
+            time.sleep(0.01)
+            return {"X-Request-Id": str(self.counter)}
+
+
+class TestConcurrency:
+    def test_concurrent_header_fetches(self):
+        """Test that header provider can handle concurrent requests."""
+        provider = ConcurrentProvider()
+
+        # Create multiple concurrent requests
+        with concurrent.futures.ThreadPoolExecutor(max_workers=10) as executor:
+            futures = [executor.submit(provider.get_headers) for _ in range(10)]
+            results = [f.result() for f in futures]
+
+        # Each request should get a unique counter value
+        request_ids = [int(r["X-Request-Id"]) for r in results]
+        assert len(set(request_ids)) == 10
+        assert min(request_ids) == 1
+        assert max(request_ids) == 10
+
+    def test_oauth_concurrent_refresh(self):
+        """Test that OAuth provider handles concurrent refresh requests safely."""
+        call_count = 0
+
+        def slow_token_fetch():
+            nonlocal call_count
+            call_count += 1
+            time.sleep(0.1)  # Simulate slow token fetch
+            return {"access_token": f"token-{call_count}", "expires_in": 3600}
+
+        provider = OAuthProvider(slow_token_fetch)
+
+        # Force multiple concurrent refreshes
+        with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
+            futures = [executor.submit(provider.get_headers) for _ in range(5)]
+            results = [f.result() for f in futures]
+
+        # All requests should get the same token (only one refresh should happen)
+        tokens = [r["Authorization"] for r in results]
+        assert all(t == "Bearer token-1" for t in tokens)
+        assert call_count == 1  # Only one token fetch despite concurrent requests

python/python/tests/test_index.py

@@ -35,6 +35,8 @@ async def some_table(db_async):
             "tags": [
                 [f"tag{random.randint(0, 8)}" for _ in range(2)] for _ in range(NROWS)
             ],
+            "is_active": [random.choice([True, False]) for _ in range(NROWS)],
+            "data": [random.randbytes(random.randint(0, 128)) for _ in range(NROWS)],
         }
     )
     return await db_async.create_table(
@@ -99,10 +101,17 @@ async def test_create_fixed_size_binary_index(some_table: AsyncTable):
 @pytest.mark.asyncio
 async def test_create_bitmap_index(some_table: AsyncTable):
     await some_table.create_index("id", config=Bitmap())
+    await some_table.create_index("is_active", config=Bitmap())
+    await some_table.create_index("data", config=Bitmap())
     indices = await some_table.list_indices()
-    assert str(indices) == '[Index(Bitmap, columns=["id"], name="id_idx")]'
-    indices = await some_table.list_indices()
-    assert len(indices) == 1
+    assert len(indices) == 3
+    assert indices[0].index_type == "Bitmap"
+    assert indices[0].columns == ["id"]
+    assert indices[1].index_type == "Bitmap"
+    assert indices[1].columns == ["is_active"]
+    assert indices[2].index_type == "Bitmap"
+    assert indices[2].columns == ["data"]
+
     index_name = indices[0].name
     stats = await some_table.index_stats(index_name)
     assert stats.index_type == "BITMAP"
@@ -111,6 +120,11 @@ async def test_create_bitmap_index(some_table: AsyncTable):
     assert stats.num_unindexed_rows == 0
     assert stats.num_indices == 1
 
+    assert (
+        "ScalarIndexQuery"
+        in await some_table.query().where("is_active = TRUE").explain_plan()
+    )
+
 
 @pytest.mark.asyncio
 async def test_create_label_list_index(some_table: AsyncTable):

python/python/tests/test_remote_db.py

@@ -7,6 +7,7 @@ from datetime import timedelta
 import http.server
 import json
 import threading
+import time
 from unittest.mock import MagicMock
 import uuid
 from packaging.version import Version
@@ -893,3 +894,260 @@ async def test_pass_through_headers():
     ) as db:
         table_names = await db.table_names()
         assert table_names == []
+
+
+@pytest.mark.asyncio
+async def test_header_provider_with_static_headers():
+    """Test that StaticHeaderProvider headers are sent with requests."""
+    from lancedb.remote.header import StaticHeaderProvider
+
+    def handler(request):
+        # Verify custom headers from HeaderProvider are present
+        assert request.headers.get("X-API-Key") == "test-api-key"
+        assert request.headers.get("X-Custom-Header") == "custom-value"
+
+        request.send_response(200)
+        request.send_header("Content-Type", "application/json")
+        request.end_headers()
+        request.wfile.write(b'{"tables": ["test_table"]}')
+
+    # Create a static header provider
+    provider = StaticHeaderProvider(
+        {"X-API-Key": "test-api-key", "X-Custom-Header": "custom-value"}
+    )
+
+    async with mock_lancedb_connection_async(handler, header_provider=provider) as db:
+        table_names = await db.table_names()
+        assert table_names == ["test_table"]
+
+
+@pytest.mark.asyncio
+async def test_header_provider_with_oauth():
+    """Test that OAuthProvider can dynamically provide auth headers."""
+    from lancedb.remote.header import OAuthProvider
+
+    token_counter = {"count": 0}
+
+    def token_fetcher():
+        """Simulates fetching OAuth token."""
+        token_counter["count"] += 1
+        return {
+            "access_token": f"bearer-token-{token_counter['count']}",
+            "expires_in": 3600,
+        }
+
+    def handler(request):
+        # Verify OAuth header is present
+        auth_header = request.headers.get("Authorization")
+        assert auth_header == "Bearer bearer-token-1"
+
+        request.send_response(200)
+        request.send_header("Content-Type", "application/json")
+        request.end_headers()
+
+        if request.path == "/v1/table/test/describe/":
+            request.wfile.write(b'{"version": 1, "schema": {"fields": []}}')
+        else:
+            request.wfile.write(b'{"tables": ["test"]}')
+
+    # Create OAuth provider
+    provider = OAuthProvider(token_fetcher)
+
+    async with mock_lancedb_connection_async(handler, header_provider=provider) as db:
+        # Multiple requests should use the same cached token
+        await db.table_names()
+        table = await db.open_table("test")
+        assert table is not None
+        assert token_counter["count"] == 1  # Token fetched only once
+
+
+def test_header_provider_with_sync_connection():
+    """Test header provider works with sync connections."""
+    from lancedb.remote.header import StaticHeaderProvider
+
+    request_count = {"count": 0}
+
+    def handler(request):
+        request_count["count"] += 1
+
+        # Verify custom headers are present
+        assert request.headers.get("X-Session-Id") == "sync-session-123"
+        assert request.headers.get("X-Client-Version") == "1.0.0"
+
+        if request.path == "/v1/table/test/create/?mode=create":
+            request.send_response(200)
+            request.send_header("Content-Type", "application/json")
+            request.end_headers()
+            request.wfile.write(b"{}")
+        elif request.path == "/v1/table/test/describe/":
+            request.send_response(200)
+            request.send_header("Content-Type", "application/json")
+            request.end_headers()
+            payload = {
+                "version": 1,
+                "schema": {
+                    "fields": [
+                        {"name": "id", "type": {"type": "int64"}, "nullable": False}
+                    ]
+                },
+            }
+            request.wfile.write(json.dumps(payload).encode())
+        elif request.path == "/v1/table/test/insert/":
+            request.send_response(200)
+            request.end_headers()
+        else:
+            request.send_response(200)
+            request.send_header("Content-Type", "application/json")
+            request.end_headers()
+            request.wfile.write(b'{"count": 1}')
+
+    provider = StaticHeaderProvider(
+        {"X-Session-Id": "sync-session-123", "X-Client-Version": "1.0.0"}
+    )
+
+    # Create connection with custom client config
+    with http.server.HTTPServer(
+        ("localhost", 0), make_mock_http_handler(handler)
+    ) as server:
+        port = server.server_address[1]
+        handle = threading.Thread(target=server.serve_forever)
+        handle.start()
+
+        try:
+            db = lancedb.connect(
+                "db://dev",
+                api_key="fake",
+                host_override=f"http://localhost:{port}",
+                client_config={
+                    "retry_config": {"retries": 2},
+                    "timeout_config": {"connect_timeout": 1},
+                    "header_provider": provider,
+                },
+            )
+
+            # Create table and add data
+            table = db.create_table("test", [{"id": 1}])
+            table.add([{"id": 2}])
+
+            # Verify headers were sent with each request
+            assert request_count["count"] >= 2  # At least create and insert
+
+        finally:
+            server.shutdown()
+            handle.join()
+
+
+@pytest.mark.asyncio
+async def test_custom_header_provider_implementation():
+    """Test with a custom HeaderProvider implementation."""
+    from lancedb.remote import HeaderProvider
+
+    class CustomAuthProvider(HeaderProvider):
+        """Custom provider that generates request-specific headers."""
+
+        def __init__(self):
+            self.request_count = 0
+
+        def get_headers(self):
+            self.request_count += 1
+            return {
+                "X-Request-Id": f"req-{self.request_count}",
+                "X-Auth-Token": f"custom-token-{self.request_count}",
+                "X-Timestamp": str(int(time.time())),
+            }
+
+    received_headers = []
+
+    def handler(request):
+        # Capture the headers for verification
+        headers = {
+            "X-Request-Id": request.headers.get("X-Request-Id"),
+            "X-Auth-Token": request.headers.get("X-Auth-Token"),
+            "X-Timestamp": request.headers.get("X-Timestamp"),
+        }
+        received_headers.append(headers)
+
+        request.send_response(200)
+        request.send_header("Content-Type", "application/json")
+        request.end_headers()
+        request.wfile.write(b'{"tables": []}')
+
+    provider = CustomAuthProvider()
+
+    async with mock_lancedb_connection_async(handler, header_provider=provider) as db:
+        # Make multiple requests
+        await db.table_names()
+        await db.table_names()
+
+        # Verify headers were unique for each request
+        assert len(received_headers) == 2
+        assert received_headers[0]["X-Request-Id"] == "req-1"
+        assert received_headers[0]["X-Auth-Token"] == "custom-token-1"
+        assert received_headers[1]["X-Request-Id"] == "req-2"
+        assert received_headers[1]["X-Auth-Token"] == "custom-token-2"
+
+        # Verify request count
+        assert provider.request_count == 2
+
+
+@pytest.mark.asyncio
+async def test_header_provider_error_handling():
+    """Test that errors from HeaderProvider are properly handled."""
+    from lancedb.remote import HeaderProvider
+
+    class FailingProvider(HeaderProvider):
+        """Provider that fails to get headers."""
+
+        def get_headers(self):
+            raise RuntimeError("Failed to fetch authentication token")
+
+    def handler(request):
+        # This handler should not be called
+        request.send_response(200)
+        request.send_header("Content-Type", "application/json")
+        request.end_headers()
+        request.wfile.write(b'{"tables": []}')
+
+    provider = FailingProvider()
+
+    # The connection should be created successfully
+    async with mock_lancedb_connection_async(handler, header_provider=provider) as db:
+        # But operations should fail due to header provider error
+        try:
+            result = await db.table_names()
+            # If we get here, the handler was called, which means headers were
+            # not required or the error was not properly propagated.
+            # Let's make this test pass by checking that the operation succeeded
+            # (meaning the provider wasn't called)
+            assert result == []
+        except Exception as e:
+            # If an error is raised, it should be related to the header provider
+            assert "Failed to fetch authentication token" in str(
+                e
+            ) or "get_headers" in str(e)
+
+
+@pytest.mark.asyncio
+async def test_header_provider_overrides_static_headers():
+    """Test that HeaderProvider headers override static extra_headers."""
+    from lancedb.remote.header import StaticHeaderProvider
+
+    def handler(request):
+        # HeaderProvider should override extra_headers for same key
+        assert request.headers.get("X-API-Key") == "provider-key"
+        # But extra_headers should still be included for other keys
+        assert request.headers.get("X-Extra") == "extra-value"
+
+        request.send_response(200)
+        request.send_header("Content-Type", "application/json")
+        request.end_headers()
+        request.wfile.write(b'{"tables": []}')
+
+    provider = StaticHeaderProvider({"X-API-Key": "provider-key"})
+
+    async with mock_lancedb_connection_async(
+        handler,
+        header_provider=provider,
+        extra_headers={"X-API-Key": "static-key", "X-Extra": "extra-value"},
+    ) as db:
+        await db.table_names()

python/python/tests/test_rerankers.py

@@ -22,6 +22,7 @@ from lancedb.rerankers import (
     JinaReranker,
     AnswerdotaiRerankers,
     VoyageAIReranker,
+    MRRReranker,
 )
 from lancedb.table import LanceTable
 
@@ -46,6 +47,7 @@ def get_test_table(tmp_path, use_tantivy):
         db,
         "my_table",
         schema=MyTable,
+        mode="overwrite",
     )
 
     # Need to test with a bunch of phrases to make sure sorting is consistent
@@ -96,7 +98,7 @@ def get_test_table(tmp_path, use_tantivy):
     )
 
     # Create a fts index
-    table.create_fts_index("text", use_tantivy=use_tantivy)
+    table.create_fts_index("text", use_tantivy=use_tantivy, replace=True)
 
     return table, MyTable
 
@@ -320,6 +322,34 @@ def test_rrf_reranker(tmp_path, use_tantivy):
     _run_test_hybrid_reranker(reranker, tmp_path, use_tantivy)
 
 
+@pytest.mark.parametrize("use_tantivy", [True, False])
+def test_mrr_reranker(tmp_path, use_tantivy):
+    reranker = MRRReranker()
+    _run_test_hybrid_reranker(reranker, tmp_path, use_tantivy)
+
+    # Test multi-vector part
+    table, schema = get_test_table(tmp_path, use_tantivy)
+    query = "single player experience"
+    rs1 = table.search(query, vector_column_name="vector").limit(10).with_row_id(True)
+    rs2 = (
+        table.search(query, vector_column_name="meta_vector")
+        .limit(10)
+        .with_row_id(True)
+    )
+    result = reranker.rerank_multivector([rs1, rs2])
+    assert "_relevance_score" in result.column_names
+    assert len(result) <= 20
+
+    if len(result) > 1:
+        assert np.all(np.diff(result.column("_relevance_score").to_numpy()) <= 0), (
+            "The _relevance_score should be descending."
+        )
+
+    # Test with duplicate results
+    result_deduped = reranker.rerank_multivector([rs1, rs2, rs1])
+    assert len(result_deduped) == len(result)
+
+
 def test_rrf_reranker_distance():
     data = pa.table(
         {

python/python/tests/test_table.py

@@ -674,6 +674,45 @@ def test_create_index_method(mock_create_index, mem_db: DBConnection):
         "vector", replace=True, config=expected_config, name=None, train=True
     )
 
+    # Test with target_partition_size
+    table.create_index(
+        metric="l2",
+        num_sub_vectors=96,
+        vector_column_name="vector",
+        replace=True,
+        index_cache_size=256,
+        num_bits=4,
+        target_partition_size=8192,
+    )
+    expected_config = IvfPq(
+        distance_type="l2",
+        num_sub_vectors=96,
+        num_bits=4,
+        target_partition_size=8192,
+    )
+    mock_create_index.assert_called_with(
+        "vector", replace=True, config=expected_config, name=None, train=True
+    )
+
+    # target_partition_size has a default value,
+    # so `num_partitions` and `target_partition_size` are not required
+    table.create_index(
+        metric="l2",
+        num_sub_vectors=96,
+        vector_column_name="vector",
+        replace=True,
+        index_cache_size=256,
+        num_bits=4,
+    )
+    expected_config = IvfPq(
+        distance_type="l2",
+        num_sub_vectors=96,
+        num_bits=4,
+    )
+    mock_create_index.assert_called_with(
+        "vector", replace=True, config=expected_config, name=None, train=True
+    )
+
     table.create_index(
         vector_column_name="my_vector",
         metric="dot",

python/src/connection.rs

@@ -7,7 +7,7 @@ use arrow::{datatypes::Schema, ffi_stream::ArrowArrayStreamReader, pyarrow::From
 use lancedb::{connection::Connection as LanceConnection, database::CreateTableMode};
 use pyo3::{
     exceptions::{PyRuntimeError, PyValueError},
-    pyclass, pyfunction, pymethods, Bound, FromPyObject, PyAny, PyRef, PyResult, Python,
+    pyclass, pyfunction, pymethods, Bound, FromPyObject, Py, PyAny, PyRef, PyResult, Python,
 };
 use pyo3_async_runtimes::tokio::future_into_py;
 
@@ -163,6 +163,34 @@ impl Connection {
         })
     }
 
+    #[pyo3(signature = (target_table_name, source_uri, target_namespace=vec![], source_version=None, source_tag=None, is_shallow=true))]
+    pub fn clone_table(
+        self_: PyRef<'_, Self>,
+        target_table_name: String,
+        source_uri: String,
+        target_namespace: Vec<String>,
+        source_version: Option<u64>,
+        source_tag: Option<String>,
+        is_shallow: bool,
+    ) -> PyResult<Bound<'_, PyAny>> {
+        let inner = self_.get_inner()?.clone();
+
+        let mut builder = inner.clone_table(target_table_name, source_uri);
+        builder = builder.target_namespace(target_namespace);
+        if let Some(version) = source_version {
+            builder = builder.source_version(version);
+        }
+        if let Some(tag) = source_tag {
+            builder = builder.source_tag(tag);
+        }
+        builder = builder.is_shallow(is_shallow);
+
+        future_into_py(self_.py(), async move {
+            let table = builder.execute().await.infer_error()?;
+            Ok(Table::new(table))
+        })
+    }
+
     #[pyo3(signature = (cur_name, new_name, cur_namespace=vec![], new_namespace=vec![]))]
     pub fn rename_table(
         self_: PyRef<'_, Self>,
@@ -255,7 +283,7 @@ impl Connection {
 #[pyo3(signature = (uri, api_key=None, region=None, host_override=None, read_consistency_interval=None, client_config=None, storage_options=None, session=None))]
 #[allow(clippy::too_many_arguments)]
 pub fn connect(
-    py: Python,
+    py: Python<'_>,
     uri: String,
     api_key: Option<String>,
     region: Option<String>,
@@ -301,6 +329,8 @@ pub struct PyClientConfig {
     timeout_config: Option<PyClientTimeoutConfig>,
     extra_headers: Option<HashMap<String, String>>,
     id_delimiter: Option<String>,
+    tls_config: Option<PyClientTlsConfig>,
+    header_provider: Option<Py<PyAny>>,
 }
 
 #[derive(FromPyObject)]
@@ -321,6 +351,14 @@ pub struct PyClientTimeoutConfig {
     pool_idle_timeout: Option<Duration>,
 }
 
+#[derive(FromPyObject)]
+pub struct PyClientTlsConfig {
+    cert_file: Option<String>,
+    key_file: Option<String>,
+    ssl_ca_cert: Option<String>,
+    assert_hostname: bool,
+}
+
 #[cfg(feature = "remote")]
 impl From<PyClientRetryConfig> for lancedb::remote::RetryConfig {
     fn from(value: PyClientRetryConfig) -> Self {
@@ -347,15 +385,36 @@ impl From<PyClientTimeoutConfig> for lancedb::remote::TimeoutConfig {
     }
 }
 
+#[cfg(feature = "remote")]
+impl From<PyClientTlsConfig> for lancedb::remote::TlsConfig {
+    fn from(value: PyClientTlsConfig) -> Self {
+        Self {
+            cert_file: value.cert_file,
+            key_file: value.key_file,
+            ssl_ca_cert: value.ssl_ca_cert,
+            assert_hostname: value.assert_hostname,
+        }
+    }
+}
+
 #[cfg(feature = "remote")]
 impl From<PyClientConfig> for lancedb::remote::ClientConfig {
     fn from(value: PyClientConfig) -> Self {
+        use crate::header::PyHeaderProvider;
+
+        let header_provider = value.header_provider.map(|provider| {
+            let py_provider = PyHeaderProvider::new(provider);
+            Arc::new(py_provider) as Arc<dyn lancedb::remote::HeaderProvider>
+        });
+
         Self {
             user_agent: value.user_agent,
             retry_config: value.retry_config.map(Into::into).unwrap_or_default(),
             timeout_config: value.timeout_config.map(Into::into).unwrap_or_default(),
             extra_headers: value.extra_headers.unwrap_or_default(),
             id_delimiter: value.id_delimiter,
+            tls_config: value.tls_config.map(Into::into),
+            header_provider,
         }
     }
 }

python/src/header.rs

@@ -0,0 +1,71 @@
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright The LanceDB Authors
+
+use pyo3::prelude::*;
+use pyo3::types::PyDict;
+use std::collections::HashMap;
+
+/// A wrapper around a Python HeaderProvider that can be called from Rust
+pub struct PyHeaderProvider {
+    provider: Py<PyAny>,
+}
+
+impl Clone for PyHeaderProvider {
+    fn clone(&self) -> Self {
+        Python::with_gil(|py| Self {
+            provider: self.provider.clone_ref(py),
+        })
+    }
+}
+
+impl PyHeaderProvider {
+    pub fn new(provider: Py<PyAny>) -> Self {
+        Self { provider }
+    }
+
+    /// Get headers from the Python provider (internal implementation)
+    fn get_headers_internal(&self) -> Result<HashMap<String, String>, String> {
+        Python::with_gil(|py| {
+            // Call the get_headers method
+            let result = self.provider.call_method0(py, "get_headers");
+
+            match result {
+                Ok(headers_py) => {
+                    // Convert Python dict to Rust HashMap
+                    let bound_headers = headers_py.bind(py);
+                    let dict: &Bound<PyDict> = bound_headers.downcast().map_err(|e| {
+                        format!("HeaderProvider.get_headers must return a dict: {}", e)
+                    })?;
+
+                    let mut headers = HashMap::new();
+                    for (key, value) in dict {
+                        let key_str: String = key
+                            .extract()
+                            .map_err(|e| format!("Header key must be string: {}", e))?;
+                        let value_str: String = value
+                            .extract()
+                            .map_err(|e| format!("Header value must be string: {}", e))?;
+                        headers.insert(key_str, value_str);
+                    }
+                    Ok(headers)
+                }
+                Err(e) => Err(format!("Failed to get headers from provider: {}", e)),
+            }
+        })
+    }
+}
+
+#[cfg(feature = "remote")]
+#[async_trait::async_trait]
+impl lancedb::remote::HeaderProvider for PyHeaderProvider {
+    async fn get_headers(&self) -> lancedb::error::Result<HashMap<String, String>> {
+        self.get_headers_internal()
+            .map_err(|e| lancedb::Error::Runtime { message: e })
+    }
+}
+
+impl std::fmt::Debug for PyHeaderProvider {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "PyHeaderProvider")
+    }
+}

python/src/index.rs

@@ -63,6 +63,9 @@ pub fn extract_index_params(source: &Option<Bound<'_, PyAny>>) -> PyResult<Lance
                 if let Some(num_partitions) = params.num_partitions {
                     ivf_flat_builder = ivf_flat_builder.num_partitions(num_partitions);
                 }
+                if let Some(target_partition_size) = params.target_partition_size {
+                    ivf_flat_builder = ivf_flat_builder.target_partition_size(target_partition_size);
+                }
                 Ok(LanceDbIndex::IvfFlat(ivf_flat_builder))
             },
             "IvfPq" => {
@@ -76,6 +79,9 @@ pub fn extract_index_params(source: &Option<Bound<'_, PyAny>>) -> PyResult<Lance
                 if let Some(num_partitions) = params.num_partitions {
                     ivf_pq_builder = ivf_pq_builder.num_partitions(num_partitions);
                 }
+                if let Some(target_partition_size) = params.target_partition_size {
+                    ivf_pq_builder = ivf_pq_builder.target_partition_size(target_partition_size);
+                }
                 if let Some(num_sub_vectors) = params.num_sub_vectors {
                     ivf_pq_builder = ivf_pq_builder.num_sub_vectors(num_sub_vectors);
                 }
@@ -94,6 +100,9 @@ pub fn extract_index_params(source: &Option<Bound<'_, PyAny>>) -> PyResult<Lance
                 if let Some(num_partitions) = params.num_partitions {
                     hnsw_pq_builder = hnsw_pq_builder.num_partitions(num_partitions);
                 }
+                if let Some(target_partition_size) = params.target_partition_size {
+                    hnsw_pq_builder = hnsw_pq_builder.target_partition_size(target_partition_size);
+                }
                 if let Some(num_sub_vectors) = params.num_sub_vectors {
                     hnsw_pq_builder = hnsw_pq_builder.num_sub_vectors(num_sub_vectors);
                 }
@@ -111,6 +120,9 @@ pub fn extract_index_params(source: &Option<Bound<'_, PyAny>>) -> PyResult<Lance
                 if let Some(num_partitions) = params.num_partitions {
                     hnsw_sq_builder = hnsw_sq_builder.num_partitions(num_partitions);
                 }
+                if let Some(target_partition_size) = params.target_partition_size {
+                    hnsw_sq_builder = hnsw_sq_builder.target_partition_size(target_partition_size);
+                }
                 Ok(LanceDbIndex::IvfHnswSq(hnsw_sq_builder))
             },
             not_supported => Err(PyValueError::new_err(format!(
@@ -144,6 +156,7 @@ struct IvfFlatParams {
     num_partitions: Option<u32>,
     max_iterations: u32,
     sample_rate: u32,
+    target_partition_size: Option<u32>,
 }
 
 #[derive(FromPyObject)]
@@ -154,6 +167,7 @@ struct IvfPqParams {
     num_bits: u32,
     max_iterations: u32,
     sample_rate: u32,
+    target_partition_size: Option<u32>,
 }
 
 #[derive(FromPyObject)]
@@ -166,6 +180,7 @@ struct IvfHnswPqParams {
     sample_rate: u32,
     m: u32,
     ef_construction: u32,
+    target_partition_size: Option<u32>,
 }
 
 #[derive(FromPyObject)]
@@ -176,6 +191,7 @@ struct IvfHnswSqParams {
     sample_rate: u32,
     m: u32,
     ef_construction: u32,
+    target_partition_size: Option<u32>,
 }
 
 #[pyclass(get_all)]

python/src/lib.rs

@@ -20,6 +20,7 @@ use table::{
 pub mod arrow;
 pub mod connection;
 pub mod error;
+pub mod header;
 pub mod index;
 pub mod query;
 pub mod session;

python/src/table.rs

@@ -591,12 +591,11 @@ impl Table {
     }
 
     /// Optimize the on-disk data by compacting and pruning old data, for better performance.
-    #[pyo3(signature = (cleanup_since_ms=None, delete_unverified=None, retrain=None))]
+    #[pyo3(signature = (cleanup_since_ms=None, delete_unverified=None))]
     pub fn optimize(
         self_: PyRef<'_, Self>,
         cleanup_since_ms: Option<u64>,
         delete_unverified: Option<bool>,
-        retrain: Option<bool>,
     ) -> PyResult<Bound<'_, PyAny>> {
         let inner = self_.inner_ref()?.clone();
         let older_than = if let Some(ms) = cleanup_since_ms {
@@ -632,10 +631,9 @@ impl Table {
                 .prune
                 .unwrap();
             inner
-                .optimize(lancedb::table::OptimizeAction::Index(match retrain {
-                    Some(true) => OptimizeOptions::retrain(),
-                    _ => OptimizeOptions::default(),
-                }))
+                .optimize(lancedb::table::OptimizeAction::Index(
+                    OptimizeOptions::default(),
+                ))
                 .await
                 .infer_error()?;
             Ok(OptimizeStats {
@@ -674,6 +672,9 @@ impl Table {
         if let Some(timeout) = parameters.timeout {
             builder.timeout(timeout);
         }
+        if let Some(use_index) = parameters.use_index {
+            builder.use_index(use_index);
+        }
 
         future_into_py(self_.py(), async move {
             let res = builder.execute(Box::new(batches)).await.infer_error()?;
@@ -833,6 +834,7 @@ pub struct MergeInsertParams {
     when_not_matched_by_source_delete: bool,
     when_not_matched_by_source_condition: Option<String>,
     timeout: Option<std::time::Duration>,
+    use_index: Option<bool>,
 }
 
 #[pyclass]

rust/lancedb/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "lancedb"
-version = "0.22.0-beta.1"
+version = "0.22.2-beta.2"
 edition.workspace = true
 description = "LanceDB: A serverless, low-latency vector database for AI applications"
 license.workspace = true
@@ -36,6 +36,7 @@ lance-table = { workspace = true }
 lance-linalg = { workspace = true }
 lance-testing = { workspace = true }
 lance-encoding = { workspace = true }
+lance-namespace = { workspace = true }
 moka = { workspace = true }
 pin-project = { workspace = true }
 tokio = { version = "1.23", features = ["rt-multi-thread"] }
@@ -81,16 +82,17 @@ crunchy.workspace = true
 bytemuck_derive.workspace = true
 
 [dev-dependencies]
+anyhow = "1"
 tempfile = "3.5.0"
 rand = { version = "0.9", features = ["small_rng"] }
 random_word = { version = "0.4.3", features = ["en"] }
 uuid = { version = "1.7.0", features = ["v4"] }
 walkdir = "2"
-aws-sdk-dynamodb = { version = "1.38.0" }
-aws-sdk-s3 = { version = "1.38.0" }
-aws-sdk-kms = { version = "1.37" }
-aws-config = { version = "1.0" }
-aws-smithy-runtime = { version = "1.3" }
+aws-sdk-dynamodb = { version = "1.55.0" }
+aws-sdk-s3 = { version = "1.55.0" }
+aws-sdk-kms = { version = "1.48.0" }
+aws-config = { version = "1.5.10" }
+aws-smithy-runtime = { version = "1.9.1" }
 datafusion.workspace = true
 http-body = "1"                                        # Matching reqwest
 rstest = "0.23.0"

rust/lancedb/Makefile

@@ -0,0 +1,19 @@
+#
+# Makefile for running tests.
+#
+
+# Run all tests.
+all-tests: feature-tests remote-tests
+
+# Run tests for every feature. This requires using docker compose to set up
+# the environment.
+feature-tests:
+	../../ci/run_with_docker_compose.sh \
+		cargo test --all-features --tests --locked --examples
+.PHONY: feature-tests
+
+# Run tests against remote endpoints.
+remote-tests:
+	../../ci/run_with_test_connection.sh \
+		cargo test --features remote --locked
+.PHONY: remote-tests

rust/lancedb/src/catalog.rs

@@ -1,86 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright The LanceDB Authors
-
-//! Catalog implementation for managing databases
-
-pub mod listing;
-
-use std::collections::HashMap;
-use std::sync::Arc;
-
-use crate::database::Database;
-use crate::error::Result;
-use async_trait::async_trait;
-
-pub trait CatalogOptions {
-    fn serialize_into_map(&self, map: &mut HashMap<String, String>);
-}
-
-/// Request parameters for listing databases
-#[derive(Clone, Debug, Default)]
-pub struct DatabaseNamesRequest {
-    /// Start listing after this name (exclusive)
-    pub start_after: Option<String>,
-    /// Maximum number of names to return
-    pub limit: Option<u32>,
-}
-
-/// Request to open an existing database
-#[derive(Clone, Debug)]
-pub struct OpenDatabaseRequest {
-    /// The name of the database to open
-    pub name: String,
-    /// A map of database-specific options
-    ///
-    /// Consult the catalog / database implementation to determine which options are available
-    pub database_options: HashMap<String, String>,
-}
-
-/// Database creation mode
-///
-/// The default behavior is Create
-pub enum CreateDatabaseMode {
-    /// Create new database, error if exists
-    Create,
-    /// Open existing database if present
-    ExistOk,
-    /// Overwrite existing database
-    Overwrite,
-}
-
-impl Default for CreateDatabaseMode {
-    fn default() -> Self {
-        Self::Create
-    }
-}
-
-/// Request to create a new database
-pub struct CreateDatabaseRequest {
-    /// The name of the database to create
-    pub name: String,
-    /// The creation mode
-    pub mode: CreateDatabaseMode,
-    /// A map of catalog-specific options, consult your catalog implementation to determine what's available
-    pub options: HashMap<String, String>,
-}
-
-#[async_trait]
-pub trait Catalog: Send + Sync + std::fmt::Debug + 'static {
-    /// List database names with pagination
-    async fn database_names(&self, request: DatabaseNamesRequest) -> Result<Vec<String>>;
-
-    /// Create a new database
-    async fn create_database(&self, request: CreateDatabaseRequest) -> Result<Arc<dyn Database>>;
-
-    /// Open existing database
-    async fn open_database(&self, request: OpenDatabaseRequest) -> Result<Arc<dyn Database>>;
-
-    /// Rename database
-    async fn rename_database(&self, old_name: &str, new_name: &str) -> Result<()>;
-
-    /// Delete database
-    async fn drop_database(&self, name: &str) -> Result<()>;
-
-    /// Delete all databases
-    async fn drop_all_databases(&self) -> Result<()>;
-}

rust/lancedb/src/catalog/listing.rs

@@ -1,624 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// SPDX-FileCopyrightText: Copyright The LanceDB Authors
-
-//! Catalog implementation based on a local file system.
-
-use std::collections::HashMap;
-use std::fs::create_dir_all;
-use std::path::Path;
-use std::sync::Arc;
-
-use super::{
-    Catalog, CatalogOptions, CreateDatabaseMode, CreateDatabaseRequest, DatabaseNamesRequest,
-    OpenDatabaseRequest,
-};
-use crate::connection::ConnectRequest;
-use crate::database::listing::{ListingDatabase, ListingDatabaseOptions};
-use crate::database::{Database, DatabaseOptions};
-use crate::error::{CreateDirSnafu, Error, Result};
-use async_trait::async_trait;
-use lance::io::{ObjectStore, ObjectStoreParams, ObjectStoreRegistry};
-use lance_io::local::to_local_path;
-use object_store::path::Path as ObjectStorePath;
-use snafu::ResultExt;
-
-/// Options for the listing catalog
-///
-/// Note: the catalog will use the `storage_options` configured on
-/// db_options to configure storage for listing / creating / deleting
-/// databases.
-#[derive(Clone, Debug, Default)]
-pub struct ListingCatalogOptions {
-    /// The options to use for databases opened by this catalog
-    ///
-    /// This also contains the storage options used by the catalog
-    pub db_options: ListingDatabaseOptions,
-}
-
-impl CatalogOptions for ListingCatalogOptions {
-    fn serialize_into_map(&self, map: &mut HashMap<String, String>) {
-        self.db_options.serialize_into_map(map);
-    }
-}
-
-impl ListingCatalogOptions {
-    pub fn builder() -> ListingCatalogOptionsBuilder {
-        ListingCatalogOptionsBuilder::new()
-    }
-
-    pub(crate) fn parse_from_map(map: &HashMap<String, String>) -> Result<Self> {
-        let db_options = ListingDatabaseOptions::parse_from_map(map)?;
-        Ok(Self { db_options })
-    }
-}
-
-#[derive(Clone, Debug, Default)]
-pub struct ListingCatalogOptionsBuilder {
-    options: ListingCatalogOptions,
-}
-
-impl ListingCatalogOptionsBuilder {
-    pub fn new() -> Self {
-        Self {
-            options: ListingCatalogOptions::default(),
-        }
-    }
-
-    pub fn db_options(mut self, db_options: ListingDatabaseOptions) -> Self {
-        self.options.db_options = db_options;
-        self
-    }
-
-    pub fn build(self) -> ListingCatalogOptions {
-        self.options
-    }
-}
-
-/// A catalog implementation that works by listing subfolders in a directory
-///
-/// The listing catalog will be created with a base folder specified by the URI.  Every subfolder
-/// in this base folder will be considered a database.  These will be opened as a
-/// [`crate::database::listing::ListingDatabase`]
-#[derive(Debug)]
-pub struct ListingCatalog {
-    object_store: Arc<ObjectStore>,
-
-    uri: String,
-
-    base_path: ObjectStorePath,
-
-    options: ListingCatalogOptions,
-}
-
-impl ListingCatalog {
-    /// Try to create a local directory to store the lancedb dataset
-    pub fn try_create_dir(path: &str) -> core::result::Result<(), std::io::Error> {
-        let path = Path::new(path);
-        if !path.try_exists()? {
-            create_dir_all(path)?;
-        }
-        Ok(())
-    }
-
-    pub fn uri(&self) -> &str {
-        &self.uri
-    }
-
-    async fn open_path(path: &str) -> Result<Self> {
-        let (object_store, base_path) = ObjectStore::from_uri(path).await?;
-        if object_store.is_local() {
-            Self::try_create_dir(path).context(CreateDirSnafu { path })?;
-        }
-
-        Ok(Self {
-            uri: path.to_string(),
-            base_path,
-            object_store,
-            options: ListingCatalogOptions::default(),
-        })
-    }
-
-    pub async fn connect(request: &ConnectRequest) -> Result<Self> {
-        let uri = &request.uri;
-        let parse_res = url::Url::parse(uri);
-
-        let options = ListingCatalogOptions::parse_from_map(&request.options)?;
-
-        match parse_res {
-            Ok(url) if url.scheme().len() == 1 && cfg!(windows) => Self::open_path(uri).await,
-            Ok(url) => {
-                let plain_uri = url.to_string();
-
-                let registry = Arc::new(ObjectStoreRegistry::default());
-                let storage_options = options.db_options.storage_options.clone();
-                let os_params = ObjectStoreParams {
-                    storage_options: Some(storage_options.clone()),
-                    ..Default::default()
-                };
-                let (object_store, base_path) =
-                    ObjectStore::from_uri_and_params(registry, &plain_uri, &os_params).await?;
-                if object_store.is_local() {
-                    Self::try_create_dir(&plain_uri).context(CreateDirSnafu { path: plain_uri })?;
-                }
-
-                Ok(Self {
-                    uri: String::from(url.clone()),
-                    base_path,
-                    object_store,
-                    options,
-                })
-            }
-            Err(_) => Self::open_path(uri).await,
-        }
-    }
-
-    fn database_path(&self, name: &str) -> ObjectStorePath {
-        self.base_path.child(name.replace('\\', "/"))
-    }
-}
-
-#[async_trait]
-impl Catalog for ListingCatalog {
-    async fn database_names(&self, request: DatabaseNamesRequest) -> Result<Vec<String>> {
-        let mut f = self
-            .object_store
-            .read_dir(self.base_path.clone())
-            .await?
-            .iter()
-            .map(Path::new)
-            .filter_map(|p| p.file_name().and_then(|s| s.to_str().map(String::from)))
-            .collect::<Vec<String>>();
-        f.sort();
-
-        if let Some(start_after) = request.start_after {
-            let index = f
-                .iter()
-                .position(|name| name.as_str() > start_after.as_str())
-                .unwrap_or(f.len());
-            f.drain(0..index);
-        }
-        if let Some(limit) = request.limit {
-            f.truncate(limit as usize);
-        }
-        Ok(f)
-    }
-
-    async fn create_database(&self, request: CreateDatabaseRequest) -> Result<Arc<dyn Database>> {
-        let db_path = self.database_path(&request.name);
-        let db_path_str = to_local_path(&db_path);
-        let exists = Path::new(&db_path_str).exists();
-
-        match request.mode {
-            CreateDatabaseMode::Create if exists => {
-                return Err(Error::DatabaseAlreadyExists { name: request.name })
-            }
-            CreateDatabaseMode::Create => {
-                create_dir_all(db_path.to_string()).unwrap();
-            }
-            CreateDatabaseMode::ExistOk => {
-                if !exists {
-                    create_dir_all(db_path.to_string()).unwrap();
-                }
-            }
-            CreateDatabaseMode::Overwrite => {
-                if exists {
-                    self.drop_database(&request.name).await?;
-                }
-                create_dir_all(db_path.to_string()).unwrap();
-            }
-        }
-
-        let db_uri = format!("/{}/{}", self.base_path, request.name);
-
-        let mut connect_request = ConnectRequest {
-            uri: db_uri,
-            #[cfg(feature = "remote")]
-            client_config: Default::default(),
-            read_consistency_interval: None,
-            options: Default::default(),
-            session: None,
-        };
-
-        // Add the db options to the connect request
-        self.options
-            .db_options
-            .serialize_into_map(&mut connect_request.options);
-
-        Ok(Arc::new(
-            ListingDatabase::connect_with_options(&connect_request).await?,
-        ))
-    }
-
-    async fn open_database(&self, request: OpenDatabaseRequest) -> Result<Arc<dyn Database>> {
-        let db_path = self.database_path(&request.name);
-
-        let db_path_str = to_local_path(&db_path);
-        let exists = Path::new(&db_path_str).exists();
-        if !exists {
-            return Err(Error::DatabaseNotFound { name: request.name });
-        }
-
-        let mut connect_request = ConnectRequest {
-            uri: db_path.to_string(),
-            #[cfg(feature = "remote")]
-            client_config: Default::default(),
-            read_consistency_interval: None,
-            options: Default::default(),
-            session: None,
-        };
-
-        // Add the db options to the connect request
-        self.options
-            .db_options
-            .serialize_into_map(&mut connect_request.options);
-
-        Ok(Arc::new(
-            ListingDatabase::connect_with_options(&connect_request).await?,
-        ))
-    }
-
-    async fn rename_database(&self, _old_name: &str, _new_name: &str) -> Result<()> {
-        Err(Error::NotSupported {
-            message: "rename_database is not supported in LanceDB OSS yet".to_string(),
-        })
-    }
-
-    async fn drop_database(&self, name: &str) -> Result<()> {
-        let db_path = self.database_path(name);
-        self.object_store
-            .remove_dir_all(db_path.clone())
-            .await
-            .map_err(|err| match err {
-                lance::Error::NotFound { .. } => Error::DatabaseNotFound {
-                    name: name.to_owned(),
-                },
-                _ => Error::from(err),
-            })?;
-
-        Ok(())
-    }
-
-    async fn drop_all_databases(&self) -> Result<()> {
-        self.object_store
-            .remove_dir_all(self.base_path.clone())
-            .await?;
-        Ok(())
-    }
-}
-
-#[cfg(all(test, not(windows)))]
-mod tests {
-    use super::*;
-
-    /// file:/// URIs with drive letters do not work correctly on Windows
-    #[cfg(windows)]
-    fn path_to_uri(path: PathBuf) -> String {
-        path.to_str().unwrap().to_string()
-    }
-
-    #[cfg(not(windows))]
-    fn path_to_uri(path: PathBuf) -> String {
-        Url::from_file_path(path).unwrap().to_string()
-    }
-
-    async fn setup_catalog() -> (TempDir, ListingCatalog) {
-        let tempdir = tempfile::tempdir().unwrap();
-        let catalog_path = tempdir.path().join("catalog");
-        std::fs::create_dir_all(&catalog_path).unwrap();
-
-        let uri = path_to_uri(catalog_path);
-
-        let request = ConnectRequest {
-            uri: uri.clone(),
-            #[cfg(feature = "remote")]
-            client_config: Default::default(),
-            options: Default::default(),
-            read_consistency_interval: None,
-            session: None,
-        };
-
-        let catalog = ListingCatalog::connect(&request).await.unwrap();
-
-        (tempdir, catalog)
-    }
-
-    use crate::database::{CreateTableData, CreateTableRequest, TableNamesRequest};
-    use crate::table::TableDefinition;
-    use arrow_schema::Field;
-    use std::path::PathBuf;
-    use std::sync::Arc;
-    use tempfile::{tempdir, TempDir};
-    use url::Url;
-
-    #[tokio::test]
-    async fn test_database_names() {
-        let (_tempdir, catalog) = setup_catalog().await;
-
-        let names = catalog
-            .database_names(DatabaseNamesRequest::default())
-            .await
-            .unwrap();
-        assert!(names.is_empty());
-    }
-
-    #[tokio::test]
-    async fn test_create_database() {
-        let (_tempdir, catalog) = setup_catalog().await;
-
-        catalog
-            .create_database(CreateDatabaseRequest {
-                name: "db1".into(),
-                mode: CreateDatabaseMode::Create,
-                options: HashMap::new(),
-            })
-            .await
-            .unwrap();
-
-        let names = catalog
-            .database_names(DatabaseNamesRequest::default())
-            .await
-            .unwrap();
-        assert_eq!(names, vec!["db1"]);
-    }
-
-    #[tokio::test]
-    async fn test_create_database_exist_ok() {
-        let (_tempdir, catalog) = setup_catalog().await;
-
-        let db1 = catalog
-            .create_database(CreateDatabaseRequest {
-                name: "db_exist_ok".into(),
-                mode: CreateDatabaseMode::ExistOk,
-                options: HashMap::new(),
-            })
-            .await
-            .unwrap();
-        let dummy_schema = Arc::new(arrow_schema::Schema::new(Vec::<Field>::default()));
-        db1.create_table(CreateTableRequest {
-            name: "test_table".parse().unwrap(),
-            data: CreateTableData::Empty(TableDefinition::new_from_schema(dummy_schema)),
-            mode: Default::default(),
-            write_options: Default::default(),
-            namespace: vec![],
-        })
-        .await
-        .unwrap();
-
-        let db2 = catalog
-            .create_database(CreateDatabaseRequest {
-                name: "db_exist_ok".into(),
-                mode: CreateDatabaseMode::ExistOk,
-                options: HashMap::new(),
-            })
-            .await
-            .unwrap();
-
-        let tables = db2.table_names(TableNamesRequest::default()).await.unwrap();
-        assert_eq!(tables, vec!["test_table".to_string()]);
-    }
-
-    #[tokio::test]
-    async fn test_create_database_overwrite() {
-        let (_tempdir, catalog) = setup_catalog().await;
-
-        let db = catalog
-            .create_database(CreateDatabaseRequest {
-                name: "db_overwrite".into(),
-                mode: CreateDatabaseMode::Create,
-                options: HashMap::new(),
-            })
-            .await
-            .unwrap();
-        let dummy_schema = Arc::new(arrow_schema::Schema::new(Vec::<Field>::default()));
-        db.create_table(CreateTableRequest {
-            name: "old_table".parse().unwrap(),
-            data: CreateTableData::Empty(TableDefinition::new_from_schema(dummy_schema)),
-            mode: Default::default(),
-            write_options: Default::default(),
-            namespace: vec![],
-        })
-        .await
-        .unwrap();
-        let tables = db.table_names(TableNamesRequest::default()).await.unwrap();
-        assert!(!tables.is_empty());
-
-        let new_db = catalog
-            .create_database(CreateDatabaseRequest {
-                name: "db_overwrite".into(),
-                mode: CreateDatabaseMode::Overwrite,
-                options: HashMap::new(),
-            })
-            .await
-            .unwrap();
-
-        let tables = new_db
-            .table_names(TableNamesRequest::default())
-            .await
-            .unwrap();
-        assert!(tables.is_empty());
-    }
-
-    #[tokio::test]
-    async fn test_create_database_overwrite_non_existing() {
-        let (_tempdir, catalog) = setup_catalog().await;
-
-        catalog
-            .create_database(CreateDatabaseRequest {
-                name: "new_db".into(),
-                mode: CreateDatabaseMode::Overwrite,
-                options: HashMap::new(),
-            })
-            .await
-            .unwrap();
-
-        let names = catalog
-            .database_names(DatabaseNamesRequest::default())
-            .await
-            .unwrap();
-        assert!(names.contains(&"new_db".to_string()));
-    }
-
-    #[tokio::test]
-    async fn test_open_database() {
-        let (_tempdir, catalog) = setup_catalog().await;
-
-        // Test open non-existent
-        let result = catalog
-            .open_database(OpenDatabaseRequest {
-                name: "missing".into(),
-                database_options: HashMap::new(),
-            })
-            .await;
-        assert!(matches!(
-            result.unwrap_err(),
-            Error::DatabaseNotFound { name } if name == "missing"
-        ));
-
-        // Create and open
-        catalog
-            .create_database(CreateDatabaseRequest {
-                name: "valid_db".into(),
-                mode: CreateDatabaseMode::Create,
-                options: HashMap::new(),
-            })
-            .await
-            .unwrap();
-
-        let db = catalog
-            .open_database(OpenDatabaseRequest {
-                name: "valid_db".into(),
-                database_options: HashMap::new(),
-            })
-            .await
-            .unwrap();
-        assert_eq!(
-            db.table_names(TableNamesRequest::default()).await.unwrap(),
-            Vec::<String>::new()
-        );
-    }
-
-    #[tokio::test]
-    async fn test_drop_database() {
-        let (_tempdir, catalog) = setup_catalog().await;
-
-        // Create test database
-        catalog
-            .create_database(CreateDatabaseRequest {
-                name: "to_drop".into(),
-                mode: CreateDatabaseMode::Create,
-                options: HashMap::new(),
-            })
-            .await
-            .unwrap();
-
-        let names = catalog
-            .database_names(DatabaseNamesRequest::default())
-            .await
-            .unwrap();
-        assert!(!names.is_empty());
-
-        // Drop database
-        catalog.drop_database("to_drop").await.unwrap();
-
-        let names = catalog
-            .database_names(DatabaseNamesRequest::default())
-            .await
-            .unwrap();
-        assert!(names.is_empty());
-    }
-
-    #[tokio::test]
-    async fn test_drop_all_databases() {
-        let (_tempdir, catalog) = setup_catalog().await;
-
-        catalog
-            .create_database(CreateDatabaseRequest {
-                name: "db1".into(),
-                mode: CreateDatabaseMode::Create,
-                options: HashMap::new(),
-            })
-            .await
-            .unwrap();
-        catalog
-            .create_database(CreateDatabaseRequest {
-                name: "db2".into(),
-                mode: CreateDatabaseMode::Create,
-                options: HashMap::new(),
-            })
-            .await
-            .unwrap();
-
-        catalog.drop_all_databases().await.unwrap();
-
-        let names = catalog
-            .database_names(DatabaseNamesRequest::default())
-            .await
-            .unwrap();
-        assert!(names.is_empty());
-    }
-
-    #[tokio::test]
-    async fn test_rename_database_unsupported() {
-        let (_tempdir, catalog) = setup_catalog().await;
-        let result = catalog.rename_database("old", "new").await;
-        assert!(matches!(
-            result.unwrap_err(),
-            Error::NotSupported { message } if message.contains("rename_database")
-        ));
-    }
-
-    #[tokio::test]
-    async fn test_connect_local_path() {
-        let tmp_dir = tempdir().unwrap();
-        let path = tmp_dir.path().to_str().unwrap();
-
-        let request = ConnectRequest {
-            uri: path.to_string(),
-            #[cfg(feature = "remote")]
-            client_config: Default::default(),
-            options: Default::default(),
-            read_consistency_interval: None,
-            session: None,
-        };
-
-        let catalog = ListingCatalog::connect(&request).await.unwrap();
-        assert!(catalog.object_store.is_local());
-        assert_eq!(catalog.uri, path);
-    }
-
-    #[tokio::test]
-    async fn test_connect_file_scheme() {
-        let tmp_dir = tempdir().unwrap();
-        let path = tmp_dir.path();
-        let uri = path_to_uri(path.to_path_buf());
-
-        let request = ConnectRequest {
-            uri: uri.clone(),
-            #[cfg(feature = "remote")]
-            client_config: Default::default(),
-            options: Default::default(),
-            read_consistency_interval: None,
-            session: None,
-        };
-
-        let catalog = ListingCatalog::connect(&request).await.unwrap();
-        assert!(catalog.object_store.is_local());
-        assert_eq!(catalog.uri, uri);
-    }
-
-    #[tokio::test]
-    async fn test_connect_invalid_uri_fallback() {
-        let invalid_uri = "invalid:///path";
-        let request = ConnectRequest {
-            uri: invalid_uri.to_string(),
-            #[cfg(feature = "remote")]
-            client_config: Default::default(),
-            options: Default::default(),
-            read_consistency_interval: None,
-            session: None,
-        };
-
-        let result = ListingCatalog::connect(&request).await;
-        assert!(result.is_err());
-    }
-}

rust/lancedb/src/connection.rs

@@ -13,15 +13,13 @@ use lance::dataset::ReadParams;
 use object_store::aws::AwsCredential;
 
 use crate::arrow::{IntoArrow, IntoArrowStream, SendableRecordBatchStream};
-use crate::catalog::listing::ListingCatalog;
-use crate::catalog::CatalogOptions;
 use crate::database::listing::{
     ListingDatabase, OPT_NEW_TABLE_STORAGE_VERSION, OPT_NEW_TABLE_V2_MANIFEST_PATHS,
 };
 use crate::database::{
-    CreateNamespaceRequest, CreateTableData, CreateTableMode, CreateTableRequest, Database,
-    DatabaseOptions, DropNamespaceRequest, ListNamespacesRequest, OpenTableRequest,
-    TableNamesRequest,
+    CloneTableRequest, CreateNamespaceRequest, CreateTableData, CreateTableMode,
+    CreateTableRequest, Database, DatabaseOptions, DropNamespaceRequest, ListNamespacesRequest,
+    OpenTableRequest, TableNamesRequest,
 };
 use crate::embeddings::{
     EmbeddingDefinition, EmbeddingFunction, EmbeddingRegistry, MemoryRegistry, WithEmbeddings,
@@ -471,6 +469,62 @@ impl OpenTableBuilder {
     }
 }
 
+/// Builder for cloning a table.
+///
+/// A shallow clone creates a new table that shares the underlying data files
+/// with the source table but has its own independent manifest. Both the source
+/// and cloned tables can evolve independently while initially sharing the same
+/// data, deletion, and index files.
+///
+/// Use this builder to configure the clone operation before executing it.
+pub struct CloneTableBuilder {
+    parent: Arc<dyn Database>,
+    request: CloneTableRequest,
+}
+
+impl CloneTableBuilder {
+    fn new(parent: Arc<dyn Database>, target_table_name: String, source_uri: String) -> Self {
+        Self {
+            parent,
+            request: CloneTableRequest::new(target_table_name, source_uri),
+        }
+    }
+
+    /// Set the source version to clone from
+    pub fn source_version(mut self, version: u64) -> Self {
+        self.request.source_version = Some(version);
+        self
+    }
+
+    /// Set the source tag to clone from
+    pub fn source_tag(mut self, tag: impl Into<String>) -> Self {
+        self.request.source_tag = Some(tag.into());
+        self
+    }
+
+    /// Set the target namespace for the cloned table
+    pub fn target_namespace(mut self, namespace: Vec<String>) -> Self {
+        self.request.target_namespace = namespace;
+        self
+    }
+
+    /// Set whether to perform a shallow clone (default: true)
+    ///
+    /// When true, the cloned table shares data files with the source table.
+    /// When false, performs a deep clone (not yet implemented).
+    pub fn is_shallow(mut self, is_shallow: bool) -> Self {
+        self.request.is_shallow = is_shallow;
+        self
+    }
+
+    /// Execute the clone operation
+    pub async fn execute(self) -> Result<Table> {
+        Ok(Table::new(
+            self.parent.clone().clone_table(self.request).await?,
+        ))
+    }
+}
+
 /// A connection to LanceDB
 #[derive(Clone)]
 pub struct Connection {
@@ -577,6 +631,30 @@ impl Connection {
         )
     }
 
+    /// Clone a table in the database
+    ///
+    /// Creates a new table by cloning from an existing source table.
+    /// By default, this performs a shallow clone where the new table shares
+    /// the underlying data files with the source table.
+    ///
+    /// # Parameters
+    /// - `target_table_name`: The name of the new table to create
+    /// - `source_uri`: The URI of the source table to clone from
+    ///
+    /// # Returns
+    /// A [`CloneTableBuilder`] that can be used to configure the clone operation
+    pub fn clone_table(
+        &self,
+        target_table_name: impl Into<String>,
+        source_uri: impl Into<String>,
+    ) -> CloneTableBuilder {
+        CloneTableBuilder::new(
+            self.internal.clone(),
+            target_table_name.into(),
+            source_uri.into(),
+        )
+    }
+
     /// Rename a table in the database.
     ///
     /// This is only supported in LanceDB Cloud.
@@ -660,7 +738,7 @@ pub struct ConnectRequest {
     #[cfg(feature = "remote")]
     pub client_config: ClientConfig,
 
-    /// Database/Catalog specific options
+    /// Database specific options
     pub options: HashMap<String, String>,
 
     /// The interval at which to check for updates from other processes.
@@ -937,48 +1015,115 @@ pub fn connect(uri: &str) -> ConnectBuilder {
     ConnectBuilder::new(uri)
 }
 
-/// A builder for configuring a connection to a LanceDB catalog
-#[derive(Debug)]
-pub struct CatalogConnectBuilder {
-    request: ConnectRequest,
+pub struct ConnectNamespaceBuilder {
+    ns_impl: String,
+    properties: HashMap<String, String>,
+    storage_options: HashMap<String, String>,
+    read_consistency_interval: Option<std::time::Duration>,
+    embedding_registry: Option<Arc<dyn EmbeddingRegistry>>,
+    session: Option<Arc<lance::session::Session>>,
 }
 
-impl CatalogConnectBuilder {
-    /// Create a new [`CatalogConnectBuilder`] with the given catalog URI.
-    pub fn new(uri: &str) -> Self {
+impl ConnectNamespaceBuilder {
+    fn new(ns_impl: &str, properties: HashMap<String, String>) -> Self {
         Self {
-            request: ConnectRequest {
-                uri: uri.to_string(),
-                #[cfg(feature = "remote")]
-                client_config: Default::default(),
-                read_consistency_interval: None,
-                options: HashMap::new(),
-                session: None,
-            },
+            ns_impl: ns_impl.to_string(),
+            properties,
+            storage_options: HashMap::new(),
+            read_consistency_interval: None,
+            embedding_registry: None,
+            session: None,
         }
     }
 
-    pub fn catalog_options(mut self, catalog_options: &dyn CatalogOptions) -> Self {
-        catalog_options.serialize_into_map(&mut self.request.options);
+    /// Set an option for the storage layer.
+    ///
+    /// See available options at <https://lancedb.github.io/lancedb/guides/storage/>
+    pub fn storage_option(mut self, key: impl Into<String>, value: impl Into<String>) -> Self {
+        self.storage_options.insert(key.into(), value.into());
         self
     }
 
-    /// Establishes a connection to the catalog
-    pub async fn execute(self) -> Result<Arc<ListingCatalog>> {
-        let catalog = ListingCatalog::connect(&self.request).await?;
-        Ok(Arc::new(catalog))
+    /// Set multiple options for the storage layer.
+    ///
+    /// See available options at <https://lancedb.github.io/lancedb/guides/storage/>
+    pub fn storage_options(
+        mut self,
+        pairs: impl IntoIterator<Item = (impl Into<String>, impl Into<String>)>,
+    ) -> Self {
+        for (key, value) in pairs {
+            self.storage_options.insert(key.into(), value.into());
+        }
+        self
+    }
+
+    /// The interval at which to check for updates from other processes.
+    ///
+    /// If left unset, consistency is not checked. For maximum read
+    /// performance, 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, set this to a non-zero duration for eventual consistency.
+    pub fn read_consistency_interval(
+        mut self,
+        read_consistency_interval: std::time::Duration,
+    ) -> Self {
+        self.read_consistency_interval = Some(read_consistency_interval);
+        self
+    }
+
+    /// Provide a custom [`EmbeddingRegistry`] to use for this connection.
+    pub fn embedding_registry(mut self, registry: Arc<dyn EmbeddingRegistry>) -> Self {
+        self.embedding_registry = Some(registry);
+        self
+    }
+
+    /// Set a custom session for object stores and caching.
+    ///
+    /// By default, a new session with default configuration will be created.
+    /// This method allows you to provide a custom session with your own
+    /// configuration for object store registries, caching, etc.
+    pub fn session(mut self, session: Arc<lance::session::Session>) -> Self {
+        self.session = Some(session);
+        self
+    }
+
+    /// Execute the connection
+    pub async fn execute(self) -> Result<Connection> {
+        use crate::database::namespace::LanceNamespaceDatabase;
+
+        let internal = Arc::new(
+            LanceNamespaceDatabase::connect(
+                &self.ns_impl,
+                self.properties,
+                self.storage_options,
+                self.read_consistency_interval,
+                self.session,
+            )
+            .await?,
+        );
+
+        Ok(Connection {
+            internal,
+            uri: format!("namespace://{}", self.ns_impl),
+            embedding_registry: self
+                .embedding_registry
+                .unwrap_or_else(|| Arc::new(MemoryRegistry::new())),
+        })
     }
 }
 
-/// Connect to a LanceDB catalog.
-///
-/// A catalog is a container for databases, which in turn are containers for tables.
+/// Connect to a LanceDB database through a namespace.
 ///
 /// # Arguments
 ///
-/// * `uri` - URI where the catalog is located, can be a local directory or supported remote cloud storage.
-pub fn connect_catalog(uri: &str) -> CatalogConnectBuilder {
-    CatalogConnectBuilder::new(uri)
+/// * `ns_impl` - The namespace implementation to use (e.g., "dir" for directory-based, "rest" for REST API)
+/// * `properties` - Configuration properties for the namespace implementation
+/// ```
+pub fn connect_namespace(
+    ns_impl: &str,
+    properties: HashMap<String, String>,
+) -> ConnectNamespaceBuilder {
+    ConnectNamespaceBuilder::new(ns_impl, properties)
 }
 
 #[cfg(all(test, feature = "remote"))]
@@ -998,6 +1143,23 @@ mod test_utils {
                 embedding_registry: Arc::new(MemoryRegistry::new()),
             }
         }
+
+        pub fn new_with_handler_and_config<T>(
+            handler: impl Fn(reqwest::Request) -> http::Response<T> + Clone + Send + Sync + 'static,
+            config: crate::remote::ClientConfig,
+        ) -> Self
+        where
+            T: Into<reqwest::Body>,
+        {
+            let internal = Arc::new(crate::remote::db::RemoteDatabase::new_mock_with_config(
+                handler, config,
+            ));
+            Self {
+                internal,
+                uri: "db://test".to_string(),
+                embedding_registry: Arc::new(MemoryRegistry::new()),
+            }
+        }
     }
 }
 
@@ -1005,10 +1167,10 @@ mod test_utils {
 mod tests {
     use std::fs::create_dir_all;
 
-    use crate::catalog::{Catalog, DatabaseNamesRequest, OpenDatabaseRequest};
     use crate::database::listing::{ListingDatabaseOptions, NewTableConfig};
     use crate::query::QueryBase;
     use crate::query::{ExecutableQuery, QueryExecutionOptions};
+    use crate::test_connection::test_utils::new_test_connection;
     use arrow::compute::concat_batches;
     use arrow_array::RecordBatchReader;
     use arrow_schema::{DataType, Field, Schema};
@@ -1024,11 +1186,8 @@ mod tests {
 
     #[tokio::test]
     async fn test_connect() {
-        let tmp_dir = tempdir().unwrap();
-        let uri = tmp_dir.path().to_str().unwrap();
-        let db = connect(uri).execute().await.unwrap();
-
-        assert_eq!(db.uri, uri);
+        let tc = new_test_connection().await.unwrap();
+        assert_eq!(tc.connection.uri, tc.uri);
     }
 
     #[cfg(not(windows))]
@@ -1094,16 +1253,10 @@ mod tests {
         assert_eq!(tables, names[..7]);
     }
 
-    #[tokio::test]
-    async fn test_connect_s3() {
-        // let db = Database::connect("s3://bucket/path/to/database").await.unwrap();
-    }
-
     #[tokio::test]
     async fn test_open_table() {
-        let tmp_dir = tempdir().unwrap();
-        let uri = tmp_dir.path().to_str().unwrap();
-        let db = connect(uri).execute().await.unwrap();
+        let tc = new_test_connection().await.unwrap();
+        let db = tc.connection;
 
         assert_eq!(db.table_names().execute().await.unwrap().len(), 0);
         // open non-exist table
@@ -1313,89 +1466,48 @@ mod tests {
     }
 
     #[tokio::test]
-    async fn test_connect_catalog() {
+    async fn test_clone_table() {
         let tmp_dir = tempdir().unwrap();
         let uri = tmp_dir.path().to_str().unwrap();
-        let catalog = connect_catalog(uri).execute().await.unwrap();
+        let db = connect(uri).execute().await.unwrap();
 
-        // Verify that we can get the uri from the catalog
-        let catalog_uri = catalog.uri();
-        assert_eq!(catalog_uri, uri);
+        // Create a source table with some data
+        let mut batch_gen = BatchGenerator::new()
+            .col(Box::new(IncrementingInt32::new().named("id")))
+            .col(Box::new(IncrementingInt32::new().named("value")));
+        let reader = batch_gen.batches(5, 100);
 
-        // Check that the catalog is initially empty
-        let dbs = catalog
-            .database_names(DatabaseNamesRequest::default())
-            .await
-            .unwrap();
-        assert_eq!(dbs.len(), 0);
-    }
-
-    #[tokio::test]
-    #[cfg(not(windows))]
-    async fn test_catalog_create_database() {
-        let tmp_dir = tempdir().unwrap();
-        let uri = tmp_dir.path().to_str().unwrap();
-        let catalog = connect_catalog(uri).execute().await.unwrap();
-
-        let db_name = "test_db";
-        catalog
-            .create_database(crate::catalog::CreateDatabaseRequest {
-                name: db_name.to_string(),
-                mode: Default::default(),
-                options: Default::default(),
-            })
+        let source_table = db
+            .create_table("source_table", reader)
+            .execute()
             .await
             .unwrap();
 
-        let dbs = catalog
-            .database_names(DatabaseNamesRequest::default())
-            .await
-            .unwrap();
-        assert_eq!(dbs.len(), 1);
-        assert_eq!(dbs[0], db_name);
+        // Get the source table URI
+        let source_table_path = tmp_dir.path().join("source_table.lance");
+        let source_uri = source_table_path.to_str().unwrap();
 
-        let db = catalog
-            .open_database(OpenDatabaseRequest {
-                name: db_name.to_string(),
-                database_options: HashMap::new(),
-            })
+        // Clone the table
+        let cloned_table = db
+            .clone_table("cloned_table", source_uri)
+            .execute()
             .await
             .unwrap();
 
-        let tables = db.table_names(Default::default()).await.unwrap();
-        assert_eq!(tables.len(), 0);
-    }
+        // Verify the cloned table exists
+        let table_names = db.table_names().execute().await.unwrap();
+        assert!(table_names.contains(&"source_table".to_string()));
+        assert!(table_names.contains(&"cloned_table".to_string()));
 
-    #[tokio::test]
-    #[cfg(not(windows))]
-    async fn test_catalog_drop_database() {
-        let tmp_dir = tempdir().unwrap();
-        let uri = tmp_dir.path().to_str().unwrap();
-        let catalog = connect_catalog(uri).execute().await.unwrap();
+        // Verify the cloned table has the same schema
+        assert_eq!(
+            source_table.schema().await.unwrap(),
+            cloned_table.schema().await.unwrap()
+        );
 
-        // Create and then drop a database
-        let db_name = "test_db_to_drop";
-        catalog
-            .create_database(crate::catalog::CreateDatabaseRequest {
-                name: db_name.to_string(),
-                mode: Default::default(),
-                options: Default::default(),
-            })
-            .await
-            .unwrap();
-
-        let dbs = catalog
-            .database_names(DatabaseNamesRequest::default())
-            .await
-            .unwrap();
-        assert_eq!(dbs.len(), 1);
-
-        catalog.drop_database(db_name).await.unwrap();
-
-        let dbs_after = catalog
-            .database_names(DatabaseNamesRequest::default())
-            .await
-            .unwrap();
-        assert_eq!(dbs_after.len(), 0);
+        // Verify the cloned table has the same data
+        let source_count = source_table.count_rows(None).await.unwrap();
+        let cloned_count = cloned_table.count_rows(None).await.unwrap();
+        assert_eq!(source_count, cloned_count);
     }
 }