Improved check [skip ci]

.github/workflows/build.yml

@@ -8,18 +8,18 @@ jobs:
       fail-fast: false
       matrix:
         include:
-          - postgres: 18
-            os: ubuntu-24.04
           - postgres: 17
-            os: ubuntu-24.04
+            os: ubuntu-22.04
           - postgres: 16
             os: ubuntu-22.04
           - postgres: 15
             os: ubuntu-22.04
           - postgres: 14
-            os: ubuntu-20.04
+            os: ubuntu-22.04
           - postgres: 13
             os: ubuntu-20.04
+          - postgres: 12
+            os: ubuntu-20.04
     steps:
       - uses: actions/checkout@v4
       - uses: ankane/setup-postgres@v1
@@ -49,7 +49,7 @@ jobs:
           - postgres: 16
             os: macos-14
           - postgres: 14
-            os: macos-13
+            os: macos-12
     steps:
       - uses: actions/checkout@v4
       - uses: ankane/setup-postgres@v1
@@ -87,14 +87,13 @@ jobs:
           postgres-version: 14
       - run: |
           call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars64.bat" && ^
+          cd %TEMP% && ^
           nmake /NOLOGO /F Makefile.win && ^
           nmake /NOLOGO /F Makefile.win install && ^
           nmake /NOLOGO /F Makefile.win installcheck && ^
           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

CHANGELOG.md

@@ -1,40 +1,8 @@
-## 0.8.0 (unreleased)
+## 0.7.0 (unreleased)
-
-- Added support for iterative index scans
-- Added casts for arrays to `sparsevec`
-- Improved cost estimation
-- Improved performance of HNSW inserts and on-disk index builds
-- Reduced memory usage for HNSW index scans
-- Dropped support for Postgres 12
-
-## 0.7.4 (2024-08-05)
-
-- Fixed locking for parallel HNSW index builds
-- Fixed compilation error with GCC 14 on i386 when SSE2 is not enabled
-
-## 0.7.3 (2024-07-22)
-
-- 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

Dockerfile

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

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.7.4",
+	"version": "0.6.2",
 	"maintainer": [
 		"Andrew Kane <andrew@ankane.org>"
 	],
@@ -20,7 +20,7 @@
 		"vector": {
 			"file": "sql/vector.sql",
 			"docfile": "README.md",
-			"version": "0.7.4",
+			"version": "0.6.2",
 			"abstract": "Open-source vector similarity search for Postgres"
 		}
 	},

Makefile

@@ -1,17 +1,15 @@
 EXTENSION = vector
-EXTVERSION = 0.7.4
+EXTVERSION = 0.6.2
 
 MODULE_big = vector
-DATA = $(wildcard sql/*--*--*.sql)
+DATA = $(wildcard sql/*--*.sql)
-DATA_built = sql/$(EXTENSION)--$(EXTVERSION).sql
+OBJS = src/bitvector.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
-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 always support -march=native
@@ -43,6 +41,8 @@ all: sql/$(EXTENSION)--$(EXTVERSION).sql
 sql/$(EXTENSION)--$(EXTVERSION).sql: sql/$(EXTENSION).sql
 	cp $< $@
 
+EXTRA_CLEAN = sql/$(EXTENSION)--$(EXTVERSION).sql
+
 PG_CONFIG ?= pg_config
 PGXS := $(shell $(PG_CONFIG) --pgxs)
 include $(PGXS)
@@ -52,7 +52,7 @@ ifeq ($(PROVE),)
 	PROVE = prove
 endif
 
-# for Postgres < 15
+# for Postgres 15
 PROVE_FLAGS += -I ./test/perl
 
 prove_installcheck:
@@ -66,7 +66,7 @@ dist:
 	git archive --format zip --prefix=$(EXTENSION)-$(EXTVERSION)/ --output dist/$(EXTENSION)-$(EXTVERSION).zip master
 
 # for Docker
-PG_MAJOR ?= 17
+PG_MAJOR ?= 16
 
 .PHONY: docker
 

Makefile.win

@@ -1,11 +1,10 @@
 EXTENSION = vector
-EXTVERSION = 0.7.4
+EXTVERSION = 0.6.2
 
-DATA_built = sql\$(EXTENSION)--$(EXTVERSION).sql
+OBJS = src\bitvector.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
-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 = bit btree cast copy halfvec hnsw_bit hnsw_halfvec hnsw_sparsevec hnsw_vector ivfflat_bit ivfflat_halfvec ivfflat_vector sparsevec vector_type
+REGRESS = bit_functions btree_halfvec btree_sparsevec btree_vector cast copy halfvec_functions halfvec_input hnsw_bit_hamming hnsw_bit_jaccard hnsw_halfvec_cosine hnsw_halfvec_ip hnsw_halfvec_l2 hnsw_options hnsw_sparsevec_cosine hnsw_sparsevec_ip hnsw_sparsevec_l2 hnsw_unlogged hnsw_vector_cosine hnsw_vector_ip hnsw_vector_l2 ivfflat_halfvec_cosine ivfflat_halfvec_ip ivfflat_halfvec_l2 ivfflat_options ivfflat_unlogged ivfflat_vector_cosine ivfflat_vector_ip ivfflat_vector_l2 sparsevec_functions sparsevec_input vector_functions vector_input
 REGRESS_OPTS = --inputdir=test --load-extension=$(EXTENSION)
 
 # For /arch flags
@@ -20,6 +19,11 @@ PG_CFLAGS = $(PG_CFLAGS) $(OPTFLAGS) /O2 /fp:fast
 # https://learn.microsoft.com/en-us/cpp/error-messages/tool-errors/vectorizer-and-parallelizer-messages
 # PG_CFLAGS = $(PG_CFLAGS) /Qvec-report:2
 
+all: sql\$(EXTENSION)--$(EXTVERSION).sql
+
+sql\$(EXTENSION)--$(EXTVERSION).sql: sql\$(EXTENSION).sql
+	copy sql\$(EXTENSION).sql $@
+
 # TODO use pg_config
 !ifndef PGROOT
 !error PGROOT is not set
@@ -39,18 +43,15 @@ SHLIB = $(EXTENSION).dll
 
 LIBS = "$(LIBDIR)\postgres.lib"
 
-all: $(SHLIB) $(DATA_built)
-
 .c.obj:
 	$(CC) $(CFLAGS) /c $< /Fo$@
 
 $(SHLIB): $(OBJS)
 	$(CC) $(CFLAGS) $(OBJS) $(LIBS) /link /DLL /OUT:$(SHLIB)
 
-sql\$(EXTENSION)--$(EXTVERSION).sql: sql\$(EXTENSION).sql
+all: $(SHLIB)
-	copy sql\$(EXTENSION).sql $@
 
-install: all
+install:
 	copy $(SHLIB) "$(PKGLIBDIR)"
 	copy $(EXTENSION).control "$(SHAREDIR)\extension"
 	copy sql\$(EXTENSION)--*.sql "$(SHAREDIR)\extension"
@@ -69,6 +70,6 @@ uninstall:
 
 clean:
 	del /f $(SHLIB) $(EXTENSION).lib $(EXTENSION).exp
-	del /f $(DATA_built)
 	del /f $(OBJS)
+	del /f sql\$(EXTENSION)--$(EXTVERSION).sql
 	del /f /s /q results regression.diffs regression.out tmp_check tmp_check_iso log output_iso

README.md

@@ -5,8 +5,7 @@ Open-source vector similarity search for Postgres
 Store your vectors with the rest of your data. Supports:
 
 - exact and approximate nearest neighbor search
-- single-precision, half-precision, binary, and sparse vectors
+- L2 distance, inner product, and cosine distance
-- 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
@@ -21,7 +20,7 @@ Compile and install the extension (supports Postgres 12+)
 
 ```sh
 cd /tmp
-git clone --branch v0.7.4 https://github.com/pgvector/pgvector.git
+git clone --branch v0.6.2 https://github.com/pgvector/pgvector.git
 cd pgvector
 make
 make install # may need sudo
@@ -46,14 +45,12 @@ Then use `nmake` to build:
 ```cmd
 set "PGROOT=C:\Program Files\PostgreSQL\16"
 cd %TEMP%
-git clone --branch v0.7.4 https://github.com/pgvector/pgvector.git
+git clone --branch v0.6.2 https://github.com/pgvector/pgvector.git
 cd pgvector
 nmake /F Makefile.win
 nmake /F Makefile.win install
 ```
 
-Note: Postgres 17 is not supported yet due to an upstream issue
-
 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).
@@ -84,7 +81,7 @@ Get the nearest neighbors by L2 distance
 SELECT * FROM items ORDER BY embedding <-> '[3,1,2]' LIMIT 5;
 ```
 
-Also supports inner product (`<#>`), cosine distance (`<=>`), and L1 distance (`<+>`, added in 0.7.0)
+Also supports inner product (`<#>`) and cosine distance (`<=>`)
 
 Note: `<#>` returns the negative inner product since Postgres only supports `ASC` order index scans on operators
 
@@ -102,15 +99,13 @@ Or add a vector column to an existing table
 ALTER TABLE items ADD COLUMN embedding vector(3);
 ```
 
-Also supports [half-precision](#half-precision-vectors), [binary](#binary-vectors), and [sparse](#sparse-vectors) vectors
-
 Insert vectors
 
 ```sql
 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/loading/example.py))
+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);
@@ -148,9 +143,6 @@ Supported distance functions are:
 - `<->` - L2 distance
 - `<#>` - (negative) inner product
 - `<=>` - cosine distance
-- `<+>` - L1 distance (added in 0.7.0)
-- `<~>` - Hamming distance (binary vectors, added in 0.7.0)
-- `<%>` - Jaccard distance (binary vectors, added in 0.7.0)
 
 Get the nearest neighbors to a row
 
@@ -208,7 +200,7 @@ You can add an index to use approximate nearest neighbor search, which trades so
 
 Supported index types are:
 
-- [HNSW](#hnsw)
+- [HNSW](#hnsw) - added in 0.5.0
 - [IVFFlat](#ivfflat)
 
 ## HNSW
@@ -223,8 +215,6 @@ 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
@@ -237,19 +227,13 @@ Cosine distance
 CREATE INDEX ON items USING hnsw (embedding vector_cosine_ops);
 ```
 
-L1 distance - added in 0.7.0
+Hamming distance - unreleased
-
-```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
+Jaccard distance - unreleased
 
 ```sql
 CREATE INDEX ON items USING hnsw (embedding bit_jaccard_ops);
@@ -258,9 +242,9 @@ 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)
+- `halfvec` - up to 4,000 dimensions (unreleased)
-- `bit` - up to 64,000 dimensions (added in 0.7.0)
+- `bit` - up to 64,000 dimensions (unreleased)
-- `sparsevec` - up to 1,000 non-zero elements (added in 0.7.0)
+- `sparsevec` - up to 1,000 non-zero elements (unreleased)
 
 ### Index Options
 
@@ -353,8 +337,6 @@ L2 distance
 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
@@ -367,17 +349,11 @@ Cosine distance
 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)
+- `halfvec` - up to 4,000 dimensions (unreleased)
-- `bit` - up to 64,000 dimensions (added in 0.7.0)
+- `bit` - up to 64,000 dimensions (unreleased)
 
 ### Query Options
 
@@ -451,104 +427,21 @@ 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);
 ```
 
-## Iterative Index Scans
+## Half Vectors
 
 *Unreleased*
 
-With approximate indexes, queries with filtering can return less results (due to post-filtering). Starting with 0.8.0, you can enable iterative index scans. If too few results from the initial scan match the filters, the scan will resume until enough results are found (or it reaches `hnsw.max_scan_tuples` or `ivfflat.max_probes`). This can significantly improve recall.
-
-There are two modes for iterative scans: strict and relaxed.
-
-Strict ensures results are in the exact order by distance
-
-```sql
-SET hnsw.iterative_scan = strict_order;
-```
-
-Relaxed allows results to be slightly out of order by distance, but provides better recall
-
-```sql
-SET hnsw.iterative_scan = relaxed_order;
-# or
-SET ivfflat.iterative_scan = relaxed_order;
-```
-
-With relaxed ordering, you can use a [materialized CTE](https://www.postgresql.org/docs/current/queries-with.html#QUERIES-WITH-CTE-MATERIALIZATION) to get strict ordering
-
-```sql
-WITH relaxed_results AS MATERIALIZED (
-    SELECT id, embedding <-> '[1,2,3]' AS distance FROM items WHERE category_id = 123 ORDER BY distance LIMIT 5
-) SELECT * FROM relaxed_results ORDER BY distance;
-```
-
-For queries that filter by distance, use a materialized CTE and place the distance filter outside of it for best performance (due to the [current behavior](https://www.postgresql.org/message-id/flat/CAOdR5yGUoMQ6j7M5hNUXrySzaqZVGf_Ne%2B8fwZMRKTFxU1nbJg%40mail.gmail.com) of the Postgres executor)
-
-```sql
-WITH nearest_results AS MATERIALIZED (
-    SELECT id, embedding <-> '[1,2,3]' AS distance FROM items ORDER BY distance LIMIT 5
-) SELECT * FROM nearest_results WHERE distance < 5 ORDER BY distance;
-```
-
-Note: Place any other filters inside the CTE
-
-### Iterative Scan Options
-
-Since scanning a large portion of an approximate index is expensive, there are options to control when a scan ends
-
-#### HNSW
-
-Specify the max number of tuples to visit (20,000 by default)
-
-```sql
-SET hnsw.max_scan_tuples = 20000;
-```
-
-Note: This is approximate and does not affect the initial scan
-
-Specify the max amount of memory to use, as a multiple of `work_mem` (1 by default)
-
-```sql
-SET hnsw.scan_mem_multiplier = 2;
-```
-
-You can see when increasing this is needed by enabling debug messages
-
-```sql
-SET client_min_messages = debug1;
-```
-
-which will show when a scan reaches the memory limit
-
-```text
-DEBUG:  hnsw index scan reached memory limit after 20000 tuples
-HINT:  Increase hnsw.scan_mem_multiplier to scan more tuples.
-```
-
-#### IVFFlat
-
-Specify the max number of probes
-
-```sql
-SET ivfflat.max_probes = 100;
-```
-
-Note: If this is lower than `ivfflat.probes`, `ivfflat.probes` will be used
-
-## 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
+## Half Indexing
 
-*Added in 0.7.0*
+*Unreleased*
 
-Index vectors at half precision for smaller indexes
+Index vectors at half precision for smaller indexes and faster build times
 
 ```sql
 CREATE INDEX ON items USING hnsw ((embedding::halfvec(3)) halfvec_l2_ops);
@@ -562,30 +455,30 @@ 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/imagehash/example.py))
+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)
+Get the nearest neighbors by Hamming distance
-
-```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;
 ```
 
+Or (unreleased)
+
+```sql
+SELECT * FROM items ORDER BY embedding <~> '101' LIMIT 5;
+```
+
 Also supports Jaccard distance (`<%>`)
 
 ## Binary Quantization
 
-*Added in 0.7.0*
+*Unreleased*
 
 Use expression indexing for binary quantization
 
@@ -609,7 +502,7 @@ SELECT * FROM (
 
 ## Sparse Vectors
 
-*Added in 0.7.0*
+*Unreleased*
 
 Use the `sparsevec` type to store sparse vectors
 
@@ -640,11 +533,11 @@ SELECT id, content FROM items, plainto_tsquery('hello search') query
     WHERE textsearch @@ query ORDER BY ts_rank_cd(textsearch, query) DESC LIMIT 5;
 ```
 
-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/cross_encoder.py) to combine results.
+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
+## Subvector Indexing
 
-*Added in 0.7.0*
+*Unreleased*
 
 Use expression indexing to index subvectors
 
@@ -686,7 +579,7 @@ 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/loading/example.py)).
+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);
@@ -776,7 +669,7 @@ 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/example.py)).
+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
 
@@ -820,7 +713,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 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).
+You’ll need to use [dimensionality reduction](https://en.wikipedia.org/wiki/Dimensionality_reduction) at the moment.
 
 #### Can I store vectors with different dimensions in the same column?
 
@@ -883,7 +776,7 @@ SELECT pg_size_pretty(pg_relation_size('index_name'));
 
 #### Why isn’t a query using an index?
 
-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.
+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.
 
 ```sql
 -- index
@@ -958,23 +851,22 @@ Operator | Description | Added
 \+ | element-wise addition |
 \- | element-wise subtraction |
 \* | element-wise multiplication | 0.5.0
-\|\| | concatenate | 0.7.0
+\|\| | concatenate | unreleased
 <-> | 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
+binary_quantize(vector) → bit | binary quantize | unreleased
 cosine_distance(vector, vector) → double precision | cosine distance |
 inner_product(vector, vector) → double precision | inner product |
 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
+l2_normalize(vector) → vector | Normalize with Euclidean norm | unreleased
-subvector(vector, integer, integer) → vector | subvector | 0.7.0
+subvector(vector, integer, integer) → vector | subvector | unreleased
 vector_dims(vector) → integer | number of dimensions |
 vector_norm(vector) → double precision | Euclidean norm |
 
@@ -993,35 +885,34 @@ Each half vector takes `2 * dimensions + 8` bytes of storage. Each element is a
 
 Operator | Description | Added
 --- | --- | ---
-\+ | element-wise addition | 0.7.0
+\+ | element-wise addition | unreleased
-\- | element-wise subtraction | 0.7.0
+\- | element-wise subtraction | unreleased
-\* | element-wise multiplication | 0.7.0
+\* | element-wise multiplication | unreleased
-\|\| | concatenate | 0.7.0
+\|\| | concatenate | unreleased
-<-> | Euclidean distance | 0.7.0
+<-> | Euclidean distance | unreleased
-<#> | negative inner product | 0.7.0
+<#> | negative inner product | unreleased
-<=> | cosine distance | 0.7.0
+<=> | cosine distance | unreleased
-<+> | taxicab distance | 0.7.0
 
 ### Halfvec Functions
 
 Function | Description | Added
 --- | --- | ---
-binary_quantize(halfvec) → bit | binary quantize | 0.7.0
+binary_quantize(halfvec) → bit | binary quantize | unreleased
-cosine_distance(halfvec, halfvec) → double precision | cosine distance | 0.7.0
+cosine_distance(halfvec, halfvec) → double precision | cosine distance | unreleased
-inner_product(halfvec, halfvec) → double precision | inner product | 0.7.0
+inner_product(halfvec, halfvec) → double precision | inner product | unreleased
-l1_distance(halfvec, halfvec) → double precision | taxicab distance | 0.7.0
+l1_distance(halfvec, halfvec) → double precision | taxicab distance | unreleased
-l2_distance(halfvec, halfvec) → double precision | Euclidean distance | 0.7.0
+l2_distance(halfvec, halfvec) → double precision | Euclidean distance | unreleased
-l2_norm(halfvec) → double precision | Euclidean norm | 0.7.0
+l2_norm(halfvec) → double precision | Euclidean norm | unreleased
-l2_normalize(halfvec) → halfvec | Normalize with Euclidean norm | 0.7.0
+l2_normalize(halfvec) → halfvec | Normalize with Euclidean norm | unreleased
-subvector(halfvec, integer, integer) → halfvec | subvector | 0.7.0
+subvector(halfvec, integer, integer) → halfvec | subvector | unreleased
-vector_dims(halfvec) → integer | number of dimensions | 0.7.0
+vector_dims(halfvec) → integer | number of dimensions | unreleased
 
 ### Halfvec Aggregate Functions
 
 Function | Description | Added
 --- | --- | ---
-avg(halfvec) → halfvec | average | 0.7.0
+avg(halfvec) → halfvec | average | unreleased
-sum(halfvec) → halfvec | sum | 0.7.0
+sum(halfvec) → halfvec | sum | unreleased
 
 ### Bit Type
 
@@ -1031,15 +922,15 @@ Each bit vector takes `dimensions / 8 + 8` bytes of storage. See the [Postgres d
 
 Operator | Description | Added
 --- | --- | ---
-<~> | Hamming distance | 0.7.0
+<~> | Hamming distance | unreleased
-<%> | Jaccard distance | 0.7.0
+<%> | Jaccard distance | unreleased
 
 ### Bit Functions
 
 Function | Description | Added
 --- | --- | ---
-hamming_distance(bit, bit) → double precision | Hamming distance | 0.7.0
+hamming_distance(bit, bit) → double precision | Hamming distance | unreleased
-jaccard_distance(bit, bit) → double precision | Jaccard distance | 0.7.0
+jaccard_distance(bit, bit) → double precision | Jaccard distance | unreleased
 
 ### Sparsevec Type
 
@@ -1049,21 +940,20 @@ Each sparse vector takes `8 * non-zero elements + 16` bytes of storage. Each ele
 
 Operator | Description | Added
 --- | --- | ---
-<-> | Euclidean distance | 0.7.0
+<-> | Euclidean distance | unreleased
-<#> | negative inner product | 0.7.0
+<#> | negative inner product | unreleased
-<=> | cosine distance | 0.7.0
+<=> | cosine distance | unreleased
-<+> | taxicab distance | 0.7.0
 
 ### Sparsevec Functions
 
 Function | Description | Added
 --- | --- | ---
-cosine_distance(sparsevec, sparsevec) → double precision | cosine distance | 0.7.0
+cosine_distance(sparsevec, sparsevec) → double precision | cosine distance | unreleased
-inner_product(sparsevec, sparsevec) → double precision | inner product | 0.7.0
+inner_product(sparsevec, sparsevec) → double precision | inner product | unreleased
-l1_distance(sparsevec, sparsevec) → double precision | taxicab distance | 0.7.0
+l1_distance(sparsevec, sparsevec) → double precision | taxicab distance | unreleased
-l2_distance(sparsevec, sparsevec) → double precision | Euclidean distance | 0.7.0
+l2_distance(sparsevec, sparsevec) → double precision | Euclidean distance | unreleased
-l2_norm(sparsevec) → double precision | Euclidean norm | 0.7.0
+l2_norm(sparsevec) → double precision | Euclidean norm | unreleased
-l2_normalize(sparsevec) → sparsevec | Normalize with Euclidean norm | 0.7.0
+l2_normalize(sparsevec) → sparsevec | Normalize with Euclidean norm | unreleased
 
 ## Installation Notes - Linux and Mac
 
@@ -1072,7 +962,7 @@ l2_normalize(sparsevec) → sparsevec | Normalize with Euclidean norm | 0.7.0
 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=/Library/PostgreSQL/17/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:
@@ -1083,11 +973,11 @@ sudo --preserve-env=PG_CONFIG make install
 
 A few common paths on Mac are:
 
-- EDB installer - `/Library/PostgreSQL/17/bin/pg_config`
+- EDB installer - `/Library/PostgreSQL/16/bin/pg_config`
-- Homebrew (arm64) - `/opt/homebrew/opt/postgresql@17/bin/pg_config`
+- Homebrew (arm64) - `/opt/homebrew/opt/postgresql@16/bin/pg_config`
-- Homebrew (x86-64) - `/usr/local/opt/postgresql@17/bin/pg_config`
+- Homebrew (x86-64) - `/usr/local/opt/postgresql@16/bin/pg_config`
 
-Note: Replace `17` with your Postgres server version
+Note: Replace `16` with your Postgres server version
 
 ### Missing Header
 
@@ -1096,10 +986,10 @@ 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-17
+sudo apt install postgresql-server-dev-16
 ```
 
-Note: Replace `17` with your Postgres server version
+Note: Replace `16` with your Postgres server version
 
 ### Missing SDK
 
@@ -1132,17 +1022,17 @@ If installation fails with `Access is denied`, re-run the installation instructi
 Get the [Docker image](https://hub.docker.com/r/pgvector/pgvector) with:
 
 ```sh
-docker pull pgvector/pgvector:pg17
+docker pull pgvector/pgvector:pg16
 ```
 
-This adds pgvector to the [Postgres image](https://hub.docker.com/_/postgres) (replace `17` with your Postgres server version, and 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.7.4 https://github.com/pgvector/pgvector.git
+git clone --branch v0.6.2 https://github.com/pgvector/pgvector.git
 cd pgvector
-docker build --pull --build-arg PG_MAJOR=17 -t myuser/pgvector .
+docker build --build-arg PG_MAJOR=16 -t myuser/pgvector .
 ```
 
 ### Homebrew
@@ -1153,7 +1043,7 @@ With Homebrew Postgres, you can use:
 brew install pgvector
 ```
 
-Note: This only adds it to the `postgresql@17` and `postgresql@14` formulas
+Note: This only adds it to the `postgresql@14` formula
 
 ### PGXN
 
@@ -1168,22 +1058,22 @@ 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-17-pgvector
+sudo apt install postgresql-16-pgvector
 ```
 
-Note: Replace `17` 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_17
+sudo yum install pgvector_16
 # or
-sudo dnf install pgvector_17
+sudo dnf install pgvector_16
 ```
 
-Note: Replace `17` with your Postgres server version
+Note: Replace `16` with your Postgres server version
 
 ### pkg
 

sql/vector--0.6.2--0.7.0.sql

@@ -13,34 +13,47 @@ CREATE FUNCTION subvector(vector, int, int) RETURNS vector
 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
+CREATE FUNCTION hamming_distance(bit, bit) RETURNS float8
-	AS 'MODULE_PATHNAME' LANGUAGE C;
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
 
-CREATE FUNCTION ivfflat_bit_support(internal) RETURNS internal
+CREATE FUNCTION jaccard_distance(bit, bit) RETURNS float8
-	AS 'MODULE_PATHNAME' LANGUAGE C;
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
 
-CREATE FUNCTION hnsw_halfvec_support(internal) RETURNS internal
+CREATE OPERATOR <~> (
-	AS 'MODULE_PATHNAME' LANGUAGE C;
+	LEFTARG = bit, RIGHTARG = bit, PROCEDURE = hamming_distance,
+	COMMUTATOR = '<~>'
+);
 
-CREATE FUNCTION hnsw_bit_support(internal) RETURNS internal
+CREATE OPERATOR <%> (
-	AS 'MODULE_PATHNAME' LANGUAGE C;
+	LEFTARG = bit, RIGHTARG = bit, PROCEDURE = jaccard_distance,
+	COMMUTATOR = '<%>'
+);
 
-CREATE FUNCTION hnsw_sparsevec_support(internal) RETURNS internal
+CREATE OPERATOR CLASS bit_hamming_ops
-	AS 'MODULE_PATHNAME' LANGUAGE C;
+	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);
 
-CREATE OPERATOR CLASS vector_l1_ops
+CREATE OPERATOR CLASS bit_jaccard_ops
-	FOR TYPE vector USING hnsw AS
+	FOR TYPE bit USING ivfflat AS
-	OPERATOR 1 <+> (vector, vector) FOR ORDER BY float_ops,
+	OPERATOR 1 <%> (bit, bit) FOR ORDER BY float_ops,
-	FUNCTION 1 l1_distance(vector, vector);
+	FUNCTION 1 jaccard_distance(bit, bit),
+	FUNCTION 3 jaccard_distance(bit, bit);
+
+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);
+
+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);
 
 CREATE TYPE halfvec;
 
@@ -143,14 +156,11 @@ CREATE FUNCTION halfvec_accum(double precision[], halfvec) RETURNS double precis
 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,
+	COMBINEFUNC = vector_combine,
 	INITCOND = '{0}',
 	PARALLEL = SAFE
 );
@@ -225,11 +235,6 @@ CREATE OPERATOR <=> (
 	COMMUTATOR = '<=>'
 );
 
-CREATE OPERATOR <+> (
-	LEFTARG = halfvec, RIGHTARG = halfvec, PROCEDURE = l1_distance,
-	COMMUTATOR = '<+>'
-);
-
 CREATE OPERATOR + (
 	LEFTARG = halfvec, RIGHTARG = halfvec, PROCEDURE = halfvec_add,
 	COMMUTATOR = +
@@ -297,16 +302,14 @@ 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 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 4 l2_norm(halfvec);
-	FUNCTION 5 ivfflat_halfvec_support(internal);
 
 CREATE OPERATOR CLASS halfvec_cosine_ops
 	FOR TYPE halfvec USING ivfflat AS
@@ -314,68 +317,23 @@ CREATE OPERATOR CLASS halfvec_cosine_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 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 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 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 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;
 
@@ -457,12 +415,6 @@ CREATE FUNCTION vector_to_sparsevec(vector, integer, boolean) RETURNS sparsevec
 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;
 
@@ -472,12 +424,6 @@ CREATE CAST (sparsevec AS vector)
 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 = '<->'
@@ -493,11 +439,6 @@ CREATE OPERATOR <=> (
 	COMMUTATOR = '<=>'
 );
 
-CREATE OPERATOR <+> (
-	LEFTARG = sparsevec, RIGHTARG = sparsevec, PROCEDURE = l1_distance,
-	COMMUTATOR = '<+>'
-);
-
 CREATE OPERATOR < (
 	LEFTARG = sparsevec, RIGHTARG = sparsevec, PROCEDURE = sparsevec_lt,
 	COMMUTATOR = > , NEGATOR = >= ,
@@ -546,24 +487,15 @@ CREATE OPERATOR CLASS sparsevec_ops
 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 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 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 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

@@ -1,2 +0,0 @@
--- 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

@@ -1,2 +0,0 @@
--- 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

@@ -1,2 +0,0 @@
--- 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--0.7.3--0.7.4.sql

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

sql/vector--0.7.4--0.8.0.sql

@@ -1,26 +0,0 @@
--- complain if script is sourced in psql, rather than via CREATE EXTENSION
-\echo Use "ALTER EXTENSION vector UPDATE TO '0.8.0'" to load this file. \quit
-
-CREATE FUNCTION array_to_sparsevec(integer[], integer, boolean) RETURNS sparsevec
-	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-
-CREATE FUNCTION array_to_sparsevec(real[], integer, boolean) RETURNS sparsevec
-	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-
-CREATE FUNCTION array_to_sparsevec(double precision[], integer, boolean) RETURNS sparsevec
-	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-
-CREATE FUNCTION array_to_sparsevec(numeric[], integer, boolean) RETURNS sparsevec
-	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-
-CREATE CAST (integer[] AS sparsevec)
-	WITH FUNCTION array_to_sparsevec(integer[], integer, boolean) AS ASSIGNMENT;
-
-CREATE CAST (real[] AS sparsevec)
-	WITH FUNCTION array_to_sparsevec(real[], integer, boolean) AS ASSIGNMENT;
-
-CREATE CAST (double precision[] AS sparsevec)
-	WITH FUNCTION array_to_sparsevec(double precision[], integer, boolean) AS ASSIGNMENT;
-
-CREATE CAST (numeric[] AS sparsevec)
-	WITH FUNCTION array_to_sparsevec(numeric[], integer, boolean) AS ASSIGNMENT;

sql/vector.sql

@@ -186,11 +186,6 @@ CREATE OPERATOR <=> (
 	COMMUTATOR = '<=>'
 );
 
-CREATE OPERATOR <+> (
-	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = l1_distance,
-	COMMUTATOR = '<+>'
-);
-
 CREATE OPERATOR + (
 	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = vector_add,
 	COMMUTATOR = +
@@ -261,23 +256,6 @@ CREATE ACCESS METHOD hnsw TYPE INDEX HANDLER hnswhandler;
 
 COMMENT ON ACCESS METHOD hnsw IS 'hnsw index access method';
 
--- 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
@@ -326,10 +304,49 @@ CREATE OPERATOR CLASS vector_cosine_ops
 	FUNCTION 1 vector_negative_inner_product(vector, vector),
 	FUNCTION 2 vector_norm(vector);
 
-CREATE OPERATOR CLASS vector_l1_ops
+-- bit functions
-	FOR TYPE vector USING hnsw AS
+
-	OPERATOR 1 <+> (vector, vector) FOR ORDER BY float_ops,
+CREATE FUNCTION hamming_distance(bit, bit) RETURNS float8
-	FUNCTION 1 l1_distance(vector, vector);
+	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);
+
+CREATE OPERATOR CLASS bit_jaccard_ops
+	FOR TYPE bit USING ivfflat AS
+	OPERATOR 1 <%> (bit, bit) FOR ORDER BY float_ops,
+	FUNCTION 1 jaccard_distance(bit, bit),
+	FUNCTION 3 jaccard_distance(bit, bit);
+
+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);
+
+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);
 
 -- halfvec type
 
@@ -438,16 +455,13 @@ CREATE FUNCTION halfvec_accum(double precision[], halfvec) RETURNS double precis
 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,
+	COMBINEFUNC = vector_combine,
 	INITCOND = '{0}',
 	PARALLEL = SAFE
 );
@@ -528,11 +542,6 @@ CREATE OPERATOR <=> (
 	COMMUTATOR = '<=>'
 );
 
-CREATE OPERATOR <+> (
-	LEFTARG = halfvec, RIGHTARG = halfvec, PROCEDURE = l1_distance,
-	COMMUTATOR = '<+>'
-);
-
 CREATE OPERATOR + (
 	LEFTARG = halfvec, RIGHTARG = halfvec, PROCEDURE = halfvec_add,
 	COMMUTATOR = +
@@ -602,16 +611,14 @@ 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 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 4 l2_norm(halfvec);
-	FUNCTION 5 ivfflat_halfvec_support(internal);
 
 CREATE OPERATOR CLASS halfvec_cosine_ops
 	FOR TYPE halfvec USING ivfflat AS
@@ -619,74 +626,23 @@ CREATE OPERATOR CLASS halfvec_cosine_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 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 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 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 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
 
@@ -776,24 +732,6 @@ CREATE FUNCTION vector_to_sparsevec(vector, integer, boolean) RETURNS sparsevec
 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 FUNCTION array_to_sparsevec(integer[], integer, boolean) RETURNS sparsevec
-	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-
-CREATE FUNCTION array_to_sparsevec(real[], integer, boolean) RETURNS sparsevec
-	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-
-CREATE FUNCTION array_to_sparsevec(double precision[], integer, boolean) RETURNS sparsevec
-	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-
-CREATE FUNCTION array_to_sparsevec(numeric[], integer, boolean) RETURNS sparsevec
-	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-
 -- sparsevec casts
 
 CREATE CAST (sparsevec AS sparsevec)
@@ -805,24 +743,6 @@ CREATE CAST (sparsevec AS vector)
 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 CAST (integer[] AS sparsevec)
-	WITH FUNCTION array_to_sparsevec(integer[], integer, boolean) AS ASSIGNMENT;
-
-CREATE CAST (real[] AS sparsevec)
-	WITH FUNCTION array_to_sparsevec(real[], integer, boolean) AS ASSIGNMENT;
-
-CREATE CAST (double precision[] AS sparsevec)
-	WITH FUNCTION array_to_sparsevec(double precision[], integer, boolean) AS ASSIGNMENT;
-
-CREATE CAST (numeric[] AS sparsevec)
-	WITH FUNCTION array_to_sparsevec(numeric[], integer, boolean) AS ASSIGNMENT;
-
 -- sparsevec operators
 
 CREATE OPERATOR <-> (
@@ -840,11 +760,6 @@ CREATE OPERATOR <=> (
 	COMMUTATOR = '<=>'
 );
 
-CREATE OPERATOR <+> (
-	LEFTARG = sparsevec, RIGHTARG = sparsevec, PROCEDURE = l1_distance,
-	COMMUTATOR = '<+>'
-);
-
 CREATE OPERATOR < (
 	LEFTARG = sparsevec, RIGHTARG = sparsevec, PROCEDURE = sparsevec_lt,
 	COMMUTATOR = > , NEGATOR = >= ,
@@ -895,24 +810,15 @@ CREATE OPERATOR CLASS sparsevec_ops
 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 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 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 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

@@ -1,222 +0,0 @@
-#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

@@ -1,16 +0,0 @@
-#ifndef BITUTILS_H
-#define BITUTILS_H
-
-#include "postgres.h"
-
-/* Check version in first header */
-#if PG_VERSION_NUM < 130000
-#error "Requires PostgreSQL 13+"
-#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/bitvector.c

@@ -1,9 +1,8 @@
 #include "postgres.h"
 
-#include "bitutils.h"
+#include "bitvector.h"
-#include "bitvec.h"
+#include "port/pg_bitutils.h"
 #include "utils/varbit.h"
-#include "vector.h"
 
 #if PG_VERSION_NUM >= 160000
 #include "varatt.h"
@@ -41,29 +40,51 @@ CheckDims(VarBit *a, VarBit *b)
 /*
  * Get the Hamming distance between two bit vectors
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(hamming_distance);
+PGDLLEXPORT 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);
+	unsigned char *ax = VARBITS(a);
+	unsigned char *bx = VARBITS(b);
+	uint64		distance = 0;
 
 	CheckDims(a, b);
 
-	PG_RETURN_FLOAT8((double) BitHammingDistance(VARBITBYTES(a), VARBITS(a), VARBITS(b), 0));
+	/* TODO Improve performance */
+	for (uint32 i = 0; i < VARBITBYTES(a); i++)
+		distance += pg_number_of_ones[ax[i] ^ bx[i]];
+
+	PG_RETURN_FLOAT8((double) distance);
 }
 
 /*
  * Get the Jaccard distance between two bit vectors
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(jaccard_distance);
+PGDLLEXPORT 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);
+	unsigned char *ax = VARBITS(a);
+	unsigned char *bx = VARBITS(b);
+	uint64		ab = 0;
+	uint64		aa;
+	uint64		bb;
 
 	CheckDims(a, b);
 
-	PG_RETURN_FLOAT8(BitJaccardDistance(VARBITBYTES(a), VARBITS(a), VARBITS(b), 0, 0, 0));
+	/* TODO Improve performance */
+	for (uint32 i = 0; i < VARBITBYTES(a); i++)
+		ab += pg_number_of_ones[ax[i] & bx[i]];
+
+	if (ab == 0)
+		PG_RETURN_FLOAT8(1);
+
+	aa = pg_popcount((char *) ax, VARBITBYTES(a));
+	bb = pg_popcount((char *) bx, VARBITBYTES(b));
+
+	PG_RETURN_FLOAT8(1 - (ab / ((double) (aa + bb - ab))));
 }

src/bitvector.h

@@ -1,5 +1,5 @@
-#ifndef BITVEC_H
+#ifndef BITVECTOR_H
-#define BITVEC_H
+#define BITVECTOR_H
 
 #include "utils/varbit.h"
 

src/halfutils.c

@@ -6,23 +6,23 @@
 #ifdef HALFVEC_DISPATCH
 #include <immintrin.h>
 
-#if defined(USE__GET_CPUID)
+#if defined(HAVE__GET_CPUID)
 #include <cpuid.h>
-#else
+#elif defined(HAVE__CPUID)
 #include <intrin.h>
 #endif
 
 #ifdef _MSC_VER
-#define TARGET_F16C
+#define TARGET_F16C_FMA
 #else
-#define TARGET_F16C __attribute__((target("avx,f16c,fma")))
+#define TARGET_F16C_FMA __attribute__((target("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)
@@ -41,8 +41,8 @@ HalfvecL2SquaredDistanceDefault(int dim, half * ax, half * bx)
 }
 
 #ifdef HALFVEC_DISPATCH
-TARGET_F16C static float
+TARGET_F16C_FMA static float
-HalfvecL2SquaredDistanceF16c(int dim, half * ax, half * bx)
+HalfvecL2SquaredDistanceF16cFma(int dim, half * ax, half * bx)
 {
 	float		distance;
 	int			i;
@@ -89,8 +89,8 @@ HalfvecInnerProductDefault(int dim, half * ax, half * bx)
 }
 
 #ifdef HALFVEC_DISPATCH
-TARGET_F16C static float
+TARGET_F16C_FMA static float
-HalfvecInnerProductF16c(int dim, half * ax, half * bx)
+HalfvecInnerProductF16cFma(int dim, half * ax, half * bx)
 {
 	float		distance;
 	int			i;
@@ -142,8 +142,8 @@ HalfvecCosineSimilarityDefault(int dim, half * ax, half * bx)
 }
 
 #ifdef HALFVEC_DISPATCH
-TARGET_F16C static double
+TARGET_F16C_FMA static double
-HalfvecCosineSimilarityF16c(int dim, half * ax, half * bx)
+HalfvecCosineSimilarityF16cFma(int dim, half * ax, half * bx)
 {
 	float		similarity;
 	float		norma;
@@ -192,51 +192,6 @@ HalfvecCosineSimilarityF16c(int dim, half * ax, half * bx)
 }
 #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)
@@ -254,21 +209,18 @@ SupportsCpuFeature(unsigned int feature)
 {
 	unsigned int exx[4] = {0, 0, 0, 0};
 
-#if defined(USE__GET_CPUID)
+#if defined(HAVE__GET_CPUID)
 	__get_cpuid(1, &exx[0], &exx[1], &exx[2], &exx[3]);
-#else
+#elif defined(HAVE__CPUID)
 	__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
@@ -283,16 +235,13 @@ HalfvecInit(void)
 	HalfvecL2SquaredDistance = HalfvecL2SquaredDistanceDefault;
 	HalfvecInnerProduct = HalfvecInnerProductDefault;
 	HalfvecCosineSimilarity = HalfvecCosineSimilarityDefault;
-	HalfvecL1Distance = HalfvecL1DistanceDefault;
 
 #ifdef HALFVEC_DISPATCH
-	if (SupportsCpuFeature(CPU_FEATURE_AVX | CPU_FEATURE_F16C | CPU_FEATURE_FMA))
+	if (SupportsCpuFeature(CPU_FEATURE_AVX | CPU_FEATURE_FMA | CPU_FEATURE_F16C))
 	{
-		HalfvecL2SquaredDistance = HalfvecL2SquaredDistanceF16c;
+		HalfvecL2SquaredDistance = HalfvecL2SquaredDistanceF16cFma;
-		HalfvecInnerProduct = HalfvecInnerProductF16c;
+		HalfvecInnerProduct = HalfvecInnerProductF16cFma;
-		HalfvecCosineSimilarity = HalfvecCosineSimilarityF16c;
+		HalfvecCosineSimilarity = HalfvecCosineSimilarityF16cFma;
-		/* Does not require FMA, but keep logic simple */
-		HalfvecL1Distance = HalfvecL1DistanceF16c;
 	}
 #endif
 }

src/halfutils.h

@@ -13,7 +13,6 @@
 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);
 
@@ -67,6 +66,9 @@ HalfToFloat4(half num)
 #elif defined(FLT16_SUPPORT)
 	return (float) num;
 #else
+	/* TODO Improve performance */
+
+	/* Assumes same endianness for floats and integers */
 	union
 	{
 		float		f;
@@ -151,6 +153,9 @@ Float4ToHalfUnchecked(float num)
 #elif defined(FLT16_SUPPORT)
 	return (_Float16) num;
 #else
+	/* TODO Improve performance */
+
+	/* Assumes same endianness for floats and integers */
 	union
 	{
 		float		f;

src/halfvec.c

@@ -2,7 +2,7 @@
 
 #include <math.h>
 
-#include "bitvec.h"
+#include "bitvector.h"
 #include "catalog/pg_type.h"
 #include "common/shortest_dec.h"
 #include "fmgr.h"
@@ -11,7 +11,6 @@
 #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"
@@ -19,6 +18,11 @@
 #include "utils/numeric.h"
 #include "vector.h"
 
+#if PG_VERSION_NUM < 130000
+#define TYPALIGN_DOUBLE 'd'
+#define TYPALIGN_INT 'i'
+#endif
+
 #define STATE_DIMS(x) (ARR_DIMS(x)[0] - 1)
 #define CreateStateDatums(dim) palloc(sizeof(Datum) * (dim + 1))
 
@@ -159,10 +163,28 @@ CheckStateArray(ArrayType *statearray, const char *caller)
 	return (float8 *) ARR_DATA_PTR(statearray);
 }
 
+#if PG_VERSION_NUM < 120003
+static pg_noinline void
+float_overflow_error(void)
+{
+	ereport(ERROR,
+			(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
+			 errmsg("value out of range: overflow")));
+}
+
+static pg_noinline void
+float_underflow_error(void)
+{
+	ereport(ERROR,
+			(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
+			 errmsg("value out of range: underflow")));
+}
+#endif
+
 /*
  * Convert textual representation to internal representation
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(halfvec_in);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(halfvec_in);
 Datum
 halfvec_in(PG_FUNCTION_ARGS)
 {
@@ -276,7 +298,7 @@ halfvec_in(PG_FUNCTION_ARGS)
 /*
  * Convert internal representation to textual representation
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(halfvec_out);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(halfvec_out);
 Datum
 halfvec_out(PG_FUNCTION_ARGS)
 {
@@ -305,10 +327,6 @@ halfvec_out(PG_FUNCTION_ARGS)
 		if (i > 0)
 			AppendChar(ptr, ',');
 
-		/*
-		 * Use shortest decimal representation of single-precision float for
-		 * simplicity
-		 */
 		AppendFloat(ptr, HalfToFloat4(vector->x[i]));
 	}
 
@@ -322,7 +340,7 @@ halfvec_out(PG_FUNCTION_ARGS)
 /*
  * Convert type modifier
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(halfvec_typmod_in);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(halfvec_typmod_in);
 Datum
 halfvec_typmod_in(PG_FUNCTION_ARGS)
 {
@@ -353,7 +371,7 @@ halfvec_typmod_in(PG_FUNCTION_ARGS)
 /*
  * Convert external binary representation to internal representation
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(halfvec_recv);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(halfvec_recv);
 Datum
 halfvec_recv(PG_FUNCTION_ARGS)
 {
@@ -387,7 +405,7 @@ halfvec_recv(PG_FUNCTION_ARGS)
 /*
  * Convert internal representation to the external binary representation
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(halfvec_send);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(halfvec_send);
 Datum
 halfvec_send(PG_FUNCTION_ARGS)
 {
@@ -407,7 +425,7 @@ halfvec_send(PG_FUNCTION_ARGS)
  * Convert half vector to half vector
  * This is needed to check the type modifier
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(halfvec);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(halfvec);
 Datum
 halfvec(PG_FUNCTION_ARGS)
 {
@@ -422,7 +440,7 @@ halfvec(PG_FUNCTION_ARGS)
 /*
  * Convert array to half vector
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(array_to_halfvec);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(array_to_halfvec);
 Datum
 array_to_halfvec(PG_FUNCTION_ARGS)
 {
@@ -496,7 +514,7 @@ array_to_halfvec(PG_FUNCTION_ARGS)
 /*
  * Convert half vector to float4[]
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(halfvec_to_float4);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(halfvec_to_float4);
 Datum
 halfvec_to_float4(PG_FUNCTION_ARGS)
 {
@@ -520,7 +538,7 @@ halfvec_to_float4(PG_FUNCTION_ARGS)
 /*
  * Convert vector to half vec
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(vector_to_halfvec);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(vector_to_halfvec);
 Datum
 vector_to_halfvec(PG_FUNCTION_ARGS)
 {
@@ -542,7 +560,7 @@ vector_to_halfvec(PG_FUNCTION_ARGS)
 /*
  * Get the L2 distance between half vectors
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(halfvec_l2_distance);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(halfvec_l2_distance);
 Datum
 halfvec_l2_distance(PG_FUNCTION_ARGS)
 {
@@ -557,7 +575,7 @@ halfvec_l2_distance(PG_FUNCTION_ARGS)
 /*
  * Get the L2 squared distance between half vectors
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(halfvec_l2_squared_distance);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(halfvec_l2_squared_distance);
 Datum
 halfvec_l2_squared_distance(PG_FUNCTION_ARGS)
 {
@@ -572,7 +590,7 @@ halfvec_l2_squared_distance(PG_FUNCTION_ARGS)
 /*
  * Get the inner product of two half vectors
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(halfvec_inner_product);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(halfvec_inner_product);
 Datum
 halfvec_inner_product(PG_FUNCTION_ARGS)
 {
@@ -587,7 +605,7 @@ halfvec_inner_product(PG_FUNCTION_ARGS)
 /*
  * Get the negative inner product of two half vectors
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(halfvec_negative_inner_product);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(halfvec_negative_inner_product);
 Datum
 halfvec_negative_inner_product(PG_FUNCTION_ARGS)
 {
@@ -602,7 +620,7 @@ halfvec_negative_inner_product(PG_FUNCTION_ARGS)
 /*
  * Get the cosine distance between two half vectors
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(halfvec_cosine_distance);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(halfvec_cosine_distance);
 Datum
 halfvec_cosine_distance(PG_FUNCTION_ARGS)
 {
@@ -634,7 +652,7 @@ halfvec_cosine_distance(PG_FUNCTION_ARGS)
  * Currently uses angular distance since needs to satisfy triangle inequality
  * Assumes inputs are unit vectors (skips norm)
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(halfvec_spherical_distance);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(halfvec_spherical_distance);
 Datum
 halfvec_spherical_distance(PG_FUNCTION_ARGS)
 {
@@ -658,22 +676,29 @@ halfvec_spherical_distance(PG_FUNCTION_ARGS)
 /*
  * Get the L1 distance between two half vectors
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(halfvec_l1_distance);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(halfvec_l1_distance);
 Datum
 halfvec_l1_distance(PG_FUNCTION_ARGS)
 {
 	HalfVector *a = PG_GETARG_HALFVEC_P(0);
 	HalfVector *b = PG_GETARG_HALFVEC_P(1);
+	half	   *ax = a->x;
+	half	   *bx = b->x;
+	float		distance = 0.0;
 
 	CheckDims(a, b);
 
-	PG_RETURN_FLOAT8((double) HalfvecL1Distance(a->dim, a->x, b->x));
+	/* Auto-vectorized */
+	for (int i = 0; i < a->dim; i++)
+		distance += fabsf(HalfToFloat4(ax[i]) - HalfToFloat4(bx[i]));
+
+	PG_RETURN_FLOAT8((double) distance);
 }
 
 /*
  * Get the dimensions of a half vector
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(halfvec_vector_dims);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(halfvec_vector_dims);
 Datum
 halfvec_vector_dims(PG_FUNCTION_ARGS)
 {
@@ -685,7 +710,7 @@ halfvec_vector_dims(PG_FUNCTION_ARGS)
 /*
  * Get the L2 norm of a half vector
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(halfvec_l2_norm);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(halfvec_l2_norm);
 Datum
 halfvec_l2_norm(PG_FUNCTION_ARGS)
 {
@@ -707,7 +732,7 @@ halfvec_l2_norm(PG_FUNCTION_ARGS)
 /*
  * Normalize a half vector with the L2 norm
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(halfvec_l2_normalize);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(halfvec_l2_normalize);
 Datum
 halfvec_l2_normalize(PG_FUNCTION_ARGS)
 {
@@ -746,7 +771,7 @@ halfvec_l2_normalize(PG_FUNCTION_ARGS)
 /*
  * Add half vectors
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(halfvec_add);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(halfvec_add);
 Datum
 halfvec_add(PG_FUNCTION_ARGS)
 {
@@ -785,7 +810,7 @@ halfvec_add(PG_FUNCTION_ARGS)
 /*
  * Subtract half vectors
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(halfvec_sub);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(halfvec_sub);
 Datum
 halfvec_sub(PG_FUNCTION_ARGS)
 {
@@ -824,7 +849,7 @@ halfvec_sub(PG_FUNCTION_ARGS)
 /*
  * Multiply half vectors
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(halfvec_mul);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(halfvec_mul);
 Datum
 halfvec_mul(PG_FUNCTION_ARGS)
 {
@@ -866,7 +891,7 @@ halfvec_mul(PG_FUNCTION_ARGS)
 /*
  * Concatenate half vectors
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(halfvec_concat);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(halfvec_concat);
 Datum
 halfvec_concat(PG_FUNCTION_ARGS)
 {
@@ -890,7 +915,7 @@ halfvec_concat(PG_FUNCTION_ARGS)
 /*
  * Quantize a half vector
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(halfvec_binary_quantize);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(halfvec_binary_quantize);
 Datum
 halfvec_binary_quantize(PG_FUNCTION_ARGS)
 {
@@ -908,39 +933,24 @@ halfvec_binary_quantize(PG_FUNCTION_ARGS)
 /*
  * Get a subvector
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(halfvec_subvector);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(halfvec_subvector);
 Datum
 halfvec_subvector(PG_FUNCTION_ARGS)
 {
 	HalfVector *a = PG_GETARG_HALFVEC_P(0);
 	int32		start = PG_GETARG_INT32(1);
 	int32		count = PG_GETARG_INT32(2);
-	int32		end;
+	int32		end = start + count;
 	half	   *ax = a->x;
 	HalfVector *result;
-	int32		dim;
+	int			dim;
-
-	if (count < 1)
-		ereport(ERROR,
-				(errcode(ERRCODE_DATA_EXCEPTION),
-				 errmsg("halfvec 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,
+	if (end > a->dim)
-				(errcode(ERRCODE_DATA_EXCEPTION),
+		end = a->dim + 1;
-				 errmsg("halfvec must have at least 1 dimension")));
 
 	dim = end - start;
 	CheckDim(dim);
@@ -955,7 +965,7 @@ halfvec_subvector(PG_FUNCTION_ARGS)
 /*
  * Internal helper to compare half vectors
  */
-static int
+int
 halfvec_cmp_internal(HalfVector * a, HalfVector * b)
 {
 	int			dim = Min(a->dim, b->dim);
@@ -982,7 +992,7 @@ halfvec_cmp_internal(HalfVector * a, HalfVector * b)
 /*
  * Less than
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(halfvec_lt);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(halfvec_lt);
 Datum
 halfvec_lt(PG_FUNCTION_ARGS)
 {
@@ -995,7 +1005,7 @@ halfvec_lt(PG_FUNCTION_ARGS)
 /*
  * Less than or equal
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(halfvec_le);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(halfvec_le);
 Datum
 halfvec_le(PG_FUNCTION_ARGS)
 {
@@ -1008,7 +1018,7 @@ halfvec_le(PG_FUNCTION_ARGS)
 /*
  * Equal
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(halfvec_eq);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(halfvec_eq);
 Datum
 halfvec_eq(PG_FUNCTION_ARGS)
 {
@@ -1021,7 +1031,7 @@ halfvec_eq(PG_FUNCTION_ARGS)
 /*
  * Not equal
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(halfvec_ne);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(halfvec_ne);
 Datum
 halfvec_ne(PG_FUNCTION_ARGS)
 {
@@ -1034,7 +1044,7 @@ halfvec_ne(PG_FUNCTION_ARGS)
 /*
  * Greater than or equal
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(halfvec_ge);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(halfvec_ge);
 Datum
 halfvec_ge(PG_FUNCTION_ARGS)
 {
@@ -1047,7 +1057,7 @@ halfvec_ge(PG_FUNCTION_ARGS)
 /*
  * Greater than
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(halfvec_gt);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(halfvec_gt);
 Datum
 halfvec_gt(PG_FUNCTION_ARGS)
 {
@@ -1060,7 +1070,7 @@ halfvec_gt(PG_FUNCTION_ARGS)
 /*
  * Compare half vectors
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(halfvec_cmp);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(halfvec_cmp);
 Datum
 halfvec_cmp(PG_FUNCTION_ARGS)
 {
@@ -1073,7 +1083,7 @@ halfvec_cmp(PG_FUNCTION_ARGS)
 /*
  * Accumulate half vectors
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(halfvec_accum);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(halfvec_accum);
 Datum
 halfvec_accum(PG_FUNCTION_ARGS)
 {
@@ -1134,7 +1144,7 @@ halfvec_accum(PG_FUNCTION_ARGS)
 /*
  * Average half vectors
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(halfvec_avg);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(halfvec_avg);
 Datum
 halfvec_avg(PG_FUNCTION_ARGS)
 {
@@ -1164,26 +1174,3 @@ halfvec_avg(PG_FUNCTION_ARGS)
 
 	PG_RETURN_POINTER(result);
 }
-
-/*
- * Convert sparse vector to half vector
- */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(sparsevec_to_halfvec);
-Datum
-sparsevec_to_halfvec(PG_FUNCTION_ARGS)
-{
-	SparseVector *svec = PG_GETARG_SPARSEVEC_P(0);
-	int32		typmod = PG_GETARG_INT32(1);
-	HalfVector *result;
-	int			dim = svec->dim;
-	float	   *values = SPARSEVEC_VALUES(svec);
-
-	CheckDim(dim);
-	CheckExpectedDim(typmod, dim);
-
-	result = InitHalfVector(dim);
-	for (int i = 0; i < svec->nnz; i++)
-		result->x[svec->indices[i]] = Float4ToHalf(values[i]);
-
-	PG_RETURN_POINTER(result);
-}

src/halfvec.h

@@ -5,40 +5,17 @@
 
 #include <float.h>
 
-/* We use two types of dispatching: intrinsics and target_clones */
+#include "fmgr.h"
-/* TODO Move to better place */
+#include "vector.h"
-#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(__x86_64__) || defined(_M_AMD64)
-#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__) && (!defined(__i386__) || defined(__SSE2__))
+#elif defined(__FLT16_MAX__) && !defined(HALFVEC_DISPATCH)
 #define FLT16_SUPPORT
 #endif
 
@@ -50,7 +27,7 @@
 #define HALF_MAX 65504
 #endif
 
-#define HALFVEC_MAX_DIM 16000
+#define HALFVEC_MAX_DIM VECTOR_MAX_DIM
 
 #define HALFVEC_SIZE(_dim)		(offsetof(HalfVector, x) + sizeof(half)*(_dim))
 #define DatumGetHalfVector(x)	((HalfVector *) PG_DETOAST_DATUM(x))
@@ -61,10 +38,12 @@ 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 */
+	int16		unused;
 	half		x[FLEXIBLE_ARRAY_MEMBER];
 }			HalfVector;
 
 HalfVector *InitHalfVector(int dim);
+int			halfvec_cmp_internal(HalfVector * a, HalfVector * b);
+PGDLLEXPORT Datum halfvec_l2_normalize(PG_FUNCTION_ARGS);
 
 #endif

src/hnsw.c

@@ -9,26 +9,14 @@
 #include "commands/vacuum.h"
 #include "hnsw.h"
 #include "miscadmin.h"
-#include "utils/float.h"
 #include "utils/guc.h"
 #include "utils/selfuncs.h"
-#include "utils/spccache.h"
 
 #if PG_VERSION_NUM < 150000
 #define MarkGUCPrefixReserved(x) EmitWarningsOnPlaceholders(x)
 #endif
 
-static const struct config_enum_entry hnsw_iterative_scan_options[] = {
-	{"off", HNSW_ITERATIVE_SCAN_OFF, false},
-	{"relaxed_order", HNSW_ITERATIVE_SCAN_RELAXED, false},
-	{"strict_order", HNSW_ITERATIVE_SCAN_STRICT, false},
-	{NULL, 0, false}
-};
-
 int			hnsw_ef_search;
-int			hnsw_iterative_scan;
-int			hnsw_max_scan_tuples;
-double		hnsw_scan_mem_multiplier;
 int			hnsw_lock_tranche_id;
 static relopt_kind hnsw_relopt_kind;
 
@@ -71,27 +59,21 @@ HnswInit(void)
 
 	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, AccessExclusiveLock);
+					  HNSW_DEFAULT_M, HNSW_MIN_M, HNSW_MAX_M
+#if PG_VERSION_NUM >= 130000
+					  ,AccessExclusiveLock
+#endif
+		);
 	add_int_reloption(hnsw_relopt_kind, "ef_construction", "Size of the dynamic candidate list for construction",
-					  HNSW_DEFAULT_EF_CONSTRUCTION, HNSW_MIN_EF_CONSTRUCTION, HNSW_MAX_EF_CONSTRUCTION, AccessExclusiveLock);
+					  HNSW_DEFAULT_EF_CONSTRUCTION, HNSW_MIN_EF_CONSTRUCTION, HNSW_MAX_EF_CONSTRUCTION
+#if PG_VERSION_NUM >= 130000
+					  ,AccessExclusiveLock
+#endif
+		);
 
 	DefineCustomIntVariable("hnsw.ef_search", "Sets the size of the dynamic candidate list for search",
 							"Valid range is 1..1000.", &hnsw_ef_search,
-							HNSW_DEFAULT_EF_SEARCH, HNSW_MIN_EF_SEARCH, HNSW_MAX_EF_SEARCH, PGC_USERSET, GUC_EXPLAIN, NULL, NULL, NULL);
+							HNSW_DEFAULT_EF_SEARCH, HNSW_MIN_EF_SEARCH, HNSW_MAX_EF_SEARCH, PGC_USERSET, 0, NULL, NULL, NULL);
-
-	DefineCustomEnumVariable("hnsw.iterative_scan", "Sets the mode for iterative scans",
-							 NULL, &hnsw_iterative_scan,
-							 HNSW_ITERATIVE_SCAN_OFF, hnsw_iterative_scan_options, PGC_USERSET, GUC_EXPLAIN, NULL, NULL, NULL);
-
-	/* This is approximate and does not affect the initial scan */
-	DefineCustomIntVariable("hnsw.max_scan_tuples", "Sets the max number of tuples to visit for iterative scans",
-							NULL, &hnsw_max_scan_tuples,
-							20000, 1, INT_MAX, PGC_USERSET, GUC_EXPLAIN, NULL, NULL, NULL);
-
-	/* Same range as hash_mem_multiplier */
-	DefineCustomRealVariable("hnsw.scan_mem_multiplier", "Sets the multiple of work_mem to use for iterative scans",
-							 NULL, &hnsw_scan_mem_multiplier,
-							 1, 1, 1000, PGC_USERSET, GUC_EXPLAIN, NULL, NULL, NULL);
 
 	MarkGUCPrefixReserved("hnsw");
 }
@@ -124,93 +106,37 @@ hnswcostestimate(PlannerInfo *root, IndexPath *path, double loop_count,
 {
 	GenericCosts costs;
 	int			m;
-	double		ratio;
+	int			entryLevel;
-	double		startupPages;
-	double		spc_seq_page_cost;
 	Relation	index;
 
 	/* Never use index without order */
 	if (path->indexorderbys == NULL)
 	{
-		*indexStartupCost = get_float8_infinity();
+		*indexStartupCost = DBL_MAX;
-		*indexTotalCost = get_float8_infinity();
+		*indexTotalCost = DBL_MAX;
 		*indexSelectivity = 0;
 		*indexCorrelation = 0;
 		*indexPages = 0;
-#if PG_VERSION_NUM >= 180000
-		/* See "On disable_cost" thread on pgsql-hackers */
-		path->path.disabled_nodes = 2;
-#endif
 		return;
 	}
 
 	MemSet(&costs, 0, sizeof(costs));
 
-	genericcostestimate(root, path, loop_count, &costs);
-
 	index = index_open(path->indexinfo->indexoid, NoLock);
 	HnswGetMetaPageInfo(index, &m, NULL);
 	index_close(index, NoLock);
 
-	/*
+	/* Approximate entry level */
-	 * HNSW cost estimation follows a formula that accounts for the total
+	entryLevel = (int) -log(1.0 / path->indexinfo->tuples) * HnswGetMl(m);
-	 * number of tuples indexed combined with the parameters that most
-	 * influence the duration of the index scan, namely: m - the number of
-	 * tuples that are scanned in each step of the HNSW graph traversal
-	 * ef_search - which influences the total number of steps taken at layer 0
-	 *
-	 * The source of the vector data can impact how many steps it takes to
-	 * converge on the set of vectors to return to the executor. Currently, we
-	 * use a hardcoded scaling factor (HNSWScanScalingFactor) to help
-	 * influence that, but this could later become a configurable parameter
-	 * based on the cost estimations.
-	 *
-	 * The tuple estimator formula is below:
-	 *
-	 * numIndexTuples = entryLevel * m + layer0TuplesMax * layer0Selectivity
-	 *
-	 * "entryLevel * m" represents the floor of tuples we need to scan to get
-	 * to layer 0 (L0).
-	 *
-	 * "layer0TuplesMax" is the estimated total number of tuples we'd scan at
-	 * L0 if we weren't discarding already visited tuples as part of the scan.
-	 *
-	 * "layer0Selectivity" estimates the percentage of tuples that are scanned
-	 * at L0, accounting for previously visited tuples, multiplied by the
-	 * "scalingFactor" (currently hardcoded).
-	 */
-	if (path->indexinfo->tuples > 0)
-	{
-		double		scalingFactor = 0.55;
-		int			entryLevel = (int) (log(path->indexinfo->tuples) * HnswGetMl(m));
-		int			layer0TuplesMax = HnswGetLayerM(m, 0) * hnsw_ef_search;
-		double		layer0Selectivity = scalingFactor * log(path->indexinfo->tuples) / (log(m) * (1 + log(hnsw_ef_search)));
 
-		ratio = (entryLevel * m + layer0TuplesMax * layer0Selectivity) / path->indexinfo->tuples;
+	/* TODO Improve estimate of visited tuples (currently underestimates) */
+	/* Account for number of tuples (or entry level), m, and ef_search */
+	costs.numIndexTuples = (entryLevel + 2) * m;
 
-		if (ratio > 1)
+	genericcostestimate(root, path, loop_count, &costs);
-			ratio = 1;
-	}
-	else
-		ratio = 1;
 
-	get_tablespace_page_costs(path->indexinfo->reltablespace, NULL, &spc_seq_page_cost);
+	/* Use total cost since most work happens before first tuple is returned */
-
+	*indexStartupCost = costs.indexTotalCost;
-	/* Startup cost is cost before returning the first row */
-	costs.indexStartupCost = costs.indexTotalCost * ratio;
-
-	/* Adjust cost if needed since TOAST not included in seq scan cost */
-	startupPages = costs.numIndexPages * ratio;
-	if (startupPages > path->indexinfo->rel->pages && ratio < 0.5)
-	{
-		/* Change all page cost from random to sequential */
-		costs.indexStartupCost -= startupPages * (costs.spc_random_page_cost - spc_seq_page_cost);
-
-		/* Remove cost of extra pages */
-		costs.indexStartupCost -= (startupPages - path->indexinfo->rel->pages) * spc_seq_page_cost;
-	}
-
-	*indexStartupCost = costs.indexStartupCost;
 	*indexTotalCost = costs.indexTotalCost;
 	*indexSelectivity = costs.indexSelectivity;
 	*indexCorrelation = costs.indexCorrelation;
@@ -228,10 +154,23 @@ hnswoptions(Datum reloptions, bool validate)
 		{"ef_construction", RELOPT_TYPE_INT, offsetof(HnswOptions, efConstruction)},
 	};
 
+#if PG_VERSION_NUM >= 130000
 	return (bytea *) build_reloptions(reloptions, validate,
 									  hnsw_relopt_kind,
 									  sizeof(HnswOptions),
 									  tab, lengthof(tab));
+#else
+	relopt_value *options;
+	int			numoptions;
+	HnswOptions *rdopts;
+
+	options = parseRelOptions(reloptions, validate, hnsw_relopt_kind, &numoptions);
+	rdopts = allocateReloptStruct(sizeof(HnswOptions), options, numoptions);
+	fillRelOptions((void *) rdopts, sizeof(HnswOptions), options, numoptions,
+				   validate, tab, lengthof(tab));
+
+	return (bytea *) rdopts;
+#endif
 }
 
 /*
@@ -248,15 +187,17 @@ hnswvalidate(Oid opclassoid)
  *
  * See https://www.postgresql.org/docs/current/index-api.html
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(hnswhandler);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(hnswhandler);
 Datum
 hnswhandler(PG_FUNCTION_ARGS)
 {
 	IndexAmRoutine *amroutine = makeNode(IndexAmRoutine);
 
 	amroutine->amstrategies = 0;
-	amroutine->amsupport = 3;
+	amroutine->amsupport = 2;
+#if PG_VERSION_NUM >= 130000
 	amroutine->amoptsprocnum = 0;
+#endif
 	amroutine->amcanorder = false;
 	amroutine->amcanorderbyop = true;
 	amroutine->amcanbackward = false;	/* can change direction mid-scan */
@@ -269,24 +210,17 @@ hnswhandler(PG_FUNCTION_ARGS)
 	amroutine->amclusterable = false;
 	amroutine->ampredlocks = false;
 	amroutine->amcanparallel = false;
-#if PG_VERSION_NUM >= 170000
-	amroutine->amcanbuildparallel = true;
-#endif
 	amroutine->amcaninclude = false;
+#if PG_VERSION_NUM >= 130000
 	amroutine->amusemaintenanceworkmem = false; /* not used during VACUUM */
-#if PG_VERSION_NUM >= 160000
-	amroutine->amsummarizing = false;
-#endif
 	amroutine->amparallelvacuumoptions = VACUUM_OPTION_PARALLEL_BULKDEL;
+#endif
 	amroutine->amkeytype = InvalidOid;
 
 	/* Interface functions */
 	amroutine->ambuild = hnswbuild;
 	amroutine->ambuildempty = hnswbuildempty;
 	amroutine->aminsert = hnswinsert;
-#if PG_VERSION_NUM >= 170000
-	amroutine->aminsertcleanup = NULL;
-#endif
 	amroutine->ambulkdelete = hnswbulkdelete;
 	amroutine->amvacuumcleanup = hnswvacuumcleanup;
 	amroutine->amcanreturn = NULL;

src/hnsw.h

@@ -12,13 +12,16 @@
 #include "utils/sampling.h"
 #include "vector.h"
 
+#if PG_VERSION_NUM < 120000
+#error "Requires PostgreSQL 12+"
+#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
@@ -53,6 +56,14 @@
 #define HNSW_UPDATE_ENTRY_GREATER 1
 #define HNSW_UPDATE_ENTRY_ALWAYS 2
 
+typedef enum HnswType
+{
+	HNSW_TYPE_VECTOR,
+	HNSW_TYPE_HALFVEC,
+	HNSW_TYPE_BIT,
+	HNSW_TYPE_SPARSEVEC
+}			HnswType;
+
 /* Build phases */
 /* PROGRESS_CREATEIDX_SUBPHASE_INITIALIZE is 1 */
 #define PROGRESS_HNSW_PHASE_LOAD		2
@@ -76,6 +87,11 @@
 #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) = list_qsort(list, cmp))
+#endif
+
 #define HnswIsElementTuple(tup) ((tup)->type == HNSW_ELEMENT_TUPLE_TYPE)
 #define HnswIsNeighborTuple(tup) ((tup)->type == HNSW_NEIGHBOR_TUPLE_TYPE)
 
@@ -88,9 +104,6 @@
 /* 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 HnswGetSearchCandidate(membername, ptr) pairingheap_container(HnswSearchCandidate, membername, ptr)
-#define HnswGetSearchCandidateConst(membername, ptr) pairingheap_const_container(HnswSearchCandidate, membername, ptr)
-
 #define HnswGetValue(base, element) PointerGetDatum(HnswPtrAccess(base, (element)->value))
 
 #if PG_VERSION_NUM < 140005
@@ -109,18 +122,8 @@
 
 /* Variables */
 extern int	hnsw_ef_search;
-extern int	hnsw_iterative_scan;
-extern int	hnsw_max_scan_tuples;
-extern double hnsw_scan_mem_multiplier;
 extern int	hnsw_lock_tranche_id;
 
-typedef enum HnswIterativeScanMode
-{
-	HNSW_ITERATIVE_SCAN_OFF,
-	HNSW_ITERATIVE_SCAN_RELAXED,
-	HNSW_ITERATIVE_SCAN_STRICT
-}			HnswIterativeScanMode;
-
 typedef struct HnswElementData HnswElementData;
 typedef struct HnswNeighborArray HnswNeighborArray;
 
@@ -142,7 +145,6 @@ struct HnswElementData
 	uint8		heaptidsLength;
 	uint8		level;
 	uint8		deleted;
-	uint8		version;
 	uint32		hash;
 	HnswNeighborsPtr neighbors;
 	BlockNumber blkno;
@@ -169,13 +171,11 @@ struct HnswNeighborArray
 	HnswCandidate items[FLEXIBLE_ARRAY_MEMBER];
 };
 
-typedef struct HnswSearchCandidate
+typedef struct HnswPairingHeapNode
 {
-	pairingheap_node c_node;
+	pairingheap_node ph_node;
-	pairingheap_node w_node;
+	HnswCandidate *inner;
-	HnswElementPtr element;
+}			HnswPairingHeapNode;
-	double		distance;
-}			HnswSearchCandidate;
 
 /* HNSW index options */
 typedef struct HnswOptions
@@ -199,8 +199,8 @@ typedef struct HnswGraph
 
 	/* Allocations state */
 	LWLock		allocatorLock;
-	Size		memoryUsed;
+	long		memoryUsed;
-	Size		memoryTotal;
+	long		memoryTotal;
 
 	/* Flushed state */
 	LWLock		flushLock;
@@ -244,25 +244,6 @@ typedef struct HnswAllocator
 	void	   *state;
 }			HnswAllocator;
 
-typedef struct HnswTypeInfo
-{
-	int			maxDimensions;
-	Datum		(*normalize) (PG_FUNCTION_ARGS);
-	void		(*checkValue) (Pointer v);
-}			HnswTypeInfo;
-
-typedef struct HnswSupport
-{
-	FmgrInfo   *procinfo;
-	FmgrInfo   *normprocinfo;
-	Oid			collation;
-}			HnswSupport;
-
-typedef struct HnswQuery
-{
-	Datum		value;
-}			HnswQuery;
-
 typedef struct HnswBuildState
 {
 	/* Info */
@@ -270,7 +251,7 @@ typedef struct HnswBuildState
 	Relation	index;
 	IndexInfo  *indexInfo;
 	ForkNumber	forkNum;
-	const		HnswTypeInfo *typeInfo;
+	HnswType	type;
 
 	/* Settings */
 	int			dimensions;
@@ -282,7 +263,9 @@ typedef struct HnswBuildState
 	double		reltuples;
 
 	/* Support functions */
-	HnswSupport support;
+	FmgrInfo   *procinfo;
+	FmgrInfo   *normprocinfo;
+	Oid			collation;
 
 	/* Variables */
 	HnswGraph	graphData;
@@ -330,10 +313,10 @@ typedef struct HnswElementTupleData
 	uint8		type;
 	uint8		level;
 	uint8		deleted;
-	uint8		version;
+	uint8		unused;
 	ItemPointerData heaptids[HNSW_HEAPTIDS];
 	ItemPointerData neighbortid;
-	uint16		unused;
+	uint16		unused2;
 	Vector		data;
 }			HnswElementTupleData;
 
@@ -342,42 +325,23 @@ typedef HnswElementTupleData * HnswElementTuple;
 typedef struct HnswNeighborTupleData
 {
 	uint8		type;
-	uint8		version;
+	uint8		unused;
 	uint16		count;
 	ItemPointerData indextids[FLEXIBLE_ARRAY_MEMBER];
 }			HnswNeighborTupleData;
 
 typedef HnswNeighborTupleData * HnswNeighborTuple;
 
-typedef union
-{
-	struct pointerhash_hash *pointers;
-	struct offsethash_hash *offsets;
-	struct tidhash_hash *tids;
-}			visited_hash;
-
-typedef union
-{
-	HnswElement element;
-	ItemPointerData indextid;
-}			HnswUnvisited;
-
 typedef struct HnswScanOpaqueData
 {
-	const		HnswTypeInfo *typeInfo;
 	bool		first;
 	List	   *w;
-	visited_hash v;
-	pairingheap *discarded;
-	HnswQuery	q;
-	int			m;
-	int64		tuples;
-	double		previousDistance;
-	Size		maxMemory;
 	MemoryContext tmpCtx;
 
 	/* Support functions */
-	HnswSupport support;
+	FmgrInfo   *procinfo;
+	FmgrInfo   *normprocinfo;
+	Oid			collation;
 }			HnswScanOpaqueData;
 
 typedef HnswScanOpaqueData * HnswScanOpaque;
@@ -395,7 +359,8 @@ typedef struct HnswVacuumState
 	int			efConstruction;
 
 	/* Support functions */
-	HnswSupport support;
+	FmgrInfo   *procinfo;
+	Oid			collation;
 
 	/* Variables */
 	struct tidhash_hash *deleted;
@@ -411,35 +376,33 @@ typedef struct HnswVacuumState
 int			HnswGetM(Relation index);
 int			HnswGetEfConstruction(Relation index);
 FmgrInfo   *HnswOptionalProcInfo(Relation index, uint16 procnum);
-void		HnswInitSupport(HnswSupport * support, Relation index);
+HnswType	HnswGetType(Relation index);
-Datum		HnswNormValue(const HnswTypeInfo * typeInfo, Oid collation, Datum value);
+Datum		HnswNormValue(Datum value, HnswType type);
-bool		HnswCheckNorm(HnswSupport * support, Datum value);
+bool		HnswCheckNorm(FmgrInfo *procinfo, Oid collation, Datum value);
+void		HnswCheckValue(Datum value, HnswType type);
 Buffer		HnswNewBuffer(Relation index, ForkNumber forkNum);
 void		HnswInitPage(Buffer buf, Page page);
 void		HnswInit(void);
-List	   *HnswSearchLayer(char *base, HnswQuery * q, List *ep, int ef, int lc, Relation index, HnswSupport * support, int m, bool inserting, HnswElement skipElement, visited_hash * v, pairingheap **discarded, bool initVisited, int64 *tuples);
+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);
 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		HnswFindElementNeighbors(char *base, HnswElement element, HnswElement entryPoint, Relation index, HnswSupport * support, int m, int efConstruction, bool existing);
+void		HnswFindElementNeighbors(char *base, HnswElement element, HnswElement entryPoint, Relation index, FmgrInfo *procinfo, Oid collation, int m, int efConstruction, bool existing);
-HnswSearchCandidate *HnswEntryCandidate(char *base, HnswElement em, HnswQuery * q, Relation rel, HnswSupport * support, bool loadVec);
+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);
-HnswNeighborArray *HnswInitNeighborArray(int lm, HnswAllocator * allocator);
 void		HnswInitNeighbors(char *base, HnswElement element, int m, HnswAllocator * alloc);
-bool		HnswInsertTupleOnDisk(Relation index, HnswSupport * support, Datum value, ItemPointer heaptid, bool building);
+bool		HnswInsertTupleOnDisk(Relation index, Datum value, Datum *values, bool *isnull, ItemPointer heap_tid, bool building);
-void		HnswUpdateNeighborsOnDisk(Relation index, HnswSupport * support, HnswElement e, int m, bool checkExisting, 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, double *distance, HnswQuery * q, Relation index, HnswSupport * support, bool loadVec, double *maxDistance);
+void		HnswLoadElement(HnswElement element, float *distance, Datum *q, Relation index, FmgrInfo *procinfo, Oid collation, bool loadVec);
-bool		HnswFormIndexValue(Datum *out, Datum *values, bool *isnull, const HnswTypeInfo * typeInfo, HnswSupport * support);
 void		HnswSetElementTuple(char *base, HnswElementTuple etup, HnswElement element);
-void		HnswUpdateConnection(char *base, HnswNeighborArray * neighbors, HnswElement newElement, float distance, int lm, int *updateIdx, Relation index, HnswSupport * support);
+void		HnswUpdateConnection(char *base, HnswElement element, HnswCandidate * hc, int lm, int lc, int *updateIdx, Relation index, FmgrInfo *procinfo, Oid collation);
-bool		HnswLoadNeighborTids(HnswElement element, ItemPointerData *indextids, Relation index, int m, int lm, int lc);
+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 */

src/hnswbuild.c

@@ -60,6 +60,12 @@
 #include "pgstat.h"
 #endif
 
+#if PG_VERSION_NUM >= 130000
+#define CALLBACK_ITEM_POINTER ItemPointer tid
+#else
+#define CALLBACK_ITEM_POINTER HeapTuple hup
+#endif
+
 #if PG_VERSION_NUM >= 140000
 #include "utils/backend_status.h"
 #include "utils/wait_event.h"
@@ -69,6 +75,10 @@
 #define PARALLEL_KEY_HNSW_AREA			UINT64CONST(0xA000000000000002)
 #define PARALLEL_KEY_QUERY_TEXT			UINT64CONST(0xA000000000000003)
 
+#if PG_VERSION_NUM < 130000
+#define GENERATIONCHUNK_RAWSIZE (SIZEOF_SIZE_T + SIZEOF_VOID_P * 2)
+#endif
+
 /*
  * Create the metapage
  */
@@ -182,9 +192,7 @@ CreateGraphPages(HnswBuildState * buildstate)
 
 		/* Initial size check */
 		if (etupSize > HNSW_TUPLE_ALLOC_SIZE)
-			ereport(ERROR,
+			elog(ERROR, "index tuple too large");
-					(errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
-					 errmsg("index tuple too large")));
 
 		HnswSetElementTuple(base, etup, element);
 
@@ -366,18 +374,12 @@ AddElementInMemory(char *base, HnswGraph * graph, HnswElement element)
  * Update neighbors
  */
 static void
-UpdateNeighborsInMemory(char *base, HnswSupport * support, HnswElement e, int m)
+UpdateNeighborsInMemory(char *base, FmgrInfo *procinfo, Oid collation, HnswElement e, int m)
 {
 	for (int lc = e->level; lc >= 0; lc--)
 	{
 		int			lm = HnswGetLayerM(m, lc);
-		Size		neighborsSize = HNSW_NEIGHBOR_ARRAY_SIZE(lm);
+		HnswNeighborArray *neighbors = HnswGetNeighbors(base, e, lc);
-		HnswNeighborArray *neighbors = palloc(neighborsSize);
-
-		/* Copy neighbors to local memory */
-		LWLockAcquire(&e->lock, LW_SHARED);
-		memcpy(neighbors, HnswGetNeighbors(base, e, lc), neighborsSize);
-		LWLockRelease(&e->lock);
 
 		for (int i = 0; i < neighbors->length; i++)
 		{
@@ -387,8 +389,9 @@ UpdateNeighborsInMemory(char *base, HnswSupport * support, HnswElement e, int m)
 			/* Keep scan-build happy on Mac x86-64 */
 			Assert(neighborElement);
 
+			/* Use element for lock instead of hc since hc can be replaced */
 			LWLockAcquire(&neighborElement->lock, LW_EXCLUSIVE);
-			HnswUpdateConnection(base, HnswGetNeighbors(base, neighborElement, lc), e, hc->distance, lm, NULL, NULL, support);
+			HnswUpdateConnection(base, e, hc, lm, lc, NULL, NULL, procinfo, collation);
 			LWLockRelease(&neighborElement->lock);
 		}
 	}
@@ -398,7 +401,7 @@ UpdateNeighborsInMemory(char *base, HnswSupport * support, HnswElement e, int m)
  * Update graph in memory
  */
 static void
-UpdateGraphInMemory(HnswSupport * support, HnswElement element, int m, int efConstruction, HnswElement entryPoint, HnswBuildState * buildstate)
+UpdateGraphInMemory(FmgrInfo *procinfo, Oid collation, HnswElement element, int m, int efConstruction, HnswElement entryPoint, HnswBuildState * buildstate)
 {
 	HnswGraph  *graph = buildstate->graph;
 	char	   *base = buildstate->hnswarea;
@@ -411,7 +414,7 @@ UpdateGraphInMemory(HnswSupport * support, HnswElement element, int m, int efCon
 	AddElementInMemory(base, graph, element);
 
 	/* Update neighbors */
-	UpdateNeighborsInMemory(base, support, element, m);
+	UpdateNeighborsInMemory(base, procinfo, collation, element, m);
 
 	/* Update entry point if needed (already have lock) */
 	if (entryPoint == NULL || element->level > entryPoint->level)
@@ -424,8 +427,9 @@ UpdateGraphInMemory(HnswSupport * support, HnswElement element, int m, int efCon
 static void
 InsertTupleInMemory(HnswBuildState * buildstate, HnswElement element)
 {
+	FmgrInfo   *procinfo = buildstate->procinfo;
+	Oid			collation = buildstate->collation;
 	HnswGraph  *graph = buildstate->graph;
-	HnswSupport *support = &buildstate->support;
 	HnswElement entryPoint;
 	LWLock	   *entryLock = &graph->entryLock;
 	LWLock	   *entryWaitLock = &graph->entryWaitLock;
@@ -457,10 +461,10 @@ InsertTupleInMemory(HnswBuildState * buildstate, HnswElement element)
 	}
 
 	/* Find neighbors for element */
-	HnswFindElementNeighbors(base, element, entryPoint, NULL, support, m, efConstruction, false);
+	HnswFindElementNeighbors(base, element, entryPoint, NULL, procinfo, collation, m, efConstruction, false);
 
 	/* Update graph in memory */
-	UpdateGraphInMemory(support, element, m, efConstruction, entryPoint, buildstate);
+	UpdateGraphInMemory(procinfo, collation, element, m, efConstruction, entryPoint, buildstate);
 
 	/* Release entry lock */
 	LWLockRelease(entryLock);
@@ -475,16 +479,25 @@ InsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heaptid, Hn
 	HnswGraph  *graph = buildstate->graph;
 	HnswElement element;
 	HnswAllocator *allocator = &buildstate->allocator;
-	HnswSupport *support = &buildstate->support;
 	Size		valueSize;
 	Pointer		valuePtr;
 	LWLock	   *flushLock = &graph->flushLock;
 	char	   *base = buildstate->hnswarea;
-	Datum		value;
 
-	/* Form index value */
+	/* Detoast once for all calls */
-	if (!HnswFormIndexValue(&value, values, isnull, buildstate->typeInfo, support))
+	Datum		value = PointerGetDatum(PG_DETOAST_DATUM(values[0]));
-		return false;
+
+	/* Check value */
+	HnswCheckValue(value, buildstate->type);
+
+	/* Normalize if needed */
+	if (buildstate->normprocinfo != NULL)
+	{
+		if (!HnswCheckNorm(buildstate->normprocinfo, buildstate->collation, value))
+			return false;
+
+		value = HnswNormValue(value, buildstate->type);
+	}
 
 	/* Get datum size */
 	valueSize = VARSIZE_ANY(DatumGetPointer(value));
@@ -497,7 +510,7 @@ InsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heaptid, Hn
 	{
 		LWLockRelease(flushLock);
 
-		return HnswInsertTupleOnDisk(index, support, value, heaptid, true);
+		return HnswInsertTupleOnDisk(index, value, values, isnull, heaptid, true);
 	}
 
 	/*
@@ -529,7 +542,7 @@ InsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heaptid, Hn
 
 		LWLockRelease(flushLock);
 
-		return HnswInsertTupleOnDisk(index, support, value, heaptid, true);
+		return HnswInsertTupleOnDisk(index, value, values, isnull, heaptid, true);
 	}
 
 	/* Ok, we can proceed to allocate the element */
@@ -563,13 +576,17 @@ InsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heaptid, Hn
  * Callback for table_index_build_scan
  */
 static void
-BuildCallback(Relation index, ItemPointer tid, Datum *values,
+BuildCallback(Relation index, CALLBACK_ITEM_POINTER, Datum *values,
 			  bool *isnull, bool tupleIsAlive, void *state)
 {
 	HnswBuildState *buildstate = (HnswBuildState *) state;
 	HnswGraph  *graph = buildstate->graph;
 	MemoryContext oldCtx;
 
+#if PG_VERSION_NUM < 130000
+	ItemPointer tid = &hup->t_self;
+#endif
+
 	/* Skip nulls */
 	if (isnull[0])
 		return;
@@ -595,7 +612,7 @@ BuildCallback(Relation index, ItemPointer tid, Datum *values,
  * Initialize the graph
  */
 static void
-InitGraph(HnswGraph * graph, char *base, Size memoryTotal)
+InitGraph(HnswGraph * graph, char *base, long memoryTotal)
 {
 	/* Initialize the lock tranche if needed */
 	HnswInitLockTranche();
@@ -632,7 +649,11 @@ HnswMemoryContextAlloc(Size size, void *state)
 	HnswBuildState *buildstate = (HnswBuildState *) state;
 	void	   *chunk = MemoryContextAlloc(buildstate->graphCtx, size);
 
+#if PG_VERSION_NUM >= 130000
 	buildstate->graphData.memoryUsed = MemoryContextMemAllocated(buildstate->graphCtx, false);
+#else
+	buildstate->graphData.memoryUsed += MAXALIGN(size);
+#endif
 
 	return chunk;
 }
@@ -650,51 +671,63 @@ HnswSharedMemoryAlloc(Size size, void *state)
 	return chunk;
 }
 
+/*
+ * Get max dimensions
+ */
+static int
+GetMaxDimensions(HnswType type)
+{
+	int			maxDimensions = HNSW_MAX_DIM;
+
+	if (type == HNSW_TYPE_HALFVEC)
+		maxDimensions *= 2;
+	else if (type == HNSW_TYPE_BIT)
+		maxDimensions *= 32;
+	else if (type == HNSW_TYPE_SPARSEVEC)
+		maxDimensions = INT_MAX;
+
+	return maxDimensions;
+}
+
 /*
  * Initialize the build state
  */
 static void
 InitBuildState(HnswBuildState * buildstate, Relation heap, Relation index, IndexInfo *indexInfo, ForkNumber forkNum)
 {
+	int			maxDimensions;
+
 	buildstate->heap = heap;
 	buildstate->index = index;
 	buildstate->indexInfo = indexInfo;
 	buildstate->forkNum = forkNum;
-	buildstate->typeInfo = HnswGetTypeInfo(index);
+	buildstate->type = HnswGetType(index);
 
 	buildstate->m = HnswGetM(index);
 	buildstate->efConstruction = HnswGetEfConstruction(index);
 	buildstate->dimensions = TupleDescAttr(index->rd_att, 0)->atttypmod;
 
-	/* Disallow varbit since require fixed dimensions */
+	maxDimensions = GetMaxDimensions(buildstate->type);
-	if (TupleDescAttr(index->rd_att, 0)->atttypid == VARBITOID)
-		ereport(ERROR,
-				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
-				 errmsg("type not supported for hnsw index")));
 
 	/* Require column to have dimensions to be indexed */
 	if (buildstate->dimensions < 0)
-		ereport(ERROR,
+		elog(ERROR, "column does not have dimensions");
-				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
-				 errmsg("column does not have dimensions")));
 
-	if (buildstate->dimensions > buildstate->typeInfo->maxDimensions)
+	if (buildstate->dimensions > maxDimensions)
-		ereport(ERROR,
+		elog(ERROR, "column cannot have more than %d dimensions for hnsw index", maxDimensions);
-				(errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
-				 errmsg("column cannot have more than %d dimensions for hnsw index", buildstate->typeInfo->maxDimensions)));
 
 	if (buildstate->efConstruction < 2 * buildstate->m)
-		ereport(ERROR,
+		elog(ERROR, "ef_construction must be greater than or equal to 2 * m");
-				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
-				 errmsg("ef_construction must be greater than or equal to 2 * m")));
 
 	buildstate->reltuples = 0;
 	buildstate->indtuples = 0;
 
 	/* Get support functions */
-	HnswInitSupport(&buildstate->support, index);
+	buildstate->procinfo = index_getprocinfo(index, 1, HNSW_DISTANCE_PROC);
+	buildstate->normprocinfo = HnswOptionalProcInfo(index, HNSW_NORM_PROC);
+	buildstate->collation = index->rd_indcollation[0];
 
-	InitGraph(&buildstate->graphData, NULL, (Size) maintenance_work_mem * 1024L);
+	InitGraph(&buildstate->graphData, NULL, maintenance_work_mem * 1024L);
 	buildstate->graph = &buildstate->graphData;
 	buildstate->ml = HnswGetMl(buildstate->m);
 	buildstate->maxLevel = HnswGetMaxLevel(buildstate->m);
@@ -1104,8 +1137,8 @@ BuildIndex(Relation heap, Relation index, IndexInfo *indexInfo,
 
 	BuildGraph(buildstate, forkNum);
 
-	if (RelationNeedsWAL(index) || forkNum == INIT_FORKNUM)
+	if (RelationNeedsWAL(index))
-		log_newpage_range(index, forkNum, 0, RelationGetNumberOfBlocksInFork(index, forkNum), true);
+		log_newpage_range(index, forkNum, 0, RelationGetNumberOfBlocks(index), true);
 
 	FreeBuildState(buildstate);
 }

src/hnswinsert.c

@@ -36,15 +36,14 @@ GetInsertPage(Relation index)
  * Check for a free offset
  */
 static bool
-HnswFreeOffset(Relation index, Buffer buf, Page page, HnswElement element, Size etupSize, Size ntupSize, Buffer *nbuf, Page *npage, OffsetNumber *freeOffno, OffsetNumber *freeNeighborOffno, BlockNumber *newInsertPage, uint8 *tupleVersion)
+HnswFreeOffset(Relation index, Buffer buf, Page page, HnswElement element, 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))
 	{
-		ItemId		eitemid = PageGetItemId(page, offno);
+		HnswElementTuple etup = (HnswElementTuple) PageGetItem(page, PageGetItemId(page, offno));
-		HnswElementTuple etup = (HnswElementTuple) PageGetItem(page, eitemid);
 
 		/* Skip neighbor tuples */
 		if (!HnswIsElementTuple(etup))
@@ -55,9 +54,7 @@ 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		nitemid;
+			ItemId		itemid;
-			Size		pageFree;
-			Size		npageFree;
 
 			if (!BlockNumberIsValid(*newInsertPage))
 				*newInsertPage = elementPage;
@@ -76,29 +73,13 @@ HnswFreeOffset(Relation index, Buffer buf, Page page, HnswElement element, Size
 				*npage = BufferGetPage(*nbuf);
 			}
 
-			nitemid = PageGetItemId(*npage, neighborOffno);
+			itemid = PageGetItemId(*npage, neighborOffno);
 
-			/* Ensure aligned for space check */
+			/* Check for space on neighbor tuple page */
-			Assert(etupSize == MAXALIGN(etupSize));
+			if (PageGetFreeSpace(*npage) + ItemIdGetLength(itemid) - sizeof(ItemIdData) >= ntupSize)
-			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;
-				*tupleVersion = etup->version;
 				return true;
 			}
 			else if (*nbuf != buf)
@@ -154,7 +135,6 @@ AddElementOnDisk(Relation index, HnswElement e, int m, BlockNumber insertPage, B
 	OffsetNumber freeOffno = InvalidOffsetNumber;
 	OffsetNumber freeNeighborOffno = InvalidOffsetNumber;
 	BlockNumber newInsertPage = InvalidBlockNumber;
-	uint8		tupleVersion;
 	char	   *base = NULL;
 
 	/* Calculate sizes */
@@ -204,7 +184,7 @@ AddElementOnDisk(Relation index, HnswElement e, int m, BlockNumber insertPage, B
 		}
 
 		/* Next, try space from a deleted element */
-		if (HnswFreeOffset(index, buf, page, e, etupSize, ntupSize, &nbuf, &npage, &freeOffno, &freeNeighborOffno, &newInsertPage, &tupleVersion))
+		if (HnswFreeOffset(index, buf, page, e, ntupSize, &nbuf, &npage, &freeOffno, &freeNeighborOffno, &newInsertPage))
 		{
 			if (nbuf != buf)
 			{
@@ -214,10 +194,6 @@ AddElementOnDisk(Relation index, HnswElement e, int m, BlockNumber insertPage, B
 					npage = GenericXLogRegisterBuffer(state, nbuf, 0);
 			}
 
-			/* Set tuple version */
-			etup->version = tupleVersion;
-			ntup->version = tupleVersion;
-
 			break;
 		}
 
@@ -340,107 +316,6 @@ AddElementOnDisk(Relation index, HnswElement e, int m, BlockNumber insertPage, B
 		*updatedInsertPage = newInsertPage;
 }
 
-/*
- * Load neighbors
- */
-static HnswNeighborArray *
-HnswLoadNeighbors(HnswElement element, Relation index, int m, int lm, int lc)
-{
-	char	   *base = NULL;
-	HnswNeighborArray *neighbors = HnswInitNeighborArray(lm, NULL);
-	ItemPointerData indextids[HNSW_MAX_M * 2];
-
-	if (!HnswLoadNeighborTids(element, indextids, index, m, lm, lc))
-		return neighbors;
-
-	for (int i = 0; i < lm; i++)
-	{
-		ItemPointer indextid = &indextids[i];
-		HnswElement e;
-		HnswCandidate *hc;
-
-		if (!ItemPointerIsValid(indextid))
-			break;
-
-		e = HnswInitElementFromBlock(ItemPointerGetBlockNumber(indextid), ItemPointerGetOffsetNumber(indextid));
-		hc = &neighbors->items[neighbors->length++];
-		HnswPtrStore(base, hc->element, e);
-	}
-
-	return neighbors;
-}
-
-/*
- * Load elements for insert
- */
-static void
-LoadElementsForInsert(HnswNeighborArray * neighbors, HnswQuery * q, int *idx, Relation index, HnswSupport * support)
-{
-	char	   *base = NULL;
-
-	for (int i = 0; i < neighbors->length; i++)
-	{
-		HnswCandidate *hc = &neighbors->items[i];
-		HnswElement element = HnswPtrAccess(base, hc->element);
-		double		distance;
-
-		HnswLoadElement(element, &distance, q, index, support, true, NULL);
-		hc->distance = distance;
-
-		/* Prune element if being deleted */
-		if (element->heaptidsLength == 0)
-		{
-			*idx = i;
-			break;
-		}
-	}
-}
-
-/*
- * Get update index
- */
-static int
-GetUpdateIndex(HnswElement element, HnswElement newElement, float distance, int m, int lm, int lc, Relation index, HnswSupport * support, MemoryContext updateCtx)
-{
-	char	   *base = NULL;
-	int			idx = -1;
-	HnswNeighborArray *neighbors;
-	MemoryContext oldCtx = MemoryContextSwitchTo(updateCtx);
-
-	/*
-	 * Get latest neighbors since they may have changed. Do not lock yet since
-	 * selecting neighbors can take time. Could use optimistic locking to
-	 * retry if another update occurs before getting exclusive lock.
-	 */
-	neighbors = HnswLoadNeighbors(element, index, m, lm, lc);
-
-	/*
-	 * Could improve performance for vacuuming by checking neighbors against
-	 * list of elements being deleted to find index. It's important to exclude
-	 * already deleted elements for this since they can be replaced at any
-	 * time.
-	 */
-
-	if (neighbors->length < lm)
-		idx = -2;
-	else
-	{
-		HnswQuery	q;
-
-		q.value = HnswGetValue(base, element);
-
-		LoadElementsForInsert(neighbors, &q, &idx, index, support);
-
-		if (idx == -1)
-			HnswUpdateConnection(base, neighbors, newElement, distance, lm, &idx, index, support);
-	}
-
-	MemoryContextSwitchTo(oldCtx);
-	MemoryContextReset(updateCtx);
-
-	return idx;
-}
-
 /*
  * Check if connection already exists
  */
@@ -461,94 +336,14 @@ ConnectionExists(HnswElement e, HnswNeighborTuple ntup, int startIdx, int lm)
 	return false;
 }
 
-/*
- * Update neighbor
- */
-static void
-UpdateNeighborOnDisk(HnswElement element, HnswElement newElement, int idx, int m, int lm, int lc, Relation index, bool checkExisting, bool building)
-{
-	Buffer		buf;
-	Page		page;
-	GenericXLogState *state;
-	HnswNeighborTuple ntup;
-	int			startIdx;
-	OffsetNumber offno = element->neighborOffno;
-
-	/* Register page */
-	buf = ReadBuffer(index, element->neighborPage);
-	LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
-	if (building)
-	{
-		state = NULL;
-		page = BufferGetPage(buf);
-	}
-	else
-	{
-		state = GenericXLogStart(index);
-		page = GenericXLogRegisterBuffer(state, buf, 0);
-	}
-
-	/* Get tuple */
-	ntup = (HnswNeighborTuple) PageGetItem(page, PageGetItemId(page, offno));
-
-	/* Calculate index for update */
-	startIdx = (element->level - lc) * m;
-
-	/* Check for existing connection */
-	if (checkExisting && ConnectionExists(newElement, ntup, startIdx, lm))
-		idx = -1;
-	else if (idx == -2)
-	{
-		/* Find free offset if still exists */
-		/* TODO Retry updating connections if not */
-		for (int j = 0; j < lm; j++)
-		{
-			if (!ItemPointerIsValid(&ntup->indextids[startIdx + j]))
-			{
-				idx = startIdx + j;
-				break;
-			}
-		}
-	}
-	else
-		idx += startIdx;
-
-	/* Make robust to issues */
-	if (idx >= 0 && idx < ntup->count)
-	{
-		ItemPointer indextid = &ntup->indextids[idx];
-
-		/* Update neighbor on the buffer */
-		ItemPointerSet(indextid, newElement->blkno, newElement->offno);
-
-		/* Commit */
-		if (building)
-			MarkBufferDirty(buf);
-		else
-			GenericXLogFinish(state);
-	}
-	else if (!building)
-		GenericXLogAbort(state);
-
-	UnlockReleaseBuffer(buf);
-}
-
 /*
  * Update neighbors
  */
 void
-HnswUpdateNeighborsOnDisk(Relation index, HnswSupport * support, HnswElement e, int m, bool checkExisting, bool building)
+HnswUpdateNeighborsOnDisk(Relation index, FmgrInfo *procinfo, Oid collation, HnswElement e, int m, bool checkExisting, bool building)
 {
 	char	   *base = NULL;
 
-	/* Use separate memory context to improve performance for larger vectors */
-	MemoryContext updateCtx = GenerationContextCreate(CurrentMemoryContext,
-													  "Hnsw insert update context",
-#if PG_VERSION_NUM >= 150000
-													  128 * 1024, 128 * 1024,
-#endif
-													  128 * 1024);
-
 	for (int lc = e->level; lc >= 0; lc--)
 	{
 		int			lm = HnswGetLayerM(m, lc);
@@ -557,20 +352,92 @@ HnswUpdateNeighborsOnDisk(Relation index, HnswSupport * support, HnswElement e,
 		for (int i = 0; i < neighbors->length; i++)
 		{
 			HnswCandidate *hc = &neighbors->items[i];
+			Buffer		buf;
+			Page		page;
+			GenericXLogState *state;
+			HnswNeighborTuple ntup;
+			int			idx = -1;
+			int			startIdx;
 			HnswElement neighborElement = HnswPtrAccess(base, hc->element);
-			int			idx;
+			OffsetNumber offno = neighborElement->neighborOffno;
 
-			idx = GetUpdateIndex(neighborElement, e, hc->distance, m, lm, lc, index, support, updateCtx);
+			/* Get latest neighbors since they may have changed */
+			/* Do not lock yet since selecting neighbors can take time */
+			HnswLoadNeighbors(neighborElement, index, m);
+
+			/*
+			 * Could improve performance for vacuuming by checking neighbors
+			 * against list of elements being deleted to find index. It's
+			 * important to exclude already deleted elements for this since
+			 * they can be replaced at any time.
+			 */
+
+			/* Select neighbors */
+			HnswUpdateConnection(NULL, e, hc, lm, lc, &idx, index, procinfo, collation);
 
 			/* New element was not selected as a neighbor */
 			if (idx == -1)
 				continue;
 
-			UpdateNeighborOnDisk(neighborElement, e, idx, m, lm, lc, index, checkExisting, building);
+			/* Register page */
+			buf = ReadBuffer(index, neighborElement->neighborPage);
+			LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
+			if (building)
+			{
+				state = NULL;
+				page = BufferGetPage(buf);
+			}
+			else
+			{
+				state = GenericXLogStart(index);
+				page = GenericXLogRegisterBuffer(state, buf, 0);
+			}
+
+			/* Get tuple */
+			ntup = (HnswNeighborTuple) PageGetItem(page, PageGetItemId(page, offno));
+
+			/* Calculate index for update */
+			startIdx = (neighborElement->level - lc) * m;
+
+			/* Check for existing connection */
+			if (checkExisting && ConnectionExists(e, ntup, startIdx, lm))
+				idx = -1;
+			else if (idx == -2)
+			{
+				/* Find free offset if still exists */
+				/* TODO Retry updating connections if not */
+				for (int j = 0; j < lm; j++)
+				{
+					if (!ItemPointerIsValid(&ntup->indextids[startIdx + j]))
+					{
+						idx = startIdx + j;
+						break;
+					}
+				}
+			}
+			else
+				idx += startIdx;
+
+			/* Make robust to issues */
+			if (idx >= 0 && idx < ntup->count)
+			{
+				ItemPointer indextid = &ntup->indextids[idx];
+
+				/* Update neighbor on the buffer */
+				ItemPointerSet(indextid, e->blkno, e->offno);
+
+				/* Commit */
+				if (building)
+					MarkBufferDirty(buf);
+				else
+					GenericXLogFinish(state);
+			}
+			else if (!building)
+				GenericXLogAbort(state);
+
+			UnlockReleaseBuffer(buf);
 		}
 	}
-
-	MemoryContextDelete(updateCtx);
 }
 
 /*
@@ -660,7 +527,7 @@ FindDuplicateOnDisk(Relation index, HnswElement element, bool building)
  * Update graph on disk
  */
 static void
-UpdateGraphOnDisk(Relation index, HnswSupport * support, HnswElement element, int m, int efConstruction, HnswElement entryPoint, bool building)
+UpdateGraphOnDisk(Relation index, FmgrInfo *procinfo, Oid collation, HnswElement element, int m, int efConstruction, HnswElement entryPoint, bool building)
 {
 	BlockNumber newInsertPage = InvalidBlockNumber;
 
@@ -676,7 +543,7 @@ UpdateGraphOnDisk(Relation index, HnswSupport * support, HnswElement element, in
 		HnswUpdateMetaPage(index, 0, NULL, newInsertPage, MAIN_FORKNUM, building);
 
 	/* Update neighbors */
-	HnswUpdateNeighborsOnDisk(index, support, element, m, false, building);
+	HnswUpdateNeighborsOnDisk(index, procinfo, collation, element, m, false, building);
 
 	/* Update entry point if needed */
 	if (entryPoint == NULL || element->level > entryPoint->level)
@@ -687,12 +554,14 @@ UpdateGraphOnDisk(Relation index, HnswSupport * support, HnswElement element, in
  * Insert a tuple into the index
  */
 bool
-HnswInsertTupleOnDisk(Relation index, HnswSupport * support, Datum value, ItemPointer heaptid, bool building)
+HnswInsertTupleOnDisk(Relation index, Datum value, Datum *values, bool *isnull, ItemPointer heap_tid, bool building)
 {
 	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];
 	LOCKMODE	lockmode = ShareLock;
 	char	   *base = NULL;
 
@@ -707,7 +576,7 @@ HnswInsertTupleOnDisk(Relation index, HnswSupport * support, Datum value, ItemPo
 	HnswGetMetaPageInfo(index, &m, &entryPoint);
 
 	/* Create an element */
-	element = HnswInitElement(base, heaptid, m, HnswGetMl(m), HnswGetMaxLevel(m), NULL);
+	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 */
@@ -725,10 +594,10 @@ HnswInsertTupleOnDisk(Relation index, HnswSupport * support, Datum value, ItemPo
 	}
 
 	/* Find neighbors for element */
-	HnswFindElementNeighbors(base, element, entryPoint, index, support, m, efConstruction, false);
+	HnswFindElementNeighbors(base, element, entryPoint, index, procinfo, collation, m, efConstruction, false);
 
 	/* Update graph on disk */
-	UpdateGraphOnDisk(index, support, element, m, efConstruction, entryPoint, building);
+	UpdateGraphOnDisk(index, procinfo, collation, element, m, efConstruction, entryPoint, building);
 
 	/* Release lock */
 	UnlockPage(index, HNSW_UPDATE_LOCK, lockmode);
@@ -740,19 +609,30 @@ HnswInsertTupleOnDisk(Relation index, HnswSupport * support, Datum value, ItemPo
  * Insert a tuple into the index
  */
 static void
-HnswInsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heaptid)
+HnswInsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heap_tid)
 {
 	Datum		value;
-	const		HnswTypeInfo *typeInfo = HnswGetTypeInfo(index);
+	FmgrInfo   *normprocinfo;
-	HnswSupport support;
+	Oid			collation = index->rd_indcollation[0];
+	HnswType	type = HnswGetType(index);
 
-	HnswInitSupport(&support, index);
+	/* Detoast once for all calls */
+	value = PointerGetDatum(PG_DETOAST_DATUM(values[0]));
 
-	/* Form index value */
+	/* Check value */
-	if (!HnswFormIndexValue(&value, values, isnull, typeInfo, &support))
+	HnswCheckValue(value, type);
-		return;
 
-	HnswInsertTupleOnDisk(index, &support, value, heaptid, false);
+	/* Normalize if needed */
+	normprocinfo = HnswOptionalProcInfo(index, HNSW_NORM_PROC);
+	if (normprocinfo != NULL)
+	{
+		if (!HnswCheckNorm(normprocinfo, collation, value))
+			return;
+
+		value = HnswNormValue(value, type);
+	}
+
+	HnswInsertTupleOnDisk(index, value, values, isnull, heap_tid, false);
 }
 
 /*

src/hnswscan.c

@@ -5,74 +5,39 @@
 #include "pgstat.h"
 #include "storage/bufmgr.h"
 #include "storage/lmgr.h"
-#include "utils/float.h"
 #include "utils/memutils.h"
 
 /*
  * Algorithm 5 from paper
  */
 static List *
-GetScanItems(IndexScanDesc scan, Datum value)
+GetScanItems(IndexScanDesc scan, Datum q)
 {
 	HnswScanOpaque so = (HnswScanOpaque) scan->opaque;
 	Relation	index = scan->indexRelation;
-	HnswSupport *support = &so->support;
+	FmgrInfo   *procinfo = so->procinfo;
+	Oid			collation = so->collation;
 	List	   *ep;
 	List	   *w;
 	int			m;
 	HnswElement entryPoint;
 	char	   *base = NULL;
-	HnswQuery  *q = &so->q;
 
 	/* Get m and entry point */
 	HnswGetMetaPageInfo(index, &m, &entryPoint);
 
-	q->value = value;
-	so->m = m;
-
 	if (entryPoint == NULL)
 		return NIL;
 
-	ep = list_make1(HnswEntryCandidate(base, entryPoint, q, index, support, false));
+	ep = list_make1(HnswEntryCandidate(base, entryPoint, q, index, procinfo, collation, false));
 
 	for (int lc = entryPoint->level; lc >= 1; lc--)
 	{
-		w = HnswSearchLayer(base, q, ep, 1, lc, index, support, m, false, NULL, NULL, NULL, true, NULL);
+		w = HnswSearchLayer(base, q, ep, 1, lc, index, procinfo, collation, m, false, NULL);
 		ep = w;
 	}
 
-	return HnswSearchLayer(base, q, ep, hnsw_ef_search, 0, index, support, m, false, NULL, &so->v, hnsw_iterative_scan != HNSW_ITERATIVE_SCAN_OFF ? &so->discarded : NULL, true, &so->tuples);
+	return HnswSearchLayer(base, q, ep, hnsw_ef_search, 0, index, procinfo, collation, m, false, NULL);
-}
-
-/*
- * Resume scan at ground level with discarded candidates
- */
-static List *
-ResumeScanItems(IndexScanDesc scan)
-{
-	HnswScanOpaque so = (HnswScanOpaque) scan->opaque;
-	Relation	index = scan->indexRelation;
-	List	   *ep = NIL;
-	char	   *base = NULL;
-	int			batch_size = hnsw_ef_search;
-
-	if (pairingheap_is_empty(so->discarded))
-		return NIL;
-
-	/* Get next batch of candidates */
-	for (int i = 0; i < batch_size; i++)
-	{
-		HnswSearchCandidate *sc;
-
-		if (pairingheap_is_empty(so->discarded))
-			break;
-
-		sc = HnswGetSearchCandidate(w_node, pairingheap_remove_first(so->discarded));
-
-		ep = lappend(ep, sc);
-	}
-
-	return HnswSearchLayer(base, &so->q, ep, batch_size, 0, index, &so->support, so->m, false, NULL, &so->v, &so->discarded, false, &so->tuples);
 }
 
 /*
@@ -94,25 +59,14 @@ GetScanValue(IndexScanDesc scan)
 		Assert(!VARATT_IS_COMPRESSED(DatumGetPointer(value)));
 		Assert(!VARATT_IS_EXTENDED(DatumGetPointer(value)));
 
-		/* Normalize if needed */
+		/* Fine if normalization fails */
-		if (so->support.normprocinfo != NULL)
+		if (so->normprocinfo != NULL)
-			value = HnswNormValue(so->typeInfo, so->support.collation, value);
+			value = HnswNormValue(value, HnswGetType(scan->indexRelation));
 	}
 
 	return value;
 }
 
-#if defined(HNSW_MEMORY)
-/*
- * Show memory usage
- */
-static void
-ShowMemoryUsage(HnswScanOpaque so)
-{
-	elog(INFO, "memory: %zu KB, tuples: " INT64_FORMAT, MemoryContextMemAllocated(so->tmpCtx, false) / 1024, so->tuples);
-}
-#endif
-
 /*
  * Prepare for an index scan
  */
@@ -121,28 +75,19 @@ hnswbeginscan(Relation index, int nkeys, int norderbys)
 {
 	IndexScanDesc scan;
 	HnswScanOpaque so;
-	double		maxMemory;
 
 	scan = RelationGetIndexScan(index, nkeys, norderbys);
 
 	so = (HnswScanOpaque) palloc(sizeof(HnswScanOpaqueData));
-	so->typeInfo = HnswGetTypeInfo(index);
+	so->first = true;
-
-	/* Set support functions */
-	HnswInitSupport(&so->support, index);
-
-	/*
-	 * Use a lower max allocation size than default to allow scanning more
-	 * tuples for iterative search before exceeding work_mem
-	 */
 	so->tmpCtx = AllocSetContextCreate(CurrentMemoryContext,
 									   "Hnsw scan temporary context",
-									   0, 8 * 1024, 256 * 1024);
+									   ALLOCSET_DEFAULT_SIZES);
 
-	/* Calculate max memory */
+	/* Set support functions */
-	/* Add 256 extra bytes to fill last block when close */
+	so->procinfo = index_getprocinfo(index, 1, HNSW_DISTANCE_PROC);
-	maxMemory = (double) work_mem * hnsw_scan_mem_multiplier * 1024.0 + 256;
+	so->normprocinfo = HnswOptionalProcInfo(index, HNSW_NORM_PROC);
-	so->maxMemory = Min(maxMemory, (double) SIZE_MAX);
+	so->collation = index->rd_indcollation[0];
 
 	scan->opaque = so;
 
@@ -158,11 +103,6 @@ hnswrescan(IndexScanDesc scan, ScanKey keys, int nkeys, ScanKey orderbys, int no
 	HnswScanOpaque so = (HnswScanOpaque) scan->opaque;
 
 	so->first = true;
-	/* v and discarded are allocated in tmpCtx */
-	so->v.tids = NULL;
-	so->discarded = NULL;
-	so->tuples = 0;
-	so->previousDistance = -get_float8_infinity();
 	MemoryContextReset(so->tmpCtx);
 
 	if (keys && scan->numberOfKeys > 0)
@@ -219,105 +159,27 @@ hnswgettuple(IndexScanDesc scan, ScanDirection dir)
 
 		so->first = false;
 
-#if defined(HNSW_MEMORY)
+#if defined(HNSW_MEMORY) && PG_VERSION_NUM >= 130000
-		ShowMemoryUsage(so);
+		elog(INFO, "memory: %zu MB", MemoryContextMemAllocated(so->tmpCtx, false) / (1024 * 1024));
 #endif
 	}
 
-	for (;;)
+	while (list_length(so->w) > 0)
 	{
 		char	   *base = NULL;
-		HnswSearchCandidate *sc;
+		HnswCandidate *hc = llast(so->w);
-		HnswElement element;
+		HnswElement element = HnswPtrAccess(base, hc->element);
 		ItemPointer heaptid;
 
-		if (list_length(so->w) == 0)
-		{
-			if (hnsw_iterative_scan == HNSW_ITERATIVE_SCAN_OFF)
-				break;
-
-			/* Empty index */
-			if (so->discarded == NULL)
-				break;
-
-			/* Reached max number of tuples */
-			if (so->tuples >= hnsw_max_scan_tuples)
-			{
-				if (pairingheap_is_empty(so->discarded))
-					break;
-
-				/* Return remaining tuples */
-				so->w = lappend(so->w, HnswGetSearchCandidate(w_node, pairingheap_remove_first(so->discarded)));
-			}
-			/* Prevent scans from consuming too much memory */
-			else if (MemoryContextMemAllocated(so->tmpCtx, false) > so->maxMemory)
-			{
-				if (pairingheap_is_empty(so->discarded))
-				{
-					ereport(DEBUG1,
-							(errmsg("hnsw index scan reached memory limit after " INT64_FORMAT " tuples", so->tuples),
-							 errhint("Increase hnsw.scan_mem_multiplier to scan more tuples.")));
-
-					break;
-				}
-
-				/* Return remaining tuples */
-				so->w = lappend(so->w, HnswGetSearchCandidate(w_node, pairingheap_remove_first(so->discarded)));
-			}
-			else
-			{
-				/*
-				 * Locking ensures when neighbors are read, the elements they
-				 * reference will not be deleted (and replaced) during the
-				 * iteration.
-				 *
-				 * Elements loaded into memory on previous iterations may have
-				 * been deleted (and replaced), so when reading neighbors, the
-				 * element version must be checked.
-				 */
-				LockPage(scan->indexRelation, HNSW_SCAN_LOCK, ShareLock);
-
-				so->w = ResumeScanItems(scan);
-
-				UnlockPage(scan->indexRelation, HNSW_SCAN_LOCK, ShareLock);
-
-#if defined(HNSW_MEMORY)
-				ShowMemoryUsage(so);
-#endif
-			}
-
-			if (list_length(so->w) == 0)
-				break;
-		}
-
-		sc = llast(so->w);
-		element = HnswPtrAccess(base, sc->element);
-
 		/* Move to next element if no valid heap TIDs */
 		if (element->heaptidsLength == 0)
 		{
 			so->w = list_delete_last(so->w);
-
-			/* Mark memory as free for next iteration */
-			if (hnsw_iterative_scan != HNSW_ITERATIVE_SCAN_OFF)
-			{
-				pfree(element);
-				pfree(sc);
-			}
-
 			continue;
 		}
 
 		heaptid = &element->heaptids[--element->heaptidsLength];
 
-		if (hnsw_iterative_scan == HNSW_ITERATIVE_SCAN_STRICT)
-		{
-			if (sc->distance < so->previousDistance)
-				continue;
-
-			so->previousDistance = sc->distance;
-		}
-
 		MemoryContextSwitchTo(oldCtx);
 
 		scan->xs_heaptid = *heaptid;

src/hnswvacuum.c

@@ -184,12 +184,13 @@ static void
 RepairGraphElement(HnswVacuumState * vacuumstate, HnswElement element, HnswElement entryPoint)
 {
 	Relation	index = vacuumstate->index;
-	HnswSupport *support = &vacuumstate->support;
 	Buffer		buf;
 	Page		page;
 	GenericXLogState *state;
 	int			m = vacuumstate->m;
 	int			efConstruction = vacuumstate->efConstruction;
+	FmgrInfo   *procinfo = vacuumstate->procinfo;
+	Oid			collation = vacuumstate->collation;
 	BufferAccessStrategy bas = vacuumstate->bas;
 	HnswNeighborTuple ntup = vacuumstate->ntup;
 	Size		ntupSize = HNSW_NEIGHBOR_TUPLE_SIZE(element->level, m);
@@ -204,7 +205,7 @@ RepairGraphElement(HnswVacuumState * vacuumstate, HnswElement element, HnswEleme
 	element->heaptidsLength = 0;
 
 	/* Find neighbors for element, skipping itself */
-	HnswFindElementNeighbors(base, element, entryPoint, index, support, m, efConstruction, true);
+	HnswFindElementNeighbors(base, element, entryPoint, index, procinfo, collation, m, efConstruction, true);
 
 	/* Zero memory for each element */
 	MemSet(ntup, 0, HNSW_TUPLE_ALLOC_SIZE);
@@ -228,7 +229,7 @@ RepairGraphElement(HnswVacuumState * vacuumstate, HnswElement element, HnswEleme
 	UnlockReleaseBuffer(buf);
 
 	/* Update neighbors */
-	HnswUpdateNeighborsOnDisk(index, support, element, m, true, false);
+	HnswUpdateNeighborsOnDisk(index, procinfo, collation, element, m, true, false);
 }
 
 /*
@@ -238,7 +239,6 @@ static void
 RepairGraphEntryPoint(HnswVacuumState * vacuumstate)
 {
 	Relation	index = vacuumstate->index;
-	HnswSupport *support = &vacuumstate->support;
 	HnswElement highestPoint = &vacuumstate->highestPoint;
 	HnswElement entryPoint;
 	MemoryContext oldCtx = MemoryContextSwitchTo(vacuumstate->tmpCtx);
@@ -256,7 +256,7 @@ RepairGraphEntryPoint(HnswVacuumState * vacuumstate)
 		LockPage(index, HNSW_UPDATE_LOCK, ShareLock);
 
 		/* Load element */
-		HnswLoadElement(highestPoint, NULL, NULL, index, support, true, NULL);
+		HnswLoadElement(highestPoint, NULL, NULL, index, vacuumstate->procinfo, vacuumstate->collation, true);
 
 		/* Repair if needed */
 		if (NeedsUpdated(vacuumstate, highestPoint))
@@ -294,7 +294,7 @@ 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, support, true, NULL);
+			HnswLoadElement(entryPoint, NULL, NULL, index, vacuumstate->procinfo, vacuumstate->collation, true);
 
 			if (NeedsUpdated(vacuumstate, entryPoint))
 			{
@@ -527,14 +527,6 @@ MarkDeleted(HnswVacuumState * vacuumstate)
 			for (int i = 0; i < ntup->count; i++)
 				ItemPointerSetInvalid(&ntup->indextids[i]);
 
-			/* Increment version */
-			/* This is used to avoid incorrect reads for iterative scans */
-			/* Reserve some bits for future use */
-			etup->version++;
-			if (etup->version > 15)
-				etup->version = 1;
-			ntup->version = etup->version;
-
 			/*
 			 * We modified the tuples in place, no need to call
 			 * PageIndexTupleOverwrite
@@ -581,13 +573,13 @@ InitVacuumState(HnswVacuumState * vacuumstate, IndexVacuumInfo *info, IndexBulkD
 	vacuumstate->callback_state = callback_state;
 	vacuumstate->efConstruction = HnswGetEfConstruction(index);
 	vacuumstate->bas = GetAccessStrategy(BAS_BULKREAD);
+	vacuumstate->procinfo = index_getprocinfo(index, 1, HNSW_DISTANCE_PROC);
+	vacuumstate->collation = index->rd_indcollation[0];
 	vacuumstate->ntup = palloc0(HNSW_TUPLE_ALLOC_SIZE);
 	vacuumstate->tmpCtx = AllocSetContextCreate(CurrentMemoryContext,
 												"Hnsw vacuum temporary context",
 												ALLOCSET_DEFAULT_SIZES);
 
-	HnswInitSupport(&vacuumstate->support, index);
-
 	/* Get m from metapage */
 	HnswGetMetaPageInfo(index, &vacuumstate->m, NULL);
 

src/ivfbuild.c

@@ -6,7 +6,7 @@
 #include "access/tableam.h"
 #include "access/parallel.h"
 #include "access/xact.h"
-#include "bitvec.h"
+#include "bitvector.h"
 #include "catalog/index.h"
 #include "catalog/pg_operator_d.h"
 #include "catalog/pg_type_d.h"
@@ -26,6 +26,12 @@
 #include "pgstat.h"
 #endif
 
+#if PG_VERSION_NUM >= 130000
+#define CALLBACK_ITEM_POINTER ItemPointer tid
+#else
+#define CALLBACK_ITEM_POINTER HeapTuple hup
+#endif
+
 #if PG_VERSION_NUM >= 140000
 #include "utils/backend_status.h"
 #include "utils/wait_event.h"
@@ -54,10 +60,8 @@ AddSample(Datum *values, IvfflatBuildState * buildstate)
 	 */
 	if (buildstate->kmeansnormprocinfo != NULL)
 	{
-		if (!IvfflatCheckNorm(buildstate->kmeansnormprocinfo, buildstate->collation, value))
+		if (!IvfflatNormValue(buildstate->kmeansnormprocinfo, buildstate->collation, &value, buildstate->type))
 			return;
-
-		value = IvfflatNormValue(buildstate->typeInfo, buildstate->collation, value);
 	}
 
 	if (samples->length < targsamples)
@@ -90,7 +94,7 @@ AddSample(Datum *values, IvfflatBuildState * buildstate)
  * Callback for sampling
  */
 static void
-SampleCallback(Relation index, ItemPointer tid, Datum *values,
+SampleCallback(Relation index, CALLBACK_ITEM_POINTER, Datum *values,
 			   bool *isnull, bool tupleIsAlive, void *state)
 {
 	IvfflatBuildState *buildstate = (IvfflatBuildState *) state;
@@ -152,10 +156,8 @@ AddTupleToSort(Relation index, ItemPointer tid, Datum *values, IvfflatBuildState
 	/* Normalize if needed */
 	if (buildstate->normprocinfo != NULL)
 	{
-		if (!IvfflatCheckNorm(buildstate->normprocinfo, buildstate->collation, value))
+		if (!IvfflatNormValue(buildstate->normprocinfo, buildstate->collation, &value, buildstate->type))
 			return;
-
-		value = IvfflatNormValue(buildstate->typeInfo, buildstate->collation, value);
 	}
 
 	/* Find the list that minimizes the distance */
@@ -201,12 +203,16 @@ AddTupleToSort(Relation index, ItemPointer tid, Datum *values, IvfflatBuildState
  * Callback for table_index_build_scan
  */
 static void
-BuildCallback(Relation index, ItemPointer tid, Datum *values,
+BuildCallback(Relation index, CALLBACK_ITEM_POINTER, Datum *values,
 			  bool *isnull, bool tupleIsAlive, void *state)
 {
 	IvfflatBuildState *buildstate = (IvfflatBuildState *) state;
 	MemoryContext oldCtx;
 
+#if PG_VERSION_NUM < 130000
+	ItemPointer tid = &hup->t_self;
+#endif
+
 	/* Skip nulls */
 	if (isnull[0])
 		return;
@@ -228,11 +234,11 @@ BuildCallback(Relation index, ItemPointer tid, Datum *values,
 static inline void
 GetNextTuple(Tuplesortstate *sortstate, TupleDesc tupdesc, TupleTableSlot *slot, IndexTuple *itup, int *list)
 {
+	Datum		value;
+	bool		isnull;
+
 	if (tuplesort_gettupleslot(sortstate, true, false, slot, NULL))
 	{
-		Datum		value;
-		bool		isnull;
-
 		*list = DatumGetInt32(slot_getattr(slot, 1, &isnull));
 		value = slot_getattr(slot, 3, &isnull);
 
@@ -254,8 +260,8 @@ InsertTuples(Relation index, IvfflatBuildState * buildstate, ForkNumber forkNum)
 	IndexTuple	itup = NULL;	/* silence compiler warning */
 	int64		inserted = 0;
 
-	TupleTableSlot *slot = MakeSingleTupleTableSlot(buildstate->sortdesc, &TTSOpsMinimalTuple);
+	TupleTableSlot *slot = MakeSingleTupleTableSlot(buildstate->tupdesc, &TTSOpsMinimalTuple);
-	TupleDesc	tupdesc = buildstate->tupdesc;
+	TupleDesc	tupdesc = RelationGetDescr(index);
 
 	pgstat_progress_update_param(PROGRESS_CREATEIDX_SUBPHASE, PROGRESS_IVFFLAT_PHASE_LOAD);
 
@@ -309,37 +315,62 @@ InsertTuples(Relation index, IvfflatBuildState * buildstate, ForkNumber forkNum)
 	}
 }
 
+/*
+ * Get max dimensions
+ */
+static int
+GetMaxDimensions(IvfflatType type)
+{
+	int			maxDimensions = IVFFLAT_MAX_DIM;
+
+	if (type == IVFFLAT_TYPE_HALFVEC)
+		maxDimensions *= 2;
+	else if (type == IVFFLAT_TYPE_BIT)
+		maxDimensions *= 32;
+
+	return maxDimensions;
+}
+
+/*
+ * Get item size
+ */
+static Size
+GetItemSize(IvfflatType type, int dimensions)
+{
+	if (type == IVFFLAT_TYPE_VECTOR)
+		return VECTOR_SIZE(dimensions);
+	else if (type == IVFFLAT_TYPE_HALFVEC)
+		return HALFVEC_SIZE(dimensions);
+	else if (type == IVFFLAT_TYPE_BIT)
+		return VARBITTOTALLEN(dimensions);
+	else
+		elog(ERROR, "Unsupported type");
+}
+
 /*
  * Initialize the build state
  */
 static void
 InitBuildState(IvfflatBuildState * buildstate, Relation heap, Relation index, IndexInfo *indexInfo)
 {
+	int			maxDimensions;
+
 	buildstate->heap = heap;
 	buildstate->index = index;
 	buildstate->indexInfo = indexInfo;
-	buildstate->typeInfo = IvfflatGetTypeInfo(index);
+	buildstate->type = IvfflatGetType(index);
-	buildstate->tupdesc = RelationGetDescr(index);
 
 	buildstate->lists = IvfflatGetLists(index);
 	buildstate->dimensions = TupleDescAttr(index->rd_att, 0)->atttypmod;
 
-	/* Disallow varbit since require fixed dimensions */
+	maxDimensions = GetMaxDimensions(buildstate->type);
-	if (TupleDescAttr(index->rd_att, 0)->atttypid == VARBITOID)
-		ereport(ERROR,
-				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
-				 errmsg("type not supported for ivfflat index")));
 
 	/* Require column to have dimensions to be indexed */
 	if (buildstate->dimensions < 0)
-		ereport(ERROR,
+		elog(ERROR, "column does not have dimensions");
-				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
-				 errmsg("column does not have dimensions")));
 
-	if (buildstate->dimensions > buildstate->typeInfo->maxDimensions)
+	if (buildstate->dimensions > maxDimensions)
-		ereport(ERROR,
+		elog(ERROR, "column cannot have more than %d dimensions for ivfflat index", maxDimensions);
-				(errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
-				 errmsg("column cannot have more than %d dimensions for ivfflat index", buildstate->typeInfo->maxDimensions)));
 
 	buildstate->reltuples = 0;
 	buildstate->indtuples = 0;
@@ -352,19 +383,17 @@ InitBuildState(IvfflatBuildState * buildstate, Relation heap, Relation index, In
 
 	/* Require more than one dimension for spherical k-means */
 	if (buildstate->kmeansnormprocinfo != NULL && buildstate->dimensions == 1)
-		ereport(ERROR,
+		elog(ERROR, "dimensions must be greater than one for this opclass");
-				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
-				 errmsg("dimensions must be greater than one for this opclass")));
 
 	/* Create tuple description for sorting */
-	buildstate->sortdesc = CreateTemplateTupleDesc(3);
+	buildstate->tupdesc = CreateTemplateTupleDesc(3);
-	TupleDescInitEntry(buildstate->sortdesc, (AttrNumber) 1, "list", INT4OID, -1, 0);
+	TupleDescInitEntry(buildstate->tupdesc, (AttrNumber) 1, "list", INT4OID, -1, 0);
-	TupleDescInitEntry(buildstate->sortdesc, (AttrNumber) 2, "tid", TIDOID, -1, 0);
+	TupleDescInitEntry(buildstate->tupdesc, (AttrNumber) 2, "tid", TIDOID, -1, 0);
-	TupleDescInitEntry(buildstate->sortdesc, (AttrNumber) 3, "vector", buildstate->tupdesc->attrs[0].atttypid, -1, 0);
+	TupleDescInitEntry(buildstate->tupdesc, (AttrNumber) 3, "vector", RelationGetDescr(index)->attrs[0].atttypid, -1, 0);
 
-	buildstate->slot = MakeSingleTupleTableSlot(buildstate->sortdesc, &TTSOpsVirtual);
+	buildstate->slot = MakeSingleTupleTableSlot(buildstate->tupdesc, &TTSOpsVirtual);
 
-	buildstate->centers = VectorArrayInit(buildstate->lists, buildstate->dimensions, buildstate->typeInfo->itemSize(buildstate->dimensions));
+	buildstate->centers = VectorArrayInit(buildstate->lists, buildstate->dimensions, GetItemSize(buildstate->type, buildstate->dimensions));
 	buildstate->listInfo = palloc(sizeof(ListInfo) * buildstate->lists);
 
 	buildstate->tmpCtx = AllocSetContextCreate(CurrentMemoryContext,
@@ -434,7 +463,7 @@ ComputeCenters(IvfflatBuildState * buildstate)
 	}
 
 	/* Calculate centers */
-	IvfflatBench("k-means", IvfflatKmeans(buildstate->index, buildstate->samples, buildstate->centers, buildstate->typeInfo));
+	IvfflatBench("k-means", IvfflatKmeans(buildstate->index, buildstate->samples, buildstate->centers, buildstate->type));
 
 	/* Free samples before we allocate more memory */
 	VectorArrayFree(buildstate->samples);
@@ -489,13 +518,10 @@ 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), VARSIZE_ANY(VectorArrayGet(centers, i)));
+		memcpy(&list->center, VectorArrayGet(centers, i), centers->itemsize);
 
 		/* Ensure free space */
 		if (PageGetFreeSpace(page) < listSize)
@@ -561,20 +587,6 @@ PrintKmeansMetrics(IvfflatBuildState * buildstate)
 }
 #endif
 
-/*
- * Initialize build sort state
- */
-static Tuplesortstate *
-InitBuildSortState(TupleDesc tupdesc, int memory, SortCoordinate coordinate)
-{
-	AttrNumber	attNums[] = {1};
-	Oid			sortOperators[] = {Int4LessOperator};
-	Oid			sortCollations[] = {InvalidOid};
-	bool		nullsFirstFlags[] = {false};
-
-	return tuplesort_begin_heap(tupdesc, 1, attNums, sortOperators, sortCollations, nullsFirstFlags, memory, coordinate, false);
-}
-
 /*
  * Within leader, wait for end of heap scan
  */
@@ -622,6 +634,12 @@ IvfflatParallelScanAndSort(IvfflatSpool * ivfspool, IvfflatShared * ivfshared, S
 	double		reltuples;
 	IndexInfo  *indexInfo;
 
+	/* Sort options, which must match AssignTuples */
+	AttrNumber	attNums[] = {1};
+	Oid			sortOperators[] = {Int4LessOperator};
+	Oid			sortCollations[] = {InvalidOid};
+	bool		nullsFirstFlags[] = {false};
+
 	/* Initialize local tuplesort coordination state */
 	coordinate = palloc0(sizeof(SortCoordinateData));
 	coordinate->isWorker = true;
@@ -634,7 +652,7 @@ IvfflatParallelScanAndSort(IvfflatSpool * ivfspool, IvfflatShared * ivfshared, S
 	InitBuildState(&buildstate, ivfspool->heap, ivfspool->index, indexInfo);
 	memcpy(buildstate.centers->items, ivfcenters, buildstate.centers->itemsize * buildstate.centers->maxlen);
 	buildstate.centers->length = buildstate.centers->maxlen;
-	ivfspool->sortstate = InitBuildSortState(buildstate.sortdesc, sortmem, coordinate);
+	ivfspool->sortstate = tuplesort_begin_heap(buildstate.tupdesc, 1, attNums, sortOperators, sortCollations, nullsFirstFlags, sortmem, coordinate, false);
 	buildstate.sortstate = ivfspool->sortstate;
 	scan = table_beginscan_parallel(ivfspool->heap,
 									ParallelTableScanFromIvfflatShared(ivfshared));
@@ -931,6 +949,12 @@ AssignTuples(IvfflatBuildState * buildstate)
 	int			parallel_workers = 0;
 	SortCoordinate coordinate = NULL;
 
+	/* Sort options, which must match IvfflatParallelScanAndSort */
+	AttrNumber	attNums[] = {1};
+	Oid			sortOperators[] = {Int4LessOperator};
+	Oid			sortCollations[] = {InvalidOid};
+	bool		nullsFirstFlags[] = {false};
+
 	pgstat_progress_update_param(PROGRESS_CREATEIDX_SUBPHASE, PROGRESS_IVFFLAT_PHASE_ASSIGN);
 
 	/* Calculate parallel workers */
@@ -951,7 +975,7 @@ AssignTuples(IvfflatBuildState * buildstate)
 	}
 
 	/* Begin serial/leader tuplesort */
-	buildstate->sortstate = InitBuildSortState(buildstate->sortdesc, maintenance_work_mem, coordinate);
+	buildstate->sortstate = tuplesort_begin_heap(buildstate->tupdesc, 1, attNums, sortOperators, sortCollations, nullsFirstFlags, maintenance_work_mem, coordinate, false);
 
 	/* Add tuples to sort */
 	if (buildstate->heap != NULL)
@@ -1007,10 +1031,6 @@ 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

@@ -7,7 +7,6 @@
 #include "commands/progress.h"
 #include "commands/vacuum.h"
 #include "ivfflat.h"
-#include "utils/float.h"
 #include "utils/guc.h"
 #include "utils/selfuncs.h"
 #include "utils/spccache.h"
@@ -17,16 +16,8 @@
 #endif
 
 int			ivfflat_probes;
-int			ivfflat_iterative_scan;
-int			ivfflat_max_probes;
 static relopt_kind ivfflat_relopt_kind;
 
-static const struct config_enum_entry ivfflat_iterative_scan_options[] = {
-	{"off", IVFFLAT_ITERATIVE_SCAN_OFF, false},
-	{"relaxed_order", IVFFLAT_ITERATIVE_SCAN_RELAXED, false},
-	{NULL, 0, false}
-};
-
 /*
  * Initialize index options and variables
  */
@@ -35,20 +26,15 @@ IvfflatInit(void)
 {
 	ivfflat_relopt_kind = add_reloption_kind();
 	add_int_reloption(ivfflat_relopt_kind, "lists", "Number of inverted lists",
-					  IVFFLAT_DEFAULT_LISTS, IVFFLAT_MIN_LISTS, IVFFLAT_MAX_LISTS, AccessExclusiveLock);
+					  IVFFLAT_DEFAULT_LISTS, IVFFLAT_MIN_LISTS, IVFFLAT_MAX_LISTS
+#if PG_VERSION_NUM >= 130000
+					  ,AccessExclusiveLock
+#endif
+		);
 
 	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, GUC_EXPLAIN, NULL, NULL, NULL);
+							IVFFLAT_DEFAULT_PROBES, IVFFLAT_MIN_LISTS, IVFFLAT_MAX_LISTS, PGC_USERSET, 0, NULL, NULL, NULL);
-
-	DefineCustomEnumVariable("ivfflat.iterative_scan", "Sets the mode for iterative scans",
-							 NULL, &ivfflat_iterative_scan,
-							 IVFFLAT_ITERATIVE_SCAN_OFF, ivfflat_iterative_scan_options, PGC_USERSET, GUC_EXPLAIN, NULL, NULL, NULL);
-
-	/* If this is less than probes, probes is used */
-	DefineCustomIntVariable("ivfflat.max_probes", "Sets the max number of probes for iterative scans",
-							NULL, &ivfflat_max_probes,
-							IVFFLAT_MAX_LISTS, IVFFLAT_MIN_LISTS, IVFFLAT_MAX_LISTS, PGC_USERSET, GUC_EXPLAIN, NULL, NULL, NULL);
 
 	MarkGUCPrefixReserved("ivfflat");
 }
@@ -86,30 +72,22 @@ ivfflatcostestimate(PlannerInfo *root, IndexPath *path, double loop_count,
 	GenericCosts costs;
 	int			lists;
 	double		ratio;
-	double		sequentialRatio = 0.5;
-	double		startupPages;
 	double		spc_seq_page_cost;
 	Relation	index;
 
 	/* Never use index without order */
 	if (path->indexorderbys == NULL)
 	{
-		*indexStartupCost = get_float8_infinity();
+		*indexStartupCost = DBL_MAX;
-		*indexTotalCost = get_float8_infinity();
+		*indexTotalCost = DBL_MAX;
 		*indexSelectivity = 0;
 		*indexCorrelation = 0;
 		*indexPages = 0;
-#if PG_VERSION_NUM >= 180000
-		/* See "On disable_cost" thread on pgsql-hackers */
-		path->path.disabled_nodes = 2;
-#endif
 		return;
 	}
 
 	MemSet(&costs, 0, sizeof(costs));
 
-	genericcostestimate(root, path, loop_count, &costs);
-
 	index = index_open(path->indexinfo->indexoid, NoLock);
 	IvfflatGetMetaPageInfo(index, &lists, NULL);
 	index_close(index, NoLock);
@@ -119,26 +97,41 @@ ivfflatcostestimate(PlannerInfo *root, IndexPath *path, double loop_count,
 	if (ratio > 1.0)
 		ratio = 1.0;
 
+	/*
+	 * This gives us the subset of tuples to visit. This value is passed into
+	 * the generic cost estimator to determine the number of pages to visit
+	 * during the index scan.
+	 */
+	costs.numIndexTuples = path->indexinfo->tuples * ratio;
+
+	genericcostestimate(root, path, loop_count, &costs);
+
 	get_tablespace_page_costs(path->indexinfo->reltablespace, NULL, &spc_seq_page_cost);
 
-	/* Change some page cost from random to sequential */
-	costs.indexTotalCost -= sequentialRatio * costs.numIndexPages * (costs.spc_random_page_cost - spc_seq_page_cost);
-
-	/* Startup cost is cost before returning the first row */
-	costs.indexStartupCost = costs.indexTotalCost * ratio;
-
 	/* Adjust cost if needed since TOAST not included in seq scan cost */
-	startupPages = costs.numIndexPages * ratio;
+	if (costs.numIndexPages > path->indexinfo->rel->pages && ratio < 0.5)
-	if (startupPages > path->indexinfo->rel->pages && ratio < 0.5)
 	{
-		/* Change rest of page cost from random to sequential */
+		/* Change all page cost from random to sequential */
-		costs.indexStartupCost -= (1 - sequentialRatio) * startupPages * (costs.spc_random_page_cost - spc_seq_page_cost);
+		costs.indexTotalCost -= costs.numIndexPages * (costs.spc_random_page_cost - spc_seq_page_cost);
 
 		/* Remove cost of extra pages */
-		costs.indexStartupCost -= (startupPages - path->indexinfo->rel->pages) * spc_seq_page_cost;
+		costs.indexTotalCost -= (costs.numIndexPages - path->indexinfo->rel->pages) * spc_seq_page_cost;
+	}
+	else
+	{
+		/* Change some page cost from random to sequential */
+		costs.indexTotalCost -= 0.5 * costs.numIndexPages * (costs.spc_random_page_cost - spc_seq_page_cost);
 	}
 
-	*indexStartupCost = costs.indexStartupCost;
+	/*
+	 * If the list selectivity is lower than what is returned from the generic
+	 * cost estimator, use that.
+	 */
+	if (ratio < costs.indexSelectivity)
+		costs.indexSelectivity = ratio;
+
+	/* Use total cost since most work happens before first tuple is returned */
+	*indexStartupCost = costs.indexTotalCost;
 	*indexTotalCost = costs.indexTotalCost;
 	*indexSelectivity = costs.indexSelectivity;
 	*indexCorrelation = costs.indexCorrelation;
@@ -155,10 +148,23 @@ ivfflatoptions(Datum reloptions, bool validate)
 		{"lists", RELOPT_TYPE_INT, offsetof(IvfflatOptions, lists)},
 	};
 
+#if PG_VERSION_NUM >= 130000
 	return (bytea *) build_reloptions(reloptions, validate,
 									  ivfflat_relopt_kind,
 									  sizeof(IvfflatOptions),
 									  tab, lengthof(tab));
+#else
+	relopt_value *options;
+	int			numoptions;
+	IvfflatOptions *rdopts;
+
+	options = parseRelOptions(reloptions, validate, ivfflat_relopt_kind, &numoptions);
+	rdopts = allocateReloptStruct(sizeof(IvfflatOptions), options, numoptions);
+	fillRelOptions((void *) rdopts, sizeof(IvfflatOptions), options, numoptions,
+				   validate, tab, lengthof(tab));
+
+	return (bytea *) rdopts;
+#endif
 }
 
 /*
@@ -175,15 +181,17 @@ ivfflatvalidate(Oid opclassoid)
  *
  * See https://www.postgresql.org/docs/current/index-api.html
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(ivfflathandler);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(ivfflathandler);
 Datum
 ivfflathandler(PG_FUNCTION_ARGS)
 {
 	IndexAmRoutine *amroutine = makeNode(IndexAmRoutine);
 
 	amroutine->amstrategies = 0;
-	amroutine->amsupport = 5;
+	amroutine->amsupport = 4;
+#if PG_VERSION_NUM >= 130000
 	amroutine->amoptsprocnum = 0;
+#endif
 	amroutine->amcanorder = false;
 	amroutine->amcanorderbyop = true;
 	amroutine->amcanbackward = false;	/* can change direction mid-scan */
@@ -196,24 +204,17 @@ ivfflathandler(PG_FUNCTION_ARGS)
 	amroutine->amclusterable = false;
 	amroutine->ampredlocks = false;
 	amroutine->amcanparallel = false;
-#if PG_VERSION_NUM >= 170000
-	amroutine->amcanbuildparallel = true;
-#endif
 	amroutine->amcaninclude = false;
+#if PG_VERSION_NUM >= 130000
 	amroutine->amusemaintenanceworkmem = false; /* not used during VACUUM */
-#if PG_VERSION_NUM >= 160000
-	amroutine->amsummarizing = false;
-#endif
 	amroutine->amparallelvacuumoptions = VACUUM_OPTION_PARALLEL_BULKDEL;
+#endif
 	amroutine->amkeytype = InvalidOid;
 
 	/* Interface functions */
 	amroutine->ambuild = ivfflatbuild;
 	amroutine->ambuildempty = ivfflatbuildempty;
 	amroutine->aminsert = ivfflatinsert;
-#if PG_VERSION_NUM >= 170000
-	amroutine->aminsertcleanup = NULL;
-#endif
 	amroutine->ambulkdelete = ivfflatbulkdelete;
 	amroutine->amvacuumcleanup = ivfflatvacuumcleanup;
 	amroutine->amcanreturn = NULL;	/* tuple not included in heapsort */

src/ivfflat.h

@@ -28,7 +28,6 @@
 #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
@@ -44,6 +43,13 @@
 #define IVFFLAT_MAX_LISTS		32768
 #define IVFFLAT_DEFAULT_PROBES	1
 
+typedef enum IvfflatType
+{
+	IVFFLAT_TYPE_VECTOR,
+	IVFFLAT_TYPE_HALFVEC,
+	IVFFLAT_TYPE_BIT
+}			IvfflatType;
+
 /* Build phases */
 /* PROGRESS_CREATEIDX_SUBPHASE_INITIALIZE is 1 */
 #define PROGRESS_IVFFLAT_PHASE_KMEANS	2
@@ -80,14 +86,6 @@
 
 /* Variables */
 extern int	ivfflat_probes;
-extern int	ivfflat_iterative_scan;
-extern int	ivfflat_max_probes;
-
-typedef enum IvfflatIterativeScanMode
-{
-	IVFFLAT_ITERATIVE_SCAN_OFF,
-	IVFFLAT_ITERATIVE_SCAN_RELAXED
-}			IvfflatIterativeScanMode;
 
 typedef struct VectorArrayData
 {
@@ -157,23 +155,13 @@ typedef struct IvfflatLeader
 	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;
+	IvfflatType type;
-	TupleDesc	tupdesc;
 
 	/* Settings */
 	int			dimensions;
@@ -207,7 +195,7 @@ typedef struct IvfflatBuildState
 
 	/* Sorting */
 	Tuplesortstate *sortstate;
-	TupleDesc	sortdesc;
+	TupleDesc	tupdesc;
 	TupleTableSlot *slot;
 
 	/* Memory */
@@ -254,59 +242,40 @@ typedef struct IvfflatScanList
 
 typedef struct IvfflatScanOpaqueData
 {
-	const		IvfflatTypeInfo *typeInfo;
 	int			probes;
-	int			maxProbes;
 	int			dimensions;
 	bool		first;
-	Datum		value;
-	MemoryContext tmpCtx;
 
 	/* Sorting */
 	Tuplesortstate *sortstate;
 	TupleDesc	tupdesc;
-	TupleTableSlot *vslot;
+	TupleTableSlot *slot;
-	TupleTableSlot *mslot;
+	bool		isnull;
-	BufferAccessStrategy bas;
 
 	/* Support functions */
 	FmgrInfo   *procinfo;
 	FmgrInfo   *normprocinfo;
 	Oid			collation;
-	Datum		(*distfunc) (FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2);
 
 	/* Lists */
 	pairingheap *listQueue;
-	BlockNumber *listPages;
+	IvfflatScanList lists[FLEXIBLE_ARRAY_MEMBER];	/* must come last */
-	int			listIndex;
-	IvfflatScanList *lists;
 }			IvfflatScanOpaqueData;
 
 typedef IvfflatScanOpaqueData * IvfflatScanOpaque;
 
 #define VECTOR_ARRAY_SIZE(_length, _size) (sizeof(VectorArrayData) + (_length) * MAXALIGN(_size))
-
+#define VECTOR_ARRAY_OFFSET(_arr, _offset) ((char*) (_arr)->items + (_offset) * (_arr)->itemsize)
-/* Use functions instead of macros to avoid double evaluation */
+#define VectorArrayGet(_arr, _offset) VECTOR_ARRAY_OFFSET(_arr, _offset)
-
+#define VectorArraySet(_arr, _offset, _val) memcpy(VECTOR_ARRAY_OFFSET(_arr, _offset), _val, (_arr)->itemsize)
-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, Size itemsize);
 void		VectorArrayFree(VectorArray arr);
-void		IvfflatKmeans(Relation index, VectorArray samples, VectorArray centers, const IvfflatTypeInfo * typeInfo);
+void		IvfflatKmeans(Relation index, VectorArray samples, VectorArray centers, IvfflatType type);
 FmgrInfo   *IvfflatOptionalProcInfo(Relation index, uint16 procnum);
-Datum		IvfflatNormValue(const IvfflatTypeInfo * typeInfo, Oid collation, Datum value);
+IvfflatType IvfflatGetType(Relation index);
-bool		IvfflatCheckNorm(FmgrInfo *procinfo, Oid collation, Datum value);
+bool		IvfflatNormValue(FmgrInfo *procinfo, Oid collation, Datum *value, IvfflatType type);
 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);
@@ -316,7 +285,6 @@ 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

@@ -67,7 +67,6 @@ 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;
@@ -86,19 +85,12 @@ InsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heap_tid, R
 	normprocinfo = IvfflatOptionalProcInfo(index, IVFFLAT_NORM_PROC);
 	if (normprocinfo != NULL)
 	{
-		Oid			collation = index->rd_indcollation[0];
+		if (!IvfflatNormValue(normprocinfo, index->rd_indcollation[0], &value, IvfflatGetType(index)))
-
-		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, &value, &insertPage, &listInfo);
+	FindInsertPage(index, values, &insertPage, &listInfo);
 	Assert(BlockNumberIsValid(insertPage));
 	originalInsertPage = insertPage;
 

src/ivfkmeans.c

@@ -3,7 +3,7 @@
 #include <float.h>
 #include <math.h>
 
-#include "bitvec.h"
+#include "bitvector.h"
 #include "halfutils.h"
 #include "halfvec.h"
 #include "ivfflat.h"
@@ -89,59 +89,140 @@ InitCenters(Relation index, VectorArray samples, VectorArray centers, float *low
 }
 
 /*
- * Norm centers
+ * Apply norm to vector
  */
-static void
+static inline void
-NormCenters(const IvfflatTypeInfo * typeInfo, Oid collation, VectorArray centers)
+ApplyNorm(FmgrInfo *normprocinfo, Oid collation, Datum value, IvfflatType type)
 {
-	MemoryContext normCtx = AllocSetContextCreate(CurrentMemoryContext,
+	double		norm = DatumGetFloat8(FunctionCall1Coll(normprocinfo, collation, value));
-												  "Ivfflat norm temporary context",
-												  ALLOCSET_DEFAULT_SIZES);
-	MemoryContext oldCtx = MemoryContextSwitchTo(normCtx);
 
-	for (int j = 0; j < centers->length; j++)
+	/* TODO Handle zero norm */
+	if (norm > 0)
 	{
-		Datum		center = PointerGetDatum(VectorArrayGet(centers, j));
+		if (type == IVFFLAT_TYPE_VECTOR)
-		Datum		newCenter = IvfflatNormValue(typeInfo, collation, center);
+		{
-		Size		size = VARSIZE_ANY(DatumGetPointer(newCenter));
+			Vector	   *vec = DatumGetVector(value);
 
-		if (size > centers->itemsize)
+			for (int i = 0; i < vec->dim; i++)
-			elog(ERROR, "safety check failed");
+				vec->x[i] /= norm;
+		}
+		else if (type == IVFFLAT_TYPE_HALFVEC)
+		{
+			HalfVector *vec = DatumGetHalfVector(value);
 
-		memcpy(DatumGetPointer(center), DatumGetPointer(newCenter), size);
+			for (int i = 0; i < vec->dim; i++)
-		MemoryContextReset(normCtx);
+				vec->x[i] = Float4ToHalfUnchecked(HalfToFloat4(vec->x[i]) / norm);
+		}
+		else
+			elog(ERROR, "Unsupported type");
 	}
-
-	MemoryContextSwitchTo(oldCtx);
-	MemoryContextDelete(normCtx);
 }
 
 /*
- * Quick approach if we have no data
+ * Compare vectors
+ */
+static int
+CompareVectors(const void *a, const void *b)
+{
+	return vector_cmp_internal((Vector *) a, (Vector *) b);
+}
+
+/*
+ * Compare half vectors
+ */
+static int
+CompareHalfVectors(const void *a, const void *b)
+{
+	return halfvec_cmp_internal((HalfVector *) a, (HalfVector *) b);
+}
+
+/*
+ * Compare bit vectors
+ */
+static int
+CompareBitVectors(const void *a, const void *b)
+{
+	return DirectFunctionCall2(bitcmp, VarBitPGetDatum((VarBit *) a), VarBitPGetDatum((VarBit *) b));
+}
+
+/*
+ * Quick approach if we have little data
  */
 static void
-RandomCenters(Relation index, VectorArray centers, const IvfflatTypeInfo * typeInfo)
+QuickCenters(Relation index, VectorArray samples, VectorArray centers, IvfflatType type)
 {
 	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);
+	FmgrInfo   *normprocinfo = IvfflatOptionalProcInfo(index, IVFFLAT_KMEANS_NORM_PROC);
 
-	/* Fill with random data */
+	/* Copy existing vectors while avoiding duplicates */
+	if (samples->length > 0)
+	{
+		if (type == IVFFLAT_TYPE_VECTOR)
+			qsort(samples->items, samples->length, samples->itemsize, CompareVectors);
+		else if (type == IVFFLAT_TYPE_HALFVEC)
+			qsort(samples->items, samples->length, samples->itemsize, CompareHalfVectors);
+		else if (type == IVFFLAT_TYPE_BIT)
+			qsort(samples->items, samples->length, samples->itemsize, CompareBitVectors);
+		else
+			elog(ERROR, "Unsupported type");
+
+		for (int i = 0; i < samples->length; i++)
+		{
+			Datum		vec = PointerGetDatum(VectorArrayGet(samples, i));
+
+			if (i == 0 || !datumIsEqual(vec, PointerGetDatum(VectorArrayGet(samples, i - 1)), false, -1))
+			{
+				VectorArraySet(centers, centers->length, DatumGetPointer(vec));
+				centers->length++;
+			}
+		}
+	}
+
+	/* Fill remaining with random data */
 	while (centers->length < centers->maxlen)
 	{
-		Pointer		center = VectorArrayGet(centers, centers->length);
+		Datum		center = PointerGetDatum(VectorArrayGet(centers, centers->length));
 
-		for (int i = 0; i < dimensions; i++)
+		if (type == IVFFLAT_TYPE_VECTOR)
-			x[i] = (float) RandomDouble();
+		{
+			Vector	   *vec = DatumGetVector(center);
 
-		typeInfo->updateCenter(center, dimensions, x);
+			SET_VARSIZE(vec, VECTOR_SIZE(dimensions));
+			vec->dim = dimensions;
+
+			for (int j = 0; j < dimensions; j++)
+				vec->x[j] = RandomDouble();
+		}
+		else if (type == IVFFLAT_TYPE_HALFVEC)
+		{
+			HalfVector *vec = DatumGetHalfVector(center);
+
+			SET_VARSIZE(vec, HALFVEC_SIZE(dimensions));
+			vec->dim = dimensions;
+
+			for (int j = 0; j < dimensions; j++)
+				vec->x[j] = Float4ToHalfUnchecked((float) RandomDouble());
+		}
+		else if (type == IVFFLAT_TYPE_BIT)
+		{
+			VarBit	   *vec = DatumGetVarBitP(center);
+
+			SET_VARSIZE(vec, VARBITTOTALLEN(dimensions));
+			VARBITLEN(vec) = dimensions;
+
+			for (int j = 0; j < dimensions; j++)
+				VARBITS(vec)[j / dimensions] |= (RandomDouble() > 0.5 ? 1 : 0) << (7 - (j % 8));
+		}
+		else
+			elog(ERROR, "Unsupported type");
+
+		/* Normalize if needed (only needed for random centers) */
+		if (normprocinfo != NULL)
+			ApplyNorm(normprocinfo, collation, center, type);
 
 		centers->length++;
 	}
-
-	if (normprocinfo != NULL)
-		NormCenters(typeInfo, collation, centers);
 }
 
 #ifdef IVFFLAT_MEMORY
@@ -151,63 +232,73 @@ RandomCenters(Relation index, VectorArray centers, const IvfflatTypeInfo * typeI
 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)
+ComputeNewCenters(VectorArray samples, VectorArray aggCenters, VectorArray newCenters, int *centerCounts, int *closestCenters, FmgrInfo *normprocinfo, Oid collation, IvfflatType type)
 {
-	int			dimensions = newCenters->dim;
+	int			dimensions = aggCenters->dim;
-	int			numCenters = newCenters->length;
+	int			numCenters = aggCenters->maxlen;
 	int			numSamples = samples->length;
 
 	/* Reset sum and count */
 	for (int j = 0; j < numCenters; j++)
 	{
-		float	   *x = agg + ((int64) j * dimensions);
+		Vector	   *vec = (Vector *) VectorArrayGet(aggCenters, j);
 
 		for (int k = 0; k < dimensions; k++)
-			x[k] = 0.0;
+			vec->x[k] = 0.0;
 
 		centerCounts[j] = 0;
 	}
 
 	/* Increment sum of closest center */
-	SumCenters(samples, agg, closestCenters, typeInfo);
+	if (type == IVFFLAT_TYPE_VECTOR)
+	{
+		for (int j = 0; j < numSamples; j++)
+		{
+			Vector	   *aggCenter = (Vector *) VectorArrayGet(aggCenters, closestCenters[j]);
+			Vector	   *vec = (Vector *) VectorArrayGet(samples, j);
+
+			for (int k = 0; k < dimensions; k++)
+				aggCenter->x[k] += vec->x[k];
+		}
+	}
+	else if (type == IVFFLAT_TYPE_HALFVEC)
+	{
+		for (int j = 0; j < numSamples; j++)
+		{
+			Vector	   *aggCenter = (Vector *) VectorArrayGet(aggCenters, closestCenters[j]);
+			HalfVector *vec = (HalfVector *) VectorArrayGet(samples, j);
+
+			for (int k = 0; k < dimensions; k++)
+				aggCenter->x[k] += HalfToFloat4(vec->x[k]);
+		}
+	}
+	else if (type == IVFFLAT_TYPE_BIT)
+	{
+		for (int j = 0; j < numSamples; j++)
+		{
+			Vector	   *aggCenter = (Vector *) VectorArrayGet(aggCenters, closestCenters[j]);
+			VarBit	   *vec = (VarBit *) VectorArrayGet(samples, j);
+
+			for (int k = 0; k < dimensions; k++)
+				aggCenter->x[k] += (float) (((VARBITS(vec)[k / 8]) >> (7 - (k % 8))) & 0x01);
+		}
+	}
+	else
+		elog(ERROR, "Unsupported type");
 
 	/* Increment count of closest center */
 	for (int j = 0; j < numSamples; j++)
@@ -216,7 +307,7 @@ ComputeNewCenters(VectorArray samples, float *agg, VectorArray newCenters, int *
 	/* Divide sum by count */
 	for (int j = 0; j < numCenters; j++)
 	{
-		float	   *x = agg + ((int64) j * dimensions);
+		Vector	   *vec = (Vector *) VectorArrayGet(aggCenters, j);
 
 		if (centerCounts[j] > 0)
 		{
@@ -224,27 +315,59 @@ ComputeNewCenters(VectorArray samples, float *agg, VectorArray newCenters, int *
 			/* TODO Update bounds */
 			for (int k = 0; k < dimensions; k++)
 			{
-				if (isinf(x[k]))
+				if (isinf(vec->x[k]))
-					x[k] = x[k] > 0 ? FLT_MAX : -FLT_MAX;
+					vec->x[k] = vec->x[k] > 0 ? FLT_MAX : -FLT_MAX;
 			}
 
 			for (int k = 0; k < dimensions; k++)
-				x[k] /= centerCounts[j];
+				vec->x[k] /= centerCounts[j];
 		}
 		else
 		{
 			/* TODO Handle empty centers properly */
 			for (int k = 0; k < dimensions; k++)
-				x[k] = RandomDouble();
+				vec->x[k] = RandomDouble();
 		}
 	}
 
-	/* Set new centers */
+	/* Set new centers if different from agg centers */
-	UpdateCenters(agg, newCenters, typeInfo);
+	if (type == IVFFLAT_TYPE_HALFVEC)
+	{
+		for (int j = 0; j < numCenters; j++)
+		{
+			Vector	   *aggCenter = (Vector *) VectorArrayGet(aggCenters, j);
+			HalfVector *newCenter = (HalfVector *) VectorArrayGet(newCenters, j);
+
+			for (int k = 0; k < dimensions; k++)
+				newCenter->x[k] = Float4ToHalfUnchecked(aggCenter->x[k]);
+		}
+	}
+	else if (type == IVFFLAT_TYPE_BIT)
+	{
+		for (int j = 0; j < numCenters; j++)
+		{
+			Vector	   *aggCenter = (Vector *) VectorArrayGet(aggCenters, j);
+			VarBit	   *newCenter = (VarBit *) VectorArrayGet(newCenters, j);
+			unsigned char *nx = VARBITS(newCenter);
+
+			for (uint32 k = 0; k < VARBITBYTES(newCenter); k++)
+				nx[k] = 0;
+
+			for (int k = 0; k < dimensions; k++)
+				nx[k / 8] |= (aggCenter->x[k] > 0.5) << (7 - (k % 8));
+		}
+	}
 
 	/* Normalize if needed */
 	if (normprocinfo != NULL)
-		NormCenters(typeInfo, collation, newCenters);
+	{
+		for (int j = 0; j < numCenters; j++)
+		{
+			Datum		newCenter = PointerGetDatum(VectorArrayGet(newCenters, j));
+
+			ApplyNorm(normprocinfo, collation, newCenter, type);
+		}
+	}
 }
 
 /*
@@ -256,7 +379,7 @@ ComputeNewCenters(VectorArray samples, float *agg, VectorArray newCenters, int *
  * https://www.aaai.org/Papers/ICML/2003/ICML03-022.pdf
  */
 static void
-ElkanKmeans(Relation index, VectorArray samples, VectorArray centers, const IvfflatTypeInfo * typeInfo)
+ElkanKmeans(Relation index, VectorArray samples, VectorArray centers, IvfflatType type)
 {
 	FmgrInfo   *procinfo;
 	FmgrInfo   *normprocinfo;
@@ -265,7 +388,7 @@ ElkanKmeans(Relation index, VectorArray samples, VectorArray centers, const Ivff
 	int			numCenters = centers->maxlen;
 	int			numSamples = samples->length;
 	VectorArray newCenters;
-	float	   *agg;
+	VectorArray aggCenters;
 	int		   *centerCounts;
 	int		   *closestCenters;
 	float	   *lowerBound;
@@ -273,12 +396,14 @@ ElkanKmeans(Relation index, VectorArray samples, VectorArray centers, const Ivff
 	float	   *s;
 	float	   *halfcdist;
 	float	   *newcdist;
+	MemoryContext kmeansCtx;
+	MemoryContext oldCtx;
 
 	/* Calculate allocation sizes */
 	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		aggCentersSize = type == IVFFLAT_TYPE_VECTOR ? 0 : VECTOR_ARRAY_SIZE(numCenters, VECTOR_SIZE(dimensions));
 	Size		centerCountsSize = sizeof(int) * numCenters;
 	Size		closestCentersSize = sizeof(int) * numSamples;
 	Size		lowerBoundSize = sizeof(float) * numSamples * numCenters;
@@ -288,7 +413,7 @@ ElkanKmeans(Relation index, VectorArray samples, VectorArray centers, const Ivff
 	Size		newcdistSize = sizeof(float) * numCenters;
 
 	/* Calculate total size */
-	Size		totalSize = samplesSize + centersSize + newCentersSize + aggSize + centerCountsSize + closestCentersSize + lowerBoundSize + upperBoundSize + sSize + halfcdistSize + newcdistSize;
+	Size		totalSize = samplesSize + centersSize + newCentersSize + aggCentersSize + centerCountsSize + closestCentersSize + lowerBoundSize + upperBoundSize + sSize + halfcdistSize + newcdistSize;
 
 	/* Check memory requirements */
 	/* Add one to error message to ceil */
@@ -307,9 +432,14 @@ ElkanKmeans(Relation index, VectorArray samples, VectorArray centers, const Ivff
 	normprocinfo = IvfflatOptionalProcInfo(index, IVFFLAT_KMEANS_NORM_PROC);
 	collation = index->rd_indcollation[0];
 
+	/* Use memory context */
+	kmeansCtx = AllocSetContextCreate(CurrentMemoryContext,
+									  "Ivfflat kmeans temporary context",
+									  ALLOCSET_DEFAULT_SIZES);
+	oldCtx = MemoryContextSwitchTo(kmeansCtx);
+
 	/* 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);
@@ -318,12 +448,49 @@ ElkanKmeans(Relation index, VectorArray samples, VectorArray centers, const Ivff
 	halfcdist = palloc_extended(halfcdistSize, MCXT_ALLOC_HUGE);
 	newcdist = palloc(newcdistSize);
 
-	/* Initialize new centers */
+	aggCenters = VectorArrayInit(numCenters, dimensions, VECTOR_SIZE(dimensions));
-	newCenters = VectorArrayInit(numCenters, dimensions, centers->itemsize);
+	for (int j = 0; j < numCenters; j++)
-	newCenters->length = numCenters;
+	{
+		Vector	   *vec = (Vector *) VectorArrayGet(aggCenters, j);
+
+		SET_VARSIZE(vec, VECTOR_SIZE(dimensions));
+		vec->dim = dimensions;
+	}
+
+	if (type == IVFFLAT_TYPE_VECTOR)
+	{
+		/* Use same centers to save memory */
+		newCenters = aggCenters;
+	}
+	else if (type == IVFFLAT_TYPE_HALFVEC)
+	{
+		newCenters = VectorArrayInit(numCenters, dimensions, centers->itemsize);
+
+		for (int j = 0; j < numCenters; j++)
+		{
+			HalfVector *vec = (HalfVector *) VectorArrayGet(newCenters, j);
+
+			SET_VARSIZE(vec, HALFVEC_SIZE(dimensions));
+			vec->dim = dimensions;
+		}
+	}
+	else if (type == IVFFLAT_TYPE_BIT)
+	{
+		newCenters = VectorArrayInit(numCenters, dimensions, centers->itemsize);
+
+		for (int j = 0; j < numCenters; j++)
+		{
+			VarBit	   *vec = (VarBit *) VectorArrayGet(newCenters, j);
+
+			SET_VARSIZE(vec, VARBITTOTALLEN(dimensions));
+			VARBITLEN(vec) = dimensions;
+		}
+	}
+	else
+		elog(ERROR, "Unsupported type");
 
 #ifdef IVFFLAT_MEMORY
-	ShowMemoryUsage(MemoryContextGetParent(CurrentMemoryContext), totalSize);
+	ShowMemoryUsage(oldCtx, totalSize);
 #endif
 
 	/* Pick initial centers */
@@ -460,7 +627,7 @@ ElkanKmeans(Relation index, VectorArray samples, VectorArray centers, const Ivff
 		}
 
 		/* Step 4: For each center c, let m(c) be mean of all points assigned */
-		ComputeNewCenters(samples, agg, newCenters, centerCounts, closestCenters, normprocinfo, collation, typeInfo);
+		ComputeNewCenters(samples, aggCenters, newCenters, centerCounts, closestCenters, normprocinfo, collation, type);
 
 		/* Step 5 */
 		for (int j = 0; j < numCenters; j++)
@@ -491,68 +658,88 @@ ElkanKmeans(Relation index, VectorArray samples, VectorArray centers, const Ivff
 		if (changes == 0 && iteration != 0)
 			break;
 	}
-}
 
-/*
+	MemoryContextSwitchTo(oldCtx);
- * Ensure no NaN or infinite values
+	MemoryContextDelete(kmeansCtx);
- */
-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, const IvfflatTypeInfo * typeInfo)
+CheckCenters(Relation index, VectorArray centers, IvfflatType type)
 {
+	FmgrInfo   *normprocinfo;
+
 	if (centers->length != centers->maxlen)
 		elog(ERROR, "Not enough centers. Please report a bug.");
 
-	CheckElements(centers, typeInfo);
+	/* Ensure no NaN or infinite values */
-	CheckNorms(centers, index);
+	for (int i = 0; i < centers->length; i++)
+	{
+		if (type == IVFFLAT_TYPE_VECTOR)
+		{
+			Vector	   *vec = (Vector *) 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.");
+			}
+		}
+		else if (type == IVFFLAT_TYPE_HALFVEC)
+		{
+			HalfVector *vec = (HalfVector *) VectorArrayGet(centers, i);
+
+			for (int j = 0; j < vec->dim; j++)
+			{
+				if (HalfIsNan(vec->x[j]))
+					elog(ERROR, "NaN detected. Please report a bug.");
+
+				if (HalfIsInf(vec->x[j]))
+					elog(ERROR, "Infinite value detected. Please report a bug.");
+			}
+		}
+		else if (type != IVFFLAT_TYPE_BIT)
+			elog(ERROR, "Unsupported type");
+	}
+
+	if (type != IVFFLAT_TYPE_BIT)
+	{
+		/* Ensure no duplicate centers */
+		/* Fine to sort in-place */
+		if (type == IVFFLAT_TYPE_VECTOR)
+			qsort(centers->items, centers->length, centers->itemsize, CompareVectors);
+		else if (type == IVFFLAT_TYPE_HALFVEC)
+			qsort(centers->items, centers->length, centers->itemsize, CompareHalfVectors);
+		else
+			elog(ERROR, "Unsupported type");
+
+		for (int i = 1; i < centers->length; i++)
+		{
+			if (datumIsEqual(PointerGetDatum(VectorArrayGet(centers, i)), PointerGetDatum(VectorArrayGet(centers, i - 1)), false, -1))
+				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.");
+		}
+	}
 }
 
 /*
@@ -560,20 +747,12 @@ CheckCenters(Relation index, VectorArray centers, const IvfflatTypeInfo * typeIn
  * We use spherical k-means for inner product and cosine
  */
 void
-IvfflatKmeans(Relation index, VectorArray samples, VectorArray centers, const IvfflatTypeInfo * typeInfo)
+IvfflatKmeans(Relation index, VectorArray samples, VectorArray centers, IvfflatType type)
 {
-	MemoryContext kmeansCtx = AllocSetContextCreate(CurrentMemoryContext,
+	if (samples->length <= centers->maxlen)
-													"Ivfflat kmeans temporary context",
+		QuickCenters(index, samples, centers, type);
-													ALLOCSET_DEFAULT_SIZES);
-	MemoryContext oldCtx = MemoryContextSwitchTo(kmeansCtx);
-
-	if (samples->length == 0)
-		RandomCenters(index, centers, typeInfo);
 	else
-		ElkanKmeans(index, samples, centers, typeInfo);
+		ElkanKmeans(index, samples, centers, type);
 
-	CheckCenters(index, centers, typeInfo);
+	CheckCenters(index, centers, type);
-
-	MemoryContextSwitchTo(oldCtx);
-	MemoryContextDelete(kmeansCtx);
 }

src/ivfscan.c

@@ -3,17 +3,15 @@
 #include <float.h>
 
 #include "access/relscan.h"
+#include "bitvector.h"
 #include "catalog/pg_operator_d.h"
 #include "catalog/pg_type_d.h"
+#include "halfvec.h"
 #include "lib/pairingheap.h"
 #include "ivfflat.h"
 #include "miscadmin.h"
 #include "pgstat.h"
 #include "storage/bufmgr.h"
-#include "utils/memutils.h"
-
-#define GetScanList(ptr) pairingheap_container(IvfflatScanList, ph_node, ptr)
-#define GetScanListConst(ptr) pairingheap_const_container(IvfflatScanList, ph_node, ptr)
 
 /*
  * Compare list distances
@@ -21,10 +19,10 @@
 static int
 CompareLists(const pairingheap_node *a, const pairingheap_node *b, void *arg)
 {
-	if (GetScanListConst(a)->distance > GetScanListConst(b)->distance)
+	if (((const IvfflatScanList *) a)->distance > ((const IvfflatScanList *) b)->distance)
 		return 1;
 
-	if (GetScanListConst(a)->distance < GetScanListConst(b)->distance)
+	if (((const IvfflatScanList *) a)->distance < ((const IvfflatScanList *) b)->distance)
 		return -1;
 
 	return 0;
@@ -60,9 +58,9 @@ GetScanLists(IndexScanDesc scan, Datum value)
 			double		distance;
 
 			/* Use procinfo from the index instead of scan key for performance */
-			distance = DatumGetFloat8(so->distfunc(so->procinfo, so->collation, PointerGetDatum(&list->center), value));
+			distance = DatumGetFloat8(FunctionCall2Coll(so->procinfo, so->collation, PointerGetDatum(&list->center), value));
 
-			if (listCount < so->maxProbes)
+			if (listCount < so->probes)
 			{
 				IvfflatScanList *scanlist;
 
@@ -75,15 +73,15 @@ GetScanLists(IndexScanDesc scan, Datum value)
 				pairingheap_add(so->listQueue, &scanlist->ph_node);
 
 				/* Calculate max distance */
-				if (listCount == so->maxProbes)
+				if (listCount == so->probes)
-					maxDistance = GetScanList(pairingheap_first(so->listQueue))->distance;
+					maxDistance = ((IvfflatScanList *) pairingheap_first(so->listQueue))->distance;
 			}
 			else if (distance < maxDistance)
 			{
 				IvfflatScanList *scanlist;
 
 				/* Remove */
-				scanlist = GetScanList(pairingheap_remove_first(so->listQueue));
+				scanlist = (IvfflatScanList *) pairingheap_remove_first(so->listQueue);
 
 				/* Reuse */
 				scanlist->startPage = list->startPage;
@@ -91,7 +89,7 @@ GetScanLists(IndexScanDesc scan, Datum value)
 				pairingheap_add(so->listQueue, &scanlist->ph_node);
 
 				/* Update max distance */
-				maxDistance = GetScanList(pairingheap_first(so->listQueue))->distance;
+				maxDistance = ((IvfflatScanList *) pairingheap_first(so->listQueue))->distance;
 			}
 		}
 
@@ -99,11 +97,6 @@ GetScanLists(IndexScanDesc scan, Datum value)
 
 		UnlockReleaseBuffer(cbuf);
 	}
-
-	for (int i = listCount - 1; i >= 0; i--)
-		so->listPages[i] = GetScanList(pairingheap_remove_first(so->listQueue))->startPage;
-
-	Assert(pairingheap_is_empty(so->listQueue));
 }
 
 /*
@@ -115,15 +108,19 @@ GetScanItems(IndexScanDesc scan, Datum value)
 	IvfflatScanOpaque so = (IvfflatScanOpaque) scan->opaque;
 	TupleDesc	tupdesc = RelationGetDescr(scan->indexRelation);
 	double		tuples = 0;
-	TupleTableSlot *slot = so->vslot;
+	TupleTableSlot *slot = MakeSingleTupleTableSlot(so->tupdesc, &TTSOpsVirtual);
-	int			batchProbes = 0;
 
-	tuplesort_reset(so->sortstate);
+	/*
+	 * Reuse same set of shared buffers for scan
+	 *
+	 * See postgres/src/backend/storage/buffer/README for description
+	 */
+	BufferAccessStrategy bas = GetAccessStrategy(BAS_BULKREAD);
 
 	/* Search closest probes lists */
-	while (so->listIndex < so->maxProbes && (++batchProbes) <= so->probes)
+	while (!pairingheap_is_empty(so->listQueue))
 	{
-		BlockNumber searchPage = so->listPages[so->listIndex++];
+		BlockNumber searchPage = ((IvfflatScanList *) pairingheap_remove_first(so->listQueue))->startPage;
 
 		/* Search all entry pages for list */
 		while (BlockNumberIsValid(searchPage))
@@ -132,7 +129,7 @@ GetScanItems(IndexScanDesc scan, Datum value)
 			Page		page;
 			OffsetNumber maxoffno;
 
-			buf = ReadBufferExtended(scan->indexRelation, MAIN_FORKNUM, searchPage, RBM_NORMAL, so->bas);
+			buf = ReadBufferExtended(scan->indexRelation, MAIN_FORKNUM, searchPage, RBM_NORMAL, bas);
 			LockBuffer(buf, BUFFER_LOCK_SHARE);
 			page = BufferGetPage(buf);
 			maxoffno = PageGetMaxOffsetNumber(page);
@@ -154,7 +151,7 @@ GetScanItems(IndexScanDesc scan, Datum value)
 				 * performance
 				 */
 				ExecClearTuple(slot);
-				slot->tts_values[0] = so->distfunc(so->procinfo, so->collation, datum, value);
+				slot->tts_values[0] = FunctionCall2Coll(so->procinfo, so->collation, datum, value);
 				slot->tts_isnull[0] = false;
 				slot->tts_values[1] = PointerGetDatum(&itup->t_tid);
 				slot->tts_isnull[1] = false;
@@ -171,26 +168,15 @@ GetScanItems(IndexScanDesc scan, Datum value)
 		}
 	}
 
-	if (tuples < 100 && ivfflat_iterative_scan == IVFFLAT_ITERATIVE_SCAN_OFF)
+	FreeAccessStrategy(bas);
+
+	if (tuples < 100)
 		ereport(DEBUG1,
 				(errmsg("index scan found few tuples"),
 				 errdetail("Index may have been created with little data."),
 				 errhint("Recreate the index and possibly decrease lists.")));
 
 	tuplesort_performsort(so->sortstate);
-
-#if defined(IVFFLAT_MEMORY)
-	elog(INFO, "memory: %zu MB", MemoryContextMemAllocated(CurrentMemoryContext, true) / (1024 * 1024));
-#endif
-}
-
-/*
- * Zero distance
- */
-static Datum
-ZeroDistance(FmgrInfo *flinfo, Oid collation, Datum arg1, Datum arg2)
-{
-	return Float8GetDatum(0.0);
 }
 
 /*
@@ -204,46 +190,33 @@ GetScanValue(IndexScanDesc scan)
 
 	if (scan->orderByData->sk_flags & SK_ISNULL)
 	{
-		value = PointerGetDatum(NULL);
+		IvfflatType type = IvfflatGetType(scan->indexRelation);
-		so->distfunc = ZeroDistance;
+
+		if (type == IVFFLAT_TYPE_VECTOR)
+			value = PointerGetDatum(InitVector(so->dimensions));
+		else if (type == IVFFLAT_TYPE_HALFVEC)
+			value = PointerGetDatum(InitHalfVector(so->dimensions));
+		else if (type == IVFFLAT_TYPE_BIT)
+			value = PointerGetDatum(InitBitVector(so->dimensions));
+		else
+			elog(ERROR, "Unsupported type");
 	}
 	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 */
+		/* Fine if normalization fails */
 		if (so->normprocinfo != NULL)
-		{
+			IvfflatNormValue(so->normprocinfo, so->collation, &value, IvfflatGetType(scan->indexRelation));
-			MemoryContext oldCtx = MemoryContextSwitchTo(so->tmpCtx);
-
-			value = IvfflatNormValue(so->typeInfo, so->collation, value);
-
-			MemoryContextSwitchTo(oldCtx);
-		}
 	}
 
 	return value;
 }
 
-/*
- * Initialize scan sort state
- */
-static Tuplesortstate *
-InitScanSortState(TupleDesc tupdesc)
-{
-	AttrNumber	attNums[] = {1};
-	Oid			sortOperators[] = {Float8LessOperator};
-	Oid			sortCollations[] = {InvalidOid};
-	bool		nullsFirstFlags[] = {false};
-
-	return tuplesort_begin_heap(tupdesc, 1, attNums, sortOperators, sortCollations, nullsFirstFlags, work_mem, NULL, false);
-}
-
 /*
  * Prepare for an index scan
  */
@@ -254,31 +227,23 @@ ivfflatbeginscan(Relation index, int nkeys, int norderbys)
 	IvfflatScanOpaque so;
 	int			lists;
 	int			dimensions;
+	AttrNumber	attNums[] = {1};
+	Oid			sortOperators[] = {Float8LessOperator};
+	Oid			sortCollations[] = {InvalidOid};
+	bool		nullsFirstFlags[] = {false};
 	int			probes = ivfflat_probes;
-	int			maxProbes;
-	MemoryContext oldCtx;
 
 	scan = RelationGetIndexScan(index, nkeys, norderbys);
 
 	/* Get lists and dimensions from metapage */
 	IvfflatGetMetaPageInfo(index, &lists, &dimensions);
 
-	if (ivfflat_iterative_scan != IVFFLAT_ITERATIVE_SCAN_OFF)
-		maxProbes = Max(ivfflat_max_probes, probes);
-	else
-		maxProbes = probes;
-
 	if (probes > lists)
 		probes = lists;
 
-	if (maxProbes > lists)
+	so = (IvfflatScanOpaque) palloc(offsetof(IvfflatScanOpaqueData, lists) + probes * sizeof(IvfflatScanList));
-		maxProbes = lists;
-
-	so = (IvfflatScanOpaque) palloc(sizeof(IvfflatScanOpaqueData));
-	so->typeInfo = IvfflatGetTypeInfo(index);
 	so->first = true;
 	so->probes = probes;
-	so->maxProbes = maxProbes;
 	so->dimensions = dimensions;
 
 	/* Set support functions */
@@ -286,37 +251,17 @@ ivfflatbeginscan(Relation index, int nkeys, int norderbys)
 	so->normprocinfo = IvfflatOptionalProcInfo(index, IVFFLAT_NORM_PROC);
 	so->collation = index->rd_indcollation[0];
 
-	so->tmpCtx = AllocSetContextCreate(CurrentMemoryContext,
-									   "Ivfflat scan temporary context",
-									   ALLOCSET_DEFAULT_SIZES);
-
-	oldCtx = MemoryContextSwitchTo(so->tmpCtx);
-
 	/* Create tuple description for sorting */
 	so->tupdesc = CreateTemplateTupleDesc(2);
 	TupleDescInitEntry(so->tupdesc, (AttrNumber) 1, "distance", FLOAT8OID, -1, 0);
 	TupleDescInitEntry(so->tupdesc, (AttrNumber) 2, "heaptid", TIDOID, -1, 0);
 
 	/* Prep sort */
-	so->sortstate = InitScanSortState(so->tupdesc);
+	so->sortstate = tuplesort_begin_heap(so->tupdesc, 1, attNums, sortOperators, sortCollations, nullsFirstFlags, work_mem, NULL, false);
 
-	/* Need separate slots for puttuple and gettuple */
+	so->slot = MakeSingleTupleTableSlot(so->tupdesc, &TTSOpsMinimalTuple);
-	so->vslot = MakeSingleTupleTableSlot(so->tupdesc, &TTSOpsVirtual);
-	so->mslot = MakeSingleTupleTableSlot(so->tupdesc, &TTSOpsMinimalTuple);
-
-	/*
-	 * Reuse same set of shared buffers for scan
-	 *
-	 * See postgres/src/backend/storage/buffer/README for description
-	 */
-	so->bas = GetAccessStrategy(BAS_BULKREAD);
 
 	so->listQueue = pairingheap_allocate(CompareLists, scan);
-	so->listPages = palloc(maxProbes * sizeof(BlockNumber));
-	so->listIndex = 0;
-	so->lists = palloc(maxProbes * sizeof(IvfflatScanList));
-
-	MemoryContextSwitchTo(oldCtx);
 
 	scan->opaque = so;
 
@@ -331,9 +276,13 @@ ivfflatrescan(IndexScanDesc scan, ScanKey keys, int nkeys, ScanKey orderbys, int
 {
 	IvfflatScanOpaque so = (IvfflatScanOpaque) scan->opaque;
 
+#if PG_VERSION_NUM >= 130000
+	if (!so->first)
+		tuplesort_reset(so->sortstate);
+#endif
+
 	so->first = true;
 	pairingheap_reset(so->listQueue);
-	so->listIndex = 0;
 
 	if (keys && scan->numberOfKeys > 0)
 		memmove(scan->keyData, keys, scan->numberOfKeys * sizeof(ScanKeyData));
@@ -349,8 +298,6 @@ bool
 ivfflatgettuple(IndexScanDesc scan, ScanDirection dir)
 {
 	IvfflatScanOpaque so = (IvfflatScanOpaque) scan->opaque;
-	ItemPointer heaptid;
-	bool		isnull;
 
 	/*
 	 * Index can be used to scan backward, but Postgres doesn't support
@@ -378,23 +325,23 @@ ivfflatgettuple(IndexScanDesc scan, ScanDirection dir)
 		IvfflatBench("GetScanLists", GetScanLists(scan, value));
 		IvfflatBench("GetScanItems", GetScanItems(scan, value));
 		so->first = false;
-		so->value = value;
+
+		/* Clean up if we allocated a new value */
+		if (value != scan->orderByData->sk_argument)
+			pfree(DatumGetPointer(value));
 	}
 
-	while (!tuplesort_gettupleslot(so->sortstate, true, false, so->mslot, NULL))
+	if (tuplesort_gettupleslot(so->sortstate, true, false, so->slot, NULL))
 	{
-		if (so->listIndex == so->maxProbes)
+		ItemPointer heaptid = (ItemPointer) DatumGetPointer(slot_getattr(so->slot, 2, &so->isnull));
-			return false;
 
-		IvfflatBench("GetScanItems", GetScanItems(scan, so->value));
+		scan->xs_heaptid = *heaptid;
+		scan->xs_recheck = false;
+		scan->xs_recheckorderby = false;
+		return true;
 	}
 
-	heaptid = (ItemPointer) DatumGetPointer(slot_getattr(so->mslot, 2, &isnull));
+	return false;
-
-	scan->xs_heaptid = *heaptid;
-	scan->xs_recheck = false;
-	scan->xs_recheckorderby = false;
-	return true;
 }
 
 /*
@@ -405,11 +352,9 @@ ivfflatendscan(IndexScanDesc scan)
 {
 	IvfflatScanOpaque so = (IvfflatScanOpaque) scan->opaque;
 
-	/* Free any temporary files */
+	pairingheap_free(so->listQueue);
 	tuplesort_end(so->sortstate);
 
-	MemoryContextDelete(so->tmpCtx);
-
 	pfree(so);
 	scan->opaque = NULL;
 }

src/ivfutils.c

@@ -1,13 +1,14 @@
 #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"
+#include "utils/syscache.h"
 
 /*
  * Allocate a vector array
@@ -65,21 +66,65 @@ IvfflatOptionalProcInfo(Relation index, uint16 procnum)
 }
 
 /*
- * Normalize value
+ * Get type
  */
-Datum
+IvfflatType
-IvfflatNormValue(const IvfflatTypeInfo * typeInfo, Oid collation, Datum value)
+IvfflatGetType(Relation index)
 {
-	return DirectFunctionCall1Coll(typeInfo->normalize, collation, value);
+	Oid			typid = TupleDescAttr(index->rd_att, 0)->atttypid;
+	HeapTuple	tuple;
+	Form_pg_type type;
+	IvfflatType result;
+
+	if (typid == BITOID)
+		return IVFFLAT_TYPE_BIT;
+
+	tuple = SearchSysCache1(TYPEOID, ObjectIdGetDatum(typid));
+	if (!HeapTupleIsValid(tuple))
+		elog(ERROR, "cache lookup failed for type %u", typid);
+
+	type = (Form_pg_type) GETSTRUCT(tuple);
+	if (strcmp(NameStr(type->typname), "vector") == 0)
+		result = IVFFLAT_TYPE_VECTOR;
+	else if (strcmp(NameStr(type->typname), "halfvec") == 0)
+		result = IVFFLAT_TYPE_HALFVEC;
+	else
+	{
+		ReleaseSysCache(tuple);
+		elog(ERROR, "type not supported for ivfflat index");
+	}
+
+	ReleaseSysCache(tuple);
+
+	return result;
 }
 
 /*
- * Check if non-zero norm
+ * 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
  */
 bool
-IvfflatCheckNorm(FmgrInfo *procinfo, Oid collation, Datum value)
+IvfflatNormValue(FmgrInfo *procinfo, Oid collation, Datum *value, IvfflatType type)
 {
-	return DatumGetFloat8(FunctionCall1Coll(procinfo, collation, value)) > 0;
+	double		norm = DatumGetFloat8(FunctionCall1Coll(procinfo, collation, *value));
+
+	if (norm > 0)
+	{
+		if (type == IVFFLAT_TYPE_VECTOR)
+			*value = DirectFunctionCall1(l2_normalize, *value);
+		else if (type == IVFFLAT_TYPE_HALFVEC)
+			*value = DirectFunctionCall1(halfvec_l2_normalize, *value);
+		else
+			elog(ERROR, "Unsupported type");
+
+		return true;
+	}
+
+	return false;
 }
 
 /*
@@ -170,11 +215,7 @@ IvfflatGetMetaPageInfo(Relation index, int *lists, int *dimensions)
 	page = BufferGetPage(buf);
 	metap = IvfflatPageGetMeta(page);
 
-	if (unlikely(metap->magicNumber != IVFFLAT_MAGIC_NUMBER))
+	*lists = metap->lists;
-		elog(ERROR, "ivfflat index is not valid");
-
-	if (lists != NULL)
-		*lists = metap->lists;
 
 	if (dimensions != NULL)
 		*dimensions = metap->dimensions;
@@ -228,146 +269,3 @@ 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

@@ -26,7 +26,7 @@ ivfflatbulkdelete(IndexVacuumInfo *info, IndexBulkDeleteResult *stats,
 		Page		cpage;
 		OffsetNumber coffno;
 		OffsetNumber cmaxoffno;
-		BlockNumber listPages[MaxOffsetNumber];
+		BlockNumber startPages[MaxOffsetNumber];
 		ListInfo	listInfo;
 
 		cbuf = ReadBuffer(index, blkno);
@@ -40,7 +40,7 @@ ivfflatbulkdelete(IndexVacuumInfo *info, IndexBulkDeleteResult *stats,
 		{
 			IvfflatList list = (IvfflatList) PageGetItem(cpage, PageGetItemId(cpage, coffno));
 
-			listPages[coffno - FirstOffsetNumber] = list->startPage;
+			startPages[coffno - FirstOffsetNumber] = list->startPage;
 		}
 
 		listInfo.blkno = blkno;
@@ -50,7 +50,7 @@ ivfflatbulkdelete(IndexVacuumInfo *info, IndexBulkDeleteResult *stats,
 
 		for (coffno = FirstOffsetNumber; coffno <= cmaxoffno; coffno = OffsetNumberNext(coffno))
 		{
-			BlockNumber searchPage = listPages[coffno - FirstOffsetNumber];
+			BlockNumber searchPage = startPages[coffno - FirstOffsetNumber];
 			BlockNumber insertPage = InvalidBlockNumber;
 
 			/* Iterate over entry pages */

src/sparsevec.c

@@ -3,16 +3,11 @@
 #include <limits.h>
 #include <math.h>
 
-#include "catalog/pg_type.h"
-#include "common/string.h"
 #include "fmgr.h"
-#include "halfutils.h"
-#include "halfvec.h"
 #include "libpq/pqformat.h"
 #include "sparsevec.h"
 #include "utils/array.h"
 #include "utils/builtins.h"
-#include "utils/lsyscache.h"
 #include "vector.h"
 
 #if PG_VERSION_NUM >= 120000
@@ -23,12 +18,6 @@
 #include "utils/builtins.h"
 #endif
 
-typedef struct SparseInputElement
-{
-	int32		index;
-	float		value;
-}			SparseInputElement;
-
 /*
  * Ensure same dimensions
  */
@@ -100,24 +89,27 @@ CheckIndex(int32 *indices, int i, int dim)
 {
 	int32		index = indices[i];
 
-	if (index < 0 || index >= dim)
+	if (index < 1)
-	{
 		ereport(ERROR,
 				(errcode(ERRCODE_DATA_EXCEPTION),
-				 errmsg("sparsevec index out of bounds")));
+				 errmsg("index must be greater than zero")));
-	}
+
+	if (index > dim)
+		ereport(ERROR,
+				(errcode(ERRCODE_DATA_EXCEPTION),
+				 errmsg("index must be less than or equal to dimensions")));
 
 	if (i > 0)
 	{
 		if (index < indices[i - 1])
 			ereport(ERROR,
 					(errcode(ERRCODE_DATA_EXCEPTION),
-					 errmsg("sparsevec indices must be in ascending order")));
+					 errmsg("indexes must be in ascending order")));
 
 		if (index == indices[i - 1])
 			ereport(ERROR,
 					(errcode(ERRCODE_DATA_EXCEPTION),
-					 errmsg("sparsevec indices must not contain duplicates")));
+					 errmsg("indexes must not contain duplicates")));
 	}
 }
 
@@ -172,36 +164,22 @@ sparsevec_isspace(char ch)
 	return false;
 }
 
-/*
- * Compare indices
- */
-static int
-CompareIndices(const void *a, const void *b)
-{
-	if (((SparseInputElement *) a)->index < ((SparseInputElement *) b)->index)
-		return -1;
-
-	if (((SparseInputElement *) a)->index > ((SparseInputElement *) b)->index)
-		return 1;
-
-	return 0;
-}
-
 /*
  * Convert textual representation to internal representation
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(sparsevec_in);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(sparsevec_in);
 Datum
 sparsevec_in(PG_FUNCTION_ARGS)
 {
 	char	   *lit = PG_GETARG_CSTRING(0);
 	int32		typmod = PG_GETARG_INT32(2);
-	long		dim;
+	int			dim;
 	char	   *pt = lit;
 	char	   *stringEnd;
 	SparseVector *result;
 	float	   *rvalues;
-	SparseInputElement *elements;
+	int32	   *indices;
+	float	   *values;
 	int			maxNnz;
 	int			nnz = 0;
 
@@ -219,7 +197,8 @@ sparsevec_in(PG_FUNCTION_ARGS)
 				(errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
 				 errmsg("sparsevec cannot have more than %d non-zero elements", SPARSEVEC_MAX_NNZ)));
 
-	elements = palloc(maxNnz * sizeof(SparseInputElement));
+	indices = palloc(maxNnz * sizeof(int32));
+	values = palloc(maxNnz * sizeof(float));
 
 	pt = lit;
 
@@ -246,6 +225,7 @@ sparsevec_in(PG_FUNCTION_ARGS)
 			long		index;
 			float		value;
 
+			/* TODO Better error */
 			if (nnz == maxNnz)
 				ereport(ERROR,
 						(errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
@@ -261,6 +241,7 @@ sparsevec_in(PG_FUNCTION_ARGS)
 						 errmsg("invalid input syntax for type sparsevec: \"%s\"", lit)));
 
 			/* Use similar logic as int2vectorin */
+			errno = 0;
 			index = strtol(pt, &stringEnd, 10);
 
 			if (stringEnd == pt)
@@ -268,11 +249,10 @@ sparsevec_in(PG_FUNCTION_ARGS)
 						(errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
 						 errmsg("invalid input syntax for type sparsevec: \"%s\"", lit)));
 
-			/* Keep in int range for correct error message later */
+			if (errno == ERANGE || index < 1 || index > INT_MAX)
-			if (index > INT_MAX)
+				ereport(ERROR,
-				index = INT_MAX;
+						(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
-			else if (index < INT_MIN + 1)
+						 errmsg("index \"%ld\" is out of range for type sparsevec", index)));
-				index = INT_MIN + 1;
 
 			pt = stringEnd;
 
@@ -311,9 +291,8 @@ sparsevec_in(PG_FUNCTION_ARGS)
 			/* Do not store zero values */
 			if (value != 0)
 			{
-				/* Convert 1-based numbering (SQL) to 0-based (C) */
+				indices[nnz] = index;
-				elements[nnz].index = index - 1;
+				values[nnz] = value;
-				elements[nnz].value = value;
 				nnz++;
 			}
 
@@ -351,6 +330,7 @@ sparsevec_in(PG_FUNCTION_ARGS)
 		pt++;
 
 	/* Use similar logic as int2vectorin */
+	errno = 0;
 	dim = strtol(pt, &stringEnd, 10);
 
 	if (stringEnd == pt)
@@ -358,12 +338,6 @@ sparsevec_in(PG_FUNCTION_ARGS)
 				(errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
 				 errmsg("invalid input syntax for type sparsevec: \"%s\"", lit)));
 
-	/* Keep in int range for correct error message later */
-	if (dim > INT_MAX)
-		dim = INT_MAX;
-	else if (dim < INT_MIN)
-		dim = INT_MIN;
-
 	pt = stringEnd;
 
 	/* Only whitespace is allowed after the closing brace */
@@ -379,14 +353,12 @@ sparsevec_in(PG_FUNCTION_ARGS)
 	CheckDim(dim);
 	CheckExpectedDim(typmod, dim);
 
-	qsort(elements, nnz, sizeof(SparseInputElement), CompareIndices);
-
 	result = InitSparseVector(dim, nnz);
 	rvalues = SPARSEVEC_VALUES(result);
 	for (int i = 0; i < nnz; i++)
 	{
-		result->indices[i] = elements[i].index;
+		result->indices[i] = indices[i];
-		rvalues[i] = elements[i].value;
+		rvalues[i] = values[i];
 
 		CheckIndex(result->indices, i, dim);
 	}
@@ -411,7 +383,7 @@ sparsevec_in(PG_FUNCTION_ARGS)
 /*
  * Convert internal representation to textual representation
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(sparsevec_out);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(sparsevec_out);
 Datum
 sparsevec_out(PG_FUNCTION_ARGS)
 {
@@ -446,8 +418,7 @@ sparsevec_out(PG_FUNCTION_ARGS)
 		if (i > 0)
 			AppendChar(ptr, ',');
 
-		/* Convert 0-based numbering (C) to 1-based (SQL) */
+		AppendInt(ptr, sparsevec->indices[i]);
-		AppendInt(ptr, sparsevec->indices[i] + 1);
 		AppendChar(ptr, ':');
 		AppendFloat(ptr, values[i]);
 	}
@@ -464,7 +435,7 @@ sparsevec_out(PG_FUNCTION_ARGS)
 /*
  * Convert type modifier
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(sparsevec_typmod_in);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(sparsevec_typmod_in);
 Datum
 sparsevec_typmod_in(PG_FUNCTION_ARGS)
 {
@@ -495,7 +466,7 @@ sparsevec_typmod_in(PG_FUNCTION_ARGS)
 /*
  * Convert external binary representation to internal representation
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(sparsevec_recv);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(sparsevec_recv);
 Datum
 sparsevec_recv(PG_FUNCTION_ARGS)
 {
@@ -523,7 +494,6 @@ sparsevec_recv(PG_FUNCTION_ARGS)
 	result = InitSparseVector(dim, nnz);
 	values = SPARSEVEC_VALUES(result);
 
-	/* Binary representation uses zero-based numbering for indices */
 	for (int i = 0; i < nnz; i++)
 	{
 		result->indices[i] = pq_getmsgint(buf, sizeof(int32));
@@ -534,11 +504,6 @@ sparsevec_recv(PG_FUNCTION_ARGS)
 	{
 		values[i] = pq_getmsgfloat4(buf);
 		CheckElement(values[i]);
-
-		if (values[i] == 0)
-			ereport(ERROR,
-					(errcode(ERRCODE_DATA_EXCEPTION),
-					 errmsg("binary representation of sparsevec cannot contain zero values")));
 	}
 
 	PG_RETURN_POINTER(result);
@@ -547,7 +512,7 @@ sparsevec_recv(PG_FUNCTION_ARGS)
 /*
  * Convert internal representation to the external binary representation
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(sparsevec_send);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(sparsevec_send);
 Datum
 sparsevec_send(PG_FUNCTION_ARGS)
 {
@@ -559,11 +524,8 @@ sparsevec_send(PG_FUNCTION_ARGS)
 	pq_sendint(&buf, svec->dim, sizeof(int32));
 	pq_sendint(&buf, svec->nnz, sizeof(int32));
 	pq_sendint(&buf, svec->unused, sizeof(int32));
-
-	/* Binary representation uses zero-based numbering for indices */
 	for (int i = 0; i < svec->nnz; i++)
 		pq_sendint(&buf, svec->indices[i], sizeof(int32));
-
 	for (int i = 0; i < svec->nnz; i++)
 		pq_sendfloat4(&buf, values[i]);
 
@@ -574,7 +536,7 @@ sparsevec_send(PG_FUNCTION_ARGS)
  * Convert sparse vector to sparse vector
  * This is needed to check the type modifier
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(sparsevec);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(sparsevec);
 Datum
 sparsevec(PG_FUNCTION_ARGS)
 {
@@ -589,7 +551,7 @@ sparsevec(PG_FUNCTION_ARGS)
 /*
  * Convert dense vector to sparse vector
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(vector_to_sparsevec);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(vector_to_sparsevec);
 Datum
 vector_to_sparsevec(PG_FUNCTION_ARGS)
 {
@@ -620,7 +582,7 @@ vector_to_sparsevec(PG_FUNCTION_ARGS)
 			if (j >= result->nnz)
 				elog(ERROR, "safety check failed");
 
-			result->indices[j] = i;
+			result->indices[j] = i + 1;
 			values[j] = vec->x[i];
 			j++;
 		}
@@ -629,180 +591,6 @@ vector_to_sparsevec(PG_FUNCTION_ARGS)
 	PG_RETURN_POINTER(result);
 }
 
-/*
- * Convert half vector to sparse vector
- */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(halfvec_to_sparsevec);
-Datum
-halfvec_to_sparsevec(PG_FUNCTION_ARGS)
-{
-	HalfVector *vec = PG_GETARG_HALFVEC_P(0);
-	int32		typmod = PG_GETARG_INT32(1);
-	SparseVector *result;
-	int			dim = vec->dim;
-	int			nnz = 0;
-	float	   *values;
-	int			j = 0;
-
-	CheckDim(dim);
-	CheckExpectedDim(typmod, dim);
-
-	for (int i = 0; i < dim; i++)
-	{
-		if (!HalfIsZero(vec->x[i]))
-			nnz++;
-	}
-
-	result = InitSparseVector(dim, nnz);
-	values = SPARSEVEC_VALUES(result);
-	for (int i = 0; i < dim; i++)
-	{
-		if (!HalfIsZero(vec->x[i]))
-		{
-			/* Safety check */
-			if (j >= result->nnz)
-				elog(ERROR, "safety check failed");
-
-			result->indices[j] = i;
-			values[j] = HalfToFloat4(vec->x[i]);
-			j++;
-		}
-	}
-
-	PG_RETURN_POINTER(result);
-}
-
-/*
- * Convert array to sparse vector
- */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(array_to_sparsevec);
-Datum
-array_to_sparsevec(PG_FUNCTION_ARGS)
-{
-	ArrayType  *array = PG_GETARG_ARRAYTYPE_P(0);
-	int32		typmod = PG_GETARG_INT32(1);
-	SparseVector *result;
-	int16		typlen;
-	bool		typbyval;
-	char		typalign;
-	Datum	   *elemsp;
-	int			nelemsp;
-	int			nnz = 0;
-	float	   *values;
-	int			j = 0;
-
-	if (ARR_NDIM(array) > 1)
-		ereport(ERROR,
-				(errcode(ERRCODE_DATA_EXCEPTION),
-				 errmsg("array must be 1-D")));
-
-	if (ARR_HASNULL(array) && array_contains_nulls(array))
-		ereport(ERROR,
-				(errcode(ERRCODE_NULL_VALUE_NOT_ALLOWED),
-				 errmsg("array must not contain nulls")));
-
-	get_typlenbyvalalign(ARR_ELEMTYPE(array), &typlen, &typbyval, &typalign);
-	deconstruct_array(array, ARR_ELEMTYPE(array), typlen, typbyval, typalign, &elemsp, NULL, &nelemsp);
-
-	CheckDim(nelemsp);
-	CheckExpectedDim(typmod, nelemsp);
-
-#ifdef _MSC_VER
-/* /fp:fast may not propagate +/-Infinity or NaN */
-#define IS_NOT_ZERO(v) (isnan((float) (v)) || isinf((float) (v)) || ((float) (v)) != 0)
-#else
-#define IS_NOT_ZERO(v) (((float) (v)) != 0)
-#endif
-
-	if (ARR_ELEMTYPE(array) == INT4OID)
-	{
-		for (int i = 0; i < nelemsp; i++)
-			nnz += IS_NOT_ZERO(DatumGetInt32(elemsp[i]));
-	}
-	else if (ARR_ELEMTYPE(array) == FLOAT8OID)
-	{
-		for (int i = 0; i < nelemsp; i++)
-			nnz += IS_NOT_ZERO(DatumGetFloat8(elemsp[i]));
-	}
-	else if (ARR_ELEMTYPE(array) == FLOAT4OID)
-	{
-		for (int i = 0; i < nelemsp; i++)
-			nnz += IS_NOT_ZERO(DatumGetFloat4(elemsp[i]));
-	}
-	else if (ARR_ELEMTYPE(array) == NUMERICOID)
-	{
-		for (int i = 0; i < nelemsp; i++)
-			nnz += IS_NOT_ZERO(DirectFunctionCall1(numeric_float4, elemsp[i]));
-	}
-	else
-	{
-		ereport(ERROR,
-				(errcode(ERRCODE_DATA_EXCEPTION),
-				 errmsg("unsupported array type")));
-	}
-
-	result = InitSparseVector(nelemsp, nnz);
-	values = SPARSEVEC_VALUES(result);
-
-#define PROCESS_ARRAY_ELEM(elem) \
-	do { \
-		float v = (float) (elem); \
-		if (IS_NOT_ZERO(v)) { \
-			/* Safety check */ \
-			if (j >= result->nnz) \
-				elog(ERROR, "safety check failed"); \
-			result->indices[j] = i; \
-			values[j] = v; \
-			j++; \
-		} \
-	} while (0)
-
-	if (ARR_ELEMTYPE(array) == INT4OID)
-	{
-		for (int i = 0; i < nelemsp; i++)
-			PROCESS_ARRAY_ELEM(DatumGetInt32(elemsp[i]));
-	}
-	else if (ARR_ELEMTYPE(array) == FLOAT8OID)
-	{
-		for (int i = 0; i < nelemsp; i++)
-			PROCESS_ARRAY_ELEM(DatumGetFloat8(elemsp[i]));
-	}
-	else if (ARR_ELEMTYPE(array) == FLOAT4OID)
-	{
-		for (int i = 0; i < nelemsp; i++)
-			PROCESS_ARRAY_ELEM(DatumGetFloat4(elemsp[i]));
-	}
-	else if (ARR_ELEMTYPE(array) == NUMERICOID)
-	{
-		for (int i = 0; i < nelemsp; i++)
-			PROCESS_ARRAY_ELEM(DatumGetFloat4(DirectFunctionCall1(numeric_float4, elemsp[i])));
-	}
-	else
-	{
-		ereport(ERROR,
-				(errcode(ERRCODE_DATA_EXCEPTION),
-				 errmsg("unsupported array type")));
-	}
-
-#undef PROCESS_ARRAY_ELEM
-#undef IS_NOT_ZERO
-
-	/*
-	 * Free allocation from deconstruct_array. Do not free individual elements
-	 * when pass-by-reference since they point to original array.
-	 */
-	pfree(elemsp);
-
-	if (j != result->nnz)
-		elog(ERROR, "correctness check failed");
-
-	/* Check elements */
-	for (int i = 0; i < result->nnz; i++)
-		CheckElement(values[i]);
-
-	PG_RETURN_POINTER(result);
-}
-
 /*
  * Get the L2 squared distance between sparse vectors
  */
@@ -825,7 +613,7 @@ SparsevecL2SquaredDistance(SparseVector * a, SparseVector * b)
 
 			if (ai == bi)
 			{
-				float		diff = ax[i] - bx[j];
+				double		diff = ax[i] - bx[j];
 
 				distance += diff * diff;
 			}
@@ -854,7 +642,7 @@ SparsevecL2SquaredDistance(SparseVector * a, SparseVector * b)
 /*
  * Get the L2 distance between sparse vectors
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(sparsevec_l2_distance);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(sparsevec_l2_distance);
 Datum
 sparsevec_l2_distance(PG_FUNCTION_ARGS)
 {
@@ -863,14 +651,14 @@ sparsevec_l2_distance(PG_FUNCTION_ARGS)
 
 	CheckDims(a, b);
 
-	PG_RETURN_FLOAT8(sqrt((double) SparsevecL2SquaredDistance(a, b)));
+	PG_RETURN_FLOAT8(sqrt(SparsevecL2SquaredDistance(a, b)));
 }
 
 /*
  * Get the L2 squared distance between sparse vectors
  * This saves a sqrt calculation
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(sparsevec_l2_squared_distance);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(sparsevec_l2_squared_distance);
 Datum
 sparsevec_l2_squared_distance(PG_FUNCTION_ARGS)
 {
@@ -879,7 +667,7 @@ sparsevec_l2_squared_distance(PG_FUNCTION_ARGS)
 
 	CheckDims(a, b);
 
-	PG_RETURN_FLOAT8((double) SparsevecL2SquaredDistance(a, b));
+	PG_RETURN_FLOAT8(SparsevecL2SquaredDistance(a, b));
 }
 
 /*
@@ -921,7 +709,7 @@ SparsevecInnerProduct(SparseVector * a, SparseVector * b)
 /*
  * Get the inner product of two sparse vectors
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(sparsevec_inner_product);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(sparsevec_inner_product);
 Datum
 sparsevec_inner_product(PG_FUNCTION_ARGS)
 {
@@ -930,13 +718,13 @@ sparsevec_inner_product(PG_FUNCTION_ARGS)
 
 	CheckDims(a, b);
 
-	PG_RETURN_FLOAT8((double) SparsevecInnerProduct(a, b));
+	PG_RETURN_FLOAT8(SparsevecInnerProduct(a, b));
 }
 
 /*
  * Get the negative inner product of two sparse vectors
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(sparsevec_negative_inner_product);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(sparsevec_negative_inner_product);
 Datum
 sparsevec_negative_inner_product(PG_FUNCTION_ARGS)
 {
@@ -945,13 +733,13 @@ sparsevec_negative_inner_product(PG_FUNCTION_ARGS)
 
 	CheckDims(a, b);
 
-	PG_RETURN_FLOAT8((double) -SparsevecInnerProduct(a, b));
+	PG_RETURN_FLOAT8(-SparsevecInnerProduct(a, b));
 }
 
 /*
  * Get the cosine distance between two sparse vectors
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(sparsevec_cosine_distance);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(sparsevec_cosine_distance);
 Datum
 sparsevec_cosine_distance(PG_FUNCTION_ARGS)
 {
@@ -996,7 +784,7 @@ sparsevec_cosine_distance(PG_FUNCTION_ARGS)
 /*
  * Get the L1 distance between two sparse vectors
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(sparsevec_l1_distance);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(sparsevec_l1_distance);
 Datum
 sparsevec_l1_distance(PG_FUNCTION_ARGS)
 {
@@ -1004,7 +792,7 @@ sparsevec_l1_distance(PG_FUNCTION_ARGS)
 	SparseVector *b = PG_GETARG_SPARSEVEC_P(1);
 	float	   *ax = SPARSEVEC_VALUES(a);
 	float	   *bx = SPARSEVEC_VALUES(b);
-	float		distance = 0.0;
+	double		distance = 0.0;
 	int			bpos = 0;
 
 	CheckDims(a, b);
@@ -1039,13 +827,13 @@ sparsevec_l1_distance(PG_FUNCTION_ARGS)
 	for (int j = bpos; j < b->nnz; j++)
 		distance += fabsf(bx[j]);
 
-	PG_RETURN_FLOAT8((double) distance);
+	PG_RETURN_FLOAT8(distance);
 }
 
 /*
  * Get the L2 norm of a sparse vector
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(sparsevec_l2_norm);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(sparsevec_l2_norm);
 Datum
 sparsevec_l2_norm(PG_FUNCTION_ARGS)
 {
@@ -1063,7 +851,7 @@ sparsevec_l2_norm(PG_FUNCTION_ARGS)
 /*
  * Normalize a sparse vector with the L2 norm
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(sparsevec_l2_normalize);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(sparsevec_l2_normalize);
 Datum
 sparsevec_l2_normalize(PG_FUNCTION_ARGS)
 {
@@ -1155,10 +943,11 @@ sparsevec_cmp_internal(SparseVector * a, SparseVector * b)
 			return 1;
 	}
 
-	if (a->nnz < b->nnz && b->indices[nnz] < a->dim)
+	/* Check <= dim since indices start at 1 */
+	if (a->nnz < b->nnz && b->indices[nnz] <= a->dim)
 		return bx[nnz] < 0 ? 1 : -1;
 
-	if (a->nnz > b->nnz && a->indices[nnz] < b->dim)
+	if (a->nnz > b->nnz && a->indices[nnz] <= b->dim)
 		return ax[nnz] < 0 ? -1 : 1;
 
 	if (a->dim < b->dim)
@@ -1173,7 +962,7 @@ sparsevec_cmp_internal(SparseVector * a, SparseVector * b)
 /*
  * Less than
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(sparsevec_lt);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(sparsevec_lt);
 Datum
 sparsevec_lt(PG_FUNCTION_ARGS)
 {
@@ -1186,7 +975,7 @@ sparsevec_lt(PG_FUNCTION_ARGS)
 /*
  * Less than or equal
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(sparsevec_le);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(sparsevec_le);
 Datum
 sparsevec_le(PG_FUNCTION_ARGS)
 {
@@ -1199,7 +988,7 @@ sparsevec_le(PG_FUNCTION_ARGS)
 /*
  * Equal
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(sparsevec_eq);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(sparsevec_eq);
 Datum
 sparsevec_eq(PG_FUNCTION_ARGS)
 {
@@ -1212,7 +1001,7 @@ sparsevec_eq(PG_FUNCTION_ARGS)
 /*
  * Not equal
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(sparsevec_ne);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(sparsevec_ne);
 Datum
 sparsevec_ne(PG_FUNCTION_ARGS)
 {
@@ -1225,7 +1014,7 @@ sparsevec_ne(PG_FUNCTION_ARGS)
 /*
  * Greater than or equal
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(sparsevec_ge);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(sparsevec_ge);
 Datum
 sparsevec_ge(PG_FUNCTION_ARGS)
 {
@@ -1238,7 +1027,7 @@ sparsevec_ge(PG_FUNCTION_ARGS)
 /*
  * Greater than
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(sparsevec_gt);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(sparsevec_gt);
 Datum
 sparsevec_gt(PG_FUNCTION_ARGS)
 {
@@ -1251,7 +1040,7 @@ sparsevec_gt(PG_FUNCTION_ARGS)
 /*
  * Compare sparse vectors
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(sparsevec_cmp);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(sparsevec_cmp);
 Datum
 sparsevec_cmp(PG_FUNCTION_ARGS)
 {

src/sparsevec.h

@@ -1,40 +1,28 @@
 #ifndef SPARSEVEC_H
 #define SPARSEVEC_H
 
-#define SPARSEVEC_MAX_DIM 1000000000
+#include "fmgr.h"
+
+#define SPARSEVEC_MAX_DIM 100000
 #define SPARSEVEC_MAX_NNZ 16000
 
+/* Ensure values are aligned */
+#define SPARSEVEC_SIZE(_nnz)		(offsetof(SparseVector, indices) + MAXALIGN((_nnz) * sizeof(int32)) + (_nnz * sizeof(float)))
+#define SPARSEVEC_VALUES(x)		((float *) (((char *) (x)) + offsetof(SparseVector, indices) + MAXALIGN((x)->nnz * sizeof(int32))))
 #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		nnz;
-	int32		unused;			/* reserved for future use, always zero */
+	int32		unused;
 	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);
+PGDLLEXPORT Datum sparsevec_l2_normalize(PG_FUNCTION_ARGS);
 
 #endif

src/vector.c

@@ -2,8 +2,7 @@
 
 #include <math.h>
 
-#include "bitutils.h"
+#include "bitvector.h"
-#include "bitvec.h"
 #include "catalog/pg_type.h"
 #include "common/shortest_dec.h"
 #include "fmgr.h"
@@ -26,13 +25,26 @@
 #include "varatt.h"
 #endif
 
+#if PG_VERSION_NUM < 130000
+#define TYPALIGN_DOUBLE 'd'
+#define TYPALIGN_INT 'i'
+#endif
+
 #define STATE_DIMS(x) (ARR_DIMS(x)[0] - 1)
 #define CreateStateDatums(dim) palloc(sizeof(Datum) * (dim + 1))
 
-#if defined(USE_TARGET_CLONES) && !defined(__FMA__)
+/* target_clones requires glibc */
-#define VECTOR_TARGET_CLONES __attribute__((target_clones("default", "fma")))
+#if defined(__gnu_linux__) && defined(__has_attribute)
+/* Use separate line for portability */
+#if __has_attribute(target_clones)
+#define HAVE_TARGET_CLONES
+#endif
+#endif
+
+#if defined(__x86_64__) && defined(HAVE_TARGET_CLONES) && !defined(__FMA__)
+#define VECTOR_DISPATCH __attribute__((target_clones("default", "fma")))
 #else
-#define VECTOR_TARGET_CLONES
+#define VECTOR_DISPATCH
 #endif
 
 PG_MODULE_MAGIC;
@@ -44,7 +56,6 @@ PGDLLEXPORT void _PG_init(void);
 void
 _PG_init(void)
 {
-	BitvecInit();
 	HalfvecInit();
 	HnswInit();
 	IvfflatInit();
@@ -155,10 +166,28 @@ CheckStateArray(ArrayType *statearray, const char *caller)
 	return (float8 *) ARR_DATA_PTR(statearray);
 }
 
+#if PG_VERSION_NUM < 120003
+static pg_noinline void
+float_overflow_error(void)
+{
+	ereport(ERROR,
+			(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
+			 errmsg("value out of range: overflow")));
+}
+
+static pg_noinline void
+float_underflow_error(void)
+{
+	ereport(ERROR,
+			(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
+			 errmsg("value out of range: underflow")));
+}
+#endif
+
 /*
  * Convert textual representation to internal representation
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(vector_in);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(vector_in);
 Datum
 vector_in(PG_FUNCTION_ARGS)
 {
@@ -271,7 +300,7 @@ vector_in(PG_FUNCTION_ARGS)
 /*
  * Convert internal representation to textual representation
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(vector_out);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(vector_out);
 Datum
 vector_out(PG_FUNCTION_ARGS)
 {
@@ -325,7 +354,7 @@ PrintVector(char *msg, Vector * vector)
 /*
  * Convert type modifier
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(vector_typmod_in);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(vector_typmod_in);
 Datum
 vector_typmod_in(PG_FUNCTION_ARGS)
 {
@@ -356,7 +385,7 @@ vector_typmod_in(PG_FUNCTION_ARGS)
 /*
  * Convert external binary representation to internal representation
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(vector_recv);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(vector_recv);
 Datum
 vector_recv(PG_FUNCTION_ARGS)
 {
@@ -390,7 +419,7 @@ vector_recv(PG_FUNCTION_ARGS)
 /*
  * Convert internal representation to the external binary representation
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(vector_send);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(vector_send);
 Datum
 vector_send(PG_FUNCTION_ARGS)
 {
@@ -410,7 +439,7 @@ vector_send(PG_FUNCTION_ARGS)
  * Convert vector to vector
  * This is needed to check the type modifier
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(vector);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(vector);
 Datum
 vector(PG_FUNCTION_ARGS)
 {
@@ -425,7 +454,7 @@ vector(PG_FUNCTION_ARGS)
 /*
  * Convert array to vector
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(array_to_vector);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(array_to_vector);
 Datum
 array_to_vector(PG_FUNCTION_ARGS)
 {
@@ -499,7 +528,7 @@ array_to_vector(PG_FUNCTION_ARGS)
 /*
  * Convert vector to float4[]
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(vector_to_float4);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(vector_to_float4);
 Datum
 vector_to_float4(PG_FUNCTION_ARGS)
 {
@@ -523,7 +552,7 @@ vector_to_float4(PG_FUNCTION_ARGS)
 /*
  * Convert half vector to vector
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(halfvec_to_vector);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(halfvec_to_vector);
 Datum
 halfvec_to_vector(PG_FUNCTION_ARGS)
 {
@@ -542,7 +571,7 @@ halfvec_to_vector(PG_FUNCTION_ARGS)
 	PG_RETURN_POINTER(result);
 }
 
-VECTOR_TARGET_CLONES static float
+VECTOR_DISPATCH static float
 VectorL2SquaredDistance(int dim, float *ax, float *bx)
 {
 	float		distance = 0.0;
@@ -561,7 +590,7 @@ VectorL2SquaredDistance(int dim, float *ax, float *bx)
 /*
  * Get the L2 distance between vectors
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(l2_distance);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(l2_distance);
 Datum
 l2_distance(PG_FUNCTION_ARGS)
 {
@@ -577,7 +606,7 @@ l2_distance(PG_FUNCTION_ARGS)
  * Get the L2 squared distance between vectors
  * This saves a sqrt calculation
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(vector_l2_squared_distance);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(vector_l2_squared_distance);
 Datum
 vector_l2_squared_distance(PG_FUNCTION_ARGS)
 {
@@ -589,7 +618,7 @@ vector_l2_squared_distance(PG_FUNCTION_ARGS)
 	PG_RETURN_FLOAT8((double) VectorL2SquaredDistance(a->dim, a->x, b->x));
 }
 
-VECTOR_TARGET_CLONES static float
+VECTOR_DISPATCH static float
 VectorInnerProduct(int dim, float *ax, float *bx)
 {
 	float		distance = 0.0;
@@ -604,7 +633,7 @@ VectorInnerProduct(int dim, float *ax, float *bx)
 /*
  * Get the inner product of two vectors
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(inner_product);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(inner_product);
 Datum
 inner_product(PG_FUNCTION_ARGS)
 {
@@ -619,7 +648,7 @@ inner_product(PG_FUNCTION_ARGS)
 /*
  * Get the negative inner product of two vectors
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(vector_negative_inner_product);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(vector_negative_inner_product);
 Datum
 vector_negative_inner_product(PG_FUNCTION_ARGS)
 {
@@ -631,7 +660,7 @@ vector_negative_inner_product(PG_FUNCTION_ARGS)
 	PG_RETURN_FLOAT8((double) -VectorInnerProduct(a->dim, a->x, b->x));
 }
 
-VECTOR_TARGET_CLONES static double
+VECTOR_DISPATCH static double
 VectorCosineSimilarity(int dim, float *ax, float *bx)
 {
 	float		similarity = 0.0;
@@ -653,7 +682,7 @@ VectorCosineSimilarity(int dim, float *ax, float *bx)
 /*
  * Get the cosine distance between two vectors
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(cosine_distance);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(cosine_distance);
 Datum
 cosine_distance(PG_FUNCTION_ARGS)
 {
@@ -685,7 +714,7 @@ cosine_distance(PG_FUNCTION_ARGS)
  * Currently uses angular distance since needs to satisfy triangle inequality
  * Assumes inputs are unit vectors (skips norm)
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(vector_spherical_distance);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(vector_spherical_distance);
 Datum
 vector_spherical_distance(PG_FUNCTION_ARGS)
 {
@@ -706,8 +735,7 @@ vector_spherical_distance(PG_FUNCTION_ARGS)
 	PG_RETURN_FLOAT8(acos(distance) / M_PI);
 }
 
-/* Does not require FMA, but keep logic simple */
+static float
-VECTOR_TARGET_CLONES static float
 VectorL1Distance(int dim, float *ax, float *bx)
 {
 	float		distance = 0.0;
@@ -722,7 +750,7 @@ VectorL1Distance(int dim, float *ax, float *bx)
 /*
  * Get the L1 distance between two vectors
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(l1_distance);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(l1_distance);
 Datum
 l1_distance(PG_FUNCTION_ARGS)
 {
@@ -737,7 +765,7 @@ l1_distance(PG_FUNCTION_ARGS)
 /*
  * Get the dimensions of a vector
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(vector_dims);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(vector_dims);
 Datum
 vector_dims(PG_FUNCTION_ARGS)
 {
@@ -749,7 +777,7 @@ vector_dims(PG_FUNCTION_ARGS)
 /*
  * Get the L2 norm of a vector
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(vector_norm);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(vector_norm);
 Datum
 vector_norm(PG_FUNCTION_ARGS)
 {
@@ -767,7 +795,7 @@ vector_norm(PG_FUNCTION_ARGS)
 /*
  * Normalize a vector with the L2 norm
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(l2_normalize);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(l2_normalize);
 Datum
 l2_normalize(PG_FUNCTION_ARGS)
 {
@@ -806,7 +834,7 @@ l2_normalize(PG_FUNCTION_ARGS)
 /*
  * Add vectors
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(vector_add);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(vector_add);
 Datum
 vector_add(PG_FUNCTION_ARGS)
 {
@@ -839,7 +867,7 @@ vector_add(PG_FUNCTION_ARGS)
 /*
  * Subtract vectors
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(vector_sub);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(vector_sub);
 Datum
 vector_sub(PG_FUNCTION_ARGS)
 {
@@ -872,7 +900,7 @@ vector_sub(PG_FUNCTION_ARGS)
 /*
  * Multiply vectors
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(vector_mul);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(vector_mul);
 Datum
 vector_mul(PG_FUNCTION_ARGS)
 {
@@ -908,7 +936,7 @@ vector_mul(PG_FUNCTION_ARGS)
 /*
  * Concatenate vectors
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(vector_concat);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(vector_concat);
 Datum
 vector_concat(PG_FUNCTION_ARGS)
 {
@@ -932,7 +960,7 @@ vector_concat(PG_FUNCTION_ARGS)
 /*
  * Quantize a vector
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(binary_quantize);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(binary_quantize);
 Datum
 binary_quantize(PG_FUNCTION_ARGS)
 {
@@ -950,39 +978,24 @@ binary_quantize(PG_FUNCTION_ARGS)
 /*
  * Get a subvector
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(subvector);
+PGDLLEXPORT 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;
+	int32		end = start + count;
 	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,
+	if (end > a->dim)
-				(errcode(ERRCODE_DATA_EXCEPTION),
+		end = a->dim + 1;
-				 errmsg("vector must have at least 1 dimension")));
 
 	dim = end - start;
 	CheckDim(dim);
@@ -1024,7 +1037,7 @@ vector_cmp_internal(Vector * a, Vector * b)
 /*
  * Less than
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(vector_lt);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(vector_lt);
 Datum
 vector_lt(PG_FUNCTION_ARGS)
 {
@@ -1037,7 +1050,7 @@ vector_lt(PG_FUNCTION_ARGS)
 /*
  * Less than or equal
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(vector_le);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(vector_le);
 Datum
 vector_le(PG_FUNCTION_ARGS)
 {
@@ -1050,7 +1063,7 @@ vector_le(PG_FUNCTION_ARGS)
 /*
  * Equal
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(vector_eq);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(vector_eq);
 Datum
 vector_eq(PG_FUNCTION_ARGS)
 {
@@ -1063,7 +1076,7 @@ vector_eq(PG_FUNCTION_ARGS)
 /*
  * Not equal
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(vector_ne);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(vector_ne);
 Datum
 vector_ne(PG_FUNCTION_ARGS)
 {
@@ -1076,7 +1089,7 @@ vector_ne(PG_FUNCTION_ARGS)
 /*
  * Greater than or equal
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(vector_ge);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(vector_ge);
 Datum
 vector_ge(PG_FUNCTION_ARGS)
 {
@@ -1089,7 +1102,7 @@ vector_ge(PG_FUNCTION_ARGS)
 /*
  * Greater than
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(vector_gt);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(vector_gt);
 Datum
 vector_gt(PG_FUNCTION_ARGS)
 {
@@ -1102,7 +1115,7 @@ vector_gt(PG_FUNCTION_ARGS)
 /*
  * Compare vectors
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(vector_cmp);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(vector_cmp);
 Datum
 vector_cmp(PG_FUNCTION_ARGS)
 {
@@ -1115,7 +1128,7 @@ vector_cmp(PG_FUNCTION_ARGS)
 /*
  * Accumulate vectors
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(vector_accum);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(vector_accum);
 Datum
 vector_accum(PG_FUNCTION_ARGS)
 {
@@ -1174,13 +1187,12 @@ vector_accum(PG_FUNCTION_ARGS)
 }
 
 /*
- * Combine vectors or half vectors (also used for halfvec_combine)
+ * Combine vectors or half vectors
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(vector_combine);
+PGDLLEXPORT 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;
@@ -1247,7 +1259,7 @@ vector_combine(PG_FUNCTION_ARGS)
 /*
  * Average vectors
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(vector_avg);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(vector_avg);
 Datum
 vector_avg(PG_FUNCTION_ARGS)
 {
@@ -1281,7 +1293,7 @@ vector_avg(PG_FUNCTION_ARGS)
 /*
  * Convert sparse vector to dense vector
  */
-FUNCTION_PREFIX PG_FUNCTION_INFO_V1(sparsevec_to_vector);
+PGDLLEXPORT PG_FUNCTION_INFO_V1(sparsevec_to_vector);
 Datum
 sparsevec_to_vector(PG_FUNCTION_ARGS)
 {
@@ -1296,7 +1308,7 @@ sparsevec_to_vector(PG_FUNCTION_ARGS)
 
 	result = InitVector(dim);
 	for (int i = 0; i < svec->nnz; i++)
-		result->x[svec->indices[i]] = values[i];
+		result->x[svec->indices[i] - 1] = values[i];
 
 	PG_RETURN_POINTER(result);
 }

src/vector.h

@@ -1,6 +1,8 @@
 #ifndef VECTOR_H
 #define VECTOR_H
 
+#include "fmgr.h"
+
 #define VECTOR_MAX_DIM 16000
 
 #define VECTOR_SIZE(_dim)		(offsetof(Vector, x) + sizeof(float)*(_dim))
@@ -12,19 +14,13 @@ typedef struct Vector
 {
 	int32		vl_len_;		/* varlena header (do not touch directly!) */
 	int16		dim;			/* number of dimensions */
-	int16		unused;			/* reserved for future use, always zero */
+	int16		unused;
 	float		x[FLEXIBLE_ARRAY_MEMBER];
 }			Vector;
 
 Vector	   *InitVector(int dim);
 void		PrintVector(char *msg, Vector * vector);
 int			vector_cmp_internal(Vector * a, Vector * b);
-
+PGDLLEXPORT Datum l2_normalize(PG_FUNCTION_ARGS);
-/* TODO Move to better place */
-#if PG_VERSION_NUM >= 160000
-#define FUNCTION_PREFIX
-#else
-#define FUNCTION_PREFIX PGDLLEXPORT
-#endif
 
 #endif

test/expected/bit.out

@@ -1,140 +0,0 @@
-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/bit_functions.out

@@ -0,0 +1,104 @@
+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('', '');
+ 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('', '');
+ 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,61 +0,0 @@
-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]';
-   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;
--- 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/btree_halfvec.out

@@ -0,0 +1,20 @@
+SET enable_seqscan = off;
+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;

test/expected/btree_sparsevec.out

@@ -0,0 +1,20 @@
+SET enable_seqscan = off;
+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/btree_vector.out

@@ -0,0 +1,20 @@
+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 (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;

test/expected/cast.out

@@ -170,100 +170,6 @@ 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[1,0,2,0,3,0]::sparsevec;
-      array      
------------------
- {1:1,3:2,5:3}/6
-(1 row)
-
-SELECT ARRAY[1.0,0.0,2.0,0.0,3.0,0.0]::sparsevec;
-      array      
------------------
- {1:1,3:2,5:3}/6
-(1 row)
-
-SELECT ARRAY[1,0,2,0,3,0]::float4[]::sparsevec;
-      array      
------------------
- {1:1,3:2,5:3}/6
-(1 row)
-
-SELECT ARRAY[1,0,2,0,3,0]::float8[]::sparsevec;
-      array      
------------------
- {1:1,3:2,5:3}/6
-(1 row)
-
-SELECT ARRAY[1,0,2,0,3,0]::numeric[]::sparsevec;
-      array      
------------------
- {1:1,3:2,5:3}/6
-(1 row)
-
-SELECT '{1,0,2,0,3,0}'::real[]::sparsevec;
-    sparsevec    
------------------
- {1:1,3:2,5:3}/6
-(1 row)
-
-SELECT '{1,0,2,0,3,0}'::real[]::sparsevec(6);
-    sparsevec    
------------------
- {1:1,3:2,5:3}/6
-(1 row)
-
-SELECT '{1,0,2,0,3,0}'::real[]::sparsevec(5);
-ERROR:  expected 5 dimensions, not 6
-SELECT '{NULL}'::real[]::sparsevec;
-ERROR:  array must not contain nulls
-SELECT '{NaN}'::real[]::sparsevec;
-ERROR:  NaN not allowed in sparsevec
-SELECT '{Infinity}'::real[]::sparsevec;
-ERROR:  infinite value not allowed in sparsevec
-SELECT '{-Infinity}'::real[]::sparsevec;
-ERROR:  infinite value not allowed in sparsevec
-SELECT '{}'::real[]::sparsevec;
-ERROR:  sparsevec must have at least 1 dimension
-SELECT '{{1}}'::real[]::sparsevec;
-ERROR:  array must be 1-D
 SELECT array_agg(n)::vector FROM generate_series(1, 16001) n;
 ERROR:  vector cannot have more than 16000 dimensions
 SELECT array_to_vector(array_agg(n), 16001, false) FROM generate_series(1, 16001) n;

test/expected/copy.out

@@ -1,50 +1,15 @@
--- vector
+CREATE TABLE t (val vector(3), val2 halfvec(3), val3 sparsevec(3));
-CREATE TABLE t (val vector(3));
+INSERT INTO t (val, val2, val3) VALUES ('[0,0,0]', '[0,0,0]', '{}/3'), ('[1,2,3]', '[1,2,3]', '{1:1,2:2,3:3}/3'), ('[1,1,1]', '[1,1,1]', '{1:1,2:1,3:1}/3'), (NULL, NULL, NULL);
-INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
+CREATE TABLE t2 (val vector(3), val2 halfvec(3), val3 sparsevec(3));
-CREATE TABLE t2 (val vector(3));
+\copy t TO 'results/data.bin' WITH (FORMAT binary)
-\copy t TO 'results/vector.bin' WITH (FORMAT binary)
+\copy t2 FROM 'results/data.bin' WITH (FORMAT binary)
-\copy t2 FROM 'results/vector.bin' WITH (FORMAT binary)
 SELECT * FROM t2 ORDER BY val;
-   val   
+   val   |  val2   |      val3       
----------
+---------+---------+-----------------
- [0,0,0]
+ [0,0,0] | [0,0,0] | {}/3
- [1,1,1]
+ [1,1,1] | [1,1,1] | {1:1,2:1,3:1}/3
- [1,2,3]
+ [1,2,3] | [1,2,3] | {1:1,2:2,3:3}/3
- 
+         |         | 
-(4 rows)
-
-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;

test/expected/halfvec_functions.out

@@ -1,167 +1,3 @@
-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? 
 ----------
@@ -340,18 +176,6 @@ SELECT l2_norm('[0,1]'::halfvec);
        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 
 -------------
@@ -480,24 +304,6 @@ SELECT l1_distance('[0,0]'::halfvec, '[0,1]');
 
 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      
 ------------------------
@@ -570,20 +376,6 @@ 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    
 -----------

test/expected/halfvec_input.out

@@ -0,0 +1,164 @@
+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

test/expected/hnsw_bit_hamming.out

@@ -1,5 +1,4 @@
 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);
@@ -20,28 +19,7 @@ SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <~> (SELECT NULL::bit)) t2;
 (1 row)
 
 DROP TABLE t;
--- jaccard
+-- TODO move
-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

test/expected/hnsw_bit_jaccard.out

@@ -0,0 +1,21 @@
+SET enable_seqscan = off;
+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;

test/expected/hnsw_halfvec.out

@@ -1,102 +0,0 @@
-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_halfvec_cosine.out

@@ -0,0 +1,26 @@
+SET enable_seqscan = off;
+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;

test/expected/hnsw_halfvec_ip.out

@@ -0,0 +1,21 @@
+SET enable_seqscan = off;
+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;

test/expected/hnsw_halfvec_l2.out

@@ -0,0 +1,33 @@
+SET enable_seqscan = off;
+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;

test/expected/hnsw_options.out

@@ -0,0 +1,26 @@
+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

@@ -1,112 +0,0 @@
-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_sparsevec_cosine.out

@@ -0,0 +1,26 @@
+SET enable_seqscan = off;
+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;

test/expected/hnsw_sparsevec_ip.out

@@ -0,0 +1,21 @@
+SET enable_seqscan = off;
+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;

test/expected/hnsw_sparsevec_l2.out

@@ -0,0 +1,43 @@
+SET enable_seqscan = off;
+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;
+-- TODO move
+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

@@ -0,0 +1,13 @@
+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

@@ -1,193 +0,0 @@
-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;
--- iterative
-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);
-SET hnsw.iterative_scan = strict_order;
-SET hnsw.ef_search = 1;
-SELECT * FROM t ORDER BY val <-> '[3,3,3]';
-   val   
----------
- [1,2,3]
- [1,1,1]
- [0,0,0]
-(3 rows)
-
-SET hnsw.iterative_scan = relaxed_order;
-SELECT * FROM t ORDER BY val <-> '[3,3,3]';
-   val   
----------
- [1,2,3]
- [1,1,1]
- [0,0,0]
-(3 rows)
-
-RESET hnsw.iterative_scan;
-RESET hnsw.ef_search;
-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)
-SHOW hnsw.iterative_scan;
- hnsw.iterative_scan 
----------------------
- off
-(1 row)
-
-SET hnsw.iterative_scan = on;
-ERROR:  invalid value for parameter "hnsw.iterative_scan": "on"
-HINT:  Available values: off, relaxed_order, strict_order.
-SHOW hnsw.max_scan_tuples;
- hnsw.max_scan_tuples 
-----------------------
- 20000
-(1 row)
-
-SET hnsw.max_scan_tuples = 0;
-ERROR:  0 is outside the valid range for parameter "hnsw.max_scan_tuples" (1 .. 2147483647)
-SHOW hnsw.scan_mem_multiplier;
- hnsw.scan_mem_multiplier 
---------------------------
- 1
-(1 row)
-
-SET hnsw.scan_mem_multiplier = 0;
-ERROR:  0 is outside the valid range for parameter "hnsw.scan_mem_multiplier" (1 .. 1000)
-DROP TABLE t;

test/expected/hnsw_vector_cosine.out

@@ -0,0 +1,26 @@
+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_vector_ip.out

@@ -0,0 +1,21 @@
+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_vector_l2.out

@@ -0,0 +1,33 @@
+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 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;

test/expected/ivfflat_bit_hamming.out

@@ -1,5 +1,4 @@
 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);
@@ -20,7 +19,7 @@ SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <~> (SELECT NULL::bit)) t2;
 (1 row)
 
 DROP TABLE t;
--- varbit
+-- TODO move
 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

test/expected/ivfflat_bit_jaccard.out

@@ -0,0 +1,21 @@
+SET enable_seqscan = off;
+CREATE TABLE t (val bit(4));
+INSERT INTO t (val) VALUES (B'0000'), (B'1100'), (B'1111'), (NULL);
+CREATE INDEX ON t USING ivfflat (val bit_jaccard_ops) WITH (lists = 1);
+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;

test/expected/ivfflat_halfvec.out

@@ -1,84 +0,0 @@
-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_halfvec_cosine.out

@@ -0,0 +1,26 @@
+SET enable_seqscan = off;
+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_halfvec_ip.out

@@ -0,0 +1,21 @@
+SET enable_seqscan = off;
+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;

test/expected/ivfflat_halfvec_l2.out

@@ -0,0 +1,36 @@
+SET enable_seqscan = off;
+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;

test/expected/ivfflat_options.out

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,13 @@
+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

@@ -1,166 +0,0 @@
-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;
--- iterative
-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 = 3);
-SET ivfflat.iterative_scan = relaxed_order;
-SELECT * FROM t ORDER BY val <-> '[3,3,3]';
-   val   
----------
- [1,2,3]
- [1,1,1]
- [0,0,0]
-(3 rows)
-
-SET ivfflat.max_probes = 1;
-SELECT * FROM t ORDER BY val <-> '[3,3,3]';
-   val   
----------
- [1,2,3]
-(1 row)
-
-SET ivfflat.max_probes = 2;
-SELECT * FROM t ORDER BY val <-> '[3,3,3]';
-   val   
----------
- [1,2,3]
- [1,1,1]
-(2 rows)
-
-RESET ivfflat.iterative_scan;
-RESET ivfflat.max_probes;
-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)
-
-SET ivfflat.probes = 0;
-ERROR:  0 is outside the valid range for parameter "ivfflat.probes" (1 .. 32768)
-SET ivfflat.probes = 32769;
-ERROR:  32769 is outside the valid range for parameter "ivfflat.probes" (1 .. 32768)
-SHOW ivfflat.iterative_scan;
- ivfflat.iterative_scan 
-------------------------
- off
-(1 row)
-
-SET ivfflat.iterative_scan = on;
-ERROR:  invalid value for parameter "ivfflat.iterative_scan": "on"
-HINT:  Available values: off, relaxed_order.
-SHOW ivfflat.max_probes;
- ivfflat.max_probes 
---------------------
- 32768
-(1 row)
-
-SET ivfflat.max_probes = 0;
-ERROR:  0 is outside the valid range for parameter "ivfflat.max_probes" (1 .. 32768)
-SET ivfflat.max_probes = 32769;
-ERROR:  32769 is outside the valid range for parameter "ivfflat.max_probes" (1 .. 32768)
-DROP TABLE t;

test/expected/ivfflat_vector_cosine.out

@@ -0,0 +1,26 @@
+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_vector_ip.out

@@ -0,0 +1,21 @@
+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_vector_l2.out

@@ -0,0 +1,36 @@
+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 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;

test/expected/sparsevec.out

@@ -1,653 +0,0 @@
-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/sparsevec_functions.out

@@ -0,0 +1,336 @@
+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_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('{}/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: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('{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 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/sparsevec_input.out

@@ -0,0 +1,215 @@
+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;
+ERROR:  indexes must be in ascending order
+LINE 1: SELECT '{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 '{}/100001'::sparsevec;
+ERROR:  sparsevec cannot have more than 100000 dimensions
+LINE 1: SELECT '{}/100001'::sparsevec;
+               ^
+SELECT '{0:1}/1'::sparsevec;
+ERROR:  index "0" is out of range for type sparsevec
+LINE 1: SELECT '{0:1}/1'::sparsevec;
+               ^
+SELECT '{2:1}/1'::sparsevec;
+ERROR:  index must be less than or equal to dimensions
+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(100001);
+ERROR:  dimensions for type sparsevec cannot exceed 100000
+LINE 1: SELECT '{}/3'::sparsevec(100001);
+                       ^

test/expected/vector_functions.out

@@ -1,179 +1,3 @@
-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? 
 ----------
@@ -358,18 +182,6 @@ SELECT vector_norm('[3e37,4e37]')::real;
        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 
 -------------
@@ -390,12 +202,6 @@ SELECT l2_distance('[3e38]'::vector, '[-3e38]');
     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? 
 ----------
@@ -416,12 +222,6 @@ SELECT inner_product('[3e38]'::vector, '[3e38]');
       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? 
 ----------
@@ -478,18 +278,6 @@ SELECT cosine_distance('[3e38]'::vector, '[3e38]');
              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? 
 ----------
@@ -516,24 +304,6 @@ SELECT l1_distance('[3e38]'::vector, '[-3e38]');
     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 
 --------------
@@ -606,20 +376,6 @@ 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    
 -----------

test/expected/vector_input.out

@@ -0,0 +1,176 @@
+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

test/perl/PostgreSQL/Test/Cluster.pm

@@ -1,11 +0,0 @@
-package PostgreSQL::Test::Cluster;
-
-use PostgresNode;
-
-sub new
-{
-	my ($class, $name) = @_;
-	return get_new_node($name);
-}
-
-1;

test/perl/PostgreSQL/Test/Utils.pm

@@ -1,5 +0,0 @@
-package PostgreSQL::Test::Utils;
-
-use TestLib;
-
-1;

test/perl/PostgresNode.pm

@@ -0,0 +1,8 @@
+use PostgreSQL::Test::Cluster;
+
+sub get_new_node
+{
+	return PostgreSQL::Test::Cluster->new(@_);
+}
+
+1;

test/perl/TestLib.pm

@@ -0,0 +1,3 @@
+use PostgreSQL::Test::Utils;
+
+1;

test/sql/bit.sql

@@ -1,27 +0,0 @@
-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/bit_functions.sql

@@ -0,0 +1,21 @@
+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('', '');
+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('', '');
+SELECT jaccard_distance('1111', '000');
+SELECT jaccard_distance('1111', '0000'::varbit(5));
+SELECT jaccard_distance('1111', '00000'::varbit(5));

test/sql/btree.sql

@@ -1,34 +0,0 @@
-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;
-
-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/btree_halfvec.sql

@@ -0,0 +1,10 @@
+SET enable_seqscan = off;
+
+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;

test/sql/btree_sparsevec.sql

@@ -0,0 +1,10 @@
+SET enable_seqscan = off;
+
+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/btree_vector.sql

@@ -0,0 +1,10 @@
+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 (val);
+
+SELECT * FROM t WHERE val = '[1,2,3]';
+SELECT * FROM t ORDER BY val;
+
+DROP TABLE t;

test/sql/cast.sql

@@ -47,33 +47,6 @@ 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[1,0,2,0,3,0]::sparsevec;
-SELECT ARRAY[1.0,0.0,2.0,0.0,3.0,0.0]::sparsevec;
-SELECT ARRAY[1,0,2,0,3,0]::float4[]::sparsevec;
-SELECT ARRAY[1,0,2,0,3,0]::float8[]::sparsevec;
-SELECT ARRAY[1,0,2,0,3,0]::numeric[]::sparsevec;
-
-SELECT '{1,0,2,0,3,0}'::real[]::sparsevec;
-SELECT '{1,0,2,0,3,0}'::real[]::sparsevec(6);
-SELECT '{1,0,2,0,3,0}'::real[]::sparsevec(5);
-SELECT '{NULL}'::real[]::sparsevec;
-SELECT '{NaN}'::real[]::sparsevec;
-SELECT '{Infinity}'::real[]::sparsevec;
-SELECT '{-Infinity}'::real[]::sparsevec;
-SELECT '{}'::real[]::sparsevec;
-SELECT '{{1}}'::real[]::sparsevec;
-
 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,42 +1,10 @@
--- vector
+CREATE TABLE t (val vector(3), val2 halfvec(3), val3 sparsevec(3));
+INSERT INTO t (val, val2, val3) VALUES ('[0,0,0]', '[0,0,0]', '{}/3'), ('[1,2,3]', '[1,2,3]', '{1:1,2:2,3:3}/3'), ('[1,1,1]', '[1,1,1]', '{1:1,2:1,3:1}/3'), (NULL, NULL, NULL);
 
-CREATE TABLE t (val vector(3));
+CREATE TABLE t2 (val vector(3), val2 halfvec(3), val3 sparsevec(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/halfvec_functions.sql

@@ -1,42 +1,3 @@
-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]';
@@ -79,8 +40,6 @@ 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]');
@@ -109,9 +68,6 @@ 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);
@@ -129,9 +85,6 @@ 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;

test/sql/halfvec_input.sql

@@ -0,0 +1,38 @@
+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)[];

test/sql/hnsw_bit_hamming.sql

@@ -1,7 +1,5 @@
 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);
@@ -13,21 +11,7 @@ SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <~> (SELECT NULL::bit)) t2;
 
 DROP TABLE t;
 
--- jaccard
+-- TODO move
-
-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);

test/sql/hnsw_bit_jaccard.sql

@@ -0,0 +1,12 @@
+SET enable_seqscan = off;
+
+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;