Version bump to 0.7.3 [skip ci]

Co-authored-by: Xing Guo <higuoxing@gmail.com>

.github/workflows/build.yml

@@ -9,9 +9,9 @@ jobs:
       matrix:
         include:
           - postgres: 17
-            os: ubuntu-22.04
+            os: ubuntu-24.04
           - postgres: 16
-            os: ubuntu-22.04
+            os: ubuntu-24.04
           - postgres: 15
             os: ubuntu-22.04
           - postgres: 14
@@ -20,8 +20,6 @@ jobs:
             os: ubuntu-20.04
           - postgres: 12
             os: ubuntu-20.04
-          - postgres: 11
-            os: ubuntu-20.04
     steps:
       - uses: actions/checkout@v4
       - uses: ankane/setup-postgres@v1
@@ -30,7 +28,7 @@ jobs:
           dev-files: true
       - run: make
         env:
-          PG_CFLAGS: -Wall -Wextra -Werror -Wno-unused-parameter -Wno-sign-compare
+          PG_CFLAGS: -DUSE_ASSERT_CHECKING -Wall -Wextra -Werror -Wno-unused-parameter -Wno-sign-compare
       - run: |
           export PG_CONFIG=`which pg_config`
           sudo --preserve-env=PG_CONFIG make install
@@ -42,27 +40,43 @@ jobs:
           sudo apt-get install libipc-run-perl
       - run: make prove_installcheck
   mac:
-    runs-on: macos-latest
+    runs-on: ${{ matrix.os }}
     if: ${{ !startsWith(github.ref_name, 'windows') }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - postgres: 16
+            os: macos-14
+          - postgres: 14
+            os: macos-12
     steps:
       - uses: actions/checkout@v4
       - uses: ankane/setup-postgres@v1
         with:
-          postgres-version: 14
+          postgres-version: ${{ matrix.postgres }}
       - run: make
         env:
-          PG_CFLAGS: -Wall -Wextra -Werror -Wno-unused-parameter
+          PG_CFLAGS: -DUSE_ASSERT_CHECKING -Wall -Wextra -Werror -Wno-unused-parameter
       - run: make install
       - run: make installcheck
       - if: ${{ failure() }}
         run: cat regression.diffs
+      # Homebrew Postgres does not enable TAP tests, so need to download
       - run: |
           brew install cpanm
           cpanm --notest IPC::Run
-          wget -q https://github.com/postgres/postgres/archive/refs/tags/REL_14_5.tar.gz
-          tar xf REL_14_5.tar.gz
-      - run: make prove_installcheck PROVE_FLAGS="-I ./postgres-REL_14_5/src/test/perl" PERL5LIB="/Users/runner/perl5/lib/perl5"
-      - run: make clean && /usr/local/opt/llvm@15/bin/scan-build --status-bugs make
+          wget -q https://github.com/postgres/postgres/archive/refs/tags/$TAG.tar.gz
+          tar xf $TAG.tar.gz
+          mv postgres-$TAG postgres
+        env:
+          TAG: ${{ matrix.postgres == 16 && 'REL_16_2' || 'REL_14_11' }}
+      - run: make prove_installcheck PROVE_FLAGS="-I ./postgres/src/test/perl -I ./test/perl"
+        env:
+          PERL5LIB: /Users/runner/perl5/lib/perl5
+      - run: make clean && $(brew --prefix llvm@15)/bin/scan-build --status-bugs make
+        env:
+          PG_CFLAGS: -DUSE_ASSERT_CHECKING
   windows:
     runs-on: windows-latest
     if: ${{ !startsWith(github.ref_name, 'mac') }}
@@ -79,14 +93,16 @@ jobs:
           nmake /NOLOGO /F Makefile.win clean && ^
           nmake /NOLOGO /F Makefile.win uninstall
         shell: cmd
+      - if: ${{ failure() }}
+        run: cat regression.diffs
   i386:
     if: ${{ !startsWith(github.ref_name, 'mac') && !startsWith(github.ref_name, 'windows') }}
     runs-on: ubuntu-latest
     container:
-      image: debian:11
+      image: debian:12
       options: --platform linux/386
     steps:
-      - run: apt-get update && apt-get install -y build-essential git libipc-run-perl postgresql-13 postgresql-server-dev-13 sudo
+      - run: apt-get update && apt-get install -y build-essential git libipc-run-perl postgresql-15 postgresql-server-dev-15 sudo
       - run: service postgresql start
       - run: |
           git clone https://github.com/${{ github.repository }}.git pgvector
@@ -99,4 +115,18 @@ jobs:
           sudo -u postgres make installcheck
           sudo -u postgres make prove_installcheck
         env:
-          PG_CFLAGS: -Wall -Wextra -Werror -Wno-unused-parameter -Wno-sign-compare
+          PG_CFLAGS: -DUSE_ASSERT_CHECKING -Wall -Wextra -Werror -Wno-unused-parameter -Wno-sign-compare
+      - if: ${{ failure() }}
+        run: cat pgvector/regression.diffs
+  valgrind:
+    if: ${{ !startsWith(github.ref_name, 'mac') && !startsWith(github.ref_name, 'windows') }}
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ankane/setup-postgres-valgrind@v1
+        with:
+          postgres-version: 16
+          check-ub: yes
+      - run: make OPTFLAGS=""
+      - run: sudo --preserve-env=PG_CONFIG make install
+      - run: make installcheck

CHANGELOG.md

@@ -1,6 +1,60 @@
-## 0.5.2 (unreleased)
+## 0.7.3 (2024-07-22)
 
-- Added support for on-disk parallel index builds for HNSW
+- Fixed `failed to add index item` error with `sparsevec`
+- Fixed compilation error with FreeBSD ARM
+- Fixed compilation warning with MSVC and Postgres 16
+
+## 0.7.2 (2024-06-11)
+
+- Fixed initialization fork for indexes on unlogged tables
+
+## 0.7.1 (2024-06-03)
+
+- Improved performance of on-disk HNSW index builds
+- Fixed `undefined symbol` error with GCC 8
+- Fixed compilation error with universal binaries on Mac
+- Fixed compilation warning with Clang < 14
+
+## 0.7.0 (2024-04-29)
+
+- Added `halfvec` type
+- Added `sparsevec` type
+- Added support for indexing `bit` type
+- Added support for indexing L1 distance with HNSW
+- Added `binary_quantize` function
+- Added `hamming_distance` function
+- Added `jaccard_distance` function
+- Added `l2_normalize` function
+- Added `subvector` function
+- Added concatenate operator for vectors
+- Added CPU dispatching for distance functions on Linux x86-64
+- Updated comparison operators to support vectors with different dimensions
+
+## 0.6.2 (2024-03-18)
+
+- Reduced lock contention with parallel HNSW index builds
+
+## 0.6.1 (2024-03-04)
+
+- Fixed error with `ANALYZE` and vectors with different dimensions
+- Fixed segmentation fault with `shared_preload_libraries`
+- Fixed vector subtraction being marked as commutative
+
+## 0.6.0 (2024-01-29)
+
+If upgrading with Postgres 12 or Docker, see [these notes](https://github.com/pgvector/pgvector#060).
+
+- Added support for parallel index builds for HNSW
+- Added validation for GUC parameters
+- Changed storage for vector from `extended` to `external`
+- Improved performance of HNSW
+- Reduced memory usage for HNSW index builds
+- Reduced WAL generation for HNSW index builds
+- Fixed error with logical replication
+- Fixed `invalid memory alloc request size` error with HNSW index builds
+- Moved Docker image to `pgvector` org
+- Added Docker tags for each supported version of Postgres
+- Dropped support for Postgres 11
 
 ## 0.5.1 (2023-10-10)
 
@@ -48,7 +102,7 @@
 
 ## 0.4.0 (2023-01-11)
 
-If upgrading with Postgres < 13, see [this note](https://github.com/pgvector/pgvector#040).
+If upgrading with Postgres < 13, see [this note](https://github.com/pgvector/pgvector/blob/v0.4.0/README.md#040).
 
 - Changed text representation for vector elements to match `real`
 - Changed storage for vector from `plain` to `extended`
@@ -65,7 +119,7 @@ If upgrading with Postgres < 13, see [this note](https://github.com/pgvector/pgv
 
 ## 0.3.1 (2022-11-02)
 
-If upgrading from 0.2.7 or 0.3.0, [recreate](https://github.com/pgvector/pgvector#031) all `ivfflat` indexes after upgrading to ensure all data is indexed.
+If upgrading from 0.2.7 or 0.3.0, [recreate](https://github.com/pgvector/pgvector/blob/v0.3.1/README.md#031) all `ivfflat` indexes after upgrading to ensure all data is indexed.
 
 - Fixed issue with inserts silently corrupting `ivfflat` indexes (introduced in 0.2.7)
 - Fixed segmentation fault with index creation when lists > 6500

Dockerfile

@@ -1,4 +1,4 @@
-ARG PG_MAJOR=15
+ARG PG_MAJOR=16
 FROM postgres:$PG_MAJOR
 ARG PG_MAJOR
 

LICENSE

@@ -1,4 +1,4 @@
-Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
 
 Portions Copyright (c) 1994, The Regents of the University of California
 

META.json

@@ -2,7 +2,7 @@
 	"name": "vector",
 	"abstract": "Open-source vector similarity search for Postgres",
 	"description": "Supports L2 distance, inner product, and cosine distance",
-	"version": "0.5.1",
+	"version": "0.7.3",
 	"maintainer": [
 		"Andrew Kane <andrew@ankane.org>"
 	],
@@ -12,7 +12,7 @@
 	"prereqs": {
 		"runtime": {
 			"requires": {
-				"PostgreSQL": "11.0.0"
+				"PostgreSQL": "12.0.0"
 			}
 		}
 	},
@@ -20,7 +20,7 @@
 		"vector": {
 			"file": "sql/vector.sql",
 			"docfile": "README.md",
-			"version": "0.5.1",
+			"version": "0.7.3",
 			"abstract": "Open-source vector similarity search for Postgres"
 		}
 	},

Makefile

@@ -1,18 +1,19 @@
 EXTENSION = vector
-EXTVERSION = 0.5.1
+EXTVERSION = 0.7.3
 
 MODULE_big = vector
 DATA = $(wildcard sql/*--*.sql)
-OBJS = src/hnsw.o src/hnswbuild.o src/hnswinsert.o src/hnswscan.o src/hnswutils.o src/hnswvacuum.o src/ivfbuild.o src/ivfflat.o src/ivfinsert.o src/ivfkmeans.o src/ivfscan.o src/ivfutils.o src/ivfvacuum.o src/vector.o
-HEADERS = src/vector.h
+OBJS = src/bitutils.o src/bitvec.o src/halfutils.o src/halfvec.o src/hnsw.o src/hnswbuild.o src/hnswinsert.o src/hnswscan.o src/hnswutils.o src/hnswvacuum.o src/ivfbuild.o src/ivfflat.o src/ivfinsert.o src/ivfkmeans.o src/ivfscan.o src/ivfutils.o src/ivfvacuum.o src/sparsevec.o src/vector.o
+HEADERS = src/halfvec.h src/sparsevec.h src/vector.h
 
 TESTS = $(wildcard test/sql/*.sql)
 REGRESS = $(patsubst test/sql/%.sql,%,$(TESTS))
 REGRESS_OPTS = --inputdir=test --load-extension=$(EXTENSION)
 
+# To compile for portability, run: make OPTFLAGS=""
 OPTFLAGS = -march=native
 
-# Mac ARM doesn't support -march=native
+# Mac ARM doesn't always support -march=native
 ifeq ($(shell uname -s), Darwin)
 	ifeq ($(shell uname -p), arm)
 		# no difference with -march=armv8.5-a
@@ -65,13 +66,15 @@ dist:
 	mkdir -p dist
 	git archive --format zip --prefix=$(EXTENSION)-$(EXTVERSION)/ --output dist/$(EXTENSION)-$(EXTVERSION).zip master
 
+# for Docker
+PG_MAJOR ?= 16
+
 .PHONY: docker
 
 docker:
-	docker build --pull --no-cache --platform linux/amd64 -t ankane/pgvector:latest .
+	docker build --pull --no-cache --build-arg PG_MAJOR=$(PG_MAJOR) -t pgvector/pgvector:pg$(PG_MAJOR) -t pgvector/pgvector:$(EXTVERSION)-pg$(PG_MAJOR) .
 
 .PHONY: docker-release
 
 docker-release:
-	docker buildx build --push --pull --no-cache --platform linux/amd64,linux/arm64 -t ankane/pgvector:latest .
-	docker buildx build --push --platform linux/amd64,linux/arm64 -t ankane/pgvector:v$(EXTVERSION) .
+	docker buildx build --push --pull --no-cache --platform linux/amd64,linux/arm64 --build-arg PG_MAJOR=$(PG_MAJOR) -t pgvector/pgvector:pg$(PG_MAJOR) -t pgvector/pgvector:$(EXTVERSION)-pg$(PG_MAJOR) .

Makefile.win

@@ -1,10 +1,10 @@
 EXTENSION = vector
-EXTVERSION = 0.5.1
+EXTVERSION = 0.7.3
 
-OBJS = src\hnsw.obj src\hnswbuild.obj src\hnswinsert.obj src\hnswscan.obj src\hnswutils.obj src\hnswvacuum.obj src\ivfbuild.obj src\ivfflat.obj src\ivfinsert.obj src\ivfkmeans.obj src\ivfscan.obj src\ivfutils.obj src\ivfvacuum.obj src\vector.obj
-HEADERS = src\vector.h
+OBJS = src\bitutils.obj src\bitvec.obj src\halfutils.obj src\halfvec.obj src\hnsw.obj src\hnswbuild.obj src\hnswinsert.obj src\hnswscan.obj src\hnswutils.obj src\hnswvacuum.obj src\ivfbuild.obj src\ivfflat.obj src\ivfinsert.obj src\ivfkmeans.obj src\ivfscan.obj src\ivfutils.obj src\ivfvacuum.obj src\sparsevec.obj src\vector.obj
+HEADERS = src\halfvec.h src\sparsevec.h src\vector.h
 
-REGRESS = btree cast copy functions input ivfflat_cosine ivfflat_ip ivfflat_l2 ivfflat_options ivfflat_unlogged
+REGRESS = bit btree cast copy halfvec hnsw_bit hnsw_halfvec hnsw_sparsevec hnsw_vector ivfflat_bit ivfflat_halfvec ivfflat_vector sparsevec vector_type
 REGRESS_OPTS = --inputdir=test --load-extension=$(EXTENSION)
 
 # For /arch flags

README.md

@@ -5,7 +5,8 @@ Open-source vector similarity search for Postgres
 Store your vectors with the rest of your data. Supports:
 
 - exact and approximate nearest neighbor search
-- L2 distance, inner product, and cosine distance
+- single-precision, half-precision, binary, and sparse vectors
+- L2 distance, inner product, cosine distance, L1 distance, Hamming distance, and Jaccard distance
 - any [language](#languages) with a Postgres client
 
 Plus [ACID](https://en.wikipedia.org/wiki/ACID) compliance, point-in-time recovery, JOINs, and all of the other [great features](https://www.postgresql.org/about/) of Postgres
@@ -14,19 +15,46 @@ Plus [ACID](https://en.wikipedia.org/wiki/ACID) compliance, point-in-time recove
 
 ## Installation
 
-Compile and install the extension (supports Postgres 11+)
+### Linux and Mac
+
+Compile and install the extension (supports Postgres 12+)
 
 ```sh
 cd /tmp
-git clone --branch v0.5.1 https://github.com/pgvector/pgvector.git
+git clone --branch v0.7.3 https://github.com/pgvector/pgvector.git
 cd pgvector
 make
 make install # may need sudo
 ```
 
-See the [installation notes](#installation-notes) if you run into issues
+See the [installation notes](#installation-notes---linux-and-mac) if you run into issues
 
-You can also install it with [Docker](#docker), [Homebrew](#homebrew), [PGXN](#pgxn), [APT](#apt), [Yum](#yum), or [conda-forge](#conda-forge), and it comes preinstalled with [Postgres.app](#postgresapp) and many [hosted providers](#hosted-postgres). There are also instructions for [GitHub Actions](https://github.com/pgvector/setup-pgvector).
+You can also install it with [Docker](#docker), [Homebrew](#homebrew), [PGXN](#pgxn), [APT](#apt), [Yum](#yum), [pkg](#pkg), or [conda-forge](#conda-forge), and it comes preinstalled with [Postgres.app](#postgresapp) and many [hosted providers](#hosted-postgres). There are also instructions for [GitHub Actions](https://github.com/pgvector/setup-pgvector).
+
+### Windows
+
+Ensure [C++ support in Visual Studio](https://learn.microsoft.com/en-us/cpp/build/building-on-the-command-line?view=msvc-170#download-and-install-the-tools) is installed, and run:
+
+```cmd
+call "C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Auxiliary\Build\vcvars64.bat"
+```
+
+Note: The exact path will vary depending on your Visual Studio version and edition
+
+Then use `nmake` to build:
+
+```cmd
+set "PGROOT=C:\Program Files\PostgreSQL\16"
+cd %TEMP%
+git clone --branch v0.7.3 https://github.com/pgvector/pgvector.git
+cd pgvector
+nmake /F Makefile.win
+nmake /F Makefile.win install
+```
+
+See the [installation notes](#installation-notes---windows) if you run into issues
+
+You can also install it with [Docker](#docker) or [conda-forge](#conda-forge).
 
 ## Getting Started
 
@@ -54,7 +82,7 @@ Get the nearest neighbors by L2 distance
 SELECT * FROM items ORDER BY embedding <-> '[3,1,2]' LIMIT 5;
 ```
 
-Also supports inner product (`<#>`) and cosine distance (`<=>`)
+Also supports inner product (`<#>`), cosine distance (`<=>`), and L1 distance (`<+>`, added in 0.7.0)
 
 Note: `<#>` returns the negative inner product since Postgres only supports `ASC` order index scans on operators
 
@@ -78,6 +106,12 @@ Insert vectors
 INSERT INTO items (embedding) VALUES ('[1,2,3]'), ('[4,5,6]');
 ```
 
+Or load vectors in bulk using `COPY` ([example](https://github.com/pgvector/pgvector-python/blob/master/examples/bulk_loading.py))
+
+```sql
+COPY items (embedding) FROM STDIN WITH (FORMAT BINARY);
+```
+
 Upsert vectors
 
 ```sql
@@ -105,6 +139,13 @@ Get the nearest neighbors to a vector
 SELECT * FROM items ORDER BY embedding <-> '[3,1,2]' LIMIT 5;
 ```
 
+Supported distance functions are:
+
+- `<->` - L2 distance
+- `<#>` - (negative) inner product
+- `<=>` - cosine distance
+- `<+>` - L1 distance (added in 0.7.0)
+
 Get the nearest neighbors to a row
 
 ```sql
@@ -161,80 +202,12 @@ You can add an index to use approximate nearest neighbor search, which trades so
 
 Supported index types are:
 
-- [IVFFlat](#ivfflat)
 - [HNSW](#hnsw) - added in 0.5.0
-
-## IVFFlat
-
-An IVFFlat index divides vectors into lists, and then searches a subset of those lists that are closest to the query vector. It has faster build times and uses less memory than HNSW, but has lower query performance (in terms of speed-recall tradeoff).
-
-Three keys to achieving good recall are:
-
-1. Create the index *after* the table has some data
-2. Choose an appropriate number of lists - a good place to start is `rows / 1000` for up to 1M rows and `sqrt(rows)` for over 1M rows
-3. When querying, specify an appropriate number of [probes](#query-options) (higher is better for recall, lower is better for speed) - a good place to start is `sqrt(lists)`
-
-Add an index for each distance function you want to use.
-
-L2 distance
-
-```sql
-CREATE INDEX ON items USING ivfflat (embedding vector_l2_ops) WITH (lists = 100);
-```
-
-Inner product
-
-```sql
-CREATE INDEX ON items USING ivfflat (embedding vector_ip_ops) WITH (lists = 100);
-```
-
-Cosine distance
-
-```sql
-CREATE INDEX ON items USING ivfflat (embedding vector_cosine_ops) WITH (lists = 100);
-```
-
-Vectors with up to 2,000 dimensions can be indexed.
-
-### Query Options
-
-Specify the number of probes (1 by default)
-
-```sql
-SET ivfflat.probes = 10;
-```
-
-A higher value provides better recall at the cost of speed, and it can be set to the number of lists for exact nearest neighbor search (at which point the planner won’t use the index)
-
-Use `SET LOCAL` inside a transaction to set it for a single query
-
-```sql
-BEGIN;
-SET LOCAL ivfflat.probes = 10;
-SELECT ...
-COMMIT;
-```
-
-### Indexing Progress
-
-Check [indexing progress](https://www.postgresql.org/docs/current/progress-reporting.html#CREATE-INDEX-PROGRESS-REPORTING) with Postgres 12+
-
-```sql
-SELECT phase, round(100.0 * tuples_done / nullif(tuples_total, 0), 1) AS "%" FROM pg_stat_progress_create_index;
-```
-
-The phases for IVFFlat are:
-
-1. `initializing`
-2. `performing k-means`
-3. `assigning tuples`
-4. `loading tuples`
-
-Note: `%` is only populated during the `loading tuples` phase
+- [IVFFlat](#ivfflat)
 
 ## HNSW
 
-An HNSW index creates a multilayer graph. It has slower build times and uses more memory than IVFFlat, but has better query performance (in terms of speed-recall tradeoff). There’s no training step like IVFFlat, so the index can be created without any data in the table.
+An HNSW index creates a multilayer graph. It has better query performance than IVFFlat (in terms of speed-recall tradeoff), but has slower build times and uses more memory. Also, an index can be created without any data in the table since there isn’t a training step like IVFFlat.
 
 Add an index for each distance function you want to use.
 
@@ -244,6 +217,8 @@ L2 distance
 CREATE INDEX ON items USING hnsw (embedding vector_l2_ops);
 ```
 
+Note: Use `halfvec_l2_ops` for `halfvec` and `sparsevec_l2_ops` for `sparsevec` (and similar with the other distance functions)
+
 Inner product
 
 ```sql
@@ -256,7 +231,30 @@ Cosine distance
 CREATE INDEX ON items USING hnsw (embedding vector_cosine_ops);
 ```
 
-Vectors with up to 2,000 dimensions can be indexed.
+L1 distance - added in 0.7.0
+
+```sql
+CREATE INDEX ON items USING hnsw (embedding vector_l1_ops);
+```
+
+Hamming distance - added in 0.7.0
+
+```sql
+CREATE INDEX ON items USING hnsw (embedding bit_hamming_ops);
+```
+
+Jaccard distance - added in 0.7.0
+
+```sql
+CREATE INDEX ON items USING hnsw (embedding bit_jaccard_ops);
+```
+
+Supported types are:
+
+- `vector` - up to 2,000 dimensions
+- `halfvec` - up to 4,000 dimensions (added in 0.7.0)
+- `bit` - up to 64,000 dimensions (added in 0.7.0)
+- `sparsevec` - up to 1,000 non-zero elements (added in 0.7.0)
 
 ### Index Options
 
@@ -290,6 +288,34 @@ SELECT ...
 COMMIT;
 ```
 
+### Index Build Time
+
+Indexes build significantly faster when the graph fits into `maintenance_work_mem`
+
+```sql
+SET maintenance_work_mem = '8GB';
+```
+
+A notice is shown when the graph no longer fits
+
+```text
+NOTICE:  hnsw graph no longer fits into maintenance_work_mem after 100000 tuples
+DETAIL:  Building will take significantly more time.
+HINT:  Increase maintenance_work_mem to speed up builds.
+```
+
+Note: Do not set `maintenance_work_mem` so high that it exhausts the memory on the server
+
+Like other index types, it’s faster to create an index after loading your initial data
+
+Starting with 0.6.0, you can also speed up index creation by increasing the number of parallel workers (2 by default)
+
+```sql
+SET max_parallel_maintenance_workers = 7; -- plus leader
+```
+
+For a large number of workers, you may also need to increase `max_parallel_workers` (8 by default)
+
 ### Indexing Progress
 
 Check [indexing progress](https://www.postgresql.org/docs/current/progress-reporting.html#CREATE-INDEX-PROGRESS-REPORTING) with Postgres 12+
@@ -303,6 +329,96 @@ The phases for HNSW are:
 1. `initializing`
 2. `loading tuples`
 
+## IVFFlat
+
+An IVFFlat index divides vectors into lists, and then searches a subset of those lists that are closest to the query vector. It has faster build times and uses less memory than HNSW, but has lower query performance (in terms of speed-recall tradeoff).
+
+Three keys to achieving good recall are:
+
+1. Create the index *after* the table has some data
+2. Choose an appropriate number of lists - a good place to start is `rows / 1000` for up to 1M rows and `sqrt(rows)` for over 1M rows
+3. When querying, specify an appropriate number of [probes](#query-options) (higher is better for recall, lower is better for speed) - a good place to start is `sqrt(lists)`
+
+Add an index for each distance function you want to use.
+
+L2 distance
+
+```sql
+CREATE INDEX ON items USING ivfflat (embedding vector_l2_ops) WITH (lists = 100);
+```
+
+Note: Use `halfvec_l2_ops` for `halfvec` (and similar with the other distance functions)
+
+Inner product
+
+```sql
+CREATE INDEX ON items USING ivfflat (embedding vector_ip_ops) WITH (lists = 100);
+```
+
+Cosine distance
+
+```sql
+CREATE INDEX ON items USING ivfflat (embedding vector_cosine_ops) WITH (lists = 100);
+```
+
+Hamming distance - added in 0.7.0
+
+```sql
+CREATE INDEX ON items USING ivfflat (embedding bit_hamming_ops) WITH (lists = 100);
+```
+
+Supported types are:
+
+- `vector` - up to 2,000 dimensions
+- `halfvec` - up to 4,000 dimensions (added in 0.7.0)
+- `bit` - up to 64,000 dimensions (added in 0.7.0)
+
+### Query Options
+
+Specify the number of probes (1 by default)
+
+```sql
+SET ivfflat.probes = 10;
+```
+
+A higher value provides better recall at the cost of speed, and it can be set to the number of lists for exact nearest neighbor search (at which point the planner won’t use the index)
+
+Use `SET LOCAL` inside a transaction to set it for a single query
+
+```sql
+BEGIN;
+SET LOCAL ivfflat.probes = 10;
+SELECT ...
+COMMIT;
+```
+
+### Index Build Time
+
+Speed up index creation on large tables by increasing the number of parallel workers (2 by default)
+
+```sql
+SET max_parallel_maintenance_workers = 7; -- plus leader
+```
+
+For a large number of workers, you may also need to increase `max_parallel_workers` (8 by default)
+
+### Indexing Progress
+
+Check [indexing progress](https://www.postgresql.org/docs/current/progress-reporting.html#CREATE-INDEX-PROGRESS-REPORTING) with Postgres 12+
+
+```sql
+SELECT phase, round(100.0 * tuples_done / nullif(tuples_total, 0), 1) AS "%" FROM pg_stat_progress_create_index;
+```
+
+The phases for IVFFlat are:
+
+1. `initializing`
+2. `performing k-means`
+3. `assigning tuples`
+4. `loading tuples`
+
+Note: `%` is only populated during the `loading tuples` phase
+
 ## Filtering
 
 There are a few ways to index nearest neighbor queries with a `WHERE` clause
@@ -320,8 +436,7 @@ CREATE INDEX ON items (category_id);
 Or a [partial index](https://www.postgresql.org/docs/current/indexes-partial.html) on the vector column for approximate search
 
 ```sql
-CREATE INDEX ON items USING ivfflat (embedding vector_l2_ops) WITH (lists = 100)
-    WHERE (category_id = 123);
+CREATE INDEX ON items USING hnsw (embedding vector_l2_ops) WHERE (category_id = 123);
 ```
 
 Use [partitioning](https://www.postgresql.org/docs/current/ddl-partitioning.html) for approximate search on many different values of the `WHERE` columns
@@ -330,6 +445,103 @@ Use [partitioning](https://www.postgresql.org/docs/current/ddl-partitioning.html
 CREATE TABLE items (embedding vector(3), category_id int) PARTITION BY LIST(category_id);
 ```
 
+## Half-Precision Vectors
+
+*Added in 0.7.0*
+
+Use the `halfvec` type to store half-precision vectors
+
+```sql
+CREATE TABLE items (id bigserial PRIMARY KEY, embedding halfvec(3));
+```
+
+## Half-Precision Indexing
+
+*Added in 0.7.0*
+
+Index vectors at half precision for smaller indexes
+
+```sql
+CREATE INDEX ON items USING hnsw ((embedding::halfvec(3)) halfvec_l2_ops);
+```
+
+Get the nearest neighbors
+
+```sql
+SELECT * FROM items ORDER BY embedding::halfvec(3) <-> '[1,2,3]' LIMIT 5;
+```
+
+## Binary Vectors
+
+Use the `bit` type to store binary vectors ([example](https://github.com/pgvector/pgvector-python/blob/master/examples/hash_image_search.py))
+
+```sql
+CREATE TABLE items (id bigserial PRIMARY KEY, embedding bit(3));
+INSERT INTO items (embedding) VALUES ('000'), ('111');
+```
+
+Get the nearest neighbors by Hamming distance (added in 0.7.0)
+
+```sql
+SELECT * FROM items ORDER BY embedding <~> '101' LIMIT 5;
+```
+
+Or (before 0.7.0)
+
+```sql
+SELECT * FROM items ORDER BY bit_count(embedding # '101') LIMIT 5;
+```
+
+Also supports Jaccard distance (`<%>`)
+
+## Binary Quantization
+
+*Added in 0.7.0*
+
+Use expression indexing for binary quantization
+
+```sql
+CREATE INDEX ON items USING hnsw ((binary_quantize(embedding)::bit(3)) bit_hamming_ops);
+```
+
+Get the nearest neighbors by Hamming distance
+
+```sql
+SELECT * FROM items ORDER BY binary_quantize(embedding)::bit(3) <~> binary_quantize('[1,-2,3]') LIMIT 5;
+```
+
+Re-rank by the original vectors for better recall
+
+```sql
+SELECT * FROM (
+    SELECT * FROM items ORDER BY binary_quantize(embedding)::bit(3) <~> binary_quantize('[1,-2,3]') LIMIT 20
+) ORDER BY embedding <=> '[1,-2,3]' LIMIT 5;
+```
+
+## Sparse Vectors
+
+*Added in 0.7.0*
+
+Use the `sparsevec` type to store sparse vectors
+
+```sql
+CREATE TABLE items (id bigserial PRIMARY KEY, embedding sparsevec(5));
+```
+
+Insert vectors
+
+```sql
+INSERT INTO items (embedding) VALUES ('{1:1,3:2,5:3}/5'), ('{1:4,3:5,5:6}/5');
+```
+
+The format is `{index1:value1,index2:value2}/dimensions` and indices start at 1 like SQL arrays
+
+Get the nearest neighbors by L2 distance
+
+```sql
+SELECT * FROM items ORDER BY embedding <-> '{1:3,3:1,5:2}/5' LIMIT 5;
+```
+
 ## Hybrid Search
 
 Use together with Postgres [full-text search](https://www.postgresql.org/docs/current/textsearch-intro.html) for hybrid search.
@@ -341,15 +553,77 @@ SELECT id, content FROM items, plainto_tsquery('hello search') query
 
 You can use [Reciprocal Rank Fusion](https://github.com/pgvector/pgvector-python/blob/master/examples/hybrid_search_rrf.py) or a [cross-encoder](https://github.com/pgvector/pgvector-python/blob/master/examples/hybrid_search.py) to combine results.
 
+## Indexing Subvectors
+
+*Added in 0.7.0*
+
+Use expression indexing to index subvectors
+
+```sql
+CREATE INDEX ON items USING hnsw ((subvector(embedding, 1, 3)::vector(3)) vector_cosine_ops);
+```
+
+Get the nearest neighbors by cosine distance
+
+```sql
+SELECT * FROM items ORDER BY subvector(embedding, 1, 3)::vector(3) <=> subvector('[1,2,3,4,5]'::vector, 1, 3) LIMIT 5;
+```
+
+Re-rank by the full vectors for better recall
+
+```sql
+SELECT * FROM (
+    SELECT * FROM items ORDER BY subvector(embedding, 1, 3)::vector(3) <=> subvector('[1,2,3,4,5]'::vector, 1, 3) LIMIT 20
+) ORDER BY embedding <=> '[1,2,3,4,5]' LIMIT 5;
+```
+
 ## Performance
 
+### Tuning
+
+Use a tool like [PgTune](https://pgtune.leopard.in.ua/) to set initial values for Postgres server parameters. For instance, `shared_buffers` should typically be 25% of the server’s memory. You can find the config file with:
+
+```sql
+SHOW config_file;
+```
+
+And check individual settings with:
+
+```sql
+SHOW shared_buffers;
+```
+
+Be sure to restart Postgres for changes to take effect.
+
+### Loading
+
+Use `COPY` for bulk loading data ([example](https://github.com/pgvector/pgvector-python/blob/master/examples/bulk_loading.py)).
+
+```sql
+COPY items (embedding) FROM STDIN WITH (FORMAT BINARY);
+```
+
+Add any indexes *after* loading the initial data for best performance.
+
+### Indexing
+
+See index build time for [HNSW](#index-build-time) and [IVFFlat](#index-build-time-1).
+
+In production environments, create indexes concurrently to avoid blocking writes.
+
+```sql
+CREATE INDEX CONCURRENTLY ...
+```
+
+### Querying
+
 Use `EXPLAIN ANALYZE` to debug performance.
 
 ```sql
 EXPLAIN ANALYZE SELECT * FROM items ORDER BY embedding <-> '[3,1,2]' LIMIT 5;
 ```
 
-### Exact Search
+#### Exact Search
 
 To speed up queries without an index, increase `max_parallel_workers_per_gather`.
 
@@ -363,7 +637,7 @@ If vectors are normalized to length 1 (like [OpenAI embeddings](https://platform
 SELECT * FROM items ORDER BY embedding <#> '[3,1,2]' LIMIT 5;
 ```
 
-### Approximate Search
+#### Approximate Search
 
 To speed up queries with an IVFFlat index, increase the number of inverted lists (at the expense of recall).
 
@@ -371,6 +645,50 @@ To speed up queries with an IVFFlat index, increase the number of inverted lists
 CREATE INDEX ON items USING ivfflat (embedding vector_l2_ops) WITH (lists = 1000);
 ```
 
+### Vacuuming
+
+Vacuuming can take a while for HNSW indexes. Speed it up by reindexing first.
+
+```sql
+REINDEX INDEX CONCURRENTLY index_name;
+VACUUM table_name;
+```
+
+## Monitoring
+
+Monitor performance with [pg_stat_statements](https://www.postgresql.org/docs/current/pgstatstatements.html) (be sure to add it to `shared_preload_libraries`).
+
+```sql
+CREATE EXTENSION pg_stat_statements;
+```
+
+Get the most time-consuming queries with:
+
+```sql
+SELECT query, calls, ROUND((total_plan_time + total_exec_time) / calls) AS avg_time_ms,
+    ROUND((total_plan_time + total_exec_time) / 60000) AS total_time_min
+    FROM pg_stat_statements ORDER BY total_plan_time + total_exec_time DESC LIMIT 20;
+```
+
+Note: Replace `total_plan_time + total_exec_time` with `total_time` for Postgres < 13
+
+Monitor recall by comparing results from approximate search with exact search.
+
+```sql
+BEGIN;
+SET LOCAL enable_indexscan = off; -- use exact search
+SELECT ...
+COMMIT;
+```
+
+## Scaling
+
+Scale pgvector the same way you scale Postgres.
+
+Scale vertically by increasing memory, CPU, and storage on a single instance. Use existing tools to [tune parameters](#tuning) and [monitor performance](#monitoring).
+
+Scale horizontally with [replicas](https://www.postgresql.org/docs/current/hot-standby.html), or use [Citus](https://github.com/citusdata/citus) or another approach for sharding ([example](https://github.com/pgvector/pgvector-python/blob/master/examples/citus.py)).
+
 ## Languages
 
 Use pgvector from any language with a Postgres client. You can even generate and store vectors in one language and query them in another.
@@ -413,7 +731,7 @@ Yes, pgvector uses the write-ahead log (WAL), which allows for replication and p
 
 #### What if I want to index vectors with more than 2,000 dimensions?
 
-You’ll need to use [dimensionality reduction](https://en.wikipedia.org/wiki/Dimensionality_reduction) at the moment.
+You can use [half-precision indexing](#half-precision-indexing) to index up to 4,000 dimensions or [binary quantization](#binary-quantization) to index up to 64,000 dimensions. Another option is [dimensionality reduction](https://en.wikipedia.org/wiki/Dimensionality_reduction).
 
 #### Can I store vectors with different dimensions in the same column?
 
@@ -476,7 +794,17 @@ SELECT pg_size_pretty(pg_relation_size('index_name'));
 
 #### Why isn’t a query using an index?
 
-The cost estimation in pgvector < 0.4.3 does not always work well with the planner. You can encourage the planner to use an index for a query with:
+The query needs to have an `ORDER BY` and `LIMIT`, and the `ORDER BY` must be the result of a distance operator (not an expression) in ascending order.
+
+```sql
+-- index
+ORDER BY embedding <=> '[3,1,2]' LIMIT 5;
+
+-- no index
+ORDER BY 1 - (embedding <=> '[3,1,2]') DESC LIMIT 5;
+```
+
+You can encourage the planner to use an index for a query with:
 
 ```sql
 BEGIN;
@@ -505,6 +833,12 @@ or choose to store vectors inline:
 ALTER TABLE items ALTER COLUMN embedding SET STORAGE PLAIN;
 ```
 
+#### Why are there less results for a query after adding an HNSW index?
+
+Results are limited by the size of the dynamic candidate list (`hnsw.ef_search`). There may be even less results due to dead tuples or filtering conditions in the query. We recommend setting `hnsw.ef_search` to at least twice the `LIMIT` of the query. If you need more than 500 results, use an IVFFlat index instead.
+
+Also, note that `NULL` vectors are not indexed (as well as zero vectors for cosine distance).
+
 #### Why are there less results for a query after adding an IVFFlat index?
 
 The index was likely created with too little data for the number of lists. Drop the index until the table has more data.
@@ -513,11 +847,20 @@ The index was likely created with too little data for the number of lists. Drop
 DROP INDEX index_name;
 ```
 
+Results can also be limited by the number of probes (`ivfflat.probes`).
+
+Also, note that `NULL` vectors are not indexed (as well as zero vectors for cosine distance).
+
 ## Reference
 
+- [Vector](#vector-type)
+- [Halfvec](#halfvec-type)
+- [Bit](#bit-type)
+- [Sparsevec](#sparsevec-type)
+
 ### Vector Type
 
-Each vector takes `4 * dimensions + 8` bytes of storage. Each element is a single precision floating-point number (like the `real` type in Postgres), and all elements must be finite (no `NaN`, `Infinity` or `-Infinity`). Vectors can have up to 16,000 dimensions.
+Each vector takes `4 * dimensions + 8` bytes of storage. Each element is a single-precision floating-point number (like the `real` type in Postgres), and all elements must be finite (no `NaN`, `Infinity` or `-Infinity`). Vectors can have up to 16,000 dimensions.
 
 ### Vector Operators
 
@@ -526,36 +869,121 @@ Operator | Description | Added
 \+ | element-wise addition |
 \- | element-wise subtraction |
 \* | element-wise multiplication | 0.5.0
+\|\| | concatenate | 0.7.0
 <-> | Euclidean distance |
 <#> | negative inner product |
 <=> | cosine distance |
+<+> | taxicab distance | 0.7.0
 
 ### Vector Functions
 
 Function | Description | Added
 --- | --- | ---
+binary_quantize(vector) → bit | binary quantize | 0.7.0
 cosine_distance(vector, vector) → double precision | cosine distance |
 inner_product(vector, vector) → double precision | inner product |
-l2_distance(vector, vector) → double precision | Euclidean distance |
 l1_distance(vector, vector) → double precision | taxicab distance | 0.5.0
+l2_distance(vector, vector) → double precision | Euclidean distance |
+l2_normalize(vector) → vector | Normalize with Euclidean norm | 0.7.0
+subvector(vector, integer, integer) → vector | subvector | 0.7.0
 vector_dims(vector) → integer | number of dimensions |
 vector_norm(vector) → double precision | Euclidean norm |
 
-### Aggregate Functions
+### Vector Aggregate Functions
 
 Function | Description | Added
 --- | --- | ---
 avg(vector) → vector | average |
 sum(vector) → vector | sum | 0.5.0
 
-## Installation Notes
+### Halfvec Type
+
+Each half vector takes `2 * dimensions + 8` bytes of storage. Each element is a half-precision floating-point number, and all elements must be finite (no `NaN`, `Infinity` or `-Infinity`). Half vectors can have up to 16,000 dimensions.
+
+### Halfvec Operators
+
+Operator | Description | Added
+--- | --- | ---
+\+ | element-wise addition | 0.7.0
+\- | element-wise subtraction | 0.7.0
+\* | element-wise multiplication | 0.7.0
+\|\| | concatenate | 0.7.0
+<-> | Euclidean distance | 0.7.0
+<#> | negative inner product | 0.7.0
+<=> | cosine distance | 0.7.0
+<+> | taxicab distance | 0.7.0
+
+### Halfvec Functions
+
+Function | Description | Added
+--- | --- | ---
+binary_quantize(halfvec) → bit | binary quantize | 0.7.0
+cosine_distance(halfvec, halfvec) → double precision | cosine distance | 0.7.0
+inner_product(halfvec, halfvec) → double precision | inner product | 0.7.0
+l1_distance(halfvec, halfvec) → double precision | taxicab distance | 0.7.0
+l2_distance(halfvec, halfvec) → double precision | Euclidean distance | 0.7.0
+l2_norm(halfvec) → double precision | Euclidean norm | 0.7.0
+l2_normalize(halfvec) → halfvec | Normalize with Euclidean norm | 0.7.0
+subvector(halfvec, integer, integer) → halfvec | subvector | 0.7.0
+vector_dims(halfvec) → integer | number of dimensions | 0.7.0
+
+### Halfvec Aggregate Functions
+
+Function | Description | Added
+--- | --- | ---
+avg(halfvec) → halfvec | average | 0.7.0
+sum(halfvec) → halfvec | sum | 0.7.0
+
+### Bit Type
+
+Each bit vector takes `dimensions / 8 + 8` bytes of storage. See the [Postgres docs](https://www.postgresql.org/docs/current/datatype-bit.html) for more info.
+
+### Bit Operators
+
+Operator | Description | Added
+--- | --- | ---
+<~> | Hamming distance | 0.7.0
+<%> | Jaccard distance | 0.7.0
+
+### Bit Functions
+
+Function | Description | Added
+--- | --- | ---
+hamming_distance(bit, bit) → double precision | Hamming distance | 0.7.0
+jaccard_distance(bit, bit) → double precision | Jaccard distance | 0.7.0
+
+### Sparsevec Type
+
+Each sparse vector takes `8 * non-zero elements + 16` bytes of storage. Each element is a single-precision floating-point number, and all elements must be finite (no `NaN`, `Infinity` or `-Infinity`). Sparse vectors can have up to 16,000 non-zero elements.
+
+### Sparsevec Operators
+
+Operator | Description | Added
+--- | --- | ---
+<-> | Euclidean distance | 0.7.0
+<#> | negative inner product | 0.7.0
+<=> | cosine distance | 0.7.0
+<+> | taxicab distance | 0.7.0
+
+### Sparsevec Functions
+
+Function | Description | Added
+--- | --- | ---
+cosine_distance(sparsevec, sparsevec) → double precision | cosine distance | 0.7.0
+inner_product(sparsevec, sparsevec) → double precision | inner product | 0.7.0
+l1_distance(sparsevec, sparsevec) → double precision | taxicab distance | 0.7.0
+l2_distance(sparsevec, sparsevec) → double precision | Euclidean distance | 0.7.0
+l2_norm(sparsevec) → double precision | Euclidean norm | 0.7.0
+l2_normalize(sparsevec) → sparsevec | Normalize with Euclidean norm | 0.7.0
+
+## Installation Notes - Linux and Mac
 
 ### Postgres Location
 
 If your machine has multiple Postgres installations, specify the path to [pg_config](https://www.postgresql.org/docs/current/app-pgconfig.html) with:
 
 ```sh
-export PG_CONFIG=/Applications/Postgres.app/Contents/Versions/latest/bin/pg_config
+export PG_CONFIG=/Library/PostgreSQL/16/bin/pg_config
 ```
 
 Then re-run the installation instructions (run `make clean` before `make` if needed). If `sudo` is needed for `make install`, use:
@@ -564,6 +992,14 @@ Then re-run the installation instructions (run `make clean` before `make` if nee
 sudo --preserve-env=PG_CONFIG make install
 ```
 
+A few common paths on Mac are:
+
+- EDB installer - `/Library/PostgreSQL/16/bin/pg_config`
+- Homebrew (arm64) - `/opt/homebrew/opt/postgresql@16/bin/pg_config`
+- Homebrew (x86-64) - `/usr/local/opt/postgresql@16/bin/pg_config`
+
+Note: Replace `16` with your Postgres server version
+
 ### Missing Header
 
 If compilation fails with `fatal error: postgres.h: No such file or directory`, make sure Postgres development files are installed on the server.
@@ -571,49 +1007,53 @@ If compilation fails with `fatal error: postgres.h: No such file or directory`,
 For Ubuntu and Debian, use:
 
 ```sh
-sudo apt install postgresql-server-dev-15
+sudo apt install postgresql-server-dev-16
 ```
 
-Note: Replace `15` with your Postgres server version
+Note: Replace `16` with your Postgres server version
 
-### Windows
+### Missing SDK
 
-Support for Windows is currently experimental. Ensure [C++ support in Visual Studio](https://learn.microsoft.com/en-us/cpp/build/building-on-the-command-line?view=msvc-170#download-and-install-the-tools) is installed, and run:
+If compilation fails and the output includes `warning: no such sysroot directory` on Mac, reinstall Xcode Command Line Tools.
 
-```cmd
-call "C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Auxiliary\Build\vcvars64.bat"
+### Portability
+
+By default, pgvector compiles with `-march=native` on some platforms for best performance. However, this can lead to `Illegal instruction` errors if trying to run the compiled extension on a different machine.
+
+To compile for portability, use:
+
+```sh
+make OPTFLAGS=""
 ```
 
-Note: The exact path will vary depending on your Visual Studio version and edition
+## Installation Notes - Windows
 
-Then use `nmake` to build:
+### Missing Header
 
-```cmd
-set "PGROOT=C:\Program Files\PostgreSQL\15"
-git clone --branch v0.5.1 https://github.com/pgvector/pgvector.git
-cd pgvector
-nmake /F Makefile.win
-nmake /F Makefile.win install
-```
+If compilation fails with `Cannot open include file: 'postgres.h': No such file or directory`, make sure `PGROOT` is correct.
+
+### Permissions
+
+If installation fails with `Access is denied`, re-run the installation instructions as an administrator.
 
 ## Additional Installation Methods
 
 ### Docker
 
-Get the [Docker image](https://hub.docker.com/r/ankane/pgvector) with:
+Get the [Docker image](https://hub.docker.com/r/pgvector/pgvector) with:
 
 ```sh
-docker pull ankane/pgvector
+docker pull pgvector/pgvector:pg16
 ```
 
-This adds pgvector to the [Postgres image](https://hub.docker.com/_/postgres) (run it the same way).
+This adds pgvector to the [Postgres image](https://hub.docker.com/_/postgres) (replace `16` with your Postgres server version, and run it the same way).
 
 You can also build the image manually:
 
 ```sh
-git clone --branch v0.5.1 https://github.com/pgvector/pgvector.git
+git clone --branch v0.7.3 https://github.com/pgvector/pgvector.git
 cd pgvector
-docker build --build-arg PG_MAJOR=15 -t myuser/pgvector .
+docker build --pull --build-arg PG_MAJOR=16 -t myuser/pgvector .
 ```
 
 ### Homebrew
@@ -639,22 +1079,37 @@ pgxn install vector
 Debian and Ubuntu packages are available from the [PostgreSQL APT Repository](https://wiki.postgresql.org/wiki/Apt). Follow the [setup instructions](https://wiki.postgresql.org/wiki/Apt#Quickstart) and run:
 
 ```sh
-sudo apt install postgresql-15-pgvector
+sudo apt install postgresql-16-pgvector
 ```
 
-Note: Replace `15` with your Postgres server version
+Note: Replace `16` with your Postgres server version
 
 ### Yum
 
 RPM packages are available from the [PostgreSQL Yum Repository](https://yum.postgresql.org/). Follow the [setup instructions](https://www.postgresql.org/download/linux/redhat/) for your distribution and run:
 
 ```sh
-sudo yum install pgvector_15
+sudo yum install pgvector_16
 # or
-sudo dnf install pgvector_15
+sudo dnf install pgvector_16
 ```
 
-Note: Replace `15` with your Postgres server version
+Note: Replace `16` with your Postgres server version
+
+### pkg
+
+Install the FreeBSD package with:
+
+```sh
+pkg install postgresql15-pgvector
+```
+
+or the port with:
+
+```sh
+cd /usr/ports/databases/pgvector
+make install
+```
 
 ### conda-forge
 
@@ -690,28 +1145,32 @@ SELECT extversion FROM pg_extension WHERE extname = 'vector';
 
 ## Upgrade Notes
 
-### 0.4.0
+### 0.6.0
 
-If upgrading with Postgres < 13, remove this line from `sql/vector--0.3.2--0.4.0.sql`:
+#### Postgres 12
+
+If upgrading with Postgres 12, remove this line from `sql/vector--0.5.1--0.6.0.sql`:
 
 ```sql
-ALTER TYPE vector SET (STORAGE = extended);
+ALTER TYPE vector SET (STORAGE = external);
 ```
 
 Then run `make install` and `ALTER EXTENSION vector UPDATE;`.
 
-### 0.3.1
+#### Docker
 
-If upgrading from 0.2.7 or 0.3.0, recreate all `ivfflat` indexes after upgrading to ensure all data is indexed.
+The Docker image is now published in the `pgvector` org, and there are tags for each supported version of Postgres (rather than a `latest` tag).
 
-```sql
--- Postgres 12+
-REINDEX INDEX CONCURRENTLY index_name;
+```sh
+docker pull pgvector/pgvector:pg16
+# or
+docker pull pgvector/pgvector:0.6.0-pg16
+```
 
--- Postgres < 12
-CREATE INDEX CONCURRENTLY temp_name ON table USING ivfflat (column opclass);
-DROP INDEX CONCURRENTLY index_name;
-ALTER INDEX temp_name RENAME TO index_name;
+Also, if you’ve increased `maintenance_work_mem`, make sure `--shm-size` is at least that size to avoid an error with parallel HNSW index builds.
+
+```sh
+docker run --shm-size=1g ...
 ```
 
 ## Thanks
@@ -757,14 +1216,32 @@ make prove_installcheck  # TAP tests
 To run single tests:
 
 ```sh
-make installcheck REGRESS=functions                    # regression test
-make prove_installcheck PROVE_TESTS=test/t/001_wal.pl  # TAP test
+make installcheck REGRESS=functions                            # regression test
+make prove_installcheck PROVE_TESTS=test/t/001_ivfflat_wal.pl  # TAP test
+```
+
+To enable assertions:
+
+```sh
+make clean && PG_CFLAGS="-DUSE_ASSERT_CHECKING" make && make install
 ```
 
 To enable benchmarking:
 
 ```sh
-make clean && PG_CFLAGS=-DIVFFLAT_BENCH make && make install
+make clean && PG_CFLAGS="-DIVFFLAT_BENCH" make && make install
+```
+
+To show memory usage:
+
+```sh
+make clean && PG_CFLAGS="-DHNSW_MEMORY -DIVFFLAT_MEMORY" make && make install
+```
+
+To get k-means metrics:
+
+```sh
+make clean && PG_CFLAGS="-DIVFFLAT_KMEANS_DEBUG" make && make install
 ```
 
 Resources for contributors

sql/vector--0.5.1--0.6.0.sql

@@ -0,0 +1,5 @@
+-- complain if script is sourced in psql, rather than via CREATE EXTENSION
+\echo Use "ALTER EXTENSION vector UPDATE TO '0.6.0'" to load this file. \quit
+
+-- remove this single line for Postgres < 13
+ALTER TYPE vector SET (STORAGE = external);

sql/vector--0.6.0--0.6.1.sql

@@ -0,0 +1,16 @@
+-- complain if script is sourced in psql, rather than via CREATE EXTENSION
+\echo Use "ALTER EXTENSION vector UPDATE TO '0.6.1'" to load this file. \quit
+
+DROP OPERATOR - (vector, vector);
+
+CREATE OPERATOR - (
+	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = vector_sub
+);
+
+ALTER OPERATOR <= (vector, vector) SET (
+	RESTRICT = scalarlesel, JOIN = scalarlejoinsel
+);
+
+ALTER OPERATOR >= (vector, vector) SET (
+	RESTRICT = scalargesel, JOIN = scalargejoinsel
+);

sql/vector--0.6.1--0.6.2.sql

@@ -0,0 +1,2 @@
+-- complain if script is sourced in psql, rather than via CREATE EXTENSION
+\echo Use "ALTER EXTENSION vector UPDATE TO '0.6.2'" to load this file. \quit

sql/vector--0.6.2--0.7.0.sql

@@ -0,0 +1,569 @@
+-- complain if script is sourced in psql, rather than via CREATE EXTENSION
+\echo Use "ALTER EXTENSION vector UPDATE TO '0.7.0'" to load this file. \quit
+
+CREATE FUNCTION l2_normalize(vector) RETURNS vector
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION binary_quantize(vector) RETURNS bit
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION subvector(vector, int, int) RETURNS vector
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION vector_concat(vector, vector) RETURNS vector
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE OPERATOR <+> (
+	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = l1_distance,
+	COMMUTATOR = '<+>'
+);
+
+CREATE OPERATOR || (
+	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = vector_concat
+);
+
+CREATE FUNCTION ivfflat_halfvec_support(internal) RETURNS internal
+	AS 'MODULE_PATHNAME' LANGUAGE C;
+
+CREATE FUNCTION ivfflat_bit_support(internal) RETURNS internal
+	AS 'MODULE_PATHNAME' LANGUAGE C;
+
+CREATE FUNCTION hnsw_halfvec_support(internal) RETURNS internal
+	AS 'MODULE_PATHNAME' LANGUAGE C;
+
+CREATE FUNCTION hnsw_bit_support(internal) RETURNS internal
+	AS 'MODULE_PATHNAME' LANGUAGE C;
+
+CREATE FUNCTION hnsw_sparsevec_support(internal) RETURNS internal
+	AS 'MODULE_PATHNAME' LANGUAGE C;
+
+CREATE OPERATOR CLASS vector_l1_ops
+	FOR TYPE vector USING hnsw AS
+	OPERATOR 1 <+> (vector, vector) FOR ORDER BY float_ops,
+	FUNCTION 1 l1_distance(vector, vector);
+
+CREATE TYPE halfvec;
+
+CREATE FUNCTION halfvec_in(cstring, oid, integer) RETURNS halfvec
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION halfvec_out(halfvec) RETURNS cstring
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION halfvec_typmod_in(cstring[]) RETURNS integer
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION halfvec_recv(internal, oid, integer) RETURNS halfvec
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION halfvec_send(halfvec) RETURNS bytea
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE TYPE halfvec (
+	INPUT     = halfvec_in,
+	OUTPUT    = halfvec_out,
+	TYPMOD_IN = halfvec_typmod_in,
+	RECEIVE   = halfvec_recv,
+	SEND      = halfvec_send,
+	STORAGE   = external
+);
+
+CREATE FUNCTION l2_distance(halfvec, halfvec) RETURNS float8
+	AS 'MODULE_PATHNAME', 'halfvec_l2_distance' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION inner_product(halfvec, halfvec) RETURNS float8
+	AS 'MODULE_PATHNAME', 'halfvec_inner_product' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION cosine_distance(halfvec, halfvec) RETURNS float8
+	AS 'MODULE_PATHNAME', 'halfvec_cosine_distance' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION l1_distance(halfvec, halfvec) RETURNS float8
+	AS 'MODULE_PATHNAME', 'halfvec_l1_distance' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION vector_dims(halfvec) RETURNS integer
+	AS 'MODULE_PATHNAME', 'halfvec_vector_dims' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION l2_norm(halfvec) RETURNS float8
+	AS 'MODULE_PATHNAME', 'halfvec_l2_norm' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION l2_normalize(halfvec) RETURNS halfvec
+	AS 'MODULE_PATHNAME', 'halfvec_l2_normalize' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION binary_quantize(halfvec) RETURNS bit
+	AS 'MODULE_PATHNAME', 'halfvec_binary_quantize' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION subvector(halfvec, int, int) RETURNS halfvec
+	AS 'MODULE_PATHNAME', 'halfvec_subvector' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION halfvec_add(halfvec, halfvec) RETURNS halfvec
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION halfvec_sub(halfvec, halfvec) RETURNS halfvec
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION halfvec_mul(halfvec, halfvec) RETURNS halfvec
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION halfvec_concat(halfvec, halfvec) RETURNS halfvec
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION halfvec_lt(halfvec, halfvec) RETURNS bool
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION halfvec_le(halfvec, halfvec) RETURNS bool
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION halfvec_eq(halfvec, halfvec) RETURNS bool
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION halfvec_ne(halfvec, halfvec) RETURNS bool
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION halfvec_ge(halfvec, halfvec) RETURNS bool
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION halfvec_gt(halfvec, halfvec) RETURNS bool
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION halfvec_cmp(halfvec, halfvec) RETURNS int4
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION halfvec_l2_squared_distance(halfvec, halfvec) RETURNS float8
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION halfvec_negative_inner_product(halfvec, halfvec) RETURNS float8
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION halfvec_spherical_distance(halfvec, halfvec) RETURNS float8
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION halfvec_accum(double precision[], halfvec) RETURNS double precision[]
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION halfvec_avg(double precision[]) RETURNS halfvec
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION halfvec_combine(double precision[], double precision[]) RETURNS double precision[]
+	AS 'MODULE_PATHNAME', 'vector_combine' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE AGGREGATE avg(halfvec) (
+	SFUNC = halfvec_accum,
+	STYPE = double precision[],
+	FINALFUNC = halfvec_avg,
+	COMBINEFUNC = halfvec_combine,
+	INITCOND = '{0}',
+	PARALLEL = SAFE
+);
+
+CREATE AGGREGATE sum(halfvec) (
+	SFUNC = halfvec_add,
+	STYPE = halfvec,
+	COMBINEFUNC = halfvec_add,
+	PARALLEL = SAFE
+);
+
+CREATE FUNCTION halfvec(halfvec, integer, boolean) RETURNS halfvec
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION halfvec_to_vector(halfvec, integer, boolean) RETURNS vector
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION vector_to_halfvec(vector, integer, boolean) RETURNS halfvec
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION array_to_halfvec(integer[], integer, boolean) RETURNS halfvec
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION array_to_halfvec(real[], integer, boolean) RETURNS halfvec
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION array_to_halfvec(double precision[], integer, boolean) RETURNS halfvec
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION array_to_halfvec(numeric[], integer, boolean) RETURNS halfvec
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION halfvec_to_float4(halfvec, integer, boolean) RETURNS real[]
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE CAST (halfvec AS halfvec)
+	WITH FUNCTION halfvec(halfvec, integer, boolean) AS IMPLICIT;
+
+CREATE CAST (halfvec AS vector)
+	WITH FUNCTION halfvec_to_vector(halfvec, integer, boolean) AS ASSIGNMENT;
+
+CREATE CAST (vector AS halfvec)
+	WITH FUNCTION vector_to_halfvec(vector, integer, boolean) AS IMPLICIT;
+
+CREATE CAST (halfvec AS real[])
+	WITH FUNCTION halfvec_to_float4(halfvec, integer, boolean) AS ASSIGNMENT;
+
+CREATE CAST (integer[] AS halfvec)
+	WITH FUNCTION array_to_halfvec(integer[], integer, boolean) AS ASSIGNMENT;
+
+CREATE CAST (real[] AS halfvec)
+	WITH FUNCTION array_to_halfvec(real[], integer, boolean) AS ASSIGNMENT;
+
+CREATE CAST (double precision[] AS halfvec)
+	WITH FUNCTION array_to_halfvec(double precision[], integer, boolean) AS ASSIGNMENT;
+
+CREATE CAST (numeric[] AS halfvec)
+	WITH FUNCTION array_to_halfvec(numeric[], integer, boolean) AS ASSIGNMENT;
+
+CREATE OPERATOR <-> (
+	LEFTARG = halfvec, RIGHTARG = halfvec, PROCEDURE = l2_distance,
+	COMMUTATOR = '<->'
+);
+
+CREATE OPERATOR <#> (
+	LEFTARG = halfvec, RIGHTARG = halfvec, PROCEDURE = halfvec_negative_inner_product,
+	COMMUTATOR = '<#>'
+);
+
+CREATE OPERATOR <=> (
+	LEFTARG = halfvec, RIGHTARG = halfvec, PROCEDURE = cosine_distance,
+	COMMUTATOR = '<=>'
+);
+
+CREATE OPERATOR <+> (
+	LEFTARG = halfvec, RIGHTARG = halfvec, PROCEDURE = l1_distance,
+	COMMUTATOR = '<+>'
+);
+
+CREATE OPERATOR + (
+	LEFTARG = halfvec, RIGHTARG = halfvec, PROCEDURE = halfvec_add,
+	COMMUTATOR = +
+);
+
+CREATE OPERATOR - (
+	LEFTARG = halfvec, RIGHTARG = halfvec, PROCEDURE = halfvec_sub
+);
+
+CREATE OPERATOR * (
+	LEFTARG = halfvec, RIGHTARG = halfvec, PROCEDURE = halfvec_mul,
+	COMMUTATOR = *
+);
+
+CREATE OPERATOR || (
+	LEFTARG = halfvec, RIGHTARG = halfvec, PROCEDURE = halfvec_concat
+);
+
+CREATE OPERATOR < (
+	LEFTARG = halfvec, RIGHTARG = halfvec, PROCEDURE = halfvec_lt,
+	COMMUTATOR = > , NEGATOR = >= ,
+	RESTRICT = scalarltsel, JOIN = scalarltjoinsel
+);
+
+CREATE OPERATOR <= (
+	LEFTARG = halfvec, RIGHTARG = halfvec, PROCEDURE = halfvec_le,
+	COMMUTATOR = >= , NEGATOR = > ,
+	RESTRICT = scalarlesel, JOIN = scalarlejoinsel
+);
+
+CREATE OPERATOR = (
+	LEFTARG = halfvec, RIGHTARG = halfvec, PROCEDURE = halfvec_eq,
+	COMMUTATOR = = , NEGATOR = <> ,
+	RESTRICT = eqsel, JOIN = eqjoinsel
+);
+
+CREATE OPERATOR <> (
+	LEFTARG = halfvec, RIGHTARG = halfvec, PROCEDURE = halfvec_ne,
+	COMMUTATOR = <> , NEGATOR = = ,
+	RESTRICT = eqsel, JOIN = eqjoinsel
+);
+
+CREATE OPERATOR >= (
+	LEFTARG = halfvec, RIGHTARG = halfvec, PROCEDURE = halfvec_ge,
+	COMMUTATOR = <= , NEGATOR = < ,
+	RESTRICT = scalargesel, JOIN = scalargejoinsel
+);
+
+CREATE OPERATOR > (
+	LEFTARG = halfvec, RIGHTARG = halfvec, PROCEDURE = halfvec_gt,
+	COMMUTATOR = < , NEGATOR = <= ,
+	RESTRICT = scalargtsel, JOIN = scalargtjoinsel
+);
+
+CREATE OPERATOR CLASS halfvec_ops
+	DEFAULT FOR TYPE halfvec USING btree AS
+	OPERATOR 1 < ,
+	OPERATOR 2 <= ,
+	OPERATOR 3 = ,
+	OPERATOR 4 >= ,
+	OPERATOR 5 > ,
+	FUNCTION 1 halfvec_cmp(halfvec, halfvec);
+
+CREATE OPERATOR CLASS halfvec_l2_ops
+	FOR TYPE halfvec USING ivfflat AS
+	OPERATOR 1 <-> (halfvec, halfvec) FOR ORDER BY float_ops,
+	FUNCTION 1 halfvec_l2_squared_distance(halfvec, halfvec),
+	FUNCTION 3 l2_distance(halfvec, halfvec),
+	FUNCTION 5 ivfflat_halfvec_support(internal);
+
+CREATE OPERATOR CLASS halfvec_ip_ops
+	FOR TYPE halfvec USING ivfflat AS
+	OPERATOR 1 <#> (halfvec, halfvec) FOR ORDER BY float_ops,
+	FUNCTION 1 halfvec_negative_inner_product(halfvec, halfvec),
+	FUNCTION 3 halfvec_spherical_distance(halfvec, halfvec),
+	FUNCTION 4 l2_norm(halfvec),
+	FUNCTION 5 ivfflat_halfvec_support(internal);
+
+CREATE OPERATOR CLASS halfvec_cosine_ops
+	FOR TYPE halfvec USING ivfflat AS
+	OPERATOR 1 <=> (halfvec, halfvec) FOR ORDER BY float_ops,
+	FUNCTION 1 halfvec_negative_inner_product(halfvec, halfvec),
+	FUNCTION 2 l2_norm(halfvec),
+	FUNCTION 3 halfvec_spherical_distance(halfvec, halfvec),
+	FUNCTION 4 l2_norm(halfvec),
+	FUNCTION 5 ivfflat_halfvec_support(internal);
+
+CREATE OPERATOR CLASS halfvec_l2_ops
+	FOR TYPE halfvec USING hnsw AS
+	OPERATOR 1 <-> (halfvec, halfvec) FOR ORDER BY float_ops,
+	FUNCTION 1 halfvec_l2_squared_distance(halfvec, halfvec),
+	FUNCTION 3 hnsw_halfvec_support(internal);
+
+CREATE OPERATOR CLASS halfvec_ip_ops
+	FOR TYPE halfvec USING hnsw AS
+	OPERATOR 1 <#> (halfvec, halfvec) FOR ORDER BY float_ops,
+	FUNCTION 1 halfvec_negative_inner_product(halfvec, halfvec),
+	FUNCTION 3 hnsw_halfvec_support(internal);
+
+CREATE OPERATOR CLASS halfvec_cosine_ops
+	FOR TYPE halfvec USING hnsw AS
+	OPERATOR 1 <=> (halfvec, halfvec) FOR ORDER BY float_ops,
+	FUNCTION 1 halfvec_negative_inner_product(halfvec, halfvec),
+	FUNCTION 2 l2_norm(halfvec),
+	FUNCTION 3 hnsw_halfvec_support(internal);
+
+CREATE OPERATOR CLASS halfvec_l1_ops
+	FOR TYPE halfvec USING hnsw AS
+	OPERATOR 1 <+> (halfvec, halfvec) FOR ORDER BY float_ops,
+	FUNCTION 1 l1_distance(halfvec, halfvec),
+	FUNCTION 3 hnsw_halfvec_support(internal);
+
+CREATE FUNCTION hamming_distance(bit, bit) RETURNS float8
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION jaccard_distance(bit, bit) RETURNS float8
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE OPERATOR <~> (
+	LEFTARG = bit, RIGHTARG = bit, PROCEDURE = hamming_distance,
+	COMMUTATOR = '<~>'
+);
+
+CREATE OPERATOR <%> (
+	LEFTARG = bit, RIGHTARG = bit, PROCEDURE = jaccard_distance,
+	COMMUTATOR = '<%>'
+);
+
+CREATE OPERATOR CLASS bit_hamming_ops
+	FOR TYPE bit USING ivfflat AS
+	OPERATOR 1 <~> (bit, bit) FOR ORDER BY float_ops,
+	FUNCTION 1 hamming_distance(bit, bit),
+	FUNCTION 3 hamming_distance(bit, bit),
+	FUNCTION 5 ivfflat_bit_support(internal);
+
+CREATE OPERATOR CLASS bit_hamming_ops
+	FOR TYPE bit USING hnsw AS
+	OPERATOR 1 <~> (bit, bit) FOR ORDER BY float_ops,
+	FUNCTION 1 hamming_distance(bit, bit),
+	FUNCTION 3 hnsw_bit_support(internal);
+
+CREATE OPERATOR CLASS bit_jaccard_ops
+	FOR TYPE bit USING hnsw AS
+	OPERATOR 1 <%> (bit, bit) FOR ORDER BY float_ops,
+	FUNCTION 1 jaccard_distance(bit, bit),
+	FUNCTION 3 hnsw_bit_support(internal);
+
+CREATE TYPE sparsevec;
+
+CREATE FUNCTION sparsevec_in(cstring, oid, integer) RETURNS sparsevec
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION sparsevec_out(sparsevec) RETURNS cstring
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION sparsevec_typmod_in(cstring[]) RETURNS integer
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION sparsevec_recv(internal, oid, integer) RETURNS sparsevec
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION sparsevec_send(sparsevec) RETURNS bytea
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE TYPE sparsevec (
+	INPUT     = sparsevec_in,
+	OUTPUT    = sparsevec_out,
+	TYPMOD_IN = sparsevec_typmod_in,
+	RECEIVE   = sparsevec_recv,
+	SEND      = sparsevec_send,
+	STORAGE   = external
+);
+
+CREATE FUNCTION l2_distance(sparsevec, sparsevec) RETURNS float8
+	AS 'MODULE_PATHNAME', 'sparsevec_l2_distance' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION inner_product(sparsevec, sparsevec) RETURNS float8
+	AS 'MODULE_PATHNAME', 'sparsevec_inner_product' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION cosine_distance(sparsevec, sparsevec) RETURNS float8
+	AS 'MODULE_PATHNAME', 'sparsevec_cosine_distance' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION l1_distance(sparsevec, sparsevec) RETURNS float8
+	AS 'MODULE_PATHNAME', 'sparsevec_l1_distance' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION l2_norm(sparsevec) RETURNS float8
+	AS 'MODULE_PATHNAME', 'sparsevec_l2_norm' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION l2_normalize(sparsevec) RETURNS sparsevec
+	AS 'MODULE_PATHNAME', 'sparsevec_l2_normalize' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION sparsevec_lt(sparsevec, sparsevec) RETURNS bool
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION sparsevec_le(sparsevec, sparsevec) RETURNS bool
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION sparsevec_eq(sparsevec, sparsevec) RETURNS bool
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION sparsevec_ne(sparsevec, sparsevec) RETURNS bool
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION sparsevec_ge(sparsevec, sparsevec) RETURNS bool
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION sparsevec_gt(sparsevec, sparsevec) RETURNS bool
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION sparsevec_cmp(sparsevec, sparsevec) RETURNS int4
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION sparsevec_l2_squared_distance(sparsevec, sparsevec) RETURNS float8
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION sparsevec_negative_inner_product(sparsevec, sparsevec) RETURNS float8
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION sparsevec(sparsevec, integer, boolean) RETURNS sparsevec
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION vector_to_sparsevec(vector, integer, boolean) RETURNS sparsevec
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION sparsevec_to_vector(sparsevec, integer, boolean) RETURNS vector
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION halfvec_to_sparsevec(halfvec, integer, boolean) RETURNS sparsevec
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION sparsevec_to_halfvec(sparsevec, integer, boolean) RETURNS halfvec
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE CAST (sparsevec AS sparsevec)
+	WITH FUNCTION sparsevec(sparsevec, integer, boolean) AS IMPLICIT;
+
+CREATE CAST (sparsevec AS vector)
+	WITH FUNCTION sparsevec_to_vector(sparsevec, integer, boolean) AS ASSIGNMENT;
+
+CREATE CAST (vector AS sparsevec)
+	WITH FUNCTION vector_to_sparsevec(vector, integer, boolean) AS IMPLICIT;
+
+CREATE CAST (sparsevec AS halfvec)
+	WITH FUNCTION sparsevec_to_halfvec(sparsevec, integer, boolean) AS ASSIGNMENT;
+
+CREATE CAST (halfvec AS sparsevec)
+	WITH FUNCTION halfvec_to_sparsevec(halfvec, integer, boolean) AS IMPLICIT;
+
+CREATE OPERATOR <-> (
+	LEFTARG = sparsevec, RIGHTARG = sparsevec, PROCEDURE = l2_distance,
+	COMMUTATOR = '<->'
+);
+
+CREATE OPERATOR <#> (
+	LEFTARG = sparsevec, RIGHTARG = sparsevec, PROCEDURE = sparsevec_negative_inner_product,
+	COMMUTATOR = '<#>'
+);
+
+CREATE OPERATOR <=> (
+	LEFTARG = sparsevec, RIGHTARG = sparsevec, PROCEDURE = cosine_distance,
+	COMMUTATOR = '<=>'
+);
+
+CREATE OPERATOR <+> (
+	LEFTARG = sparsevec, RIGHTARG = sparsevec, PROCEDURE = l1_distance,
+	COMMUTATOR = '<+>'
+);
+
+CREATE OPERATOR < (
+	LEFTARG = sparsevec, RIGHTARG = sparsevec, PROCEDURE = sparsevec_lt,
+	COMMUTATOR = > , NEGATOR = >= ,
+	RESTRICT = scalarltsel, JOIN = scalarltjoinsel
+);
+
+CREATE OPERATOR <= (
+	LEFTARG = sparsevec, RIGHTARG = sparsevec, PROCEDURE = sparsevec_le,
+	COMMUTATOR = >= , NEGATOR = > ,
+	RESTRICT = scalarlesel, JOIN = scalarlejoinsel
+);
+
+CREATE OPERATOR = (
+	LEFTARG = sparsevec, RIGHTARG = sparsevec, PROCEDURE = sparsevec_eq,
+	COMMUTATOR = = , NEGATOR = <> ,
+	RESTRICT = eqsel, JOIN = eqjoinsel
+);
+
+CREATE OPERATOR <> (
+	LEFTARG = sparsevec, RIGHTARG = sparsevec, PROCEDURE = sparsevec_ne,
+	COMMUTATOR = <> , NEGATOR = = ,
+	RESTRICT = eqsel, JOIN = eqjoinsel
+);
+
+CREATE OPERATOR >= (
+	LEFTARG = sparsevec, RIGHTARG = sparsevec, PROCEDURE = sparsevec_ge,
+	COMMUTATOR = <= , NEGATOR = < ,
+	RESTRICT = scalargesel, JOIN = scalargejoinsel
+);
+
+CREATE OPERATOR > (
+	LEFTARG = sparsevec, RIGHTARG = sparsevec, PROCEDURE = sparsevec_gt,
+	COMMUTATOR = < , NEGATOR = <= ,
+	RESTRICT = scalargtsel, JOIN = scalargtjoinsel
+);
+
+CREATE OPERATOR CLASS sparsevec_ops
+	DEFAULT FOR TYPE sparsevec USING btree AS
+	OPERATOR 1 < ,
+	OPERATOR 2 <= ,
+	OPERATOR 3 = ,
+	OPERATOR 4 >= ,
+	OPERATOR 5 > ,
+	FUNCTION 1 sparsevec_cmp(sparsevec, sparsevec);
+
+CREATE OPERATOR CLASS sparsevec_l2_ops
+	FOR TYPE sparsevec USING hnsw AS
+	OPERATOR 1 <-> (sparsevec, sparsevec) FOR ORDER BY float_ops,
+	FUNCTION 1 sparsevec_l2_squared_distance(sparsevec, sparsevec),
+	FUNCTION 3 hnsw_sparsevec_support(internal);
+
+CREATE OPERATOR CLASS sparsevec_ip_ops
+	FOR TYPE sparsevec USING hnsw AS
+	OPERATOR 1 <#> (sparsevec, sparsevec) FOR ORDER BY float_ops,
+	FUNCTION 1 sparsevec_negative_inner_product(sparsevec, sparsevec),
+	FUNCTION 3 hnsw_sparsevec_support(internal);
+
+CREATE OPERATOR CLASS sparsevec_cosine_ops
+	FOR TYPE sparsevec USING hnsw AS
+	OPERATOR 1 <=> (sparsevec, sparsevec) FOR ORDER BY float_ops,
+	FUNCTION 1 sparsevec_negative_inner_product(sparsevec, sparsevec),
+	FUNCTION 2 l2_norm(sparsevec),
+	FUNCTION 3 hnsw_sparsevec_support(internal);
+
+CREATE OPERATOR CLASS sparsevec_l1_ops
+	FOR TYPE sparsevec USING hnsw AS
+	OPERATOR 1 <+> (sparsevec, sparsevec) FOR ORDER BY float_ops,
+	FUNCTION 1 l1_distance(sparsevec, sparsevec),
+	FUNCTION 3 hnsw_sparsevec_support(internal);

sql/vector--0.7.0--0.7.1.sql

@@ -0,0 +1,2 @@
+-- complain if script is sourced in psql, rather than via CREATE EXTENSION
+\echo Use "ALTER EXTENSION vector UPDATE TO '0.7.1'" to load this file. \quit

sql/vector--0.7.1--0.7.2.sql

@@ -0,0 +1,2 @@
+-- complain if script is sourced in psql, rather than via CREATE EXTENSION
+\echo Use "ALTER EXTENSION vector UPDATE TO '0.7.2'" to load this file. \quit

sql/vector--0.7.2--0.7.3.sql

@@ -0,0 +1,2 @@
+-- complain if script is sourced in psql, rather than via CREATE EXTENSION
+\echo Use "ALTER EXTENSION vector UPDATE TO '0.7.3'" to load this file. \quit

sql/vector.sql

@@ -1,7 +1,7 @@
 -- complain if script is sourced in psql, rather than via CREATE EXTENSION
 \echo Use "CREATE EXTENSION vector" to load this file. \quit
 
--- type
+-- vector type
 
 CREATE TYPE vector;
 
@@ -26,10 +26,10 @@ CREATE TYPE vector (
 	TYPMOD_IN = vector_typmod_in,
 	RECEIVE   = vector_recv,
 	SEND      = vector_send,
-	STORAGE   = extended
+	STORAGE   = external
 );
 
--- functions
+-- vector functions
 
 CREATE FUNCTION l2_distance(vector, vector) RETURNS float8
 	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
@@ -49,6 +49,17 @@ CREATE FUNCTION vector_dims(vector) RETURNS integer
 CREATE FUNCTION vector_norm(vector) RETURNS float8
 	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
 
+CREATE FUNCTION l2_normalize(vector) RETURNS vector
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION binary_quantize(vector) RETURNS bit
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION subvector(vector, int, int) RETURNS vector
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+-- vector private functions
+
 CREATE FUNCTION vector_add(vector, vector) RETURNS vector
 	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
 
@@ -58,7 +69,8 @@ CREATE FUNCTION vector_sub(vector, vector) RETURNS vector
 CREATE FUNCTION vector_mul(vector, vector) RETURNS vector
 	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
 
--- private functions
+CREATE FUNCTION vector_concat(vector, vector) RETURNS vector
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
 
 CREATE FUNCTION vector_lt(vector, vector) RETURNS bool
 	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
@@ -99,7 +111,7 @@ CREATE FUNCTION vector_avg(double precision[]) RETURNS vector
 CREATE FUNCTION vector_combine(double precision[], double precision[]) RETURNS double precision[]
 	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
 
--- aggregates
+-- vector aggregates
 
 CREATE AGGREGATE avg(vector) (
 	SFUNC = vector_accum,
@@ -117,7 +129,7 @@ CREATE AGGREGATE sum(vector) (
 	PARALLEL = SAFE
 );
 
--- cast functions
+-- vector cast functions
 
 CREATE FUNCTION vector(vector, integer, boolean) RETURNS vector
 	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
@@ -137,7 +149,7 @@ CREATE FUNCTION array_to_vector(numeric[], integer, boolean) RETURNS vector
 CREATE FUNCTION vector_to_float4(vector, integer, boolean) RETURNS real[]
 	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
 
--- casts
+-- vector casts
 
 CREATE CAST (vector AS vector)
 	WITH FUNCTION vector(vector, integer, boolean) AS IMPLICIT;
@@ -157,7 +169,7 @@ CREATE CAST (double precision[] AS vector)
 CREATE CAST (numeric[] AS vector)
 	WITH FUNCTION array_to_vector(numeric[], integer, boolean) AS ASSIGNMENT;
 
--- operators
+-- vector operators
 
 CREATE OPERATOR <-> (
 	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = l2_distance,
@@ -174,14 +186,18 @@ CREATE OPERATOR <=> (
 	COMMUTATOR = '<=>'
 );
 
+CREATE OPERATOR <+> (
+	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = l1_distance,
+	COMMUTATOR = '<+>'
+);
+
 CREATE OPERATOR + (
 	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = vector_add,
 	COMMUTATOR = +
 );
 
 CREATE OPERATOR - (
-	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = vector_sub,
-	COMMUTATOR = -
+	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = vector_sub
 );
 
 CREATE OPERATOR * (
@@ -189,17 +205,20 @@ CREATE OPERATOR * (
 	COMMUTATOR = *
 );
 
+CREATE OPERATOR || (
+	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = vector_concat
+);
+
 CREATE OPERATOR < (
 	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = vector_lt,
 	COMMUTATOR = > , NEGATOR = >= ,
 	RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );
 
--- should use scalarlesel and scalarlejoinsel, but not supported in Postgres < 11
 CREATE OPERATOR <= (
 	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = vector_le,
 	COMMUTATOR = >= , NEGATOR = > ,
-	RESTRICT = scalarltsel, JOIN = scalarltjoinsel
+	RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );
 
 CREATE OPERATOR = (
@@ -214,11 +233,10 @@ CREATE OPERATOR <> (
 	RESTRICT = eqsel, JOIN = eqjoinsel
 );
 
--- should use scalargesel and scalargejoinsel, but not supported in Postgres < 11
 CREATE OPERATOR >= (
 	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = vector_ge,
 	COMMUTATOR = <= , NEGATOR = < ,
-	RESTRICT = scalargtsel, JOIN = scalargtjoinsel
+	RESTRICT = scalargesel, JOIN = scalargejoinsel
 );
 
 CREATE OPERATOR > (
@@ -243,7 +261,24 @@ CREATE ACCESS METHOD hnsw TYPE INDEX HANDLER hnswhandler;
 
 COMMENT ON ACCESS METHOD hnsw IS 'hnsw index access method';
 
--- opclasses
+-- access method private functions
+
+CREATE FUNCTION ivfflat_halfvec_support(internal) RETURNS internal
+	AS 'MODULE_PATHNAME' LANGUAGE C;
+
+CREATE FUNCTION ivfflat_bit_support(internal) RETURNS internal
+	AS 'MODULE_PATHNAME' LANGUAGE C;
+
+CREATE FUNCTION hnsw_halfvec_support(internal) RETURNS internal
+	AS 'MODULE_PATHNAME' LANGUAGE C;
+
+CREATE FUNCTION hnsw_bit_support(internal) RETURNS internal
+	AS 'MODULE_PATHNAME' LANGUAGE C;
+
+CREATE FUNCTION hnsw_sparsevec_support(internal) RETURNS internal
+	AS 'MODULE_PATHNAME' LANGUAGE C;
+
+-- vector opclasses
 
 CREATE OPERATOR CLASS vector_ops
 	DEFAULT FOR TYPE vector USING btree AS
@@ -290,3 +325,570 @@ CREATE OPERATOR CLASS vector_cosine_ops
 	OPERATOR 1 <=> (vector, vector) FOR ORDER BY float_ops,
 	FUNCTION 1 vector_negative_inner_product(vector, vector),
 	FUNCTION 2 vector_norm(vector);
+
+CREATE OPERATOR CLASS vector_l1_ops
+	FOR TYPE vector USING hnsw AS
+	OPERATOR 1 <+> (vector, vector) FOR ORDER BY float_ops,
+	FUNCTION 1 l1_distance(vector, vector);
+
+-- halfvec type
+
+CREATE TYPE halfvec;
+
+CREATE FUNCTION halfvec_in(cstring, oid, integer) RETURNS halfvec
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION halfvec_out(halfvec) RETURNS cstring
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION halfvec_typmod_in(cstring[]) RETURNS integer
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION halfvec_recv(internal, oid, integer) RETURNS halfvec
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION halfvec_send(halfvec) RETURNS bytea
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE TYPE halfvec (
+	INPUT     = halfvec_in,
+	OUTPUT    = halfvec_out,
+	TYPMOD_IN = halfvec_typmod_in,
+	RECEIVE   = halfvec_recv,
+	SEND      = halfvec_send,
+	STORAGE   = external
+);
+
+-- halfvec functions
+
+CREATE FUNCTION l2_distance(halfvec, halfvec) RETURNS float8
+	AS 'MODULE_PATHNAME', 'halfvec_l2_distance' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION inner_product(halfvec, halfvec) RETURNS float8
+	AS 'MODULE_PATHNAME', 'halfvec_inner_product' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION cosine_distance(halfvec, halfvec) RETURNS float8
+	AS 'MODULE_PATHNAME', 'halfvec_cosine_distance' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION l1_distance(halfvec, halfvec) RETURNS float8
+	AS 'MODULE_PATHNAME', 'halfvec_l1_distance' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION vector_dims(halfvec) RETURNS integer
+	AS 'MODULE_PATHNAME', 'halfvec_vector_dims' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION l2_norm(halfvec) RETURNS float8
+	AS 'MODULE_PATHNAME', 'halfvec_l2_norm' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION l2_normalize(halfvec) RETURNS halfvec
+	AS 'MODULE_PATHNAME', 'halfvec_l2_normalize' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION binary_quantize(halfvec) RETURNS bit
+	AS 'MODULE_PATHNAME', 'halfvec_binary_quantize' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION subvector(halfvec, int, int) RETURNS halfvec
+	AS 'MODULE_PATHNAME', 'halfvec_subvector' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+-- halfvec private functions
+
+CREATE FUNCTION halfvec_add(halfvec, halfvec) RETURNS halfvec
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION halfvec_sub(halfvec, halfvec) RETURNS halfvec
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION halfvec_mul(halfvec, halfvec) RETURNS halfvec
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION halfvec_concat(halfvec, halfvec) RETURNS halfvec
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION halfvec_lt(halfvec, halfvec) RETURNS bool
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION halfvec_le(halfvec, halfvec) RETURNS bool
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION halfvec_eq(halfvec, halfvec) RETURNS bool
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION halfvec_ne(halfvec, halfvec) RETURNS bool
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION halfvec_ge(halfvec, halfvec) RETURNS bool
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION halfvec_gt(halfvec, halfvec) RETURNS bool
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION halfvec_cmp(halfvec, halfvec) RETURNS int4
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION halfvec_l2_squared_distance(halfvec, halfvec) RETURNS float8
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION halfvec_negative_inner_product(halfvec, halfvec) RETURNS float8
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION halfvec_spherical_distance(halfvec, halfvec) RETURNS float8
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION halfvec_accum(double precision[], halfvec) RETURNS double precision[]
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION halfvec_avg(double precision[]) RETURNS halfvec
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION halfvec_combine(double precision[], double precision[]) RETURNS double precision[]
+	AS 'MODULE_PATHNAME', 'vector_combine' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+-- halfvec aggregates
+
+CREATE AGGREGATE avg(halfvec) (
+	SFUNC = halfvec_accum,
+	STYPE = double precision[],
+	FINALFUNC = halfvec_avg,
+	COMBINEFUNC = halfvec_combine,
+	INITCOND = '{0}',
+	PARALLEL = SAFE
+);
+
+CREATE AGGREGATE sum(halfvec) (
+	SFUNC = halfvec_add,
+	STYPE = halfvec,
+	COMBINEFUNC = halfvec_add,
+	PARALLEL = SAFE
+);
+
+-- halfvec cast functions
+
+CREATE FUNCTION halfvec(halfvec, integer, boolean) RETURNS halfvec
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION halfvec_to_vector(halfvec, integer, boolean) RETURNS vector
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION vector_to_halfvec(vector, integer, boolean) RETURNS halfvec
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION array_to_halfvec(integer[], integer, boolean) RETURNS halfvec
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION array_to_halfvec(real[], integer, boolean) RETURNS halfvec
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION array_to_halfvec(double precision[], integer, boolean) RETURNS halfvec
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION array_to_halfvec(numeric[], integer, boolean) RETURNS halfvec
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION halfvec_to_float4(halfvec, integer, boolean) RETURNS real[]
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+-- halfvec casts
+
+CREATE CAST (halfvec AS halfvec)
+	WITH FUNCTION halfvec(halfvec, integer, boolean) AS IMPLICIT;
+
+CREATE CAST (halfvec AS vector)
+	WITH FUNCTION halfvec_to_vector(halfvec, integer, boolean) AS ASSIGNMENT;
+
+CREATE CAST (vector AS halfvec)
+	WITH FUNCTION vector_to_halfvec(vector, integer, boolean) AS IMPLICIT;
+
+CREATE CAST (halfvec AS real[])
+	WITH FUNCTION halfvec_to_float4(halfvec, integer, boolean) AS ASSIGNMENT;
+
+CREATE CAST (integer[] AS halfvec)
+	WITH FUNCTION array_to_halfvec(integer[], integer, boolean) AS ASSIGNMENT;
+
+CREATE CAST (real[] AS halfvec)
+	WITH FUNCTION array_to_halfvec(real[], integer, boolean) AS ASSIGNMENT;
+
+CREATE CAST (double precision[] AS halfvec)
+	WITH FUNCTION array_to_halfvec(double precision[], integer, boolean) AS ASSIGNMENT;
+
+CREATE CAST (numeric[] AS halfvec)
+	WITH FUNCTION array_to_halfvec(numeric[], integer, boolean) AS ASSIGNMENT;
+
+-- halfvec operators
+
+CREATE OPERATOR <-> (
+	LEFTARG = halfvec, RIGHTARG = halfvec, PROCEDURE = l2_distance,
+	COMMUTATOR = '<->'
+);
+
+CREATE OPERATOR <#> (
+	LEFTARG = halfvec, RIGHTARG = halfvec, PROCEDURE = halfvec_negative_inner_product,
+	COMMUTATOR = '<#>'
+);
+
+CREATE OPERATOR <=> (
+	LEFTARG = halfvec, RIGHTARG = halfvec, PROCEDURE = cosine_distance,
+	COMMUTATOR = '<=>'
+);
+
+CREATE OPERATOR <+> (
+	LEFTARG = halfvec, RIGHTARG = halfvec, PROCEDURE = l1_distance,
+	COMMUTATOR = '<+>'
+);
+
+CREATE OPERATOR + (
+	LEFTARG = halfvec, RIGHTARG = halfvec, PROCEDURE = halfvec_add,
+	COMMUTATOR = +
+);
+
+CREATE OPERATOR - (
+	LEFTARG = halfvec, RIGHTARG = halfvec, PROCEDURE = halfvec_sub
+);
+
+CREATE OPERATOR * (
+	LEFTARG = halfvec, RIGHTARG = halfvec, PROCEDURE = halfvec_mul,
+	COMMUTATOR = *
+);
+
+CREATE OPERATOR || (
+	LEFTARG = halfvec, RIGHTARG = halfvec, PROCEDURE = halfvec_concat
+);
+
+CREATE OPERATOR < (
+	LEFTARG = halfvec, RIGHTARG = halfvec, PROCEDURE = halfvec_lt,
+	COMMUTATOR = > , NEGATOR = >= ,
+	RESTRICT = scalarltsel, JOIN = scalarltjoinsel
+);
+
+CREATE OPERATOR <= (
+	LEFTARG = halfvec, RIGHTARG = halfvec, PROCEDURE = halfvec_le,
+	COMMUTATOR = >= , NEGATOR = > ,
+	RESTRICT = scalarlesel, JOIN = scalarlejoinsel
+);
+
+CREATE OPERATOR = (
+	LEFTARG = halfvec, RIGHTARG = halfvec, PROCEDURE = halfvec_eq,
+	COMMUTATOR = = , NEGATOR = <> ,
+	RESTRICT = eqsel, JOIN = eqjoinsel
+);
+
+CREATE OPERATOR <> (
+	LEFTARG = halfvec, RIGHTARG = halfvec, PROCEDURE = halfvec_ne,
+	COMMUTATOR = <> , NEGATOR = = ,
+	RESTRICT = eqsel, JOIN = eqjoinsel
+);
+
+CREATE OPERATOR >= (
+	LEFTARG = halfvec, RIGHTARG = halfvec, PROCEDURE = halfvec_ge,
+	COMMUTATOR = <= , NEGATOR = < ,
+	RESTRICT = scalargesel, JOIN = scalargejoinsel
+);
+
+CREATE OPERATOR > (
+	LEFTARG = halfvec, RIGHTARG = halfvec, PROCEDURE = halfvec_gt,
+	COMMUTATOR = < , NEGATOR = <= ,
+	RESTRICT = scalargtsel, JOIN = scalargtjoinsel
+);
+
+-- halfvec opclasses
+
+CREATE OPERATOR CLASS halfvec_ops
+	DEFAULT FOR TYPE halfvec USING btree AS
+	OPERATOR 1 < ,
+	OPERATOR 2 <= ,
+	OPERATOR 3 = ,
+	OPERATOR 4 >= ,
+	OPERATOR 5 > ,
+	FUNCTION 1 halfvec_cmp(halfvec, halfvec);
+
+CREATE OPERATOR CLASS halfvec_l2_ops
+	FOR TYPE halfvec USING ivfflat AS
+	OPERATOR 1 <-> (halfvec, halfvec) FOR ORDER BY float_ops,
+	FUNCTION 1 halfvec_l2_squared_distance(halfvec, halfvec),
+	FUNCTION 3 l2_distance(halfvec, halfvec),
+	FUNCTION 5 ivfflat_halfvec_support(internal);
+
+CREATE OPERATOR CLASS halfvec_ip_ops
+	FOR TYPE halfvec USING ivfflat AS
+	OPERATOR 1 <#> (halfvec, halfvec) FOR ORDER BY float_ops,
+	FUNCTION 1 halfvec_negative_inner_product(halfvec, halfvec),
+	FUNCTION 3 halfvec_spherical_distance(halfvec, halfvec),
+	FUNCTION 4 l2_norm(halfvec),
+	FUNCTION 5 ivfflat_halfvec_support(internal);
+
+CREATE OPERATOR CLASS halfvec_cosine_ops
+	FOR TYPE halfvec USING ivfflat AS
+	OPERATOR 1 <=> (halfvec, halfvec) FOR ORDER BY float_ops,
+	FUNCTION 1 halfvec_negative_inner_product(halfvec, halfvec),
+	FUNCTION 2 l2_norm(halfvec),
+	FUNCTION 3 halfvec_spherical_distance(halfvec, halfvec),
+	FUNCTION 4 l2_norm(halfvec),
+	FUNCTION 5 ivfflat_halfvec_support(internal);
+
+CREATE OPERATOR CLASS halfvec_l2_ops
+	FOR TYPE halfvec USING hnsw AS
+	OPERATOR 1 <-> (halfvec, halfvec) FOR ORDER BY float_ops,
+	FUNCTION 1 halfvec_l2_squared_distance(halfvec, halfvec),
+	FUNCTION 3 hnsw_halfvec_support(internal);
+
+CREATE OPERATOR CLASS halfvec_ip_ops
+	FOR TYPE halfvec USING hnsw AS
+	OPERATOR 1 <#> (halfvec, halfvec) FOR ORDER BY float_ops,
+	FUNCTION 1 halfvec_negative_inner_product(halfvec, halfvec),
+	FUNCTION 3 hnsw_halfvec_support(internal);
+
+CREATE OPERATOR CLASS halfvec_cosine_ops
+	FOR TYPE halfvec USING hnsw AS
+	OPERATOR 1 <=> (halfvec, halfvec) FOR ORDER BY float_ops,
+	FUNCTION 1 halfvec_negative_inner_product(halfvec, halfvec),
+	FUNCTION 2 l2_norm(halfvec),
+	FUNCTION 3 hnsw_halfvec_support(internal);
+
+CREATE OPERATOR CLASS halfvec_l1_ops
+	FOR TYPE halfvec USING hnsw AS
+	OPERATOR 1 <+> (halfvec, halfvec) FOR ORDER BY float_ops,
+	FUNCTION 1 l1_distance(halfvec, halfvec),
+	FUNCTION 3 hnsw_halfvec_support(internal);
+
+-- bit functions
+
+CREATE FUNCTION hamming_distance(bit, bit) RETURNS float8
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION jaccard_distance(bit, bit) RETURNS float8
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+-- bit operators
+
+CREATE OPERATOR <~> (
+	LEFTARG = bit, RIGHTARG = bit, PROCEDURE = hamming_distance,
+	COMMUTATOR = '<~>'
+);
+
+CREATE OPERATOR <%> (
+	LEFTARG = bit, RIGHTARG = bit, PROCEDURE = jaccard_distance,
+	COMMUTATOR = '<%>'
+);
+
+-- bit opclasses
+
+CREATE OPERATOR CLASS bit_hamming_ops
+	FOR TYPE bit USING ivfflat AS
+	OPERATOR 1 <~> (bit, bit) FOR ORDER BY float_ops,
+	FUNCTION 1 hamming_distance(bit, bit),
+	FUNCTION 3 hamming_distance(bit, bit),
+	FUNCTION 5 ivfflat_bit_support(internal);
+
+CREATE OPERATOR CLASS bit_hamming_ops
+	FOR TYPE bit USING hnsw AS
+	OPERATOR 1 <~> (bit, bit) FOR ORDER BY float_ops,
+	FUNCTION 1 hamming_distance(bit, bit),
+	FUNCTION 3 hnsw_bit_support(internal);
+
+CREATE OPERATOR CLASS bit_jaccard_ops
+	FOR TYPE bit USING hnsw AS
+	OPERATOR 1 <%> (bit, bit) FOR ORDER BY float_ops,
+	FUNCTION 1 jaccard_distance(bit, bit),
+	FUNCTION 3 hnsw_bit_support(internal);
+
+--- sparsevec type
+
+CREATE TYPE sparsevec;
+
+CREATE FUNCTION sparsevec_in(cstring, oid, integer) RETURNS sparsevec
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION sparsevec_out(sparsevec) RETURNS cstring
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION sparsevec_typmod_in(cstring[]) RETURNS integer
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION sparsevec_recv(internal, oid, integer) RETURNS sparsevec
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION sparsevec_send(sparsevec) RETURNS bytea
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE TYPE sparsevec (
+	INPUT     = sparsevec_in,
+	OUTPUT    = sparsevec_out,
+	TYPMOD_IN = sparsevec_typmod_in,
+	RECEIVE   = sparsevec_recv,
+	SEND      = sparsevec_send,
+	STORAGE   = external
+);
+
+-- sparsevec functions
+
+CREATE FUNCTION l2_distance(sparsevec, sparsevec) RETURNS float8
+	AS 'MODULE_PATHNAME', 'sparsevec_l2_distance' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION inner_product(sparsevec, sparsevec) RETURNS float8
+	AS 'MODULE_PATHNAME', 'sparsevec_inner_product' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION cosine_distance(sparsevec, sparsevec) RETURNS float8
+	AS 'MODULE_PATHNAME', 'sparsevec_cosine_distance' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION l1_distance(sparsevec, sparsevec) RETURNS float8
+	AS 'MODULE_PATHNAME', 'sparsevec_l1_distance' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION l2_norm(sparsevec) RETURNS float8
+	AS 'MODULE_PATHNAME', 'sparsevec_l2_norm' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION l2_normalize(sparsevec) RETURNS sparsevec
+	AS 'MODULE_PATHNAME', 'sparsevec_l2_normalize' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+-- sparsevec private functions
+
+CREATE FUNCTION sparsevec_lt(sparsevec, sparsevec) RETURNS bool
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION sparsevec_le(sparsevec, sparsevec) RETURNS bool
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION sparsevec_eq(sparsevec, sparsevec) RETURNS bool
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION sparsevec_ne(sparsevec, sparsevec) RETURNS bool
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION sparsevec_ge(sparsevec, sparsevec) RETURNS bool
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION sparsevec_gt(sparsevec, sparsevec) RETURNS bool
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION sparsevec_cmp(sparsevec, sparsevec) RETURNS int4
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION sparsevec_l2_squared_distance(sparsevec, sparsevec) RETURNS float8
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION sparsevec_negative_inner_product(sparsevec, sparsevec) RETURNS float8
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+-- sparsevec cast functions
+
+CREATE FUNCTION sparsevec(sparsevec, integer, boolean) RETURNS sparsevec
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION vector_to_sparsevec(vector, integer, boolean) RETURNS sparsevec
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION sparsevec_to_vector(sparsevec, integer, boolean) RETURNS vector
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION halfvec_to_sparsevec(halfvec, integer, boolean) RETURNS sparsevec
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION sparsevec_to_halfvec(sparsevec, integer, boolean) RETURNS halfvec
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+-- sparsevec casts
+
+CREATE CAST (sparsevec AS sparsevec)
+	WITH FUNCTION sparsevec(sparsevec, integer, boolean) AS IMPLICIT;
+
+CREATE CAST (sparsevec AS vector)
+	WITH FUNCTION sparsevec_to_vector(sparsevec, integer, boolean) AS ASSIGNMENT;
+
+CREATE CAST (vector AS sparsevec)
+	WITH FUNCTION vector_to_sparsevec(vector, integer, boolean) AS IMPLICIT;
+
+CREATE CAST (sparsevec AS halfvec)
+	WITH FUNCTION sparsevec_to_halfvec(sparsevec, integer, boolean) AS ASSIGNMENT;
+
+CREATE CAST (halfvec AS sparsevec)
+	WITH FUNCTION halfvec_to_sparsevec(halfvec, integer, boolean) AS IMPLICIT;
+
+-- sparsevec operators
+
+CREATE OPERATOR <-> (
+	LEFTARG = sparsevec, RIGHTARG = sparsevec, PROCEDURE = l2_distance,
+	COMMUTATOR = '<->'
+);
+
+CREATE OPERATOR <#> (
+	LEFTARG = sparsevec, RIGHTARG = sparsevec, PROCEDURE = sparsevec_negative_inner_product,
+	COMMUTATOR = '<#>'
+);
+
+CREATE OPERATOR <=> (
+	LEFTARG = sparsevec, RIGHTARG = sparsevec, PROCEDURE = cosine_distance,
+	COMMUTATOR = '<=>'
+);
+
+CREATE OPERATOR <+> (
+	LEFTARG = sparsevec, RIGHTARG = sparsevec, PROCEDURE = l1_distance,
+	COMMUTATOR = '<+>'
+);
+
+CREATE OPERATOR < (
+	LEFTARG = sparsevec, RIGHTARG = sparsevec, PROCEDURE = sparsevec_lt,
+	COMMUTATOR = > , NEGATOR = >= ,
+	RESTRICT = scalarltsel, JOIN = scalarltjoinsel
+);
+
+CREATE OPERATOR <= (
+	LEFTARG = sparsevec, RIGHTARG = sparsevec, PROCEDURE = sparsevec_le,
+	COMMUTATOR = >= , NEGATOR = > ,
+	RESTRICT = scalarlesel, JOIN = scalarlejoinsel
+);
+
+CREATE OPERATOR = (
+	LEFTARG = sparsevec, RIGHTARG = sparsevec, PROCEDURE = sparsevec_eq,
+	COMMUTATOR = = , NEGATOR = <> ,
+	RESTRICT = eqsel, JOIN = eqjoinsel
+);
+
+CREATE OPERATOR <> (
+	LEFTARG = sparsevec, RIGHTARG = sparsevec, PROCEDURE = sparsevec_ne,
+	COMMUTATOR = <> , NEGATOR = = ,
+	RESTRICT = eqsel, JOIN = eqjoinsel
+);
+
+CREATE OPERATOR >= (
+	LEFTARG = sparsevec, RIGHTARG = sparsevec, PROCEDURE = sparsevec_ge,
+	COMMUTATOR = <= , NEGATOR = < ,
+	RESTRICT = scalargesel, JOIN = scalargejoinsel
+);
+
+CREATE OPERATOR > (
+	LEFTARG = sparsevec, RIGHTARG = sparsevec, PROCEDURE = sparsevec_gt,
+	COMMUTATOR = < , NEGATOR = <= ,
+	RESTRICT = scalargtsel, JOIN = scalargtjoinsel
+);
+
+-- sparsevec opclasses
+
+CREATE OPERATOR CLASS sparsevec_ops
+	DEFAULT FOR TYPE sparsevec USING btree AS
+	OPERATOR 1 < ,
+	OPERATOR 2 <= ,
+	OPERATOR 3 = ,
+	OPERATOR 4 >= ,
+	OPERATOR 5 > ,
+	FUNCTION 1 sparsevec_cmp(sparsevec, sparsevec);
+
+CREATE OPERATOR CLASS sparsevec_l2_ops
+	FOR TYPE sparsevec USING hnsw AS
+	OPERATOR 1 <-> (sparsevec, sparsevec) FOR ORDER BY float_ops,
+	FUNCTION 1 sparsevec_l2_squared_distance(sparsevec, sparsevec),
+	FUNCTION 3 hnsw_sparsevec_support(internal);
+
+CREATE OPERATOR CLASS sparsevec_ip_ops
+	FOR TYPE sparsevec USING hnsw AS
+	OPERATOR 1 <#> (sparsevec, sparsevec) FOR ORDER BY float_ops,
+	FUNCTION 1 sparsevec_negative_inner_product(sparsevec, sparsevec),
+	FUNCTION 3 hnsw_sparsevec_support(internal);
+
+CREATE OPERATOR CLASS sparsevec_cosine_ops
+	FOR TYPE sparsevec USING hnsw AS
+	OPERATOR 1 <=> (sparsevec, sparsevec) FOR ORDER BY float_ops,
+	FUNCTION 1 sparsevec_negative_inner_product(sparsevec, sparsevec),
+	FUNCTION 2 l2_norm(sparsevec),
+	FUNCTION 3 hnsw_sparsevec_support(internal);
+
+CREATE OPERATOR CLASS sparsevec_l1_ops
+	FOR TYPE sparsevec USING hnsw AS
+	OPERATOR 1 <+> (sparsevec, sparsevec) FOR ORDER BY float_ops,
+	FUNCTION 1 l1_distance(sparsevec, sparsevec),
+	FUNCTION 3 hnsw_sparsevec_support(internal);

src/bitutils.c

@@ -0,0 +1,222 @@
+#include "postgres.h"
+
+#include "bitutils.h"
+#include "halfvec.h"			/* for USE_DISPATCH and USE_TARGET_CLONES */
+#include "port/pg_bitutils.h"
+
+#if defined(USE_DISPATCH)
+#define BIT_DISPATCH
+#endif
+
+#ifdef BIT_DISPATCH
+#include <immintrin.h>
+
+#if defined(USE__GET_CPUID)
+#include <cpuid.h>
+#else
+#include <intrin.h>
+#endif
+
+#ifdef _MSC_VER
+#define TARGET_AVX512_POPCOUNT
+#else
+#define TARGET_AVX512_POPCOUNT __attribute__((target("avx512f,avx512vpopcntdq")))
+#endif
+#endif
+
+/* Disable for LLVM due to crash with bitcode generation */
+#if defined(USE_TARGET_CLONES) && !defined(__POPCNT__) && !defined(__llvm__)
+#define BIT_TARGET_CLONES __attribute__((target_clones("default", "popcnt")))
+#else
+#define BIT_TARGET_CLONES
+#endif
+
+/* Use built-ins when possible for inlining */
+#if defined(HAVE__BUILTIN_POPCOUNT) && defined(HAVE_LONG_INT_64)
+#define popcount64(x) __builtin_popcountl(x)
+#elif defined(HAVE__BUILTIN_POPCOUNT) && defined(HAVE_LONG_LONG_INT_64)
+#define popcount64(x) __builtin_popcountll(x)
+#elif !defined(_MSC_VER)
+/* Fails to resolve with MSVC */
+#define popcount64(x) pg_popcount64(x)
+#endif
+
+uint64		(*BitHammingDistance) (uint32 bytes, unsigned char *ax, unsigned char *bx, uint64 distance);
+double		(*BitJaccardDistance) (uint32 bytes, unsigned char *ax, unsigned char *bx, uint64 ab, uint64 aa, uint64 bb);
+
+BIT_TARGET_CLONES static uint64
+BitHammingDistanceDefault(uint32 bytes, unsigned char *ax, unsigned char *bx, uint64 distance)
+{
+#ifdef popcount64
+	for (; bytes >= sizeof(uint64); bytes -= sizeof(uint64))
+	{
+		uint64		axs;
+		uint64		bxs;
+
+		/* Ensure aligned */
+		memcpy(&axs, ax, sizeof(uint64));
+		memcpy(&bxs, bx, sizeof(uint64));
+
+		distance += popcount64(axs ^ bxs);
+
+		ax += sizeof(uint64);
+		bx += sizeof(uint64);
+	}
+#endif
+
+	for (uint32 i = 0; i < bytes; i++)
+		distance += pg_number_of_ones[ax[i] ^ bx[i]];
+
+	return distance;
+}
+
+#ifdef BIT_DISPATCH
+TARGET_AVX512_POPCOUNT static uint64
+BitHammingDistanceAvx512Popcount(uint32 bytes, unsigned char *ax, unsigned char *bx, uint64 distance)
+{
+	__m512i		dist = _mm512_setzero_si512();
+
+	for (; bytes >= sizeof(__m512i); bytes -= sizeof(__m512i))
+	{
+		__m512i		axs = _mm512_loadu_si512((const __m512i *) ax);
+		__m512i		bxs = _mm512_loadu_si512((const __m512i *) bx);
+
+		dist = _mm512_add_epi64(dist, _mm512_popcnt_epi64(_mm512_xor_si512(axs, bxs)));
+
+		ax += sizeof(__m512i);
+		bx += sizeof(__m512i);
+	}
+
+	distance += _mm512_reduce_add_epi64(dist);
+
+	return BitHammingDistanceDefault(bytes, ax, bx, distance);
+}
+#endif
+
+BIT_TARGET_CLONES static double
+BitJaccardDistanceDefault(uint32 bytes, unsigned char *ax, unsigned char *bx, uint64 ab, uint64 aa, uint64 bb)
+{
+#ifdef popcount64
+	for (; bytes >= sizeof(uint64); bytes -= sizeof(uint64))
+	{
+		uint64		axs;
+		uint64		bxs;
+
+		/* Ensure aligned */
+		memcpy(&axs, ax, sizeof(uint64));
+		memcpy(&bxs, bx, sizeof(uint64));
+
+		ab += popcount64(axs & bxs);
+		aa += popcount64(axs);
+		bb += popcount64(bxs);
+
+		ax += sizeof(uint64);
+		bx += sizeof(uint64);
+	}
+#endif
+
+	for (uint32 i = 0; i < bytes; i++)
+	{
+		ab += pg_number_of_ones[ax[i] & bx[i]];
+		aa += pg_number_of_ones[ax[i]];
+		bb += pg_number_of_ones[bx[i]];
+	}
+
+	if (ab == 0)
+		return 1;
+	else
+		return 1 - (ab / ((double) (aa + bb - ab)));
+}
+
+#ifdef BIT_DISPATCH
+TARGET_AVX512_POPCOUNT static double
+BitJaccardDistanceAvx512Popcount(uint32 bytes, unsigned char *ax, unsigned char *bx, uint64 ab, uint64 aa, uint64 bb)
+{
+	__m512i		abx = _mm512_setzero_si512();
+	__m512i		aax = _mm512_setzero_si512();
+	__m512i		bbx = _mm512_setzero_si512();
+
+	for (; bytes >= sizeof(__m512i); bytes -= sizeof(__m512i))
+	{
+		__m512i		axs = _mm512_loadu_si512((const __m512i *) ax);
+		__m512i		bxs = _mm512_loadu_si512((const __m512i *) bx);
+
+		abx = _mm512_add_epi64(abx, _mm512_popcnt_epi64(_mm512_and_si512(axs, bxs)));
+		aax = _mm512_add_epi64(aax, _mm512_popcnt_epi64(axs));
+		bbx = _mm512_add_epi64(bbx, _mm512_popcnt_epi64(bxs));
+
+		ax += sizeof(__m512i);
+		bx += sizeof(__m512i);
+	}
+
+	ab += _mm512_reduce_add_epi64(abx);
+	aa += _mm512_reduce_add_epi64(aax);
+	bb += _mm512_reduce_add_epi64(bbx);
+
+	return BitJaccardDistanceDefault(bytes, ax, bx, ab, aa, bb);
+}
+#endif
+
+#ifdef BIT_DISPATCH
+#define CPU_FEATURE_OSXSAVE         (1 << 27)	/* F1 ECX */
+#define CPU_FEATURE_AVX512F         (1 << 16)	/* F7,0 EBX */
+#define CPU_FEATURE_AVX512VPOPCNTDQ (1 << 14)	/* F7,0 ECX */
+
+#ifdef _MSC_VER
+#define TARGET_XSAVE
+#else
+#define TARGET_XSAVE __attribute__((target("xsave")))
+#endif
+
+TARGET_XSAVE static bool
+SupportsAvx512Popcount()
+{
+	unsigned int exx[4] = {0, 0, 0, 0};
+
+#if defined(USE__GET_CPUID)
+	__get_cpuid(1, &exx[0], &exx[1], &exx[2], &exx[3]);
+#else
+	__cpuid(exx, 1);
+#endif
+
+	/* Check OS supports XSAVE */
+	if ((exx[2] & CPU_FEATURE_OSXSAVE) != CPU_FEATURE_OSXSAVE)
+		return false;
+
+	/* Check XMM, YMM, and ZMM registers are enabled */
+	if ((_xgetbv(0) & 0xe6) != 0xe6)
+		return false;
+
+#if defined(USE__GET_CPUID)
+	__get_cpuid_count(7, 0, &exx[0], &exx[1], &exx[2], &exx[3]);
+#else
+	__cpuidex(exx, 7, 0);
+#endif
+
+	/* Check AVX512F */
+	if ((exx[1] & CPU_FEATURE_AVX512F) != CPU_FEATURE_AVX512F)
+		return false;
+
+	/* Check AVX512VPOPCNTDQ */
+	return (exx[2] & CPU_FEATURE_AVX512VPOPCNTDQ) == CPU_FEATURE_AVX512VPOPCNTDQ;
+}
+#endif
+
+void
+BitvecInit(void)
+{
+	/*
+	 * Could skip pointer when single function, but no difference in
+	 * performance
+	 */
+	BitHammingDistance = BitHammingDistanceDefault;
+	BitJaccardDistance = BitJaccardDistanceDefault;
+
+#ifdef BIT_DISPATCH
+	if (SupportsAvx512Popcount())
+	{
+		BitHammingDistance = BitHammingDistanceAvx512Popcount;
+		BitJaccardDistance = BitJaccardDistanceAvx512Popcount;
+	}
+#endif
+}

src/bitutils.h

@@ -0,0 +1,16 @@
+#ifndef BITUTILS_H
+#define BITUTILS_H
+
+#include "postgres.h"
+
+/* Check version in first header */
+#if PG_VERSION_NUM < 120000
+#error "Requires PostgreSQL 12+"
+#endif
+
+extern uint64 (*BitHammingDistance) (uint32 bytes, unsigned char *ax, unsigned char *bx, uint64 distance);
+extern double (*BitJaccardDistance) (uint32 bytes, unsigned char *ax, unsigned char *bx, uint64 ab, uint64 aa, uint64 bb);
+
+void		BitvecInit(void);
+
+#endif

src/bitvec.c

@@ -0,0 +1,69 @@
+#include "postgres.h"
+
+#include "bitutils.h"
+#include "bitvec.h"
+#include "utils/varbit.h"
+#include "vector.h"
+
+#if PG_VERSION_NUM >= 160000
+#include "varatt.h"
+#endif
+
+/*
+ * Allocate and initialize a new bit vector
+ */
+VarBit *
+InitBitVector(int dim)
+{
+	VarBit	   *result;
+	int			size;
+
+	size = VARBITTOTALLEN(dim);
+	result = (VarBit *) palloc0(size);
+	SET_VARSIZE(result, size);
+	VARBITLEN(result) = dim;
+
+	return result;
+}
+
+/*
+ * Ensure same dimensions
+ */
+static inline void
+CheckDims(VarBit *a, VarBit *b)
+{
+	if (VARBITLEN(a) != VARBITLEN(b))
+		ereport(ERROR,
+				(errcode(ERRCODE_DATA_EXCEPTION),
+				 errmsg("different bit lengths %u and %u", VARBITLEN(a), VARBITLEN(b))));
+}
+
+/*
+ * Get the Hamming distance between two bit vectors
+ */
+FUNCTION_PREFIX PG_FUNCTION_INFO_V1(hamming_distance);
+Datum
+hamming_distance(PG_FUNCTION_ARGS)
+{
+	VarBit	   *a = PG_GETARG_VARBIT_P(0);
+	VarBit	   *b = PG_GETARG_VARBIT_P(1);
+
+	CheckDims(a, b);
+
+	PG_RETURN_FLOAT8((double) BitHammingDistance(VARBITBYTES(a), VARBITS(a), VARBITS(b), 0));
+}
+
+/*
+ * Get the Jaccard distance between two bit vectors
+ */
+FUNCTION_PREFIX PG_FUNCTION_INFO_V1(jaccard_distance);
+Datum
+jaccard_distance(PG_FUNCTION_ARGS)
+{
+	VarBit	   *a = PG_GETARG_VARBIT_P(0);
+	VarBit	   *b = PG_GETARG_VARBIT_P(1);
+
+	CheckDims(a, b);
+
+	PG_RETURN_FLOAT8(BitJaccardDistance(VARBITBYTES(a), VARBITS(a), VARBITS(b), 0, 0, 0));
+}

src/bitvec.h

@@ -0,0 +1,8 @@
+#ifndef BITVEC_H
+#define BITVEC_H
+
+#include "utils/varbit.h"
+
+VarBit	   *InitBitVector(int dim);
+
+#endif

src/halfutils.c

@@ -0,0 +1,298 @@
+#include "postgres.h"
+
+#include "halfutils.h"
+#include "halfvec.h"
+
+#ifdef HALFVEC_DISPATCH
+#include <immintrin.h>
+
+#if defined(USE__GET_CPUID)
+#include <cpuid.h>
+#else
+#include <intrin.h>
+#endif
+
+#ifdef _MSC_VER
+#define TARGET_F16C
+#else
+#define TARGET_F16C __attribute__((target("avx,f16c,fma")))
+#endif
+#endif
+
+float		(*HalfvecL2SquaredDistance) (int dim, half * ax, half * bx);
+float		(*HalfvecInnerProduct) (int dim, half * ax, half * bx);
+double		(*HalfvecCosineSimilarity) (int dim, half * ax, half * bx);
+float		(*HalfvecL1Distance) (int dim, half * ax, half * bx);
+
+static float
+HalfvecL2SquaredDistanceDefault(int dim, half * ax, half * bx)
+{
+	float		distance = 0.0;
+
+	/* Auto-vectorized */
+	for (int i = 0; i < dim; i++)
+	{
+		float		diff = HalfToFloat4(ax[i]) - HalfToFloat4(bx[i]);
+
+		distance += diff * diff;
+	}
+
+	return distance;
+}
+
+#ifdef HALFVEC_DISPATCH
+TARGET_F16C static float
+HalfvecL2SquaredDistanceF16c(int dim, half * ax, half * bx)
+{
+	float		distance;
+	int			i;
+	float		s[8];
+	int			count = (dim / 8) * 8;
+	__m256		dist = _mm256_setzero_ps();
+
+	for (i = 0; i < count; i += 8)
+	{
+		__m128i		axi = _mm_loadu_si128((__m128i *) (ax + i));
+		__m128i		bxi = _mm_loadu_si128((__m128i *) (bx + i));
+		__m256		axs = _mm256_cvtph_ps(axi);
+		__m256		bxs = _mm256_cvtph_ps(bxi);
+		__m256		diff = _mm256_sub_ps(axs, bxs);
+
+		dist = _mm256_fmadd_ps(diff, diff, dist);
+	}
+
+	_mm256_storeu_ps(s, dist);
+
+	distance = s[0] + s[1] + s[2] + s[3] + s[4] + s[5] + s[6] + s[7];
+
+	for (; i < dim; i++)
+	{
+		float		diff = HalfToFloat4(ax[i]) - HalfToFloat4(bx[i]);
+
+		distance += diff * diff;
+	}
+
+	return distance;
+}
+#endif
+
+static float
+HalfvecInnerProductDefault(int dim, half * ax, half * bx)
+{
+	float		distance = 0.0;
+
+	/* Auto-vectorized */
+	for (int i = 0; i < dim; i++)
+		distance += HalfToFloat4(ax[i]) * HalfToFloat4(bx[i]);
+
+	return distance;
+}
+
+#ifdef HALFVEC_DISPATCH
+TARGET_F16C static float
+HalfvecInnerProductF16c(int dim, half * ax, half * bx)
+{
+	float		distance;
+	int			i;
+	float		s[8];
+	int			count = (dim / 8) * 8;
+	__m256		dist = _mm256_setzero_ps();
+
+	for (i = 0; i < count; i += 8)
+	{
+		__m128i		axi = _mm_loadu_si128((__m128i *) (ax + i));
+		__m128i		bxi = _mm_loadu_si128((__m128i *) (bx + i));
+		__m256		axs = _mm256_cvtph_ps(axi);
+		__m256		bxs = _mm256_cvtph_ps(bxi);
+
+		dist = _mm256_fmadd_ps(axs, bxs, dist);
+	}
+
+	_mm256_storeu_ps(s, dist);
+
+	distance = s[0] + s[1] + s[2] + s[3] + s[4] + s[5] + s[6] + s[7];
+
+	for (; i < dim; i++)
+		distance += HalfToFloat4(ax[i]) * HalfToFloat4(bx[i]);
+
+	return distance;
+}
+#endif
+
+static double
+HalfvecCosineSimilarityDefault(int dim, half * ax, half * bx)
+{
+	float		similarity = 0.0;
+	float		norma = 0.0;
+	float		normb = 0.0;
+
+	/* Auto-vectorized */
+	for (int i = 0; i < dim; i++)
+	{
+		float		axi = HalfToFloat4(ax[i]);
+		float		bxi = HalfToFloat4(bx[i]);
+
+		similarity += axi * bxi;
+		norma += axi * axi;
+		normb += bxi * bxi;
+	}
+
+	/* Use sqrt(a * b) over sqrt(a) * sqrt(b) */
+	return (double) similarity / sqrt((double) norma * (double) normb);
+}
+
+#ifdef HALFVEC_DISPATCH
+TARGET_F16C static double
+HalfvecCosineSimilarityF16c(int dim, half * ax, half * bx)
+{
+	float		similarity;
+	float		norma;
+	float		normb;
+	int			i;
+	float		s[8];
+	int			count = (dim / 8) * 8;
+	__m256		sim = _mm256_setzero_ps();
+	__m256		na = _mm256_setzero_ps();
+	__m256		nb = _mm256_setzero_ps();
+
+	for (i = 0; i < count; i += 8)
+	{
+		__m128i		axi = _mm_loadu_si128((__m128i *) (ax + i));
+		__m128i		bxi = _mm_loadu_si128((__m128i *) (bx + i));
+		__m256		axs = _mm256_cvtph_ps(axi);
+		__m256		bxs = _mm256_cvtph_ps(bxi);
+
+		sim = _mm256_fmadd_ps(axs, bxs, sim);
+		na = _mm256_fmadd_ps(axs, axs, na);
+		nb = _mm256_fmadd_ps(bxs, bxs, nb);
+	}
+
+	_mm256_storeu_ps(s, sim);
+	similarity = s[0] + s[1] + s[2] + s[3] + s[4] + s[5] + s[6] + s[7];
+
+	_mm256_storeu_ps(s, na);
+	norma = s[0] + s[1] + s[2] + s[3] + s[4] + s[5] + s[6] + s[7];
+
+	_mm256_storeu_ps(s, nb);
+	normb = s[0] + s[1] + s[2] + s[3] + s[4] + s[5] + s[6] + s[7];
+
+	/* Auto-vectorized */
+	for (; i < dim; i++)
+	{
+		float		axi = HalfToFloat4(ax[i]);
+		float		bxi = HalfToFloat4(bx[i]);
+
+		similarity += axi * bxi;
+		norma += axi * axi;
+		normb += bxi * bxi;
+	}
+
+	/* Use sqrt(a * b) over sqrt(a) * sqrt(b) */
+	return (double) similarity / sqrt((double) norma * (double) normb);
+}
+#endif
+
+static float
+HalfvecL1DistanceDefault(int dim, half * ax, half * bx)
+{
+	float		distance = 0.0;
+
+	/* Auto-vectorized */
+	for (int i = 0; i < dim; i++)
+		distance += fabsf(HalfToFloat4(ax[i]) - HalfToFloat4(bx[i]));
+
+	return distance;
+}
+
+#ifdef HALFVEC_DISPATCH
+/* Does not require FMA, but keep logic simple */
+TARGET_F16C static float
+HalfvecL1DistanceF16c(int dim, half * ax, half * bx)
+{
+	float		distance;
+	int			i;
+	float		s[8];
+	int			count = (dim / 8) * 8;
+	__m256		dist = _mm256_setzero_ps();
+	__m256		sign = _mm256_set1_ps(-0.0);
+
+	for (i = 0; i < count; i += 8)
+	{
+		__m128i		axi = _mm_loadu_si128((__m128i *) (ax + i));
+		__m128i		bxi = _mm_loadu_si128((__m128i *) (bx + i));
+		__m256		axs = _mm256_cvtph_ps(axi);
+		__m256		bxs = _mm256_cvtph_ps(bxi);
+
+		dist = _mm256_add_ps(dist, _mm256_andnot_ps(sign, _mm256_sub_ps(axs, bxs)));
+	}
+
+	_mm256_storeu_ps(s, dist);
+
+	distance = s[0] + s[1] + s[2] + s[3] + s[4] + s[5] + s[6] + s[7];
+
+	for (; i < dim; i++)
+		distance += fabsf(HalfToFloat4(ax[i]) - HalfToFloat4(bx[i]));
+
+	return distance;
+}
+#endif
+
+#ifdef HALFVEC_DISPATCH
+#define CPU_FEATURE_FMA     (1 << 12)
+#define CPU_FEATURE_OSXSAVE (1 << 27)
+#define CPU_FEATURE_AVX     (1 << 28)
+#define CPU_FEATURE_F16C    (1 << 29)
+
+#ifdef _MSC_VER
+#define TARGET_XSAVE
+#else
+#define TARGET_XSAVE __attribute__((target("xsave")))
+#endif
+
+TARGET_XSAVE static bool
+SupportsCpuFeature(unsigned int feature)
+{
+	unsigned int exx[4] = {0, 0, 0, 0};
+
+#if defined(USE__GET_CPUID)
+	__get_cpuid(1, &exx[0], &exx[1], &exx[2], &exx[3]);
+#else
+	__cpuid(exx, 1);
+#endif
+
+	/* Check OS supports XSAVE */
+	if ((exx[2] & CPU_FEATURE_OSXSAVE) != CPU_FEATURE_OSXSAVE)
+		return false;
+
+	/* Check XMM and YMM registers are enabled */
+	if ((_xgetbv(0) & 6) != 6)
+		return false;
+
+	/* Now check features */
+	return (exx[2] & feature) == feature;
+}
+#endif
+
+void
+HalfvecInit(void)
+{
+	/*
+	 * Could skip pointer when single function, but no difference in
+	 * performance
+	 */
+	HalfvecL2SquaredDistance = HalfvecL2SquaredDistanceDefault;
+	HalfvecInnerProduct = HalfvecInnerProductDefault;
+	HalfvecCosineSimilarity = HalfvecCosineSimilarityDefault;
+	HalfvecL1Distance = HalfvecL1DistanceDefault;
+
+#ifdef HALFVEC_DISPATCH
+	if (SupportsCpuFeature(CPU_FEATURE_AVX | CPU_FEATURE_F16C | CPU_FEATURE_FMA))
+	{
+		HalfvecL2SquaredDistance = HalfvecL2SquaredDistanceF16c;
+		HalfvecInnerProduct = HalfvecInnerProductF16c;
+		HalfvecCosineSimilarity = HalfvecCosineSimilarityF16c;
+		/* Does not require FMA, but keep logic simple */
+		HalfvecL1Distance = HalfvecL1DistanceF16c;
+	}
+#endif
+}

src/halfutils.h

@@ -0,0 +1,263 @@
+#ifndef HALFUTILS_H
+#define HALFUTILS_H
+
+#include <math.h>
+
+#include "common/shortest_dec.h"
+#include "halfvec.h"
+
+#ifdef F16C_SUPPORT
+#include <immintrin.h>
+#endif
+
+extern float (*HalfvecL2SquaredDistance) (int dim, half * ax, half * bx);
+extern float (*HalfvecInnerProduct) (int dim, half * ax, half * bx);
+extern double (*HalfvecCosineSimilarity) (int dim, half * ax, half * bx);
+extern float (*HalfvecL1Distance) (int dim, half * ax, half * bx);
+
+void		HalfvecInit(void);
+
+/*
+ * Check if half is NaN
+ */
+static inline bool
+HalfIsNan(half num)
+{
+#ifdef FLT16_SUPPORT
+	return isnan(num);
+#else
+	return (num & 0x7C00) == 0x7C00 && (num & 0x7FFF) != 0x7C00;
+#endif
+}
+
+/*
+ * Check if half is infinite
+ */
+static inline bool
+HalfIsInf(half num)
+{
+#ifdef FLT16_SUPPORT
+	return isinf(num);
+#else
+	return (num & 0x7FFF) == 0x7C00;
+#endif
+}
+
+/*
+ * Check if half is zero
+ */
+static inline bool
+HalfIsZero(half num)
+{
+#ifdef FLT16_SUPPORT
+	return num == 0;
+#else
+	return (num & 0x7FFF) == 0x0000;
+#endif
+}
+
+/*
+ * Convert a half to a float4
+ */
+static inline float
+HalfToFloat4(half num)
+{
+#if defined(F16C_SUPPORT)
+	return _cvtsh_ss(num);
+#elif defined(FLT16_SUPPORT)
+	return (float) num;
+#else
+	union
+	{
+		float		f;
+		uint32		i;
+	}			swapfloat;
+
+	union
+	{
+		half		h;
+		uint16		i;
+	}			swaphalf;
+
+	uint16		bin;
+	uint32		exponent;
+	uint32		mantissa;
+	uint32		result;
+
+	swaphalf.h = num;
+	bin = swaphalf.i;
+	exponent = (bin & 0x7C00) >> 10;
+	mantissa = bin & 0x03FF;
+
+	/* Sign */
+	result = (bin & 0x8000) << 16;
+
+	if (unlikely(exponent == 31))
+	{
+		if (mantissa == 0)
+		{
+			/* Infinite */
+			result |= 0x7F800000;
+		}
+		else
+		{
+			/* NaN */
+			result |= 0x7FC00000;
+		}
+	}
+	else if (unlikely(exponent == 0))
+	{
+		/* Subnormal */
+		if (mantissa != 0)
+		{
+			exponent = -14;
+
+			for (int i = 0; i < 10; i++)
+			{
+				mantissa <<= 1;
+				exponent -= 1;
+
+				if ((mantissa >> 10) % 2 == 1)
+				{
+					mantissa &= 0x03ff;
+					break;
+				}
+			}
+
+			result |= (exponent + 127) << 23;
+		}
+	}
+	else
+	{
+		/* Normal */
+		result |= (exponent - 15 + 127) << 23;
+	}
+
+	result |= mantissa << 13;
+
+	swapfloat.i = result;
+	return swapfloat.f;
+#endif
+}
+
+/*
+ * Convert a float4 to a half
+ */
+static inline half
+Float4ToHalfUnchecked(float num)
+{
+#if defined(F16C_SUPPORT)
+	return _cvtss_sh(num, 0);
+#elif defined(FLT16_SUPPORT)
+	return (_Float16) num;
+#else
+	union
+	{
+		float		f;
+		uint32		i;
+	}			swapfloat;
+
+	union
+	{
+		half		h;
+		uint16		i;
+	}			swaphalf;
+
+	uint32		bin;
+	int			exponent;
+	int			mantissa;
+	uint16		result;
+
+	swapfloat.f = num;
+	bin = swapfloat.i;
+	exponent = (bin & 0x7F800000) >> 23;
+	mantissa = bin & 0x007FFFFF;
+
+	/* Sign */
+	result = (bin & 0x80000000) >> 16;
+
+	if (isinf(num))
+	{
+		/* Infinite */
+		result |= 0x7C00;
+	}
+	else if (isnan(num))
+	{
+		/* NaN */
+		result |= 0x7E00;
+		result |= mantissa >> 13;
+	}
+	else if (exponent > 98)
+	{
+		int			m;
+		int			gr;
+		int			s;
+
+		exponent -= 127;
+		s = mantissa & 0x00000FFF;
+
+		/* Subnormal */
+		if (exponent < -14)
+		{
+			int			diff = -exponent - 14;
+
+			mantissa >>= diff;
+			mantissa += 1 << (23 - diff);
+			s |= mantissa & 0x00000FFF;
+		}
+
+		m = mantissa >> 13;
+
+		/* Round */
+		gr = (mantissa >> 12) % 4;
+		if (gr == 3 || (gr == 1 && s != 0))
+			m += 1;
+
+		if (m == 1024)
+		{
+			m = 0;
+			exponent += 1;
+		}
+
+		if (exponent > 15)
+		{
+			/* Infinite */
+			result |= 0x7C00;
+		}
+		else
+		{
+			if (exponent >= -14)
+				result |= (exponent + 15) << 10;
+
+			result |= m;
+		}
+	}
+
+	swaphalf.i = result;
+	return swaphalf.h;
+#endif
+}
+
+/*
+ * Convert a float4 to a half
+ */
+static inline half
+Float4ToHalf(float num)
+{
+	half		result = Float4ToHalfUnchecked(num);
+
+	if (unlikely(HalfIsInf(result)) && !isinf(num))
+	{
+		char	   *buf = palloc(FLOAT_SHORTEST_DECIMAL_LEN);
+
+		float_to_shortest_decimal_buf(num, buf);
+
+		ereport(ERROR,
+				(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
+				 errmsg("\"%s\" is out of range for type halfvec", buf)));
+	}
+
+	return result;
+}
+
+#endif

src/halfvec.h

@@ -0,0 +1,70 @@
+#ifndef HALFVEC_H
+#define HALFVEC_H
+
+#define __STDC_WANT_IEC_60559_TYPES_EXT__
+
+#include <float.h>
+
+/* We use two types of dispatching: intrinsics and target_clones */
+/* TODO Move to better place */
+#ifndef DISABLE_DISPATCH
+/* Only enable for more recent compilers to keep build process simple */
+#if defined(__x86_64__) && defined(__GNUC__) && __GNUC__ >= 9
+#define USE_DISPATCH
+#elif defined(__x86_64__) && defined(__clang_major__) && __clang_major__ >= 7
+#define USE_DISPATCH
+#elif defined(_M_AMD64) && defined(_MSC_VER) && _MSC_VER >= 1920
+#define USE_DISPATCH
+#endif
+#endif
+
+/* target_clones requires glibc */
+#if defined(USE_DISPATCH) && defined(__gnu_linux__) && defined(__has_attribute)
+/* Use separate line for portability */
+#if __has_attribute(target_clones)
+#define USE_TARGET_CLONES
+#endif
+#endif
+
+/* Apple clang check needed for universal binaries on Mac */
+#if defined(USE_DISPATCH) && (defined(HAVE__GET_CPUID) || defined(__apple_build_version__))
+#define USE__GET_CPUID
+#endif
+
+#if defined(USE_DISPATCH)
+#define HALFVEC_DISPATCH
+#endif
+
+/* F16C has better performance than _Float16 (on x86-64) */
+#if defined(__F16C__)
+#define F16C_SUPPORT
+#elif defined(__FLT16_MAX__) && !defined(HALFVEC_DISPATCH) && !defined(__FreeBSD__)
+#define FLT16_SUPPORT
+#endif
+
+#ifdef FLT16_SUPPORT
+#define half _Float16
+#define HALF_MAX FLT16_MAX
+#else
+#define half uint16
+#define HALF_MAX 65504
+#endif
+
+#define HALFVEC_MAX_DIM 16000
+
+#define HALFVEC_SIZE(_dim)		(offsetof(HalfVector, x) + sizeof(half)*(_dim))
+#define DatumGetHalfVector(x)	((HalfVector *) PG_DETOAST_DATUM(x))
+#define PG_GETARG_HALFVEC_P(x)	DatumGetHalfVector(PG_GETARG_DATUM(x))
+#define PG_RETURN_HALFVEC_P(x)	PG_RETURN_POINTER(x)
+
+typedef struct HalfVector
+{
+	int32		vl_len_;		/* varlena header (do not touch directly!) */
+	int16		dim;			/* number of dimensions */
+	int16		unused;			/* reserved for future use, always zero */
+	half		x[FLEXIBLE_ARRAY_MEMBER];
+}			HalfVector;
+
+HalfVector *InitHalfVector(int dim);
+
+#endif

src/hnsw.c

@@ -4,25 +4,59 @@
 #include <math.h>
 
 #include "access/amapi.h"
+#include "access/reloptions.h"
+#include "commands/progress.h"
 #include "commands/vacuum.h"
 #include "hnsw.h"
+#include "miscadmin.h"
 #include "utils/guc.h"
 #include "utils/selfuncs.h"
 
-#if PG_VERSION_NUM >= 120000
-#include "commands/progress.h"
+#if PG_VERSION_NUM < 150000
+#define MarkGUCPrefixReserved(x) EmitWarningsOnPlaceholders(x)
 #endif
 
 int			hnsw_ef_search;
-bool		hnsw_enable_parallel_build;
+int			hnsw_lock_tranche_id;
 static relopt_kind hnsw_relopt_kind;
 
+/*
+ * Assign a tranche ID for our LWLocks. This only needs to be done by one
+ * backend, as the tranche ID is remembered in shared memory.
+ *
+ * This shared memory area is very small, so we just allocate it from the
+ * "slop" that PostgreSQL reserves for small allocations like this. If
+ * this grows bigger, we should use a shmem_request_hook and
+ * RequestAddinShmemSpace() to pre-reserve space for this.
+ */
+void
+HnswInitLockTranche(void)
+{
+	int		   *tranche_ids;
+	bool		found;
+
+	LWLockAcquire(AddinShmemInitLock, LW_EXCLUSIVE);
+	tranche_ids = ShmemInitStruct("hnsw LWLock ids",
+								  sizeof(int) * 1,
+								  &found);
+	if (!found)
+		tranche_ids[0] = LWLockNewTrancheId();
+	hnsw_lock_tranche_id = tranche_ids[0];
+	LWLockRelease(AddinShmemInitLock);
+
+	/* Per-backend registration of the tranche ID */
+	LWLockRegisterTranche(hnsw_lock_tranche_id, "HnswBuild");
+}
+
 /*
  * Initialize index options and variables
  */
 void
 HnswInit(void)
 {
+	if (!process_shared_preload_libraries_in_progress)
+		HnswInitLockTranche();
+
 	hnsw_relopt_kind = add_reloption_kind();
 	add_int_reloption(hnsw_relopt_kind, "m", "Max number of connections",
 					  HNSW_DEFAULT_M, HNSW_MIN_M, HNSW_MAX_M
@@ -41,16 +75,12 @@ HnswInit(void)
 							"Valid range is 1..1000.", &hnsw_ef_search,
 							HNSW_DEFAULT_EF_SEARCH, HNSW_MIN_EF_SEARCH, HNSW_MAX_EF_SEARCH, PGC_USERSET, 0, NULL, NULL, NULL);
 
-	/* Behind a variable for now since can be slower than building in memory */
-	DefineCustomBoolVariable("hnsw.enable_parallel_build", "Enables or disables building indexes in parallel",
-							 NULL, &hnsw_enable_parallel_build,
-							 false, PGC_USERSET, 0, NULL, NULL, NULL);
+	MarkGUCPrefixReserved("hnsw");
 }
 
 /*
  * Get the name of index build phase
  */
-#if PG_VERSION_NUM >= 120000
 static char *
 hnswbuildphasename(int64 phasenum)
 {
@@ -64,7 +94,6 @@ hnswbuildphasename(int64 phasenum)
 			return NULL;
 	}
 }
-#endif
 
 /*
  * Estimate the cost of an index scan
@@ -79,9 +108,6 @@ hnswcostestimate(PlannerInfo *root, IndexPath *path, double loop_count,
 	int			m;
 	int			entryLevel;
 	Relation	index;
-#if PG_VERSION_NUM < 120000
-	List	   *qinfos;
-#endif
 
 	/* Never use index without order */
 	if (path->indexorderbys == NULL)
@@ -107,12 +133,7 @@ hnswcostestimate(PlannerInfo *root, IndexPath *path, double loop_count,
 	/* Account for number of tuples (or entry level), m, and ef_search */
 	costs.numIndexTuples = (entryLevel + 2) * m;
 
-#if PG_VERSION_NUM >= 120000
 	genericcostestimate(root, path, loop_count, &costs);
-#else
-	qinfos = deconstruct_indexquals(path);
-	genericcostestimate(root, path, loop_count, qinfos, &costs);
-#endif
 
 	/* Use total cost since most work happens before first tuple is returned */
 	*indexStartupCost = costs.indexTotalCost;
@@ -166,14 +187,14 @@ hnswvalidate(Oid opclassoid)
  *
  * See https://www.postgresql.org/docs/current/index-api.html
  */
-PGDLLEXPORT PG_FUNCTION_INFO_V1(hnswhandler);
+FUNCTION_PREFIX PG_FUNCTION_INFO_V1(hnswhandler);
 Datum
 hnswhandler(PG_FUNCTION_ARGS)
 {
 	IndexAmRoutine *amroutine = makeNode(IndexAmRoutine);
 
 	amroutine->amstrategies = 0;
-	amroutine->amsupport = 2;
+	amroutine->amsupport = 3;
 #if PG_VERSION_NUM >= 130000
 	amroutine->amoptsprocnum = 0;
 #endif
@@ -206,9 +227,7 @@ hnswhandler(PG_FUNCTION_ARGS)
 	amroutine->amcostestimate = hnswcostestimate;
 	amroutine->amoptions = hnswoptions;
 	amroutine->amproperty = NULL;	/* TODO AMPROP_DISTANCE_ORDERABLE */
-#if PG_VERSION_NUM >= 120000
 	amroutine->ambuildphasename = hnswbuildphasename;
-#endif
 	amroutine->amvalidate = hnswvalidate;
 #if PG_VERSION_NUM >= 140000
 	amroutine->amadjustmembers = NULL;

src/hnsw.h

@@ -3,27 +3,22 @@
 
 #include "postgres.h"
 
-#include "access/generic_xlog.h"
+#include "access/genam.h"
 #include "access/parallel.h"
-#include "access/reloptions.h"
+#include "lib/pairingheap.h"
 #include "nodes/execnodes.h"
 #include "port.h"				/* for random() */
+#include "utils/relptr.h"
 #include "utils/sampling.h"
 #include "vector.h"
 
-#if PG_VERSION_NUM < 110000
-#error "Requires PostgreSQL 11+"
-#endif
-
-#if PG_VERSION_NUM < 120000
-#include "access/relscan.h"
-#endif
-
 #define HNSW_MAX_DIM 2000
+#define HNSW_MAX_NNZ 1000
 
 /* Support functions */
 #define HNSW_DISTANCE_PROC 1
 #define HNSW_NORM_PROC 2
+#define HNSW_TYPE_INFO_PROC 3
 
 #define HNSW_VERSION	1
 #define HNSW_MAGIC_NUMBER 0xA953A953
@@ -63,22 +58,27 @@
 #define PROGRESS_HNSW_PHASE_LOAD		2
 
 #define HNSW_MAX_SIZE (BLCKSZ - MAXALIGN(SizeOfPageHeaderData) - MAXALIGN(sizeof(HnswPageOpaqueData)) - sizeof(ItemIdData))
+#define HNSW_TUPLE_ALLOC_SIZE BLCKSZ
 
 #define HNSW_ELEMENT_TUPLE_SIZE(size)	MAXALIGN(offsetof(HnswElementTupleData, data) + (size))
 #define HNSW_NEIGHBOR_TUPLE_SIZE(level, m)	MAXALIGN(offsetof(HnswNeighborTupleData, indextids) + ((level) + 2) * (m) * sizeof(ItemPointerData))
 
+#define HNSW_NEIGHBOR_ARRAY_SIZE(lm)	(offsetof(HnswNeighborArray, items) + sizeof(HnswCandidate) * (lm))
+
 #define HnswPageGetOpaque(page)	((HnswPageOpaque) PageGetSpecialPointer(page))
 #define HnswPageGetMeta(page)	((HnswMetaPageData *) PageGetContents(page))
 
 #if PG_VERSION_NUM >= 150000
 #define RandomDouble() pg_prng_double(&pg_global_prng_state)
+#define SeedRandom(seed) pg_prng_seed(&pg_global_prng_state, seed)
 #else
 #define RandomDouble() (((double) random()) / MAX_RANDOM_VALUE)
+#define SeedRandom(seed) srandom(seed)
 #endif
 
 #if PG_VERSION_NUM < 130000
 #define list_delete_last(list) list_truncate(list, list_length(list) - 1)
-#define list_sort(list, cmp) list_qsort(list, cmp)
+#define list_sort(list, cmp) ((list) = list_qsort(list, cmp))
 #endif
 
 #define HnswIsElementTuple(tup) ((tup)->type == HNSW_ELEMENT_TUPLE_TYPE)
@@ -91,42 +91,74 @@
 #define HnswGetMl(m) (1 / log(m))
 
 /* Ensure fits on page and in uint8 */
-#define HnswGetMaxLevel(m) Min(((BLCKSZ - MAXALIGN(SizeOfPageHeaderData) - MAXALIGN(sizeof(HnswPageOpaqueData)) - offsetof(HnswNeighborTupleData, indextids) - sizeof(ItemIdData)) / (sizeof(ItemPointerData)) / m) - 2, 255)
+#define HnswGetMaxLevel(m) Min(((BLCKSZ - MAXALIGN(SizeOfPageHeaderData) - MAXALIGN(sizeof(HnswPageOpaqueData)) - offsetof(HnswNeighborTupleData, indextids) - sizeof(ItemIdData)) / (sizeof(ItemPointerData)) / (m)) - 2, 255)
+
+#define HnswGetValue(base, element) PointerGetDatum(HnswPtrAccess(base, (element)->value))
+
+#if PG_VERSION_NUM < 140005
+#define relptr_offset(rp) ((rp).relptr_off - 1)
+#endif
+
+/* Pointer macros */
+#define HnswPtrAccess(base, hp) ((base) == NULL ? (hp).ptr : relptr_access(base, (hp).relptr))
+#define HnswPtrStore(base, hp, value) ((base) == NULL ? (void) ((hp).ptr = (value)) : (void) relptr_store(base, (hp).relptr, value))
+#define HnswPtrIsNull(base, hp) ((base) == NULL ? (hp).ptr == NULL : relptr_is_null((hp).relptr))
+#define HnswPtrEqual(base, hp1, hp2) ((base) == NULL ? (hp1).ptr == (hp2).ptr : relptr_offset((hp1).relptr) == relptr_offset((hp2).relptr))
+
+/* For code paths dedicated to each type */
+#define HnswPtrPointer(hp) (hp).ptr
+#define HnswPtrOffset(hp) relptr_offset((hp).relptr)
 
 /* Variables */
 extern int	hnsw_ef_search;
-extern bool hnsw_enable_parallel_build;
+extern int	hnsw_lock_tranche_id;
 
+typedef struct HnswElementData HnswElementData;
 typedef struct HnswNeighborArray HnswNeighborArray;
 
-typedef struct HnswElementData
+#define HnswPtrDeclare(type, relptrtype, ptrtype) \
+	relptr_declare(type, relptrtype); \
+	typedef union { type *ptr; relptrtype relptr; } ptrtype;
+
+/* Pointers that can be absolute or relative */
+/* Use char for DatumPtr so works with Pointer */
+HnswPtrDeclare(HnswElementData, HnswElementRelptr, HnswElementPtr);
+HnswPtrDeclare(HnswNeighborArray, HnswNeighborArrayRelptr, HnswNeighborArrayPtr);
+HnswPtrDeclare(HnswNeighborArrayPtr, HnswNeighborsRelptr, HnswNeighborsPtr);
+HnswPtrDeclare(char, DatumRelptr, DatumPtr);
+
+struct HnswElementData
 {
-	List	   *heaptids;
+	HnswElementPtr next;
+	ItemPointerData heaptids[HNSW_HEAPTIDS];
+	uint8		heaptidsLength;
 	uint8		level;
 	uint8		deleted;
-	HnswNeighborArray *neighbors;
+	uint32		hash;
+	HnswNeighborsPtr neighbors;
 	BlockNumber blkno;
 	OffsetNumber offno;
 	OffsetNumber neighborOffno;
 	BlockNumber neighborPage;
-	Datum		value;
-}			HnswElementData;
+	DatumPtr	value;
+	LWLock		lock;
+};
 
 typedef HnswElementData * HnswElement;
 
 typedef struct HnswCandidate
 {
-	HnswElement element;
+	HnswElementPtr element;
 	float		distance;
 	bool		closer;
 }			HnswCandidate;
 
-typedef struct HnswNeighborArray
+struct HnswNeighborArray
 {
 	int			length;
 	bool		closerSet;
-	HnswCandidate *items;
-}			HnswNeighborArray;
+	HnswCandidate items[FLEXIBLE_ARRAY_MEMBER];
+};
 
 typedef struct HnswPairingHeapNode
 {
@@ -142,11 +174,27 @@ typedef struct HnswOptions
 	int			efConstruction; /* size of dynamic candidate list */
 }			HnswOptions;
 
-typedef struct HnswSpool
+typedef struct HnswGraph
 {
-	Relation	heap;
-	Relation	index;
-}			HnswSpool;
+	/* Graph state */
+	slock_t		lock;
+	HnswElementPtr head;
+	double		indtuples;
+
+	/* Entry state */
+	LWLock		entryLock;
+	LWLock		entryWaitLock;
+	HnswElementPtr entryPoint;
+
+	/* Allocations state */
+	LWLock		allocatorLock;
+	long		memoryUsed;
+	long		memoryTotal;
+
+	/* Flushed state */
+	LWLock		flushLock;
+	bool		flushed;
+}			HnswGraph;
 
 typedef struct HnswShared
 {
@@ -154,7 +202,6 @@ typedef struct HnswShared
 	Oid			heaprelid;
 	Oid			indexrelid;
 	bool		isconcurrent;
-	int			scantuplesortstates;
 
 	/* Worker progress */
 	ConditionVariable workersdonecv;
@@ -165,17 +212,11 @@ typedef struct HnswShared
 	/* Mutable state */
 	int			nparticipantsdone;
 	double		reltuples;
-	double		indtuples;
-
-#if PG_VERSION_NUM < 120000
-	ParallelHeapScanDescData heapdesc;	/* must come last */
-#endif
+	HnswGraph	graphData;
 }			HnswShared;
 
-#if PG_VERSION_NUM >= 120000
 #define ParallelTableScanFromHnswShared(shared) \
 	(ParallelTableScanDesc) ((char *) (shared) + BUFFERALIGN(sizeof(HnswShared)))
-#endif
 
 typedef struct HnswLeader
 {
@@ -183,8 +224,22 @@ typedef struct HnswLeader
 	int			nparticipanttuplesorts;
 	HnswShared *hnswshared;
 	Snapshot	snapshot;
+	char	   *hnswarea;
 }			HnswLeader;
 
+typedef struct HnswAllocator
+{
+	void	   *(*alloc) (Size size, void *state);
+	void	   *state;
+}			HnswAllocator;
+
+typedef struct HnswTypeInfo
+{
+	int			maxDimensions;
+	Datum		(*normalize) (PG_FUNCTION_ARGS);
+	void		(*checkValue) (Pointer v);
+}			HnswTypeInfo;
+
 typedef struct HnswBuildState
 {
 	/* Info */
@@ -192,6 +247,7 @@ typedef struct HnswBuildState
 	Relation	index;
 	IndexInfo  *indexInfo;
 	ForkNumber	forkNum;
+	const		HnswTypeInfo *typeInfo;
 
 	/* Settings */
 	int			dimensions;
@@ -208,20 +264,20 @@ typedef struct HnswBuildState
 	Oid			collation;
 
 	/* Variables */
-	List	   *elements;
-	HnswElement entryPoint;
+	HnswGraph	graphData;
+	HnswGraph  *graph;
 	double		ml;
 	int			maxLevel;
-	long		memoryLeft;
-	bool		flushed;
-	Vector	   *normvec;
 
 	/* Memory */
+	MemoryContext graphCtx;
 	MemoryContext tmpCtx;
+	HnswAllocator allocator;
 
 	/* Parallel builds */
 	HnswLeader *hnswleader;
 	HnswShared *hnswshared;
+	char	   *hnswarea;
 }			HnswBuildState;
 
 typedef struct HnswMetaPageData
@@ -274,6 +330,7 @@ typedef HnswNeighborTupleData * HnswNeighborTuple;
 
 typedef struct HnswScanOpaqueData
 {
+	const		HnswTypeInfo *typeInfo;
 	bool		first;
 	List	   *w;
 	MemoryContext tmpCtx;
@@ -303,7 +360,7 @@ typedef struct HnswVacuumState
 	Oid			collation;
 
 	/* Variables */
-	HTAB	   *deleted;
+	struct tidhash_hash *deleted;
 	BufferAccessStrategy bas;
 	HnswNeighborTuple ntup;
 	HnswElementData highestPoint;
@@ -316,32 +373,32 @@ typedef struct HnswVacuumState
 int			HnswGetM(Relation index);
 int			HnswGetEfConstruction(Relation index);
 FmgrInfo   *HnswOptionalProcInfo(Relation index, uint16 procnum);
-bool		HnswNormValue(FmgrInfo *procinfo, Oid collation, Datum *value, Vector * result);
-void		HnswCommitBuffer(Buffer buf, GenericXLogState *state);
+Datum		HnswNormValue(const HnswTypeInfo * typeInfo, Oid collation, Datum value);
+bool		HnswCheckNorm(FmgrInfo *procinfo, Oid collation, Datum value);
 Buffer		HnswNewBuffer(Relation index, ForkNumber forkNum);
 void		HnswInitPage(Buffer buf, Page page);
-void		HnswInitRegisterPage(Relation index, Buffer *buf, Page *page, GenericXLogState **state);
 void		HnswInit(void);
-List	   *HnswSearchLayer(Datum q, List *ep, int ef, int lc, Relation index, FmgrInfo *procinfo, Oid collation, int m, bool inserting, HnswElement skipElement);
+List	   *HnswSearchLayer(char *base, Datum q, List *ep, int ef, int lc, Relation index, FmgrInfo *procinfo, Oid collation, int m, bool inserting, HnswElement skipElement);
 HnswElement HnswGetEntryPoint(Relation index);
 void		HnswGetMetaPageInfo(Relation index, int *m, HnswElement * entryPoint);
-HnswElement HnswInitElement(ItemPointer tid, int m, double ml, int maxLevel);
-void		HnswFreeElement(HnswElement element);
+void	   *HnswAlloc(HnswAllocator * allocator, Size size);
+HnswElement HnswInitElement(char *base, ItemPointer tid, int m, double ml, int maxLevel, HnswAllocator * alloc);
 HnswElement HnswInitElementFromBlock(BlockNumber blkno, OffsetNumber offno);
-void		HnswInsertElement(HnswElement element, HnswElement entryPoint, Relation index, FmgrInfo *procinfo, Oid collation, int m, int efConstruction, bool existing);
-HnswElement HnswFindDuplicate(HnswElement e);
-HnswCandidate *HnswEntryCandidate(HnswElement em, Datum q, Relation rel, FmgrInfo *procinfo, Oid collation, bool loadVec);
-void		HnswUpdateMetaPage(Relation index, int updateEntry, HnswElement entryPoint, BlockNumber insertPage, ForkNumber forkNum);
-void		HnswSetNeighborTuple(HnswNeighborTuple ntup, HnswElement e, int m);
+void		HnswFindElementNeighbors(char *base, HnswElement element, HnswElement entryPoint, Relation index, FmgrInfo *procinfo, Oid collation, int m, int efConstruction, bool existing);
+HnswCandidate *HnswEntryCandidate(char *base, HnswElement em, Datum q, Relation rel, FmgrInfo *procinfo, Oid collation, bool loadVec);
+void		HnswUpdateMetaPage(Relation index, int updateEntry, HnswElement entryPoint, BlockNumber insertPage, ForkNumber forkNum, bool building);
+void		HnswSetNeighborTuple(char *base, HnswNeighborTuple ntup, HnswElement e, int m);
 void		HnswAddHeapTid(HnswElement element, ItemPointer heaptid);
-void		HnswInitNeighbors(HnswElement element, int m);
-bool		HnswInsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heap_tid, Relation heapRel);
-void		HnswUpdateNeighborPages(Relation index, FmgrInfo *procinfo, Oid collation, HnswElement e, int m, bool checkExisting);
+void		HnswInitNeighbors(char *base, HnswElement element, int m, HnswAllocator * alloc);
+bool		HnswInsertTupleOnDisk(Relation index, Datum value, Datum *values, bool *isnull, ItemPointer heap_tid, bool building);
+void		HnswUpdateNeighborsOnDisk(Relation index, FmgrInfo *procinfo, Oid collation, HnswElement e, int m, bool checkExisting, bool building);
 void		HnswLoadElementFromTuple(HnswElement element, HnswElementTuple etup, bool loadHeaptids, bool loadVec);
-void		HnswLoadElement(HnswElement element, float *distance, Datum *q, Relation index, FmgrInfo *procinfo, Oid collation, bool loadVec);
-void		HnswSetElementTuple(HnswElementTuple etup, HnswElement element);
-void		HnswUpdateConnection(HnswElement element, HnswCandidate * hc, int m, int lc, int *updateIdx, Relation index, FmgrInfo *procinfo, Oid collation);
+void		HnswLoadElement(HnswElement element, float *distance, Datum *q, Relation index, FmgrInfo *procinfo, Oid collation, bool loadVec, float *maxDistance);
+void		HnswSetElementTuple(char *base, HnswElementTuple etup, HnswElement element);
+void		HnswUpdateConnection(char *base, HnswElement element, HnswCandidate * hc, int lm, int lc, int *updateIdx, Relation index, FmgrInfo *procinfo, Oid collation);
 void		HnswLoadNeighbors(HnswElement element, Relation index, int m);
+void		HnswInitLockTranche(void);
+const		HnswTypeInfo *HnswGetTypeInfo(Relation index);
 PGDLLEXPORT void HnswParallelBuildMain(dsm_segment *seg, shm_toc *toc);
 
 /* Index access methods */
@@ -360,4 +417,54 @@ void		hnswrescan(IndexScanDesc scan, ScanKey keys, int nkeys, ScanKey orderbys,
 bool		hnswgettuple(IndexScanDesc scan, ScanDirection dir);
 void		hnswendscan(IndexScanDesc scan);
 
+static inline HnswNeighborArray *
+HnswGetNeighbors(char *base, HnswElement element, int lc)
+{
+	HnswNeighborArrayPtr *neighborList = HnswPtrAccess(base, element->neighbors);
+
+	Assert(element->level >= lc);
+
+	return HnswPtrAccess(base, neighborList[lc]);
+}
+
+/* Hash tables */
+typedef struct TidHashEntry
+{
+	ItemPointerData tid;
+	char		status;
+}			TidHashEntry;
+
+#define SH_PREFIX tidhash
+#define SH_ELEMENT_TYPE TidHashEntry
+#define SH_KEY_TYPE ItemPointerData
+#define SH_SCOPE extern
+#define SH_DECLARE
+#include "lib/simplehash.h"
+
+typedef struct PointerHashEntry
+{
+	uintptr_t	ptr;
+	char		status;
+}			PointerHashEntry;
+
+#define SH_PREFIX pointerhash
+#define SH_ELEMENT_TYPE PointerHashEntry
+#define SH_KEY_TYPE uintptr_t
+#define SH_SCOPE extern
+#define SH_DECLARE
+#include "lib/simplehash.h"
+
+typedef struct OffsetHashEntry
+{
+	Size		offset;
+	char		status;
+}			OffsetHashEntry;
+
+#define SH_PREFIX offsethash
+#define SH_ELEMENT_TYPE OffsetHashEntry
+#define SH_KEY_TYPE Size
+#define SH_SCOPE extern
+#define SH_DECLARE
+#include "lib/simplehash.h"
+
 #endif

src/hnswinsert.c

@@ -2,9 +2,11 @@
 
 #include <math.h>
 
+#include "access/generic_xlog.h"
 #include "hnsw.h"
 #include "storage/bufmgr.h"
 #include "storage/lmgr.h"
+#include "utils/datum.h"
 #include "utils/memutils.h"
 
 /*
@@ -34,14 +36,15 @@ GetInsertPage(Relation index)
  * Check for a free offset
  */
 static bool
-HnswFreeOffset(Relation index, Buffer buf, Page page, HnswElement element, Size ntupSize, Buffer *nbuf, Page *npage, OffsetNumber *freeOffno, OffsetNumber *freeNeighborOffno, BlockNumber *newInsertPage)
+HnswFreeOffset(Relation index, Buffer buf, Page page, HnswElement element, Size etupSize, Size ntupSize, Buffer *nbuf, Page *npage, OffsetNumber *freeOffno, OffsetNumber *freeNeighborOffno, BlockNumber *newInsertPage)
 {
 	OffsetNumber offno;
 	OffsetNumber maxoffno = PageGetMaxOffsetNumber(page);
 
 	for (offno = FirstOffsetNumber; offno <= maxoffno; offno = OffsetNumberNext(offno))
 	{
-		HnswElementTuple etup = (HnswElementTuple) PageGetItem(page, PageGetItemId(page, offno));
+		ItemId		eitemid = PageGetItemId(page, offno);
+		HnswElementTuple etup = (HnswElementTuple) PageGetItem(page, eitemid);
 
 		/* Skip neighbor tuples */
 		if (!HnswIsElementTuple(etup))
@@ -52,7 +55,9 @@ HnswFreeOffset(Relation index, Buffer buf, Page page, HnswElement element, Size
 			BlockNumber elementPage = BufferGetBlockNumber(buf);
 			BlockNumber neighborPage = ItemPointerGetBlockNumber(&etup->neighbortid);
 			OffsetNumber neighborOffno = ItemPointerGetOffsetNumber(&etup->neighbortid);
-			ItemId		itemid;
+			ItemId		nitemid;
+			Size		pageFree;
+			Size		npageFree;
 
 			if (!BlockNumberIsValid(*newInsertPage))
 				*newInsertPage = elementPage;
@@ -71,10 +76,25 @@ HnswFreeOffset(Relation index, Buffer buf, Page page, HnswElement element, Size
 				*npage = BufferGetPage(*nbuf);
 			}
 
-			itemid = PageGetItemId(*npage, neighborOffno);
+			nitemid = PageGetItemId(*npage, neighborOffno);
 
-			/* Check for space on neighbor tuple page */
-			if (PageGetFreeSpace(*npage) + ItemIdGetLength(itemid) - sizeof(ItemIdData) >= ntupSize)
+			/* Ensure aligned for space check */
+			Assert(etupSize == MAXALIGN(etupSize));
+			Assert(ntupSize == MAXALIGN(ntupSize));
+
+			/*
+			 * Calculate free space individually since tuples are overwritten
+			 * individually (in separate calls to PageIndexTupleOverwrite)
+			 */
+			pageFree = ItemIdGetLength(eitemid) + PageGetExactFreeSpace(page);
+			npageFree = ItemIdGetLength(nitemid);
+			if (neighborPage != elementPage)
+				npageFree += PageGetExactFreeSpace(*npage);
+			else if (pageFree >= etupSize)
+				npageFree += pageFree - etupSize;
+
+			/* Check for space */
+			if (pageFree >= etupSize && npageFree >= ntupSize)
 			{
 				*freeOffno = offno;
 				*freeNeighborOffno = neighborOffno;
@@ -92,7 +112,7 @@ HnswFreeOffset(Relation index, Buffer buf, Page page, HnswElement element, Size
  * Add a new page
  */
 static void
-HnswInsertAppendPage(Relation index, Buffer *nbuf, Page *npage, GenericXLogState *state, Page page)
+HnswInsertAppendPage(Relation index, Buffer *nbuf, Page *npage, GenericXLogState *state, Page page, bool building)
 {
 	/* Add a new page */
 	LockRelationForExtension(index, ExclusiveLock);
@@ -100,7 +120,11 @@ HnswInsertAppendPage(Relation index, Buffer *nbuf, Page *npage, GenericXLogState
 	UnlockRelationForExtension(index, ExclusiveLock);
 
 	/* Init new page */
-	*npage = GenericXLogRegisterBuffer(state, *nbuf, GENERIC_XLOG_FULL_IMAGE);
+	if (building)
+		*npage = BufferGetPage(*nbuf);
+	else
+		*npage = GenericXLogRegisterBuffer(state, *nbuf, GENERIC_XLOG_FULL_IMAGE);
+
 	HnswInitPage(*nbuf, *npage);
 
 	/* Update previous buffer */
@@ -111,7 +135,7 @@ HnswInsertAppendPage(Relation index, Buffer *nbuf, Page *npage, GenericXLogState
  * Add to element and neighbor pages
  */
 static void
-WriteNewElementPages(Relation index, HnswElement e, int m, BlockNumber insertPage, BlockNumber *updatedInsertPage)
+AddElementOnDisk(Relation index, HnswElement e, int m, BlockNumber insertPage, BlockNumber *updatedInsertPage, bool building)
 {
 	Buffer		buf;
 	Page		page;
@@ -129,9 +153,10 @@ WriteNewElementPages(Relation index, HnswElement e, int m, BlockNumber insertPag
 	OffsetNumber freeOffno = InvalidOffsetNumber;
 	OffsetNumber freeNeighborOffno = InvalidOffsetNumber;
 	BlockNumber newInsertPage = InvalidBlockNumber;
+	char	   *base = NULL;
 
 	/* Calculate sizes */
-	etupSize = HNSW_ELEMENT_TUPLE_SIZE(VARSIZE_ANY(DatumGetPointer(e->value)));
+	etupSize = HNSW_ELEMENT_TUPLE_SIZE(VARSIZE_ANY(HnswPtrAccess(base, e->value)));
 	ntupSize = HNSW_NEIGHBOR_TUPLE_SIZE(e->level, m);
 	combinedSize = etupSize + ntupSize + sizeof(ItemIdData);
 	maxSize = HNSW_MAX_SIZE;
@@ -139,11 +164,11 @@ WriteNewElementPages(Relation index, HnswElement e, int m, BlockNumber insertPag
 
 	/* Prepare element tuple */
 	etup = palloc0(etupSize);
-	HnswSetElementTuple(etup, e);
+	HnswSetElementTuple(base, etup, e);
 
 	/* Prepare neighbor tuple */
 	ntup = palloc0(ntupSize);
-	HnswSetNeighborTuple(ntup, e, m);
+	HnswSetNeighborTuple(base, ntup, e, m);
 
 	/* Find a page (or two if needed) to insert the tuples */
 	for (;;)
@@ -151,8 +176,16 @@ WriteNewElementPages(Relation index, HnswElement e, int m, BlockNumber insertPag
 		buf = ReadBuffer(index, currentPage);
 		LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
 
-		state = GenericXLogStart(index);
-		page = GenericXLogRegisterBuffer(state, buf, 0);
+		if (building)
+		{
+			state = NULL;
+			page = BufferGetPage(buf);
+		}
+		else
+		{
+			state = GenericXLogStart(index);
+			page = GenericXLogRegisterBuffer(state, buf, 0);
+		}
 
 		/* Keep track of first page where element at level 0 can fit */
 		if (!BlockNumberIsValid(newInsertPage) && PageGetFreeSpace(page) >= minCombinedSize)
@@ -169,10 +202,15 @@ WriteNewElementPages(Relation index, HnswElement e, int m, BlockNumber insertPag
 		}
 
 		/* Next, try space from a deleted element */
-		if (HnswFreeOffset(index, buf, page, e, ntupSize, &nbuf, &npage, &freeOffno, &freeNeighborOffno, &newInsertPage))
+		if (HnswFreeOffset(index, buf, page, e, etupSize, ntupSize, &nbuf, &npage, &freeOffno, &freeNeighborOffno, &newInsertPage))
 		{
 			if (nbuf != buf)
-				npage = GenericXLogRegisterBuffer(state, nbuf, 0);
+			{
+				if (building)
+					npage = BufferGetPage(nbuf);
+				else
+					npage = GenericXLogRegisterBuffer(state, nbuf, 0);
+			}
 
 			break;
 		}
@@ -181,7 +219,7 @@ WriteNewElementPages(Relation index, HnswElement e, int m, BlockNumber insertPag
 		/* Skip if both tuples can fit on the same page */
 		if (combinedSize > maxSize && PageGetFreeSpace(page) >= etupSize && !BlockNumberIsValid(HnswPageGetOpaque(page)->nextblkno))
 		{
-			HnswInsertAppendPage(index, &nbuf, &npage, state, page);
+			HnswInsertAppendPage(index, &nbuf, &npage, state, page, building);
 			break;
 		}
 
@@ -190,7 +228,8 @@ WriteNewElementPages(Relation index, HnswElement e, int m, BlockNumber insertPag
 		if (BlockNumberIsValid(currentPage))
 		{
 			/* Move to next page */
-			GenericXLogAbort(state);
+			if (!building)
+				GenericXLogAbort(state);
 			UnlockReleaseBuffer(buf);
 		}
 		else
@@ -198,22 +237,33 @@ WriteNewElementPages(Relation index, HnswElement e, int m, BlockNumber insertPag
 			Buffer		newbuf;
 			Page		newpage;
 
-			HnswInsertAppendPage(index, &newbuf, &newpage, state, page);
+			HnswInsertAppendPage(index, &newbuf, &newpage, state, page, building);
 
 			/* Commit */
-			GenericXLogFinish(state);
+			if (building)
+				MarkBufferDirty(buf);
+			else
+				GenericXLogFinish(state);
 
 			/* Unlock previous buffer */
 			UnlockReleaseBuffer(buf);
 
 			/* Prepare new buffer */
-			state = GenericXLogStart(index);
 			buf = newbuf;
-			page = GenericXLogRegisterBuffer(state, buf, 0);
+			if (building)
+			{
+				state = NULL;
+				page = BufferGetPage(buf);
+			}
+			else
+			{
+				state = GenericXLogStart(index);
+				page = GenericXLogRegisterBuffer(state, buf, 0);
+			}
 
 			/* Create new page for neighbors if needed */
 			if (PageGetFreeSpace(page) < combinedSize)
-				HnswInsertAppendPage(index, &nbuf, &npage, state, page);
+				HnswInsertAppendPage(index, &nbuf, &npage, state, page, building);
 			else
 			{
 				nbuf = buf;
@@ -267,7 +317,14 @@ WriteNewElementPages(Relation index, HnswElement e, int m, BlockNumber insertPag
 	}
 
 	/* Commit */
-	GenericXLogFinish(state);
+	if (building)
+	{
+		MarkBufferDirty(buf);
+		if (nbuf != buf)
+			MarkBufferDirty(nbuf);
+	}
+	else
+		GenericXLogFinish(state);
 	UnlockReleaseBuffer(buf);
 	if (nbuf != buf)
 		UnlockReleaseBuffer(nbuf);
@@ -301,12 +358,14 @@ ConnectionExists(HnswElement e, HnswNeighborTuple ntup, int startIdx, int lm)
  * Update neighbors
  */
 void
-HnswUpdateNeighborPages(Relation index, FmgrInfo *procinfo, Oid collation, HnswElement e, int m, bool checkExisting)
+HnswUpdateNeighborsOnDisk(Relation index, FmgrInfo *procinfo, Oid collation, HnswElement e, int m, bool checkExisting, bool building)
 {
+	char	   *base = NULL;
+
 	for (int lc = e->level; lc >= 0; lc--)
 	{
 		int			lm = HnswGetLayerM(m, lc);
-		HnswNeighborArray *neighbors = &e->neighbors[lc];
+		HnswNeighborArray *neighbors = HnswGetNeighbors(base, e, lc);
 
 		for (int i = 0; i < neighbors->length; i++)
 		{
@@ -314,16 +373,15 @@ HnswUpdateNeighborPages(Relation index, FmgrInfo *procinfo, Oid collation, HnswE
 			Buffer		buf;
 			Page		page;
 			GenericXLogState *state;
-			ItemId		itemid;
 			HnswNeighborTuple ntup;
-			Size		ntupSize;
 			int			idx = -1;
 			int			startIdx;
-			OffsetNumber offno = hc->element->neighborOffno;
+			HnswElement neighborElement = HnswPtrAccess(base, hc->element);
+			OffsetNumber offno = neighborElement->neighborOffno;
 
 			/* Get latest neighbors since they may have changed */
 			/* Do not lock yet since selecting neighbors can take time */
-			HnswLoadNeighbors(hc->element, index, m);
+			HnswLoadNeighbors(neighborElement, index, m);
 
 			/*
 			 * Could improve performance for vacuuming by checking neighbors
@@ -333,25 +391,31 @@ HnswUpdateNeighborPages(Relation index, FmgrInfo *procinfo, Oid collation, HnswE
 			 */
 
 			/* Select neighbors */
-			HnswUpdateConnection(e, hc, lm, lc, &idx, index, procinfo, collation);
+			HnswUpdateConnection(NULL, e, hc, lm, lc, &idx, index, procinfo, collation);
 
 			/* New element was not selected as a neighbor */
 			if (idx == -1)
 				continue;
 
 			/* Register page */
-			buf = ReadBuffer(index, hc->element->neighborPage);
+			buf = ReadBuffer(index, neighborElement->neighborPage);
 			LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
-			state = GenericXLogStart(index);
-			page = GenericXLogRegisterBuffer(state, buf, 0);
+			if (building)
+			{
+				state = NULL;
+				page = BufferGetPage(buf);
+			}
+			else
+			{
+				state = GenericXLogStart(index);
+				page = GenericXLogRegisterBuffer(state, buf, 0);
+			}
 
 			/* Get tuple */
-			itemid = PageGetItemId(page, offno);
-			ntup = (HnswNeighborTuple) PageGetItem(page, itemid);
-			ntupSize = ItemIdGetLength(itemid);
+			ntup = (HnswNeighborTuple) PageGetItem(page, PageGetItemId(page, offno));
 
 			/* Calculate index for update */
-			startIdx = (hc->element->level - lc) * m;
+			startIdx = (neighborElement->level - lc) * m;
 
 			/* Check for existing connection */
 			if (checkExisting && ConnectionExists(e, ntup, startIdx, lm))
@@ -377,17 +441,16 @@ HnswUpdateNeighborPages(Relation index, FmgrInfo *procinfo, Oid collation, HnswE
 			{
 				ItemPointer indextid = &ntup->indextids[idx];
 
-				/* Update neighbor */
+				/* Update neighbor on the buffer */
 				ItemPointerSet(indextid, e->blkno, e->offno);
 
-				/* Overwrite tuple */
-				if (!PageIndexTupleOverwrite(page, offno, (Item) ntup, ntupSize))
-					elog(ERROR, "failed to add index item to \"%s\"", RelationGetRelationName(index));
-
 				/* Commit */
-				GenericXLogFinish(state);
+				if (building)
+					MarkBufferDirty(buf);
+				else
+					GenericXLogFinish(state);
 			}
-			else
+			else if (!building)
 				GenericXLogAbort(state);
 
 			UnlockReleaseBuffer(buf);
@@ -399,26 +462,30 @@ HnswUpdateNeighborPages(Relation index, FmgrInfo *procinfo, Oid collation, HnswE
  * Add a heap TID to an existing element
  */
 static bool
-HnswAddDuplicate(Relation index, HnswElement element, HnswElement dup)
+AddDuplicateOnDisk(Relation index, HnswElement element, HnswElement dup, bool building)
 {
 	Buffer		buf;
 	Page		page;
 	GenericXLogState *state;
-	ItemId		itemid;
 	HnswElementTuple etup;
-	Size		etupSize;
 	int			i;
 
 	/* Read page */
 	buf = ReadBuffer(index, dup->blkno);
 	LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
-	state = GenericXLogStart(index);
-	page = GenericXLogRegisterBuffer(state, buf, 0);
+	if (building)
+	{
+		state = NULL;
+		page = BufferGetPage(buf);
+	}
+	else
+	{
+		state = GenericXLogStart(index);
+		page = GenericXLogRegisterBuffer(state, buf, 0);
+	}
 
 	/* Find space */
-	itemid = PageGetItemId(page, dup->offno);
-	etup = (HnswElementTuple) PageGetItem(page, itemid);
-	etupSize = ItemIdGetLength(itemid);
+	etup = (HnswElementTuple) PageGetItem(page, PageGetItemId(page, dup->offno));
 	for (i = 0; i < HNSW_HEAPTIDS; i++)
 	{
 		if (!ItemPointerIsValid(&etup->heaptids[i]))
@@ -428,82 +495,93 @@ HnswAddDuplicate(Relation index, HnswElement element, HnswElement dup)
 	/* Either being deleted or we lost our chance to another backend */
 	if (i == 0 || i == HNSW_HEAPTIDS)
 	{
-		GenericXLogAbort(state);
+		if (!building)
+			GenericXLogAbort(state);
 		UnlockReleaseBuffer(buf);
 		return false;
 	}
 
-	/* Add heap TID */
-	etup->heaptids[i] = *((ItemPointer) linitial(element->heaptids));
-
-	/* Overwrite tuple */
-	if (!PageIndexTupleOverwrite(page, dup->offno, (Item) etup, etupSize))
-		elog(ERROR, "failed to add index item to \"%s\"", RelationGetRelationName(index));
+	/* Add heap TID, modifying the tuple on the page directly */
+	etup->heaptids[i] = element->heaptids[0];
 
 	/* Commit */
-	GenericXLogFinish(state);
+	if (building)
+		MarkBufferDirty(buf);
+	else
+		GenericXLogFinish(state);
 	UnlockReleaseBuffer(buf);
 
 	return true;
 }
 
 /*
- * Write changes to disk
+ * Find duplicate element
+ */
+static bool
+FindDuplicateOnDisk(Relation index, HnswElement element, bool building)
+{
+	char	   *base = NULL;
+	HnswNeighborArray *neighbors = HnswGetNeighbors(base, element, 0);
+	Datum		value = HnswGetValue(base, element);
+
+	for (int i = 0; i < neighbors->length; i++)
+	{
+		HnswCandidate *neighbor = &neighbors->items[i];
+		HnswElement neighborElement = HnswPtrAccess(base, neighbor->element);
+		Datum		neighborValue = HnswGetValue(base, neighborElement);
+
+		/* Exit early since ordered by distance */
+		if (!datumIsEqual(value, neighborValue, false, -1))
+			return false;
+
+		if (AddDuplicateOnDisk(index, element, neighborElement, building))
+			return true;
+	}
+
+	return false;
+}
+
+/*
+ * Update graph on disk
  */
 static void
-WriteElement(Relation index, FmgrInfo *procinfo, Oid collation, HnswElement element, int m, int efConstruction, HnswElement dup, HnswElement entryPoint)
+UpdateGraphOnDisk(Relation index, FmgrInfo *procinfo, Oid collation, HnswElement element, int m, int efConstruction, HnswElement entryPoint, bool building)
 {
 	BlockNumber newInsertPage = InvalidBlockNumber;
 
-	/* Try to add to existing page */
-	if (dup != NULL)
-	{
-		if (HnswAddDuplicate(index, element, dup))
-			return;
-	}
+	/* Look for duplicate */
+	if (FindDuplicateOnDisk(index, element, building))
+		return;
 
-	/* Write element and neighbor tuples */
-	WriteNewElementPages(index, element, m, GetInsertPage(index), &newInsertPage);
+	/* Add element */
+	AddElementOnDisk(index, element, m, GetInsertPage(index), &newInsertPage, building);
 
 	/* Update insert page if needed */
 	if (BlockNumberIsValid(newInsertPage))
-		HnswUpdateMetaPage(index, 0, NULL, newInsertPage, MAIN_FORKNUM);
+		HnswUpdateMetaPage(index, 0, NULL, newInsertPage, MAIN_FORKNUM, building);
 
 	/* Update neighbors */
-	HnswUpdateNeighborPages(index, procinfo, collation, element, m, false);
+	HnswUpdateNeighborsOnDisk(index, procinfo, collation, element, m, false, building);
 
-	/* Update metapage if needed */
+	/* Update entry point if needed */
 	if (entryPoint == NULL || element->level > entryPoint->level)
-		HnswUpdateMetaPage(index, HNSW_UPDATE_ENTRY_GREATER, element, InvalidBlockNumber, MAIN_FORKNUM);
+		HnswUpdateMetaPage(index, HNSW_UPDATE_ENTRY_GREATER, element, InvalidBlockNumber, MAIN_FORKNUM, building);
 }
 
 /*
  * Insert a tuple into the index
  */
 bool
-HnswInsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heap_tid, Relation heapRel)
+HnswInsertTupleOnDisk(Relation index, Datum value, Datum *values, bool *isnull, ItemPointer heap_tid, bool building)
 {
-	Datum		value;
-	FmgrInfo   *normprocinfo;
 	HnswElement entryPoint;
 	HnswElement element;
 	int			m;
 	int			efConstruction = HnswGetEfConstruction(index);
 	FmgrInfo   *procinfo = index_getprocinfo(index, 1, HNSW_DISTANCE_PROC);
 	Oid			collation = index->rd_indcollation[0];
-	HnswElement dup;
 	LOCKMODE	lockmode = ShareLock;
-
-	/* Detoast once for all calls */
-	value = PointerGetDatum(PG_DETOAST_DATUM(values[0]));
-
-	/* Normalize if needed */
-	normprocinfo = HnswOptionalProcInfo(index, HNSW_NORM_PROC);
-	if (normprocinfo != NULL)
-	{
-		if (!HnswNormValue(normprocinfo, collation, &value, NULL))
-			return false;
-	}
+	char	   *base = NULL;
 
 	/*
 	 * Get a shared lock. This allows vacuum to ensure no in-flight inserts
@@ -516,8 +594,8 @@ HnswInsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heap_ti
 	HnswGetMetaPageInfo(index, &m, &entryPoint);
 
 	/* Create an element */
-	element = HnswInitElement(heap_tid, m, HnswGetMl(m), HnswGetMaxLevel(m));
-	element->value = value;
+	element = HnswInitElement(base, heap_tid, m, HnswGetMl(m), HnswGetMaxLevel(m), NULL);
+	HnswPtrStore(base, element->value, DatumGetPointer(value));
 
 	/* Prevent concurrent inserts when likely updating entry point */
 	if (entryPoint == NULL || element->level > entryPoint->level)
@@ -533,14 +611,11 @@ HnswInsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heap_ti
 		entryPoint = HnswGetEntryPoint(index);
 	}
 
-	/* Insert element in graph */
-	HnswInsertElement(element, entryPoint, index, procinfo, collation, m, efConstruction, false);
+	/* Find neighbors for element */
+	HnswFindElementNeighbors(base, element, entryPoint, index, procinfo, collation, m, efConstruction, false);
 
-	/* Look for duplicate */
-	dup = HnswFindDuplicate(element);
-
-	/* Write to disk */
-	WriteElement(index, procinfo, collation, element, m, efConstruction, dup, entryPoint);
+	/* Update graph on disk */
+	UpdateGraphOnDisk(index, procinfo, collation, element, m, efConstruction, entryPoint, building);
 
 	/* Release lock */
 	UnlockPage(index, HNSW_UPDATE_LOCK, lockmode);
@@ -548,6 +623,37 @@ HnswInsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heap_ti
 	return true;
 }
 
+/*
+ * Insert a tuple into the index
+ */
+static void
+HnswInsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heap_tid)
+{
+	Datum		value;
+	const		HnswTypeInfo *typeInfo = HnswGetTypeInfo(index);
+	FmgrInfo   *normprocinfo;
+	Oid			collation = index->rd_indcollation[0];
+
+	/* Detoast once for all calls */
+	value = PointerGetDatum(PG_DETOAST_DATUM(values[0]));
+
+	/* Check value */
+	if (typeInfo->checkValue != NULL)
+		typeInfo->checkValue(DatumGetPointer(value));
+
+	/* Normalize if needed */
+	normprocinfo = HnswOptionalProcInfo(index, HNSW_NORM_PROC);
+	if (normprocinfo != NULL)
+	{
+		if (!HnswCheckNorm(normprocinfo, collation, value))
+			return;
+
+		value = HnswNormValue(typeInfo, collation, value);
+	}
+
+	HnswInsertTupleOnDisk(index, value, values, isnull, heap_tid, false);
+}
+
 /*
  * Insert a tuple into the index
  */
@@ -574,7 +680,7 @@ hnswinsert(Relation index, Datum *values, bool *isnull, ItemPointer heap_tid,
 	oldCtx = MemoryContextSwitchTo(insertCtx);
 
 	/* Insert tuple */
-	HnswInsertTuple(index, values, isnull, heap_tid, heap);
+	HnswInsertTuple(index, values, isnull, heap_tid);
 
 	/* Delete memory context */
 	MemoryContextSwitchTo(oldCtx);

src/hnswscan.c

@@ -21,6 +21,7 @@ GetScanItems(IndexScanDesc scan, Datum q)
 	List	   *w;
 	int			m;
 	HnswElement entryPoint;
+	char	   *base = NULL;
 
 	/* Get m and entry point */
 	HnswGetMetaPageInfo(index, &m, &entryPoint);
@@ -28,38 +29,15 @@ GetScanItems(IndexScanDesc scan, Datum q)
 	if (entryPoint == NULL)
 		return NIL;
 
-	ep = list_make1(HnswEntryCandidate(entryPoint, q, index, procinfo, collation, false));
+	ep = list_make1(HnswEntryCandidate(base, entryPoint, q, index, procinfo, collation, false));
 
 	for (int lc = entryPoint->level; lc >= 1; lc--)
 	{
-		w = HnswSearchLayer(q, ep, 1, lc, index, procinfo, collation, m, false, NULL);
+		w = HnswSearchLayer(base, q, ep, 1, lc, index, procinfo, collation, m, false, NULL);
 		ep = w;
 	}
 
-	return HnswSearchLayer(q, ep, hnsw_ef_search, 0, index, procinfo, collation, m, false, NULL);
-}
-
-/*
- * Get dimensions from metapage
- */
-static int
-GetDimensions(Relation index)
-{
-	Buffer		buf;
-	Page		page;
-	HnswMetaPage metap;
-	int			dimensions;
-
-	buf = ReadBuffer(index, HNSW_METAPAGE_BLKNO);
-	LockBuffer(buf, BUFFER_LOCK_SHARE);
-	page = BufferGetPage(buf);
-	metap = HnswPageGetMeta(page);
-
-	dimensions = metap->dimensions;
-
-	UnlockReleaseBuffer(buf);
-
-	return dimensions;
+	return HnswSearchLayer(base, q, ep, hnsw_ef_search, 0, index, procinfo, collation, m, false, NULL);
 }
 
 /*
@@ -72,7 +50,7 @@ GetScanValue(IndexScanDesc scan)
 	Datum		value;
 
 	if (scan->orderByData->sk_flags & SK_ISNULL)
-		value = PointerGetDatum(InitVector(GetDimensions(scan->indexRelation)));
+		value = PointerGetDatum(NULL);
 	else
 	{
 		value = scan->orderByData->sk_argument;
@@ -81,9 +59,9 @@ GetScanValue(IndexScanDesc scan)
 		Assert(!VARATT_IS_COMPRESSED(DatumGetPointer(value)));
 		Assert(!VARATT_IS_EXTENDED(DatumGetPointer(value)));
 
-		/* Fine if normalization fails */
+		/* Normalize if needed */
 		if (so->normprocinfo != NULL)
-			HnswNormValue(so->normprocinfo, so->collation, &value, NULL);
+			value = HnswNormValue(so->typeInfo, so->collation, value);
 	}
 
 	return value;
@@ -101,6 +79,7 @@ hnswbeginscan(Relation index, int nkeys, int norderbys)
 	scan = RelationGetIndexScan(index, nkeys, norderbys);
 
 	so = (HnswScanOpaque) palloc(sizeof(HnswScanOpaqueData));
+	so->typeInfo = HnswGetTypeInfo(index);
 	so->first = true;
 	so->tmpCtx = AllocSetContextCreate(CurrentMemoryContext,
 									   "Hnsw scan temporary context",
@@ -180,32 +159,32 @@ hnswgettuple(IndexScanDesc scan, ScanDirection dir)
 		UnlockPage(scan->indexRelation, HNSW_SCAN_LOCK, ShareLock);
 
 		so->first = false;
+
+#if defined(HNSW_MEMORY) && PG_VERSION_NUM >= 130000
+		elog(INFO, "memory: %zu MB", MemoryContextMemAllocated(so->tmpCtx, false) / (1024 * 1024));
+#endif
 	}
 
 	while (list_length(so->w) > 0)
 	{
+		char	   *base = NULL;
 		HnswCandidate *hc = llast(so->w);
+		HnswElement element = HnswPtrAccess(base, hc->element);
 		ItemPointer heaptid;
 
 		/* Move to next element if no valid heap TIDs */
-		if (list_length(hc->element->heaptids) == 0)
+		if (element->heaptidsLength == 0)
 		{
 			so->w = list_delete_last(so->w);
 			continue;
 		}
 
-		heaptid = llast(hc->element->heaptids);
-
-		hc->element->heaptids = list_delete_last(hc->element->heaptids);
+		heaptid = &element->heaptids[--element->heaptidsLength];
 
 		MemoryContextSwitchTo(oldCtx);
 
-#if PG_VERSION_NUM >= 120000
 		scan->xs_heaptid = *heaptid;
-#else
-		scan->xs_ctup.t_self = *heaptid;
-#endif
-
+		scan->xs_recheck = false;
 		scan->xs_recheckorderby = false;
 		return true;
 	}

src/hnswvacuum.c

@@ -2,6 +2,7 @@
 
 #include <math.h>
 
+#include "access/generic_xlog.h"
 #include "commands/vacuum.h"
 #include "hnsw.h"
 #include "storage/bufmgr.h"
@@ -12,12 +13,9 @@
  * Check if deleted list contains an index TID
  */
 static bool
-DeletedContains(HTAB *deleted, ItemPointer indextid)
+DeletedContains(tidhash_hash * deleted, ItemPointer indextid)
 {
-	bool		found;
-
-	hash_search(deleted, indextid, HASH_FIND, &found);
-	return found;
+	return tidhash_lookup(deleted, *indextid) != NULL;
 }
 
 /*
@@ -62,8 +60,7 @@ RemoveHeapTids(HnswVacuumState * vacuumstate)
 		/* Iterate over nodes */
 		for (offno = FirstOffsetNumber; offno <= maxoffno; offno = OffsetNumberNext(offno))
 		{
-			ItemId		itemid = PageGetItemId(page, offno);
-			HnswElementTuple etup = (HnswElementTuple) PageGetItem(page, itemid);
+			HnswElementTuple etup = (HnswElementTuple) PageGetItem(page, PageGetItemId(page, offno));
 			int			idx = 0;
 			bool		itemUpdated = false;
 
@@ -94,15 +91,10 @@ RemoveHeapTids(HnswVacuumState * vacuumstate)
 
 				if (itemUpdated)
 				{
-					Size		etupSize = ItemIdGetLength(itemid);
-
 					/* Mark rest as invalid */
 					for (int i = idx; i < HNSW_HEAPTIDS; i++)
 						ItemPointerSetInvalid(&etup->heaptids[i]);
 
-					if (!PageIndexTupleOverwrite(page, offno, (Item) etup, etupSize))
-						elog(ERROR, "failed to add index item to \"%s\"", RelationGetRelationName(index));
-
 					updated = true;
 				}
 			}
@@ -110,11 +102,13 @@ RemoveHeapTids(HnswVacuumState * vacuumstate)
 			if (!ItemPointerIsValid(&etup->heaptids[0]))
 			{
 				ItemPointerData ip;
+				bool		found;
 
 				/* Add to deleted list */
 				ItemPointerSet(&ip, blkno, offno);
 
-				(void) hash_search(vacuumstate->deleted, &ip, HASH_ENTER, NULL);
+				tidhash_insert(vacuumstate->deleted, ip, &found);
+				Assert(!found);
 			}
 			else if (etup->level > highestLevel && !(entryPoint != NULL && blkno == entryPoint->blkno && offno == entryPoint->offno))
 			{
@@ -200,21 +194,25 @@ RepairGraphElement(HnswVacuumState * vacuumstate, HnswElement element, HnswEleme
 	BufferAccessStrategy bas = vacuumstate->bas;
 	HnswNeighborTuple ntup = vacuumstate->ntup;
 	Size		ntupSize = HNSW_NEIGHBOR_TUPLE_SIZE(element->level, m);
+	char	   *base = NULL;
 
 	/* Skip if element is entry point */
 	if (entryPoint != NULL && element->blkno == entryPoint->blkno && element->offno == entryPoint->offno)
 		return;
 
 	/* Init fields */
-	HnswInitNeighbors(element, m);
-	element->heaptids = NIL;
+	HnswInitNeighbors(base, element, m, NULL);
+	element->heaptidsLength = 0;
 
-	/* Add element to graph, skipping itself */
-	HnswInsertElement(element, entryPoint, index, procinfo, collation, m, efConstruction, true);
+	/* Find neighbors for element, skipping itself */
+	HnswFindElementNeighbors(base, element, entryPoint, index, procinfo, collation, m, efConstruction, true);
+
+	/* Zero memory for each element */
+	MemSet(ntup, 0, HNSW_TUPLE_ALLOC_SIZE);
 
 	/* Update neighbor tuple */
 	/* Do this before getting page to minimize locking */
-	HnswSetNeighborTuple(ntup, element, m);
+	HnswSetNeighborTuple(base, ntup, element, m);
 
 	/* Get neighbor page */
 	buf = ReadBufferExtended(index, MAIN_FORKNUM, element->neighborPage, RBM_NORMAL, bas);
@@ -231,7 +229,7 @@ RepairGraphElement(HnswVacuumState * vacuumstate, HnswElement element, HnswEleme
 	UnlockReleaseBuffer(buf);
 
 	/* Update neighbors */
-	HnswUpdateNeighborPages(index, procinfo, collation, element, m, true);
+	HnswUpdateNeighborsOnDisk(index, procinfo, collation, element, m, true, false);
 }
 
 /*
@@ -258,7 +256,7 @@ RepairGraphEntryPoint(HnswVacuumState * vacuumstate)
 		LockPage(index, HNSW_UPDATE_LOCK, ShareLock);
 
 		/* Load element */
-		HnswLoadElement(highestPoint, NULL, NULL, index, vacuumstate->procinfo, vacuumstate->collation, true);
+		HnswLoadElement(highestPoint, NULL, NULL, index, vacuumstate->procinfo, vacuumstate->collation, true, NULL);
 
 		/* Repair if needed */
 		if (NeedsUpdated(vacuumstate, highestPoint))
@@ -287,7 +285,7 @@ RepairGraphEntryPoint(HnswVacuumState * vacuumstate)
 			 * point is outdated and empty, the entry point will be empty
 			 * until an element is repaired.
 			 */
-			HnswUpdateMetaPage(index, HNSW_UPDATE_ENTRY_ALWAYS, highestPoint, InvalidBlockNumber, MAIN_FORKNUM);
+			HnswUpdateMetaPage(index, HNSW_UPDATE_ENTRY_ALWAYS, highestPoint, InvalidBlockNumber, MAIN_FORKNUM, false);
 		}
 		else
 		{
@@ -296,13 +294,13 @@ RepairGraphEntryPoint(HnswVacuumState * vacuumstate)
 			 * is outdated, this can remove connections at higher levels in
 			 * the graph until they are repaired, but this should be fine.
 			 */
-			HnswLoadElement(entryPoint, NULL, NULL, index, vacuumstate->procinfo, vacuumstate->collation, true);
+			HnswLoadElement(entryPoint, NULL, NULL, index, vacuumstate->procinfo, vacuumstate->collation, true, NULL);
 
 			if (NeedsUpdated(vacuumstate, entryPoint))
 			{
 				/* Reset neighbors from previous update */
 				if (highestPoint != NULL)
-					highestPoint->neighbors = NULL;
+					HnswPtrStore((char *) NULL, highestPoint->neighbors, (HnswNeighborArrayPtr *) NULL);
 
 				RepairGraphElement(vacuumstate, entryPoint, highestPoint);
 			}
@@ -420,7 +418,7 @@ RepairGraph(HnswVacuumState * vacuumstate)
 			 * was replaced and highest point was outdated.
 			 */
 			if (entryPoint == NULL || element->level > entryPoint->level)
-				HnswUpdateMetaPage(index, HNSW_UPDATE_ENTRY_GREATER, element, InvalidBlockNumber, MAIN_FORKNUM);
+				HnswUpdateMetaPage(index, HNSW_UPDATE_ENTRY_GREATER, element, InvalidBlockNumber, MAIN_FORKNUM, false);
 
 			/* Release lock */
 			UnlockPage(index, HNSW_UPDATE_LOCK, lockmode);
@@ -478,11 +476,8 @@ MarkDeleted(HnswVacuumState * vacuumstate)
 		/* Update element and neighbors together */
 		for (offno = FirstOffsetNumber; offno <= maxoffno; offno = OffsetNumberNext(offno))
 		{
-			ItemId		itemid = PageGetItemId(page, offno);
-			HnswElementTuple etup = (HnswElementTuple) PageGetItem(page, itemid);
+			HnswElementTuple etup = (HnswElementTuple) PageGetItem(page, PageGetItemId(page, offno));
 			HnswNeighborTuple ntup;
-			Size		etupSize;
-			Size		ntupSize;
 			Buffer		nbuf;
 			Page		npage;
 			BlockNumber neighborPage;
@@ -506,10 +501,6 @@ MarkDeleted(HnswVacuumState * vacuumstate)
 			if (ItemPointerIsValid(&etup->heaptids[0]))
 				continue;
 
-			/* Calculate sizes */
-			etupSize = ItemIdGetLength(itemid);
-			ntupSize = HNSW_NEIGHBOR_TUPLE_SIZE(etup->level, vacuumstate->m);
-
 			/* Get neighbor page */
 			neighborPage = ItemPointerGetBlockNumber(&etup->neighbortid);
 			neighborOffno = ItemPointerGetOffsetNumber(&etup->neighbortid);
@@ -536,13 +527,10 @@ MarkDeleted(HnswVacuumState * vacuumstate)
 			for (int i = 0; i < ntup->count; i++)
 				ItemPointerSetInvalid(&ntup->indextids[i]);
 
-			/* Overwrite element tuple */
-			if (!PageIndexTupleOverwrite(page, offno, (Item) etup, etupSize))
-				elog(ERROR, "failed to add index item to \"%s\"", RelationGetRelationName(index));
-
-			/* Overwrite neighbor tuple */
-			if (!PageIndexTupleOverwrite(npage, neighborOffno, (Item) ntup, ntupSize))
-				elog(ERROR, "failed to add index item to \"%s\"", RelationGetRelationName(index));
+			/*
+			 * We modified the tuples in place, no need to call
+			 * PageIndexTupleOverwrite
+			 */
 
 			/* Commit */
 			GenericXLogFinish(state);
@@ -565,7 +553,7 @@ MarkDeleted(HnswVacuumState * vacuumstate)
 	}
 
 	/* Update insert page last, after everything has been marked as deleted */
-	HnswUpdateMetaPage(index, 0, NULL, insertPage, MAIN_FORKNUM);
+	HnswUpdateMetaPage(index, 0, NULL, insertPage, MAIN_FORKNUM, false);
 }
 
 /*
@@ -575,7 +563,6 @@ static void
 InitVacuumState(HnswVacuumState * vacuumstate, IndexVacuumInfo *info, IndexBulkDeleteResult *stats, IndexBulkDeleteCallback callback, void *callback_state)
 {
 	Relation	index = info->index;
-	HASHCTL		hash_ctl;
 
 	if (stats == NULL)
 		stats = (IndexBulkDeleteResult *) palloc0(sizeof(IndexBulkDeleteResult));
@@ -588,7 +575,7 @@ InitVacuumState(HnswVacuumState * vacuumstate, IndexVacuumInfo *info, IndexBulkD
 	vacuumstate->bas = GetAccessStrategy(BAS_BULKREAD);
 	vacuumstate->procinfo = index_getprocinfo(index, 1, HNSW_DISTANCE_PROC);
 	vacuumstate->collation = index->rd_indcollation[0];
-	vacuumstate->ntup = palloc0(BLCKSZ);
+	vacuumstate->ntup = palloc0(HNSW_TUPLE_ALLOC_SIZE);
 	vacuumstate->tmpCtx = AllocSetContextCreate(CurrentMemoryContext,
 												"Hnsw vacuum temporary context",
 												ALLOCSET_DEFAULT_SIZES);
@@ -597,10 +584,7 @@ InitVacuumState(HnswVacuumState * vacuumstate, IndexVacuumInfo *info, IndexBulkD
 	HnswGetMetaPageInfo(index, &vacuumstate->m, NULL);
 
 	/* Create hash table */
-	hash_ctl.keysize = sizeof(ItemPointerData);
-	hash_ctl.entrysize = sizeof(ItemPointerData);
-	hash_ctl.hcxt = CurrentMemoryContext;
-	vacuumstate->deleted = hash_create("hnswbulkdelete indextids", 256, &hash_ctl, HASH_ELEM | HASH_BLOBS | HASH_CONTEXT);
+	vacuumstate->deleted = tidhash_create(CurrentMemoryContext, 256, NULL);
 }
 
 /*
@@ -609,7 +593,7 @@ InitVacuumState(HnswVacuumState * vacuumstate, IndexVacuumInfo *info, IndexBulkD
 static void
 FreeVacuumState(HnswVacuumState * vacuumstate)
 {
-	hash_destroy(vacuumstate->deleted);
+	tidhash_destroy(vacuumstate->deleted);
 	FreeAccessStrategy(vacuumstate->bas);
 	pfree(vacuumstate->ntup);
 	MemoryContextDelete(vacuumstate->tmpCtx);

src/ivfbuild.c

@@ -2,30 +2,28 @@
 
 #include <float.h>
 
+#include "access/table.h"
+#include "access/tableam.h"
 #include "access/parallel.h"
 #include "access/xact.h"
+#include "bitvec.h"
 #include "catalog/index.h"
 #include "catalog/pg_operator_d.h"
 #include "catalog/pg_type_d.h"
+#include "commands/progress.h"
+#include "halfvec.h"
 #include "ivfflat.h"
 #include "miscadmin.h"
+#include "optimizer/optimizer.h"
 #include "storage/bufmgr.h"
 #include "tcop/tcopprot.h"
 #include "utils/memutils.h"
+#include "vector.h"
 
 #if PG_VERSION_NUM >= 140000
 #include "utils/backend_progress.h"
-#elif PG_VERSION_NUM >= 120000
-#include "pgstat.h"
-#endif
-
-#if PG_VERSION_NUM >= 120000
-#include "access/tableam.h"
-#include "commands/progress.h"
 #else
-#define PROGRESS_CREATEIDX_SUBPHASE 0
-#define PROGRESS_CREATEIDX_TUPLES_TOTAL 0
-#define PROGRESS_CREATEIDX_TUPLES_DONE 0
+#include "pgstat.h"
 #endif
 
 #if PG_VERSION_NUM >= 130000
@@ -34,26 +32,11 @@
 #define CALLBACK_ITEM_POINTER HeapTuple hup
 #endif
 
-#if PG_VERSION_NUM >= 120000
-#define UpdateProgress(index, val) pgstat_progress_update_param(index, val)
-#else
-#define UpdateProgress(index, val) ((void)val)
-#endif
-
 #if PG_VERSION_NUM >= 140000
 #include "utils/backend_status.h"
 #include "utils/wait_event.h"
 #endif
 
-#if PG_VERSION_NUM >= 120000
-#include "access/table.h"
-#include "optimizer/optimizer.h"
-#else
-#include "access/heapam.h"
-#include "optimizer/planner.h"
-#include "pgstat.h"
-#endif
-
 #define PARALLEL_KEY_IVFFLAT_SHARED		UINT64CONST(0xA000000000000001)
 #define PARALLEL_KEY_TUPLESORT			UINT64CONST(0xA000000000000002)
 #define PARALLEL_KEY_IVFFLAT_CENTERS	UINT64CONST(0xA000000000000003)
@@ -77,13 +60,15 @@ AddSample(Datum *values, IvfflatBuildState * buildstate)
 	 */
 	if (buildstate->kmeansnormprocinfo != NULL)
 	{
-		if (!IvfflatNormValue(buildstate->kmeansnormprocinfo, buildstate->collation, &value, buildstate->normvec))
+		if (!IvfflatCheckNorm(buildstate->kmeansnormprocinfo, buildstate->collation, value))
 			return;
+
+		value = IvfflatNormValue(buildstate->typeInfo, buildstate->collation, value);
 	}
 
 	if (samples->length < targsamples)
 	{
-		VectorArraySet(samples, samples->length, DatumGetVector(value));
+		VectorArraySet(samples, samples->length, DatumGetPointer(value));
 		samples->length++;
 	}
 	else
@@ -100,7 +85,7 @@ AddSample(Datum *values, IvfflatBuildState * buildstate)
 #endif
 
 			Assert(k >= 0 && k < targsamples);
-			VectorArraySet(samples, k, DatumGetVector(value));
+			VectorArraySet(samples, k, DatumGetPointer(value));
 		}
 
 		buildstate->rowstoskip -= 1;
@@ -125,7 +110,7 @@ SampleCallback(Relation index, CALLBACK_ITEM_POINTER, Datum *values,
 	oldCtx = MemoryContextSwitchTo(buildstate->tmpCtx);
 
 	/* Add sample */
-	AddSample(values, state);
+	AddSample(values, buildstate);
 
 	/* Reset memory context */
 	MemoryContextSwitchTo(oldCtx);
@@ -150,13 +135,8 @@ SampleRows(IvfflatBuildState * buildstate)
 	{
 		BlockNumber targblock = BlockSampler_Next(&buildstate->bs);
 
-#if PG_VERSION_NUM >= 120000
 		table_index_build_range_scan(buildstate->heap, buildstate->index, buildstate->indexInfo,
 									 false, true, false, targblock, 1, SampleCallback, (void *) buildstate, NULL);
-#else
-		IndexBuildHeapRangeScan(buildstate->heap, buildstate->index, buildstate->indexInfo,
-								false, true, targblock, 1, SampleCallback, (void *) buildstate, NULL);
-#endif
 	}
 }
 
@@ -178,8 +158,10 @@ AddTupleToSort(Relation index, ItemPointer tid, Datum *values, IvfflatBuildState
 	/* Normalize if needed */
 	if (buildstate->normprocinfo != NULL)
 	{
-		if (!IvfflatNormValue(buildstate->normprocinfo, buildstate->collation, &value, buildstate->normvec))
+		if (!IvfflatCheckNorm(buildstate->normprocinfo, buildstate->collation, value))
 			return;
+
+		value = IvfflatNormValue(buildstate->typeInfo, buildstate->collation, value);
 	}
 
 	/* Find the list that minimizes the distance */
@@ -282,16 +264,12 @@ InsertTuples(Relation index, IvfflatBuildState * buildstate, ForkNumber forkNum)
 	IndexTuple	itup = NULL;	/* silence compiler warning */
 	int64		inserted = 0;
 
-#if PG_VERSION_NUM >= 120000
 	TupleTableSlot *slot = MakeSingleTupleTableSlot(buildstate->tupdesc, &TTSOpsMinimalTuple);
-#else
-	TupleTableSlot *slot = MakeSingleTupleTableSlot(buildstate->tupdesc);
-#endif
 	TupleDesc	tupdesc = RelationGetDescr(index);
 
-	UpdateProgress(PROGRESS_CREATEIDX_SUBPHASE, PROGRESS_IVFFLAT_PHASE_LOAD);
+	pgstat_progress_update_param(PROGRESS_CREATEIDX_SUBPHASE, PROGRESS_IVFFLAT_PHASE_LOAD);
 
-	UpdateProgress(PROGRESS_CREATEIDX_TUPLES_TOTAL, buildstate->indtuples);
+	pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_TOTAL, buildstate->indtuples);
 
 	GetNextTuple(buildstate->sortstate, tupdesc, slot, &itup, &list);
 
@@ -327,7 +305,7 @@ InsertTuples(Relation index, IvfflatBuildState * buildstate, ForkNumber forkNum)
 
 			pfree(itup);
 
-			UpdateProgress(PROGRESS_CREATEIDX_TUPLES_DONE, ++inserted);
+			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE, ++inserted);
 
 			GetNextTuple(buildstate->sortstate, tupdesc, slot, &itup, &list);
 		}
@@ -350,16 +328,21 @@ InitBuildState(IvfflatBuildState * buildstate, Relation heap, Relation index, In
 	buildstate->heap = heap;
 	buildstate->index = index;
 	buildstate->indexInfo = indexInfo;
+	buildstate->typeInfo = IvfflatGetTypeInfo(index);
 
 	buildstate->lists = IvfflatGetLists(index);
 	buildstate->dimensions = TupleDescAttr(index->rd_att, 0)->atttypmod;
 
+	/* Disallow varbit since require fixed dimensions */
+	if (TupleDescAttr(index->rd_att, 0)->atttypid == VARBITOID)
+		elog(ERROR, "type not supported for ivfflat index");
+
 	/* Require column to have dimensions to be indexed */
 	if (buildstate->dimensions < 0)
 		elog(ERROR, "column does not have dimensions");
 
-	if (buildstate->dimensions > IVFFLAT_MAX_DIM)
-		elog(ERROR, "column cannot have more than %d dimensions for ivfflat index", IVFFLAT_MAX_DIM);
+	if (buildstate->dimensions > buildstate->typeInfo->maxDimensions)
+		elog(ERROR, "column cannot have more than %d dimensions for ivfflat index", buildstate->typeInfo->maxDimensions);
 
 	buildstate->reltuples = 0;
 	buildstate->indtuples = 0;
@@ -375,27 +358,16 @@ InitBuildState(IvfflatBuildState * buildstate, Relation heap, Relation index, In
 		elog(ERROR, "dimensions must be greater than one for this opclass");
 
 	/* Create tuple description for sorting */
-#if PG_VERSION_NUM >= 120000
 	buildstate->tupdesc = CreateTemplateTupleDesc(3);
-#else
-	buildstate->tupdesc = CreateTemplateTupleDesc(3, false);
-#endif
 	TupleDescInitEntry(buildstate->tupdesc, (AttrNumber) 1, "list", INT4OID, -1, 0);
 	TupleDescInitEntry(buildstate->tupdesc, (AttrNumber) 2, "tid", TIDOID, -1, 0);
 	TupleDescInitEntry(buildstate->tupdesc, (AttrNumber) 3, "vector", RelationGetDescr(index)->attrs[0].atttypid, -1, 0);
 
-#if PG_VERSION_NUM >= 120000
 	buildstate->slot = MakeSingleTupleTableSlot(buildstate->tupdesc, &TTSOpsVirtual);
-#else
-	buildstate->slot = MakeSingleTupleTableSlot(buildstate->tupdesc);
-#endif
 
-	buildstate->centers = VectorArrayInit(buildstate->lists, buildstate->dimensions);
+	buildstate->centers = VectorArrayInit(buildstate->lists, buildstate->dimensions, buildstate->typeInfo->itemSize(buildstate->dimensions));
 	buildstate->listInfo = palloc(sizeof(ListInfo) * buildstate->lists);
 
-	/* Reuse for each tuple */
-	buildstate->normvec = InitVector(buildstate->dimensions);
-
 	buildstate->tmpCtx = AllocSetContextCreate(CurrentMemoryContext,
 											   "Ivfflat build temporary context",
 											   ALLOCSET_DEFAULT_SIZES);
@@ -417,7 +389,6 @@ FreeBuildState(IvfflatBuildState * buildstate)
 {
 	VectorArrayFree(buildstate->centers);
 	pfree(buildstate->listInfo);
-	pfree(buildstate->normvec);
 
 #ifdef IVFFLAT_KMEANS_DEBUG
 	pfree(buildstate->listSums);
@@ -435,7 +406,7 @@ ComputeCenters(IvfflatBuildState * buildstate)
 {
 	int			numSamples;
 
-	UpdateProgress(PROGRESS_CREATEIDX_SUBPHASE, PROGRESS_IVFFLAT_PHASE_KMEANS);
+	pgstat_progress_update_param(PROGRESS_CREATEIDX_SUBPHASE, PROGRESS_IVFFLAT_PHASE_KMEANS);
 
 	/* Target 50 samples per list, with at least 10000 samples */
 	/* The number of samples has a large effect on index build time */
@@ -449,7 +420,7 @@ ComputeCenters(IvfflatBuildState * buildstate)
 
 	/* Sample rows */
 	/* TODO Ensure within maintenance_work_mem */
-	buildstate->samples = VectorArrayInit(numSamples, buildstate->dimensions);
+	buildstate->samples = VectorArrayInit(numSamples, buildstate->dimensions, buildstate->centers->itemsize);
 	if (buildstate->heap != NULL)
 	{
 		SampleRows(buildstate);
@@ -464,7 +435,7 @@ ComputeCenters(IvfflatBuildState * buildstate)
 	}
 
 	/* Calculate centers */
-	IvfflatBench("k-means", IvfflatKmeans(buildstate->index, buildstate->samples, buildstate->centers));
+	IvfflatBench("k-means", IvfflatKmeans(buildstate->index, buildstate->samples, buildstate->centers, buildstate->typeInfo));
 
 	/* Free samples before we allocate more memory */
 	VectorArrayFree(buildstate->samples);
@@ -509,8 +480,8 @@ CreateListPages(Relation index, VectorArray centers, int dimensions,
 	Size		listSize;
 	IvfflatList list;
 
-	listSize = MAXALIGN(IVFFLAT_LIST_SIZE(dimensions));
-	list = palloc(listSize);
+	listSize = MAXALIGN(IVFFLAT_LIST_SIZE(centers->itemsize));
+	list = palloc0(listSize);
 
 	buf = IvfflatNewBuffer(index, forkNum);
 	IvfflatInitRegisterPage(index, &buf, &page, &state);
@@ -519,10 +490,13 @@ CreateListPages(Relation index, VectorArray centers, int dimensions,
 	{
 		OffsetNumber offno;
 
+		/* Zero memory for each list */
+		MemSet(list, 0, listSize);
+
 		/* Load list */
 		list->startPage = InvalidBlockNumber;
 		list->insertPage = InvalidBlockNumber;
-		memcpy(&list->center, VectorArrayGet(centers, i), VECTOR_SIZE(dimensions));
+		memcpy(&list->center, VectorArrayGet(centers, i), VARSIZE_ANY(VectorArrayGet(centers, i)));
 
 		/* Ensure free space */
 		if (PageGetFreeSpace(page) < listSize)
@@ -543,10 +517,10 @@ CreateListPages(Relation index, VectorArray centers, int dimensions,
 	pfree(list);
 }
 
+#ifdef IVFFLAT_KMEANS_DEBUG
 /*
  * Print k-means metrics
  */
-#ifdef IVFFLAT_KMEANS_DEBUG
 static void
 PrintKmeansMetrics(IvfflatBuildState * buildstate)
 {
@@ -627,15 +601,11 @@ ParallelHeapScan(IvfflatBuildState * buildstate)
  * Perform a worker's portion of a parallel sort
  */
 static void
-IvfflatParallelScanAndSort(IvfflatSpool * ivfspool, IvfflatShared * ivfshared, Sharedsort *sharedsort, Vector * ivfcenters, int sortmem, bool progress)
+IvfflatParallelScanAndSort(IvfflatSpool * ivfspool, IvfflatShared * ivfshared, Sharedsort *sharedsort, char *ivfcenters, int sortmem, bool progress)
 {
 	SortCoordinate coordinate;
 	IvfflatBuildState buildstate;
-#if PG_VERSION_NUM >= 120000
 	TableScanDesc scan;
-#else
-	HeapScanDesc scan;
-#endif
 	double		reltuples;
 	IndexInfo  *indexInfo;
 
@@ -655,22 +625,15 @@ IvfflatParallelScanAndSort(IvfflatSpool * ivfspool, IvfflatShared * ivfshared, S
 	indexInfo = BuildIndexInfo(ivfspool->index);
 	indexInfo->ii_Concurrent = ivfshared->isconcurrent;
 	InitBuildState(&buildstate, ivfspool->heap, ivfspool->index, indexInfo);
-	memcpy(buildstate.centers->items, ivfcenters, VECTOR_SIZE(buildstate.centers->dim) * buildstate.centers->maxlen);
+	memcpy(buildstate.centers->items, ivfcenters, buildstate.centers->itemsize * buildstate.centers->maxlen);
 	buildstate.centers->length = buildstate.centers->maxlen;
 	ivfspool->sortstate = tuplesort_begin_heap(buildstate.tupdesc, 1, attNums, sortOperators, sortCollations, nullsFirstFlags, sortmem, coordinate, false);
 	buildstate.sortstate = ivfspool->sortstate;
-#if PG_VERSION_NUM >= 120000
 	scan = table_beginscan_parallel(ivfspool->heap,
 									ParallelTableScanFromIvfflatShared(ivfshared));
 	reltuples = table_index_build_scan(ivfspool->heap, ivfspool->index, indexInfo,
 									   true, progress, BuildCallback,
 									   (void *) &buildstate, scan);
-#else
-	scan = heap_beginscan_parallel(ivfspool->heap, &ivfshared->heapdesc);
-	reltuples = IndexBuildHeapScan(ivfspool->heap, ivfspool->index, indexInfo,
-								   true, BuildCallback,
-								   (void *) &buildstate, scan);
-#endif
 
 	/* Execute this worker's part of the sort */
 	tuplesort_performsort(ivfspool->sortstate);
@@ -710,7 +673,7 @@ IvfflatParallelBuildMain(dsm_segment *seg, shm_toc *toc)
 	IvfflatSpool *ivfspool;
 	IvfflatShared *ivfshared;
 	Sharedsort *sharedsort;
-	Vector	   *ivfcenters;
+	char	   *ivfcenters;
 	Relation	heapRel;
 	Relation	indexRel;
 	LOCKMODE	heapLockmode;
@@ -740,11 +703,7 @@ IvfflatParallelBuildMain(dsm_segment *seg, shm_toc *toc)
 	}
 
 	/* Open relations within worker */
-#if PG_VERSION_NUM >= 120000
 	heapRel = table_open(ivfshared->heaprelid, heapLockmode);
-#else
-	heapRel = heap_open(ivfshared->heaprelid, heapLockmode);
-#endif
 	indexRel = index_open(ivfshared->indexrelid, indexLockmode);
 
 	/* Initialize worker's own spool */
@@ -764,11 +723,7 @@ IvfflatParallelBuildMain(dsm_segment *seg, shm_toc *toc)
 
 	/* Close relations within worker */
 	index_close(indexRel, indexLockmode);
-#if PG_VERSION_NUM >= 120000
 	table_close(heapRel, heapLockmode);
-#else
-	heap_close(heapRel, heapLockmode);
-#endif
 }
 
 /*
@@ -793,19 +748,7 @@ IvfflatEndParallel(IvfflatLeader * ivfleader)
 static Size
 ParallelEstimateShared(Relation heap, Snapshot snapshot)
 {
-#if PG_VERSION_NUM >= 120000
 	return add_size(BUFFERALIGN(sizeof(IvfflatShared)), table_parallelscan_estimate(heap, snapshot));
-#else
-	if (!IsMVCCSnapshot(snapshot))
-	{
-		Assert(snapshot == SnapshotAny);
-		return sizeof(IvfflatShared);
-	}
-
-	return add_size(offsetof(IvfflatShared, heapdesc) +
-					offsetof(ParallelHeapScanDescData, phs_snapshot_data),
-					EstimateSnapshotSpace(snapshot));
-#endif
 }
 
 /*
@@ -844,7 +787,7 @@ IvfflatBeginParallel(IvfflatBuildState * buildstate, bool isconcurrent, int requ
 	Size		estcenters;
 	IvfflatShared *ivfshared;
 	Sharedsort *sharedsort;
-	Vector	   *ivfcenters;
+	char	   *ivfcenters;
 	IvfflatLeader *ivfleader = (IvfflatLeader *) palloc0(sizeof(IvfflatLeader));
 	bool		leaderparticipates = true;
 	int			querylen;
@@ -856,11 +799,7 @@ IvfflatBeginParallel(IvfflatBuildState * buildstate, bool isconcurrent, int requ
 	/* Enter parallel mode and create context */
 	EnterParallelMode();
 	Assert(request > 0);
-#if PG_VERSION_NUM >= 120000
 	pcxt = CreateParallelContext("vector", "IvfflatParallelBuildMain", request);
-#else
-	pcxt = CreateParallelContext("vector", "IvfflatParallelBuildMain", request, true);
-#endif
 
 	scantuplesortstates = leaderparticipates ? request + 1 : request;
 
@@ -875,7 +814,7 @@ IvfflatBeginParallel(IvfflatBuildState * buildstate, bool isconcurrent, int requ
 	shm_toc_estimate_chunk(&pcxt->estimator, estivfshared);
 	estsort = tuplesort_estimate_shared(scantuplesortstates);
 	shm_toc_estimate_chunk(&pcxt->estimator, estsort);
-	estcenters = VECTOR_SIZE(buildstate->dimensions) * buildstate->lists;
+	estcenters = buildstate->centers->itemsize * buildstate->centers->maxlen;
 	shm_toc_estimate_chunk(&pcxt->estimator, estcenters);
 	shm_toc_estimate_keys(&pcxt->estimator, 3);
 
@@ -918,20 +857,16 @@ IvfflatBeginParallel(IvfflatBuildState * buildstate, bool isconcurrent, int requ
 #ifdef IVFFLAT_KMEANS_DEBUG
 	ivfshared->inertia = 0;
 #endif
-#if PG_VERSION_NUM >= 120000
 	table_parallelscan_initialize(buildstate->heap,
 								  ParallelTableScanFromIvfflatShared(ivfshared),
 								  snapshot);
-#else
-	heap_parallelscan_initialize(&ivfshared->heapdesc, buildstate->heap, snapshot);
-#endif
 
 	/* Store shared tuplesort-private state, for which we reserved space */
 	sharedsort = (Sharedsort *) shm_toc_allocate(pcxt->toc, estsort);
 	tuplesort_initialize_shared(sharedsort, scantuplesortstates,
 								pcxt->seg);
 
-	ivfcenters = (Vector *) shm_toc_allocate(pcxt->toc, estcenters);
+	ivfcenters = shm_toc_allocate(pcxt->toc, estcenters);
 	memcpy(ivfcenters, buildstate->centers->items, estcenters);
 
 	shm_toc_insert(pcxt->toc, PARALLEL_KEY_IVFFLAT_SHARED, ivfshared);
@@ -995,7 +930,7 @@ AssignTuples(IvfflatBuildState * buildstate)
 	Oid			sortCollations[] = {InvalidOid};
 	bool		nullsFirstFlags[] = {false};
 
-	UpdateProgress(PROGRESS_CREATEIDX_SUBPHASE, PROGRESS_IVFFLAT_PHASE_ASSIGN);
+	pgstat_progress_update_param(PROGRESS_CREATEIDX_SUBPHASE, PROGRESS_IVFFLAT_PHASE_ASSIGN);
 
 	/* Calculate parallel workers */
 	if (buildstate->heap != NULL)
@@ -1023,15 +958,8 @@ AssignTuples(IvfflatBuildState * buildstate)
 		if (buildstate->ivfleader)
 			buildstate->reltuples = ParallelHeapScan(buildstate);
 		else
-		{
-#if PG_VERSION_NUM >= 120000
 			buildstate->reltuples = table_index_build_scan(buildstate->heap, buildstate->index, buildstate->indexInfo,
 														   true, true, BuildCallback, (void *) buildstate, NULL);
-#else
-			buildstate->reltuples = IndexBuildHeapScan(buildstate->heap, buildstate->index, buildstate->indexInfo,
-													   true, BuildCallback, (void *) buildstate, NULL);
-#endif
-		}
 
 #ifdef IVFFLAT_KMEANS_DEBUG
 		PrintKmeansMetrics(buildstate);
@@ -1078,6 +1006,10 @@ BuildIndex(Relation heap, Relation index, IndexInfo *indexInfo,
 	CreateListPages(index, buildstate->centers, buildstate->dimensions, buildstate->lists, forkNum, &buildstate->listInfo);
 	CreateEntryPages(buildstate, forkNum);
 
+	/* Write WAL for initialization fork since GenericXLog functions do not */
+	if (forkNum == INIT_FORKNUM)
+		log_newpage_range(index, forkNum, 0, RelationGetNumberOfBlocksInFork(index, forkNum), true);
+
 	FreeBuildState(buildstate);
 }
 

src/ivfflat.c

@@ -3,14 +3,16 @@
 #include <float.h>
 
 #include "access/amapi.h"
+#include "access/reloptions.h"
+#include "commands/progress.h"
 #include "commands/vacuum.h"
 #include "ivfflat.h"
 #include "utils/guc.h"
 #include "utils/selfuncs.h"
 #include "utils/spccache.h"
 
-#if PG_VERSION_NUM >= 120000
-#include "commands/progress.h"
+#if PG_VERSION_NUM < 150000
+#define MarkGUCPrefixReserved(x) EmitWarningsOnPlaceholders(x)
 #endif
 
 int			ivfflat_probes;
@@ -33,12 +35,13 @@ IvfflatInit(void)
 	DefineCustomIntVariable("ivfflat.probes", "Sets the number of probes",
 							"Valid range is 1..lists.", &ivfflat_probes,
 							IVFFLAT_DEFAULT_PROBES, IVFFLAT_MIN_LISTS, IVFFLAT_MAX_LISTS, PGC_USERSET, 0, NULL, NULL, NULL);
+
+	MarkGUCPrefixReserved("ivfflat");
 }
 
 /*
  * Get the name of index build phase
  */
-#if PG_VERSION_NUM >= 120000
 static char *
 ivfflatbuildphasename(int64 phasenum)
 {
@@ -56,7 +59,6 @@ ivfflatbuildphasename(int64 phasenum)
 			return NULL;
 	}
 }
-#endif
 
 /*
  * Estimate the cost of an index scan
@@ -72,9 +74,6 @@ ivfflatcostestimate(PlannerInfo *root, IndexPath *path, double loop_count,
 	double		ratio;
 	double		spc_seq_page_cost;
 	Relation	index;
-#if PG_VERSION_NUM < 120000
-	List	   *qinfos;
-#endif
 
 	/* Never use index without order */
 	if (path->indexorderbys == NULL)
@@ -105,12 +104,7 @@ ivfflatcostestimate(PlannerInfo *root, IndexPath *path, double loop_count,
 	 */
 	costs.numIndexTuples = path->indexinfo->tuples * ratio;
 
-#if PG_VERSION_NUM >= 120000
 	genericcostestimate(root, path, loop_count, &costs);
-#else
-	qinfos = deconstruct_indexquals(path);
-	genericcostestimate(root, path, loop_count, qinfos, &costs);
-#endif
 
 	get_tablespace_page_costs(path->indexinfo->reltablespace, NULL, &spc_seq_page_cost);
 
@@ -187,14 +181,14 @@ ivfflatvalidate(Oid opclassoid)
  *
  * See https://www.postgresql.org/docs/current/index-api.html
  */
-PGDLLEXPORT PG_FUNCTION_INFO_V1(ivfflathandler);
+FUNCTION_PREFIX PG_FUNCTION_INFO_V1(ivfflathandler);
 Datum
 ivfflathandler(PG_FUNCTION_ARGS)
 {
 	IndexAmRoutine *amroutine = makeNode(IndexAmRoutine);
 
 	amroutine->amstrategies = 0;
-	amroutine->amsupport = 4;
+	amroutine->amsupport = 5;
 #if PG_VERSION_NUM >= 130000
 	amroutine->amoptsprocnum = 0;
 #endif
@@ -227,9 +221,7 @@ ivfflathandler(PG_FUNCTION_ARGS)
 	amroutine->amcostestimate = ivfflatcostestimate;
 	amroutine->amoptions = ivfflatoptions;
 	amroutine->amproperty = NULL;	/* TODO AMPROP_DISTANCE_ORDERABLE */
-#if PG_VERSION_NUM >= 120000
 	amroutine->ambuildphasename = ivfflatbuildphasename;
-#endif
 	amroutine->amvalidate = ivfflatvalidate;
 #if PG_VERSION_NUM >= 140000
 	amroutine->amadjustmembers = NULL;

src/ivfflat.h

@@ -3,9 +3,10 @@
 
 #include "postgres.h"
 
+#include "access/genam.h"
 #include "access/generic_xlog.h"
 #include "access/parallel.h"
-#include "access/reloptions.h"
+#include "lib/pairingheap.h"
 #include "nodes/execnodes.h"
 #include "port.h"				/* for random() */
 #include "utils/sampling.h"
@@ -16,10 +17,6 @@
 #include "common/pg_prng.h"
 #endif
 
-#if PG_VERSION_NUM < 120000
-#include "access/relscan.h"
-#endif
-
 #ifdef IVFFLAT_BENCH
 #include "portability/instr_time.h"
 #endif
@@ -31,6 +28,7 @@
 #define IVFFLAT_NORM_PROC 2
 #define IVFFLAT_KMEANS_DISTANCE_PROC 3
 #define IVFFLAT_KMEANS_NORM_PROC 4
+#define IVFFLAT_TYPE_INFO_PROC 5
 
 #define IVFFLAT_VERSION	1
 #define IVFFLAT_MAGIC_NUMBER 0x14FF1A7
@@ -52,7 +50,7 @@
 #define PROGRESS_IVFFLAT_PHASE_ASSIGN	3
 #define PROGRESS_IVFFLAT_PHASE_LOAD		4
 
-#define IVFFLAT_LIST_SIZE(_dim)	(offsetof(IvfflatListData, center) + VECTOR_SIZE(_dim))
+#define IVFFLAT_LIST_SIZE(size)	(offsetof(IvfflatListData, center) + size)
 
 #define IvfflatPageGetOpaque(page)	((IvfflatPageOpaque) PageGetSpecialPointer(page))
 #define IvfflatPageGetMeta(page)	((IvfflatMetaPageData *) PageGetContents(page))
@@ -88,7 +86,8 @@ typedef struct VectorArrayData
 	int			length;
 	int			maxlen;
 	int			dim;
-	Vector	   *items;
+	Size		itemsize;
+	char	   *items;
 }			VectorArrayData;
 
 typedef VectorArrayData * VectorArray;
@@ -135,16 +134,10 @@ typedef struct IvfflatShared
 #ifdef IVFFLAT_KMEANS_DEBUG
 	double		inertia;
 #endif
-
-#if PG_VERSION_NUM < 120000
-	ParallelHeapScanDescData heapdesc;	/* must come last */
-#endif
 }			IvfflatShared;
 
-#if PG_VERSION_NUM >= 120000
 #define ParallelTableScanFromIvfflatShared(shared) \
 	(ParallelTableScanDesc) ((char *) (shared) + BUFFERALIGN(sizeof(IvfflatShared)))
-#endif
 
 typedef struct IvfflatLeader
 {
@@ -153,15 +146,25 @@ typedef struct IvfflatLeader
 	IvfflatShared *ivfshared;
 	Sharedsort *sharedsort;
 	Snapshot	snapshot;
-	Vector	   *ivfcenters;
+	char	   *ivfcenters;
 }			IvfflatLeader;
 
+typedef struct IvfflatTypeInfo
+{
+	int			maxDimensions;
+	Datum		(*normalize) (PG_FUNCTION_ARGS);
+	Size		(*itemSize) (int dimensions);
+	void		(*updateCenter) (Pointer v, int dimensions, float *x);
+	void		(*sumCenter) (Pointer v, float *x);
+}			IvfflatTypeInfo;
+
 typedef struct IvfflatBuildState
 {
 	/* Info */
 	Relation	heap;
 	Relation	index;
 	IndexInfo  *indexInfo;
+	const		IvfflatTypeInfo *typeInfo;
 
 	/* Settings */
 	int			dimensions;
@@ -181,7 +184,6 @@ typedef struct IvfflatBuildState
 	VectorArray samples;
 	VectorArray centers;
 	ListInfo   *listInfo;
-	Vector	   *normvec;
 
 #ifdef IVFFLAT_KMEANS_DEBUG
 	double		inertia;
@@ -243,6 +245,7 @@ typedef struct IvfflatScanList
 
 typedef struct IvfflatScanOpaqueData
 {
+	const		IvfflatTypeInfo *typeInfo;
 	int			probes;
 	int			dimensions;
 	bool		first;
@@ -257,6 +260,7 @@ typedef struct IvfflatScanOpaqueData
 	FmgrInfo   *procinfo;
 	FmgrInfo   *normprocinfo;
 	Oid			collation;
+	Datum		(*distfunc) (FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2);
 
 	/* Lists */
 	pairingheap *listQueue;
@@ -265,18 +269,29 @@ typedef struct IvfflatScanOpaqueData
 
 typedef IvfflatScanOpaqueData * IvfflatScanOpaque;
 
-#define VECTOR_ARRAY_SIZE(_length, _dim) (sizeof(VectorArrayData) + (_length) * VECTOR_SIZE(_dim))
-#define VECTOR_ARRAY_OFFSET(_arr, _offset) ((char*) (_arr)->items + (_offset) * VECTOR_SIZE((_arr)->dim))
-#define VectorArrayGet(_arr, _offset) ((Vector *) VECTOR_ARRAY_OFFSET(_arr, _offset))
-#define VectorArraySet(_arr, _offset, _val) memcpy(VECTOR_ARRAY_OFFSET(_arr, _offset), _val, VECTOR_SIZE((_arr)->dim))
+#define VECTOR_ARRAY_SIZE(_length, _size) (sizeof(VectorArrayData) + (_length) * MAXALIGN(_size))
+
+/* Use functions instead of macros to avoid double evaluation */
+
+static inline Pointer
+VectorArrayGet(VectorArray arr, int offset)
+{
+	return ((char *) arr->items) + (offset * arr->itemsize);
+}
+
+static inline void
+VectorArraySet(VectorArray arr, int offset, Pointer val)
+{
+	memcpy(VectorArrayGet(arr, offset), val, VARSIZE_ANY(val));
+}
 
 /* Methods */
-VectorArray VectorArrayInit(int maxlen, int dimensions);
+VectorArray VectorArrayInit(int maxlen, int dimensions, Size itemsize);
 void		VectorArrayFree(VectorArray arr);
-void		PrintVectorArray(char *msg, VectorArray arr);
-void		IvfflatKmeans(Relation index, VectorArray samples, VectorArray centers);
+void		IvfflatKmeans(Relation index, VectorArray samples, VectorArray centers, const IvfflatTypeInfo * typeInfo);
 FmgrInfo   *IvfflatOptionalProcInfo(Relation index, uint16 procnum);
-bool		IvfflatNormValue(FmgrInfo *procinfo, Oid collation, Datum *value, Vector * result);
+Datum		IvfflatNormValue(const IvfflatTypeInfo * typeInfo, Oid collation, Datum value);
+bool		IvfflatCheckNorm(FmgrInfo *procinfo, Oid collation, Datum value);
 int			IvfflatGetLists(Relation index);
 void		IvfflatGetMetaPageInfo(Relation index, int *lists, int *dimensions);
 void		IvfflatUpdateList(Relation index, ListInfo listInfo, BlockNumber insertPage, BlockNumber originalInsertPage, BlockNumber startPage, ForkNumber forkNum);
@@ -286,6 +301,7 @@ Buffer		IvfflatNewBuffer(Relation index, ForkNumber forkNum);
 void		IvfflatInitPage(Buffer buf, Page page);
 void		IvfflatInitRegisterPage(Relation index, Buffer *buf, Page *page, GenericXLogState **state);
 void		IvfflatInit(void);
+const		IvfflatTypeInfo *IvfflatGetTypeInfo(Relation index);
 PGDLLEXPORT void IvfflatParallelBuildMain(dsm_segment *seg, shm_toc *toc);
 
 /* Index access methods */

src/ivfinsert.c

@@ -2,6 +2,7 @@
 
 #include <float.h>
 
+#include "access/generic_xlog.h"
 #include "ivfflat.h"
 #include "storage/bufmgr.h"
 #include "storage/lmgr.h"
@@ -66,6 +67,7 @@ FindInsertPage(Relation index, Datum *values, BlockNumber *insertPage, ListInfo
 static void
 InsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heap_tid, Relation heapRel)
 {
+	const		IvfflatTypeInfo *typeInfo = IvfflatGetTypeInfo(index);
 	IndexTuple	itup;
 	Datum		value;
 	FmgrInfo   *normprocinfo;
@@ -84,10 +86,17 @@ InsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heap_tid, R
 	normprocinfo = IvfflatOptionalProcInfo(index, IVFFLAT_NORM_PROC);
 	if (normprocinfo != NULL)
 	{
-		if (!IvfflatNormValue(normprocinfo, index->rd_indcollation[0], &value, NULL))
+		Oid			collation = index->rd_indcollation[0];
+
+		if (!IvfflatCheckNorm(normprocinfo, collation, value))
 			return;
+
+		value = IvfflatNormValue(typeInfo, collation, value);
 	}
 
+	/* Ensure index is valid */
+	IvfflatGetMetaPageInfo(index, NULL, NULL);
+
 	/* Find the insert page - sets the page and list info */
 	FindInsertPage(index, values, &insertPage, &listInfo);
 	Assert(BlockNumberIsValid(insertPage));

src/ivfkmeans.c

@@ -3,8 +3,15 @@
 #include <float.h>
 #include <math.h>
 
+#include "bitvec.h"
+#include "halfutils.h"
+#include "halfvec.h"
 #include "ivfflat.h"
 #include "miscadmin.h"
+#include "utils/builtins.h"
+#include "utils/datum.h"
+#include "utils/memutils.h"
+#include "vector.h"
 
 /*
  * Initialize with kmeans++
@@ -42,12 +49,12 @@ InitCenters(Relation index, VectorArray samples, VectorArray centers, float *low
 
 		for (j = 0; j < numSamples; j++)
 		{
-			Vector	   *vec = VectorArrayGet(samples, j);
+			Datum		vec = PointerGetDatum(VectorArrayGet(samples, j));
 			double		distance;
 
 			/* Only need to compute distance for new center */
 			/* TODO Use triangle inequality to reduce distance calculations */
-			distance = DatumGetFloat8(FunctionCall2Coll(procinfo, collation, PointerGetDatum(vec), PointerGetDatum(VectorArrayGet(centers, i))));
+			distance = DatumGetFloat8(FunctionCall2Coll(procinfo, collation, vec, PointerGetDatum(VectorArrayGet(centers, i))));
 
 			/* Set lower bound */
 			lowerBound[j * numCenters + i] = distance;
@@ -82,73 +89,166 @@ InitCenters(Relation index, VectorArray samples, VectorArray centers, float *low
 }
 
 /*
- * Apply norm to vector
- */
-static inline void
-ApplyNorm(FmgrInfo *normprocinfo, Oid collation, Vector * vec)
-{
-	double		norm = DatumGetFloat8(FunctionCall1Coll(normprocinfo, collation, PointerGetDatum(vec)));
-
-	/* TODO Handle zero norm */
-	if (norm > 0)
-	{
-		for (int i = 0; i < vec->dim; i++)
-			vec->x[i] /= norm;
-	}
-}
-
-/*
- * Compare vectors
- */
-static int
-CompareVectors(const void *a, const void *b)
-{
-	return vector_cmp_internal((Vector *) a, (Vector *) b);
-}
-
-/*
- * Quick approach if we have little data
+ * Norm centers
  */
 static void
-QuickCenters(Relation index, VectorArray samples, VectorArray centers)
+NormCenters(const IvfflatTypeInfo * typeInfo, Oid collation, VectorArray centers)
 {
-	int			dimensions = centers->dim;
-	Oid			collation = index->rd_indcollation[0];
-	FmgrInfo   *normprocinfo = IvfflatOptionalProcInfo(index, IVFFLAT_KMEANS_NORM_PROC);
+	MemoryContext normCtx = AllocSetContextCreate(CurrentMemoryContext,
+												  "Ivfflat norm temporary context",
+												  ALLOCSET_DEFAULT_SIZES);
+	MemoryContext oldCtx = MemoryContextSwitchTo(normCtx);
 
-	/* Copy existing vectors while avoiding duplicates */
-	if (samples->length > 0)
+	for (int j = 0; j < centers->length; j++)
 	{
-		qsort(samples->items, samples->length, VECTOR_SIZE(samples->dim), CompareVectors);
-		for (int i = 0; i < samples->length; i++)
-		{
-			Vector	   *vec = VectorArrayGet(samples, i);
+		Datum		center = PointerGetDatum(VectorArrayGet(centers, j));
+		Datum		newCenter = IvfflatNormValue(typeInfo, collation, center);
+		Size		size = VARSIZE_ANY(DatumGetPointer(newCenter));
 
-			if (i == 0 || CompareVectors(vec, VectorArrayGet(samples, i - 1)) != 0)
-			{
-				VectorArraySet(centers, centers->length, vec);
-				centers->length++;
-			}
-		}
+		if (size > centers->itemsize)
+			elog(ERROR, "safety check failed");
+
+		memcpy(DatumGetPointer(center), DatumGetPointer(newCenter), size);
+		MemoryContextReset(normCtx);
 	}
 
-	/* Fill remaining with random data */
+	MemoryContextSwitchTo(oldCtx);
+	MemoryContextDelete(normCtx);
+}
+
+/*
+ * Quick approach if we have no data
+ */
+static void
+RandomCenters(Relation index, VectorArray centers, const IvfflatTypeInfo * typeInfo)
+{
+	int			dimensions = centers->dim;
+	FmgrInfo   *normprocinfo = IvfflatOptionalProcInfo(index, IVFFLAT_KMEANS_NORM_PROC);
+	Oid			collation = index->rd_indcollation[0];
+	float	   *x = (float *) palloc(sizeof(float) * dimensions);
+
+	/* Fill with random data */
 	while (centers->length < centers->maxlen)
 	{
-		Vector	   *vec = VectorArrayGet(centers, centers->length);
+		Pointer		center = VectorArrayGet(centers, centers->length);
 
-		SET_VARSIZE(vec, VECTOR_SIZE(dimensions));
-		vec->dim = dimensions;
+		for (int i = 0; i < dimensions; i++)
+			x[i] = (float) RandomDouble();
 
-		for (int j = 0; j < dimensions; j++)
-			vec->x[j] = RandomDouble();
-
-		/* Normalize if needed (only needed for random centers) */
-		if (normprocinfo != NULL)
-			ApplyNorm(normprocinfo, collation, vec);
+		typeInfo->updateCenter(center, dimensions, x);
 
 		centers->length++;
 	}
+
+	if (normprocinfo != NULL)
+		NormCenters(typeInfo, collation, centers);
+}
+
+#ifdef IVFFLAT_MEMORY
+/*
+ * Show memory usage
+ */
+static void
+ShowMemoryUsage(MemoryContext context, Size estimatedSize)
+{
+#if PG_VERSION_NUM >= 130000
+	elog(INFO, "total memory: %zu MB",
+		 MemoryContextMemAllocated(context, true) / (1024 * 1024));
+#else
+	MemoryContextStats(context);
+#endif
+	elog(INFO, "estimated memory: %zu MB", estimatedSize / (1024 * 1024));
+}
+#endif
+
+/*
+ * Sum centers
+ */
+static void
+SumCenters(VectorArray samples, float *agg, int *closestCenters, const IvfflatTypeInfo * typeInfo)
+{
+	for (int j = 0; j < samples->length; j++)
+	{
+		float	   *x = agg + ((int64) closestCenters[j] * samples->dim);
+
+		typeInfo->sumCenter(VectorArrayGet(samples, j), x);
+	}
+}
+
+/*
+ * Update centers
+ */
+static void
+UpdateCenters(float *agg, VectorArray centers, const IvfflatTypeInfo * typeInfo)
+{
+	for (int j = 0; j < centers->length; j++)
+	{
+		float	   *x = agg + ((int64) j * centers->dim);
+
+		typeInfo->updateCenter(VectorArrayGet(centers, j), centers->dim, x);
+	}
+}
+
+/*
+ * Compute new centers
+ */
+static void
+ComputeNewCenters(VectorArray samples, float *agg, VectorArray newCenters, int *centerCounts, int *closestCenters, FmgrInfo *normprocinfo, Oid collation, const IvfflatTypeInfo * typeInfo)
+{
+	int			dimensions = newCenters->dim;
+	int			numCenters = newCenters->length;
+	int			numSamples = samples->length;
+
+	/* Reset sum and count */
+	for (int j = 0; j < numCenters; j++)
+	{
+		float	   *x = agg + ((int64) j * dimensions);
+
+		for (int k = 0; k < dimensions; k++)
+			x[k] = 0.0;
+
+		centerCounts[j] = 0;
+	}
+
+	/* Increment sum of closest center */
+	SumCenters(samples, agg, closestCenters, typeInfo);
+
+	/* Increment count of closest center */
+	for (int j = 0; j < numSamples; j++)
+		centerCounts[closestCenters[j]] += 1;
+
+	/* Divide sum by count */
+	for (int j = 0; j < numCenters; j++)
+	{
+		float	   *x = agg + ((int64) j * dimensions);
+
+		if (centerCounts[j] > 0)
+		{
+			/* Double avoids overflow, but requires more memory */
+			/* TODO Update bounds */
+			for (int k = 0; k < dimensions; k++)
+			{
+				if (isinf(x[k]))
+					x[k] = x[k] > 0 ? FLT_MAX : -FLT_MAX;
+			}
+
+			for (int k = 0; k < dimensions; k++)
+				x[k] /= centerCounts[j];
+		}
+		else
+		{
+			/* TODO Handle empty centers properly */
+			for (int k = 0; k < dimensions; k++)
+				x[k] = RandomDouble();
+		}
+	}
+
+	/* Set new centers */
+	UpdateCenters(agg, newCenters, typeInfo);
+
+	/* Normalize if needed */
+	if (normprocinfo != NULL)
+		NormCenters(typeInfo, collation, newCenters);
 }
 
 /*
@@ -160,19 +260,16 @@ QuickCenters(Relation index, VectorArray samples, VectorArray centers)
  * https://www.aaai.org/Papers/ICML/2003/ICML03-022.pdf
  */
 static void
-ElkanKmeans(Relation index, VectorArray samples, VectorArray centers)
+ElkanKmeans(Relation index, VectorArray samples, VectorArray centers, const IvfflatTypeInfo * typeInfo)
 {
 	FmgrInfo   *procinfo;
 	FmgrInfo   *normprocinfo;
 	Oid			collation;
-	Vector	   *vec;
-	Vector	   *newCenter;
-	int64		j;
-	int64		k;
 	int			dimensions = centers->dim;
 	int			numCenters = centers->maxlen;
 	int			numSamples = samples->length;
 	VectorArray newCenters;
+	float	   *agg;
 	int		   *centerCounts;
 	int		   *closestCenters;
 	float	   *lowerBound;
@@ -182,9 +279,10 @@ ElkanKmeans(Relation index, VectorArray samples, VectorArray centers)
 	float	   *newcdist;
 
 	/* Calculate allocation sizes */
-	Size		samplesSize = VECTOR_ARRAY_SIZE(samples->maxlen, samples->dim);
-	Size		centersSize = VECTOR_ARRAY_SIZE(centers->maxlen, centers->dim);
-	Size		newCentersSize = VECTOR_ARRAY_SIZE(numCenters, dimensions);
+	Size		samplesSize = VECTOR_ARRAY_SIZE(samples->maxlen, samples->itemsize);
+	Size		centersSize = VECTOR_ARRAY_SIZE(centers->maxlen, centers->itemsize);
+	Size		newCentersSize = VECTOR_ARRAY_SIZE(numCenters, centers->itemsize);
+	Size		aggSize = sizeof(float) * (int64) numCenters * dimensions;
 	Size		centerCountsSize = sizeof(int) * numCenters;
 	Size		closestCentersSize = sizeof(int) * numSamples;
 	Size		lowerBoundSize = sizeof(float) * numSamples * numCenters;
@@ -194,7 +292,7 @@ ElkanKmeans(Relation index, VectorArray samples, VectorArray centers)
 	Size		newcdistSize = sizeof(float) * numCenters;
 
 	/* Calculate total size */
-	Size		totalSize = samplesSize + centersSize + newCentersSize + centerCountsSize + closestCentersSize + lowerBoundSize + upperBoundSize + sSize + halfcdistSize + newcdistSize;
+	Size		totalSize = samplesSize + centersSize + newCentersSize + aggSize + centerCountsSize + closestCentersSize + lowerBoundSize + upperBoundSize + sSize + halfcdistSize + newcdistSize;
 
 	/* Check memory requirements */
 	/* Add one to error message to ceil */
@@ -215,6 +313,7 @@ ElkanKmeans(Relation index, VectorArray samples, VectorArray centers)
 
 	/* Allocate space */
 	/* Use float instead of double to save memory */
+	agg = palloc(aggSize);
 	centerCounts = palloc(centerCountsSize);
 	closestCenters = palloc(closestCentersSize);
 	lowerBound = palloc_extended(lowerBoundSize, MCXT_ALLOC_HUGE);
@@ -223,25 +322,25 @@ ElkanKmeans(Relation index, VectorArray samples, VectorArray centers)
 	halfcdist = palloc_extended(halfcdistSize, MCXT_ALLOC_HUGE);
 	newcdist = palloc(newcdistSize);
 
-	newCenters = VectorArrayInit(numCenters, dimensions);
-	for (j = 0; j < numCenters; j++)
-	{
-		vec = VectorArrayGet(newCenters, j);
-		SET_VARSIZE(vec, VECTOR_SIZE(dimensions));
-		vec->dim = dimensions;
-	}
+	/* Initialize new centers */
+	newCenters = VectorArrayInit(numCenters, dimensions, centers->itemsize);
+	newCenters->length = numCenters;
+
+#ifdef IVFFLAT_MEMORY
+	ShowMemoryUsage(MemoryContextGetParent(CurrentMemoryContext));
+#endif
 
 	/* Pick initial centers */
 	InitCenters(index, samples, centers, lowerBound);
 
 	/* Assign each x to its closest initial center c(x) = argmin d(x,c) */
-	for (j = 0; j < numSamples; j++)
+	for (int64 j = 0; j < numSamples; j++)
 	{
 		float		minDistance = FLT_MAX;
 		int			closestCenter = 0;
 
 		/* Find closest center */
-		for (k = 0; k < numCenters; k++)
+		for (int64 k = 0; k < numCenters; k++)
 		{
 			/* TODO Use Lemma 1 in k-means++ initialization */
 			float		distance = lowerBound[j * numCenters + k];
@@ -267,13 +366,13 @@ ElkanKmeans(Relation index, VectorArray samples, VectorArray centers)
 		CHECK_FOR_INTERRUPTS();
 
 		/* Step 1: For all centers, compute distance */
-		for (j = 0; j < numCenters; j++)
+		for (int64 j = 0; j < numCenters; j++)
 		{
-			vec = VectorArrayGet(centers, j);
+			Datum		vec = PointerGetDatum(VectorArrayGet(centers, j));
 
-			for (k = j + 1; k < numCenters; k++)
+			for (int64 k = j + 1; k < numCenters; k++)
 			{
-				float		distance = 0.5 * DatumGetFloat8(FunctionCall2Coll(procinfo, collation, PointerGetDatum(vec), PointerGetDatum(VectorArrayGet(centers, k))));
+				float		distance = 0.5 * DatumGetFloat8(FunctionCall2Coll(procinfo, collation, vec, PointerGetDatum(VectorArrayGet(centers, k))));
 
 				halfcdist[j * numCenters + k] = distance;
 				halfcdist[k * numCenters + j] = distance;
@@ -281,11 +380,11 @@ ElkanKmeans(Relation index, VectorArray samples, VectorArray centers)
 		}
 
 		/* For all centers c, compute s(c) */
-		for (j = 0; j < numCenters; j++)
+		for (int64 j = 0; j < numCenters; j++)
 		{
 			float		minDistance = FLT_MAX;
 
-			for (k = 0; k < numCenters; k++)
+			for (int64 k = 0; k < numCenters; k++)
 			{
 				float		distance;
 
@@ -302,7 +401,7 @@ ElkanKmeans(Relation index, VectorArray samples, VectorArray centers)
 
 		rjreset = iteration != 0;
 
-		for (j = 0; j < numSamples; j++)
+		for (int64 j = 0; j < numSamples; j++)
 		{
 			bool		rj;
 
@@ -312,8 +411,9 @@ ElkanKmeans(Relation index, VectorArray samples, VectorArray centers)
 
 			rj = rjreset;
 
-			for (k = 0; k < numCenters; k++)
+			for (int64 k = 0; k < numCenters; k++)
 			{
+				Datum		vec;
 				float		dxcx;
 
 				/* Step 3: For all remaining points x and centers c */
@@ -326,12 +426,12 @@ ElkanKmeans(Relation index, VectorArray samples, VectorArray centers)
 				if (upperBound[j] <= halfcdist[closestCenters[j] * numCenters + k])
 					continue;
 
-				vec = VectorArrayGet(samples, j);
+				vec = PointerGetDatum(VectorArrayGet(samples, j));
 
 				/* Step 3a */
 				if (rj)
 				{
-					dxcx = DatumGetFloat8(FunctionCall2Coll(procinfo, collation, PointerGetDatum(vec), PointerGetDatum(VectorArrayGet(centers, closestCenters[j]))));
+					dxcx = DatumGetFloat8(FunctionCall2Coll(procinfo, collation, vec, PointerGetDatum(VectorArrayGet(centers, closestCenters[j]))));
 
 					/* d(x,c(x)) computed, which is a form of d(x,c) */
 					lowerBound[j * numCenters + closestCenters[j]] = dxcx;
@@ -345,7 +445,7 @@ ElkanKmeans(Relation index, VectorArray samples, VectorArray centers)
 				/* Step 3b */
 				if (dxcx > lowerBound[j * numCenters + k] || dxcx > halfcdist[closestCenters[j] * numCenters + k])
 				{
-					float		dxc = DatumGetFloat8(FunctionCall2Coll(procinfo, collation, PointerGetDatum(vec), PointerGetDatum(VectorArrayGet(centers, k))));
+					float		dxc = DatumGetFloat8(FunctionCall2Coll(procinfo, collation, vec, PointerGetDatum(VectorArrayGet(centers, k))));
 
 					/* d(x,c) calculated */
 					lowerBound[j * numCenters + k] = dxc;
@@ -364,66 +464,15 @@ ElkanKmeans(Relation index, VectorArray samples, VectorArray centers)
 		}
 
 		/* Step 4: For each center c, let m(c) be mean of all points assigned */
-		for (j = 0; j < numCenters; j++)
-		{
-			vec = VectorArrayGet(newCenters, j);
-			for (k = 0; k < dimensions; k++)
-				vec->x[k] = 0.0;
-
-			centerCounts[j] = 0;
-		}
-
-		for (j = 0; j < numSamples; j++)
-		{
-			int			closestCenter;
-
-			vec = VectorArrayGet(samples, j);
-			closestCenter = closestCenters[j];
-
-			/* Increment sum and count of closest center */
-			newCenter = VectorArrayGet(newCenters, closestCenter);
-			for (k = 0; k < dimensions; k++)
-				newCenter->x[k] += vec->x[k];
-
-			centerCounts[closestCenter] += 1;
-		}
-
-		for (j = 0; j < numCenters; j++)
-		{
-			vec = VectorArrayGet(newCenters, j);
-
-			if (centerCounts[j] > 0)
-			{
-				/* Double avoids overflow, but requires more memory */
-				/* TODO Update bounds */
-				for (k = 0; k < dimensions; k++)
-				{
-					if (isinf(vec->x[k]))
-						vec->x[k] = vec->x[k] > 0 ? FLT_MAX : -FLT_MAX;
-				}
-
-				for (k = 0; k < dimensions; k++)
-					vec->x[k] /= centerCounts[j];
-			}
-			else
-			{
-				/* TODO Handle empty centers properly */
-				for (k = 0; k < dimensions; k++)
-					vec->x[k] = RandomDouble();
-			}
-
-			/* Normalize if needed */
-			if (normprocinfo != NULL)
-				ApplyNorm(normprocinfo, collation, vec);
-		}
+		ComputeNewCenters(samples, agg, newCenters, centerCounts, closestCenters, normprocinfo, collation, typeInfo);
 
 		/* Step 5 */
-		for (j = 0; j < numCenters; j++)
+		for (int j = 0; j < numCenters; j++)
 			newcdist[j] = DatumGetFloat8(FunctionCall2Coll(procinfo, collation, PointerGetDatum(VectorArrayGet(centers, j)), PointerGetDatum(VectorArrayGet(newCenters, j))));
 
-		for (j = 0; j < numSamples; j++)
+		for (int64 j = 0; j < numSamples; j++)
 		{
-			for (k = 0; k < numCenters; k++)
+			for (int64 k = 0; k < numCenters; k++)
 			{
 				float		distance = lowerBound[j * numCenters + k] - newcdist[k];
 
@@ -436,77 +485,78 @@ ElkanKmeans(Relation index, VectorArray samples, VectorArray centers)
 
 		/* Step 6 */
 		/* We reset r(x) before Step 3 in the next iteration */
-		for (j = 0; j < numSamples; j++)
+		for (int j = 0; j < numSamples; j++)
 			upperBound[j] += newcdist[closestCenters[j]];
 
 		/* Step 7 */
-		for (j = 0; j < numCenters; j++)
+		for (int j = 0; j < numCenters; j++)
 			VectorArraySet(centers, j, VectorArrayGet(newCenters, j));
 
 		if (changes == 0 && iteration != 0)
 			break;
 	}
+}
 
-	VectorArrayFree(newCenters);
-	pfree(centerCounts);
-	pfree(closestCenters);
-	pfree(lowerBound);
-	pfree(upperBound);
-	pfree(s);
-	pfree(halfcdist);
-	pfree(newcdist);
+/*
+ * Ensure no NaN or infinite values
+ */
+static void
+CheckElements(VectorArray centers, const IvfflatTypeInfo * typeInfo)
+{
+	float	   *scratch = palloc(sizeof(float) * centers->dim);
+
+	for (int i = 0; i < centers->length; i++)
+	{
+		for (int j = 0; j < centers->dim; j++)
+			scratch[j] = 0;
+
+		/* /fp:fast may not propagate NaN with MSVC, but that's alright */
+		typeInfo->sumCenter(VectorArrayGet(centers, i), scratch);
+
+		for (int j = 0; j < centers->dim; j++)
+		{
+			if (isnan(scratch[j]))
+				elog(ERROR, "NaN detected. Please report a bug.");
+
+			if (isinf(scratch[j]))
+				elog(ERROR, "Infinite value detected. Please report a bug.");
+		}
+	}
+}
+
+/*
+ * Ensure no zero vectors for cosine distance
+ */
+static void
+CheckNorms(VectorArray centers, Relation index)
+{
+	/* Check NORM_PROC instead of KMEANS_NORM_PROC */
+	FmgrInfo   *normprocinfo = IvfflatOptionalProcInfo(index, IVFFLAT_NORM_PROC);
+	Oid			collation = index->rd_indcollation[0];
+
+	if (normprocinfo == NULL)
+		return;
+
+	for (int i = 0; i < centers->length; i++)
+	{
+		double		norm = DatumGetFloat8(FunctionCall1Coll(normprocinfo, collation, PointerGetDatum(VectorArrayGet(centers, i))));
+
+		if (norm == 0)
+			elog(ERROR, "Zero norm detected. Please report a bug.");
+	}
 }
 
 /*
  * Detect issues with centers
  */
 static void
-CheckCenters(Relation index, VectorArray centers)
+CheckCenters(Relation index, VectorArray centers, const IvfflatTypeInfo * typeInfo)
 {
-	FmgrInfo   *normprocinfo;
-
 	if (centers->length != centers->maxlen)
 		elog(ERROR, "Not enough centers. Please report a bug.");
 
-	/* Ensure no NaN or infinite values */
-	for (int i = 0; i < centers->length; i++)
-	{
-		Vector	   *vec = VectorArrayGet(centers, i);
-
-		for (int j = 0; j < vec->dim; j++)
-		{
-			if (isnan(vec->x[j]))
-				elog(ERROR, "NaN detected. Please report a bug.");
-
-			if (isinf(vec->x[j]))
-				elog(ERROR, "Infinite value detected. Please report a bug.");
-		}
-	}
-
-	/* Ensure no duplicate centers */
-	/* Fine to sort in-place */
-	qsort(centers->items, centers->length, VECTOR_SIZE(centers->dim), CompareVectors);
-	for (int i = 1; i < centers->length; i++)
-	{
-		if (CompareVectors(VectorArrayGet(centers, i), VectorArrayGet(centers, i - 1)) == 0)
-			elog(ERROR, "Duplicate centers detected. Please report a bug.");
-	}
-
-	/* Ensure no zero vectors for cosine distance */
-	/* Check NORM_PROC instead of KMEANS_NORM_PROC */
-	normprocinfo = IvfflatOptionalProcInfo(index, IVFFLAT_NORM_PROC);
-	if (normprocinfo != NULL)
-	{
-		Oid			collation = index->rd_indcollation[0];
-
-		for (int i = 0; i < centers->length; i++)
-		{
-			double		norm = DatumGetFloat8(FunctionCall1Coll(normprocinfo, collation, PointerGetDatum(VectorArrayGet(centers, i))));
-
-			if (norm == 0)
-				elog(ERROR, "Zero norm detected. Please report a bug.");
-		}
-	}
+	CheckElements(centers, typeInfo);
+	CheckNorms(centers, index);
 }
 
 /*
@@ -514,12 +564,20 @@ CheckCenters(Relation index, VectorArray centers)
  * We use spherical k-means for inner product and cosine
  */
 void
-IvfflatKmeans(Relation index, VectorArray samples, VectorArray centers)
+IvfflatKmeans(Relation index, VectorArray samples, VectorArray centers, const IvfflatTypeInfo * typeInfo)
 {
-	if (samples->length <= centers->maxlen)
-		QuickCenters(index, samples, centers);
-	else
-		ElkanKmeans(index, samples, centers);
+	MemoryContext kmeansCtx = AllocSetContextCreate(CurrentMemoryContext,
+													"Ivfflat kmeans temporary context",
+													ALLOCSET_DEFAULT_SIZES);
+	MemoryContext oldCtx = MemoryContextSwitchTo(kmeansCtx);
 
-	CheckCenters(index, centers);
+	if (samples->length == 0)
+		RandomCenters(index, centers, typeInfo);
+	else
+		ElkanKmeans(index, samples, centers, typeInfo);
+
+	CheckCenters(index, centers, typeInfo);
+
+	MemoryContextSwitchTo(oldCtx);
+	MemoryContextDelete(kmeansCtx);
 }

src/ivfscan.c

@@ -5,6 +5,7 @@
 #include "access/relscan.h"
 #include "catalog/pg_operator_d.h"
 #include "catalog/pg_type_d.h"
+#include "lib/pairingheap.h"
 #include "ivfflat.h"
 #include "miscadmin.h"
 #include "pgstat.h"
@@ -55,7 +56,7 @@ GetScanLists(IndexScanDesc scan, Datum value)
 			double		distance;
 
 			/* Use procinfo from the index instead of scan key for performance */
-			distance = DatumGetFloat8(FunctionCall2Coll(so->procinfo, so->collation, PointerGetDatum(&list->center), value));
+			distance = DatumGetFloat8(so->distfunc(so->procinfo, so->collation, PointerGetDatum(&list->center), value));
 
 			if (listCount < so->probes)
 			{
@@ -105,12 +106,7 @@ GetScanItems(IndexScanDesc scan, Datum value)
 	IvfflatScanOpaque so = (IvfflatScanOpaque) scan->opaque;
 	TupleDesc	tupdesc = RelationGetDescr(scan->indexRelation);
 	double		tuples = 0;
-
-#if PG_VERSION_NUM >= 120000
 	TupleTableSlot *slot = MakeSingleTupleTableSlot(so->tupdesc, &TTSOpsVirtual);
-#else
-	TupleTableSlot *slot = MakeSingleTupleTableSlot(so->tupdesc);
-#endif
 
 	/*
 	 * Reuse same set of shared buffers for scan
@@ -153,7 +149,7 @@ GetScanItems(IndexScanDesc scan, Datum value)
 				 * performance
 				 */
 				ExecClearTuple(slot);
-				slot->tts_values[0] = FunctionCall2Coll(so->procinfo, so->collation, datum, value);
+				slot->tts_values[0] = so->distfunc(so->procinfo, so->collation, datum, value);
 				slot->tts_isnull[0] = false;
 				slot->tts_values[1] = PointerGetDatum(&itup->t_tid);
 				slot->tts_isnull[1] = false;
@@ -181,6 +177,46 @@ GetScanItems(IndexScanDesc scan, Datum value)
 	tuplesort_performsort(so->sortstate);
 }
 
+/*
+ * Zero distance
+ */
+static Datum
+ZeroDistance(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2)
+{
+	return Float8GetDatum(0.0);
+}
+
+/*
+ * Get scan value
+ */
+static Datum
+GetScanValue(IndexScanDesc scan)
+{
+	IvfflatScanOpaque so = (IvfflatScanOpaque) scan->opaque;
+	Datum		value;
+
+	if (scan->orderByData->sk_flags & SK_ISNULL)
+	{
+		value = PointerGetDatum(NULL);
+		so->distfunc = ZeroDistance;
+	}
+	else
+	{
+		value = scan->orderByData->sk_argument;
+		so->distfunc = FunctionCall2Coll;
+
+		/* Value should not be compressed or toasted */
+		Assert(!VARATT_IS_COMPRESSED(DatumGetPointer(value)));
+		Assert(!VARATT_IS_EXTENDED(DatumGetPointer(value)));
+
+		/* Normalize if needed */
+		if (so->normprocinfo != NULL)
+			value = IvfflatNormValue(so->typeInfo, so->collation, value);
+	}
+
+	return value;
+}
+
 /*
  * Prepare for an index scan
  */
@@ -206,6 +242,7 @@ ivfflatbeginscan(Relation index, int nkeys, int norderbys)
 		probes = lists;
 
 	so = (IvfflatScanOpaque) palloc(offsetof(IvfflatScanOpaqueData, lists) + probes * sizeof(IvfflatScanList));
+	so->typeInfo = IvfflatGetTypeInfo(index);
 	so->first = true;
 	so->probes = probes;
 	so->dimensions = dimensions;
@@ -216,22 +253,14 @@ ivfflatbeginscan(Relation index, int nkeys, int norderbys)
 	so->collation = index->rd_indcollation[0];
 
 	/* Create tuple description for sorting */
-#if PG_VERSION_NUM >= 120000
 	so->tupdesc = CreateTemplateTupleDesc(2);
-#else
-	so->tupdesc = CreateTemplateTupleDesc(2, false);
-#endif
 	TupleDescInitEntry(so->tupdesc, (AttrNumber) 1, "distance", FLOAT8OID, -1, 0);
 	TupleDescInitEntry(so->tupdesc, (AttrNumber) 2, "heaptid", TIDOID, -1, 0);
 
 	/* Prep sort */
 	so->sortstate = tuplesort_begin_heap(so->tupdesc, 1, attNums, sortOperators, sortCollations, nullsFirstFlags, work_mem, NULL, false);
 
-#if PG_VERSION_NUM >= 120000
 	so->slot = MakeSingleTupleTableSlot(so->tupdesc, &TTSOpsMinimalTuple);
-#else
-	so->slot = MakeSingleTupleTableSlot(so->tupdesc);
-#endif
 
 	so->listQueue = pairingheap_allocate(CompareLists, scan);
 
@@ -293,21 +322,7 @@ ivfflatgettuple(IndexScanDesc scan, ScanDirection dir)
 		if (!IsMVCCSnapshot(scan->xs_snapshot))
 			elog(ERROR, "non-MVCC snapshots are not supported with ivfflat");
 
-		if (scan->orderByData->sk_flags & SK_ISNULL)
-			value = PointerGetDatum(InitVector(so->dimensions));
-		else
-		{
-			value = scan->orderByData->sk_argument;
-
-			/* Value should not be compressed or toasted */
-			Assert(!VARATT_IS_COMPRESSED(DatumGetPointer(value)));
-			Assert(!VARATT_IS_EXTENDED(DatumGetPointer(value)));
-
-			/* Fine if normalization fails */
-			if (so->normprocinfo != NULL)
-				IvfflatNormValue(so->normprocinfo, so->collation, &value, NULL);
-		}
-
+		value = GetScanValue(scan);
 		IvfflatBench("GetScanLists", GetScanLists(scan, value));
 		IvfflatBench("GetScanItems", GetScanItems(scan, value));
 		so->first = false;
@@ -321,12 +336,8 @@ ivfflatgettuple(IndexScanDesc scan, ScanDirection dir)
 	{
 		ItemPointer heaptid = (ItemPointer) DatumGetPointer(slot_getattr(so->slot, 2, &so->isnull));
 
-#if PG_VERSION_NUM >= 120000
 		scan->xs_heaptid = *heaptid;
-#else
-		scan->xs_ctup.t_self = *heaptid;
-#endif
-
+		scan->xs_recheck = false;
 		scan->xs_recheckorderby = false;
 		return true;
 	}

src/ivfutils.c

@@ -1,21 +1,30 @@
 #include "postgres.h"
 
+#include "access/generic_xlog.h"
+#include "bitvec.h"
+#include "catalog/pg_type.h"
+#include "fmgr.h"
+#include "halfutils.h"
+#include "halfvec.h"
 #include "ivfflat.h"
 #include "storage/bufmgr.h"
-#include "vector.h"
 
 /*
  * Allocate a vector array
  */
 VectorArray
-VectorArrayInit(int maxlen, int dimensions)
+VectorArrayInit(int maxlen, int dimensions, Size itemsize)
 {
 	VectorArray res = palloc(sizeof(VectorArrayData));
 
+	/* Ensure items are aligned to prevent UB */
+	itemsize = MAXALIGN(itemsize);
+
 	res->length = 0;
 	res->maxlen = maxlen;
 	res->dim = dimensions;
-	res->items = palloc_extended(maxlen * VECTOR_SIZE(dimensions), MCXT_ALLOC_ZERO | MCXT_ALLOC_HUGE);
+	res->itemsize = itemsize;
+	res->items = palloc_extended(maxlen * itemsize, MCXT_ALLOC_ZERO | MCXT_ALLOC_HUGE);
 	return res;
 }
 
@@ -29,16 +38,6 @@ VectorArrayFree(VectorArray arr)
 	pfree(arr);
 }
 
-/*
- * Print vector array - useful for debugging
- */
-void
-PrintVectorArray(char *msg, VectorArray arr)
-{
-	for (int i = 0; i < arr->length; i++)
-		PrintVector(msg, VectorArrayGet(arr, i));
-}
-
 /*
  * Get the number of lists in the index
  */
@@ -66,34 +65,21 @@ IvfflatOptionalProcInfo(Relation index, uint16 procnum)
 }
 
 /*
- * Divide by the norm
- *
- * Returns false if value should not be indexed
- *
- * The caller needs to free the pointer stored in value
- * if it's different than the original value
+ * Normalize value
+ */
+Datum
+IvfflatNormValue(const IvfflatTypeInfo * typeInfo, Oid collation, Datum value)
+{
+	return DirectFunctionCall1Coll(typeInfo->normalize, collation, value);
+}
+
+/*
+ * Check if non-zero norm
  */
 bool
-IvfflatNormValue(FmgrInfo *procinfo, Oid collation, Datum *value, Vector * result)
+IvfflatCheckNorm(FmgrInfo *procinfo, Oid collation, Datum value)
 {
-	double		norm = DatumGetFloat8(FunctionCall1Coll(procinfo, collation, *value));
-
-	if (norm > 0)
-	{
-		Vector	   *v = DatumGetVector(*value);
-
-		if (result == NULL)
-			result = InitVector(v->dim);
-
-		for (int i = 0; i < v->dim; i++)
-			result->x[i] = v->x[i] / norm;
-
-		*value = PointerGetDatum(result);
-
-		return true;
-	}
-
-	return false;
+	return DatumGetFloat8(FunctionCall1Coll(procinfo, collation, value)) > 0;
 }
 
 /*
@@ -184,7 +170,11 @@ IvfflatGetMetaPageInfo(Relation index, int *lists, int *dimensions)
 	page = BufferGetPage(buf);
 	metap = IvfflatPageGetMeta(page);
 
-	*lists = metap->lists;
+	if (unlikely(metap->magicNumber != IVFFLAT_MAGIC_NUMBER))
+		elog(ERROR, "ivfflat index is not valid");
+
+	if (lists != NULL)
+		*lists = metap->lists;
 
 	if (dimensions != NULL)
 		*dimensions = metap->dimensions;
@@ -238,3 +228,146 @@ IvfflatUpdateList(Relation index, ListInfo listInfo,
 		UnlockReleaseBuffer(buf);
 	}
 }
+
+PGDLLEXPORT Datum l2_normalize(PG_FUNCTION_ARGS);
+PGDLLEXPORT Datum halfvec_l2_normalize(PG_FUNCTION_ARGS);
+PGDLLEXPORT Datum sparsevec_l2_normalize(PG_FUNCTION_ARGS);
+
+static Size
+VectorItemSize(int dimensions)
+{
+	return VECTOR_SIZE(dimensions);
+}
+
+static Size
+HalfvecItemSize(int dimensions)
+{
+	return HALFVEC_SIZE(dimensions);
+}
+
+static Size
+BitItemSize(int dimensions)
+{
+	return VARBITTOTALLEN(dimensions);
+}
+
+static void
+VectorUpdateCenter(Pointer v, int dimensions, float *x)
+{
+	Vector	   *vec = (Vector *) v;
+
+	SET_VARSIZE(vec, VECTOR_SIZE(dimensions));
+	vec->dim = dimensions;
+
+	for (int k = 0; k < dimensions; k++)
+		vec->x[k] = x[k];
+}
+
+static void
+HalfvecUpdateCenter(Pointer v, int dimensions, float *x)
+{
+	HalfVector *vec = (HalfVector *) v;
+
+	SET_VARSIZE(vec, HALFVEC_SIZE(dimensions));
+	vec->dim = dimensions;
+
+	for (int k = 0; k < dimensions; k++)
+		vec->x[k] = Float4ToHalfUnchecked(x[k]);
+}
+
+static void
+BitUpdateCenter(Pointer v, int dimensions, float *x)
+{
+	VarBit	   *vec = (VarBit *) v;
+	unsigned char *nx = VARBITS(vec);
+
+	SET_VARSIZE(vec, VARBITTOTALLEN(dimensions));
+	VARBITLEN(vec) = dimensions;
+
+	for (uint32 k = 0; k < VARBITBYTES(vec); k++)
+		nx[k] = 0;
+
+	for (int k = 0; k < dimensions; k++)
+		nx[k / 8] |= (x[k] > 0.5 ? 1 : 0) << (7 - (k % 8));
+}
+
+static void
+VectorSumCenter(Pointer v, float *x)
+{
+	Vector	   *vec = (Vector *) v;
+
+	for (int k = 0; k < vec->dim; k++)
+		x[k] += vec->x[k];
+}
+
+static void
+HalfvecSumCenter(Pointer v, float *x)
+{
+	HalfVector *vec = (HalfVector *) v;
+
+	for (int k = 0; k < vec->dim; k++)
+		x[k] += HalfToFloat4(vec->x[k]);
+}
+
+static void
+BitSumCenter(Pointer v, float *x)
+{
+	VarBit	   *vec = (VarBit *) v;
+
+	for (int k = 0; k < VARBITLEN(vec); k++)
+		x[k] += (float) (((VARBITS(vec)[k / 8]) >> (7 - (k % 8))) & 0x01);
+}
+
+/*
+ * Get type info
+ */
+const		IvfflatTypeInfo *
+IvfflatGetTypeInfo(Relation index)
+{
+	FmgrInfo   *procinfo = IvfflatOptionalProcInfo(index, IVFFLAT_TYPE_INFO_PROC);
+
+	if (procinfo == NULL)
+	{
+		static const IvfflatTypeInfo typeInfo = {
+			.maxDimensions = IVFFLAT_MAX_DIM,
+			.normalize = l2_normalize,
+			.itemSize = VectorItemSize,
+			.updateCenter = VectorUpdateCenter,
+			.sumCenter = VectorSumCenter
+		};
+
+		return (&typeInfo);
+	}
+	else
+		return (const IvfflatTypeInfo *) DatumGetPointer(FunctionCall0Coll(procinfo, InvalidOid));
+}
+
+FUNCTION_PREFIX PG_FUNCTION_INFO_V1(ivfflat_halfvec_support);
+Datum
+ivfflat_halfvec_support(PG_FUNCTION_ARGS)
+{
+	static const IvfflatTypeInfo typeInfo = {
+		.maxDimensions = IVFFLAT_MAX_DIM * 2,
+		.normalize = halfvec_l2_normalize,
+		.itemSize = HalfvecItemSize,
+		.updateCenter = HalfvecUpdateCenter,
+		.sumCenter = HalfvecSumCenter
+	};
+
+	PG_RETURN_POINTER(&typeInfo);
+};
+
+FUNCTION_PREFIX PG_FUNCTION_INFO_V1(ivfflat_bit_support);
+Datum
+ivfflat_bit_support(PG_FUNCTION_ARGS)
+{
+	static const IvfflatTypeInfo typeInfo = {
+		.maxDimensions = IVFFLAT_MAX_DIM * 32,
+		.normalize = NULL,
+		.itemSize = BitItemSize,
+		.updateCenter = BitUpdateCenter,
+		.sumCenter = BitSumCenter
+	};
+
+	PG_RETURN_POINTER(&typeInfo);
+};

src/ivfvacuum.c

@@ -1,5 +1,6 @@
 #include "postgres.h"
 
+#include "access/generic_xlog.h"
 #include "commands/vacuum.h"
 #include "ivfflat.h"
 #include "storage/bufmgr.h"

src/sparsevec.h

@@ -0,0 +1,40 @@
+#ifndef SPARSEVEC_H
+#define SPARSEVEC_H
+
+#define SPARSEVEC_MAX_DIM 1000000000
+#define SPARSEVEC_MAX_NNZ 16000
+
+#define DatumGetSparseVector(x)		((SparseVector *) PG_DETOAST_DATUM(x))
+#define PG_GETARG_SPARSEVEC_P(x)	DatumGetSparseVector(PG_GETARG_DATUM(x))
+#define PG_RETURN_SPARSEVEC_P(x)	PG_RETURN_POINTER(x)
+
+/*
+ * Indices use 0-based numbering for the on-disk (and binary) format (consistent with C)
+ * and are always sorted. Values come after indices.
+ */
+typedef struct SparseVector
+{
+	int32		vl_len_;		/* varlena header (do not touch directly!) */
+	int32		dim;			/* number of dimensions */
+	int32		nnz;			/* number of non-zero elements */
+	int32		unused;			/* reserved for future use, always zero */
+	int32		indices[FLEXIBLE_ARRAY_MEMBER];
+}			SparseVector;
+
+/* Use functions instead of macros to avoid double evaluation */
+
+static inline Size
+SPARSEVEC_SIZE(int nnz)
+{
+	return offsetof(SparseVector, indices) + (nnz * sizeof(int32)) + (nnz * sizeof(float));
+}
+
+static inline float *
+SPARSEVEC_VALUES(SparseVector * x)
+{
+	return (float *) (((char *) x) + offsetof(SparseVector, indices) + (x->nnz * sizeof(int32)));
+}
+
+SparseVector *InitSparseVector(int dim, int nnz);
+
+#endif

src/vector.c

@@ -2,15 +2,22 @@
 
 #include <math.h>
 
+#include "bitutils.h"
+#include "bitvec.h"
 #include "catalog/pg_type.h"
+#include "common/shortest_dec.h"
 #include "fmgr.h"
+#include "halfutils.h"
+#include "halfvec.h"
 #include "hnsw.h"
 #include "ivfflat.h"
 #include "lib/stringinfo.h"
 #include "libpq/pqformat.h"
 #include "port.h"				/* for strtof() */
+#include "sparsevec.h"
 #include "utils/array.h"
 #include "utils/builtins.h"
+#include "utils/float.h"
 #include "utils/lsyscache.h"
 #include "utils/numeric.h"
 #include "vector.h"
@@ -19,13 +26,6 @@
 #include "varatt.h"
 #endif
 
-#if PG_VERSION_NUM >= 120000
-#include "common/shortest_dec.h"
-#include "utils/float.h"
-#else
-#include <float.h>
-#endif
-
 #if PG_VERSION_NUM < 130000
 #define TYPALIGN_DOUBLE 'd'
 #define TYPALIGN_INT 'i'
@@ -34,6 +34,12 @@
 #define STATE_DIMS(x) (ARR_DIMS(x)[0] - 1)
 #define CreateStateDatums(dim) palloc(sizeof(Datum) * (dim + 1))
 
+#if defined(USE_TARGET_CLONES) && !defined(__FMA__)
+#define VECTOR_TARGET_CLONES __attribute__((target_clones("default", "fma")))
+#else
+#define VECTOR_TARGET_CLONES
+#endif
+
 PG_MODULE_MAGIC;
 
 /*
@@ -43,6 +49,8 @@ PGDLLEXPORT void _PG_init(void);
 void
 _PG_init(void)
 {
+	BitvecInit();
+	HalfvecInit();
 	HnswInit();
 	IvfflatInit();
 }
@@ -173,34 +181,41 @@ float_underflow_error(void)
 /*
  * Convert textual representation to internal representation
  */
-PGDLLEXPORT PG_FUNCTION_INFO_V1(vector_in);
+FUNCTION_PREFIX PG_FUNCTION_INFO_V1(vector_in);
 Datum
 vector_in(PG_FUNCTION_ARGS)
 {
-	char	   *str = PG_GETARG_CSTRING(0);
+	char	   *lit = PG_GETARG_CSTRING(0);
 	int32		typmod = PG_GETARG_INT32(2);
 	float		x[VECTOR_MAX_DIM];
 	int			dim = 0;
-	char	   *pt;
-	char	   *stringEnd;
+	char	   *pt = lit;
 	Vector	   *result;
-	char	   *lit = pstrdup(str);
 
-	while (vector_isspace(*str))
-		str++;
+	while (vector_isspace(*pt))
+		pt++;
 
-	if (*str != '[')
+	if (*pt != '[')
 		ereport(ERROR,
 				(errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
-				 errmsg("malformed vector literal: \"%s\"", lit),
+				 errmsg("invalid input syntax for type vector: \"%s\"", lit),
 				 errdetail("Vector contents must start with \"[\".")));
 
-	str++;
-	pt = strtok(str, ",");
-	stringEnd = pt;
+	pt++;
 
-	while (pt != NULL && *stringEnd != ']')
+	while (vector_isspace(*pt))
+		pt++;
+
+	if (*pt == ']')
+		ereport(ERROR,
+				(errcode(ERRCODE_DATA_EXCEPTION),
+				 errmsg("vector must have at least 1 dimension")));
+
+	for (;;)
 	{
+		float		val;
+		char	   *stringEnd;
+
 		if (dim == VECTOR_MAX_DIM)
 			ereport(ERROR,
 					(errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
@@ -215,61 +230,55 @@ vector_in(PG_FUNCTION_ARGS)
 					(errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
 					 errmsg("invalid input syntax for type vector: \"%s\"", lit)));
 
+		errno = 0;
+
 		/* Use strtof like float4in to avoid a double-rounding problem */
-		x[dim] = strtof(pt, &stringEnd);
-		CheckElement(x[dim]);
-		dim++;
+		/* Postgres sets LC_NUMERIC to C on startup */
+		val = strtof(pt, &stringEnd);
 
 		if (stringEnd == pt)
 			ereport(ERROR,
 					(errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
 					 errmsg("invalid input syntax for type vector: \"%s\"", lit)));
 
-		while (vector_isspace(*stringEnd))
-			stringEnd++;
+		/* Check for range error like float4in */
+		if (errno == ERANGE && isinf(val))
+			ereport(ERROR,
+					(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
+					 errmsg("\"%s\" is out of range for type vector", pnstrdup(pt, stringEnd - pt))));
 
-		if (*stringEnd != '\0' && *stringEnd != ']')
+		CheckElement(val);
+		x[dim++] = val;
+
+		pt = stringEnd;
+
+		while (vector_isspace(*pt))
+			pt++;
+
+		if (*pt == ',')
+			pt++;
+		else if (*pt == ']')
+		{
+			pt++;
+			break;
+		}
+		else
 			ereport(ERROR,
 					(errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
 					 errmsg("invalid input syntax for type vector: \"%s\"", lit)));
-
-		pt = strtok(NULL, ",");
 	}
 
-	if (stringEnd == NULL || *stringEnd != ']')
-		ereport(ERROR,
-				(errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
-				 errmsg("malformed vector literal: \"%s\"", lit),
-				 errdetail("Unexpected end of input.")));
-
-	stringEnd++;
-
 	/* Only whitespace is allowed after the closing brace */
-	while (vector_isspace(*stringEnd))
-		stringEnd++;
+	while (vector_isspace(*pt))
+		pt++;
 
-	if (*stringEnd != '\0')
+	if (*pt != '\0')
 		ereport(ERROR,
 				(errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
-				 errmsg("malformed vector literal: \"%s\"", lit),
+				 errmsg("invalid input syntax for type vector: \"%s\"", lit),
 				 errdetail("Junk after closing right brace.")));
 
-	/* Ensure no consecutive delimiters since strtok skips */
-	for (pt = lit + 1; *pt != '\0'; pt++)
-	{
-		if (pt[-1] == ',' && *pt == ',')
-			ereport(ERROR,
-					(errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
-					 errmsg("malformed vector literal: \"%s\"", lit)));
-	}
-
-	if (dim < 1)
-		ereport(ERROR,
-				(errcode(ERRCODE_DATA_EXCEPTION),
-				 errmsg("vector must have at least 1 dimension")));
-
-	pfree(lit);
-
+	CheckDim(dim);
 	CheckExpectedDim(typmod, dim);
 
 	result = InitVector(dim);
@@ -279,10 +288,13 @@ vector_in(PG_FUNCTION_ARGS)
 	PG_RETURN_POINTER(result);
 }
 
+#define AppendChar(ptr, c) (*(ptr)++ = (c))
+#define AppendFloat(ptr, f) ((ptr) += float_to_shortest_decimal_bufn((f), (ptr)))
+
 /*
  * Convert internal representation to textual representation
  */
-PGDLLEXPORT PG_FUNCTION_INFO_V1(vector_out);
+FUNCTION_PREFIX PG_FUNCTION_INFO_V1(vector_out);
 Datum
 vector_out(PG_FUNCTION_ARGS)
 {
@@ -290,16 +302,6 @@ vector_out(PG_FUNCTION_ARGS)
 	int			dim = vector->dim;
 	char	   *buf;
 	char	   *ptr;
-	int			n;
-
-#if PG_VERSION_NUM < 120000
-	int			ndig = FLT_DIG + extra_float_digits;
-
-	if (ndig < 1)
-		ndig = 1;
-
-#define FLOAT_SHORTEST_DECIMAL_LEN (ndig + 10)
-#endif
 
 	/*
 	 * Need:
@@ -314,25 +316,17 @@ vector_out(PG_FUNCTION_ARGS)
 	buf = (char *) palloc(FLOAT_SHORTEST_DECIMAL_LEN * dim + 2);
 	ptr = buf;
 
-	*ptr = '[';
-	ptr++;
+	AppendChar(ptr, '[');
+
 	for (int i = 0; i < dim; i++)
 	{
 		if (i > 0)
-		{
-			*ptr = ',';
-			ptr++;
-		}
+			AppendChar(ptr, ',');
 
-#if PG_VERSION_NUM >= 120000
-		n = float_to_shortest_decimal_bufn(vector->x[i], ptr);
-#else
-		n = sprintf(ptr, "%.*g", ndig, vector->x[i]);
-#endif
-		ptr += n;
+		AppendFloat(ptr, vector->x[i]);
 	}
-	*ptr = ']';
-	ptr++;
+
+	AppendChar(ptr, ']');
 	*ptr = '\0';
 
 	PG_FREE_IF_COPY(vector, 0);
@@ -354,7 +348,7 @@ PrintVector(char *msg, Vector * vector)
 /*
  * Convert type modifier
  */
-PGDLLEXPORT PG_FUNCTION_INFO_V1(vector_typmod_in);
+FUNCTION_PREFIX PG_FUNCTION_INFO_V1(vector_typmod_in);
 Datum
 vector_typmod_in(PG_FUNCTION_ARGS)
 {
@@ -385,7 +379,7 @@ vector_typmod_in(PG_FUNCTION_ARGS)
 /*
  * Convert external binary representation to internal representation
  */
-PGDLLEXPORT PG_FUNCTION_INFO_V1(vector_recv);
+FUNCTION_PREFIX PG_FUNCTION_INFO_V1(vector_recv);
 Datum
 vector_recv(PG_FUNCTION_ARGS)
 {
@@ -419,7 +413,7 @@ vector_recv(PG_FUNCTION_ARGS)
 /*
  * Convert internal representation to the external binary representation
  */
-PGDLLEXPORT PG_FUNCTION_INFO_V1(vector_send);
+FUNCTION_PREFIX PG_FUNCTION_INFO_V1(vector_send);
 Datum
 vector_send(PG_FUNCTION_ARGS)
 {
@@ -439,7 +433,7 @@ vector_send(PG_FUNCTION_ARGS)
  * Convert vector to vector
  * This is needed to check the type modifier
  */
-PGDLLEXPORT PG_FUNCTION_INFO_V1(vector);
+FUNCTION_PREFIX PG_FUNCTION_INFO_V1(vector);
 Datum
 vector(PG_FUNCTION_ARGS)
 {
@@ -454,7 +448,7 @@ vector(PG_FUNCTION_ARGS)
 /*
  * Convert array to vector
  */
-PGDLLEXPORT PG_FUNCTION_INFO_V1(array_to_vector);
+FUNCTION_PREFIX PG_FUNCTION_INFO_V1(array_to_vector);
 Datum
 array_to_vector(PG_FUNCTION_ARGS)
 {
@@ -528,7 +522,7 @@ array_to_vector(PG_FUNCTION_ARGS)
 /*
  * Convert vector to float4[]
  */
-PGDLLEXPORT PG_FUNCTION_INFO_V1(vector_to_float4);
+FUNCTION_PREFIX PG_FUNCTION_INFO_V1(vector_to_float4);
 Datum
 vector_to_float4(PG_FUNCTION_ARGS)
 {
@@ -549,131 +543,150 @@ vector_to_float4(PG_FUNCTION_ARGS)
 	PG_RETURN_POINTER(result);
 }
 
+/*
+ * Convert half vector to vector
+ */
+FUNCTION_PREFIX PG_FUNCTION_INFO_V1(halfvec_to_vector);
+Datum
+halfvec_to_vector(PG_FUNCTION_ARGS)
+{
+	HalfVector *vec = PG_GETARG_HALFVEC_P(0);
+	int32		typmod = PG_GETARG_INT32(1);
+	Vector	   *result;
+
+	CheckDim(vec->dim);
+	CheckExpectedDim(typmod, vec->dim);
+
+	result = InitVector(vec->dim);
+
+	for (int i = 0; i < vec->dim; i++)
+		result->x[i] = HalfToFloat4(vec->x[i]);
+
+	PG_RETURN_POINTER(result);
+}
+
+VECTOR_TARGET_CLONES static float
+VectorL2SquaredDistance(int dim, float *ax, float *bx)
+{
+	float		distance = 0.0;
+
+	/* Auto-vectorized */
+	for (int i = 0; i < dim; i++)
+	{
+		float		diff = ax[i] - bx[i];
+
+		distance += diff * diff;
+	}
+
+	return distance;
+}
+
 /*
  * Get the L2 distance between vectors
  */
-PGDLLEXPORT PG_FUNCTION_INFO_V1(l2_distance);
+FUNCTION_PREFIX PG_FUNCTION_INFO_V1(l2_distance);
 Datum
 l2_distance(PG_FUNCTION_ARGS)
 {
 	Vector	   *a = PG_GETARG_VECTOR_P(0);
 	Vector	   *b = PG_GETARG_VECTOR_P(1);
-	float	   *ax = a->x;
-	float	   *bx = b->x;
-	float		distance = 0.0;
-	float		diff;
 
 	CheckDims(a, b);
 
-	/* Auto-vectorized */
-	for (int i = 0; i < a->dim; i++)
-	{
-		diff = ax[i] - bx[i];
-		distance += diff * diff;
-	}
-
-	PG_RETURN_FLOAT8(sqrt((double) distance));
+	PG_RETURN_FLOAT8(sqrt((double) VectorL2SquaredDistance(a->dim, a->x, b->x)));
 }
 
 /*
  * Get the L2 squared distance between vectors
  * This saves a sqrt calculation
  */
-PGDLLEXPORT PG_FUNCTION_INFO_V1(vector_l2_squared_distance);
+FUNCTION_PREFIX PG_FUNCTION_INFO_V1(vector_l2_squared_distance);
 Datum
 vector_l2_squared_distance(PG_FUNCTION_ARGS)
 {
 	Vector	   *a = PG_GETARG_VECTOR_P(0);
 	Vector	   *b = PG_GETARG_VECTOR_P(1);
-	float	   *ax = a->x;
-	float	   *bx = b->x;
-	float		distance = 0.0;
-	float		diff;
 
 	CheckDims(a, b);
 
-	/* Auto-vectorized */
-	for (int i = 0; i < a->dim; i++)
-	{
-		diff = ax[i] - bx[i];
-		distance += diff * diff;
-	}
+	PG_RETURN_FLOAT8((double) VectorL2SquaredDistance(a->dim, a->x, b->x));
+}
 
-	PG_RETURN_FLOAT8((double) distance);
+VECTOR_TARGET_CLONES static float
+VectorInnerProduct(int dim, float *ax, float *bx)
+{
+	float		distance = 0.0;
+
+	/* Auto-vectorized */
+	for (int i = 0; i < dim; i++)
+		distance += ax[i] * bx[i];
+
+	return distance;
 }
 
 /*
  * Get the inner product of two vectors
  */
-PGDLLEXPORT PG_FUNCTION_INFO_V1(inner_product);
+FUNCTION_PREFIX PG_FUNCTION_INFO_V1(inner_product);
 Datum
 inner_product(PG_FUNCTION_ARGS)
 {
 	Vector	   *a = PG_GETARG_VECTOR_P(0);
 	Vector	   *b = PG_GETARG_VECTOR_P(1);
-	float	   *ax = a->x;
-	float	   *bx = b->x;
-	float		distance = 0.0;
 
 	CheckDims(a, b);
 
-	/* Auto-vectorized */
-	for (int i = 0; i < a->dim; i++)
-		distance += ax[i] * bx[i];
-
-	PG_RETURN_FLOAT8((double) distance);
+	PG_RETURN_FLOAT8((double) VectorInnerProduct(a->dim, a->x, b->x));
 }
 
 /*
  * Get the negative inner product of two vectors
  */
-PGDLLEXPORT PG_FUNCTION_INFO_V1(vector_negative_inner_product);
+FUNCTION_PREFIX PG_FUNCTION_INFO_V1(vector_negative_inner_product);
 Datum
 vector_negative_inner_product(PG_FUNCTION_ARGS)
 {
 	Vector	   *a = PG_GETARG_VECTOR_P(0);
 	Vector	   *b = PG_GETARG_VECTOR_P(1);
-	float	   *ax = a->x;
-	float	   *bx = b->x;
-	float		distance = 0.0;
 
 	CheckDims(a, b);
 
-	/* Auto-vectorized */
-	for (int i = 0; i < a->dim; i++)
-		distance += ax[i] * bx[i];
-
-	PG_RETURN_FLOAT8((double) distance * -1);
+	PG_RETURN_FLOAT8((double) -VectorInnerProduct(a->dim, a->x, b->x));
 }
 
-/*
- * Get the cosine distance between two vectors
- */
-PGDLLEXPORT PG_FUNCTION_INFO_V1(cosine_distance);
-Datum
-cosine_distance(PG_FUNCTION_ARGS)
+VECTOR_TARGET_CLONES static double
+VectorCosineSimilarity(int dim, float *ax, float *bx)
 {
-	Vector	   *a = PG_GETARG_VECTOR_P(0);
-	Vector	   *b = PG_GETARG_VECTOR_P(1);
-	float	   *ax = a->x;
-	float	   *bx = b->x;
-	float		distance = 0.0;
+	float		similarity = 0.0;
 	float		norma = 0.0;
 	float		normb = 0.0;
-	double		similarity;
-
-	CheckDims(a, b);
 
 	/* Auto-vectorized */
-	for (int i = 0; i < a->dim; i++)
+	for (int i = 0; i < dim; i++)
 	{
-		distance += ax[i] * bx[i];
+		similarity += ax[i] * bx[i];
 		norma += ax[i] * ax[i];
 		normb += bx[i] * bx[i];
 	}
 
 	/* Use sqrt(a * b) over sqrt(a) * sqrt(b) */
-	similarity = (double) distance / sqrt((double) norma * (double) normb);
+	return (double) similarity / sqrt((double) norma * (double) normb);
+}
+
+/*
+ * Get the cosine distance between two vectors
+ */
+FUNCTION_PREFIX PG_FUNCTION_INFO_V1(cosine_distance);
+Datum
+cosine_distance(PG_FUNCTION_ARGS)
+{
+	Vector	   *a = PG_GETARG_VECTOR_P(0);
+	Vector	   *b = PG_GETARG_VECTOR_P(1);
+	double		similarity;
+
+	CheckDims(a, b);
+
+	similarity = VectorCosineSimilarity(a->dim, a->x, b->x);
 
 #ifdef _MSC_VER
 	/* /fp:fast may not propagate NaN */
@@ -695,24 +708,17 @@ cosine_distance(PG_FUNCTION_ARGS)
  * Currently uses angular distance since needs to satisfy triangle inequality
  * Assumes inputs are unit vectors (skips norm)
  */
-PGDLLEXPORT PG_FUNCTION_INFO_V1(vector_spherical_distance);
+FUNCTION_PREFIX PG_FUNCTION_INFO_V1(vector_spherical_distance);
 Datum
 vector_spherical_distance(PG_FUNCTION_ARGS)
 {
 	Vector	   *a = PG_GETARG_VECTOR_P(0);
 	Vector	   *b = PG_GETARG_VECTOR_P(1);
-	float	   *ax = a->x;
-	float	   *bx = b->x;
-	float		dp = 0.0;
 	double		distance;
 
 	CheckDims(a, b);
 
-	/* Auto-vectorized */
-	for (int i = 0; i < a->dim; i++)
-		dp += ax[i] * bx[i];
-
-	distance = (double) dp;
+	distance = (double) VectorInnerProduct(a->dim, a->x, b->x);
 
 	/* Prevent NaN with acos with loss of precision */
 	if (distance > 1)
@@ -723,32 +729,38 @@ vector_spherical_distance(PG_FUNCTION_ARGS)
 	PG_RETURN_FLOAT8(acos(distance) / M_PI);
 }
 
+/* Does not require FMA, but keep logic simple */
+VECTOR_TARGET_CLONES static float
+VectorL1Distance(int dim, float *ax, float *bx)
+{
+	float		distance = 0.0;
+
+	/* Auto-vectorized */
+	for (int i = 0; i < dim; i++)
+		distance += fabsf(ax[i] - bx[i]);
+
+	return distance;
+}
+
 /*
- * Get the L1 distance between vectors
+ * Get the L1 distance between two vectors
  */
-PGDLLEXPORT PG_FUNCTION_INFO_V1(l1_distance);
+FUNCTION_PREFIX PG_FUNCTION_INFO_V1(l1_distance);
 Datum
 l1_distance(PG_FUNCTION_ARGS)
 {
 	Vector	   *a = PG_GETARG_VECTOR_P(0);
 	Vector	   *b = PG_GETARG_VECTOR_P(1);
-	float	   *ax = a->x;
-	float	   *bx = b->x;
-	float		distance = 0.0;
 
 	CheckDims(a, b);
 
-	/* Auto-vectorized */
-	for (int i = 0; i < a->dim; i++)
-		distance += fabsf(ax[i] - bx[i]);
-
-	PG_RETURN_FLOAT8((double) distance);
+	PG_RETURN_FLOAT8((double) VectorL1Distance(a->dim, a->x, b->x));
 }
 
 /*
  * Get the dimensions of a vector
  */
-PGDLLEXPORT PG_FUNCTION_INFO_V1(vector_dims);
+FUNCTION_PREFIX PG_FUNCTION_INFO_V1(vector_dims);
 Datum
 vector_dims(PG_FUNCTION_ARGS)
 {
@@ -760,7 +772,7 @@ vector_dims(PG_FUNCTION_ARGS)
 /*
  * Get the L2 norm of a vector
  */
-PGDLLEXPORT PG_FUNCTION_INFO_V1(vector_norm);
+FUNCTION_PREFIX PG_FUNCTION_INFO_V1(vector_norm);
 Datum
 vector_norm(PG_FUNCTION_ARGS)
 {
@@ -775,10 +787,49 @@ vector_norm(PG_FUNCTION_ARGS)
 	PG_RETURN_FLOAT8(sqrt(norm));
 }
 
+/*
+ * Normalize a vector with the L2 norm
+ */
+FUNCTION_PREFIX PG_FUNCTION_INFO_V1(l2_normalize);
+Datum
+l2_normalize(PG_FUNCTION_ARGS)
+{
+	Vector	   *a = PG_GETARG_VECTOR_P(0);
+	float	   *ax = a->x;
+	double		norm = 0;
+	Vector	   *result;
+	float	   *rx;
+
+	result = InitVector(a->dim);
+	rx = result->x;
+
+	/* Auto-vectorized */
+	for (int i = 0; i < a->dim; i++)
+		norm += (double) ax[i] * (double) ax[i];
+
+	norm = sqrt(norm);
+
+	/* Return zero vector for zero norm */
+	if (norm > 0)
+	{
+		for (int i = 0; i < a->dim; i++)
+			rx[i] = ax[i] / norm;
+
+		/* Check for overflow */
+		for (int i = 0; i < a->dim; i++)
+		{
+			if (isinf(rx[i]))
+				float_overflow_error();
+		}
+	}
+
+	PG_RETURN_POINTER(result);
+}
+
 /*
  * Add vectors
  */
-PGDLLEXPORT PG_FUNCTION_INFO_V1(vector_add);
+FUNCTION_PREFIX PG_FUNCTION_INFO_V1(vector_add);
 Datum
 vector_add(PG_FUNCTION_ARGS)
 {
@@ -811,7 +862,7 @@ vector_add(PG_FUNCTION_ARGS)
 /*
  * Subtract vectors
  */
-PGDLLEXPORT PG_FUNCTION_INFO_V1(vector_sub);
+FUNCTION_PREFIX PG_FUNCTION_INFO_V1(vector_sub);
 Datum
 vector_sub(PG_FUNCTION_ARGS)
 {
@@ -844,7 +895,7 @@ vector_sub(PG_FUNCTION_ARGS)
 /*
  * Multiply vectors
  */
-PGDLLEXPORT PG_FUNCTION_INFO_V1(vector_mul);
+FUNCTION_PREFIX PG_FUNCTION_INFO_V1(vector_mul);
 Datum
 vector_mul(PG_FUNCTION_ARGS)
 {
@@ -877,15 +928,105 @@ vector_mul(PG_FUNCTION_ARGS)
 	PG_RETURN_POINTER(result);
 }
 
+/*
+ * Concatenate vectors
+ */
+FUNCTION_PREFIX PG_FUNCTION_INFO_V1(vector_concat);
+Datum
+vector_concat(PG_FUNCTION_ARGS)
+{
+	Vector	   *a = PG_GETARG_VECTOR_P(0);
+	Vector	   *b = PG_GETARG_VECTOR_P(1);
+	Vector	   *result;
+	int			dim = a->dim + b->dim;
+
+	CheckDim(dim);
+	result = InitVector(dim);
+
+	for (int i = 0; i < a->dim; i++)
+		result->x[i] = a->x[i];
+
+	for (int i = 0; i < b->dim; i++)
+		result->x[i + a->dim] = b->x[i];
+
+	PG_RETURN_POINTER(result);
+}
+
+/*
+ * Quantize a vector
+ */
+FUNCTION_PREFIX PG_FUNCTION_INFO_V1(binary_quantize);
+Datum
+binary_quantize(PG_FUNCTION_ARGS)
+{
+	Vector	   *a = PG_GETARG_VECTOR_P(0);
+	float	   *ax = a->x;
+	VarBit	   *result = InitBitVector(a->dim);
+	unsigned char *rx = VARBITS(result);
+
+	for (int i = 0; i < a->dim; i++)
+		rx[i / 8] |= (ax[i] > 0) << (7 - (i % 8));
+
+	PG_RETURN_VARBIT_P(result);
+}
+
+/*
+ * Get a subvector
+ */
+FUNCTION_PREFIX PG_FUNCTION_INFO_V1(subvector);
+Datum
+subvector(PG_FUNCTION_ARGS)
+{
+	Vector	   *a = PG_GETARG_VECTOR_P(0);
+	int32		start = PG_GETARG_INT32(1);
+	int32		count = PG_GETARG_INT32(2);
+	int32		end;
+	float	   *ax = a->x;
+	Vector	   *result;
+	int			dim;
+
+	if (count < 1)
+		ereport(ERROR,
+				(errcode(ERRCODE_DATA_EXCEPTION),
+				 errmsg("vector must have at least 1 dimension")));
+
+	/*
+	 * Check if (start + count > a->dim), avoiding integer overflow. a->dim
+	 * and count are both positive, so a->dim - count won't overflow.
+	 */
+	if (start > a->dim - count)
+		end = a->dim + 1;
+	else
+		end = start + count;
+
+	/* Indexing starts at 1, like substring */
+	if (start < 1)
+		start = 1;
+	else if (start > a->dim)
+		ereport(ERROR,
+				(errcode(ERRCODE_DATA_EXCEPTION),
+				 errmsg("vector must have at least 1 dimension")));
+
+	dim = end - start;
+	CheckDim(dim);
+	result = InitVector(dim);
+
+	for (int i = 0; i < dim; i++)
+		result->x[i] = ax[start - 1 + i];
+
+	PG_RETURN_POINTER(result);
+}
+
 /*
  * Internal helper to compare vectors
  */
 int
 vector_cmp_internal(Vector * a, Vector * b)
 {
-	CheckDims(a, b);
+	int			dim = Min(a->dim, b->dim);
 
-	for (int i = 0; i < a->dim; i++)
+	/* Check values before dimensions to be consistent with Postgres arrays */
+	for (int i = 0; i < dim; i++)
 	{
 		if (a->x[i] < b->x[i])
 			return -1;
@@ -893,18 +1034,25 @@ vector_cmp_internal(Vector * a, Vector * b)
 		if (a->x[i] > b->x[i])
 			return 1;
 	}
+
+	if (a->dim < b->dim)
+		return -1;
+
+	if (a->dim > b->dim)
+		return 1;
+
 	return 0;
 }
 
 /*
  * Less than
  */
-PGDLLEXPORT PG_FUNCTION_INFO_V1(vector_lt);
+FUNCTION_PREFIX PG_FUNCTION_INFO_V1(vector_lt);
 Datum
 vector_lt(PG_FUNCTION_ARGS)
 {
-	Vector	   *a = (Vector *) PG_GETARG_VECTOR_P(0);
-	Vector	   *b = (Vector *) PG_GETARG_VECTOR_P(1);
+	Vector	   *a = PG_GETARG_VECTOR_P(0);
+	Vector	   *b = PG_GETARG_VECTOR_P(1);
 
 	PG_RETURN_BOOL(vector_cmp_internal(a, b) < 0);
 }
@@ -912,12 +1060,12 @@ vector_lt(PG_FUNCTION_ARGS)
 /*
  * Less than or equal
  */
-PGDLLEXPORT PG_FUNCTION_INFO_V1(vector_le);
+FUNCTION_PREFIX PG_FUNCTION_INFO_V1(vector_le);
 Datum
 vector_le(PG_FUNCTION_ARGS)
 {
-	Vector	   *a = (Vector *) PG_GETARG_VECTOR_P(0);
-	Vector	   *b = (Vector *) PG_GETARG_VECTOR_P(1);
+	Vector	   *a = PG_GETARG_VECTOR_P(0);
+	Vector	   *b = PG_GETARG_VECTOR_P(1);
 
 	PG_RETURN_BOOL(vector_cmp_internal(a, b) <= 0);
 }
@@ -925,12 +1073,12 @@ vector_le(PG_FUNCTION_ARGS)
 /*
  * Equal
  */
-PGDLLEXPORT PG_FUNCTION_INFO_V1(vector_eq);
+FUNCTION_PREFIX PG_FUNCTION_INFO_V1(vector_eq);
 Datum
 vector_eq(PG_FUNCTION_ARGS)
 {
-	Vector	   *a = (Vector *) PG_GETARG_VECTOR_P(0);
-	Vector	   *b = (Vector *) PG_GETARG_VECTOR_P(1);
+	Vector	   *a = PG_GETARG_VECTOR_P(0);
+	Vector	   *b = PG_GETARG_VECTOR_P(1);
 
 	PG_RETURN_BOOL(vector_cmp_internal(a, b) == 0);
 }
@@ -938,12 +1086,12 @@ vector_eq(PG_FUNCTION_ARGS)
 /*
  * Not equal
  */
-PGDLLEXPORT PG_FUNCTION_INFO_V1(vector_ne);
+FUNCTION_PREFIX PG_FUNCTION_INFO_V1(vector_ne);
 Datum
 vector_ne(PG_FUNCTION_ARGS)
 {
-	Vector	   *a = (Vector *) PG_GETARG_VECTOR_P(0);
-	Vector	   *b = (Vector *) PG_GETARG_VECTOR_P(1);
+	Vector	   *a = PG_GETARG_VECTOR_P(0);
+	Vector	   *b = PG_GETARG_VECTOR_P(1);
 
 	PG_RETURN_BOOL(vector_cmp_internal(a, b) != 0);
 }
@@ -951,12 +1099,12 @@ vector_ne(PG_FUNCTION_ARGS)
 /*
  * Greater than or equal
  */
-PGDLLEXPORT PG_FUNCTION_INFO_V1(vector_ge);
+FUNCTION_PREFIX PG_FUNCTION_INFO_V1(vector_ge);
 Datum
 vector_ge(PG_FUNCTION_ARGS)
 {
-	Vector	   *a = (Vector *) PG_GETARG_VECTOR_P(0);
-	Vector	   *b = (Vector *) PG_GETARG_VECTOR_P(1);
+	Vector	   *a = PG_GETARG_VECTOR_P(0);
+	Vector	   *b = PG_GETARG_VECTOR_P(1);
 
 	PG_RETURN_BOOL(vector_cmp_internal(a, b) >= 0);
 }
@@ -964,12 +1112,12 @@ vector_ge(PG_FUNCTION_ARGS)
 /*
  * Greater than
  */
-PGDLLEXPORT PG_FUNCTION_INFO_V1(vector_gt);
+FUNCTION_PREFIX PG_FUNCTION_INFO_V1(vector_gt);
 Datum
 vector_gt(PG_FUNCTION_ARGS)
 {
-	Vector	   *a = (Vector *) PG_GETARG_VECTOR_P(0);
-	Vector	   *b = (Vector *) PG_GETARG_VECTOR_P(1);
+	Vector	   *a = PG_GETARG_VECTOR_P(0);
+	Vector	   *b = PG_GETARG_VECTOR_P(1);
 
 	PG_RETURN_BOOL(vector_cmp_internal(a, b) > 0);
 }
@@ -977,12 +1125,12 @@ vector_gt(PG_FUNCTION_ARGS)
 /*
  * Compare vectors
  */
-PGDLLEXPORT PG_FUNCTION_INFO_V1(vector_cmp);
+FUNCTION_PREFIX PG_FUNCTION_INFO_V1(vector_cmp);
 Datum
 vector_cmp(PG_FUNCTION_ARGS)
 {
-	Vector	   *a = (Vector *) PG_GETARG_VECTOR_P(0);
-	Vector	   *b = (Vector *) PG_GETARG_VECTOR_P(1);
+	Vector	   *a = PG_GETARG_VECTOR_P(0);
+	Vector	   *b = PG_GETARG_VECTOR_P(1);
 
 	PG_RETURN_INT32(vector_cmp_internal(a, b));
 }
@@ -990,7 +1138,7 @@ vector_cmp(PG_FUNCTION_ARGS)
 /*
  * Accumulate vectors
  */
-PGDLLEXPORT PG_FUNCTION_INFO_V1(vector_accum);
+FUNCTION_PREFIX PG_FUNCTION_INFO_V1(vector_accum);
 Datum
 vector_accum(PG_FUNCTION_ARGS)
 {
@@ -1049,12 +1197,13 @@ vector_accum(PG_FUNCTION_ARGS)
 }
 
 /*
- * Combine vectors
+ * Combine vectors or half vectors (also used for halfvec_combine)
  */
-PGDLLEXPORT PG_FUNCTION_INFO_V1(vector_combine);
+FUNCTION_PREFIX PG_FUNCTION_INFO_V1(vector_combine);
 Datum
 vector_combine(PG_FUNCTION_ARGS)
 {
+	/* Must also update parameters of halfvec_combine if modifying */
 	ArrayType  *statearray1 = PG_GETARG_ARRAYTYPE_P(0);
 	ArrayType  *statearray2 = PG_GETARG_ARRAYTYPE_P(1);
 	float8	   *statevalues1;
@@ -1121,7 +1270,7 @@ vector_combine(PG_FUNCTION_ARGS)
 /*
  * Average vectors
  */
-PGDLLEXPORT PG_FUNCTION_INFO_V1(vector_avg);
+FUNCTION_PREFIX PG_FUNCTION_INFO_V1(vector_avg);
 Datum
 vector_avg(PG_FUNCTION_ARGS)
 {
@@ -1151,3 +1300,26 @@ vector_avg(PG_FUNCTION_ARGS)
 
 	PG_RETURN_POINTER(result);
 }
+
+/*
+ * Convert sparse vector to dense vector
+ */
+FUNCTION_PREFIX PG_FUNCTION_INFO_V1(sparsevec_to_vector);
+Datum
+sparsevec_to_vector(PG_FUNCTION_ARGS)
+{
+	SparseVector *svec = PG_GETARG_SPARSEVEC_P(0);
+	int32		typmod = PG_GETARG_INT32(1);
+	Vector	   *result;
+	int			dim = svec->dim;
+	float	   *values = SPARSEVEC_VALUES(svec);
+
+	CheckDim(dim);
+	CheckExpectedDim(typmod, dim);
+
+	result = InitVector(dim);
+	for (int i = 0; i < svec->nnz; i++)
+		result->x[svec->indices[i]] = values[i];
+
+	PG_RETURN_POINTER(result);
+}

src/vector.h

@@ -12,7 +12,7 @@ typedef struct Vector
 {
 	int32		vl_len_;		/* varlena header (do not touch directly!) */
 	int16		dim;			/* number of dimensions */
-	int16		unused;
+	int16		unused;			/* reserved for future use, always zero */
 	float		x[FLEXIBLE_ARRAY_MEMBER];
 }			Vector;
 
@@ -20,4 +20,11 @@ Vector	   *InitVector(int dim);
 void		PrintVector(char *msg, Vector * vector);
 int			vector_cmp_internal(Vector * a, Vector * b);
 
+/* TODO Move to better place */
+#if PG_VERSION_NUM >= 160000
+#define FUNCTION_PREFIX
+#else
+#define FUNCTION_PREFIX PGDLLEXPORT
+#endif
+
 #endif

test/expected/bit.out

@@ -0,0 +1,140 @@
+SELECT hamming_distance('111', '111');
+ hamming_distance 
+------------------
+                0
+(1 row)
+
+SELECT hamming_distance('111', '110');
+ hamming_distance 
+------------------
+                1
+(1 row)
+
+SELECT hamming_distance('111', '100');
+ hamming_distance 
+------------------
+                2
+(1 row)
+
+SELECT hamming_distance('111', '000');
+ hamming_distance 
+------------------
+                3
+(1 row)
+
+SELECT hamming_distance('10101010101010101010', '01010101010101010101');
+ hamming_distance 
+------------------
+               20
+(1 row)
+
+SELECT hamming_distance('101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101', '101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101');
+ hamming_distance 
+------------------
+                0
+(1 row)
+
+SELECT hamming_distance('101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101', '010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010');
+ hamming_distance 
+------------------
+              513
+(1 row)
+
+SELECT hamming_distance('110000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011', '100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001');
+ hamming_distance 
+------------------
+                2
+(1 row)
+
+SELECT hamming_distance('', '');
+ hamming_distance 
+------------------
+                0
+(1 row)
+
+SELECT hamming_distance('111', '00');
+ERROR:  different bit lengths 3 and 2
+SELECT hamming_distance('111', '000'::varbit(4));
+ hamming_distance 
+------------------
+                3
+(1 row)
+
+SELECT hamming_distance('111', '0000'::varbit(4));
+ERROR:  different bit lengths 3 and 4
+SELECT jaccard_distance('1111', '1111');
+ jaccard_distance 
+------------------
+                0
+(1 row)
+
+SELECT jaccard_distance('1111', '1110');
+ jaccard_distance 
+------------------
+             0.25
+(1 row)
+
+SELECT jaccard_distance('1111', '1100');
+ jaccard_distance 
+------------------
+              0.5
+(1 row)
+
+SELECT jaccard_distance('1111', '1000');
+ jaccard_distance 
+------------------
+             0.75
+(1 row)
+
+SELECT jaccard_distance('1111', '0000');
+ jaccard_distance 
+------------------
+                1
+(1 row)
+
+SELECT jaccard_distance('1100', '1000');
+ jaccard_distance 
+------------------
+              0.5
+(1 row)
+
+SELECT jaccard_distance('10101010101010101010', '01010101010101010101');
+ jaccard_distance 
+------------------
+                1
+(1 row)
+
+SELECT jaccard_distance('101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101', '101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101');
+ jaccard_distance 
+------------------
+                0
+(1 row)
+
+SELECT jaccard_distance('101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101', '010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010');
+ jaccard_distance 
+------------------
+                1
+(1 row)
+
+SELECT jaccard_distance('110000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011', '100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001');
+ jaccard_distance 
+------------------
+              0.5
+(1 row)
+
+SELECT jaccard_distance('', '');
+ jaccard_distance 
+------------------
+                1
+(1 row)
+
+SELECT jaccard_distance('1111', '000');
+ERROR:  different bit lengths 4 and 3
+SELECT jaccard_distance('1111', '0000'::varbit(5));
+ jaccard_distance 
+------------------
+                1
+(1 row)
+
+SELECT jaccard_distance('1111', '00000'::varbit(5));
+ERROR:  different bit lengths 4 and 5

test/expected/btree.out

@@ -1,4 +1,5 @@
 SET enable_seqscan = off;
+-- vector
 CREATE TABLE t (val vector(3));
 INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
 CREATE INDEX ON t (val);
@@ -8,10 +9,53 @@ SELECT * FROM t WHERE val = '[1,2,3]';
  [1,2,3]
 (1 row)
 
-SELECT * FROM t ORDER BY val LIMIT 1;
+SELECT * FROM t ORDER BY val;
    val   
 ---------
  [0,0,0]
-(1 row)
+ [1,1,1]
+ [1,2,3]
+ 
+(4 rows)
+
+DROP TABLE t;
+-- halfvec
+CREATE TABLE t (val halfvec(3));
+INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
+CREATE INDEX ON t (val);
+SELECT * FROM t WHERE val = '[1,2,3]';
+   val   
+---------
+ [1,2,3]
+(1 row)
+
+SELECT * FROM t ORDER BY val;
+   val   
+---------
+ [0,0,0]
+ [1,1,1]
+ [1,2,3]
+ 
+(4 rows)
+
+DROP TABLE t;
+-- sparsevec
+CREATE TABLE t (val sparsevec(3));
+INSERT INTO t (val) VALUES ('{}/3'), ('{1:1,2:2,3:3}/3'), ('{1:1,2:1,3:1}/3'), (NULL);
+CREATE INDEX ON t (val);
+SELECT * FROM t WHERE val = '{1:1,2:2,3:3}/3';
+       val       
+-----------------
+ {1:1,2:2,3:3}/3
+(1 row)
+
+SELECT * FROM t ORDER BY val;
+       val       
+-----------------
+ {}/3
+ {1:1,2:1,3:1}/3
+ {1:1,2:2,3:3}/3
+ 
+(4 rows)
 
 DROP TABLE t;

test/expected/cast.out

@@ -28,6 +28,26 @@ SELECT ARRAY[1,2,3]::numeric[]::vector;
  [1,2,3]
 (1 row)
 
+SELECT '[1,2,3]'::vector::real[];
+ float4  
+---------
+ {1,2,3}
+(1 row)
+
+SELECT '{1,2,3}'::real[]::vector;
+ vector  
+---------
+ [1,2,3]
+(1 row)
+
+SELECT '{1,2,3}'::real[]::vector(3);
+ vector  
+---------
+ [1,2,3]
+(1 row)
+
+SELECT '{1,2,3}'::real[]::vector(2);
+ERROR:  expected 2 dimensions, not 3
 SELECT '{NULL}'::real[]::vector;
 ERROR:  array must not contain nulls
 SELECT '{NaN}'::real[]::vector;
@@ -40,10 +60,152 @@ SELECT '{}'::real[]::vector;
 ERROR:  vector must have at least 1 dimension
 SELECT '{{1}}'::real[]::vector;
 ERROR:  array must be 1-D
-SELECT '[1,2,3]'::vector::real[];
- float4  
+SELECT '{1,2,3}'::double precision[]::vector;
+ vector  
 ---------
- {1,2,3}
+ [1,2,3]
+(1 row)
+
+SELECT '{1,2,3}'::double precision[]::vector(3);
+ vector  
+---------
+ [1,2,3]
+(1 row)
+
+SELECT '{1,2,3}'::double precision[]::vector(2);
+ERROR:  expected 2 dimensions, not 3
+SELECT '{4e38,-4e38}'::double precision[]::vector;
+ERROR:  infinite value not allowed in vector
+SELECT '{1e-46,-1e-46}'::double precision[]::vector;
+ vector 
+--------
+ [0,-0]
+(1 row)
+
+SELECT '[1,2,3]'::vector::halfvec;
+ halfvec 
+---------
+ [1,2,3]
+(1 row)
+
+SELECT '[1,2,3]'::vector::halfvec(3);
+ halfvec 
+---------
+ [1,2,3]
+(1 row)
+
+SELECT '[1,2,3]'::vector::halfvec(2);
+ERROR:  expected 2 dimensions, not 3
+SELECT '[65520]'::vector::halfvec;
+ERROR:  "65520" is out of range for type halfvec
+SELECT '[1e-8]'::vector::halfvec;
+ halfvec 
+---------
+ [0]
+(1 row)
+
+SELECT '[1,2,3]'::halfvec::vector;
+ vector  
+---------
+ [1,2,3]
+(1 row)
+
+SELECT '[1,2,3]'::halfvec::vector(3);
+ vector  
+---------
+ [1,2,3]
+(1 row)
+
+SELECT '[1,2,3]'::halfvec::vector(2);
+ERROR:  expected 2 dimensions, not 3
+SELECT '{1,2,3}'::real[]::halfvec;
+ halfvec 
+---------
+ [1,2,3]
+(1 row)
+
+SELECT '{1,2,3}'::real[]::halfvec(3);
+ halfvec 
+---------
+ [1,2,3]
+(1 row)
+
+SELECT '{1,2,3}'::real[]::halfvec(2);
+ERROR:  expected 2 dimensions, not 3
+SELECT '{65520,-65520}'::real[]::halfvec;
+ERROR:  "65520" is out of range for type halfvec
+SELECT '{1e-8,-1e-8}'::real[]::halfvec;
+ halfvec 
+---------
+ [0,-0]
+(1 row)
+
+SELECT '[0,1.5,0,3.5,0]'::vector::sparsevec;
+    sparsevec    
+-----------------
+ {2:1.5,4:3.5}/5
+(1 row)
+
+SELECT '[0,1.5,0,3.5,0]'::vector::sparsevec(5);
+    sparsevec    
+-----------------
+ {2:1.5,4:3.5}/5
+(1 row)
+
+SELECT '[0,1.5,0,3.5,0]'::vector::sparsevec(4);
+ERROR:  expected 4 dimensions, not 5
+SELECT '{2:1.5,4:3.5}/5'::sparsevec::vector;
+     vector      
+-----------------
+ [0,1.5,0,3.5,0]
+(1 row)
+
+SELECT '{2:1.5,4:3.5}/5'::sparsevec::vector(5);
+     vector      
+-----------------
+ [0,1.5,0,3.5,0]
+(1 row)
+
+SELECT '{2:1.5,4:3.5}/5'::sparsevec::vector(4);
+ERROR:  expected 4 dimensions, not 5
+SELECT '{}/16001'::sparsevec::vector;
+ERROR:  vector cannot have more than 16000 dimensions
+SELECT '[0,1.5,0,3.5,0]'::halfvec::sparsevec;
+    sparsevec    
+-----------------
+ {2:1.5,4:3.5}/5
+(1 row)
+
+SELECT '[0,1.5,0,3.5,0]'::halfvec::sparsevec(5);
+    sparsevec    
+-----------------
+ {2:1.5,4:3.5}/5
+(1 row)
+
+SELECT '[0,1.5,0,3.5,0]'::halfvec::sparsevec(4);
+ERROR:  expected 4 dimensions, not 5
+SELECT '{2:1.5,4:3.5}/5'::sparsevec::halfvec;
+     halfvec     
+-----------------
+ [0,1.5,0,3.5,0]
+(1 row)
+
+SELECT '{2:1.5,4:3.5}/5'::sparsevec::halfvec(5);
+     halfvec     
+-----------------
+ [0,1.5,0,3.5,0]
+(1 row)
+
+SELECT '{2:1.5,4:3.5}/5'::sparsevec::halfvec(4);
+ERROR:  expected 4 dimensions, not 5
+SELECT '{}/16001'::sparsevec::halfvec;
+ERROR:  halfvec cannot have more than 16000 dimensions
+SELECT '{1:65520}/1'::sparsevec::halfvec;
+ERROR:  "65520" is out of range for type halfvec
+SELECT '{1:1e-8}/1'::sparsevec::halfvec;
+ halfvec 
+---------
+ [0]
 (1 row)
 
 SELECT array_agg(n)::vector FROM generate_series(1, 16001) n;

test/expected/copy.out

@@ -1,8 +1,9 @@
+-- vector
 CREATE TABLE t (val vector(3));
 INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
 CREATE TABLE t2 (val vector(3));
-\copy t TO 'results/data.bin' WITH (FORMAT binary)
-\copy t2 FROM 'results/data.bin' WITH (FORMAT binary)
+\copy t TO 'results/vector.bin' WITH (FORMAT binary)
+\copy t2 FROM 'results/vector.bin' WITH (FORMAT binary)
 SELECT * FROM t2 ORDER BY val;
    val   
 ---------
@@ -14,3 +15,37 @@ SELECT * FROM t2 ORDER BY val;
 
 DROP TABLE t;
 DROP TABLE t2;
+-- halfvec
+CREATE TABLE t (val halfvec(3));
+INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
+CREATE TABLE t2 (val halfvec(3));
+\copy t TO 'results/halfvec.bin' WITH (FORMAT binary)
+\copy t2 FROM 'results/halfvec.bin' WITH (FORMAT binary)
+SELECT * FROM t2 ORDER BY val;
+   val   
+---------
+ [0,0,0]
+ [1,1,1]
+ [1,2,3]
+ 
+(4 rows)
+
+DROP TABLE t;
+DROP TABLE t2;
+-- sparsevec
+CREATE TABLE t (val sparsevec(3));
+INSERT INTO t (val) VALUES ('{}/3'), ('{1:1,2:2,3:3}/3'), ('{1:1,2:1,3:1}/3'), (NULL);
+CREATE TABLE t2 (val sparsevec(3));
+\copy t TO 'results/sparsevec.bin' WITH (FORMAT binary)
+\copy t2 FROM 'results/sparsevec.bin' WITH (FORMAT binary)
+SELECT * FROM t2 ORDER BY val;
+       val       
+-----------------
+ {}/3
+ {1:1,2:1,3:1}/3
+ {1:1,2:2,3:3}/3
+ 
+(4 rows)
+
+DROP TABLE t;
+DROP TABLE t2;

test/expected/functions.out

@@ -1,210 +0,0 @@
-SELECT '[1,2,3]'::vector + '[4,5,6]';
- ?column? 
-----------
- [5,7,9]
-(1 row)
-
-SELECT '[3e38]'::vector + '[3e38]';
-ERROR:  value out of range: overflow
-SELECT '[1,2,3]'::vector - '[4,5,6]';
-  ?column?  
-------------
- [-3,-3,-3]
-(1 row)
-
-SELECT '[-3e38]'::vector - '[3e38]';
-ERROR:  value out of range: overflow
-SELECT '[1,2,3]'::vector * '[4,5,6]';
- ?column?  
------------
- [4,10,18]
-(1 row)
-
-SELECT '[1e37]'::vector * '[1e37]';
-ERROR:  value out of range: overflow
-SELECT '[1e-37]'::vector * '[1e-37]';
-ERROR:  value out of range: underflow
-SELECT vector_dims('[1,2,3]');
- vector_dims 
--------------
-           3
-(1 row)
-
-SELECT round(vector_norm('[1,1]')::numeric, 5);
-  round  
----------
- 1.41421
-(1 row)
-
-SELECT vector_norm('[3,4]');
- vector_norm 
--------------
-           5
-(1 row)
-
-SELECT vector_norm('[0,1]');
- vector_norm 
--------------
-           1
-(1 row)
-
-SELECT vector_norm('[3e37,4e37]')::real;
- vector_norm 
--------------
-       5e+37
-(1 row)
-
-SELECT l2_distance('[0,0]', '[3,4]');
- l2_distance 
--------------
-           5
-(1 row)
-
-SELECT l2_distance('[0,0]', '[0,1]');
- l2_distance 
--------------
-           1
-(1 row)
-
-SELECT l2_distance('[1,2]', '[3]');
-ERROR:  different vector dimensions 2 and 1
-SELECT l2_distance('[3e38]', '[-3e38]');
- l2_distance 
--------------
-    Infinity
-(1 row)
-
-SELECT inner_product('[1,2]', '[3,4]');
- inner_product 
----------------
-            11
-(1 row)
-
-SELECT inner_product('[1,2]', '[3]');
-ERROR:  different vector dimensions 2 and 1
-SELECT inner_product('[3e38]', '[3e38]');
- inner_product 
----------------
-      Infinity
-(1 row)
-
-SELECT cosine_distance('[1,2]', '[2,4]');
- cosine_distance 
------------------
-               0
-(1 row)
-
-SELECT cosine_distance('[1,2]', '[0,0]');
- cosine_distance 
------------------
-             NaN
-(1 row)
-
-SELECT cosine_distance('[1,1]', '[1,1]');
- cosine_distance 
------------------
-               0
-(1 row)
-
-SELECT cosine_distance('[1,0]', '[0,2]');
- cosine_distance 
------------------
-               1
-(1 row)
-
-SELECT cosine_distance('[1,1]', '[-1,-1]');
- cosine_distance 
------------------
-               2
-(1 row)
-
-SELECT cosine_distance('[1,2]', '[3]');
-ERROR:  different vector dimensions 2 and 1
-SELECT cosine_distance('[1,1]', '[1.1,1.1]');
- cosine_distance 
------------------
-               0
-(1 row)
-
-SELECT cosine_distance('[1,1]', '[-1.1,-1.1]');
- cosine_distance 
------------------
-               2
-(1 row)
-
-SELECT cosine_distance('[3e38]', '[3e38]');
- cosine_distance 
------------------
-             NaN
-(1 row)
-
-SELECT l1_distance('[0,0]', '[3,4]');
- l1_distance 
--------------
-           7
-(1 row)
-
-SELECT l1_distance('[0,0]', '[0,1]');
- l1_distance 
--------------
-           1
-(1 row)
-
-SELECT l1_distance('[1,2]', '[3]');
-ERROR:  different vector dimensions 2 and 1
-SELECT l1_distance('[3e38]', '[-3e38]');
- l1_distance 
--------------
-    Infinity
-(1 row)
-
-SELECT avg(v) FROM unnest(ARRAY['[1,2,3]'::vector, '[3,5,7]']) v;
-    avg    
------------
- [2,3.5,5]
-(1 row)
-
-SELECT avg(v) FROM unnest(ARRAY['[1,2,3]'::vector, '[3,5,7]', NULL]) v;
-    avg    
------------
- [2,3.5,5]
-(1 row)
-
-SELECT avg(v) FROM unnest(ARRAY[]::vector[]) v;
- avg 
------
- 
-(1 row)
-
-SELECT avg(v) FROM unnest(ARRAY['[1,2]'::vector, '[3]']) v;
-ERROR:  expected 2 dimensions, not 1
-SELECT avg(v) FROM unnest(ARRAY['[3e38]'::vector, '[3e38]']) v;
-   avg   
----------
- [3e+38]
-(1 row)
-
-SELECT vector_avg(array_agg(n)) FROM generate_series(1, 16002) n;
-ERROR:  vector cannot have more than 16000 dimensions
-SELECT sum(v) FROM unnest(ARRAY['[1,2,3]'::vector, '[3,5,7]']) v;
-   sum    
-----------
- [4,7,10]
-(1 row)
-
-SELECT sum(v) FROM unnest(ARRAY['[1,2,3]'::vector, '[3,5,7]', NULL]) v;
-   sum    
-----------
- [4,7,10]
-(1 row)
-
-SELECT sum(v) FROM unnest(ARRAY[]::vector[]) v;
- sum 
------
- 
-(1 row)
-
-SELECT sum(v) FROM unnest(ARRAY['[1,2]'::vector, '[3]']) v;
-ERROR:  different vector dimensions 2 and 1
-SELECT sum(v) FROM unnest(ARRAY['[3e38]'::vector, '[3e38]']) v;
-ERROR:  value out of range: overflow

test/expected/halfvec.out

@@ -0,0 +1,636 @@
+SELECT '[1,2,3]'::halfvec;
+ halfvec 
+---------
+ [1,2,3]
+(1 row)
+
+SELECT '[-1,-2,-3]'::halfvec;
+  halfvec   
+------------
+ [-1,-2,-3]
+(1 row)
+
+SELECT '[1.,2.,3.]'::halfvec;
+ halfvec 
+---------
+ [1,2,3]
+(1 row)
+
+SELECT ' [ 1,  2 ,    3  ] '::halfvec;
+ halfvec 
+---------
+ [1,2,3]
+(1 row)
+
+SELECT '[1.23456]'::halfvec;
+  halfvec   
+------------
+ [1.234375]
+(1 row)
+
+SELECT '[hello,1]'::halfvec;
+ERROR:  invalid input syntax for type halfvec: "[hello,1]"
+LINE 1: SELECT '[hello,1]'::halfvec;
+               ^
+SELECT '[NaN,1]'::halfvec;
+ERROR:  NaN not allowed in halfvec
+LINE 1: SELECT '[NaN,1]'::halfvec;
+               ^
+SELECT '[Infinity,1]'::halfvec;
+ERROR:  infinite value not allowed in halfvec
+LINE 1: SELECT '[Infinity,1]'::halfvec;
+               ^
+SELECT '[-Infinity,1]'::halfvec;
+ERROR:  infinite value not allowed in halfvec
+LINE 1: SELECT '[-Infinity,1]'::halfvec;
+               ^
+SELECT '[65519,-65519]'::halfvec;
+    halfvec     
+----------------
+ [65504,-65504]
+(1 row)
+
+SELECT '[65520,-65520]'::halfvec;
+ERROR:  "65520" is out of range for type halfvec
+LINE 1: SELECT '[65520,-65520]'::halfvec;
+               ^
+SELECT '[1e-8,-1e-8]'::halfvec;
+ halfvec 
+---------
+ [0,-0]
+(1 row)
+
+SELECT '[4e38,1]'::halfvec;
+ERROR:  "4e38" is out of range for type halfvec
+LINE 1: SELECT '[4e38,1]'::halfvec;
+               ^
+SELECT '[1e-46,1]'::halfvec;
+ halfvec 
+---------
+ [0,1]
+(1 row)
+
+SELECT '[1,2,3'::halfvec;
+ERROR:  invalid input syntax for type halfvec: "[1,2,3"
+LINE 1: SELECT '[1,2,3'::halfvec;
+               ^
+SELECT '[1,2,3]9'::halfvec;
+ERROR:  invalid input syntax for type halfvec: "[1,2,3]9"
+LINE 1: SELECT '[1,2,3]9'::halfvec;
+               ^
+DETAIL:  Junk after closing right brace.
+SELECT '1,2,3'::halfvec;
+ERROR:  invalid input syntax for type halfvec: "1,2,3"
+LINE 1: SELECT '1,2,3'::halfvec;
+               ^
+DETAIL:  Vector contents must start with "[".
+SELECT ''::halfvec;
+ERROR:  invalid input syntax for type halfvec: ""
+LINE 1: SELECT ''::halfvec;
+               ^
+DETAIL:  Vector contents must start with "[".
+SELECT '['::halfvec;
+ERROR:  invalid input syntax for type halfvec: "["
+LINE 1: SELECT '['::halfvec;
+               ^
+SELECT '[ '::halfvec;
+ERROR:  invalid input syntax for type halfvec: "[ "
+LINE 1: SELECT '[ '::halfvec;
+               ^
+SELECT '[,'::halfvec;
+ERROR:  invalid input syntax for type halfvec: "[,"
+LINE 1: SELECT '[,'::halfvec;
+               ^
+SELECT '[]'::halfvec;
+ERROR:  halfvec must have at least 1 dimension
+LINE 1: SELECT '[]'::halfvec;
+               ^
+SELECT '[ ]'::halfvec;
+ERROR:  halfvec must have at least 1 dimension
+LINE 1: SELECT '[ ]'::halfvec;
+               ^
+SELECT '[,]'::halfvec;
+ERROR:  invalid input syntax for type halfvec: "[,]"
+LINE 1: SELECT '[,]'::halfvec;
+               ^
+SELECT '[1,]'::halfvec;
+ERROR:  invalid input syntax for type halfvec: "[1,]"
+LINE 1: SELECT '[1,]'::halfvec;
+               ^
+SELECT '[1a]'::halfvec;
+ERROR:  invalid input syntax for type halfvec: "[1a]"
+LINE 1: SELECT '[1a]'::halfvec;
+               ^
+SELECT '[1,,3]'::halfvec;
+ERROR:  invalid input syntax for type halfvec: "[1,,3]"
+LINE 1: SELECT '[1,,3]'::halfvec;
+               ^
+SELECT '[1, ,3]'::halfvec;
+ERROR:  invalid input syntax for type halfvec: "[1, ,3]"
+LINE 1: SELECT '[1, ,3]'::halfvec;
+               ^
+SELECT '[1,2,3]'::halfvec(3);
+ halfvec 
+---------
+ [1,2,3]
+(1 row)
+
+SELECT '[1,2,3]'::halfvec(2);
+ERROR:  expected 2 dimensions, not 3
+SELECT '[1,2,3]'::halfvec(3, 2);
+ERROR:  invalid type modifier
+LINE 1: SELECT '[1,2,3]'::halfvec(3, 2);
+                          ^
+SELECT '[1,2,3]'::halfvec('a');
+ERROR:  invalid input syntax for type integer: "a"
+LINE 1: SELECT '[1,2,3]'::halfvec('a');
+                          ^
+SELECT '[1,2,3]'::halfvec(0);
+ERROR:  dimensions for type halfvec must be at least 1
+LINE 1: SELECT '[1,2,3]'::halfvec(0);
+                          ^
+SELECT '[1,2,3]'::halfvec(16001);
+ERROR:  dimensions for type halfvec cannot exceed 16000
+LINE 1: SELECT '[1,2,3]'::halfvec(16001);
+                          ^
+SELECT unnest('{"[1,2,3]", "[4,5,6]"}'::halfvec[]);
+ unnest  
+---------
+ [1,2,3]
+ [4,5,6]
+(2 rows)
+
+SELECT '{"[1,2,3]"}'::halfvec(2)[];
+ERROR:  expected 2 dimensions, not 3
+SELECT '[1,2,3]'::halfvec + '[4,5,6]';
+ ?column? 
+----------
+ [5,7,9]
+(1 row)
+
+SELECT '[65519]'::halfvec + '[65519]';
+ERROR:  value out of range: overflow
+SELECT '[1,2]'::halfvec + '[3]';
+ERROR:  different halfvec dimensions 2 and 1
+SELECT '[1,2,3]'::halfvec - '[4,5,6]';
+  ?column?  
+------------
+ [-3,-3,-3]
+(1 row)
+
+SELECT '[-65519]'::halfvec - '[65519]';
+ERROR:  value out of range: overflow
+SELECT '[1,2]'::halfvec - '[3]';
+ERROR:  different halfvec dimensions 2 and 1
+SELECT '[1,2,3]'::halfvec * '[4,5,6]';
+ ?column?  
+-----------
+ [4,10,18]
+(1 row)
+
+SELECT '[65519]'::halfvec * '[65519]';
+ERROR:  value out of range: overflow
+SELECT '[1e-7]'::halfvec * '[1e-7]';
+ERROR:  value out of range: underflow
+SELECT '[1,2]'::halfvec * '[3]';
+ERROR:  different halfvec dimensions 2 and 1
+SELECT '[1,2,3]'::halfvec || '[4,5]';
+  ?column?   
+-------------
+ [1,2,3,4,5]
+(1 row)
+
+SELECT array_fill(0, ARRAY[16000])::halfvec || '[1]';
+ERROR:  halfvec cannot have more than 16000 dimensions
+SELECT '[1,2,3]'::halfvec < '[1,2,3]';
+ ?column? 
+----------
+ f
+(1 row)
+
+SELECT '[1,2,3]'::halfvec < '[1,2]';
+ ?column? 
+----------
+ f
+(1 row)
+
+SELECT '[1,2,3]'::halfvec <= '[1,2,3]';
+ ?column? 
+----------
+ t
+(1 row)
+
+SELECT '[1,2,3]'::halfvec <= '[1,2]';
+ ?column? 
+----------
+ f
+(1 row)
+
+SELECT '[1,2,3]'::halfvec = '[1,2,3]';
+ ?column? 
+----------
+ t
+(1 row)
+
+SELECT '[1,2,3]'::halfvec = '[1,2]';
+ ?column? 
+----------
+ f
+(1 row)
+
+SELECT '[1,2,3]'::halfvec != '[1,2,3]';
+ ?column? 
+----------
+ f
+(1 row)
+
+SELECT '[1,2,3]'::halfvec != '[1,2]';
+ ?column? 
+----------
+ t
+(1 row)
+
+SELECT '[1,2,3]'::halfvec >= '[1,2,3]';
+ ?column? 
+----------
+ t
+(1 row)
+
+SELECT '[1,2,3]'::halfvec >= '[1,2]';
+ ?column? 
+----------
+ t
+(1 row)
+
+SELECT '[1,2,3]'::halfvec > '[1,2,3]';
+ ?column? 
+----------
+ f
+(1 row)
+
+SELECT '[1,2,3]'::halfvec > '[1,2]';
+ ?column? 
+----------
+ t
+(1 row)
+
+SELECT halfvec_cmp('[1,2,3]', '[1,2,3]');
+ halfvec_cmp 
+-------------
+           0
+(1 row)
+
+SELECT halfvec_cmp('[1,2,3]', '[0,0,0]');
+ halfvec_cmp 
+-------------
+           1
+(1 row)
+
+SELECT halfvec_cmp('[0,0,0]', '[1,2,3]');
+ halfvec_cmp 
+-------------
+          -1
+(1 row)
+
+SELECT halfvec_cmp('[1,2]', '[1,2,3]');
+ halfvec_cmp 
+-------------
+          -1
+(1 row)
+
+SELECT halfvec_cmp('[1,2,3]', '[1,2]');
+ halfvec_cmp 
+-------------
+           1
+(1 row)
+
+SELECT halfvec_cmp('[1,2]', '[2,3,4]');
+ halfvec_cmp 
+-------------
+          -1
+(1 row)
+
+SELECT halfvec_cmp('[2,3]', '[1,2,3]');
+ halfvec_cmp 
+-------------
+           1
+(1 row)
+
+SELECT vector_dims('[1,2,3]'::halfvec);
+ vector_dims 
+-------------
+           3
+(1 row)
+
+SELECT round(l2_norm('[1,1]'::halfvec)::numeric, 5);
+  round  
+---------
+ 1.41421
+(1 row)
+
+SELECT l2_norm('[3,4]'::halfvec);
+ l2_norm 
+---------
+       5
+(1 row)
+
+SELECT l2_norm('[0,1]'::halfvec);
+ l2_norm 
+---------
+       1
+(1 row)
+
+SELECT l2_norm('[0,0]'::halfvec);
+ l2_norm 
+---------
+       0
+(1 row)
+
+SELECT l2_norm('[2]'::halfvec);
+ l2_norm 
+---------
+       2
+(1 row)
+
+SELECT l2_distance('[0,0]'::halfvec, '[3,4]');
+ l2_distance 
+-------------
+           5
+(1 row)
+
+SELECT l2_distance('[0,0]'::halfvec, '[0,1]');
+ l2_distance 
+-------------
+           1
+(1 row)
+
+SELECT l2_distance('[1,2]'::halfvec, '[3]');
+ERROR:  different halfvec dimensions 2 and 1
+SELECT l2_distance('[1,1,1,1,1,1,1,1,1]'::halfvec, '[1,1,1,1,1,1,1,4,5]');
+ l2_distance 
+-------------
+           5
+(1 row)
+
+SELECT '[0,0]'::halfvec <-> '[3,4]';
+ ?column? 
+----------
+        5
+(1 row)
+
+SELECT inner_product('[1,2]'::halfvec, '[3,4]');
+ inner_product 
+---------------
+            11
+(1 row)
+
+SELECT inner_product('[1,2]'::halfvec, '[3]');
+ERROR:  different halfvec dimensions 2 and 1
+SELECT inner_product('[65504]'::halfvec, '[65504]');
+ inner_product 
+---------------
+    4290774016
+(1 row)
+
+SELECT inner_product('[1,1,1,1,1,1,1,1,1]'::halfvec, '[1,2,3,4,5,6,7,8,9]');
+ inner_product 
+---------------
+            45
+(1 row)
+
+SELECT '[1,2]'::halfvec <#> '[3,4]';
+ ?column? 
+----------
+      -11
+(1 row)
+
+SELECT cosine_distance('[1,2]'::halfvec, '[2,4]');
+ cosine_distance 
+-----------------
+               0
+(1 row)
+
+SELECT cosine_distance('[1,2]'::halfvec, '[0,0]');
+ cosine_distance 
+-----------------
+             NaN
+(1 row)
+
+SELECT cosine_distance('[1,1]'::halfvec, '[1,1]');
+ cosine_distance 
+-----------------
+               0
+(1 row)
+
+SELECT cosine_distance('[1,0]'::halfvec, '[0,2]');
+ cosine_distance 
+-----------------
+               1
+(1 row)
+
+SELECT cosine_distance('[1,1]'::halfvec, '[-1,-1]');
+ cosine_distance 
+-----------------
+               2
+(1 row)
+
+SELECT cosine_distance('[1,2]'::halfvec, '[3]');
+ERROR:  different halfvec dimensions 2 and 1
+SELECT cosine_distance('[1,1]'::halfvec, '[1.1,1.1]');
+ cosine_distance 
+-----------------
+               0
+(1 row)
+
+SELECT cosine_distance('[1,1]'::halfvec, '[-1.1,-1.1]');
+ cosine_distance 
+-----------------
+               2
+(1 row)
+
+SELECT cosine_distance('[1,2,3,4,5,6,7,8,9]'::halfvec, '[1,2,3,4,5,6,7,8,9]');
+ cosine_distance 
+-----------------
+               0
+(1 row)
+
+SELECT cosine_distance('[1,2,3,4,5,6,7,8,9]'::halfvec, '[-1,-2,-3,-4,-5,-6,-7,-8,-9]');
+ cosine_distance 
+-----------------
+               2
+(1 row)
+
+SELECT '[1,2]'::halfvec <=> '[2,4]';
+ ?column? 
+----------
+        0
+(1 row)
+
+SELECT l1_distance('[0,0]'::halfvec, '[3,4]');
+ l1_distance 
+-------------
+           7
+(1 row)
+
+SELECT l1_distance('[0,0]'::halfvec, '[0,1]');
+ l1_distance 
+-------------
+           1
+(1 row)
+
+SELECT l1_distance('[1,2]'::halfvec, '[3]');
+ERROR:  different halfvec dimensions 2 and 1
+SELECT l1_distance('[1,2,3,4,5,6,7,8,9]'::halfvec, '[1,2,3,4,5,6,7,8,9]');
+ l1_distance 
+-------------
+           0
+(1 row)
+
+SELECT l1_distance('[1,2,3,4,5,6,7,8,9]'::halfvec, '[0,3,2,5,4,7,6,9,8]');
+ l1_distance 
+-------------
+           9
+(1 row)
+
+SELECT '[0,0]'::halfvec <+> '[3,4]';
+ ?column? 
+----------
+        7
+(1 row)
+
+SELECT l2_normalize('[3,4]'::halfvec);
+      l2_normalize      
+------------------------
+ [0.60009766,0.7998047]
+(1 row)
+
+SELECT l2_normalize('[3,0]'::halfvec);
+ l2_normalize 
+--------------
+ [1,0]
+(1 row)
+
+SELECT l2_normalize('[0,0.1]'::halfvec);
+ l2_normalize 
+--------------
+ [0,1]
+(1 row)
+
+SELECT l2_normalize('[0,0]'::halfvec);
+ l2_normalize 
+--------------
+ [0,0]
+(1 row)
+
+SELECT l2_normalize('[65504]'::halfvec);
+ l2_normalize 
+--------------
+ [1]
+(1 row)
+
+SELECT binary_quantize('[1,0,-1]'::halfvec);
+ binary_quantize 
+-----------------
+ 100
+(1 row)
+
+SELECT binary_quantize('[0,0.1,-0.2,-0.3,0.4,0.5,0.6,-0.7,0.8,-0.9,1]'::halfvec);
+ binary_quantize 
+-----------------
+ 01001110101
+(1 row)
+
+SELECT subvector('[1,2,3,4,5]'::halfvec, 1, 3);
+ subvector 
+-----------
+ [1,2,3]
+(1 row)
+
+SELECT subvector('[1,2,3,4,5]'::halfvec, 3, 2);
+ subvector 
+-----------
+ [3,4]
+(1 row)
+
+SELECT subvector('[1,2,3,4,5]'::halfvec, -1, 3);
+ subvector 
+-----------
+ [1]
+(1 row)
+
+SELECT subvector('[1,2,3,4,5]'::halfvec, 3, 9);
+ subvector 
+-----------
+ [3,4,5]
+(1 row)
+
+SELECT subvector('[1,2,3,4,5]'::halfvec, 1, 0);
+ERROR:  halfvec must have at least 1 dimension
+SELECT subvector('[1,2,3,4,5]'::halfvec, 3, -1);
+ERROR:  halfvec must have at least 1 dimension
+SELECT subvector('[1,2,3,4,5]'::halfvec, -1, 2);
+ERROR:  halfvec must have at least 1 dimension
+SELECT subvector('[1,2,3,4,5]'::halfvec, 2147483647, 10);
+ERROR:  halfvec must have at least 1 dimension
+SELECT subvector('[1,2,3,4,5]'::halfvec, 3, 2147483647);
+ subvector 
+-----------
+ [3,4,5]
+(1 row)
+
+SELECT subvector('[1,2,3,4,5]'::halfvec, -2147483644, 2147483647);
+ subvector 
+-----------
+ [1,2]
+(1 row)
+
+SELECT avg(v) FROM unnest(ARRAY['[1,2,3]'::halfvec, '[3,5,7]']) v;
+    avg    
+-----------
+ [2,3.5,5]
+(1 row)
+
+SELECT avg(v) FROM unnest(ARRAY['[1,2,3]'::halfvec, '[3,5,7]', NULL]) v;
+    avg    
+-----------
+ [2,3.5,5]
+(1 row)
+
+SELECT avg(v) FROM unnest(ARRAY[]::halfvec[]) v;
+ avg 
+-----
+ 
+(1 row)
+
+SELECT avg(v) FROM unnest(ARRAY['[1,2]'::halfvec, '[3]']) v;
+ERROR:  expected 2 dimensions, not 1
+SELECT avg(v) FROM unnest(ARRAY['[65504]'::halfvec, '[65504]']) v;
+   avg   
+---------
+ [65504]
+(1 row)
+
+SELECT halfvec_avg(array_agg(n)) FROM generate_series(1, 16002) n;
+ERROR:  halfvec cannot have more than 16000 dimensions
+SELECT sum(v) FROM unnest(ARRAY['[1,2,3]'::halfvec, '[3,5,7]']) v;
+   sum    
+----------
+ [4,7,10]
+(1 row)
+
+SELECT sum(v) FROM unnest(ARRAY['[1,2,3]'::halfvec, '[3,5,7]', NULL]) v;
+   sum    
+----------
+ [4,7,10]
+(1 row)
+
+SELECT sum(v) FROM unnest(ARRAY[]::halfvec[]) v;
+ sum 
+-----
+ 
+(1 row)
+
+SELECT sum(v) FROM unnest(ARRAY['[1,2]'::halfvec, '[3]']) v;
+ERROR:  different halfvec dimensions 2 and 1
+SELECT sum(v) FROM unnest(ARRAY['[65504]'::halfvec, '[65504]']) v;
+ERROR:  value out of range: overflow

test/expected/hnsw_bit.out

@@ -0,0 +1,51 @@
+SET enable_seqscan = off;
+-- hamming
+CREATE TABLE t (val bit(3));
+INSERT INTO t (val) VALUES (B'000'), (B'100'), (B'111'), (NULL);
+CREATE INDEX ON t USING hnsw (val bit_hamming_ops);
+INSERT INTO t (val) VALUES (B'110');
+SELECT * FROM t ORDER BY val <~> B'111';
+ val 
+-----
+ 111
+ 110
+ 100
+ 000
+(4 rows)
+
+SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <~> (SELECT NULL::bit)) t2;
+ count 
+-------
+     4
+(1 row)
+
+DROP TABLE t;
+-- jaccard
+CREATE TABLE t (val bit(4));
+INSERT INTO t (val) VALUES (B'0000'), (B'1100'), (B'1111'), (NULL);
+CREATE INDEX ON t USING hnsw (val bit_jaccard_ops);
+INSERT INTO t (val) VALUES (B'1110');
+SELECT * FROM t ORDER BY val <%> B'1111';
+ val  
+------
+ 1111
+ 1110
+ 1100
+ 0000
+(4 rows)
+
+SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <%> (SELECT NULL::bit)) t2;
+ count 
+-------
+     4
+(1 row)
+
+DROP TABLE t;
+-- varbit
+CREATE TABLE t (val varbit(3));
+CREATE INDEX ON t USING hnsw (val bit_hamming_ops);
+ERROR:  type not supported for hnsw index
+CREATE INDEX ON t USING hnsw ((val::bit(3)) bit_hamming_ops);
+CREATE INDEX ON t USING hnsw ((val::bit(64001)) bit_hamming_ops);
+ERROR:  column cannot have more than 64000 dimensions for hnsw index
+DROP TABLE t;

test/expected/hnsw_cosine.out

@@ -1,26 +0,0 @@
-SET enable_seqscan = off;
-CREATE TABLE t (val vector(3));
-INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
-CREATE INDEX ON t USING hnsw (val vector_cosine_ops);
-INSERT INTO t (val) VALUES ('[1,2,4]');
-SELECT * FROM t ORDER BY val <=> '[3,3,3]';
-   val   
----------
- [1,1,1]
- [1,2,3]
- [1,2,4]
-(3 rows)
-
-SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <=> '[0,0,0]') t2;
- count 
--------
-     3
-(1 row)
-
-SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <=> (SELECT NULL::vector)) t2;
- count 
--------
-     3
-(1 row)
-
-DROP TABLE t;

test/expected/hnsw_halfvec.out

@@ -0,0 +1,102 @@
+SET enable_seqscan = off;
+-- L2
+CREATE TABLE t (val halfvec(3));
+INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
+CREATE INDEX ON t USING hnsw (val halfvec_l2_ops);
+INSERT INTO t (val) VALUES ('[1,2,4]');
+SELECT * FROM t ORDER BY val <-> '[3,3,3]';
+   val   
+---------
+ [1,2,3]
+ [1,2,4]
+ [1,1,1]
+ [0,0,0]
+(4 rows)
+
+SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <-> (SELECT NULL::halfvec)) t2;
+ count 
+-------
+     4
+(1 row)
+
+SELECT COUNT(*) FROM t;
+ count 
+-------
+     5
+(1 row)
+
+TRUNCATE t;
+SELECT * FROM t ORDER BY val <-> '[3,3,3]';
+ val 
+-----
+(0 rows)
+
+DROP TABLE t;
+-- inner product
+CREATE TABLE t (val halfvec(3));
+INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
+CREATE INDEX ON t USING hnsw (val halfvec_ip_ops);
+INSERT INTO t (val) VALUES ('[1,2,4]');
+SELECT * FROM t ORDER BY val <#> '[3,3,3]';
+   val   
+---------
+ [1,2,4]
+ [1,2,3]
+ [1,1,1]
+ [0,0,0]
+(4 rows)
+
+SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <#> (SELECT NULL::halfvec)) t2;
+ count 
+-------
+     4
+(1 row)
+
+DROP TABLE t;
+-- cosine
+CREATE TABLE t (val halfvec(3));
+INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
+CREATE INDEX ON t USING hnsw (val halfvec_cosine_ops);
+INSERT INTO t (val) VALUES ('[1,2,4]');
+SELECT * FROM t ORDER BY val <=> '[3,3,3]';
+   val   
+---------
+ [1,1,1]
+ [1,2,3]
+ [1,2,4]
+(3 rows)
+
+SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <=> '[0,0,0]') t2;
+ count 
+-------
+     3
+(1 row)
+
+SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <=> (SELECT NULL::halfvec)) t2;
+ count 
+-------
+     3
+(1 row)
+
+DROP TABLE t;
+-- L1
+CREATE TABLE t (val halfvec(3));
+INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
+CREATE INDEX ON t USING hnsw (val halfvec_l1_ops);
+INSERT INTO t (val) VALUES ('[1,2,4]');
+SELECT * FROM t ORDER BY val <+> '[3,3,3]';
+   val   
+---------
+ [1,2,3]
+ [1,2,4]
+ [1,1,1]
+ [0,0,0]
+(4 rows)
+
+SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <+> (SELECT NULL::halfvec)) t2;
+ count 
+-------
+     4
+(1 row)
+
+DROP TABLE t;

test/expected/hnsw_ip.out

@@ -1,21 +0,0 @@
-SET enable_seqscan = off;
-CREATE TABLE t (val vector(3));
-INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
-CREATE INDEX ON t USING hnsw (val vector_ip_ops);
-INSERT INTO t (val) VALUES ('[1,2,4]');
-SELECT * FROM t ORDER BY val <#> '[3,3,3]';
-   val   
----------
- [1,2,4]
- [1,2,3]
- [1,1,1]
- [0,0,0]
-(4 rows)
-
-SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <#> (SELECT NULL::vector)) t2;
- count 
--------
-     4
-(1 row)
-
-DROP TABLE t;

test/expected/hnsw_l2.out

@@ -1,36 +0,0 @@
-SET enable_seqscan = off;
-CREATE TABLE t (val vector(3));
-INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
-CREATE INDEX ON t USING hnsw (val vector_l2_ops);
-INSERT INTO t (val) VALUES ('[1,2,4]');
-SELECT * FROM t ORDER BY val <-> '[3,3,3]';
-   val   
----------
- [1,2,3]
- [1,2,4]
- [1,1,1]
- [0,0,0]
-(4 rows)
-
-SELECT * FROM t ORDER BY val <-> (SELECT NULL::vector);
-   val   
----------
- [0,0,0]
- [1,1,1]
- [1,2,3]
- [1,2,4]
-(4 rows)
-
-SELECT COUNT(*) FROM t;
- count 
--------
-     5
-(1 row)
-
-TRUNCATE t;
-SELECT * FROM t ORDER BY val <-> '[3,3,3]';
- val 
------
-(0 rows)
-
-DROP TABLE t;

test/expected/hnsw_options.out

@@ -1,26 +0,0 @@
-CREATE TABLE t (val vector(3));
-CREATE INDEX ON t USING hnsw (val vector_l2_ops) WITH (m = 1);
-ERROR:  value 1 out of bounds for option "m"
-DETAIL:  Valid values are between "2" and "100".
-CREATE INDEX ON t USING hnsw (val vector_l2_ops) WITH (m = 101);
-ERROR:  value 101 out of bounds for option "m"
-DETAIL:  Valid values are between "2" and "100".
-CREATE INDEX ON t USING hnsw (val vector_l2_ops) WITH (ef_construction = 3);
-ERROR:  value 3 out of bounds for option "ef_construction"
-DETAIL:  Valid values are between "4" and "1000".
-CREATE INDEX ON t USING hnsw (val vector_l2_ops) WITH (ef_construction = 1001);
-ERROR:  value 1001 out of bounds for option "ef_construction"
-DETAIL:  Valid values are between "4" and "1000".
-CREATE INDEX ON t USING hnsw (val vector_l2_ops) WITH (m = 16, ef_construction = 31);
-ERROR:  ef_construction must be greater than or equal to 2 * m
-SHOW hnsw.ef_search;
- hnsw.ef_search 
-----------------
- 40
-(1 row)
-
-SET hnsw.ef_search = 0;
-ERROR:  0 is outside the valid range for parameter "hnsw.ef_search" (1 .. 1000)
-SET hnsw.ef_search = 1001;
-ERROR:  1001 is outside the valid range for parameter "hnsw.ef_search" (1 .. 1000)
-DROP TABLE t;

test/expected/hnsw_sparsevec.out

@@ -0,0 +1,112 @@
+SET enable_seqscan = off;
+-- L2
+CREATE TABLE t (val sparsevec(3));
+INSERT INTO t (val) VALUES ('{}/3'), ('{1:1,2:2,3:3}/3'), ('{1:1,2:1,3:1}/3'), (NULL);
+CREATE INDEX ON t USING hnsw (val sparsevec_l2_ops);
+INSERT INTO t (val) VALUES ('{1:1,2:2,3:4}/3');
+SELECT * FROM t ORDER BY val <-> '{1:3,2:3,3:3}/3';
+       val       
+-----------------
+ {1:1,2:2,3:3}/3
+ {1:1,2:2,3:4}/3
+ {1:1,2:1,3:1}/3
+ {}/3
+(4 rows)
+
+SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <-> (SELECT NULL::sparsevec)) t2;
+ count 
+-------
+     4
+(1 row)
+
+SELECT COUNT(*) FROM t;
+ count 
+-------
+     5
+(1 row)
+
+TRUNCATE t;
+SELECT * FROM t ORDER BY val <-> '{1:3,2:3,3:3}/3';
+ val 
+-----
+(0 rows)
+
+DROP TABLE t;
+-- inner product
+CREATE TABLE t (val sparsevec(3));
+INSERT INTO t (val) VALUES ('{}/3'), ('{1:1,2:2,3:3}/3'), ('{1:1,2:1,3:1}/3'), (NULL);
+CREATE INDEX ON t USING hnsw (val sparsevec_ip_ops);
+INSERT INTO t (val) VALUES ('{1:1,2:2,3:4}/3');
+SELECT * FROM t ORDER BY val <#> '{1:3,2:3,3:3}/3';
+       val       
+-----------------
+ {1:1,2:2,3:4}/3
+ {1:1,2:2,3:3}/3
+ {1:1,2:1,3:1}/3
+ {}/3
+(4 rows)
+
+SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <#> (SELECT NULL::sparsevec)) t2;
+ count 
+-------
+     4
+(1 row)
+
+DROP TABLE t;
+-- cosine
+CREATE TABLE t (val sparsevec(3));
+INSERT INTO t (val) VALUES ('{}/3'), ('{1:1,2:2,3:3}/3'), ('{1:1,2:1,3:1}/3'), (NULL);
+CREATE INDEX ON t USING hnsw (val sparsevec_cosine_ops);
+INSERT INTO t (val) VALUES ('{1:1,2:2,3:4}/3');
+SELECT * FROM t ORDER BY val <=> '{1:3,2:3,3:3}/3';
+       val       
+-----------------
+ {1:1,2:1,3:1}/3
+ {1:1,2:2,3:3}/3
+ {1:1,2:2,3:4}/3
+(3 rows)
+
+SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <=> '{}/3') t2;
+ count 
+-------
+     3
+(1 row)
+
+SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <=> (SELECT NULL::sparsevec)) t2;
+ count 
+-------
+     3
+(1 row)
+
+DROP TABLE t;
+-- L1
+CREATE TABLE t (val sparsevec(3));
+INSERT INTO t (val) VALUES ('{}/3'), ('{1:1,2:2,3:3}/3'), ('{1:1,2:1,3:1}/3'), (NULL);
+CREATE INDEX ON t USING hnsw (val sparsevec_l1_ops);
+INSERT INTO t (val) VALUES ('{1:1,2:2,3:4}/3');
+SELECT * FROM t ORDER BY val <+> '{1:3,2:3,3:3}/3';
+       val       
+-----------------
+ {1:1,2:2,3:3}/3
+ {1:1,2:2,3:4}/3
+ {1:1,2:1,3:1}/3
+ {}/3
+(4 rows)
+
+SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <+> (SELECT NULL::sparsevec)) t2;
+ count 
+-------
+     4
+(1 row)
+
+DROP TABLE t;
+-- non-zero elements
+CREATE TABLE t (val sparsevec(1001));
+INSERT INTO t (val) VALUES (array_fill(1, ARRAY[1001])::vector::sparsevec);
+CREATE INDEX ON t USING hnsw (val sparsevec_l2_ops);
+ERROR:  sparsevec cannot have more than 1000 non-zero elements for hnsw index
+TRUNCATE t;
+CREATE INDEX ON t USING hnsw (val sparsevec_l2_ops);
+INSERT INTO t (val) VALUES (array_fill(1, ARRAY[1001])::vector::sparsevec);
+ERROR:  sparsevec cannot have more than 1000 non-zero elements for hnsw index
+DROP TABLE t;

test/expected/hnsw_unlogged.out

@@ -1,13 +0,0 @@
-SET enable_seqscan = off;
-CREATE UNLOGGED TABLE t (val vector(3));
-INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
-CREATE INDEX ON t USING hnsw (val vector_l2_ops);
-SELECT * FROM t ORDER BY val <-> '[3,3,3]';
-   val   
----------
- [1,2,3]
- [1,1,1]
- [0,0,0]
-(3 rows)
-
-DROP TABLE t;

test/expected/hnsw_vector.out

@@ -0,0 +1,142 @@
+SET enable_seqscan = off;
+-- L2
+CREATE TABLE t (val vector(3));
+INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
+CREATE INDEX ON t USING hnsw (val vector_l2_ops);
+INSERT INTO t (val) VALUES ('[1,2,4]');
+SELECT * FROM t ORDER BY val <-> '[3,3,3]';
+   val   
+---------
+ [1,2,3]
+ [1,2,4]
+ [1,1,1]
+ [0,0,0]
+(4 rows)
+
+SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <-> (SELECT NULL::vector)) t2;
+ count 
+-------
+     4
+(1 row)
+
+SELECT COUNT(*) FROM t;
+ count 
+-------
+     5
+(1 row)
+
+TRUNCATE t;
+SELECT * FROM t ORDER BY val <-> '[3,3,3]';
+ val 
+-----
+(0 rows)
+
+DROP TABLE t;
+-- inner product
+CREATE TABLE t (val vector(3));
+INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
+CREATE INDEX ON t USING hnsw (val vector_ip_ops);
+INSERT INTO t (val) VALUES ('[1,2,4]');
+SELECT * FROM t ORDER BY val <#> '[3,3,3]';
+   val   
+---------
+ [1,2,4]
+ [1,2,3]
+ [1,1,1]
+ [0,0,0]
+(4 rows)
+
+SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <#> (SELECT NULL::vector)) t2;
+ count 
+-------
+     4
+(1 row)
+
+DROP TABLE t;
+-- cosine
+CREATE TABLE t (val vector(3));
+INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
+CREATE INDEX ON t USING hnsw (val vector_cosine_ops);
+INSERT INTO t (val) VALUES ('[1,2,4]');
+SELECT * FROM t ORDER BY val <=> '[3,3,3]';
+   val   
+---------
+ [1,1,1]
+ [1,2,3]
+ [1,2,4]
+(3 rows)
+
+SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <=> '[0,0,0]') t2;
+ count 
+-------
+     3
+(1 row)
+
+SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <=> (SELECT NULL::vector)) t2;
+ count 
+-------
+     3
+(1 row)
+
+DROP TABLE t;
+-- L1
+CREATE TABLE t (val vector(3));
+INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
+CREATE INDEX ON t USING hnsw (val vector_l1_ops);
+INSERT INTO t (val) VALUES ('[1,2,4]');
+SELECT * FROM t ORDER BY val <+> '[3,3,3]';
+   val   
+---------
+ [1,2,3]
+ [1,2,4]
+ [1,1,1]
+ [0,0,0]
+(4 rows)
+
+SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <+> (SELECT NULL::vector)) t2;
+ count 
+-------
+     4
+(1 row)
+
+DROP TABLE t;
+-- unlogged
+CREATE UNLOGGED TABLE t (val vector(3));
+INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
+CREATE INDEX ON t USING hnsw (val vector_l2_ops);
+SELECT * FROM t ORDER BY val <-> '[3,3,3]';
+   val   
+---------
+ [1,2,3]
+ [1,1,1]
+ [0,0,0]
+(3 rows)
+
+DROP TABLE t;
+-- options
+CREATE TABLE t (val vector(3));
+CREATE INDEX ON t USING hnsw (val vector_l2_ops) WITH (m = 1);
+ERROR:  value 1 out of bounds for option "m"
+DETAIL:  Valid values are between "2" and "100".
+CREATE INDEX ON t USING hnsw (val vector_l2_ops) WITH (m = 101);
+ERROR:  value 101 out of bounds for option "m"
+DETAIL:  Valid values are between "2" and "100".
+CREATE INDEX ON t USING hnsw (val vector_l2_ops) WITH (ef_construction = 3);
+ERROR:  value 3 out of bounds for option "ef_construction"
+DETAIL:  Valid values are between "4" and "1000".
+CREATE INDEX ON t USING hnsw (val vector_l2_ops) WITH (ef_construction = 1001);
+ERROR:  value 1001 out of bounds for option "ef_construction"
+DETAIL:  Valid values are between "4" and "1000".
+CREATE INDEX ON t USING hnsw (val vector_l2_ops) WITH (m = 16, ef_construction = 31);
+ERROR:  ef_construction must be greater than or equal to 2 * m
+SHOW hnsw.ef_search;
+ hnsw.ef_search 
+----------------
+ 40
+(1 row)
+
+SET hnsw.ef_search = 0;
+ERROR:  0 is outside the valid range for parameter "hnsw.ef_search" (1 .. 1000)
+SET hnsw.ef_search = 1001;
+ERROR:  1001 is outside the valid range for parameter "hnsw.ef_search" (1 .. 1000)
+DROP TABLE t;

test/expected/input.out

@@ -1,129 +0,0 @@
-SELECT '[1,2,3]'::vector;
- vector  
----------
- [1,2,3]
-(1 row)
-
-SELECT '[-1,-2,-3]'::vector;
-   vector   
-------------
- [-1,-2,-3]
-(1 row)
-
-SELECT '[1.,2.,3.]'::vector;
- vector  
----------
- [1,2,3]
-(1 row)
-
-SELECT ' [ 1,  2 ,    3  ] '::vector;
- vector  
----------
- [1,2,3]
-(1 row)
-
-SELECT '[1.23456]'::vector;
-  vector   
------------
- [1.23456]
-(1 row)
-
-SELECT '[hello,1]'::vector;
-ERROR:  invalid input syntax for type vector: "[hello,1]"
-LINE 1: SELECT '[hello,1]'::vector;
-               ^
-SELECT '[NaN,1]'::vector;
-ERROR:  NaN not allowed in vector
-LINE 1: SELECT '[NaN,1]'::vector;
-               ^
-SELECT '[Infinity,1]'::vector;
-ERROR:  infinite value not allowed in vector
-LINE 1: SELECT '[Infinity,1]'::vector;
-               ^
-SELECT '[-Infinity,1]'::vector;
-ERROR:  infinite value not allowed in vector
-LINE 1: SELECT '[-Infinity,1]'::vector;
-               ^
-SELECT '[1.5e38,-1.5e38]'::vector;
-       vector       
---------------------
- [1.5e+38,-1.5e+38]
-(1 row)
-
-SELECT '[1.5e+38,-1.5e+38]'::vector;
-       vector       
---------------------
- [1.5e+38,-1.5e+38]
-(1 row)
-
-SELECT '[1.5e-38,-1.5e-38]'::vector;
-       vector       
---------------------
- [1.5e-38,-1.5e-38]
-(1 row)
-
-SELECT '[4e38,1]'::vector;
-ERROR:  infinite value not allowed in vector
-LINE 1: SELECT '[4e38,1]'::vector;
-               ^
-SELECT '[1,2,3'::vector;
-ERROR:  malformed vector literal: "[1,2,3"
-LINE 1: SELECT '[1,2,3'::vector;
-               ^
-DETAIL:  Unexpected end of input.
-SELECT '[1,2,3]9'::vector;
-ERROR:  malformed vector literal: "[1,2,3]9"
-LINE 1: SELECT '[1,2,3]9'::vector;
-               ^
-DETAIL:  Junk after closing right brace.
-SELECT '1,2,3'::vector;
-ERROR:  malformed vector literal: "1,2,3"
-LINE 1: SELECT '1,2,3'::vector;
-               ^
-DETAIL:  Vector contents must start with "[".
-SELECT ''::vector;
-ERROR:  malformed vector literal: ""
-LINE 1: SELECT ''::vector;
-               ^
-DETAIL:  Vector contents must start with "[".
-SELECT '['::vector;
-ERROR:  malformed vector literal: "["
-LINE 1: SELECT '['::vector;
-               ^
-DETAIL:  Unexpected end of input.
-SELECT '[,'::vector;
-ERROR:  malformed vector literal: "[,"
-LINE 1: SELECT '[,'::vector;
-               ^
-DETAIL:  Unexpected end of input.
-SELECT '[]'::vector;
-ERROR:  vector must have at least 1 dimension
-LINE 1: SELECT '[]'::vector;
-               ^
-SELECT '[1,]'::vector;
-ERROR:  invalid input syntax for type vector: "[1,]"
-LINE 1: SELECT '[1,]'::vector;
-               ^
-SELECT '[1a]'::vector;
-ERROR:  invalid input syntax for type vector: "[1a]"
-LINE 1: SELECT '[1a]'::vector;
-               ^
-SELECT '[1,,3]'::vector;
-ERROR:  malformed vector literal: "[1,,3]"
-LINE 1: SELECT '[1,,3]'::vector;
-               ^
-SELECT '[1, ,3]'::vector;
-ERROR:  invalid input syntax for type vector: "[1, ,3]"
-LINE 1: SELECT '[1, ,3]'::vector;
-               ^
-SELECT '[1,2,3]'::vector(2);
-ERROR:  expected 2 dimensions, not 3
-SELECT unnest('{"[1,2,3]", "[4,5,6]"}'::vector[]);
- unnest  
----------
- [1,2,3]
- [4,5,6]
-(2 rows)
-
-SELECT '{"[1,2,3]"}'::vector(2)[];
-ERROR:  expected 2 dimensions, not 3

test/expected/ivfflat_bit.out

@@ -0,0 +1,37 @@
+SET enable_seqscan = off;
+-- hamming
+CREATE TABLE t (val bit(3));
+INSERT INTO t (val) VALUES (B'000'), (B'100'), (B'111'), (NULL);
+CREATE INDEX ON t USING ivfflat (val bit_hamming_ops) WITH (lists = 1);
+INSERT INTO t (val) VALUES (B'110');
+SELECT * FROM t ORDER BY val <~> B'111';
+ val 
+-----
+ 111
+ 110
+ 100
+ 000
+(4 rows)
+
+SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <~> (SELECT NULL::bit)) t2;
+ count 
+-------
+     4
+(1 row)
+
+DROP TABLE t;
+-- varbit
+CREATE TABLE t (val varbit(3));
+CREATE INDEX ON t USING ivfflat (val bit_hamming_ops) WITH (lists = 1);
+ERROR:  type not supported for ivfflat index
+CREATE INDEX ON t USING ivfflat ((val::bit(3)) bit_hamming_ops) WITH (lists = 1);
+NOTICE:  ivfflat index created with little data
+DETAIL:  This will cause low recall.
+HINT:  Drop the index until the table has more data.
+CREATE INDEX ON t USING ivfflat ((val::bit(64001)) bit_hamming_ops) WITH (lists = 1);
+ERROR:  column cannot have more than 64000 dimensions for ivfflat index
+CREATE INDEX ON t USING ivfflat ((val::bit(2)) bit_hamming_ops) WITH (lists = 5);
+NOTICE:  ivfflat index created with little data
+DETAIL:  This will cause low recall.
+HINT:  Drop the index until the table has more data.
+DROP TABLE t;

test/expected/ivfflat_cosine.out

@@ -1,26 +0,0 @@
-SET enable_seqscan = off;
-CREATE TABLE t (val vector(3));
-INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
-CREATE INDEX ON t USING ivfflat (val vector_cosine_ops) WITH (lists = 1);
-INSERT INTO t (val) VALUES ('[1,2,4]');
-SELECT * FROM t ORDER BY val <=> '[3,3,3]';
-   val   
----------
- [1,1,1]
- [1,2,3]
- [1,2,4]
-(3 rows)
-
-SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <=> '[0,0,0]') t2;
- count 
--------
-     3
-(1 row)
-
-SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <=> (SELECT NULL::vector)) t2;
- count 
--------
-     3
-(1 row)
-
-DROP TABLE t;

test/expected/ivfflat_halfvec.out

@@ -0,0 +1,84 @@
+SET enable_seqscan = off;
+-- L2
+CREATE TABLE t (val halfvec(3));
+INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
+CREATE INDEX ON t USING ivfflat (val halfvec_l2_ops) WITH (lists = 1);
+INSERT INTO t (val) VALUES ('[1,2,4]');
+SELECT * FROM t ORDER BY val <-> '[3,3,3]';
+   val   
+---------
+ [1,2,3]
+ [1,2,4]
+ [1,1,1]
+ [0,0,0]
+(4 rows)
+
+SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <-> (SELECT NULL::halfvec)) t2;
+ count 
+-------
+     4
+(1 row)
+
+SELECT COUNT(*) FROM t;
+ count 
+-------
+     5
+(1 row)
+
+TRUNCATE t;
+NOTICE:  ivfflat index created with little data
+DETAIL:  This will cause low recall.
+HINT:  Drop the index until the table has more data.
+SELECT * FROM t ORDER BY val <-> '[3,3,3]';
+ val 
+-----
+(0 rows)
+
+DROP TABLE t;
+-- inner product
+CREATE TABLE t (val halfvec(3));
+INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
+CREATE INDEX ON t USING ivfflat (val halfvec_ip_ops) WITH (lists = 1);
+INSERT INTO t (val) VALUES ('[1,2,4]');
+SELECT * FROM t ORDER BY val <#> '[3,3,3]';
+   val   
+---------
+ [1,2,4]
+ [1,2,3]
+ [1,1,1]
+ [0,0,0]
+(4 rows)
+
+SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <#> (SELECT NULL::halfvec)) t2;
+ count 
+-------
+     4
+(1 row)
+
+DROP TABLE t;
+-- cosine
+CREATE TABLE t (val halfvec(3));
+INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
+CREATE INDEX ON t USING ivfflat (val halfvec_cosine_ops) WITH (lists = 1);
+INSERT INTO t (val) VALUES ('[1,2,4]');
+SELECT * FROM t ORDER BY val <=> '[3,3,3]';
+   val   
+---------
+ [1,1,1]
+ [1,2,3]
+ [1,2,4]
+(3 rows)
+
+SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <=> '[0,0,0]') t2;
+ count 
+-------
+     3
+(1 row)
+
+SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <=> (SELECT NULL::halfvec)) t2;
+ count 
+-------
+     3
+(1 row)
+
+DROP TABLE t;

test/expected/ivfflat_ip.out

@@ -1,21 +0,0 @@
-SET enable_seqscan = off;
-CREATE TABLE t (val vector(3));
-INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
-CREATE INDEX ON t USING ivfflat (val vector_ip_ops) WITH (lists = 1);
-INSERT INTO t (val) VALUES ('[1,2,4]');
-SELECT * FROM t ORDER BY val <#> '[3,3,3]';
-   val   
----------
- [1,2,4]
- [1,2,3]
- [1,1,1]
- [0,0,0]
-(4 rows)
-
-SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <#> (SELECT NULL::vector)) t2;
- count 
--------
-     4
-(1 row)
-
-DROP TABLE t;

test/expected/ivfflat_l2.out

@@ -1,39 +0,0 @@
-SET enable_seqscan = off;
-CREATE TABLE t (val vector(3));
-INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
-CREATE INDEX ON t USING ivfflat (val vector_l2_ops) WITH (lists = 1);
-INSERT INTO t (val) VALUES ('[1,2,4]');
-SELECT * FROM t ORDER BY val <-> '[3,3,3]';
-   val   
----------
- [1,2,3]
- [1,2,4]
- [1,1,1]
- [0,0,0]
-(4 rows)
-
-SELECT * FROM t ORDER BY val <-> (SELECT NULL::vector);
-   val   
----------
- [0,0,0]
- [1,1,1]
- [1,2,3]
- [1,2,4]
-(4 rows)
-
-SELECT COUNT(*) FROM t;
- count 
--------
-     5
-(1 row)
-
-TRUNCATE t;
-NOTICE:  ivfflat index created with little data
-DETAIL:  This will cause low recall.
-HINT:  Drop the index until the table has more data.
-SELECT * FROM t ORDER BY val <-> '[3,3,3]';
- val 
------
-(0 rows)
-
-DROP TABLE t;

test/expected/ivfflat_options.out

@@ -1,14 +0,0 @@
-CREATE TABLE t (val vector(3));
-CREATE INDEX ON t USING ivfflat (val vector_l2_ops) WITH (lists = 0);
-ERROR:  value 0 out of bounds for option "lists"
-DETAIL:  Valid values are between "1" and "32768".
-CREATE INDEX ON t USING ivfflat (val vector_l2_ops) WITH (lists = 32769);
-ERROR:  value 32769 out of bounds for option "lists"
-DETAIL:  Valid values are between "1" and "32768".
-SHOW ivfflat.probes;
- ivfflat.probes 
-----------------
- 1
-(1 row)
-
-DROP TABLE t;

test/expected/ivfflat_unlogged.out

@@ -1,13 +0,0 @@
-SET enable_seqscan = off;
-CREATE UNLOGGED TABLE t (val vector(3));
-INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
-CREATE INDEX ON t USING ivfflat (val vector_l2_ops) WITH (lists = 1);
-SELECT * FROM t ORDER BY val <-> '[3,3,3]';
-   val   
----------
- [1,2,3]
- [1,1,1]
- [0,0,0]
-(3 rows)
-
-DROP TABLE t;

test/expected/ivfflat_vector.out

@@ -0,0 +1,112 @@
+SET enable_seqscan = off;
+-- L2
+CREATE TABLE t (val vector(3));
+INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
+CREATE INDEX ON t USING ivfflat (val vector_l2_ops) WITH (lists = 1);
+INSERT INTO t (val) VALUES ('[1,2,4]');
+SELECT * FROM t ORDER BY val <-> '[3,3,3]';
+   val   
+---------
+ [1,2,3]
+ [1,2,4]
+ [1,1,1]
+ [0,0,0]
+(4 rows)
+
+SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <-> (SELECT NULL::vector)) t2;
+ count 
+-------
+     4
+(1 row)
+
+SELECT COUNT(*) FROM t;
+ count 
+-------
+     5
+(1 row)
+
+TRUNCATE t;
+NOTICE:  ivfflat index created with little data
+DETAIL:  This will cause low recall.
+HINT:  Drop the index until the table has more data.
+SELECT * FROM t ORDER BY val <-> '[3,3,3]';
+ val 
+-----
+(0 rows)
+
+DROP TABLE t;
+-- inner product
+CREATE TABLE t (val vector(3));
+INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
+CREATE INDEX ON t USING ivfflat (val vector_ip_ops) WITH (lists = 1);
+INSERT INTO t (val) VALUES ('[1,2,4]');
+SELECT * FROM t ORDER BY val <#> '[3,3,3]';
+   val   
+---------
+ [1,2,4]
+ [1,2,3]
+ [1,1,1]
+ [0,0,0]
+(4 rows)
+
+SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <#> (SELECT NULL::vector)) t2;
+ count 
+-------
+     4
+(1 row)
+
+DROP TABLE t;
+-- cosine
+CREATE TABLE t (val vector(3));
+INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
+CREATE INDEX ON t USING ivfflat (val vector_cosine_ops) WITH (lists = 1);
+INSERT INTO t (val) VALUES ('[1,2,4]');
+SELECT * FROM t ORDER BY val <=> '[3,3,3]';
+   val   
+---------
+ [1,1,1]
+ [1,2,3]
+ [1,2,4]
+(3 rows)
+
+SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <=> '[0,0,0]') t2;
+ count 
+-------
+     3
+(1 row)
+
+SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <=> (SELECT NULL::vector)) t2;
+ count 
+-------
+     3
+(1 row)
+
+DROP TABLE t;
+-- unlogged
+CREATE UNLOGGED TABLE t (val vector(3));
+INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
+CREATE INDEX ON t USING ivfflat (val vector_l2_ops) WITH (lists = 1);
+SELECT * FROM t ORDER BY val <-> '[3,3,3]';
+   val   
+---------
+ [1,2,3]
+ [1,1,1]
+ [0,0,0]
+(3 rows)
+
+DROP TABLE t;
+-- options
+CREATE TABLE t (val vector(3));
+CREATE INDEX ON t USING ivfflat (val vector_l2_ops) WITH (lists = 0);
+ERROR:  value 0 out of bounds for option "lists"
+DETAIL:  Valid values are between "1" and "32768".
+CREATE INDEX ON t USING ivfflat (val vector_l2_ops) WITH (lists = 32769);
+ERROR:  value 32769 out of bounds for option "lists"
+DETAIL:  Valid values are between "1" and "32768".
+SHOW ivfflat.probes;
+ ivfflat.probes 
+----------------
+ 1
+(1 row)
+
+DROP TABLE t;

test/expected/sparsevec.out

@@ -0,0 +1,653 @@
+SELECT '{1:1.5,3:3.5}/5'::sparsevec;
+    sparsevec    
+-----------------
+ {1:1.5,3:3.5}/5
+(1 row)
+
+SELECT '{1:-2,3:-4}/5'::sparsevec;
+   sparsevec   
+---------------
+ {1:-2,3:-4}/5
+(1 row)
+
+SELECT '{1:2.,3:4.}/5'::sparsevec;
+  sparsevec  
+-------------
+ {1:2,3:4}/5
+(1 row)
+
+SELECT ' { 1 : 1.5 ,  3  :  3.5  } / 5 '::sparsevec;
+    sparsevec    
+-----------------
+ {1:1.5,3:3.5}/5
+(1 row)
+
+SELECT '{1:1.23456}/1'::sparsevec;
+   sparsevec   
+---------------
+ {1:1.23456}/1
+(1 row)
+
+SELECT '{1:hello,2:1}/2'::sparsevec;
+ERROR:  invalid input syntax for type sparsevec: "{1:hello,2:1}/2"
+LINE 1: SELECT '{1:hello,2:1}/2'::sparsevec;
+               ^
+SELECT '{1:NaN,2:1}/2'::sparsevec;
+ERROR:  NaN not allowed in sparsevec
+LINE 1: SELECT '{1:NaN,2:1}/2'::sparsevec;
+               ^
+SELECT '{1:Infinity,2:1}/2'::sparsevec;
+ERROR:  infinite value not allowed in sparsevec
+LINE 1: SELECT '{1:Infinity,2:1}/2'::sparsevec;
+               ^
+SELECT '{1:-Infinity,2:1}/2'::sparsevec;
+ERROR:  infinite value not allowed in sparsevec
+LINE 1: SELECT '{1:-Infinity,2:1}/2'::sparsevec;
+               ^
+SELECT '{1:1.5e38,2:-1.5e38}/2'::sparsevec;
+        sparsevec         
+--------------------------
+ {1:1.5e+38,2:-1.5e+38}/2
+(1 row)
+
+SELECT '{1:1.5e+38,2:-1.5e+38}/2'::sparsevec;
+        sparsevec         
+--------------------------
+ {1:1.5e+38,2:-1.5e+38}/2
+(1 row)
+
+SELECT '{1:1.5e-38,2:-1.5e-38}/2'::sparsevec;
+        sparsevec         
+--------------------------
+ {1:1.5e-38,2:-1.5e-38}/2
+(1 row)
+
+SELECT '{1:4e38,2:1}/2'::sparsevec;
+ERROR:  "4e38" is out of range for type sparsevec
+LINE 1: SELECT '{1:4e38,2:1}/2'::sparsevec;
+               ^
+SELECT '{1:-4e38,2:1}/2'::sparsevec;
+ERROR:  "-4e38" is out of range for type sparsevec
+LINE 1: SELECT '{1:-4e38,2:1}/2'::sparsevec;
+               ^
+SELECT '{1:1e-46,2:1}/2'::sparsevec;
+ERROR:  "1e-46" is out of range for type sparsevec
+LINE 1: SELECT '{1:1e-46,2:1}/2'::sparsevec;
+               ^
+SELECT '{1:-1e-46,2:1}/2'::sparsevec;
+ERROR:  "-1e-46" is out of range for type sparsevec
+LINE 1: SELECT '{1:-1e-46,2:1}/2'::sparsevec;
+               ^
+SELECT ''::sparsevec;
+ERROR:  invalid input syntax for type sparsevec: ""
+LINE 1: SELECT ''::sparsevec;
+               ^
+DETAIL:  Vector contents must start with "{".
+SELECT '{'::sparsevec;
+ERROR:  invalid input syntax for type sparsevec: "{"
+LINE 1: SELECT '{'::sparsevec;
+               ^
+SELECT '{ '::sparsevec;
+ERROR:  invalid input syntax for type sparsevec: "{ "
+LINE 1: SELECT '{ '::sparsevec;
+               ^
+SELECT '{:'::sparsevec;
+ERROR:  invalid input syntax for type sparsevec: "{:"
+LINE 1: SELECT '{:'::sparsevec;
+               ^
+SELECT '{,'::sparsevec;
+ERROR:  invalid input syntax for type sparsevec: "{,"
+LINE 1: SELECT '{,'::sparsevec;
+               ^
+SELECT '{}'::sparsevec;
+ERROR:  invalid input syntax for type sparsevec: "{}"
+LINE 1: SELECT '{}'::sparsevec;
+               ^
+DETAIL:  Unexpected end of input.
+SELECT '{}/'::sparsevec;
+ERROR:  invalid input syntax for type sparsevec: "{}/"
+LINE 1: SELECT '{}/'::sparsevec;
+               ^
+SELECT '{}/1'::sparsevec;
+ sparsevec 
+-----------
+ {}/1
+(1 row)
+
+SELECT '{}/1a'::sparsevec;
+ERROR:  invalid input syntax for type sparsevec: "{}/1a"
+LINE 1: SELECT '{}/1a'::sparsevec;
+               ^
+DETAIL:  Junk after closing.
+SELECT '{ }/1'::sparsevec;
+ sparsevec 
+-----------
+ {}/1
+(1 row)
+
+SELECT '{:}/1'::sparsevec;
+ERROR:  invalid input syntax for type sparsevec: "{:}/1"
+LINE 1: SELECT '{:}/1'::sparsevec;
+               ^
+SELECT '{,}/1'::sparsevec;
+ERROR:  invalid input syntax for type sparsevec: "{,}/1"
+LINE 1: SELECT '{,}/1'::sparsevec;
+               ^
+SELECT '{1,}/1'::sparsevec;
+ERROR:  invalid input syntax for type sparsevec: "{1,}/1"
+LINE 1: SELECT '{1,}/1'::sparsevec;
+               ^
+SELECT '{:1}/1'::sparsevec;
+ERROR:  invalid input syntax for type sparsevec: "{:1}/1"
+LINE 1: SELECT '{:1}/1'::sparsevec;
+               ^
+SELECT '{1:}/1'::sparsevec;
+ERROR:  invalid input syntax for type sparsevec: "{1:}/1"
+LINE 1: SELECT '{1:}/1'::sparsevec;
+               ^
+SELECT '{1a:1}/1'::sparsevec;
+ERROR:  invalid input syntax for type sparsevec: "{1a:1}/1"
+LINE 1: SELECT '{1a:1}/1'::sparsevec;
+               ^
+SELECT '{1:1a}/1'::sparsevec;
+ERROR:  invalid input syntax for type sparsevec: "{1:1a}/1"
+LINE 1: SELECT '{1:1a}/1'::sparsevec;
+               ^
+SELECT '{1:1,}/1'::sparsevec;
+ERROR:  invalid input syntax for type sparsevec: "{1:1,}/1"
+LINE 1: SELECT '{1:1,}/1'::sparsevec;
+               ^
+SELECT '{1:0,2:1,3:0}/3'::sparsevec;
+ sparsevec 
+-----------
+ {2:1}/3
+(1 row)
+
+SELECT '{2:1,1:1}/2'::sparsevec;
+  sparsevec  
+-------------
+ {1:1,2:1}/2
+(1 row)
+
+SELECT '{1:1,1:1}/2'::sparsevec;
+ERROR:  sparsevec indices must not contain duplicates
+LINE 1: SELECT '{1:1,1:1}/2'::sparsevec;
+               ^
+SELECT '{1:1,2:1,1:1}/2'::sparsevec;
+ERROR:  sparsevec indices must not contain duplicates
+LINE 1: SELECT '{1:1,2:1,1:1}/2'::sparsevec;
+               ^
+SELECT '{}/5'::sparsevec;
+ sparsevec 
+-----------
+ {}/5
+(1 row)
+
+SELECT '{}/-1'::sparsevec;
+ERROR:  sparsevec must have at least 1 dimension
+LINE 1: SELECT '{}/-1'::sparsevec;
+               ^
+SELECT '{}/1000000001'::sparsevec;
+ERROR:  sparsevec cannot have more than 1000000000 dimensions
+LINE 1: SELECT '{}/1000000001'::sparsevec;
+               ^
+SELECT '{}/2147483648'::sparsevec;
+ERROR:  sparsevec cannot have more than 1000000000 dimensions
+LINE 1: SELECT '{}/2147483648'::sparsevec;
+               ^
+SELECT '{}/-2147483649'::sparsevec;
+ERROR:  sparsevec must have at least 1 dimension
+LINE 1: SELECT '{}/-2147483649'::sparsevec;
+               ^
+SELECT '{}/9223372036854775808'::sparsevec;
+ERROR:  sparsevec cannot have more than 1000000000 dimensions
+LINE 1: SELECT '{}/9223372036854775808'::sparsevec;
+               ^
+SELECT '{}/-9223372036854775809'::sparsevec;
+ERROR:  sparsevec must have at least 1 dimension
+LINE 1: SELECT '{}/-9223372036854775809'::sparsevec;
+               ^
+SELECT '{2147483647:1}/1'::sparsevec;
+ERROR:  sparsevec index out of bounds
+LINE 1: SELECT '{2147483647:1}/1'::sparsevec;
+               ^
+SELECT '{2147483648:1}/1'::sparsevec;
+ERROR:  sparsevec index out of bounds
+LINE 1: SELECT '{2147483648:1}/1'::sparsevec;
+               ^
+SELECT '{-2147483648:1}/1'::sparsevec;
+ERROR:  sparsevec index out of bounds
+LINE 1: SELECT '{-2147483648:1}/1'::sparsevec;
+               ^
+SELECT '{-2147483649:1}/1'::sparsevec;
+ERROR:  sparsevec index out of bounds
+LINE 1: SELECT '{-2147483649:1}/1'::sparsevec;
+               ^
+SELECT '{0:1}/1'::sparsevec;
+ERROR:  sparsevec index out of bounds
+LINE 1: SELECT '{0:1}/1'::sparsevec;
+               ^
+SELECT '{2:1}/1'::sparsevec;
+ERROR:  sparsevec index out of bounds
+LINE 1: SELECT '{2:1}/1'::sparsevec;
+               ^
+SELECT '{}/3'::sparsevec(3);
+ sparsevec 
+-----------
+ {}/3
+(1 row)
+
+SELECT '{}/3'::sparsevec(2);
+ERROR:  expected 2 dimensions, not 3
+SELECT '{}/3'::sparsevec(3, 2);
+ERROR:  invalid type modifier
+LINE 1: SELECT '{}/3'::sparsevec(3, 2);
+                       ^
+SELECT '{}/3'::sparsevec('a');
+ERROR:  invalid input syntax for type integer: "a"
+LINE 1: SELECT '{}/3'::sparsevec('a');
+                       ^
+SELECT '{}/3'::sparsevec(0);
+ERROR:  dimensions for type sparsevec must be at least 1
+LINE 1: SELECT '{}/3'::sparsevec(0);
+                       ^
+SELECT '{}/3'::sparsevec(1000000001);
+ERROR:  dimensions for type sparsevec cannot exceed 1000000000
+LINE 1: SELECT '{}/3'::sparsevec(1000000001);
+                       ^
+SELECT '{1:1,2:2,3:3}/3'::sparsevec < '{1:1,2:2,3:3}/3';
+ ?column? 
+----------
+ f
+(1 row)
+
+SELECT '{1:1,2:2,3:3}/3'::sparsevec < '{1:1,2:2}/2';
+ ?column? 
+----------
+ f
+(1 row)
+
+SELECT '{1:1,2:2,3:3}/3'::sparsevec <= '{1:1,2:2,3:3}/3';
+ ?column? 
+----------
+ t
+(1 row)
+
+SELECT '{1:1,2:2,3:3}/3'::sparsevec <= '{1:1,2:2}/2';
+ ?column? 
+----------
+ f
+(1 row)
+
+SELECT '{1:1,2:2,3:3}/3'::sparsevec = '{1:1,2:2,3:3}/3';
+ ?column? 
+----------
+ t
+(1 row)
+
+SELECT '{1:1,2:2,3:3}/3'::sparsevec = '{1:1,2:2}/2';
+ ?column? 
+----------
+ f
+(1 row)
+
+SELECT '{1:1,2:2,3:3}/3'::sparsevec != '{1:1,2:2,3:3}/3';
+ ?column? 
+----------
+ f
+(1 row)
+
+SELECT '{1:1,2:2,3:3}/3'::sparsevec != '{1:1,2:2}/2';
+ ?column? 
+----------
+ t
+(1 row)
+
+SELECT '{1:1,2:2,3:3}/3'::sparsevec >= '{1:1,2:2,3:3}/3';
+ ?column? 
+----------
+ t
+(1 row)
+
+SELECT '{1:1,2:2,3:3}/3'::sparsevec >= '{1:1,2:2}/2';
+ ?column? 
+----------
+ t
+(1 row)
+
+SELECT '{1:1,2:2,3:3}/3'::sparsevec > '{1:1,2:2,3:3}/3';
+ ?column? 
+----------
+ f
+(1 row)
+
+SELECT '{1:1,2:2,3:3}/3'::sparsevec > '{1:1,2:2}/2';
+ ?column? 
+----------
+ t
+(1 row)
+
+SELECT sparsevec_cmp('{1:1,2:2,3:3}/3', '{1:1,2:2,3:3}/3');
+ sparsevec_cmp 
+---------------
+             0
+(1 row)
+
+SELECT sparsevec_cmp('{1:1,2:2,3:3}/3', '{}/3');
+ sparsevec_cmp 
+---------------
+             1
+(1 row)
+
+SELECT sparsevec_cmp('{}/3', '{1:1,2:2,3:3}/3');
+ sparsevec_cmp 
+---------------
+            -1
+(1 row)
+
+SELECT sparsevec_cmp('{1:1,2:2}/2', '{1:1,2:2,3:3}/3');
+ sparsevec_cmp 
+---------------
+            -1
+(1 row)
+
+SELECT sparsevec_cmp('{1:1,2:2,3:3}/3', '{1:1,2:2}/2');
+ sparsevec_cmp 
+---------------
+             1
+(1 row)
+
+SELECT sparsevec_cmp('{1:1,2:2}/2', '{1:2,2:3,3:4}/3');
+ sparsevec_cmp 
+---------------
+            -1
+(1 row)
+
+SELECT sparsevec_cmp('{1:2,2:3}/2', '{1:1,2:2,3:3}/3');
+ sparsevec_cmp 
+---------------
+             1
+(1 row)
+
+SELECT round(l2_norm('{1:1,2:1}/2'::sparsevec)::numeric, 5);
+  round  
+---------
+ 1.41421
+(1 row)
+
+SELECT l2_norm('{1:3,2:4}/2'::sparsevec);
+ l2_norm 
+---------
+       5
+(1 row)
+
+SELECT l2_norm('{2:1}/2'::sparsevec);
+ l2_norm 
+---------
+       1
+(1 row)
+
+SELECT l2_norm('{1:3e37,2:4e37}/2'::sparsevec)::real;
+ l2_norm 
+---------
+   5e+37
+(1 row)
+
+SELECT l2_norm('{}/2'::sparsevec);
+ l2_norm 
+---------
+       0
+(1 row)
+
+SELECT l2_norm('{1:2}/1'::sparsevec);
+ l2_norm 
+---------
+       2
+(1 row)
+
+SELECT l2_distance('{}/2'::sparsevec, '{1:3,2:4}/2');
+ l2_distance 
+-------------
+           5
+(1 row)
+
+SELECT l2_distance('{1:3}/2'::sparsevec, '{2:4}/2');
+ l2_distance 
+-------------
+           5
+(1 row)
+
+SELECT l2_distance('{2:4}/2'::sparsevec, '{1:3}/2');
+ l2_distance 
+-------------
+           5
+(1 row)
+
+SELECT l2_distance('{1:3,2:4}/2'::sparsevec, '{}/2');
+ l2_distance 
+-------------
+           5
+(1 row)
+
+SELECT l2_distance('{}/2'::sparsevec, '{2:1}/2');
+ l2_distance 
+-------------
+           1
+(1 row)
+
+SELECT '{}/2'::sparsevec <-> '{1:3,2:4}/2';
+ ?column? 
+----------
+        5
+(1 row)
+
+SELECT inner_product('{1:1,2:2}/2'::sparsevec, '{1:2,2:4}/2');
+ inner_product 
+---------------
+            10
+(1 row)
+
+SELECT inner_product('{1:1,2:2}/2'::sparsevec, '{1:3}/1');
+ERROR:  different sparsevec dimensions 2 and 1
+SELECT inner_product('{1:1,3:3}/4'::sparsevec, '{2:2,4:4}/4');
+ inner_product 
+---------------
+             0
+(1 row)
+
+SELECT inner_product('{2:2,4:4}/4'::sparsevec, '{1:1,3:3}/4');
+ inner_product 
+---------------
+             0
+(1 row)
+
+SELECT inner_product('{1:1,3:3,5:5}/5'::sparsevec, '{2:4,3:6,4:8}/5');
+ inner_product 
+---------------
+            18
+(1 row)
+
+SELECT inner_product('{1:1}/2'::sparsevec, '{}/2');
+ inner_product 
+---------------
+             0
+(1 row)
+
+SELECT inner_product('{}/2'::sparsevec, '{1:1}/2');
+ inner_product 
+---------------
+             0
+(1 row)
+
+SELECT inner_product('{1:3e38}/1'::sparsevec, '{1:3e38}/1');
+ inner_product 
+---------------
+      Infinity
+(1 row)
+
+SELECT inner_product('{1:1,3:3,5:5}/5'::sparsevec, '{2:4,3:6,4:8}/5');
+ inner_product 
+---------------
+            18
+(1 row)
+
+SELECT '{1:1,2:2}/2'::sparsevec <#> '{1:3,2:4}/2';
+ ?column? 
+----------
+      -11
+(1 row)
+
+SELECT cosine_distance('{1:1,2:2}/2'::sparsevec, '{1:2,2:4}/2');
+ cosine_distance 
+-----------------
+               0
+(1 row)
+
+SELECT cosine_distance('{1:1,2:2}/2'::sparsevec, '{}/2');
+ cosine_distance 
+-----------------
+             NaN
+(1 row)
+
+SELECT cosine_distance('{1:1,2:1}/2'::sparsevec, '{1:1,2:1}/2');
+ cosine_distance 
+-----------------
+               0
+(1 row)
+
+SELECT cosine_distance('{1:1}/2'::sparsevec, '{2:2}/2');
+ cosine_distance 
+-----------------
+               1
+(1 row)
+
+SELECT cosine_distance('{1:1,2:1}/2'::sparsevec, '{1:-1,2:-1}/2');
+ cosine_distance 
+-----------------
+               2
+(1 row)
+
+SELECT cosine_distance('{1:2}/2'::sparsevec, '{2:2}/2');
+ cosine_distance 
+-----------------
+               1
+(1 row)
+
+SELECT cosine_distance('{2:2}/2'::sparsevec, '{1:2}/2');
+ cosine_distance 
+-----------------
+               1
+(1 row)
+
+SELECT cosine_distance('{1:1,2:2}/2'::sparsevec, '{1:3}/1');
+ERROR:  different sparsevec dimensions 2 and 1
+SELECT cosine_distance('{1:1,2:1}/2'::sparsevec, '{1:1.1,2:1.1}/2');
+ cosine_distance 
+-----------------
+               0
+(1 row)
+
+SELECT cosine_distance('{1:1,2:1}/2'::sparsevec, '{1:-1.1,2:-1.1}/2');
+ cosine_distance 
+-----------------
+               2
+(1 row)
+
+SELECT cosine_distance('{1:3e38}/1'::sparsevec, '{1:3e38}/1');
+ cosine_distance 
+-----------------
+             NaN
+(1 row)
+
+SELECT cosine_distance('{}/1'::sparsevec, '{}/1');
+ cosine_distance 
+-----------------
+             NaN
+(1 row)
+
+SELECT '{1:1,2:2}/2'::sparsevec <=> '{1:2,2:4}/2';
+ ?column? 
+----------
+        0
+(1 row)
+
+SELECT l1_distance('{}/2'::sparsevec, '{1:3,2:4}/2');
+ l1_distance 
+-------------
+           7
+(1 row)
+
+SELECT l1_distance('{}/2'::sparsevec, '{2:1}/2');
+ l1_distance 
+-------------
+           1
+(1 row)
+
+SELECT l1_distance('{1:1,2:2}/2'::sparsevec, '{1:3}/1');
+ERROR:  different sparsevec dimensions 2 and 1
+SELECT l1_distance('{1:3e38}/1'::sparsevec, '{1:-3e38}/1');
+ l1_distance 
+-------------
+    Infinity
+(1 row)
+
+SELECT l1_distance('{1:1,3:3,5:5,7:7}/8'::sparsevec, '{2:2,4:4,6:6,8:8}/8');
+ l1_distance 
+-------------
+          36
+(1 row)
+
+SELECT l1_distance('{1:1,3:3,5:5,7:7,9:9}/9'::sparsevec, '{2:2,4:4,6:6,8:8}/9');
+ l1_distance 
+-------------
+          45
+(1 row)
+
+SELECT '{}/2'::sparsevec <+> '{1:3,2:4}/2';
+ ?column? 
+----------
+        7
+(1 row)
+
+SELECT l2_normalize('{1:3,2:4}/2'::sparsevec);
+  l2_normalize   
+-----------------
+ {1:0.6,2:0.8}/2
+(1 row)
+
+SELECT l2_normalize('{1:3}/2'::sparsevec);
+ l2_normalize 
+--------------
+ {1:1}/2
+(1 row)
+
+SELECT l2_normalize('{2:0.1}/2'::sparsevec);
+ l2_normalize 
+--------------
+ {2:1}/2
+(1 row)
+
+SELECT l2_normalize('{}/2'::sparsevec);
+ l2_normalize 
+--------------
+ {}/2
+(1 row)
+
+SELECT l2_normalize('{1:3e38}/1'::sparsevec);
+ l2_normalize 
+--------------
+ {1:1}/1
+(1 row)
+
+SELECT l2_normalize('{1:3e38,2:1e-37}/2'::sparsevec);
+ l2_normalize 
+--------------
+ {1:1}/2
+(1 row)
+
+SELECT l2_normalize('{2:3e37,4:3e-37,6:4e37,8:4e-37}/9'::sparsevec);
+  l2_normalize   
+-----------------
+ {2:0.6,6:0.8}/9
+(1 row)
+

test/expected/vector_type.out

@@ -0,0 +1,672 @@
+SELECT '[1,2,3]'::vector;
+ vector  
+---------
+ [1,2,3]
+(1 row)
+
+SELECT '[-1,-2,-3]'::vector;
+   vector   
+------------
+ [-1,-2,-3]
+(1 row)
+
+SELECT '[1.,2.,3.]'::vector;
+ vector  
+---------
+ [1,2,3]
+(1 row)
+
+SELECT ' [ 1,  2 ,    3  ] '::vector;
+ vector  
+---------
+ [1,2,3]
+(1 row)
+
+SELECT '[1.23456]'::vector;
+  vector   
+-----------
+ [1.23456]
+(1 row)
+
+SELECT '[hello,1]'::vector;
+ERROR:  invalid input syntax for type vector: "[hello,1]"
+LINE 1: SELECT '[hello,1]'::vector;
+               ^
+SELECT '[NaN,1]'::vector;
+ERROR:  NaN not allowed in vector
+LINE 1: SELECT '[NaN,1]'::vector;
+               ^
+SELECT '[Infinity,1]'::vector;
+ERROR:  infinite value not allowed in vector
+LINE 1: SELECT '[Infinity,1]'::vector;
+               ^
+SELECT '[-Infinity,1]'::vector;
+ERROR:  infinite value not allowed in vector
+LINE 1: SELECT '[-Infinity,1]'::vector;
+               ^
+SELECT '[1.5e38,-1.5e38]'::vector;
+       vector       
+--------------------
+ [1.5e+38,-1.5e+38]
+(1 row)
+
+SELECT '[1.5e+38,-1.5e+38]'::vector;
+       vector       
+--------------------
+ [1.5e+38,-1.5e+38]
+(1 row)
+
+SELECT '[1.5e-38,-1.5e-38]'::vector;
+       vector       
+--------------------
+ [1.5e-38,-1.5e-38]
+(1 row)
+
+SELECT '[4e38,1]'::vector;
+ERROR:  "4e38" is out of range for type vector
+LINE 1: SELECT '[4e38,1]'::vector;
+               ^
+SELECT '[-4e38,1]'::vector;
+ERROR:  "-4e38" is out of range for type vector
+LINE 1: SELECT '[-4e38,1]'::vector;
+               ^
+SELECT '[1e-46,1]'::vector;
+ vector 
+--------
+ [0,1]
+(1 row)
+
+SELECT '[-1e-46,1]'::vector;
+ vector 
+--------
+ [-0,1]
+(1 row)
+
+SELECT '[1,2,3'::vector;
+ERROR:  invalid input syntax for type vector: "[1,2,3"
+LINE 1: SELECT '[1,2,3'::vector;
+               ^
+SELECT '[1,2,3]9'::vector;
+ERROR:  invalid input syntax for type vector: "[1,2,3]9"
+LINE 1: SELECT '[1,2,3]9'::vector;
+               ^
+DETAIL:  Junk after closing right brace.
+SELECT '1,2,3'::vector;
+ERROR:  invalid input syntax for type vector: "1,2,3"
+LINE 1: SELECT '1,2,3'::vector;
+               ^
+DETAIL:  Vector contents must start with "[".
+SELECT ''::vector;
+ERROR:  invalid input syntax for type vector: ""
+LINE 1: SELECT ''::vector;
+               ^
+DETAIL:  Vector contents must start with "[".
+SELECT '['::vector;
+ERROR:  invalid input syntax for type vector: "["
+LINE 1: SELECT '['::vector;
+               ^
+SELECT '[ '::vector;
+ERROR:  invalid input syntax for type vector: "[ "
+LINE 1: SELECT '[ '::vector;
+               ^
+SELECT '[,'::vector;
+ERROR:  invalid input syntax for type vector: "[,"
+LINE 1: SELECT '[,'::vector;
+               ^
+SELECT '[]'::vector;
+ERROR:  vector must have at least 1 dimension
+LINE 1: SELECT '[]'::vector;
+               ^
+SELECT '[ ]'::vector;
+ERROR:  vector must have at least 1 dimension
+LINE 1: SELECT '[ ]'::vector;
+               ^
+SELECT '[,]'::vector;
+ERROR:  invalid input syntax for type vector: "[,]"
+LINE 1: SELECT '[,]'::vector;
+               ^
+SELECT '[1,]'::vector;
+ERROR:  invalid input syntax for type vector: "[1,]"
+LINE 1: SELECT '[1,]'::vector;
+               ^
+SELECT '[1a]'::vector;
+ERROR:  invalid input syntax for type vector: "[1a]"
+LINE 1: SELECT '[1a]'::vector;
+               ^
+SELECT '[1,,3]'::vector;
+ERROR:  invalid input syntax for type vector: "[1,,3]"
+LINE 1: SELECT '[1,,3]'::vector;
+               ^
+SELECT '[1, ,3]'::vector;
+ERROR:  invalid input syntax for type vector: "[1, ,3]"
+LINE 1: SELECT '[1, ,3]'::vector;
+               ^
+SELECT '[1,2,3]'::vector(3);
+ vector  
+---------
+ [1,2,3]
+(1 row)
+
+SELECT '[1,2,3]'::vector(2);
+ERROR:  expected 2 dimensions, not 3
+SELECT '[1,2,3]'::vector(3, 2);
+ERROR:  invalid type modifier
+LINE 1: SELECT '[1,2,3]'::vector(3, 2);
+                          ^
+SELECT '[1,2,3]'::vector('a');
+ERROR:  invalid input syntax for type integer: "a"
+LINE 1: SELECT '[1,2,3]'::vector('a');
+                          ^
+SELECT '[1,2,3]'::vector(0);
+ERROR:  dimensions for type vector must be at least 1
+LINE 1: SELECT '[1,2,3]'::vector(0);
+                          ^
+SELECT '[1,2,3]'::vector(16001);
+ERROR:  dimensions for type vector cannot exceed 16000
+LINE 1: SELECT '[1,2,3]'::vector(16001);
+                          ^
+SELECT unnest('{"[1,2,3]", "[4,5,6]"}'::vector[]);
+ unnest  
+---------
+ [1,2,3]
+ [4,5,6]
+(2 rows)
+
+SELECT '{"[1,2,3]"}'::vector(2)[];
+ERROR:  expected 2 dimensions, not 3
+SELECT '[1,2,3]'::vector + '[4,5,6]';
+ ?column? 
+----------
+ [5,7,9]
+(1 row)
+
+SELECT '[3e38]'::vector + '[3e38]';
+ERROR:  value out of range: overflow
+SELECT '[1,2]'::vector + '[3]';
+ERROR:  different vector dimensions 2 and 1
+SELECT '[1,2,3]'::vector - '[4,5,6]';
+  ?column?  
+------------
+ [-3,-3,-3]
+(1 row)
+
+SELECT '[-3e38]'::vector - '[3e38]';
+ERROR:  value out of range: overflow
+SELECT '[1,2]'::vector - '[3]';
+ERROR:  different vector dimensions 2 and 1
+SELECT '[1,2,3]'::vector * '[4,5,6]';
+ ?column?  
+-----------
+ [4,10,18]
+(1 row)
+
+SELECT '[1e37]'::vector * '[1e37]';
+ERROR:  value out of range: overflow
+SELECT '[1e-37]'::vector * '[1e-37]';
+ERROR:  value out of range: underflow
+SELECT '[1,2]'::vector * '[3]';
+ERROR:  different vector dimensions 2 and 1
+SELECT '[1,2,3]'::vector || '[4,5]';
+  ?column?   
+-------------
+ [1,2,3,4,5]
+(1 row)
+
+SELECT array_fill(0, ARRAY[16000])::vector || '[1]';
+ERROR:  vector cannot have more than 16000 dimensions
+SELECT '[1,2,3]'::vector < '[1,2,3]';
+ ?column? 
+----------
+ f
+(1 row)
+
+SELECT '[1,2,3]'::vector < '[1,2]';
+ ?column? 
+----------
+ f
+(1 row)
+
+SELECT '[1,2,3]'::vector <= '[1,2,3]';
+ ?column? 
+----------
+ t
+(1 row)
+
+SELECT '[1,2,3]'::vector <= '[1,2]';
+ ?column? 
+----------
+ f
+(1 row)
+
+SELECT '[1,2,3]'::vector = '[1,2,3]';
+ ?column? 
+----------
+ t
+(1 row)
+
+SELECT '[1,2,3]'::vector = '[1,2]';
+ ?column? 
+----------
+ f
+(1 row)
+
+SELECT '[1,2,3]'::vector != '[1,2,3]';
+ ?column? 
+----------
+ f
+(1 row)
+
+SELECT '[1,2,3]'::vector != '[1,2]';
+ ?column? 
+----------
+ t
+(1 row)
+
+SELECT '[1,2,3]'::vector >= '[1,2,3]';
+ ?column? 
+----------
+ t
+(1 row)
+
+SELECT '[1,2,3]'::vector >= '[1,2]';
+ ?column? 
+----------
+ t
+(1 row)
+
+SELECT '[1,2,3]'::vector > '[1,2,3]';
+ ?column? 
+----------
+ f
+(1 row)
+
+SELECT '[1,2,3]'::vector > '[1,2]';
+ ?column? 
+----------
+ t
+(1 row)
+
+SELECT vector_cmp('[1,2,3]', '[1,2,3]');
+ vector_cmp 
+------------
+          0
+(1 row)
+
+SELECT vector_cmp('[1,2,3]', '[0,0,0]');
+ vector_cmp 
+------------
+          1
+(1 row)
+
+SELECT vector_cmp('[0,0,0]', '[1,2,3]');
+ vector_cmp 
+------------
+         -1
+(1 row)
+
+SELECT vector_cmp('[1,2]', '[1,2,3]');
+ vector_cmp 
+------------
+         -1
+(1 row)
+
+SELECT vector_cmp('[1,2,3]', '[1,2]');
+ vector_cmp 
+------------
+          1
+(1 row)
+
+SELECT vector_cmp('[1,2]', '[2,3,4]');
+ vector_cmp 
+------------
+         -1
+(1 row)
+
+SELECT vector_cmp('[2,3]', '[1,2,3]');
+ vector_cmp 
+------------
+          1
+(1 row)
+
+SELECT vector_dims('[1,2,3]'::vector);
+ vector_dims 
+-------------
+           3
+(1 row)
+
+SELECT round(vector_norm('[1,1]')::numeric, 5);
+  round  
+---------
+ 1.41421
+(1 row)
+
+SELECT vector_norm('[3,4]');
+ vector_norm 
+-------------
+           5
+(1 row)
+
+SELECT vector_norm('[0,1]');
+ vector_norm 
+-------------
+           1
+(1 row)
+
+SELECT vector_norm('[3e37,4e37]')::real;
+ vector_norm 
+-------------
+       5e+37
+(1 row)
+
+SELECT vector_norm('[0,0]');
+ vector_norm 
+-------------
+           0
+(1 row)
+
+SELECT vector_norm('[2]');
+ vector_norm 
+-------------
+           2
+(1 row)
+
+SELECT l2_distance('[0,0]'::vector, '[3,4]');
+ l2_distance 
+-------------
+           5
+(1 row)
+
+SELECT l2_distance('[0,0]'::vector, '[0,1]');
+ l2_distance 
+-------------
+           1
+(1 row)
+
+SELECT l2_distance('[1,2]'::vector, '[3]');
+ERROR:  different vector dimensions 2 and 1
+SELECT l2_distance('[3e38]'::vector, '[-3e38]');
+ l2_distance 
+-------------
+    Infinity
+(1 row)
+
+SELECT l2_distance('[1,1,1,1,1,1,1,1,1]'::vector, '[1,1,1,1,1,1,1,4,5]');
+ l2_distance 
+-------------
+           5
+(1 row)
+
+SELECT '[0,0]'::vector <-> '[3,4]';
+ ?column? 
+----------
+        5
+(1 row)
+
+SELECT inner_product('[1,2]'::vector, '[3,4]');
+ inner_product 
+---------------
+            11
+(1 row)
+
+SELECT inner_product('[1,2]'::vector, '[3]');
+ERROR:  different vector dimensions 2 and 1
+SELECT inner_product('[3e38]'::vector, '[3e38]');
+ inner_product 
+---------------
+      Infinity
+(1 row)
+
+SELECT inner_product('[1,1,1,1,1,1,1,1,1]'::vector, '[1,2,3,4,5,6,7,8,9]');
+ inner_product 
+---------------
+            45
+(1 row)
+
+SELECT '[1,2]'::vector <#> '[3,4]';
+ ?column? 
+----------
+      -11
+(1 row)
+
+SELECT cosine_distance('[1,2]'::vector, '[2,4]');
+ cosine_distance 
+-----------------
+               0
+(1 row)
+
+SELECT cosine_distance('[1,2]'::vector, '[0,0]');
+ cosine_distance 
+-----------------
+             NaN
+(1 row)
+
+SELECT cosine_distance('[1,1]'::vector, '[1,1]');
+ cosine_distance 
+-----------------
+               0
+(1 row)
+
+SELECT cosine_distance('[1,0]'::vector, '[0,2]');
+ cosine_distance 
+-----------------
+               1
+(1 row)
+
+SELECT cosine_distance('[1,1]'::vector, '[-1,-1]');
+ cosine_distance 
+-----------------
+               2
+(1 row)
+
+SELECT cosine_distance('[1,2]'::vector, '[3]');
+ERROR:  different vector dimensions 2 and 1
+SELECT cosine_distance('[1,1]'::vector, '[1.1,1.1]');
+ cosine_distance 
+-----------------
+               0
+(1 row)
+
+SELECT cosine_distance('[1,1]'::vector, '[-1.1,-1.1]');
+ cosine_distance 
+-----------------
+               2
+(1 row)
+
+SELECT cosine_distance('[3e38]'::vector, '[3e38]');
+ cosine_distance 
+-----------------
+             NaN
+(1 row)
+
+SELECT cosine_distance('[1,2,3,4,5,6,7,8,9]'::vector, '[1,2,3,4,5,6,7,8,9]');
+ cosine_distance 
+-----------------
+               0
+(1 row)
+
+SELECT cosine_distance('[1,2,3,4,5,6,7,8,9]'::vector, '[-1,-2,-3,-4,-5,-6,-7,-8,-9]');
+ cosine_distance 
+-----------------
+               2
+(1 row)
+
+SELECT '[1,2]'::vector <=> '[2,4]';
+ ?column? 
+----------
+        0
+(1 row)
+
+SELECT l1_distance('[0,0]'::vector, '[3,4]');
+ l1_distance 
+-------------
+           7
+(1 row)
+
+SELECT l1_distance('[0,0]'::vector, '[0,1]');
+ l1_distance 
+-------------
+           1
+(1 row)
+
+SELECT l1_distance('[1,2]'::vector, '[3]');
+ERROR:  different vector dimensions 2 and 1
+SELECT l1_distance('[3e38]'::vector, '[-3e38]');
+ l1_distance 
+-------------
+    Infinity
+(1 row)
+
+SELECT l1_distance('[1,2,3,4,5,6,7,8,9]'::vector, '[1,2,3,4,5,6,7,8,9]');
+ l1_distance 
+-------------
+           0
+(1 row)
+
+SELECT l1_distance('[1,2,3,4,5,6,7,8,9]'::vector, '[0,3,2,5,4,7,6,9,8]');
+ l1_distance 
+-------------
+           9
+(1 row)
+
+SELECT '[0,0]'::vector <+> '[3,4]';
+ ?column? 
+----------
+        7
+(1 row)
+
+SELECT l2_normalize('[3,4]'::vector);
+ l2_normalize 
+--------------
+ [0.6,0.8]
+(1 row)
+
+SELECT l2_normalize('[3,0]'::vector);
+ l2_normalize 
+--------------
+ [1,0]
+(1 row)
+
+SELECT l2_normalize('[0,0.1]'::vector);
+ l2_normalize 
+--------------
+ [0,1]
+(1 row)
+
+SELECT l2_normalize('[0,0]'::vector);
+ l2_normalize 
+--------------
+ [0,0]
+(1 row)
+
+SELECT l2_normalize('[3e38]'::vector);
+ l2_normalize 
+--------------
+ [1]
+(1 row)
+
+SELECT binary_quantize('[1,0,-1]'::vector);
+ binary_quantize 
+-----------------
+ 100
+(1 row)
+
+SELECT binary_quantize('[0,0.1,-0.2,-0.3,0.4,0.5,0.6,-0.7,0.8,-0.9,1]'::vector);
+ binary_quantize 
+-----------------
+ 01001110101
+(1 row)
+
+SELECT subvector('[1,2,3,4,5]'::vector, 1, 3);
+ subvector 
+-----------
+ [1,2,3]
+(1 row)
+
+SELECT subvector('[1,2,3,4,5]'::vector, 3, 2);
+ subvector 
+-----------
+ [3,4]
+(1 row)
+
+SELECT subvector('[1,2,3,4,5]'::vector, -1, 3);
+ subvector 
+-----------
+ [1]
+(1 row)
+
+SELECT subvector('[1,2,3,4,5]'::vector, 3, 9);
+ subvector 
+-----------
+ [3,4,5]
+(1 row)
+
+SELECT subvector('[1,2,3,4,5]'::vector, 1, 0);
+ERROR:  vector must have at least 1 dimension
+SELECT subvector('[1,2,3,4,5]'::vector, 3, -1);
+ERROR:  vector must have at least 1 dimension
+SELECT subvector('[1,2,3,4,5]'::vector, -1, 2);
+ERROR:  vector must have at least 1 dimension
+SELECT subvector('[1,2,3,4,5]'::vector, 2147483647, 10);
+ERROR:  vector must have at least 1 dimension
+SELECT subvector('[1,2,3,4,5]'::vector, 3, 2147483647);
+ subvector 
+-----------
+ [3,4,5]
+(1 row)
+
+SELECT subvector('[1,2,3,4,5]'::vector, -2147483644, 2147483647);
+ subvector 
+-----------
+ [1,2]
+(1 row)
+
+SELECT avg(v) FROM unnest(ARRAY['[1,2,3]'::vector, '[3,5,7]']) v;
+    avg    
+-----------
+ [2,3.5,5]
+(1 row)
+
+SELECT avg(v) FROM unnest(ARRAY['[1,2,3]'::vector, '[3,5,7]', NULL]) v;
+    avg    
+-----------
+ [2,3.5,5]
+(1 row)
+
+SELECT avg(v) FROM unnest(ARRAY[]::vector[]) v;
+ avg 
+-----
+ 
+(1 row)
+
+SELECT avg(v) FROM unnest(ARRAY['[1,2]'::vector, '[3]']) v;
+ERROR:  expected 2 dimensions, not 1
+SELECT avg(v) FROM unnest(ARRAY['[3e38]'::vector, '[3e38]']) v;
+   avg   
+---------
+ [3e+38]
+(1 row)
+
+SELECT vector_avg(array_agg(n)) FROM generate_series(1, 16002) n;
+ERROR:  vector cannot have more than 16000 dimensions
+SELECT sum(v) FROM unnest(ARRAY['[1,2,3]'::vector, '[3,5,7]']) v;
+   sum    
+----------
+ [4,7,10]
+(1 row)
+
+SELECT sum(v) FROM unnest(ARRAY['[1,2,3]'::vector, '[3,5,7]', NULL]) v;
+   sum    
+----------
+ [4,7,10]
+(1 row)
+
+SELECT sum(v) FROM unnest(ARRAY[]::vector[]) v;
+ sum 
+-----
+ 
+(1 row)
+
+SELECT sum(v) FROM unnest(ARRAY['[1,2]'::vector, '[3]']) v;
+ERROR:  different vector dimensions 2 and 1
+SELECT sum(v) FROM unnest(ARRAY['[3e38]'::vector, '[3e38]']) v;
+ERROR:  value out of range: overflow

test/sql/bit.sql

@@ -0,0 +1,27 @@
+SELECT hamming_distance('111', '111');
+SELECT hamming_distance('111', '110');
+SELECT hamming_distance('111', '100');
+SELECT hamming_distance('111', '000');
+SELECT hamming_distance('10101010101010101010', '01010101010101010101');
+SELECT hamming_distance('101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101', '101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101');
+SELECT hamming_distance('101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101', '010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010');
+SELECT hamming_distance('110000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011', '100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001');
+SELECT hamming_distance('', '');
+SELECT hamming_distance('111', '00');
+SELECT hamming_distance('111', '000'::varbit(4));
+SELECT hamming_distance('111', '0000'::varbit(4));
+
+SELECT jaccard_distance('1111', '1111');
+SELECT jaccard_distance('1111', '1110');
+SELECT jaccard_distance('1111', '1100');
+SELECT jaccard_distance('1111', '1000');
+SELECT jaccard_distance('1111', '0000');
+SELECT jaccard_distance('1100', '1000');
+SELECT jaccard_distance('10101010101010101010', '01010101010101010101');
+SELECT jaccard_distance('101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101', '101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101');
+SELECT jaccard_distance('101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101', '010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010');
+SELECT jaccard_distance('110000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011', '100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001');
+SELECT jaccard_distance('', '');
+SELECT jaccard_distance('1111', '000');
+SELECT jaccard_distance('1111', '0000'::varbit(5));
+SELECT jaccard_distance('1111', '00000'::varbit(5));

test/sql/btree.sql

@@ -1,10 +1,34 @@
 SET enable_seqscan = off;
 
+-- vector
+
 CREATE TABLE t (val vector(3));
 INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
 CREATE INDEX ON t (val);
 
 SELECT * FROM t WHERE val = '[1,2,3]';
-SELECT * FROM t ORDER BY val LIMIT 1;
+SELECT * FROM t ORDER BY val;
+
+DROP TABLE t;
+
+-- halfvec
+
+CREATE TABLE t (val halfvec(3));
+INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
+CREATE INDEX ON t (val);
+
+SELECT * FROM t WHERE val = '[1,2,3]';
+SELECT * FROM t ORDER BY val;
+
+DROP TABLE t;
+
+-- sparsevec
+
+CREATE TABLE t (val sparsevec(3));
+INSERT INTO t (val) VALUES ('{}/3'), ('{1:1,2:2,3:3}/3'), ('{1:1,2:1,3:1}/3'), (NULL);
+CREATE INDEX ON t (val);
+
+SELECT * FROM t WHERE val = '{1:1,2:2,3:3}/3';
+SELECT * FROM t ORDER BY val;
 
 DROP TABLE t;

test/sql/cast.sql

@@ -3,13 +3,61 @@ SELECT ARRAY[1.0,2.0,3.0]::vector;
 SELECT ARRAY[1,2,3]::float4[]::vector;
 SELECT ARRAY[1,2,3]::float8[]::vector;
 SELECT ARRAY[1,2,3]::numeric[]::vector;
+
+SELECT '[1,2,3]'::vector::real[];
+
+SELECT '{1,2,3}'::real[]::vector;
+SELECT '{1,2,3}'::real[]::vector(3);
+SELECT '{1,2,3}'::real[]::vector(2);
 SELECT '{NULL}'::real[]::vector;
 SELECT '{NaN}'::real[]::vector;
 SELECT '{Infinity}'::real[]::vector;
 SELECT '{-Infinity}'::real[]::vector;
 SELECT '{}'::real[]::vector;
 SELECT '{{1}}'::real[]::vector;
-SELECT '[1,2,3]'::vector::real[];
+
+SELECT '{1,2,3}'::double precision[]::vector;
+SELECT '{1,2,3}'::double precision[]::vector(3);
+SELECT '{1,2,3}'::double precision[]::vector(2);
+SELECT '{4e38,-4e38}'::double precision[]::vector;
+SELECT '{1e-46,-1e-46}'::double precision[]::vector;
+
+SELECT '[1,2,3]'::vector::halfvec;
+SELECT '[1,2,3]'::vector::halfvec(3);
+SELECT '[1,2,3]'::vector::halfvec(2);
+SELECT '[65520]'::vector::halfvec;
+SELECT '[1e-8]'::vector::halfvec;
+
+SELECT '[1,2,3]'::halfvec::vector;
+SELECT '[1,2,3]'::halfvec::vector(3);
+SELECT '[1,2,3]'::halfvec::vector(2);
+
+SELECT '{1,2,3}'::real[]::halfvec;
+SELECT '{1,2,3}'::real[]::halfvec(3);
+SELECT '{1,2,3}'::real[]::halfvec(2);
+SELECT '{65520,-65520}'::real[]::halfvec;
+SELECT '{1e-8,-1e-8}'::real[]::halfvec;
+
+SELECT '[0,1.5,0,3.5,0]'::vector::sparsevec;
+SELECT '[0,1.5,0,3.5,0]'::vector::sparsevec(5);
+SELECT '[0,1.5,0,3.5,0]'::vector::sparsevec(4);
+
+SELECT '{2:1.5,4:3.5}/5'::sparsevec::vector;
+SELECT '{2:1.5,4:3.5}/5'::sparsevec::vector(5);
+SELECT '{2:1.5,4:3.5}/5'::sparsevec::vector(4);
+SELECT '{}/16001'::sparsevec::vector;
+
+SELECT '[0,1.5,0,3.5,0]'::halfvec::sparsevec;
+SELECT '[0,1.5,0,3.5,0]'::halfvec::sparsevec(5);
+SELECT '[0,1.5,0,3.5,0]'::halfvec::sparsevec(4);
+
+SELECT '{2:1.5,4:3.5}/5'::sparsevec::halfvec;
+SELECT '{2:1.5,4:3.5}/5'::sparsevec::halfvec(5);
+SELECT '{2:1.5,4:3.5}/5'::sparsevec::halfvec(4);
+SELECT '{}/16001'::sparsevec::halfvec;
+SELECT '{1:65520}/1'::sparsevec::halfvec;
+SELECT '{1:1e-8}/1'::sparsevec::halfvec;
+
 SELECT array_agg(n)::vector FROM generate_series(1, 16001) n;
 SELECT array_to_vector(array_agg(n), 16001, false) FROM generate_series(1, 16001) n;
 

test/sql/copy.sql

@@ -1,10 +1,42 @@
+-- vector
+
 CREATE TABLE t (val vector(3));
 INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
 
 CREATE TABLE t2 (val vector(3));
 
-\copy t TO 'results/data.bin' WITH (FORMAT binary)
-\copy t2 FROM 'results/data.bin' WITH (FORMAT binary)
+\copy t TO 'results/vector.bin' WITH (FORMAT binary)
+\copy t2 FROM 'results/vector.bin' WITH (FORMAT binary)
+
+SELECT * FROM t2 ORDER BY val;
+
+DROP TABLE t;
+DROP TABLE t2;
+
+-- halfvec
+
+CREATE TABLE t (val halfvec(3));
+INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
+
+CREATE TABLE t2 (val halfvec(3));
+
+\copy t TO 'results/halfvec.bin' WITH (FORMAT binary)
+\copy t2 FROM 'results/halfvec.bin' WITH (FORMAT binary)
+
+SELECT * FROM t2 ORDER BY val;
+
+DROP TABLE t;
+DROP TABLE t2;
+
+-- sparsevec
+
+CREATE TABLE t (val sparsevec(3));
+INSERT INTO t (val) VALUES ('{}/3'), ('{1:1,2:2,3:3}/3'), ('{1:1,2:1,3:1}/3'), (NULL);
+
+CREATE TABLE t2 (val sparsevec(3));
+
+\copy t TO 'results/sparsevec.bin' WITH (FORMAT binary)
+\copy t2 FROM 'results/sparsevec.bin' WITH (FORMAT binary)
 
 SELECT * FROM t2 ORDER BY val;
 

test/sql/functions.sql

@@ -1,51 +0,0 @@
-SELECT '[1,2,3]'::vector + '[4,5,6]';
-SELECT '[3e38]'::vector + '[3e38]';
-SELECT '[1,2,3]'::vector - '[4,5,6]';
-SELECT '[-3e38]'::vector - '[3e38]';
-SELECT '[1,2,3]'::vector * '[4,5,6]';
-SELECT '[1e37]'::vector * '[1e37]';
-SELECT '[1e-37]'::vector * '[1e-37]';
-
-SELECT vector_dims('[1,2,3]');
-
-SELECT round(vector_norm('[1,1]')::numeric, 5);
-SELECT vector_norm('[3,4]');
-SELECT vector_norm('[0,1]');
-SELECT vector_norm('[3e37,4e37]')::real;
-
-SELECT l2_distance('[0,0]', '[3,4]');
-SELECT l2_distance('[0,0]', '[0,1]');
-SELECT l2_distance('[1,2]', '[3]');
-SELECT l2_distance('[3e38]', '[-3e38]');
-
-SELECT inner_product('[1,2]', '[3,4]');
-SELECT inner_product('[1,2]', '[3]');
-SELECT inner_product('[3e38]', '[3e38]');
-
-SELECT cosine_distance('[1,2]', '[2,4]');
-SELECT cosine_distance('[1,2]', '[0,0]');
-SELECT cosine_distance('[1,1]', '[1,1]');
-SELECT cosine_distance('[1,0]', '[0,2]');
-SELECT cosine_distance('[1,1]', '[-1,-1]');
-SELECT cosine_distance('[1,2]', '[3]');
-SELECT cosine_distance('[1,1]', '[1.1,1.1]');
-SELECT cosine_distance('[1,1]', '[-1.1,-1.1]');
-SELECT cosine_distance('[3e38]', '[3e38]');
-
-SELECT l1_distance('[0,0]', '[3,4]');
-SELECT l1_distance('[0,0]', '[0,1]');
-SELECT l1_distance('[1,2]', '[3]');
-SELECT l1_distance('[3e38]', '[-3e38]');
-
-SELECT avg(v) FROM unnest(ARRAY['[1,2,3]'::vector, '[3,5,7]']) v;
-SELECT avg(v) FROM unnest(ARRAY['[1,2,3]'::vector, '[3,5,7]', NULL]) v;
-SELECT avg(v) FROM unnest(ARRAY[]::vector[]) v;
-SELECT avg(v) FROM unnest(ARRAY['[1,2]'::vector, '[3]']) v;
-SELECT avg(v) FROM unnest(ARRAY['[3e38]'::vector, '[3e38]']) v;
-SELECT vector_avg(array_agg(n)) FROM generate_series(1, 16002) n;
-
-SELECT sum(v) FROM unnest(ARRAY['[1,2,3]'::vector, '[3,5,7]']) v;
-SELECT sum(v) FROM unnest(ARRAY['[1,2,3]'::vector, '[3,5,7]', NULL]) v;
-SELECT sum(v) FROM unnest(ARRAY[]::vector[]) v;
-SELECT sum(v) FROM unnest(ARRAY['[1,2]'::vector, '[3]']) v;
-SELECT sum(v) FROM unnest(ARRAY['[3e38]'::vector, '[3e38]']) v;

test/sql/halfvec.sql

@@ -0,0 +1,147 @@
+SELECT '[1,2,3]'::halfvec;
+SELECT '[-1,-2,-3]'::halfvec;
+SELECT '[1.,2.,3.]'::halfvec;
+SELECT ' [ 1,  2 ,    3  ] '::halfvec;
+SELECT '[1.23456]'::halfvec;
+SELECT '[hello,1]'::halfvec;
+SELECT '[NaN,1]'::halfvec;
+SELECT '[Infinity,1]'::halfvec;
+SELECT '[-Infinity,1]'::halfvec;
+SELECT '[65519,-65519]'::halfvec;
+SELECT '[65520,-65520]'::halfvec;
+SELECT '[1e-8,-1e-8]'::halfvec;
+SELECT '[4e38,1]'::halfvec;
+SELECT '[1e-46,1]'::halfvec;
+SELECT '[1,2,3'::halfvec;
+SELECT '[1,2,3]9'::halfvec;
+SELECT '1,2,3'::halfvec;
+SELECT ''::halfvec;
+SELECT '['::halfvec;
+SELECT '[ '::halfvec;
+SELECT '[,'::halfvec;
+SELECT '[]'::halfvec;
+SELECT '[ ]'::halfvec;
+SELECT '[,]'::halfvec;
+SELECT '[1,]'::halfvec;
+SELECT '[1a]'::halfvec;
+SELECT '[1,,3]'::halfvec;
+SELECT '[1, ,3]'::halfvec;
+
+SELECT '[1,2,3]'::halfvec(3);
+SELECT '[1,2,3]'::halfvec(2);
+SELECT '[1,2,3]'::halfvec(3, 2);
+SELECT '[1,2,3]'::halfvec('a');
+SELECT '[1,2,3]'::halfvec(0);
+SELECT '[1,2,3]'::halfvec(16001);
+
+SELECT unnest('{"[1,2,3]", "[4,5,6]"}'::halfvec[]);
+SELECT '{"[1,2,3]"}'::halfvec(2)[];
+
+SELECT '[1,2,3]'::halfvec + '[4,5,6]';
+SELECT '[65519]'::halfvec + '[65519]';
+SELECT '[1,2]'::halfvec + '[3]';
+
+SELECT '[1,2,3]'::halfvec - '[4,5,6]';
+SELECT '[-65519]'::halfvec - '[65519]';
+SELECT '[1,2]'::halfvec - '[3]';
+
+SELECT '[1,2,3]'::halfvec * '[4,5,6]';
+SELECT '[65519]'::halfvec * '[65519]';
+SELECT '[1e-7]'::halfvec * '[1e-7]';
+SELECT '[1,2]'::halfvec * '[3]';
+
+SELECT '[1,2,3]'::halfvec || '[4,5]';
+SELECT array_fill(0, ARRAY[16000])::halfvec || '[1]';
+
+SELECT '[1,2,3]'::halfvec < '[1,2,3]';
+SELECT '[1,2,3]'::halfvec < '[1,2]';
+SELECT '[1,2,3]'::halfvec <= '[1,2,3]';
+SELECT '[1,2,3]'::halfvec <= '[1,2]';
+SELECT '[1,2,3]'::halfvec = '[1,2,3]';
+SELECT '[1,2,3]'::halfvec = '[1,2]';
+SELECT '[1,2,3]'::halfvec != '[1,2,3]';
+SELECT '[1,2,3]'::halfvec != '[1,2]';
+SELECT '[1,2,3]'::halfvec >= '[1,2,3]';
+SELECT '[1,2,3]'::halfvec >= '[1,2]';
+SELECT '[1,2,3]'::halfvec > '[1,2,3]';
+SELECT '[1,2,3]'::halfvec > '[1,2]';
+
+SELECT halfvec_cmp('[1,2,3]', '[1,2,3]');
+SELECT halfvec_cmp('[1,2,3]', '[0,0,0]');
+SELECT halfvec_cmp('[0,0,0]', '[1,2,3]');
+SELECT halfvec_cmp('[1,2]', '[1,2,3]');
+SELECT halfvec_cmp('[1,2,3]', '[1,2]');
+SELECT halfvec_cmp('[1,2]', '[2,3,4]');
+SELECT halfvec_cmp('[2,3]', '[1,2,3]');
+
+SELECT vector_dims('[1,2,3]'::halfvec);
+
+SELECT round(l2_norm('[1,1]'::halfvec)::numeric, 5);
+SELECT l2_norm('[3,4]'::halfvec);
+SELECT l2_norm('[0,1]'::halfvec);
+SELECT l2_norm('[0,0]'::halfvec);
+SELECT l2_norm('[2]'::halfvec);
+
+SELECT l2_distance('[0,0]'::halfvec, '[3,4]');
+SELECT l2_distance('[0,0]'::halfvec, '[0,1]');
+SELECT l2_distance('[1,2]'::halfvec, '[3]');
+SELECT l2_distance('[1,1,1,1,1,1,1,1,1]'::halfvec, '[1,1,1,1,1,1,1,4,5]');
+SELECT '[0,0]'::halfvec <-> '[3,4]';
+
+SELECT inner_product('[1,2]'::halfvec, '[3,4]');
+SELECT inner_product('[1,2]'::halfvec, '[3]');
+SELECT inner_product('[65504]'::halfvec, '[65504]');
+SELECT inner_product('[1,1,1,1,1,1,1,1,1]'::halfvec, '[1,2,3,4,5,6,7,8,9]');
+SELECT '[1,2]'::halfvec <#> '[3,4]';
+
+SELECT cosine_distance('[1,2]'::halfvec, '[2,4]');
+SELECT cosine_distance('[1,2]'::halfvec, '[0,0]');
+SELECT cosine_distance('[1,1]'::halfvec, '[1,1]');
+SELECT cosine_distance('[1,0]'::halfvec, '[0,2]');
+SELECT cosine_distance('[1,1]'::halfvec, '[-1,-1]');
+SELECT cosine_distance('[1,2]'::halfvec, '[3]');
+SELECT cosine_distance('[1,1]'::halfvec, '[1.1,1.1]');
+SELECT cosine_distance('[1,1]'::halfvec, '[-1.1,-1.1]');
+SELECT cosine_distance('[1,2,3,4,5,6,7,8,9]'::halfvec, '[1,2,3,4,5,6,7,8,9]');
+SELECT cosine_distance('[1,2,3,4,5,6,7,8,9]'::halfvec, '[-1,-2,-3,-4,-5,-6,-7,-8,-9]');
+SELECT '[1,2]'::halfvec <=> '[2,4]';
+
+SELECT l1_distance('[0,0]'::halfvec, '[3,4]');
+SELECT l1_distance('[0,0]'::halfvec, '[0,1]');
+SELECT l1_distance('[1,2]'::halfvec, '[3]');
+SELECT l1_distance('[1,2,3,4,5,6,7,8,9]'::halfvec, '[1,2,3,4,5,6,7,8,9]');
+SELECT l1_distance('[1,2,3,4,5,6,7,8,9]'::halfvec, '[0,3,2,5,4,7,6,9,8]');
+SELECT '[0,0]'::halfvec <+> '[3,4]';
+
+SELECT l2_normalize('[3,4]'::halfvec);
+SELECT l2_normalize('[3,0]'::halfvec);
+SELECT l2_normalize('[0,0.1]'::halfvec);
+SELECT l2_normalize('[0,0]'::halfvec);
+SELECT l2_normalize('[65504]'::halfvec);
+
+SELECT binary_quantize('[1,0,-1]'::halfvec);
+SELECT binary_quantize('[0,0.1,-0.2,-0.3,0.4,0.5,0.6,-0.7,0.8,-0.9,1]'::halfvec);
+
+SELECT subvector('[1,2,3,4,5]'::halfvec, 1, 3);
+SELECT subvector('[1,2,3,4,5]'::halfvec, 3, 2);
+SELECT subvector('[1,2,3,4,5]'::halfvec, -1, 3);
+SELECT subvector('[1,2,3,4,5]'::halfvec, 3, 9);
+SELECT subvector('[1,2,3,4,5]'::halfvec, 1, 0);
+SELECT subvector('[1,2,3,4,5]'::halfvec, 3, -1);
+SELECT subvector('[1,2,3,4,5]'::halfvec, -1, 2);
+SELECT subvector('[1,2,3,4,5]'::halfvec, 2147483647, 10);
+SELECT subvector('[1,2,3,4,5]'::halfvec, 3, 2147483647);
+SELECT subvector('[1,2,3,4,5]'::halfvec, -2147483644, 2147483647);
+
+SELECT avg(v) FROM unnest(ARRAY['[1,2,3]'::halfvec, '[3,5,7]']) v;
+SELECT avg(v) FROM unnest(ARRAY['[1,2,3]'::halfvec, '[3,5,7]', NULL]) v;
+SELECT avg(v) FROM unnest(ARRAY[]::halfvec[]) v;
+SELECT avg(v) FROM unnest(ARRAY['[1,2]'::halfvec, '[3]']) v;
+SELECT avg(v) FROM unnest(ARRAY['[65504]'::halfvec, '[65504]']) v;
+SELECT halfvec_avg(array_agg(n)) FROM generate_series(1, 16002) n;
+
+SELECT sum(v) FROM unnest(ARRAY['[1,2,3]'::halfvec, '[3,5,7]']) v;
+SELECT sum(v) FROM unnest(ARRAY['[1,2,3]'::halfvec, '[3,5,7]', NULL]) v;
+SELECT sum(v) FROM unnest(ARRAY[]::halfvec[]) v;
+SELECT sum(v) FROM unnest(ARRAY['[1,2]'::halfvec, '[3]']) v;
+SELECT sum(v) FROM unnest(ARRAY['[65504]'::halfvec, '[65504]']) v;

test/sql/hnsw_bit.sql

@@ -0,0 +1,35 @@
+SET enable_seqscan = off;
+
+-- hamming
+
+CREATE TABLE t (val bit(3));
+INSERT INTO t (val) VALUES (B'000'), (B'100'), (B'111'), (NULL);
+CREATE INDEX ON t USING hnsw (val bit_hamming_ops);
+
+INSERT INTO t (val) VALUES (B'110');
+
+SELECT * FROM t ORDER BY val <~> B'111';
+SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <~> (SELECT NULL::bit)) t2;
+
+DROP TABLE t;
+
+-- jaccard
+
+CREATE TABLE t (val bit(4));
+INSERT INTO t (val) VALUES (B'0000'), (B'1100'), (B'1111'), (NULL);
+CREATE INDEX ON t USING hnsw (val bit_jaccard_ops);
+
+INSERT INTO t (val) VALUES (B'1110');
+
+SELECT * FROM t ORDER BY val <%> B'1111';
+SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <%> (SELECT NULL::bit)) t2;
+
+DROP TABLE t;
+
+-- varbit
+
+CREATE TABLE t (val varbit(3));
+CREATE INDEX ON t USING hnsw (val bit_hamming_ops);
+CREATE INDEX ON t USING hnsw ((val::bit(3)) bit_hamming_ops);
+CREATE INDEX ON t USING hnsw ((val::bit(64001)) bit_hamming_ops);
+DROP TABLE t;

test/sql/hnsw_cosine.sql

@@ -1,13 +0,0 @@
-SET enable_seqscan = off;
-
-CREATE TABLE t (val vector(3));
-INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
-CREATE INDEX ON t USING hnsw (val vector_cosine_ops);
-
-INSERT INTO t (val) VALUES ('[1,2,4]');
-
-SELECT * FROM t ORDER BY val <=> '[3,3,3]';
-SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <=> '[0,0,0]') t2;
-SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <=> (SELECT NULL::vector)) t2;
-
-DROP TABLE t;

test/sql/hnsw_halfvec.sql

@@ -0,0 +1,58 @@
+SET enable_seqscan = off;
+
+-- L2
+
+CREATE TABLE t (val halfvec(3));
+INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
+CREATE INDEX ON t USING hnsw (val halfvec_l2_ops);
+
+INSERT INTO t (val) VALUES ('[1,2,4]');
+
+SELECT * FROM t ORDER BY val <-> '[3,3,3]';
+SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <-> (SELECT NULL::halfvec)) t2;
+SELECT COUNT(*) FROM t;
+
+TRUNCATE t;
+SELECT * FROM t ORDER BY val <-> '[3,3,3]';
+
+DROP TABLE t;
+
+-- inner product
+
+CREATE TABLE t (val halfvec(3));
+INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
+CREATE INDEX ON t USING hnsw (val halfvec_ip_ops);
+
+INSERT INTO t (val) VALUES ('[1,2,4]');
+
+SELECT * FROM t ORDER BY val <#> '[3,3,3]';
+SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <#> (SELECT NULL::halfvec)) t2;
+
+DROP TABLE t;
+
+-- cosine
+
+CREATE TABLE t (val halfvec(3));
+INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
+CREATE INDEX ON t USING hnsw (val halfvec_cosine_ops);
+
+INSERT INTO t (val) VALUES ('[1,2,4]');
+
+SELECT * FROM t ORDER BY val <=> '[3,3,3]';
+SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <=> '[0,0,0]') t2;
+SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <=> (SELECT NULL::halfvec)) t2;
+
+DROP TABLE t;
+
+-- L1
+
+CREATE TABLE t (val halfvec(3));
+INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
+CREATE INDEX ON t USING hnsw (val halfvec_l1_ops);
+
+INSERT INTO t (val) VALUES ('[1,2,4]');
+
+SELECT * FROM t ORDER BY val <+> '[3,3,3]';
+SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <+> (SELECT NULL::halfvec)) t2;
+
+DROP TABLE t;

test/sql/hnsw_ip.sql

@@ -1,12 +0,0 @@
-SET enable_seqscan = off;
-
-CREATE TABLE t (val vector(3));
-INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
-CREATE INDEX ON t USING hnsw (val vector_ip_ops);
-
-INSERT INTO t (val) VALUES ('[1,2,4]');
-
-SELECT * FROM t ORDER BY val <#> '[3,3,3]';
-SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <#> (SELECT NULL::vector)) t2;
-
-DROP TABLE t;

test/sql/hnsw_l2.sql

@@ -1,16 +0,0 @@
-SET enable_seqscan = off;
-
-CREATE TABLE t (val vector(3));
-INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
-CREATE INDEX ON t USING hnsw (val vector_l2_ops);
-
-INSERT INTO t (val) VALUES ('[1,2,4]');
-
-SELECT * FROM t ORDER BY val <-> '[3,3,3]';
-SELECT * FROM t ORDER BY val <-> (SELECT NULL::vector);
-SELECT COUNT(*) FROM t;
-
-TRUNCATE t;
-SELECT * FROM t ORDER BY val <-> '[3,3,3]';
-
-DROP TABLE t;

test/sql/hnsw_options.sql

@@ -1,13 +0,0 @@
-CREATE TABLE t (val vector(3));
-CREATE INDEX ON t USING hnsw (val vector_l2_ops) WITH (m = 1);
-CREATE INDEX ON t USING hnsw (val vector_l2_ops) WITH (m = 101);
-CREATE INDEX ON t USING hnsw (val vector_l2_ops) WITH (ef_construction = 3);
-CREATE INDEX ON t USING hnsw (val vector_l2_ops) WITH (ef_construction = 1001);
-CREATE INDEX ON t USING hnsw (val vector_l2_ops) WITH (m = 16, ef_construction = 31);
-
-SHOW hnsw.ef_search;
-
-SET hnsw.ef_search = 0;
-SET hnsw.ef_search = 1001;
-
-DROP TABLE t;

test/sql/hnsw_sparsevec.sql

@@ -0,0 +1,68 @@
+SET enable_seqscan = off;
+
+-- L2
+
+CREATE TABLE t (val sparsevec(3));
+INSERT INTO t (val) VALUES ('{}/3'), ('{1:1,2:2,3:3}/3'), ('{1:1,2:1,3:1}/3'), (NULL);
+CREATE INDEX ON t USING hnsw (val sparsevec_l2_ops);
+
+INSERT INTO t (val) VALUES ('{1:1,2:2,3:4}/3');
+
+SELECT * FROM t ORDER BY val <-> '{1:3,2:3,3:3}/3';
+SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <-> (SELECT NULL::sparsevec)) t2;
+SELECT COUNT(*) FROM t;
+
+TRUNCATE t;
+SELECT * FROM t ORDER BY val <-> '{1:3,2:3,3:3}/3';
+
+DROP TABLE t;
+
+-- inner product
+
+CREATE TABLE t (val sparsevec(3));
+INSERT INTO t (val) VALUES ('{}/3'), ('{1:1,2:2,3:3}/3'), ('{1:1,2:1,3:1}/3'), (NULL);
+CREATE INDEX ON t USING hnsw (val sparsevec_ip_ops);
+
+INSERT INTO t (val) VALUES ('{1:1,2:2,3:4}/3');
+
+SELECT * FROM t ORDER BY val <#> '{1:3,2:3,3:3}/3';
+SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <#> (SELECT NULL::sparsevec)) t2;
+
+DROP TABLE t;
+
+-- cosine
+
+CREATE TABLE t (val sparsevec(3));
+INSERT INTO t (val) VALUES ('{}/3'), ('{1:1,2:2,3:3}/3'), ('{1:1,2:1,3:1}/3'), (NULL);
+CREATE INDEX ON t USING hnsw (val sparsevec_cosine_ops);
+
+INSERT INTO t (val) VALUES ('{1:1,2:2,3:4}/3');
+
+SELECT * FROM t ORDER BY val <=> '{1:3,2:3,3:3}/3';
+SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <=> '{}/3') t2;
+SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <=> (SELECT NULL::sparsevec)) t2;
+
+DROP TABLE t;
+
+-- L1
+
+CREATE TABLE t (val sparsevec(3));
+INSERT INTO t (val) VALUES ('{}/3'), ('{1:1,2:2,3:3}/3'), ('{1:1,2:1,3:1}/3'), (NULL);
+CREATE INDEX ON t USING hnsw (val sparsevec_l1_ops);
+
+INSERT INTO t (val) VALUES ('{1:1,2:2,3:4}/3');
+
+SELECT * FROM t ORDER BY val <+> '{1:3,2:3,3:3}/3';
+SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <+> (SELECT NULL::sparsevec)) t2;
+
+DROP TABLE t;
+
+-- non-zero elements
+
+CREATE TABLE t (val sparsevec(1001));
+INSERT INTO t (val) VALUES (array_fill(1, ARRAY[1001])::vector::sparsevec);
+CREATE INDEX ON t USING hnsw (val sparsevec_l2_ops);
+TRUNCATE t;
+CREATE INDEX ON t USING hnsw (val sparsevec_l2_ops);
+INSERT INTO t (val) VALUES (array_fill(1, ARRAY[1001])::vector::sparsevec);
+DROP TABLE t;

test/sql/hnsw_unlogged.sql

@@ -1,9 +0,0 @@
-SET enable_seqscan = off;
-
-CREATE UNLOGGED TABLE t (val vector(3));
-INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
-CREATE INDEX ON t USING hnsw (val vector_l2_ops);
-
-SELECT * FROM t ORDER BY val <-> '[3,3,3]';
-
-DROP TABLE t;

test/sql/hnsw_vector.sql

@@ -0,0 +1,84 @@
+SET enable_seqscan = off;
+
+-- L2
+
+CREATE TABLE t (val vector(3));
+INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
+CREATE INDEX ON t USING hnsw (val vector_l2_ops);
+
+INSERT INTO t (val) VALUES ('[1,2,4]');
+
+SELECT * FROM t ORDER BY val <-> '[3,3,3]';
+SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <-> (SELECT NULL::vector)) t2;
+SELECT COUNT(*) FROM t;
+
+TRUNCATE t;
+SELECT * FROM t ORDER BY val <-> '[3,3,3]';
+
+DROP TABLE t;
+
+-- inner product
+
+CREATE TABLE t (val vector(3));
+INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
+CREATE INDEX ON t USING hnsw (val vector_ip_ops);
+
+INSERT INTO t (val) VALUES ('[1,2,4]');
+
+SELECT * FROM t ORDER BY val <#> '[3,3,3]';
+SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <#> (SELECT NULL::vector)) t2;
+
+DROP TABLE t;
+
+-- cosine
+
+CREATE TABLE t (val vector(3));
+INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
+CREATE INDEX ON t USING hnsw (val vector_cosine_ops);
+
+INSERT INTO t (val) VALUES ('[1,2,4]');
+
+SELECT * FROM t ORDER BY val <=> '[3,3,3]';
+SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <=> '[0,0,0]') t2;
+SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <=> (SELECT NULL::vector)) t2;
+
+DROP TABLE t;
+
+-- L1
+
+CREATE TABLE t (val vector(3));
+INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
+CREATE INDEX ON t USING hnsw (val vector_l1_ops);
+
+INSERT INTO t (val) VALUES ('[1,2,4]');
+
+SELECT * FROM t ORDER BY val <+> '[3,3,3]';
+SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <+> (SELECT NULL::vector)) t2;
+
+DROP TABLE t;
+
+-- unlogged
+
+CREATE UNLOGGED TABLE t (val vector(3));
+INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
+CREATE INDEX ON t USING hnsw (val vector_l2_ops);
+
+SELECT * FROM t ORDER BY val <-> '[3,3,3]';
+
+DROP TABLE t;
+
+-- options
+
+CREATE TABLE t (val vector(3));
+CREATE INDEX ON t USING hnsw (val vector_l2_ops) WITH (m = 1);
+CREATE INDEX ON t USING hnsw (val vector_l2_ops) WITH (m = 101);
+CREATE INDEX ON t USING hnsw (val vector_l2_ops) WITH (ef_construction = 3);
+CREATE INDEX ON t USING hnsw (val vector_l2_ops) WITH (ef_construction = 1001);
+CREATE INDEX ON t USING hnsw (val vector_l2_ops) WITH (m = 16, ef_construction = 31);
+
+SHOW hnsw.ef_search;
+
+SET hnsw.ef_search = 0;
+SET hnsw.ef_search = 1001;
+
+DROP TABLE t;

test/sql/input.sql

@@ -1,28 +0,0 @@
-SELECT '[1,2,3]'::vector;
-SELECT '[-1,-2,-3]'::vector;
-SELECT '[1.,2.,3.]'::vector;
-SELECT ' [ 1,  2 ,    3  ] '::vector;
-SELECT '[1.23456]'::vector;
-SELECT '[hello,1]'::vector;
-SELECT '[NaN,1]'::vector;
-SELECT '[Infinity,1]'::vector;
-SELECT '[-Infinity,1]'::vector;
-SELECT '[1.5e38,-1.5e38]'::vector;
-SELECT '[1.5e+38,-1.5e+38]'::vector;
-SELECT '[1.5e-38,-1.5e-38]'::vector;
-SELECT '[4e38,1]'::vector;
-SELECT '[1,2,3'::vector;
-SELECT '[1,2,3]9'::vector;
-SELECT '1,2,3'::vector;
-SELECT ''::vector;
-SELECT '['::vector;
-SELECT '[,'::vector;
-SELECT '[]'::vector;
-SELECT '[1,]'::vector;
-SELECT '[1a]'::vector;
-SELECT '[1,,3]'::vector;
-SELECT '[1, ,3]'::vector;
-SELECT '[1,2,3]'::vector(2);
-
-SELECT unnest('{"[1,2,3]", "[4,5,6]"}'::vector[]);
-SELECT '{"[1,2,3]"}'::vector(2)[];

test/sql/ivfflat_bit.sql

@@ -0,0 +1,23 @@
+SET enable_seqscan = off;
+
+-- hamming
+
+CREATE TABLE t (val bit(3));
+INSERT INTO t (val) VALUES (B'000'), (B'100'), (B'111'), (NULL);
+CREATE INDEX ON t USING ivfflat (val bit_hamming_ops) WITH (lists = 1);
+
+INSERT INTO t (val) VALUES (B'110');
+
+SELECT * FROM t ORDER BY val <~> B'111';
+SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <~> (SELECT NULL::bit)) t2;
+
+DROP TABLE t;
+
+-- varbit
+
+CREATE TABLE t (val varbit(3));
+CREATE INDEX ON t USING ivfflat (val bit_hamming_ops) WITH (lists = 1);
+CREATE INDEX ON t USING ivfflat ((val::bit(3)) bit_hamming_ops) WITH (lists = 1);
+CREATE INDEX ON t USING ivfflat ((val::bit(64001)) bit_hamming_ops) WITH (lists = 1);
+CREATE INDEX ON t USING ivfflat ((val::bit(2)) bit_hamming_ops) WITH (lists = 5);
+DROP TABLE t;

test/sql/ivfflat_cosine.sql

@@ -1,13 +0,0 @@
-SET enable_seqscan = off;
-
-CREATE TABLE t (val vector(3));
-INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
-CREATE INDEX ON t USING ivfflat (val vector_cosine_ops) WITH (lists = 1);
-
-INSERT INTO t (val) VALUES ('[1,2,4]');
-
-SELECT * FROM t ORDER BY val <=> '[3,3,3]';
-SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <=> '[0,0,0]') t2;
-SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <=> (SELECT NULL::vector)) t2;
-
-DROP TABLE t;

test/sql/ivfflat_halfvec.sql

@@ -0,0 +1,45 @@
+SET enable_seqscan = off;
+
+-- L2
+
+CREATE TABLE t (val halfvec(3));
+INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
+CREATE INDEX ON t USING ivfflat (val halfvec_l2_ops) WITH (lists = 1);
+
+INSERT INTO t (val) VALUES ('[1,2,4]');
+
+SELECT * FROM t ORDER BY val <-> '[3,3,3]';
+SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <-> (SELECT NULL::halfvec)) t2;
+SELECT COUNT(*) FROM t;
+
+TRUNCATE t;
+SELECT * FROM t ORDER BY val <-> '[3,3,3]';
+
+DROP TABLE t;
+
+-- inner product
+
+CREATE TABLE t (val halfvec(3));
+INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
+CREATE INDEX ON t USING ivfflat (val halfvec_ip_ops) WITH (lists = 1);
+
+INSERT INTO t (val) VALUES ('[1,2,4]');
+
+SELECT * FROM t ORDER BY val <#> '[3,3,3]';
+SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <#> (SELECT NULL::halfvec)) t2;
+
+DROP TABLE t;
+
+-- cosine
+
+CREATE TABLE t (val halfvec(3));
+INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
+CREATE INDEX ON t USING ivfflat (val halfvec_cosine_ops) WITH (lists = 1);
+
+INSERT INTO t (val) VALUES ('[1,2,4]');
+
+SELECT * FROM t ORDER BY val <=> '[3,3,3]';
+SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <=> '[0,0,0]') t2;
+SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <=> (SELECT NULL::halfvec)) t2;
+
+DROP TABLE t;

test/sql/ivfflat_ip.sql

@@ -1,12 +0,0 @@
-SET enable_seqscan = off;
-
-CREATE TABLE t (val vector(3));
-INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
-CREATE INDEX ON t USING ivfflat (val vector_ip_ops) WITH (lists = 1);
-
-INSERT INTO t (val) VALUES ('[1,2,4]');
-
-SELECT * FROM t ORDER BY val <#> '[3,3,3]';
-SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <#> (SELECT NULL::vector)) t2;
-
-DROP TABLE t;

test/sql/ivfflat_l2.sql

@@ -1,16 +0,0 @@
-SET enable_seqscan = off;
-
-CREATE TABLE t (val vector(3));
-INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
-CREATE INDEX ON t USING ivfflat (val vector_l2_ops) WITH (lists = 1);
-
-INSERT INTO t (val) VALUES ('[1,2,4]');
-
-SELECT * FROM t ORDER BY val <-> '[3,3,3]';
-SELECT * FROM t ORDER BY val <-> (SELECT NULL::vector);
-SELECT COUNT(*) FROM t;
-
-TRUNCATE t;
-SELECT * FROM t ORDER BY val <-> '[3,3,3]';
-
-DROP TABLE t;

test/sql/ivfflat_options.sql

@@ -1,7 +0,0 @@
-CREATE TABLE t (val vector(3));
-CREATE INDEX ON t USING ivfflat (val vector_l2_ops) WITH (lists = 0);
-CREATE INDEX ON t USING ivfflat (val vector_l2_ops) WITH (lists = 32769);
-
-SHOW ivfflat.probes;
-
-DROP TABLE t;

test/sql/ivfflat_unlogged.sql

@@ -1,9 +0,0 @@
-SET enable_seqscan = off;
-
-CREATE UNLOGGED TABLE t (val vector(3));
-INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
-CREATE INDEX ON t USING ivfflat (val vector_l2_ops) WITH (lists = 1);
-
-SELECT * FROM t ORDER BY val <-> '[3,3,3]';
-
-DROP TABLE t;

test/sql/ivfflat_vector.sql

@@ -0,0 +1,65 @@
+SET enable_seqscan = off;
+
+-- L2
+
+CREATE TABLE t (val vector(3));
+INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
+CREATE INDEX ON t USING ivfflat (val vector_l2_ops) WITH (lists = 1);
+
+INSERT INTO t (val) VALUES ('[1,2,4]');
+
+SELECT * FROM t ORDER BY val <-> '[3,3,3]';
+SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <-> (SELECT NULL::vector)) t2;
+SELECT COUNT(*) FROM t;
+
+TRUNCATE t;
+SELECT * FROM t ORDER BY val <-> '[3,3,3]';
+
+DROP TABLE t;
+
+-- inner product
+
+CREATE TABLE t (val vector(3));
+INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
+CREATE INDEX ON t USING ivfflat (val vector_ip_ops) WITH (lists = 1);
+
+INSERT INTO t (val) VALUES ('[1,2,4]');
+
+SELECT * FROM t ORDER BY val <#> '[3,3,3]';
+SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <#> (SELECT NULL::vector)) t2;
+
+DROP TABLE t;
+
+-- cosine
+
+CREATE TABLE t (val vector(3));
+INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
+CREATE INDEX ON t USING ivfflat (val vector_cosine_ops) WITH (lists = 1);
+
+INSERT INTO t (val) VALUES ('[1,2,4]');
+
+SELECT * FROM t ORDER BY val <=> '[3,3,3]';
+SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <=> '[0,0,0]') t2;
+SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <=> (SELECT NULL::vector)) t2;
+
+DROP TABLE t;
+
+-- unlogged
+
+CREATE UNLOGGED TABLE t (val vector(3));
+INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
+CREATE INDEX ON t USING ivfflat (val vector_l2_ops) WITH (lists = 1);
+
+SELECT * FROM t ORDER BY val <-> '[3,3,3]';
+
+DROP TABLE t;
+
+-- options
+
+CREATE TABLE t (val vector(3));
+CREATE INDEX ON t USING ivfflat (val vector_l2_ops) WITH (lists = 0);
+CREATE INDEX ON t USING ivfflat (val vector_l2_ops) WITH (lists = 32769);
+
+SHOW ivfflat.probes;
+
+DROP TABLE t;

test/sql/sparsevec.sql

@@ -0,0 +1,134 @@
+SELECT '{1:1.5,3:3.5}/5'::sparsevec;
+SELECT '{1:-2,3:-4}/5'::sparsevec;
+SELECT '{1:2.,3:4.}/5'::sparsevec;
+SELECT ' { 1 : 1.5 ,  3  :  3.5  } / 5 '::sparsevec;
+SELECT '{1:1.23456}/1'::sparsevec;
+SELECT '{1:hello,2:1}/2'::sparsevec;
+SELECT '{1:NaN,2:1}/2'::sparsevec;
+SELECT '{1:Infinity,2:1}/2'::sparsevec;
+SELECT '{1:-Infinity,2:1}/2'::sparsevec;
+SELECT '{1:1.5e38,2:-1.5e38}/2'::sparsevec;
+SELECT '{1:1.5e+38,2:-1.5e+38}/2'::sparsevec;
+SELECT '{1:1.5e-38,2:-1.5e-38}/2'::sparsevec;
+SELECT '{1:4e38,2:1}/2'::sparsevec;
+SELECT '{1:-4e38,2:1}/2'::sparsevec;
+SELECT '{1:1e-46,2:1}/2'::sparsevec;
+SELECT '{1:-1e-46,2:1}/2'::sparsevec;
+SELECT ''::sparsevec;
+SELECT '{'::sparsevec;
+SELECT '{ '::sparsevec;
+SELECT '{:'::sparsevec;
+SELECT '{,'::sparsevec;
+SELECT '{}'::sparsevec;
+SELECT '{}/'::sparsevec;
+SELECT '{}/1'::sparsevec;
+SELECT '{}/1a'::sparsevec;
+SELECT '{ }/1'::sparsevec;
+SELECT '{:}/1'::sparsevec;
+SELECT '{,}/1'::sparsevec;
+SELECT '{1,}/1'::sparsevec;
+SELECT '{:1}/1'::sparsevec;
+SELECT '{1:}/1'::sparsevec;
+SELECT '{1a:1}/1'::sparsevec;
+SELECT '{1:1a}/1'::sparsevec;
+SELECT '{1:1,}/1'::sparsevec;
+SELECT '{1:0,2:1,3:0}/3'::sparsevec;
+SELECT '{2:1,1:1}/2'::sparsevec;
+SELECT '{1:1,1:1}/2'::sparsevec;
+SELECT '{1:1,2:1,1:1}/2'::sparsevec;
+SELECT '{}/5'::sparsevec;
+SELECT '{}/-1'::sparsevec;
+SELECT '{}/1000000001'::sparsevec;
+SELECT '{}/2147483648'::sparsevec;
+SELECT '{}/-2147483649'::sparsevec;
+SELECT '{}/9223372036854775808'::sparsevec;
+SELECT '{}/-9223372036854775809'::sparsevec;
+SELECT '{2147483647:1}/1'::sparsevec;
+SELECT '{2147483648:1}/1'::sparsevec;
+SELECT '{-2147483648:1}/1'::sparsevec;
+SELECT '{-2147483649:1}/1'::sparsevec;
+SELECT '{0:1}/1'::sparsevec;
+SELECT '{2:1}/1'::sparsevec;
+
+SELECT '{}/3'::sparsevec(3);
+SELECT '{}/3'::sparsevec(2);
+SELECT '{}/3'::sparsevec(3, 2);
+SELECT '{}/3'::sparsevec('a');
+SELECT '{}/3'::sparsevec(0);
+SELECT '{}/3'::sparsevec(1000000001);
+
+SELECT '{1:1,2:2,3:3}/3'::sparsevec < '{1:1,2:2,3:3}/3';
+SELECT '{1:1,2:2,3:3}/3'::sparsevec < '{1:1,2:2}/2';
+SELECT '{1:1,2:2,3:3}/3'::sparsevec <= '{1:1,2:2,3:3}/3';
+SELECT '{1:1,2:2,3:3}/3'::sparsevec <= '{1:1,2:2}/2';
+SELECT '{1:1,2:2,3:3}/3'::sparsevec = '{1:1,2:2,3:3}/3';
+SELECT '{1:1,2:2,3:3}/3'::sparsevec = '{1:1,2:2}/2';
+SELECT '{1:1,2:2,3:3}/3'::sparsevec != '{1:1,2:2,3:3}/3';
+SELECT '{1:1,2:2,3:3}/3'::sparsevec != '{1:1,2:2}/2';
+SELECT '{1:1,2:2,3:3}/3'::sparsevec >= '{1:1,2:2,3:3}/3';
+SELECT '{1:1,2:2,3:3}/3'::sparsevec >= '{1:1,2:2}/2';
+SELECT '{1:1,2:2,3:3}/3'::sparsevec > '{1:1,2:2,3:3}/3';
+SELECT '{1:1,2:2,3:3}/3'::sparsevec > '{1:1,2:2}/2';
+
+SELECT sparsevec_cmp('{1:1,2:2,3:3}/3', '{1:1,2:2,3:3}/3');
+SELECT sparsevec_cmp('{1:1,2:2,3:3}/3', '{}/3');
+SELECT sparsevec_cmp('{}/3', '{1:1,2:2,3:3}/3');
+SELECT sparsevec_cmp('{1:1,2:2}/2', '{1:1,2:2,3:3}/3');
+SELECT sparsevec_cmp('{1:1,2:2,3:3}/3', '{1:1,2:2}/2');
+SELECT sparsevec_cmp('{1:1,2:2}/2', '{1:2,2:3,3:4}/3');
+SELECT sparsevec_cmp('{1:2,2:3}/2', '{1:1,2:2,3:3}/3');
+
+SELECT round(l2_norm('{1:1,2:1}/2'::sparsevec)::numeric, 5);
+SELECT l2_norm('{1:3,2:4}/2'::sparsevec);
+SELECT l2_norm('{2:1}/2'::sparsevec);
+SELECT l2_norm('{1:3e37,2:4e37}/2'::sparsevec)::real;
+SELECT l2_norm('{}/2'::sparsevec);
+SELECT l2_norm('{1:2}/1'::sparsevec);
+
+SELECT l2_distance('{}/2'::sparsevec, '{1:3,2:4}/2');
+SELECT l2_distance('{1:3}/2'::sparsevec, '{2:4}/2');
+SELECT l2_distance('{2:4}/2'::sparsevec, '{1:3}/2');
+SELECT l2_distance('{1:3,2:4}/2'::sparsevec, '{}/2');
+SELECT l2_distance('{}/2'::sparsevec, '{2:1}/2');
+SELECT '{}/2'::sparsevec <-> '{1:3,2:4}/2';
+
+SELECT inner_product('{1:1,2:2}/2'::sparsevec, '{1:2,2:4}/2');
+SELECT inner_product('{1:1,2:2}/2'::sparsevec, '{1:3}/1');
+SELECT inner_product('{1:1,3:3}/4'::sparsevec, '{2:2,4:4}/4');
+SELECT inner_product('{2:2,4:4}/4'::sparsevec, '{1:1,3:3}/4');
+SELECT inner_product('{1:1,3:3,5:5}/5'::sparsevec, '{2:4,3:6,4:8}/5');
+SELECT inner_product('{1:1}/2'::sparsevec, '{}/2');
+SELECT inner_product('{}/2'::sparsevec, '{1:1}/2');
+SELECT inner_product('{1:3e38}/1'::sparsevec, '{1:3e38}/1');
+SELECT inner_product('{1:1,3:3,5:5}/5'::sparsevec, '{2:4,3:6,4:8}/5');
+SELECT '{1:1,2:2}/2'::sparsevec <#> '{1:3,2:4}/2';
+
+SELECT cosine_distance('{1:1,2:2}/2'::sparsevec, '{1:2,2:4}/2');
+SELECT cosine_distance('{1:1,2:2}/2'::sparsevec, '{}/2');
+SELECT cosine_distance('{1:1,2:1}/2'::sparsevec, '{1:1,2:1}/2');
+SELECT cosine_distance('{1:1}/2'::sparsevec, '{2:2}/2');
+SELECT cosine_distance('{1:1,2:1}/2'::sparsevec, '{1:-1,2:-1}/2');
+SELECT cosine_distance('{1:2}/2'::sparsevec, '{2:2}/2');
+SELECT cosine_distance('{2:2}/2'::sparsevec, '{1:2}/2');
+SELECT cosine_distance('{1:1,2:2}/2'::sparsevec, '{1:3}/1');
+SELECT cosine_distance('{1:1,2:1}/2'::sparsevec, '{1:1.1,2:1.1}/2');
+SELECT cosine_distance('{1:1,2:1}/2'::sparsevec, '{1:-1.1,2:-1.1}/2');
+SELECT cosine_distance('{1:3e38}/1'::sparsevec, '{1:3e38}/1');
+SELECT cosine_distance('{}/1'::sparsevec, '{}/1');
+SELECT '{1:1,2:2}/2'::sparsevec <=> '{1:2,2:4}/2';
+
+SELECT l1_distance('{}/2'::sparsevec, '{1:3,2:4}/2');
+SELECT l1_distance('{}/2'::sparsevec, '{2:1}/2');
+SELECT l1_distance('{1:1,2:2}/2'::sparsevec, '{1:3}/1');
+SELECT l1_distance('{1:3e38}/1'::sparsevec, '{1:-3e38}/1');
+SELECT l1_distance('{1:1,3:3,5:5,7:7}/8'::sparsevec, '{2:2,4:4,6:6,8:8}/8');
+SELECT l1_distance('{1:1,3:3,5:5,7:7,9:9}/9'::sparsevec, '{2:2,4:4,6:6,8:8}/9');
+SELECT '{}/2'::sparsevec <+> '{1:3,2:4}/2';
+
+SELECT l2_normalize('{1:3,2:4}/2'::sparsevec);
+SELECT l2_normalize('{1:3}/2'::sparsevec);
+SELECT l2_normalize('{2:0.1}/2'::sparsevec);
+SELECT l2_normalize('{}/2'::sparsevec);
+SELECT l2_normalize('{1:3e38}/1'::sparsevec);
+SELECT l2_normalize('{1:3e38,2:1e-37}/2'::sparsevec);
+SELECT l2_normalize('{2:3e37,4:3e-37,6:4e37,8:4e-37}/9'::sparsevec);

test/sql/vector_type.sql

@@ -0,0 +1,154 @@
+SELECT '[1,2,3]'::vector;
+SELECT '[-1,-2,-3]'::vector;
+SELECT '[1.,2.,3.]'::vector;
+SELECT ' [ 1,  2 ,    3  ] '::vector;
+SELECT '[1.23456]'::vector;
+SELECT '[hello,1]'::vector;
+SELECT '[NaN,1]'::vector;
+SELECT '[Infinity,1]'::vector;
+SELECT '[-Infinity,1]'::vector;
+SELECT '[1.5e38,-1.5e38]'::vector;
+SELECT '[1.5e+38,-1.5e+38]'::vector;
+SELECT '[1.5e-38,-1.5e-38]'::vector;
+SELECT '[4e38,1]'::vector;
+SELECT '[-4e38,1]'::vector;
+SELECT '[1e-46,1]'::vector;
+SELECT '[-1e-46,1]'::vector;
+SELECT '[1,2,3'::vector;
+SELECT '[1,2,3]9'::vector;
+SELECT '1,2,3'::vector;
+SELECT ''::vector;
+SELECT '['::vector;
+SELECT '[ '::vector;
+SELECT '[,'::vector;
+SELECT '[]'::vector;
+SELECT '[ ]'::vector;
+SELECT '[,]'::vector;
+SELECT '[1,]'::vector;
+SELECT '[1a]'::vector;
+SELECT '[1,,3]'::vector;
+SELECT '[1, ,3]'::vector;
+
+SELECT '[1,2,3]'::vector(3);
+SELECT '[1,2,3]'::vector(2);
+SELECT '[1,2,3]'::vector(3, 2);
+SELECT '[1,2,3]'::vector('a');
+SELECT '[1,2,3]'::vector(0);
+SELECT '[1,2,3]'::vector(16001);
+
+SELECT unnest('{"[1,2,3]", "[4,5,6]"}'::vector[]);
+SELECT '{"[1,2,3]"}'::vector(2)[];
+
+
+SELECT '[1,2,3]'::vector + '[4,5,6]';
+SELECT '[3e38]'::vector + '[3e38]';
+SELECT '[1,2]'::vector + '[3]';
+
+SELECT '[1,2,3]'::vector - '[4,5,6]';
+SELECT '[-3e38]'::vector - '[3e38]';
+SELECT '[1,2]'::vector - '[3]';
+
+SELECT '[1,2,3]'::vector * '[4,5,6]';
+SELECT '[1e37]'::vector * '[1e37]';
+SELECT '[1e-37]'::vector * '[1e-37]';
+SELECT '[1,2]'::vector * '[3]';
+
+SELECT '[1,2,3]'::vector || '[4,5]';
+SELECT array_fill(0, ARRAY[16000])::vector || '[1]';
+
+SELECT '[1,2,3]'::vector < '[1,2,3]';
+SELECT '[1,2,3]'::vector < '[1,2]';
+SELECT '[1,2,3]'::vector <= '[1,2,3]';
+SELECT '[1,2,3]'::vector <= '[1,2]';
+SELECT '[1,2,3]'::vector = '[1,2,3]';
+SELECT '[1,2,3]'::vector = '[1,2]';
+SELECT '[1,2,3]'::vector != '[1,2,3]';
+SELECT '[1,2,3]'::vector != '[1,2]';
+SELECT '[1,2,3]'::vector >= '[1,2,3]';
+SELECT '[1,2,3]'::vector >= '[1,2]';
+SELECT '[1,2,3]'::vector > '[1,2,3]';
+SELECT '[1,2,3]'::vector > '[1,2]';
+
+SELECT vector_cmp('[1,2,3]', '[1,2,3]');
+SELECT vector_cmp('[1,2,3]', '[0,0,0]');
+SELECT vector_cmp('[0,0,0]', '[1,2,3]');
+SELECT vector_cmp('[1,2]', '[1,2,3]');
+SELECT vector_cmp('[1,2,3]', '[1,2]');
+SELECT vector_cmp('[1,2]', '[2,3,4]');
+SELECT vector_cmp('[2,3]', '[1,2,3]');
+
+SELECT vector_dims('[1,2,3]'::vector);
+
+SELECT round(vector_norm('[1,1]')::numeric, 5);
+SELECT vector_norm('[3,4]');
+SELECT vector_norm('[0,1]');
+SELECT vector_norm('[3e37,4e37]')::real;
+SELECT vector_norm('[0,0]');
+SELECT vector_norm('[2]');
+
+SELECT l2_distance('[0,0]'::vector, '[3,4]');
+SELECT l2_distance('[0,0]'::vector, '[0,1]');
+SELECT l2_distance('[1,2]'::vector, '[3]');
+SELECT l2_distance('[3e38]'::vector, '[-3e38]');
+SELECT l2_distance('[1,1,1,1,1,1,1,1,1]'::vector, '[1,1,1,1,1,1,1,4,5]');
+SELECT '[0,0]'::vector <-> '[3,4]';
+
+SELECT inner_product('[1,2]'::vector, '[3,4]');
+SELECT inner_product('[1,2]'::vector, '[3]');
+SELECT inner_product('[3e38]'::vector, '[3e38]');
+SELECT inner_product('[1,1,1,1,1,1,1,1,1]'::vector, '[1,2,3,4,5,6,7,8,9]');
+SELECT '[1,2]'::vector <#> '[3,4]';
+
+SELECT cosine_distance('[1,2]'::vector, '[2,4]');
+SELECT cosine_distance('[1,2]'::vector, '[0,0]');
+SELECT cosine_distance('[1,1]'::vector, '[1,1]');
+SELECT cosine_distance('[1,0]'::vector, '[0,2]');
+SELECT cosine_distance('[1,1]'::vector, '[-1,-1]');
+SELECT cosine_distance('[1,2]'::vector, '[3]');
+SELECT cosine_distance('[1,1]'::vector, '[1.1,1.1]');
+SELECT cosine_distance('[1,1]'::vector, '[-1.1,-1.1]');
+SELECT cosine_distance('[3e38]'::vector, '[3e38]');
+SELECT cosine_distance('[1,2,3,4,5,6,7,8,9]'::vector, '[1,2,3,4,5,6,7,8,9]');
+SELECT cosine_distance('[1,2,3,4,5,6,7,8,9]'::vector, '[-1,-2,-3,-4,-5,-6,-7,-8,-9]');
+SELECT '[1,2]'::vector <=> '[2,4]';
+
+SELECT l1_distance('[0,0]'::vector, '[3,4]');
+SELECT l1_distance('[0,0]'::vector, '[0,1]');
+SELECT l1_distance('[1,2]'::vector, '[3]');
+SELECT l1_distance('[3e38]'::vector, '[-3e38]');
+SELECT l1_distance('[1,2,3,4,5,6,7,8,9]'::vector, '[1,2,3,4,5,6,7,8,9]');
+SELECT l1_distance('[1,2,3,4,5,6,7,8,9]'::vector, '[0,3,2,5,4,7,6,9,8]');
+SELECT '[0,0]'::vector <+> '[3,4]';
+
+SELECT l2_normalize('[3,4]'::vector);
+SELECT l2_normalize('[3,0]'::vector);
+SELECT l2_normalize('[0,0.1]'::vector);
+SELECT l2_normalize('[0,0]'::vector);
+SELECT l2_normalize('[3e38]'::vector);
+
+SELECT binary_quantize('[1,0,-1]'::vector);
+SELECT binary_quantize('[0,0.1,-0.2,-0.3,0.4,0.5,0.6,-0.7,0.8,-0.9,1]'::vector);
+
+SELECT subvector('[1,2,3,4,5]'::vector, 1, 3);
+SELECT subvector('[1,2,3,4,5]'::vector, 3, 2);
+SELECT subvector('[1,2,3,4,5]'::vector, -1, 3);
+SELECT subvector('[1,2,3,4,5]'::vector, 3, 9);
+SELECT subvector('[1,2,3,4,5]'::vector, 1, 0);
+SELECT subvector('[1,2,3,4,5]'::vector, 3, -1);
+SELECT subvector('[1,2,3,4,5]'::vector, -1, 2);
+SELECT subvector('[1,2,3,4,5]'::vector, 2147483647, 10);
+SELECT subvector('[1,2,3,4,5]'::vector, 3, 2147483647);
+SELECT subvector('[1,2,3,4,5]'::vector, -2147483644, 2147483647);
+
+SELECT avg(v) FROM unnest(ARRAY['[1,2,3]'::vector, '[3,5,7]']) v;
+SELECT avg(v) FROM unnest(ARRAY['[1,2,3]'::vector, '[3,5,7]', NULL]) v;
+SELECT avg(v) FROM unnest(ARRAY[]::vector[]) v;
+SELECT avg(v) FROM unnest(ARRAY['[1,2]'::vector, '[3]']) v;
+SELECT avg(v) FROM unnest(ARRAY['[3e38]'::vector, '[3e38]']) v;
+SELECT vector_avg(array_agg(n)) FROM generate_series(1, 16002) n;
+
+SELECT sum(v) FROM unnest(ARRAY['[1,2,3]'::vector, '[3,5,7]']) v;
+SELECT sum(v) FROM unnest(ARRAY['[1,2,3]'::vector, '[3,5,7]', NULL]) v;
+SELECT sum(v) FROM unnest(ARRAY[]::vector[]) v;
+SELECT sum(v) FROM unnest(ARRAY['[1,2]'::vector, '[3]']) v;
+SELECT sum(v) FROM unnest(ARRAY['[3e38]'::vector, '[3e38]']) v;

test/t/003_ivfflat_vector_build_recall.pl

@@ -30,18 +30,19 @@ sub test_recall
 			SELECT i FROM tst ORDER BY v $operator '$queries[$i]' LIMIT $limit;
 		));
 		my @actual_ids = split("\n", $actual);
-		my %actual_set = map { $_ => 1 } @actual_ids;
 
 		my @expected_ids = split("\n", $expected[$i]);
+		my %expected_set = map { $_ => 1 } @expected_ids;
 
-		foreach (@expected_ids)
+		foreach (@actual_ids)
 		{
-			if (exists($actual_set{$_}))
+			if (exists($expected_set{$_}))
 			{
 				$correct++;
 			}
-			$total++;
 		}
+
+		$total += $limit;
 	}
 
 	cmp_ok($correct / $total, ">=", $min, $operator);
@@ -81,7 +82,12 @@ for my $i (0 .. $#operators)
 	@expected = ();
 	foreach (@queries)
 	{
-		my $res = $node->safe_psql("postgres", "SELECT i FROM tst ORDER BY v $operator '$_' LIMIT $limit;");
+		my $res = $node->safe_psql("postgres", qq(
+			WITH top AS (
+				SELECT v $operator '$_' AS distance FROM tst ORDER BY distance LIMIT $limit
+			)
+			SELECT i FROM tst WHERE (v $operator '$_') <= (SELECT MAX(distance) FROM top)
+		));
 		push(@expected, $res);
 	}
 
@@ -98,8 +104,16 @@ for my $i (0 .. $#operators)
 		test_recall(1, 0.71, $operator);
 		test_recall(10, 0.95, $operator);
 	}
-	# Account for equal distances
-	test_recall(100, 0.9925, $operator);
+
+	# Test probes equals lists
+	if ($operator eq "<=>")
+	{
+		test_recall(100, 0.9925, $operator);
+	}
+	else
+	{
+		test_recall(100, 1.00, $operator);
+	}
 
 	$node->safe_psql("postgres", "DROP INDEX idx;");
 
@@ -119,8 +133,16 @@ for my $i (0 .. $#operators)
 		test_recall(1, 0.71, $operator);
 		test_recall(10, 0.95, $operator);
 	}
-	# Account for equal distances
-	test_recall(100, 0.9925, $operator);
+
+	# Test probes equals lists
+	if ($operator eq "<=>")
+	{
+		test_recall(100, 0.9925, $operator);
+	}
+	else
+	{
+		test_recall(100, 1.00, $operator);
+	}
 
 	$node->safe_psql("postgres", "DROP INDEX idx;");
 }

test/t/009_ivfflat_filtering.pl

@@ -0,0 +1,116 @@
+use strict;
+use warnings;
+use PostgresNode;
+use TestLib;
+use Test::More;
+
+my $dim = 3;
+my $nc = 50;
+my $limit = 20;
+
+my $array_sql = join(",", ('random()') x $dim);
+
+# Initialize node
+my $node = get_new_node('node');
+$node->init;
+$node->start;
+
+# Create table and index
+$node->safe_psql("postgres", "CREATE EXTENSION vector;");
+$node->safe_psql("postgres", "CREATE TABLE tst (i int4, v vector($dim), c int4, t text);");
+$node->safe_psql("postgres",
+	"INSERT INTO tst SELECT i, ARRAY[$array_sql], i % $nc, 'test ' || i FROM generate_series(1, 10000) i;"
+);
+$node->safe_psql("postgres", "CREATE INDEX idx ON tst USING ivfflat (v vector_l2_ops) WITH (lists = 100);");
+$node->safe_psql("postgres", "ANALYZE tst;");
+
+# Generate query
+my @r = ();
+for (1 .. $dim)
+{
+	push(@r, rand());
+}
+my $query = "[" . join(",", @r) . "]";
+my $c = int(rand() * $nc);
+
+# Test attribute filtering
+my $explain = $node->safe_psql("postgres", qq(
+	EXPLAIN ANALYZE SELECT i FROM tst WHERE c = $c ORDER BY v <-> '$query' LIMIT $limit;
+));
+# TODO Do not use index
+like($explain, qr/Index Scan using idx/);
+
+# Test attribute filtering with few rows removed
+$explain = $node->safe_psql("postgres", qq(
+	EXPLAIN ANALYZE SELECT i FROM tst WHERE c != $c ORDER BY v <-> '$query' LIMIT $limit;
+));
+like($explain, qr/Index Scan using idx/);
+
+# Test attribute filtering with few rows removed comparison
+$explain = $node->safe_psql("postgres", qq(
+	EXPLAIN ANALYZE SELECT i FROM tst WHERE c >= 1 ORDER BY v <-> '$query' LIMIT $limit;
+));
+like($explain, qr/Index Scan using idx/);
+
+# Test attribute filtering with many rows removed comparison
+$explain = $node->safe_psql("postgres", qq(
+	EXPLAIN ANALYZE SELECT i FROM tst WHERE c < 1 ORDER BY v <-> '$query' LIMIT $limit;
+));
+# TODO Do not use index
+like($explain, qr/Index Scan using idx/);
+
+# Test attribute filtering with few rows removed like
+$explain = $node->safe_psql("postgres", qq(
+	EXPLAIN ANALYZE SELECT i FROM tst WHERE t LIKE '%%test%%' ORDER BY v <-> '$query' LIMIT $limit;
+));
+like($explain, qr/Index Scan using idx/);
+
+# Test attribute filtering with many rows removed like
+$explain = $node->safe_psql("postgres", qq(
+	EXPLAIN ANALYZE SELECT i FROM tst WHERE t LIKE '%%other%%' ORDER BY v <-> '$query' LIMIT $limit;
+));
+like($explain, qr/Seq Scan/);
+
+# Test distance filtering
+$explain = $node->safe_psql("postgres", qq(
+	EXPLAIN ANALYZE SELECT i FROM tst WHERE v <-> '$query' < 1 ORDER BY v <-> '$query' LIMIT $limit;
+));
+like($explain, qr/Index Scan using idx/);
+
+# Test distance filtering greater than distance
+$explain = $node->safe_psql("postgres", qq(
+	EXPLAIN ANALYZE SELECT i FROM tst WHERE v <-> '$query' > 1 ORDER BY v <-> '$query' LIMIT $limit;
+));
+# TODO Do not use index
+like($explain, qr/Index Scan using idx/);
+
+# Test distance filtering without order
+$explain = $node->safe_psql("postgres", qq(
+	EXPLAIN ANALYZE SELECT i FROM tst WHERE v <-> '$query' < 1;
+));
+like($explain, qr/Seq Scan/);
+
+# Test distance filtering without limit
+$explain = $node->safe_psql("postgres", qq(
+	EXPLAIN ANALYZE SELECT i FROM tst WHERE v <-> '$query' < 1 ORDER BY v <-> '$query';
+));
+# TODO Do not use index
+like($explain, qr/Index Scan using idx/);
+
+# Test attribute index
+$node->safe_psql("postgres", "CREATE INDEX attribute_idx ON tst (c);");
+$explain = $node->safe_psql("postgres", qq(
+	EXPLAIN ANALYZE SELECT i FROM tst WHERE c = $c ORDER BY v <-> '$query' LIMIT $limit;
+));
+# TODO Use attribute index
+like($explain, qr/Index Scan using idx/);
+
+# Test partial index
+$node->safe_psql("postgres", "CREATE INDEX partial_idx ON tst USING ivfflat (v vector_l2_ops) WITH (lists = 5) WHERE (c = $c);");
+$explain = $node->safe_psql("postgres", qq(
+	EXPLAIN ANALYZE SELECT i FROM tst WHERE c = $c ORDER BY v <-> '$query' LIMIT $limit;
+));
+# TODO Use partial index
+like($explain, qr/Index Scan using idx/);
+
+done_testing();

test/t/012_hnsw_vector_build_recall.pl

@@ -8,6 +8,7 @@ my $node;
 my @queries = ();
 my @expected;
 my $limit = 20;
+my $array_sql = join(",", ('random() * random()') x 3);
 
 sub test_recall
 {
@@ -54,7 +55,7 @@ $node->start;
 $node->safe_psql("postgres", "CREATE EXTENSION vector;");
 $node->safe_psql("postgres", "CREATE TABLE tst (i int4, v vector(3));");
 $node->safe_psql("postgres",
-	"INSERT INTO tst SELECT i, ARRAY[random(), random(), random()] FROM generate_series(1, 10000) i;"
+	"INSERT INTO tst SELECT i, ARRAY[$array_sql] FROM generate_series(1, 10000) i;"
 );
 
 # Generate queries
@@ -67,8 +68,8 @@ for (1 .. 20)
 }
 
 # Check each index type
-my @operators = ("<->", "<#>", "<=>");
-my @opclasses = ("vector_l2_ops", "vector_ip_ops", "vector_cosine_ops");
+my @operators = ("<->", "<#>", "<=>", "<+>");
+my @opclasses = ("vector_l2_ops", "vector_ip_ops", "vector_cosine_ops", "vector_l1_ops");
 
 for my $i (0 .. $#operators)
 {
@@ -90,16 +91,15 @@ for my $i (0 .. $#operators)
 	));
 
 	# Test approximate results
-	my $min = $operator eq "<#>" ? 0.80 : 0.99;
+	my $min = $operator eq "<#>" ? 0.97 : 0.99;
 	test_recall($min, $operator);
 
 	$node->safe_psql("postgres", "DROP INDEX idx;");
 
-	# Build index in parallel
+	# Build index in parallel in memory
 	my ($ret, $stdout, $stderr) = $node->psql("postgres", qq(
 		SET client_min_messages = DEBUG;
 		SET min_parallel_table_scan_size = 1;
-		SET hnsw.enable_parallel_build = on;
 		CREATE INDEX idx ON tst USING hnsw (v $opclass);
 	));
 	is($ret, 0, $stderr);
@@ -109,6 +109,21 @@ for my $i (0 .. $#operators)
 	test_recall($min, $operator);
 
 	$node->safe_psql("postgres", "DROP INDEX idx;");
+
+	# Build index in parallel on disk
+	# Set parallel_workers on table to use workers with low maintenance_work_mem
+	($ret, $stdout, $stderr) = $node->psql("postgres", qq(
+		ALTER TABLE tst SET (parallel_workers = 2);
+		SET client_min_messages = DEBUG;
+		SET maintenance_work_mem = '4MB';
+		CREATE INDEX idx ON tst USING hnsw (v $opclass);
+		ALTER TABLE tst RESET (parallel_workers);
+	));
+	is($ret, 0, $stderr);
+	like($stderr, qr/using \d+ parallel workers/);
+	like($stderr, qr/hnsw graph no longer fits into maintenance_work_mem/);
+
+	$node->safe_psql("postgres", "DROP INDEX idx;");
 }
 
 done_testing();