Improved name [skip ci]

CHANGELOG.md

@@ -1,9 +1,6 @@
 ## 0.8.0 (unreleased)
 
-- Added support for inline filtering with IVFFlat
 - 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
 

Dockerfile

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

Makefile

@@ -4,8 +4,8 @@ EXTVERSION = 0.7.4
 MODULE_big = vector
 DATA = $(wildcard sql/*--*--*.sql)
 DATA_built = sql/$(EXTENSION)--$(EXTVERSION).sql
-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
+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/minivec.o src/ivfvacuum.o src/sparsevec.o src/vector.o
+HEADERS = src/halfvec.h src/minivec.h src/sparsevec.h src/vector.h
 
 TESTS = $(wildcard test/sql/*.sql)
 REGRESS = $(patsubst test/sql/%.sql,%,$(TESTS))
@@ -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

@@ -2,10 +2,10 @@ EXTENSION = vector
 EXTVERSION = 0.7.4
 
 DATA_built = sql\$(EXTENSION)--$(EXTVERSION).sql
-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
+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\minivec.obj src\sparsevec.obj src\vector.obj
+HEADERS = src\halfvec.h src\minivec.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 btree cast copy halfvec hnsw_bit hnsw_halfvec hnsw_sparsevec hnsw_vector ivfflat_bit ivfflat_halfvec ivfflat_vector minivec sparsevec vector_type
 REGRESS_OPTS = --inputdir=test --load-extension=$(EXTENSION)
 
 # For /arch flags

README.md

@@ -52,8 +52,6 @@ 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).
@@ -102,8 +100,6 @@ 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
@@ -149,8 +145,6 @@ Supported distance functions are:
 - `<#>` - (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
 
@@ -439,12 +433,6 @@ Create an index on one [or more](https://www.postgresql.org/docs/current/indexes
 CREATE INDEX ON items (category_id);
 ```
 
-Or a composite IVFFlat index for approximate search (added in 0.8.0)
-
-```sql
-CREATE INDEX ON items USING ivfflat (embedding vector_l2_ops, category_id) WITH (lists = 100);
-```
-
 Or a [partial index](https://www.postgresql.org/docs/current/indexes-partial.html) on the vector column for approximate search
 
 ```sql
@@ -946,6 +934,37 @@ Function | Description | Added
 avg(halfvec) → halfvec | average | 0.7.0
 sum(halfvec) → halfvec | sum | 0.7.0
 
+### Minivec Type
+
+Each mini vector takes `dimensions + 8` bytes of storage. Each element is a E4M3 8-bit floating-point number, and all elements must be finite (no `NaN`). Mini vectors can have up to 16,000 dimensions.
+
+### Minivec Operators
+
+Operator | Description | Added
+--- | --- | ---
+\+ | element-wise addition | 0.8.0
+\- | element-wise subtraction | 0.8.0
+\* | element-wise multiplication | 0.8.0
+\|\| | concatenate | 0.8.0
+<-> | Euclidean distance | 0.8.0
+<#> | negative inner product | 0.8.0
+<=> | cosine distance | 0.8.0
+<+> | taxicab distance | 0.8.0
+
+### Minivec Functions
+
+Function | Description | Added
+--- | --- | ---
+binary_quantize(minivec) → bit | binary quantize | 0.8.0
+cosine_distance(minivec, minivec) → double precision | cosine distance | 0.8.0
+inner_product(minivec, minivec) → double precision | inner product | 0.8.0
+l1_distance(minivec, minivec) → double precision | taxicab distance | 0.8.0
+l2_distance(minivec, minivec) → double precision | Euclidean distance | 0.8.0
+l2_norm(minivec) → double precision | Euclidean norm | 0.8.0
+l2_normalize(minivec) → minivec | Normalize with Euclidean norm | 0.8.0
+subvector(minivec, integer, integer) → minivec | subvector | 0.8.0
+vector_dims(minivec) → integer | number of dimensions | 0.8.0
+
 ### Bit Type
 
 Each bit vector takes `dimensions / 8 + 8` bytes of storage. See the [Postgres docs](https://www.postgresql.org/docs/current/datatype-bit.html) for more info.
@@ -995,7 +1014,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:
@@ -1006,11 +1025,11 @@ sudo --preserve-env=PG_CONFIG make install
 
 A few common paths on Mac are:
 
-- EDB installer - `/Library/PostgreSQL/17/bin/pg_config`
-- Homebrew (arm64) - `/opt/homebrew/opt/postgresql@17/bin/pg_config`
-- Homebrew (x86-64) - `/usr/local/opt/postgresql@17/bin/pg_config`
+- EDB installer - `/Library/PostgreSQL/16/bin/pg_config`
+- Homebrew (arm64) - `/opt/homebrew/opt/postgresql@16/bin/pg_config`
+- Homebrew (x86-64) - `/usr/local/opt/postgresql@16/bin/pg_config`
 
-Note: Replace `17` with your Postgres server version
+Note: Replace `16` with your Postgres server version
 
 ### Missing Header
 
@@ -1019,10 +1038,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
 
@@ -1055,17 +1074,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
 cd pgvector
-docker build --pull --build-arg PG_MAJOR=17 -t myuser/pgvector .
+docker build --pull --build-arg PG_MAJOR=16 -t myuser/pgvector .
 ```
 
 ### Homebrew
@@ -1076,7 +1095,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
 
@@ -1091,22 +1110,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.7.4--0.8.0.sql

@@ -1,6 +1,8 @@
 -- 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
 
+-- TODO minivec functions
+
 CREATE FUNCTION array_to_sparsevec(integer[], integer, boolean) RETURNS sparsevec
 	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
 
@@ -24,5 +26,3 @@ CREATE CAST (double precision[] AS sparsevec)
 
 CREATE CAST (numeric[] AS sparsevec)
 	WITH FUNCTION array_to_sparsevec(numeric[], integer, boolean) AS ASSIGNMENT;
-
--- TODO add ivfflat attributes

sql/vector.sql

@@ -266,12 +266,18 @@ COMMENT ON ACCESS METHOD hnsw IS 'hnsw index access method';
 CREATE FUNCTION ivfflat_halfvec_support(internal) RETURNS internal
 	AS 'MODULE_PATHNAME' LANGUAGE C;
 
+CREATE FUNCTION ivfflat_minivec_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_minivec_support(internal) RETURNS internal
+	AS 'MODULE_PATHNAME' LANGUAGE C;
+
 CREATE FUNCTION hnsw_bit_support(internal) RETURNS internal
 	AS 'MODULE_PATHNAME' LANGUAGE C;
 
@@ -647,6 +653,295 @@ CREATE OPERATOR CLASS halfvec_l1_ops
 	FUNCTION 1 l1_distance(halfvec, halfvec),
 	FUNCTION 3 hnsw_halfvec_support(internal);
 
+-- minivec type
+
+CREATE TYPE minivec;
+
+CREATE FUNCTION minivec_in(cstring, oid, integer) RETURNS minivec
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION minivec_out(minivec) RETURNS cstring
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION minivec_typmod_in(cstring[]) RETURNS integer
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION minivec_recv(internal, oid, integer) RETURNS minivec
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION minivec_send(minivec) RETURNS bytea
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE TYPE minivec (
+	INPUT     = minivec_in,
+	OUTPUT    = minivec_out,
+	TYPMOD_IN = minivec_typmod_in,
+	RECEIVE   = minivec_recv,
+	SEND      = minivec_send,
+	STORAGE   = external
+);
+
+-- minivec functions
+
+CREATE FUNCTION l2_distance(minivec, minivec) RETURNS float8
+	AS 'MODULE_PATHNAME', 'minivec_l2_distance' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION inner_product(minivec, minivec) RETURNS float8
+	AS 'MODULE_PATHNAME', 'minivec_inner_product' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION cosine_distance(minivec, minivec) RETURNS float8
+	AS 'MODULE_PATHNAME', 'minivec_cosine_distance' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION l1_distance(minivec, minivec) RETURNS float8
+	AS 'MODULE_PATHNAME', 'minivec_l1_distance' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION vector_dims(minivec) RETURNS integer
+	AS 'MODULE_PATHNAME', 'minivec_vector_dims' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION l2_norm(minivec) RETURNS float8
+	AS 'MODULE_PATHNAME', 'minivec_l2_norm' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION l2_normalize(minivec) RETURNS minivec
+	AS 'MODULE_PATHNAME', 'minivec_l2_normalize' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION binary_quantize(minivec) RETURNS bit
+	AS 'MODULE_PATHNAME', 'minivec_binary_quantize' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION subvector(minivec, int, int) RETURNS minivec
+	AS 'MODULE_PATHNAME', 'minivec_subvector' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+-- minivec private functions
+
+CREATE FUNCTION minivec_add(minivec, minivec) RETURNS minivec
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION minivec_sub(minivec, minivec) RETURNS minivec
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION minivec_mul(minivec, minivec) RETURNS minivec
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION minivec_concat(minivec, minivec) RETURNS minivec
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION minivec_lt(minivec, minivec) RETURNS bool
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION minivec_le(minivec, minivec) RETURNS bool
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION minivec_eq(minivec, minivec) RETURNS bool
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION minivec_ne(minivec, minivec) RETURNS bool
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION minivec_ge(minivec, minivec) RETURNS bool
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION minivec_gt(minivec, minivec) RETURNS bool
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION minivec_cmp(minivec, minivec) RETURNS int4
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION minivec_l2_squared_distance(minivec, minivec) RETURNS float8
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION minivec_negative_inner_product(minivec, minivec) RETURNS float8
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION minivec_spherical_distance(minivec, minivec) RETURNS float8
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+-- minivec cast functions
+
+CREATE FUNCTION minivec(minivec, integer, boolean) RETURNS minivec
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION minivec_to_vector(minivec, integer, boolean) RETURNS vector
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION vector_to_minivec(vector, integer, boolean) RETURNS minivec
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION array_to_minivec(integer[], integer, boolean) RETURNS minivec
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION array_to_minivec(real[], integer, boolean) RETURNS minivec
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION array_to_minivec(double precision[], integer, boolean) RETURNS minivec
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION array_to_minivec(numeric[], integer, boolean) RETURNS minivec
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION minivec_to_float4(minivec, integer, boolean) RETURNS real[]
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+-- minivec casts
+
+CREATE CAST (minivec AS minivec)
+	WITH FUNCTION minivec(minivec, integer, boolean) AS IMPLICIT;
+
+CREATE CAST (minivec AS vector)
+	WITH FUNCTION minivec_to_vector(minivec, integer, boolean) AS ASSIGNMENT;
+
+CREATE CAST (vector AS minivec)
+	WITH FUNCTION vector_to_minivec(vector, integer, boolean) AS IMPLICIT;
+
+CREATE CAST (minivec AS real[])
+	WITH FUNCTION minivec_to_float4(minivec, integer, boolean) AS ASSIGNMENT;
+
+CREATE CAST (integer[] AS minivec)
+	WITH FUNCTION array_to_minivec(integer[], integer, boolean) AS ASSIGNMENT;
+
+CREATE CAST (real[] AS minivec)
+	WITH FUNCTION array_to_minivec(real[], integer, boolean) AS ASSIGNMENT;
+
+CREATE CAST (double precision[] AS minivec)
+	WITH FUNCTION array_to_minivec(double precision[], integer, boolean) AS ASSIGNMENT;
+
+CREATE CAST (numeric[] AS minivec)
+	WITH FUNCTION array_to_minivec(numeric[], integer, boolean) AS ASSIGNMENT;
+
+-- minivec operators
+
+CREATE OPERATOR <-> (
+	LEFTARG = minivec, RIGHTARG = minivec, PROCEDURE = l2_distance,
+	COMMUTATOR = '<->'
+);
+
+CREATE OPERATOR <#> (
+	LEFTARG = minivec, RIGHTARG = minivec, PROCEDURE = minivec_negative_inner_product,
+	COMMUTATOR = '<#>'
+);
+
+CREATE OPERATOR <=> (
+	LEFTARG = minivec, RIGHTARG = minivec, PROCEDURE = cosine_distance,
+	COMMUTATOR = '<=>'
+);
+
+CREATE OPERATOR <+> (
+	LEFTARG = minivec, RIGHTARG = minivec, PROCEDURE = l1_distance,
+	COMMUTATOR = '<+>'
+);
+
+CREATE OPERATOR + (
+	LEFTARG = minivec, RIGHTARG = minivec, PROCEDURE = minivec_add,
+	COMMUTATOR = +
+);
+
+CREATE OPERATOR - (
+	LEFTARG = minivec, RIGHTARG = minivec, PROCEDURE = minivec_sub
+);
+
+CREATE OPERATOR * (
+	LEFTARG = minivec, RIGHTARG = minivec, PROCEDURE = minivec_mul,
+	COMMUTATOR = *
+);
+
+CREATE OPERATOR || (
+	LEFTARG = minivec, RIGHTARG = minivec, PROCEDURE = minivec_concat
+);
+
+CREATE OPERATOR < (
+	LEFTARG = minivec, RIGHTARG = minivec, PROCEDURE = minivec_lt,
+	COMMUTATOR = > , NEGATOR = >= ,
+	RESTRICT = scalarltsel, JOIN = scalarltjoinsel
+);
+
+CREATE OPERATOR <= (
+	LEFTARG = minivec, RIGHTARG = minivec, PROCEDURE = minivec_le,
+	COMMUTATOR = >= , NEGATOR = > ,
+	RESTRICT = scalarlesel, JOIN = scalarlejoinsel
+);
+
+CREATE OPERATOR = (
+	LEFTARG = minivec, RIGHTARG = minivec, PROCEDURE = minivec_eq,
+	COMMUTATOR = = , NEGATOR = <> ,
+	RESTRICT = eqsel, JOIN = eqjoinsel
+);
+
+CREATE OPERATOR <> (
+	LEFTARG = minivec, RIGHTARG = minivec, PROCEDURE = minivec_ne,
+	COMMUTATOR = <> , NEGATOR = = ,
+	RESTRICT = eqsel, JOIN = eqjoinsel
+);
+
+CREATE OPERATOR >= (
+	LEFTARG = minivec, RIGHTARG = minivec, PROCEDURE = minivec_ge,
+	COMMUTATOR = <= , NEGATOR = < ,
+	RESTRICT = scalargesel, JOIN = scalargejoinsel
+);
+
+CREATE OPERATOR > (
+	LEFTARG = minivec, RIGHTARG = minivec, PROCEDURE = minivec_gt,
+	COMMUTATOR = < , NEGATOR = <= ,
+	RESTRICT = scalargtsel, JOIN = scalargtjoinsel
+);
+
+-- minivec op classes
+
+CREATE OPERATOR CLASS minivec_ops
+	DEFAULT FOR TYPE minivec USING btree AS
+	OPERATOR 1 < ,
+	OPERATOR 2 <= ,
+	OPERATOR 3 = ,
+	OPERATOR 4 >= ,
+	OPERATOR 5 > ,
+	FUNCTION 1 minivec_cmp(minivec, minivec);
+
+CREATE OPERATOR CLASS minivec_l2_ops
+	FOR TYPE minivec USING ivfflat AS
+	OPERATOR 1 <-> (minivec, minivec) FOR ORDER BY float_ops,
+	FUNCTION 1 minivec_l2_squared_distance(minivec, minivec),
+	FUNCTION 3 l2_distance(minivec, minivec),
+	FUNCTION 5 ivfflat_minivec_support(internal);
+
+CREATE OPERATOR CLASS minivec_ip_ops
+	FOR TYPE minivec USING ivfflat AS
+	OPERATOR 1 <#> (minivec, minivec) FOR ORDER BY float_ops,
+	FUNCTION 1 minivec_negative_inner_product(minivec, minivec),
+	FUNCTION 3 minivec_spherical_distance(minivec, minivec),
+	FUNCTION 4 l2_norm(minivec),
+	FUNCTION 5 ivfflat_minivec_support(internal);
+
+CREATE OPERATOR CLASS minivec_cosine_ops
+	FOR TYPE minivec USING ivfflat AS
+	OPERATOR 1 <=> (minivec, minivec) FOR ORDER BY float_ops,
+	FUNCTION 1 cosine_distance(minivec, minivec),
+	FUNCTION 2 l2_norm(minivec),
+	FUNCTION 3 minivec_spherical_distance(minivec, minivec),
+	FUNCTION 4 l2_norm(minivec),
+	FUNCTION 5 ivfflat_minivec_support(internal);
+
+CREATE OPERATOR CLASS minivec_l2_ops
+	FOR TYPE minivec USING hnsw AS
+	OPERATOR 1 <-> (minivec, minivec) FOR ORDER BY float_ops,
+	FUNCTION 1 minivec_l2_squared_distance(minivec, minivec),
+	FUNCTION 3 hnsw_minivec_support(internal);
+
+CREATE OPERATOR CLASS minivec_ip_ops
+	FOR TYPE minivec USING hnsw AS
+	OPERATOR 1 <#> (minivec, minivec) FOR ORDER BY float_ops,
+	FUNCTION 1 minivec_negative_inner_product(minivec, minivec),
+	FUNCTION 3 hnsw_minivec_support(internal);
+
+CREATE OPERATOR CLASS minivec_cosine_ops
+	FOR TYPE minivec USING hnsw AS
+	OPERATOR 1 <=> (minivec, minivec) FOR ORDER BY float_ops,
+	FUNCTION 1 cosine_distance(minivec, minivec),
+	FUNCTION 2 l2_norm(minivec),
+	FUNCTION 3 hnsw_minivec_support(internal);
+
+CREATE OPERATOR CLASS minivec_l1_ops
+	FOR TYPE minivec USING hnsw AS
+	OPERATOR 1 <+> (minivec, minivec) FOR ORDER BY float_ops,
+	FUNCTION 1 l1_distance(minivec, minivec),
+	FUNCTION 3 hnsw_minivec_support(internal);
+
 -- bit functions
 
 CREATE FUNCTION hamming_distance(bit, bit) RETURNS float8
@@ -916,13 +1211,3 @@ CREATE OPERATOR CLASS sparsevec_l1_ops
 	OPERATOR 1 <+> (sparsevec, sparsevec) FOR ORDER BY float_ops,
 	FUNCTION 1 l1_distance(sparsevec, sparsevec),
 	FUNCTION 3 hnsw_sparsevec_support(internal);
-
--- ivfflat attributes
-
-CREATE OPERATOR CLASS vector_integer_ops
-	DEFAULT FOR TYPE integer USING ivfflat AS
-	OPERATOR 2 < ,
-	OPERATOR 3 <= ,
-	OPERATOR 4 = ,
-	OPERATOR 5 >= ,
-	OPERATOR 6 > ;

src/hnsw.c

@@ -12,7 +12,6 @@
 #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)
@@ -100,9 +99,7 @@ hnswcostestimate(PlannerInfo *root, IndexPath *path, double loop_count,
 {
 	GenericCosts costs;
 	int			m;
-	double		ratio;
-	double		startupPages;
-	double		spc_seq_page_cost;
+	int			entryLevel;
 	Relation	index;
 
 	/* Never use index without order */
@@ -118,71 +115,21 @@ hnswcostestimate(PlannerInfo *root, IndexPath *path, double loop_count,
 
 	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);
 
-	/*
-	 * HNSW cost estimation follows a formula that accounts for the total
-	 * 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)));
+	/* Approximate entry level */
+	entryLevel = (int) -log(1.0 / path->indexinfo->tuples) * HnswGetMl(m);
 
-		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)
-			ratio = 1;
-	}
-	else
-		ratio = 1;
+	genericcostestimate(root, path, loop_count, &costs);
 
-	get_tablespace_page_costs(path->indexinfo->reltablespace, NULL, &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 (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;
+	/* Use total cost since most work happens before first tuple is returned */
+	*indexStartupCost = costs.indexTotalCost;
 	*indexTotalCost = costs.indexTotalCost;
 	*indexSelectivity = costs.indexSelectivity;
 	*indexCorrelation = costs.indexCorrelation;

src/hnsw.h

@@ -88,9 +88,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
@@ -163,7 +160,7 @@ typedef struct HnswSearchCandidate
 	pairingheap_node c_node;
 	pairingheap_node w_node;
 	HnswElementPtr element;
-	double		distance;
+	float		distance;
 }			HnswSearchCandidate;
 
 /* HNSW index options */
@@ -188,8 +185,8 @@ typedef struct HnswGraph
 
 	/* Allocations state */
 	LWLock		allocatorLock;
-	Size		memoryUsed;
-	Size		memoryTotal;
+	long		memoryUsed;
+	long		memoryTotal;
 
 	/* Flushed state */
 	LWLock		flushLock;
@@ -240,18 +237,6 @@ typedef struct HnswTypeInfo
 	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 */
@@ -271,7 +256,9 @@ typedef struct HnswBuildState
 	double		reltuples;
 
 	/* Support functions */
-	HnswSupport support;
+	FmgrInfo   *procinfo;
+	FmgrInfo   *normprocinfo;
+	Oid			collation;
 
 	/* Variables */
 	HnswGraph	graphData;
@@ -338,19 +325,6 @@ typedef struct 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;
@@ -359,7 +333,9 @@ typedef struct HnswScanOpaqueData
 	MemoryContext tmpCtx;
 
 	/* Support functions */
-	HnswSupport support;
+	FmgrInfo   *procinfo;
+	FmgrInfo   *normprocinfo;
+	Oid			collation;
 }			HnswScanOpaqueData;
 
 typedef HnswScanOpaqueData * HnswScanOpaque;
@@ -377,7 +353,8 @@ typedef struct HnswVacuumState
 	int			efConstruction;
 
 	/* Support functions */
-	HnswSupport support;
+	FmgrInfo   *procinfo;
+	Oid			collation;
 
 	/* Variables */
 	struct tidhash_hash *deleted;
@@ -393,33 +370,30 @@ typedef struct HnswVacuumState
 int			HnswGetM(Relation index);
 int			HnswGetEfConstruction(Relation index);
 FmgrInfo   *HnswOptionalProcInfo(Relation index, uint16 procnum);
-void		HnswInitSupport(HnswSupport * support, Relation index);
 Datum		HnswNormValue(const HnswTypeInfo * typeInfo, Oid collation, Datum value);
-bool		HnswCheckNorm(HnswSupport * support, Datum value);
+bool		HnswCheckNorm(FmgrInfo *procinfo, Oid collation, Datum value);
 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);
+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);
-HnswSearchCandidate *HnswEntryCandidate(char *base, HnswElement em, HnswQuery * q, Relation rel, HnswSupport * support, bool loadVec);
+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, 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);
-void		HnswUpdateNeighborsOnDisk(Relation index, HnswSupport * support, HnswElement e, int m, bool checkExisting, bool building);
+bool		HnswInsertTupleOnDisk(Relation index, Datum value, Datum *values, bool *isnull, ItemPointer heap_tid, bool building);
+void		HnswUpdateNeighborsOnDisk(Relation index, FmgrInfo *procinfo, Oid collation, HnswElement e, int m, bool checkExisting, bool building);
 void		HnswLoadElementFromTuple(HnswElement element, HnswElementTuple etup, bool loadHeaptids, bool loadVec);
-void		HnswLoadElement(HnswElement element, double *distance, HnswQuery * q, Relation index, HnswSupport * support, bool loadVec, double *maxDistance);
-bool		HnswFormIndexValue(Datum *out, Datum *values, bool *isnull, const HnswTypeInfo * typeInfo, HnswSupport * support);
+void		HnswLoadElement(HnswElement element, float *distance, Datum *q, Relation index, FmgrInfo *procinfo, Oid collation, bool loadVec, float *maxDistance);
 void		HnswSetElementTuple(char *base, HnswElementTuple etup, HnswElement element);
-void		HnswUpdateConnection(char *base, HnswNeighborArray * neighbors, HnswElement newElement, float distance, int lm, int *updateIdx, Relation index, HnswSupport * support);
-bool		HnswLoadNeighborTids(HnswElement element, ItemPointerData *indextids, Relation index, int m, int lm, int lc);
+void		HnswUpdateConnection(char *base, HnswElement element, HnswCandidate * hc, int lm, int lc, int *updateIdx, Relation index, FmgrInfo *procinfo, Oid collation);
+void		HnswLoadNeighbors(HnswElement element, Relation index, int m);
 void		HnswInitLockTranche(void);
 const		HnswTypeInfo *HnswGetTypeInfo(Relation index);
 PGDLLEXPORT void HnswParallelBuildMain(dsm_segment *seg, shm_toc *toc);

src/hnswbuild.c

@@ -366,7 +366,7 @@ 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--)
 	{
@@ -388,7 +388,7 @@ UpdateNeighborsInMemory(char *base, HnswSupport * support, HnswElement e, int m)
 			Assert(neighborElement);
 
 			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 +398,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 +411,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 +424,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 +458,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);
@@ -472,19 +473,30 @@ InsertTupleInMemory(HnswBuildState * buildstate, HnswElement element)
 static bool
 InsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heaptid, HnswBuildState * buildstate)
 {
+	const		HnswTypeInfo *typeInfo = buildstate->typeInfo;
 	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 */
-	if (!HnswFormIndexValue(&value, values, isnull, buildstate->typeInfo, support))
-		return false;
+	/* Detoast once for all calls */
+	Datum		value = PointerGetDatum(PG_DETOAST_DATUM(values[0]));
+
+	/* Check value */
+	if (typeInfo->checkValue != NULL)
+		typeInfo->checkValue(DatumGetPointer(value));
+
+	/* Normalize if needed */
+	if (buildstate->normprocinfo != NULL)
+	{
+		if (!HnswCheckNorm(buildstate->normprocinfo, buildstate->collation, value))
+			return false;
+
+		value = HnswNormValue(typeInfo, buildstate->collation, value);
+	}
 
 	/* Get datum size */
 	valueSize = VARSIZE_ANY(DatumGetPointer(value));
@@ -497,7 +509,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 +541,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 */
@@ -595,7 +607,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();
@@ -692,9 +704,11 @@ InitBuildState(HnswBuildState * buildstate, Relation heap, Relation index, Index
 	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);

src/hnswinsert.c

@@ -334,107 +334,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
  */
@@ -455,94 +354,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);
@@ -551,20 +370,96 @@ 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. Could use
+			 * optimistic locking to retry if another update occurs before
+			 * getting exclusive lock.
+			 */
+			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);
 }
 
 /*
@@ -654,7 +549,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;
 
@@ -670,7 +565,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)
@@ -681,12 +576,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;
 
@@ -701,7 +598,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 */
@@ -719,10 +616,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);
@@ -734,19 +631,31 @@ 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);
-	HnswSupport support;
+	FmgrInfo   *normprocinfo;
+	Oid			collation = index->rd_indcollation[0];
 
-	HnswInitSupport(&support, index);
+	/* Detoast once for all calls */
+	value = PointerGetDatum(PG_DETOAST_DATUM(values[0]));
 
-	/* Form index value */
-	if (!HnswFormIndexValue(&value, values, isnull, typeInfo, &support))
-		return;
+	/* Check value */
+	if (typeInfo->checkValue != NULL)
+		typeInfo->checkValue(DatumGetPointer(value));
 
-	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(typeInfo, collation, value);
+	}
+
+	HnswInsertTupleOnDisk(index, value, values, isnull, heap_tid, false);
 }
 
 /*

src/hnswscan.c

@@ -11,19 +11,17 @@
  * 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;
-
-	q.value = value;
 
 	/* Get m and entry point */
 	HnswGetMetaPageInfo(index, &m, &entryPoint);
@@ -31,15 +29,15 @@ GetScanItems(IndexScanDesc scan, Datum value)
 	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);
+		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);
+	return HnswSearchLayer(base, q, ep, hnsw_ef_search, 0, index, procinfo, collation, m, false, NULL);
 }
 
 /*
@@ -62,8 +60,8 @@ GetScanValue(IndexScanDesc scan)
 		Assert(!VARATT_IS_EXTENDED(DatumGetPointer(value)));
 
 		/* Normalize if needed */
-		if (so->support.normprocinfo != NULL)
-			value = HnswNormValue(so->typeInfo, so->support.collation, value);
+		if (so->normprocinfo != NULL)
+			value = HnswNormValue(so->typeInfo, so->collation, value);
 	}
 
 	return value;
@@ -88,7 +86,9 @@ hnswbeginscan(Relation index, int nkeys, int norderbys)
 									   ALLOCSET_DEFAULT_SIZES);
 
 	/* Set support functions */
-	HnswInitSupport(&so->support, index);
+	so->procinfo = index_getprocinfo(index, 1, HNSW_DISTANCE_PROC);
+	so->normprocinfo = HnswOptionalProcInfo(index, HNSW_NORM_PROC);
+	so->collation = index->rd_indcollation[0];
 
 	scan->opaque = so;
 
@@ -168,8 +168,8 @@ hnswgettuple(IndexScanDesc scan, ScanDirection dir)
 	while (list_length(so->w) > 0)
 	{
 		char	   *base = NULL;
-		HnswSearchCandidate *sc = llast(so->w);
-		HnswElement element = HnswPtrAccess(base, sc->element);
+		HnswSearchCandidate *hc = llast(so->w);
+		HnswElement element = HnswPtrAccess(base, hc->element);
 		ItemPointer heaptid;
 
 		/* Move to next element if no valid heap TIDs */

src/hnswutils.c

@@ -100,6 +100,19 @@ hash_offset(Size offset)
 #define SH_DEFINE
 #include "lib/simplehash.h"
 
+typedef union
+{
+	pointerhash_hash *pointers;
+	offsethash_hash *offsets;
+	tidhash_hash *tids;
+}			visited_hash;
+
+typedef union
+{
+	HnswElement element;
+	ItemPointerData indextid;
+}			HnswUnvisited;
+
 /*
  * Get the max number of connections in an upper layer for each element in the index
  */
@@ -140,23 +153,15 @@ HnswOptionalProcInfo(Relation index, uint16 procnum)
 	return index_getprocinfo(index, 1, procnum);
 }
 
-/*
- * Init support functions
- */
-void
-HnswInitSupport(HnswSupport * support, Relation index)
-{
-	support->procinfo = index_getprocinfo(index, 1, HNSW_DISTANCE_PROC);
-	support->collation = index->rd_indcollation[0];
-	support->normprocinfo = HnswOptionalProcInfo(index, HNSW_NORM_PROC);
-}
-
 /*
  * Normalize value
  */
 Datum
 HnswNormValue(const HnswTypeInfo * typeInfo, Oid collation, Datum value)
 {
+	if (!typeInfo->normalize)
+		return value;
+
 	return DirectFunctionCall1Coll(typeInfo->normalize, collation, value);
 }
 
@@ -164,9 +169,9 @@ HnswNormValue(const HnswTypeInfo * typeInfo, Oid collation, Datum value)
  * Check if non-zero norm
  */
 bool
-HnswCheckNorm(HnswSupport * support, Datum value)
+HnswCheckNorm(FmgrInfo *procinfo, Oid collation, Datum value)
 {
-	return DatumGetFloat8(FunctionCall1Coll(support->normprocinfo, support->collation, value)) > 0;
+	return DatumGetFloat8(FunctionCall1Coll(procinfo, collation, value)) > 0;
 }
 
 /*
@@ -195,7 +200,7 @@ HnswInitPage(Buffer buf, Page page)
 /*
  * Allocate a neighbor array
  */
-HnswNeighborArray *
+static HnswNeighborArray *
 HnswInitNeighborArray(int lm, HnswAllocator * allocator)
 {
 	HnswNeighborArray *a = HnswAlloc(allocator, HNSW_NEIGHBOR_ARRAY_SIZE(lm));
@@ -392,33 +397,6 @@ HnswUpdateMetaPage(Relation index, int updateEntry, HnswElement entryPoint, Bloc
 	UnlockReleaseBuffer(buf);
 }
 
-/*
- * Form index value
- */
-bool
-HnswFormIndexValue(Datum *out, Datum *values, bool *isnull, const HnswTypeInfo * typeInfo, HnswSupport * support)
-{
-	/* Detoast once for all calls */
-	Datum		value = PointerGetDatum(PG_DETOAST_DATUM(values[0]));
-
-	/* Check value */
-	if (typeInfo->checkValue != NULL)
-		typeInfo->checkValue(DatumGetPointer(value));
-
-	/* Normalize if needed */
-	if (support->normprocinfo != NULL)
-	{
-		if (!HnswCheckNorm(support, value))
-			return false;
-
-		value = HnswNormValue(typeInfo, support->collation, value);
-	}
-
-	*out = value;
-
-	return true;
-}
-
 /*
  * Set element tuple, except for neighbor info
  */
@@ -474,6 +452,69 @@ HnswSetNeighborTuple(char *base, HnswNeighborTuple ntup, HnswElement e, int m)
 	ntup->count = idx;
 }
 
+/*
+ * Load neighbors from page
+ */
+static void
+LoadNeighborsFromPage(HnswElement element, Relation index, Page page, int m)
+{
+	char	   *base = NULL;
+
+	HnswNeighborTuple ntup = (HnswNeighborTuple) PageGetItem(page, PageGetItemId(page, element->neighborOffno));
+	int			neighborCount = (element->level + 2) * m;
+
+	Assert(HnswIsNeighborTuple(ntup));
+
+	HnswInitNeighbors(base, element, m, NULL);
+
+	/* Ensure expected neighbors */
+	if (ntup->count != neighborCount)
+		return;
+
+	for (int i = 0; i < neighborCount; i++)
+	{
+		HnswElement e;
+		int			level;
+		HnswCandidate *hc;
+		ItemPointer indextid;
+		HnswNeighborArray *neighbors;
+
+		indextid = &ntup->indextids[i];
+
+		if (!ItemPointerIsValid(indextid))
+			continue;
+
+		e = HnswInitElementFromBlock(ItemPointerGetBlockNumber(indextid), ItemPointerGetOffsetNumber(indextid));
+
+		/* Calculate level based on offset */
+		level = element->level - i / m;
+		if (level < 0)
+			level = 0;
+
+		neighbors = HnswGetNeighbors(base, element, level);
+		hc = &neighbors->items[neighbors->length++];
+		HnswPtrStore(base, hc->element, e);
+	}
+}
+
+/*
+ * Load neighbors
+ */
+void
+HnswLoadNeighbors(HnswElement element, Relation index, int m)
+{
+	Buffer		buf;
+	Page		page;
+
+	buf = ReadBuffer(index, element->neighborPage);
+	LockBuffer(buf, BUFFER_LOCK_SHARE);
+	page = BufferGetPage(buf);
+
+	LoadNeighborsFromPage(element, index, page, m);
+
+	UnlockReleaseBuffer(buf);
+}
+
 /*
  * Load an element from a tuple
  */
@@ -507,20 +548,11 @@ HnswLoadElementFromTuple(HnswElement element, HnswElementTuple etup, bool loadHe
 	}
 }
 
-/*
- * Calculate the distance between values
- */
-static inline double
-HnswGetDistance(Datum a, Datum b, HnswSupport * support)
-{
-	return DatumGetFloat8(FunctionCall2Coll(support->procinfo, support->collation, a, b));
-}
-
 /*
  * Load an element and optionally get its distance from q
  */
 static void
-HnswLoadElementImpl(BlockNumber blkno, OffsetNumber offno, double *distance, HnswQuery * q, Relation index, HnswSupport * support, bool loadVec, double *maxDistance, HnswElement * element)
+HnswLoadElementImpl(BlockNumber blkno, OffsetNumber offno, float *distance, Datum *q, Relation index, FmgrInfo *procinfo, Oid collation, bool loadVec, float *maxDistance, HnswElement * element)
 {
 	Buffer		buf;
 	Page		page;
@@ -538,10 +570,10 @@ HnswLoadElementImpl(BlockNumber blkno, OffsetNumber offno, double *distance, Hns
 	/* Calculate distance */
 	if (distance != NULL)
 	{
-		if (DatumGetPointer(q->value) == NULL)
+		if (DatumGetPointer(*q) == NULL)
 			*distance = 0;
 		else
-			*distance = HnswGetDistance(q->value, PointerGetDatum(&etup->data), support);
+			*distance = (float) DatumGetFloat8(FunctionCall2Coll(procinfo, collation, *q, PointerGetDatum(&etup->data)));
 	}
 
 	/* Load element */
@@ -560,39 +592,41 @@ HnswLoadElementImpl(BlockNumber blkno, OffsetNumber offno, double *distance, Hns
  * Load an element and optionally get its distance from q
  */
 void
-HnswLoadElement(HnswElement element, double *distance, HnswQuery * q, Relation index, HnswSupport * support, bool loadVec, double *maxDistance)
+HnswLoadElement(HnswElement element, float *distance, Datum *q, Relation index, FmgrInfo *procinfo, Oid collation, bool loadVec, float *maxDistance)
 {
-	HnswLoadElementImpl(element->blkno, element->offno, distance, q, index, support, loadVec, maxDistance, &element);
+	HnswLoadElementImpl(element->blkno, element->offno, distance, q, index, procinfo, collation, loadVec, maxDistance, &element);
 }
 
 /*
  * Get the distance for an element
  */
-static double
-GetElementDistance(char *base, HnswElement element, HnswQuery * q, HnswSupport * support)
+static float
+GetElementDistance(char *base, HnswElement element, Datum q, FmgrInfo *procinfo, Oid collation)
 {
 	Datum		value = HnswGetValue(base, element);
 
-	return HnswGetDistance(q->value, value, support);
+	return DatumGetFloat8(FunctionCall2Coll(procinfo, collation, q, value));
 }
 
 /*
  * Create a candidate for the entry point
  */
 HnswSearchCandidate *
-HnswEntryCandidate(char *base, HnswElement entryPoint, HnswQuery * q, Relation index, HnswSupport * support, bool loadVec)
+HnswEntryCandidate(char *base, HnswElement entryPoint, Datum q, Relation index, FmgrInfo *procinfo, Oid collation, bool loadVec)
 {
-	HnswSearchCandidate *sc = palloc(sizeof(HnswSearchCandidate));
-	bool		inMemory = index == NULL;
+	HnswSearchCandidate *hc = palloc(sizeof(HnswSearchCandidate));
 
-	HnswPtrStore(base, sc->element, entryPoint);
-	if (inMemory)
-		sc->distance = GetElementDistance(base, entryPoint, q, support);
+	HnswPtrStore(base, hc->element, entryPoint);
+	if (index == NULL)
+		hc->distance = GetElementDistance(base, entryPoint, q, procinfo, collation);
 	else
-		HnswLoadElement(entryPoint, &sc->distance, q, index, support, loadVec, NULL);
-	return sc;
+		HnswLoadElement(entryPoint, &hc->distance, &q, index, procinfo, collation, loadVec, NULL);
+	return hc;
 }
 
+#define HnswGetSearchCandidate(membername, ptr) pairingheap_container(HnswSearchCandidate, membername, ptr)
+#define HnswGetSearchCandidateConst(membername, ptr) pairingheap_const_container(HnswSearchCandidate, membername, ptr)
+
 /*
  * Compare candidate distances
  */
@@ -627,9 +661,9 @@ CompareFurthestCandidates(const pairingheap_node *a, const pairingheap_node *b,
  * Init visited
  */
 static inline void
-InitVisited(char *base, visited_hash * v, bool inMemory, int ef, int m)
+InitVisited(char *base, visited_hash * v, Relation index, int ef, int m)
 {
-	if (!inMemory)
+	if (index != NULL)
 		v->tids = tidhash_create(CurrentMemoryContext, ef * m * 2, NULL);
 	else if (base != NULL)
 		v->offsets = offsethash_create(CurrentMemoryContext, ef * m * 2, NULL);
@@ -641,9 +675,9 @@ InitVisited(char *base, visited_hash * v, bool inMemory, int ef, int m)
  * Add to visited
  */
 static inline void
-AddToVisited(char *base, visited_hash * v, HnswElementPtr elementPtr, bool inMemory, bool *found)
+AddToVisited(char *base, visited_hash * v, HnswElementPtr elementPtr, Relation index, bool *found)
 {
-	if (!inMemory)
+	if (index != NULL)
 	{
 		HnswElement element = HnswPtrAccess(base, elementPtr);
 		ItemPointerData indextid;
@@ -704,57 +738,38 @@ HnswLoadUnvisitedFromMemory(char *base, HnswElement element, HnswUnvisited * unv
 		HnswCandidate *hc = &localNeighborhood->items[i];
 		bool		found;
 
-		AddToVisited(base, v, hc->element, true, &found);
+		AddToVisited(base, v, hc->element, NULL, &found);
 
 		if (!found)
 			unvisited[(*unvisitedLength)++].element = HnswPtrAccess(base, hc->element);
 	}
 }
 
-/*
- * Load neighbor index TIDs
- */
-bool
-HnswLoadNeighborTids(HnswElement element, ItemPointerData *indextids, Relation index, int m, int lm, int lc)
-{
-	Buffer		buf;
-	Page		page;
-	HnswNeighborTuple ntup;
-	int			start;
-
-	buf = ReadBuffer(index, element->neighborPage);
-	LockBuffer(buf, BUFFER_LOCK_SHARE);
-	page = BufferGetPage(buf);
-
-	ntup = (HnswNeighborTuple) PageGetItem(page, PageGetItemId(page, element->neighborOffno));
-
-	/* Ensure expected neighbors */
-	if (ntup->count != (element->level + 2) * m)
-	{
-		UnlockReleaseBuffer(buf);
-		return false;
-	}
-
-	/* Copy to minimize lock time */
-	start = (element->level - lc) * m;
-	memcpy(indextids, ntup->indextids + start, lm * sizeof(ItemPointerData));
-
-	UnlockReleaseBuffer(buf);
-	return true;
-}
-
 /*
  * Load unvisited neighbors from disk
  */
 static void
 HnswLoadUnvisitedFromDisk(HnswElement element, HnswUnvisited * unvisited, int *unvisitedLength, visited_hash * v, Relation index, int m, int lm, int lc)
 {
+	Buffer		buf;
+	Page		page;
+	HnswNeighborTuple ntup;
+	int			start;
 	ItemPointerData indextids[HNSW_MAX_M * 2];
 
-	*unvisitedLength = 0;
+	buf = ReadBuffer(index, element->neighborPage);
+	LockBuffer(buf, BUFFER_LOCK_SHARE);
+	page = BufferGetPage(buf);
 
-	if (!HnswLoadNeighborTids(element, indextids, index, m, lm, lc))
-		return;
+	ntup = (HnswNeighborTuple) PageGetItem(page, PageGetItemId(page, element->neighborOffno));
+	start = (element->level - lc) * m;
+
+	/* Copy to minimize lock time */
+	memcpy(&indextids, ntup->indextids + start, lm * sizeof(ItemPointerData));
+
+	UnlockReleaseBuffer(buf);
+
+	*unvisitedLength = 0;
 
 	for (int i = 0; i < lm; i++)
 	{
@@ -775,7 +790,7 @@ HnswLoadUnvisitedFromDisk(HnswElement element, HnswUnvisited * unvisited, int *u
  * Algorithm 2 from paper
  */
 List *
-HnswSearchLayer(char *base, HnswQuery * q, List *ep, int ef, int lc, Relation index, HnswSupport * support, int m, bool inserting, HnswElement skipElement)
+HnswSearchLayer(char *base, Datum q, List *ep, int ef, int lc, Relation index, FmgrInfo *procinfo, Oid collation, int m, bool inserting, HnswElement skipElement)
 {
 	List	   *w = NIL;
 	pairingheap *C = pairingheap_allocate(CompareNearestCandidates, NULL);
@@ -788,12 +803,11 @@ HnswSearchLayer(char *base, HnswQuery * q, List *ep, int ef, int lc, Relation in
 	int			lm = HnswGetLayerM(m, lc);
 	HnswUnvisited *unvisited = palloc(lm * sizeof(HnswUnvisited));
 	int			unvisitedLength;
-	bool		inMemory = index == NULL;
 
-	InitVisited(base, &v, inMemory, ef, m);
+	InitVisited(base, &v, index, ef, m);
 
 	/* Create local memory for neighborhood if needed */
-	if (inMemory)
+	if (index == NULL)
 	{
 		neighborhoodSize = HNSW_NEIGHBOR_ARRAY_SIZE(lm);
 		localNeighborhood = palloc(neighborhoodSize);
@@ -802,20 +816,20 @@ HnswSearchLayer(char *base, HnswQuery * q, List *ep, int ef, int lc, Relation in
 	/* Add entry points to v, C, and W */
 	foreach(lc2, ep)
 	{
-		HnswSearchCandidate *sc = (HnswSearchCandidate *) lfirst(lc2);
+		HnswSearchCandidate *hc = (HnswSearchCandidate *) lfirst(lc2);
 		bool		found;
 
-		AddToVisited(base, &v, sc->element, inMemory, &found);
+		AddToVisited(base, &v, hc->element, index, &found);
 
-		pairingheap_add(C, &sc->c_node);
-		pairingheap_add(W, &sc->w_node);
+		pairingheap_add(C, &hc->c_node);
+		pairingheap_add(W, &hc->w_node);
 
 		/*
 		 * Do not count elements being deleted towards ef when vacuuming. It
 		 * would be ideal to do this for inserts as well, but this could
 		 * affect insert performance.
 		 */
-		if (CountElement(skipElement, HnswPtrAccess(base, sc->element)))
+		if (CountElement(skipElement, HnswPtrAccess(base, hc->element)))
 			wlen++;
 	}
 
@@ -830,7 +844,7 @@ HnswSearchLayer(char *base, HnswQuery * q, List *ep, int ef, int lc, Relation in
 
 		cElement = HnswPtrAccess(base, c->element);
 
-		if (inMemory)
+		if (index == NULL)
 			HnswLoadUnvisitedFromMemory(base, cElement, unvisited, &unvisitedLength, &v, lc, localNeighborhood, neighborhoodSize);
 		else
 			HnswLoadUnvisitedFromDisk(cElement, unvisited, &unvisitedLength, &v, index, m, lm, lc);
@@ -839,15 +853,15 @@ HnswSearchLayer(char *base, HnswQuery * q, List *ep, int ef, int lc, Relation in
 		{
 			HnswElement eElement;
 			HnswSearchCandidate *e;
-			double		eDistance;
+			float		eDistance;
 			bool		alwaysAdd = wlen < ef;
 
 			f = HnswGetSearchCandidate(w_node, pairingheap_first(W));
 
-			if (inMemory)
+			if (index == NULL)
 			{
 				eElement = unvisited[i].element;
-				eDistance = GetElementDistance(base, eElement, q, support);
+				eDistance = GetElementDistance(base, eElement, q, procinfo, collation);
 			}
 			else
 			{
@@ -857,7 +871,7 @@ HnswSearchLayer(char *base, HnswQuery * q, List *ep, int ef, int lc, Relation in
 
 				/* Avoid any allocations if not adding */
 				eElement = NULL;
-				HnswLoadElementImpl(blkno, offno, &eDistance, q, index, support, inserting, alwaysAdd ? NULL : &f->distance, &eElement);
+				HnswLoadElementImpl(blkno, offno, &eDistance, &q, index, procinfo, collation, inserting, alwaysAdd ? NULL : &f->distance, &eElement);
 
 				if (eElement == NULL)
 					continue;
@@ -898,9 +912,9 @@ HnswSearchLayer(char *base, HnswQuery * q, List *ep, int ef, int lc, Relation in
 	/* Add each element of W to w */
 	while (!pairingheap_is_empty(W))
 	{
-		HnswSearchCandidate *sc = HnswGetSearchCandidate(w_node, pairingheap_remove_first(W));
+		HnswSearchCandidate *hc = HnswGetSearchCandidate(w_node, pairingheap_remove_first(W));
 
-		w = lappend(w, sc);
+		w = lappend(w, hc);
 	}
 
 	return w;
@@ -954,22 +968,32 @@ CompareCandidateDistancesOffset(const ListCell *a, const ListCell *b)
 	return 0;
 }
 
+/*
+ * Calculate the distance between elements
+ */
+static float
+HnswGetDistance(char *base, HnswElement a, HnswElement b, FmgrInfo *procinfo, Oid collation)
+{
+	Datum		aValue = HnswGetValue(base, a);
+	Datum		bValue = HnswGetValue(base, b);
+
+	return DatumGetFloat8(FunctionCall2Coll(procinfo, collation, aValue, bValue));
+}
+
 /*
  * Check if an element is closer to q than any element from R
  */
 static bool
-CheckElementCloser(char *base, HnswCandidate * e, List *r, HnswSupport * support)
+CheckElementCloser(char *base, HnswCandidate * e, List *r, FmgrInfo *procinfo, Oid collation)
 {
 	HnswElement eElement = HnswPtrAccess(base, e->element);
-	Datum		eValue = HnswGetValue(base, eElement);
 	ListCell   *lc2;
 
 	foreach(lc2, r)
 	{
 		HnswCandidate *ri = lfirst(lc2);
 		HnswElement riElement = HnswPtrAccess(base, ri->element);
-		Datum		riValue = HnswGetValue(base, riElement);
-		float		distance = HnswGetDistance(eValue, riValue, support);
+		float		distance = HnswGetDistance(base, eElement, riElement, procinfo, collation);
 
 		if (distance <= e->distance)
 			return false;
@@ -982,14 +1006,15 @@ CheckElementCloser(char *base, HnswCandidate * e, List *r, HnswSupport * support
  * Algorithm 4 from paper
  */
 static List *
-SelectNeighbors(char *base, List *c, int lm, HnswSupport * support, bool *closerSet, HnswCandidate * newCandidate, HnswCandidate * *pruned, bool sortCandidates)
+SelectNeighbors(char *base, List *c, int lm, int lc, FmgrInfo *procinfo, Oid collation, HnswElement e2, HnswCandidate * newCandidate, HnswCandidate * *pruned, bool sortCandidates)
 {
 	List	   *r = NIL;
 	List	   *w = list_copy(c);
 	HnswCandidate **wd;
 	int			wdlen = 0;
 	int			wdoff = 0;
-	bool		mustCalculate = !(*closerSet);
+	HnswNeighborArray *neighbors = HnswGetNeighbors(base, e2, lc);
+	bool		mustCalculate = !neighbors->closerSet;
 	List	   *added = NIL;
 	bool		removedAny = false;
 
@@ -1016,7 +1041,7 @@ SelectNeighbors(char *base, List *c, int lm, HnswSupport * support, bool *closer
 
 		/* Use previous state of r and wd to skip work when possible */
 		if (mustCalculate)
-			e->closer = CheckElementCloser(base, e, r, support);
+			e->closer = CheckElementCloser(base, e, r, procinfo, collation);
 		else if (list_length(added) > 0)
 		{
 			/* Keep Valgrind happy for in-memory, parallel builds */
@@ -1029,7 +1054,7 @@ SelectNeighbors(char *base, List *c, int lm, HnswSupport * support, bool *closer
 			 */
 			if (e->closer)
 			{
-				e->closer = CheckElementCloser(base, e, added, support);
+				e->closer = CheckElementCloser(base, e, added, procinfo, collation);
 
 				if (!e->closer)
 					removedAny = true;
@@ -1042,7 +1067,7 @@ SelectNeighbors(char *base, List *c, int lm, HnswSupport * support, bool *closer
 				 */
 				if (removedAny)
 				{
-					e->closer = CheckElementCloser(base, e, r, support);
+					e->closer = CheckElementCloser(base, e, r, procinfo, collation);
 					if (e->closer)
 						added = lappend(added, e);
 				}
@@ -1050,7 +1075,7 @@ SelectNeighbors(char *base, List *c, int lm, HnswSupport * support, bool *closer
 		}
 		else if (e == newCandidate)
 		{
-			e->closer = CheckElementCloser(base, e, r, support);
+			e->closer = CheckElementCloser(base, e, r, procinfo, collation);
 			if (e->closer)
 				added = lappend(added, e);
 		}
@@ -1066,7 +1091,7 @@ SelectNeighbors(char *base, List *c, int lm, HnswSupport * support, bool *closer
 	}
 
 	/* Cached value can only be used in future if sorted deterministically */
-	*closerSet = sortCandidates;
+	neighbors->closerSet = sortCandidates;
 
 	/* Keep pruned connections */
 	while (wdoff < wdlen && list_length(r) < lm)
@@ -1101,16 +1126,18 @@ AddConnections(char *base, HnswElement element, List *neighbors, int lc)
  * Update connections
  */
 void
-HnswUpdateConnection(char *base, HnswNeighborArray * neighbors, HnswElement newElement, float distance, int lm, int *updateIdx, Relation index, HnswSupport * support)
+HnswUpdateConnection(char *base, HnswElement element, HnswCandidate * hc, int lm, int lc, int *updateIdx, Relation index, FmgrInfo *procinfo, Oid collation)
 {
-	HnswCandidate newHc;
+	HnswElement hce = HnswPtrAccess(base, hc->element);
+	HnswNeighborArray *currentNeighbors = HnswGetNeighbors(base, hce, lc);
+	HnswCandidate hc2;
 
-	HnswPtrStore(base, newHc.element, newElement);
-	newHc.distance = distance;
+	HnswPtrStore(base, hc2.element, element);
+	hc2.distance = hc->distance;
 
-	if (neighbors->length < lm)
+	if (currentNeighbors->length < lm)
 	{
-		neighbors->items[neighbors->length++] = newHc;
+		currentNeighbors->items[currentNeighbors->length++] = hc2;
 
 		/* Track update */
 		if (updateIdx != NULL)
@@ -1119,26 +1146,54 @@ HnswUpdateConnection(char *base, HnswNeighborArray * neighbors, HnswElement newE
 	else
 	{
 		/* Shrink connections */
-		List	   *c = NIL;
 		HnswCandidate *pruned = NULL;
 
-		/* Add candidates */
-		for (int i = 0; i < neighbors->length; i++)
-			c = lappend(c, &neighbors->items[i]);
-		c = lappend(c, &newHc);
+		/* Load elements on insert */
+		if (index != NULL)
+		{
+			Datum		q = HnswGetValue(base, hce);
 
-		SelectNeighbors(base, c, lm, support, &neighbors->closerSet, &newHc, &pruned, true);
+			for (int i = 0; i < currentNeighbors->length; i++)
+			{
+				HnswCandidate *hc3 = &currentNeighbors->items[i];
+				HnswElement hc3Element = HnswPtrAccess(base, hc3->element);
+
+				if (HnswPtrIsNull(base, hc3Element->value))
+					HnswLoadElement(hc3Element, &hc3->distance, &q, index, procinfo, collation, true, NULL);
+				else
+					hc3->distance = GetElementDistance(base, hc3Element, q, procinfo, collation);
+
+				/* Prune element if being deleted */
+				if (hc3Element->heaptidsLength == 0)
+				{
+					pruned = &currentNeighbors->items[i];
+					break;
+				}
+			}
+		}
 
-		/* Should not happen */
 		if (pruned == NULL)
-			return;
+		{
+			List	   *c = NIL;
+
+			/* Add candidates */
+			for (int i = 0; i < currentNeighbors->length; i++)
+				c = lappend(c, &currentNeighbors->items[i]);
+			c = lappend(c, &hc2);
+
+			SelectNeighbors(base, c, lm, lc, procinfo, collation, hce, &hc2, &pruned, true);
+
+			/* Should not happen */
+			if (pruned == NULL)
+				return;
+		}
 
 		/* Find and replace the pruned element */
-		for (int i = 0; i < neighbors->length; i++)
+		for (int i = 0; i < currentNeighbors->length; i++)
 		{
-			if (HnswPtrEqual(base, neighbors->items[i].element, pruned->element))
+			if (HnswPtrEqual(base, currentNeighbors->items[i].element, pruned->element))
 			{
-				neighbors->items[i] = newHc;
+				currentNeighbors->items[i] = hc2;
 
 				/* Track update */
 				if (updateIdx != NULL)
@@ -1198,20 +1253,17 @@ PrecomputeHash(char *base, HnswElement element)
  * Algorithm 1 from paper
  */
 void
-HnswFindElementNeighbors(char *base, HnswElement element, HnswElement entryPoint, Relation index, HnswSupport * support, int m, int efConstruction, bool existing)
+HnswFindElementNeighbors(char *base, HnswElement element, HnswElement entryPoint, Relation index, FmgrInfo *procinfo, Oid collation, int m, int efConstruction, bool existing)
 {
 	List	   *ep;
 	List	   *w;
 	int			level = element->level;
 	int			entryLevel;
-	HnswQuery	q;
+	Datum		q = HnswGetValue(base, element);
 	HnswElement skipElement = existing ? element : NULL;
-	bool		inMemory = index == NULL;
-
-	q.value = HnswGetValue(base, element);
 
 	/* Precompute hash */
-	if (inMemory)
+	if (index == NULL)
 		PrecomputeHash(base, element);
 
 	/* No neighbors if no entry point */
@@ -1219,13 +1271,13 @@ HnswFindElementNeighbors(char *base, HnswElement element, HnswElement entryPoint
 		return;
 
 	/* Get entry point and level */
-	ep = list_make1(HnswEntryCandidate(base, entryPoint, &q, index, support, true));
+	ep = list_make1(HnswEntryCandidate(base, entryPoint, q, index, procinfo, collation, true));
 	entryLevel = entryPoint->level;
 
 	/* 1st phase: greedy search to insert level */
 	for (int lc = entryLevel; lc >= level + 1; lc--)
 	{
-		w = HnswSearchLayer(base, &q, ep, 1, lc, index, support, m, true, skipElement);
+		w = HnswSearchLayer(base, q, ep, 1, lc, index, procinfo, collation, m, true, skipElement);
 		ep = w;
 	}
 
@@ -1244,7 +1296,7 @@ HnswFindElementNeighbors(char *base, HnswElement element, HnswElement entryPoint
 		List	   *lw = NIL;
 		ListCell   *lc2;
 
-		w = HnswSearchLayer(base, &q, ep, efConstruction, lc, index, support, m, true, skipElement);
+		w = HnswSearchLayer(base, q, ep, efConstruction, lc, index, procinfo, collation, m, true, skipElement);
 
 		/* Convert search candidates to candidates */
 		foreach(lc2, w)
@@ -1260,7 +1312,7 @@ HnswFindElementNeighbors(char *base, HnswElement element, HnswElement entryPoint
 
 		/* Elements being deleted or skipped can help with search */
 		/* but should be removed before selecting neighbors */
-		if (!inMemory)
+		if (index != NULL)
 			lw = RemoveElements(base, lw, skipElement);
 
 		/*
@@ -1268,7 +1320,7 @@ HnswFindElementNeighbors(char *base, HnswElement element, HnswElement entryPoint
 		 * sortCandidates to true for in-memory builds to enable closer
 		 * caching, but there does not seem to be a difference in performance.
 		 */
-		neighbors = SelectNeighbors(base, lw, lm, support, &HnswGetNeighbors(base, element, lc)->closerSet, NULL, NULL, false);
+		neighbors = SelectNeighbors(base, lw, lm, lc, procinfo, collation, element, NULL, NULL, false);
 
 		AddConnections(base, element, neighbors, lc);
 
@@ -1278,6 +1330,7 @@ HnswFindElementNeighbors(char *base, HnswElement element, HnswElement entryPoint
 
 PGDLLEXPORT Datum l2_normalize(PG_FUNCTION_ARGS);
 PGDLLEXPORT Datum halfvec_l2_normalize(PG_FUNCTION_ARGS);
+PGDLLEXPORT Datum minivec_l2_normalize(PG_FUNCTION_ARGS);
 PGDLLEXPORT Datum sparsevec_l2_normalize(PG_FUNCTION_ARGS);
 
 static void
@@ -1326,6 +1379,20 @@ hnsw_halfvec_support(PG_FUNCTION_ARGS)
 	PG_RETURN_POINTER(&typeInfo);
 };
 
+FUNCTION_PREFIX PG_FUNCTION_INFO_V1(hnsw_minivec_support);
+Datum
+hnsw_minivec_support(PG_FUNCTION_ARGS)
+{
+	static const HnswTypeInfo typeInfo = {
+		.maxDimensions = HNSW_MAX_DIM * 4,
+		/* Do not normalize to maximize precision */
+		.normalize = NULL,
+		.checkValue = NULL
+	};
+
+	PG_RETURN_POINTER(&typeInfo);
+};
+
 FUNCTION_PREFIX PG_FUNCTION_INFO_V1(hnsw_bit_support);
 Datum
 hnsw_bit_support(PG_FUNCTION_ARGS)

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, NULL);
 
 		/* 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, NULL);
 
 			if (NeedsUpdated(vacuumstate, entryPoint))
 			{
@@ -573,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

@@ -138,7 +138,7 @@ SampleRows(IvfflatBuildState * buildstate)
  * Add tuple to sort
  */
 static void
-AddTupleToSort(Relation index, ItemPointer tid, Datum *values, bool *isnull, IvfflatBuildState * buildstate)
+AddTupleToSort(Relation index, ItemPointer tid, Datum *values, IvfflatBuildState * buildstate)
 {
 	double		distance;
 	double		minDistance = DBL_MAX;
@@ -184,11 +184,6 @@ AddTupleToSort(Relation index, ItemPointer tid, Datum *values, bool *isnull, Ivf
 	slot->tts_isnull[1] = false;
 	slot->tts_values[2] = value;
 	slot->tts_isnull[2] = false;
-	for (int i = 1; i < buildstate->tupdesc->natts; i++)
-	{
-		slot->tts_values[2 + i] = values[i];
-		slot->tts_isnull[2 + i] = isnull[i];
-	}
 	ExecStoreVirtualTuple(slot);
 
 	/*
@@ -220,7 +215,7 @@ BuildCallback(Relation index, ItemPointer tid, Datum *values,
 	oldCtx = MemoryContextSwitchTo(buildstate->tmpCtx);
 
 	/* Add tuple to sort */
-	AddTupleToSort(index, tid, values, isnull, buildstate);
+	AddTupleToSort(index, tid, values, buildstate);
 
 	/* Reset memory context */
 	MemoryContextSwitchTo(oldCtx);
@@ -231,20 +226,19 @@ BuildCallback(Relation index, ItemPointer tid, Datum *values,
  * Get index tuple from sort state
  */
 static inline void
-GetNextTuple(Tuplesortstate *sortstate, TupleDesc tupdesc, TupleTableSlot *slot, Datum *values, bool *isnull, IndexTuple *itup, int *list)
+GetNextTuple(Tuplesortstate *sortstate, TupleDesc tupdesc, TupleTableSlot *slot, IndexTuple *itup, int *list)
 {
+	Datum		value;
+	bool		isnull;
+
 	if (tuplesort_gettupleslot(sortstate, true, false, slot, NULL))
 	{
-		bool		unused;
-
-		*list = DatumGetInt32(slot_getattr(slot, 1, &unused));
-
-		for (int i = 0; i < tupdesc->natts; i++)
-			values[i] = slot_getattr(slot, 3 + i, &isnull[i]);
+		*list = DatumGetInt32(slot_getattr(slot, 1, &isnull));
+		value = slot_getattr(slot, 3, &isnull);
 
 		/* Form the index tuple */
-		*itup = index_form_tuple(tupdesc, values, isnull);
-		(*itup)->t_tid = *((ItemPointer) DatumGetPointer(slot_getattr(slot, 2, &unused)));
+		*itup = index_form_tuple(tupdesc, &value, &isnull);
+		(*itup)->t_tid = *((ItemPointer) DatumGetPointer(slot_getattr(slot, 2, &isnull)));
 	}
 	else
 		*list = -1;
@@ -260,16 +254,14 @@ InsertTuples(Relation index, IvfflatBuildState * buildstate, ForkNumber forkNum)
 	IndexTuple	itup = NULL;	/* silence compiler warning */
 	int64		inserted = 0;
 
-	TupleTableSlot *slot = MakeSingleTupleTableSlot(buildstate->sortdesc, &TTSOpsMinimalTuple);
-	TupleDesc	tupdesc = buildstate->tupdesc;
-	Datum	   *values = palloc(tupdesc->natts * sizeof(Datum));
-	bool	   *isnull = palloc(tupdesc->natts * sizeof(bool));
+	TupleTableSlot *slot = MakeSingleTupleTableSlot(buildstate->tupdesc, &TTSOpsMinimalTuple);
+	TupleDesc	tupdesc = RelationGetDescr(index);
 
 	pgstat_progress_update_param(PROGRESS_CREATEIDX_SUBPHASE, PROGRESS_IVFFLAT_PHASE_LOAD);
 
 	pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_TOTAL, buildstate->indtuples);
 
-	GetNextTuple(buildstate->sortstate, tupdesc, slot, values, isnull, &itup, &list);
+	GetNextTuple(buildstate->sortstate, tupdesc, slot, &itup, &list);
 
 	for (int i = 0; i < buildstate->centers->length; i++)
 	{
@@ -305,7 +297,7 @@ InsertTuples(Relation index, IvfflatBuildState * buildstate, ForkNumber forkNum)
 
 			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE, ++inserted);
 
-			GetNextTuple(buildstate->sortstate, tupdesc, slot, values, isnull, &itup, &list);
+			GetNextTuple(buildstate->sortstate, tupdesc, slot, &itup, &list);
 		}
 
 		insertPage = BufferGetBlockNumber(buf);
@@ -315,9 +307,6 @@ InsertTuples(Relation index, IvfflatBuildState * buildstate, ForkNumber forkNum)
 		/* Set the start and insert pages */
 		IvfflatUpdateList(index, buildstate->listInfo[i], insertPage, InvalidBlockNumber, startPage, forkNum);
 	}
-
-	pfree(values);
-	pfree(isnull);
 }
 
 /*
@@ -330,7 +319,6 @@ InitBuildState(IvfflatBuildState * buildstate, Relation heap, Relation index, In
 	buildstate->index = index;
 	buildstate->indexInfo = indexInfo;
 	buildstate->typeInfo = IvfflatGetTypeInfo(index);
-	buildstate->tupdesc = RelationGetDescr(index);
 
 	buildstate->lists = IvfflatGetLists(index);
 	buildstate->dimensions = TupleDescAttr(index->rd_att, 0)->atttypmod;
@@ -341,19 +329,6 @@ InitBuildState(IvfflatBuildState * buildstate, Relation heap, Relation index, In
 				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 				 errmsg("type not supported for ivfflat index")));
 
-	/* TODO See if needed */
-	if (IndexRelationGetNumberOfKeyAttributes(index) > 3)
-		elog(ERROR, "index cannot have more than three columns");
-
-	if (!OidIsValid(index_getprocid(index, 1, IVFFLAT_DISTANCE_PROC)))
-		elog(ERROR, "first column must be a vector");
-
-	for (int i = 1; i < IndexRelationGetNumberOfKeyAttributes(index); i++)
-	{
-		if (OidIsValid(index_getprocid(index, i + 1, IVFFLAT_DISTANCE_PROC)))
-			elog(ERROR, "column %d cannot be a vector", i + 1);
-	}
-
 	/* Require column to have dimensions to be indexed */
 	if (buildstate->dimensions < 0)
 		ereport(ERROR,
@@ -381,13 +356,12 @@ InitBuildState(IvfflatBuildState * buildstate, Relation heap, Relation index, In
 				 errmsg("dimensions must be greater than one for this opclass")));
 
 	/* Create tuple description for sorting */
-	buildstate->sortdesc = CreateTemplateTupleDesc(2 + buildstate->tupdesc->natts);
-	TupleDescInitEntry(buildstate->sortdesc, (AttrNumber) 1, "list", INT4OID, -1, 0);
-	TupleDescInitEntry(buildstate->sortdesc, (AttrNumber) 2, "tid", TIDOID, -1, 0);
-	for (int i = 0; i < buildstate->tupdesc->natts; i++)
-		TupleDescInitEntry(buildstate->sortdesc, (AttrNumber) (3 + i), NULL, buildstate->tupdesc->attrs[i].atttypid, -1, 0);
+	buildstate->tupdesc = CreateTemplateTupleDesc(3);
+	TupleDescInitEntry(buildstate->tupdesc, (AttrNumber) 1, "list", INT4OID, -1, 0);
+	TupleDescInitEntry(buildstate->tupdesc, (AttrNumber) 2, "tid", TIDOID, -1, 0);
+	TupleDescInitEntry(buildstate->tupdesc, (AttrNumber) 3, "vector", RelationGetDescr(index)->attrs[0].atttypid, -1, 0);
 
-	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->listInfo = palloc(sizeof(ListInfo) * buildstate->lists);
@@ -659,7 +633,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 = InitBuildSortState(buildstate.tupdesc, sortmem, coordinate);
 	buildstate.sortstate = ivfspool->sortstate;
 	scan = table_beginscan_parallel(ivfspool->heap,
 									ParallelTableScanFromIvfflatShared(ivfshared));
@@ -976,7 +950,7 @@ AssignTuples(IvfflatBuildState * buildstate)
 	}
 
 	/* Begin serial/leader tuplesort */
-	buildstate->sortstate = InitBuildSortState(buildstate->sortdesc, maintenance_work_mem, coordinate);
+	buildstate->sortstate = InitBuildSortState(buildstate->tupdesc, maintenance_work_mem, coordinate);
 
 	/* Add tuples to sort */
 	if (buildstate->heap != NULL)

src/ivfflat.c

@@ -69,8 +69,6 @@ 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;
 
@@ -87,8 +85,6 @@ ivfflatcostestimate(PlannerInfo *root, IndexPath *path, double loop_count,
 
 	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);
@@ -98,26 +94,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 (startupPages > path->indexinfo->rel->pages && ratio < 0.5)
+	if (costs.numIndexPages > path->indexinfo->rel->pages && ratio < 0.5)
 	{
-		/* Change rest of page cost from random to sequential */
-		costs.indexStartupCost -= (1 - sequentialRatio) * startupPages * (costs.spc_random_page_cost - spc_seq_page_cost);
+		/* Change all page cost from random to sequential */
+		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;
@@ -167,7 +178,7 @@ ivfflathandler(PG_FUNCTION_ARGS)
 	amroutine->amcanorderbyop = true;
 	amroutine->amcanbackward = false;	/* can change direction mid-scan */
 	amroutine->amcanunique = false;
-	amroutine->amcanmulticol = true;
+	amroutine->amcanmulticol = false;
 	amroutine->amoptionalkey = true;
 	amroutine->amsearcharray = false;
 	amroutine->amsearchnulls = false;

src/ivfflat.h

@@ -165,7 +165,6 @@ typedef struct IvfflatBuildState
 	Relation	index;
 	IndexInfo  *indexInfo;
 	const		IvfflatTypeInfo *typeInfo;
-	TupleDesc	tupdesc;
 
 	/* Settings */
 	int			dimensions;
@@ -199,7 +198,7 @@ typedef struct IvfflatBuildState
 
 	/* Sorting */
 	Tuplesortstate *sortstate;
-	TupleDesc	sortdesc;
+	TupleDesc	tupdesc;
 	TupleTableSlot *slot;
 
 	/* Memory */

src/ivfinsert.c

@@ -78,8 +78,6 @@ InsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heap_tid, R
 	BlockNumber insertPage = InvalidBlockNumber;
 	ListInfo	listInfo;
 	BlockNumber originalInsertPage;
-	TupleDesc	tupdesc = RelationGetDescr(index);
-	Datum	   *newValues = palloc(tupdesc->natts * sizeof(Datum));
 
 	/* Detoast once for all calls */
 	value = PointerGetDatum(PG_DETOAST_DATUM(values[0]));
@@ -100,16 +98,12 @@ InsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heap_tid, R
 	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;
 
-	newValues[0] = value;
-	for (int i = 1; i < tupdesc->natts; i++)
-		newValues[i] = values[i];
-
 	/* Form tuple */
-	itup = index_form_tuple(tupdesc, newValues, isnull);
+	itup = index_form_tuple(RelationGetDescr(index), &value, isnull);
 	itup->t_tid = *heap_tid;
 
 	/* Get tuple size */

src/ivfscan.c

@@ -104,34 +104,6 @@ GetScanLists(IndexScanDesc scan, Datum value)
 	}
 }
 
-/*
- * Check if matches scan keys
- */
-static bool
-MatchesScanKeys(IndexScanDesc scan, IndexTuple itup, TupleDesc tupdesc)
-{
-	for (int i = 0; i < scan->numberOfKeys; i++)
-	{
-		ScanKey		key = &scan->keyData[i];
-		bool		attnull = key->sk_flags & SK_ISNULL;
-		bool		isnull;
-		Datum		value = index_getattr(itup, key->sk_attno, tupdesc, &isnull);
-
-		if (isnull || attnull)
-		{
-			if (isnull != attnull)
-				return false;
-		}
-		else
-		{
-			if (!DatumGetBool(FunctionCall2Coll(&key->sk_func, key->sk_collation, value, key->sk_argument)))
-				return false;
-		}
-	}
-
-	return true;
-}
-
 /*
  * Get items
  */
@@ -168,10 +140,6 @@ GetScanItems(IndexScanDesc scan, Datum value)
 				ItemId		itemid = PageGetItemId(page, offno);
 
 				itup = (IndexTuple) PageGetItem(page, itemid);
-
-				if (!MatchesScanKeys(scan, itup, tupdesc))
-					continue;
-
 				datum = index_getattr(itup, 1, tupdesc, &isnull);
 
 				/*

src/ivfutils.c

@@ -7,6 +7,7 @@
 #include "halfutils.h"
 #include "halfvec.h"
 #include "ivfflat.h"
+#include "minivec.h"
 #include "storage/bufmgr.h"
 
 /*
@@ -70,6 +71,9 @@ IvfflatOptionalProcInfo(Relation index, uint16 procnum)
 Datum
 IvfflatNormValue(const IvfflatTypeInfo * typeInfo, Oid collation, Datum value)
 {
+	if (!typeInfo->normalize)
+		return value;
+
 	return DirectFunctionCall1Coll(typeInfo->normalize, collation, value);
 }
 
@@ -231,6 +235,7 @@ IvfflatUpdateList(Relation index, ListInfo listInfo,
 
 PGDLLEXPORT Datum l2_normalize(PG_FUNCTION_ARGS);
 PGDLLEXPORT Datum halfvec_l2_normalize(PG_FUNCTION_ARGS);
+PGDLLEXPORT Datum minivec_l2_normalize(PG_FUNCTION_ARGS);
 PGDLLEXPORT Datum sparsevec_l2_normalize(PG_FUNCTION_ARGS);
 
 static Size
@@ -245,6 +250,12 @@ HalfvecItemSize(int dimensions)
 	return HALFVEC_SIZE(dimensions);
 }
 
+static Size
+MinivecItemSize(int dimensions)
+{
+	return MINIVEC_SIZE(dimensions);
+}
+
 static Size
 BitItemSize(int dimensions)
 {
@@ -275,6 +286,18 @@ HalfvecUpdateCenter(Pointer v, int dimensions, float *x)
 		vec->x[k] = Float4ToHalfUnchecked(x[k]);
 }
 
+static void
+MinivecUpdateCenter(Pointer v, int dimensions, float *x)
+{
+	MiniVector *vec = (MiniVector *) v;
+
+	SET_VARSIZE(vec, MINIVEC_SIZE(dimensions));
+	vec->dim = dimensions;
+
+	for (int k = 0; k < dimensions; k++)
+		vec->x[k] = Float4ToFp8Unchecked(x[k]);
+}
+
 static void
 BitUpdateCenter(Pointer v, int dimensions, float *x)
 {
@@ -309,6 +332,15 @@ HalfvecSumCenter(Pointer v, float *x)
 		x[k] += HalfToFloat4(vec->x[k]);
 }
 
+static void
+MinivecSumCenter(Pointer v, float *x)
+{
+	MiniVector *vec = (MiniVector *) v;
+
+	for (int k = 0; k < vec->dim; k++)
+		x[k] += Fp8ToFloat4(vec->x[k]);
+}
+
 static void
 BitSumCenter(Pointer v, float *x)
 {
@@ -357,6 +389,22 @@ ivfflat_halfvec_support(PG_FUNCTION_ARGS)
 	PG_RETURN_POINTER(&typeInfo);
 };
 
+FUNCTION_PREFIX PG_FUNCTION_INFO_V1(ivfflat_minivec_support);
+Datum
+ivfflat_minivec_support(PG_FUNCTION_ARGS)
+{
+	static const IvfflatTypeInfo typeInfo = {
+		.maxDimensions = IVFFLAT_MAX_DIM * 4,
+		/* Do not normalize to maximize precision */
+		.normalize = NULL,
+		.itemSize = MinivecItemSize,
+		.updateCenter = MinivecUpdateCenter,
+		.sumCenter = MinivecSumCenter
+	};
+
+	PG_RETURN_POINTER(&typeInfo);
+};
+
 FUNCTION_PREFIX PG_FUNCTION_INFO_V1(ivfflat_bit_support);
 Datum
 ivfflat_bit_support(PG_FUNCTION_ARGS)

src/minivec.h

@@ -0,0 +1,163 @@
+#ifndef MINIVEC_H
+#define MINIVEC_H
+
+#define MINIVEC_MAX_DIM 16000
+
+#define fp8 uint8
+
+#define MINIVEC_SIZE(_dim)		(offsetof(MiniVector, x) + sizeof(fp8)*(_dim))
+#define DatumGetMiniVector(x)		((MiniVector *) PG_DETOAST_DATUM(x))
+#define PG_GETARG_MINIVEC_P(x)	DatumGetMiniVector(PG_GETARG_DATUM(x))
+#define PG_RETURN_MINIVEC_P(x)	PG_RETURN_POINTER(x)
+
+typedef struct MiniVector
+{
+	int32		vl_len_;		/* varlena header (do not touch directly!) */
+	int16		dim;			/* number of dimensions */
+	int16		unused;			/* reserved for future use, always zero */
+	fp8			x[FLEXIBLE_ARRAY_MEMBER];
+}			MiniVector;
+
+MiniVector *InitMiniVector(int dim);
+
+/*
+ * Check if fp8 is NaN
+ */
+static inline bool
+Fp8IsNan(fp8 num)
+{
+	return (num & 0x7F) == 0x7F;
+}
+
+/*
+ * Check if fp8 is zero
+ */
+static inline bool
+Fp8IsZero(fp8 num)
+{
+	return num == 0;
+}
+
+/*
+ * Convert a fp8 to a float4
+ */
+static inline float
+Fp8ToFloat4(fp8 num)
+{
+	/* Lookup table for non-sign bits */
+	/* Uses uint32 for correctness */
+	uint32		lookup[128] = {0, 989855744, 998244352, 1002438656, 1006632960, 1008730112, 1010827264, 1012924416, 1015021568, 1016070144, 1017118720, 1018167296, 1019215872, 1020264448, 1021313024, 1022361600, 1023410176, 1024458752, 1025507328, 1026555904, 1027604480, 1028653056, 1029701632, 1030750208, 1031798784, 1032847360, 1033895936, 1034944512, 1035993088, 1037041664, 1038090240, 1039138816, 1040187392, 1041235968, 1042284544, 1043333120, 1044381696, 1045430272, 1046478848, 1047527424, 1048576000, 1049624576, 1050673152, 1051721728, 1052770304, 1053818880, 1054867456, 1055916032, 1056964608, 1058013184, 1059061760, 1060110336, 1061158912, 1062207488, 1063256064, 1064304640, 1065353216, 1066401792, 1067450368, 1068498944, 1069547520, 1070596096, 1071644672, 1072693248, 1073741824, 1074790400, 1075838976, 1076887552, 1077936128, 1078984704, 1080033280, 1081081856, 1082130432, 1083179008, 1084227584, 1085276160, 1086324736, 1087373312, 1088421888, 1089470464, 1090519040, 1091567616, 1092616192, 1093664768, 1094713344, 1095761920, 1096810496, 1097859072, 1098907648, 1099956224, 1101004800, 1102053376, 1103101952, 1104150528, 1105199104, 1106247680, 1107296256, 1108344832, 1109393408, 1110441984, 1111490560, 1112539136, 1113587712, 1114636288, 1115684864, 1116733440, 1117782016, 1118830592, 1119879168, 1120927744, 1121976320, 1123024896, 1124073472, 1125122048, 1126170624, 1127219200, 1128267776, 1129316352, 1130364928, 1131413504, 1132462080, 1133510656, 1134559232, 1135607808, 1136656384, 1137704960, 1138753536, 2146435072};
+
+	union
+	{
+		float		f;
+		uint32		i;
+	}			swap;
+
+	swap.i = lookup[num & 0x7F];
+
+	return (num & 0x80) == 0x80 ? -swap.f : swap.f;
+}
+
+/*
+ * Convert a float4 to a fp8
+ */
+static inline fp8
+Float4ToFp8Unchecked(float num)
+{
+	union
+	{
+		float		f;
+		uint32		i;
+	}			swap;
+
+	uint32		bin;
+	int			exponent;
+	int			mantissa;
+	uint8		result;
+
+	swap.f = num;
+	bin = swap.i;
+	exponent = (bin & 0x7F800000) >> 23;
+	mantissa = bin & 0x007FFFFF;
+
+	/* Sign */
+	result = (bin & 0x80000000) >> 24;
+
+	if (isinf(num) || isnan(num))
+	{
+		/* NaN */
+		result |= 0x7F;
+	}
+	else if (exponent > 114)
+	{
+		int			m;
+		int			gr;
+		int			s;
+
+		exponent -= 127;
+		s = mantissa & 0x0007FFFF;
+
+		/* Subnormal */
+		if (exponent < -6)
+		{
+			int			diff = -exponent - 6;
+
+			mantissa >>= diff;
+			mantissa += 1 << (23 - diff);
+			s |= mantissa & 0x0007FFFF;
+		}
+
+		m = mantissa >> 20;
+
+		/* Round */
+		gr = (mantissa >> 19) % 4;
+		if (gr == 3 || (gr == 1 && s != 0))
+			m += 1;
+
+		if (m == 8)
+		{
+			m = 0;
+			exponent += 1;
+		}
+
+		if (exponent > 8)
+		{
+			/* Infinite, which is NaN */
+			result |= 0x7F;
+		}
+		else
+		{
+			if (exponent >= -6)
+				result |= (exponent + 7) << 3;
+
+			result |= m;
+		}
+	}
+
+	return result;
+}
+
+/*
+ * Convert a float4 to a fp8
+ */
+static inline fp8
+Float4ToFp8(float num)
+{
+	fp8			result = Float4ToFp8Unchecked(num);
+
+	if (unlikely(Fp8IsNan(result)) && !isinf(num))
+	{
+		char	   *buf = palloc(FLOAT_SHORTEST_DECIMAL_LEN);
+
+		float_to_shortest_decimal_buf(num, buf);
+
+		ereport(ERROR,
+				(errcode(ERRCODE_NUMERIC_VALUE_OUT_OF_RANGE),
+				 errmsg("\"%s\" is out of range for type minivec", buf)));
+	}
+
+	return result;
+}
+
+#endif

src/vector.c

@@ -13,6 +13,7 @@
 #include "ivfflat.h"
 #include "lib/stringinfo.h"
 #include "libpq/pqformat.h"
+#include "minivec.h"
 #include "port.h"				/* for strtof() */
 #include "sparsevec.h"
 #include "utils/array.h"
@@ -542,6 +543,28 @@ halfvec_to_vector(PG_FUNCTION_ARGS)
 	PG_RETURN_POINTER(result);
 }
 
+/*
+ * Convert fp8 vector to vector
+ */
+FUNCTION_PREFIX PG_FUNCTION_INFO_V1(minivec_to_vector);
+Datum
+minivec_to_vector(PG_FUNCTION_ARGS)
+{
+	MiniVector *vec = PG_GETARG_MINIVEC_P(0);
+	int32		typmod = PG_GETARG_INT32(1);
+	Vector	   *result;
+
+	CheckDim(vec->dim);
+	CheckExpectedDim(typmod, vec->dim);
+
+	result = InitVector(vec->dim);
+
+	for (int i = 0; i < vec->dim; i++)
+		result->x[i] = Fp8ToFloat4(vec->x[i]);
+
+	PG_RETURN_POINTER(result);
+}
+
 VECTOR_TARGET_CLONES static float
 VectorL2SquaredDistance(int dim, float *ax, float *bx)
 {

test/expected/btree.out

@@ -38,6 +38,26 @@ SELECT * FROM t ORDER BY val;
  
 (4 rows)
 
+DROP TABLE t;
+-- minivec
+CREATE TABLE t (val minivec(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));

test/expected/cast.out

@@ -140,6 +140,64 @@ SELECT '{1e-8,-1e-8}'::real[]::halfvec;
  [0,-0]
 (1 row)
 
+SELECT '[1,2,3]'::vector::minivec;
+ minivec 
+---------
+ [1,2,3]
+(1 row)
+
+SELECT '[1,2,3]'::vector::minivec(3);
+ minivec 
+---------
+ [1,2,3]
+(1 row)
+
+SELECT '[1,2,3]'::vector::minivec(2);
+ERROR:  expected 2 dimensions, not 3
+SELECT '[465]'::vector::minivec;
+ERROR:  "465" is out of range for type minivec
+SELECT '[1e-8]'::vector::minivec;
+ minivec 
+---------
+ [0]
+(1 row)
+
+SELECT '[1,2,3]'::minivec::vector;
+ vector  
+---------
+ [1,2,3]
+(1 row)
+
+SELECT '[1,2,3]'::minivec::vector(3);
+ vector  
+---------
+ [1,2,3]
+(1 row)
+
+SELECT '[1,2,3]'::minivec::vector(2);
+ERROR:  expected 2 dimensions, not 3
+SELECT '{1,2,3}'::real[]::minivec;
+ minivec 
+---------
+ [1,2,3]
+(1 row)
+
+SELECT '{1,2,3}'::real[]::minivec(3);
+ minivec 
+---------
+ [1,2,3]
+(1 row)
+
+SELECT '{1,2,3}'::real[]::minivec(2);
+ERROR:  expected 2 dimensions, not 3
+SELECT '{465,-465}'::real[]::minivec;
+ERROR:  "465" is out of range for type minivec
+SELECT '{1e-8,-1e-8}'::real[]::minivec;
+ minivec 
+---------
+ [0,-0]
+(1 row)
+
 SELECT '[0,1.5,0,3.5,0]'::vector::sparsevec;
     sparsevec    
 -----------------

test/expected/copy.out

@@ -30,6 +30,23 @@ SELECT * FROM t2 ORDER BY val;
  
 (4 rows)
 
+DROP TABLE t;
+DROP TABLE t2;
+-- minivec
+CREATE TABLE t (val minivec(3));
+INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
+CREATE TABLE t2 (val minivec(3));
+\copy t TO 'results/minivec.bin' WITH (FORMAT binary)
+\copy t2 FROM 'results/minivec.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

test/expected/ivfflat_minivec.out

@@ -0,0 +1,84 @@
+SET enable_seqscan = off;
+-- L2
+CREATE TABLE t (val minivec(3));
+INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
+CREATE INDEX ON t USING ivfflat (val minivec_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::minivec)) 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 minivec(3));
+INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
+CREATE INDEX ON t USING ivfflat (val minivec_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::minivec)) t2;
+ count 
+-------
+     4
+(1 row)
+
+DROP TABLE t;
+-- cosine
+CREATE TABLE t (val minivec(3));
+INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
+CREATE INDEX ON t USING ivfflat (val minivec_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::minivec)) t2;
+ count 
+-------
+     3
+(1 row)
+
+DROP TABLE t;

test/expected/minivec.out

@@ -0,0 +1,588 @@
+SELECT '[1,2,3]'::minivec;
+ minivec 
+---------
+ [1,2,3]
+(1 row)
+
+SELECT '[-1,-2,-3]'::minivec;
+  minivec   
+------------
+ [-1,-2,-3]
+(1 row)
+
+SELECT '[1.,2.,3.]'::minivec;
+ minivec 
+---------
+ [1,2,3]
+(1 row)
+
+SELECT ' [ 1,  2 ,    3  ] '::minivec;
+ minivec 
+---------
+ [1,2,3]
+(1 row)
+
+SELECT '[1.23456]'::minivec;
+ minivec 
+---------
+ [1.25]
+(1 row)
+
+SELECT '[hello,1]'::minivec;
+ERROR:  invalid input syntax for type minivec: "[hello,1]"
+LINE 1: SELECT '[hello,1]'::minivec;
+               ^
+SELECT '[NaN,1]'::minivec;
+ERROR:  NaN not allowed in minivec
+LINE 1: SELECT '[NaN,1]'::minivec;
+               ^
+SELECT '[Infinity,1]'::minivec;
+ERROR:  "Infinity" is out of range for type minivec
+LINE 1: SELECT '[Infinity,1]'::minivec;
+               ^
+SELECT '[-Infinity,1]'::minivec;
+ERROR:  "-Infinity" is out of range for type minivec
+LINE 1: SELECT '[-Infinity,1]'::minivec;
+               ^
+SELECT '[65519,-65519]'::minivec;
+ERROR:  "65519" is out of range for type minivec
+LINE 1: SELECT '[65519,-65519]'::minivec;
+               ^
+SELECT '[65520,-65520]'::minivec;
+ERROR:  "65520" is out of range for type minivec
+LINE 1: SELECT '[65520,-65520]'::minivec;
+               ^
+SELECT '[1e-8,-1e-8]'::minivec;
+ minivec 
+---------
+ [0,-0]
+(1 row)
+
+SELECT '[4e38,1]'::minivec;
+ERROR:  "4e38" is out of range for type minivec
+LINE 1: SELECT '[4e38,1]'::minivec;
+               ^
+SELECT '[1e-46,1]'::minivec;
+ minivec 
+---------
+ [0,1]
+(1 row)
+
+SELECT '[1,2,3'::minivec;
+ERROR:  invalid input syntax for type minivec: "[1,2,3"
+LINE 1: SELECT '[1,2,3'::minivec;
+               ^
+SELECT '[1,2,3]9'::minivec;
+ERROR:  invalid input syntax for type minivec: "[1,2,3]9"
+LINE 1: SELECT '[1,2,3]9'::minivec;
+               ^
+DETAIL:  Junk after closing right brace.
+SELECT '1,2,3'::minivec;
+ERROR:  invalid input syntax for type minivec: "1,2,3"
+LINE 1: SELECT '1,2,3'::minivec;
+               ^
+DETAIL:  Vector contents must start with "[".
+SELECT ''::minivec;
+ERROR:  invalid input syntax for type minivec: ""
+LINE 1: SELECT ''::minivec;
+               ^
+DETAIL:  Vector contents must start with "[".
+SELECT '['::minivec;
+ERROR:  invalid input syntax for type minivec: "["
+LINE 1: SELECT '['::minivec;
+               ^
+SELECT '[ '::minivec;
+ERROR:  invalid input syntax for type minivec: "[ "
+LINE 1: SELECT '[ '::minivec;
+               ^
+SELECT '[,'::minivec;
+ERROR:  invalid input syntax for type minivec: "[,"
+LINE 1: SELECT '[,'::minivec;
+               ^
+SELECT '[]'::minivec;
+ERROR:  minivec must have at least 1 dimension
+LINE 1: SELECT '[]'::minivec;
+               ^
+SELECT '[ ]'::minivec;
+ERROR:  minivec must have at least 1 dimension
+LINE 1: SELECT '[ ]'::minivec;
+               ^
+SELECT '[,]'::minivec;
+ERROR:  invalid input syntax for type minivec: "[,]"
+LINE 1: SELECT '[,]'::minivec;
+               ^
+SELECT '[1,]'::minivec;
+ERROR:  invalid input syntax for type minivec: "[1,]"
+LINE 1: SELECT '[1,]'::minivec;
+               ^
+SELECT '[1a]'::minivec;
+ERROR:  invalid input syntax for type minivec: "[1a]"
+LINE 1: SELECT '[1a]'::minivec;
+               ^
+SELECT '[1,,3]'::minivec;
+ERROR:  invalid input syntax for type minivec: "[1,,3]"
+LINE 1: SELECT '[1,,3]'::minivec;
+               ^
+SELECT '[1, ,3]'::minivec;
+ERROR:  invalid input syntax for type minivec: "[1, ,3]"
+LINE 1: SELECT '[1, ,3]'::minivec;
+               ^
+SELECT '[1,2,3]'::minivec(3);
+ minivec 
+---------
+ [1,2,3]
+(1 row)
+
+SELECT '[1,2,3]'::minivec(2);
+ERROR:  expected 2 dimensions, not 3
+SELECT '[1,2,3]'::minivec(3, 2);
+ERROR:  invalid type modifier
+LINE 1: SELECT '[1,2,3]'::minivec(3, 2);
+                          ^
+SELECT '[1,2,3]'::minivec('a');
+ERROR:  invalid input syntax for type integer: "a"
+LINE 1: SELECT '[1,2,3]'::minivec('a');
+                          ^
+SELECT '[1,2,3]'::minivec(0);
+ERROR:  dimensions for type minivec must be at least 1
+LINE 1: SELECT '[1,2,3]'::minivec(0);
+                          ^
+SELECT '[1,2,3]'::minivec(16001);
+ERROR:  dimensions for type minivec cannot exceed 16000
+LINE 1: SELECT '[1,2,3]'::minivec(16001);
+                          ^
+SELECT unnest('{"[1,2,3]", "[4,5,6]"}'::minivec[]);
+ unnest  
+---------
+ [1,2,3]
+ [4,5,6]
+(2 rows)
+
+SELECT '{"[1,2,3]"}'::minivec(2)[];
+ERROR:  expected 2 dimensions, not 3
+SELECT '[1,2,3]'::minivec + '[4,5,6]';
+ ?column? 
+----------
+ [5,7,9]
+(1 row)
+
+SELECT '[448]'::minivec + '[448]';
+ERROR:  value out of range: overflow
+SELECT '[1,2]'::minivec + '[3]';
+ERROR:  different minivec dimensions 2 and 1
+SELECT '[1,2,3]'::minivec - '[4,5,6]';
+  ?column?  
+------------
+ [-3,-3,-3]
+(1 row)
+
+SELECT '[-448]'::minivec - '[448]';
+ERROR:  value out of range: overflow
+SELECT '[1,2]'::minivec - '[3]';
+ERROR:  different minivec dimensions 2 and 1
+SELECT '[1,2,3]'::minivec * '[4,5,6]';
+ ?column?  
+-----------
+ [4,10,18]
+(1 row)
+
+SELECT '[448]'::minivec * '[448]';
+ERROR:  value out of range: overflow
+SELECT '[1e-7]'::minivec * '[1e-7]';
+ ?column? 
+----------
+ [0]
+(1 row)
+
+SELECT '[1,2]'::minivec * '[3]';
+ERROR:  different minivec dimensions 2 and 1
+SELECT '[1,2,3]'::minivec || '[4,5]';
+  ?column?   
+-------------
+ [1,2,3,4,5]
+(1 row)
+
+SELECT array_fill(0, ARRAY[16000])::minivec || '[1]';
+ERROR:  minivec cannot have more than 16000 dimensions
+SELECT '[1,2,3]'::minivec < '[1,2,3]';
+ ?column? 
+----------
+ f
+(1 row)
+
+SELECT '[1,2,3]'::minivec < '[1,2]';
+ ?column? 
+----------
+ f
+(1 row)
+
+SELECT '[1,2,3]'::minivec <= '[1,2,3]';
+ ?column? 
+----------
+ t
+(1 row)
+
+SELECT '[1,2,3]'::minivec <= '[1,2]';
+ ?column? 
+----------
+ f
+(1 row)
+
+SELECT '[1,2,3]'::minivec = '[1,2,3]';
+ ?column? 
+----------
+ t
+(1 row)
+
+SELECT '[1,2,3]'::minivec = '[1,2]';
+ ?column? 
+----------
+ f
+(1 row)
+
+SELECT '[1,2,3]'::minivec != '[1,2,3]';
+ ?column? 
+----------
+ f
+(1 row)
+
+SELECT '[1,2,3]'::minivec != '[1,2]';
+ ?column? 
+----------
+ t
+(1 row)
+
+SELECT '[1,2,3]'::minivec >= '[1,2,3]';
+ ?column? 
+----------
+ t
+(1 row)
+
+SELECT '[1,2,3]'::minivec >= '[1,2]';
+ ?column? 
+----------
+ t
+(1 row)
+
+SELECT '[1,2,3]'::minivec > '[1,2,3]';
+ ?column? 
+----------
+ f
+(1 row)
+
+SELECT '[1,2,3]'::minivec > '[1,2]';
+ ?column? 
+----------
+ t
+(1 row)
+
+SELECT minivec_cmp('[1,2,3]', '[1,2,3]');
+ minivec_cmp 
+-------------
+           0
+(1 row)
+
+SELECT minivec_cmp('[1,2,3]', '[0,0,0]');
+ minivec_cmp 
+-------------
+           1
+(1 row)
+
+SELECT minivec_cmp('[0,0,0]', '[1,2,3]');
+ minivec_cmp 
+-------------
+          -1
+(1 row)
+
+SELECT minivec_cmp('[1,2]', '[1,2,3]');
+ minivec_cmp 
+-------------
+          -1
+(1 row)
+
+SELECT minivec_cmp('[1,2,3]', '[1,2]');
+ minivec_cmp 
+-------------
+           1
+(1 row)
+
+SELECT minivec_cmp('[1,2]', '[2,3,4]');
+ minivec_cmp 
+-------------
+          -1
+(1 row)
+
+SELECT minivec_cmp('[2,3]', '[1,2,3]');
+ minivec_cmp 
+-------------
+           1
+(1 row)
+
+SELECT vector_dims('[1,2,3]'::minivec);
+ vector_dims 
+-------------
+           3
+(1 row)
+
+SELECT round(l2_norm('[1,1]'::minivec)::numeric, 5);
+  round  
+---------
+ 1.41421
+(1 row)
+
+SELECT l2_norm('[3,4]'::minivec);
+ l2_norm 
+---------
+       5
+(1 row)
+
+SELECT l2_norm('[0,1]'::minivec);
+ l2_norm 
+---------
+       1
+(1 row)
+
+SELECT l2_norm('[0,0]'::minivec);
+ l2_norm 
+---------
+       0
+(1 row)
+
+SELECT l2_norm('[2]'::minivec);
+ l2_norm 
+---------
+       2
+(1 row)
+
+SELECT l2_distance('[0,0]'::minivec, '[3,4]');
+ l2_distance 
+-------------
+           5
+(1 row)
+
+SELECT l2_distance('[0,0]'::minivec, '[0,1]');
+ l2_distance 
+-------------
+           1
+(1 row)
+
+SELECT l2_distance('[1,2]'::minivec, '[3]');
+ERROR:  different minivec dimensions 2 and 1
+SELECT l2_distance('[1,1,1,1,1,1,1,1,1]'::minivec, '[1,1,1,1,1,1,1,4,5]');
+ l2_distance 
+-------------
+           5
+(1 row)
+
+SELECT '[0,0]'::minivec <-> '[3,4]';
+ ?column? 
+----------
+        5
+(1 row)
+
+SELECT inner_product('[1,2]'::minivec, '[3,4]');
+ inner_product 
+---------------
+            11
+(1 row)
+
+SELECT inner_product('[1,2]'::minivec, '[3]');
+ERROR:  different minivec dimensions 2 and 1
+SELECT inner_product('[448]'::minivec, '[448]');
+ inner_product 
+---------------
+        200704
+(1 row)
+
+SELECT inner_product('[1,1,1,1,1,1,1,1,1]'::minivec, '[1,2,3,4,5,6,7,8,9]');
+ inner_product 
+---------------
+            45
+(1 row)
+
+SELECT '[1,2]'::minivec <#> '[3,4]';
+ ?column? 
+----------
+      -11
+(1 row)
+
+SELECT cosine_distance('[1,2]'::minivec, '[2,4]');
+ cosine_distance 
+-----------------
+               0
+(1 row)
+
+SELECT cosine_distance('[1,2]'::minivec, '[0,0]');
+ cosine_distance 
+-----------------
+             NaN
+(1 row)
+
+SELECT cosine_distance('[1,1]'::minivec, '[1,1]');
+ cosine_distance 
+-----------------
+               0
+(1 row)
+
+SELECT cosine_distance('[1,0]'::minivec, '[0,2]');
+ cosine_distance 
+-----------------
+               1
+(1 row)
+
+SELECT cosine_distance('[1,1]'::minivec, '[-1,-1]');
+ cosine_distance 
+-----------------
+               2
+(1 row)
+
+SELECT cosine_distance('[1,2]'::minivec, '[3]');
+ERROR:  different minivec dimensions 2 and 1
+SELECT cosine_distance('[1,1]'::minivec, '[1.1,1.1]');
+ cosine_distance 
+-----------------
+               0
+(1 row)
+
+SELECT cosine_distance('[1,1]'::minivec, '[-1.1,-1.1]');
+ cosine_distance 
+-----------------
+               2
+(1 row)
+
+SELECT cosine_distance('[1,2,3,4,5,6,7,8,9]'::minivec, '[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]'::minivec, '[-1,-2,-3,-4,-5,-6,-7,-8,-9]');
+ cosine_distance 
+-----------------
+               2
+(1 row)
+
+SELECT '[1,2]'::minivec <=> '[2,4]';
+ ?column? 
+----------
+        0
+(1 row)
+
+SELECT l1_distance('[0,0]'::minivec, '[3,4]');
+ l1_distance 
+-------------
+           7
+(1 row)
+
+SELECT l1_distance('[0,0]'::minivec, '[0,1]');
+ l1_distance 
+-------------
+           1
+(1 row)
+
+SELECT l1_distance('[1,2]'::minivec, '[3]');
+ERROR:  different minivec dimensions 2 and 1
+SELECT l1_distance('[1,2,3,4,5,6,7,8,9]'::minivec, '[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]'::minivec, '[0,3,2,5,4,7,6,9,8]');
+ l1_distance 
+-------------
+           9
+(1 row)
+
+SELECT '[0,0]'::minivec <+> '[3,4]';
+ ?column? 
+----------
+        7
+(1 row)
+
+SELECT l2_normalize('[3,4]'::minivec);
+  l2_normalize  
+----------------
+ [0.625,0.8125]
+(1 row)
+
+SELECT l2_normalize('[3,0]'::minivec);
+ l2_normalize 
+--------------
+ [1,0]
+(1 row)
+
+SELECT l2_normalize('[0,0.1]'::minivec);
+ l2_normalize 
+--------------
+ [0,1]
+(1 row)
+
+SELECT l2_normalize('[0,0]'::minivec);
+ l2_normalize 
+--------------
+ [0,0]
+(1 row)
+
+SELECT l2_normalize('[448]'::minivec);
+ l2_normalize 
+--------------
+ [1]
+(1 row)
+
+SELECT binary_quantize('[1,0,-1]'::minivec);
+ binary_quantize 
+-----------------
+ 100
+(1 row)
+
+SELECT binary_quantize('[0,0.1,-0.2,-0.3,0.4,0.5,0.6,-0.7,0.8,-0.9,1]'::minivec);
+ binary_quantize 
+-----------------
+ 01001110101
+(1 row)
+
+SELECT subvector('[1,2,3,4,5]'::minivec, 1, 3);
+ subvector 
+-----------
+ [1,2,3]
+(1 row)
+
+SELECT subvector('[1,2,3,4,5]'::minivec, 3, 2);
+ subvector 
+-----------
+ [3,4]
+(1 row)
+
+SELECT subvector('[1,2,3,4,5]'::minivec, -1, 3);
+ subvector 
+-----------
+ [1]
+(1 row)
+
+SELECT subvector('[1,2,3,4,5]'::minivec, 3, 9);
+ subvector 
+-----------
+ [3,4,5]
+(1 row)
+
+SELECT subvector('[1,2,3,4,5]'::minivec, 1, 0);
+ERROR:  minivec must have at least 1 dimension
+SELECT subvector('[1,2,3,4,5]'::minivec, 3, -1);
+ERROR:  minivec must have at least 1 dimension
+SELECT subvector('[1,2,3,4,5]'::minivec, -1, 2);
+ERROR:  minivec must have at least 1 dimension
+SELECT subvector('[1,2,3,4,5]'::minivec, 2147483647, 10);
+ERROR:  minivec must have at least 1 dimension
+SELECT subvector('[1,2,3,4,5]'::minivec, 3, 2147483647);
+ subvector 
+-----------
+ [3,4,5]
+(1 row)
+
+SELECT subvector('[1,2,3,4,5]'::minivec, -2147483644, 2147483647);
+ subvector 
+-----------
+ [1,2]
+(1 row)
+

test/sql/btree.sql

@@ -22,6 +22,17 @@ SELECT * FROM t ORDER BY val;
 
 DROP TABLE t;
 
+-- minivec
+
+CREATE TABLE t (val minivec(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));

test/sql/cast.sql

@@ -38,6 +38,22 @@ SELECT '{1,2,3}'::real[]::halfvec(2);
 SELECT '{65520,-65520}'::real[]::halfvec;
 SELECT '{1e-8,-1e-8}'::real[]::halfvec;
 
+SELECT '[1,2,3]'::vector::minivec;
+SELECT '[1,2,3]'::vector::minivec(3);
+SELECT '[1,2,3]'::vector::minivec(2);
+SELECT '[465]'::vector::minivec;
+SELECT '[1e-8]'::vector::minivec;
+
+SELECT '[1,2,3]'::minivec::vector;
+SELECT '[1,2,3]'::minivec::vector(3);
+SELECT '[1,2,3]'::minivec::vector(2);
+
+SELECT '{1,2,3}'::real[]::minivec;
+SELECT '{1,2,3}'::real[]::minivec(3);
+SELECT '{1,2,3}'::real[]::minivec(2);
+SELECT '{465,-465}'::real[]::minivec;
+SELECT '{1e-8,-1e-8}'::real[]::minivec;
+
 SELECT '[0,1.5,0,3.5,0]'::vector::sparsevec;
 SELECT '[0,1.5,0,3.5,0]'::vector::sparsevec(5);
 SELECT '[0,1.5,0,3.5,0]'::vector::sparsevec(4);

test/sql/copy.sql

@@ -28,6 +28,21 @@ SELECT * FROM t2 ORDER BY val;
 DROP TABLE t;
 DROP TABLE t2;
 
+-- minivec
+
+CREATE TABLE t (val minivec(3));
+INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
+
+CREATE TABLE t2 (val minivec(3));
+
+\copy t TO 'results/minivec.bin' WITH (FORMAT binary)
+\copy t2 FROM 'results/minivec.bin' WITH (FORMAT binary)
+
+SELECT * FROM t2 ORDER BY val;
+
+DROP TABLE t;
+DROP TABLE t2;
+
 -- sparsevec
 
 CREATE TABLE t (val sparsevec(3));

test/sql/ivfflat_minivec.sql

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

test/sql/minivec.sql

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

test/t/002_ivfflat_vacuum.pl

@@ -6,7 +6,13 @@ use Test::More;
 
 my $dim = 3;
 
-my $array_sql = join(",", ('random()') x $dim);
+my @r = ();
+for (1 .. $dim)
+{
+	my $v = int(rand(1000)) + 1;
+	push(@r, "i % $v");
+}
+my $array_sql = join(", ", @r);
 
 # Initialize node
 my $node = PostgreSQL::Test::Cluster->new('node');
@@ -17,20 +23,19 @@ $node->start;
 $node->safe_psql("postgres", "CREATE EXTENSION vector;");
 $node->safe_psql("postgres", "CREATE TABLE tst (i int4, v vector($dim));");
 $node->safe_psql("postgres",
-	"INSERT INTO tst SELECT i, ARRAY[$array_sql] FROM generate_series(1, 100000) i;"
+	"INSERT INTO tst SELECT i % 10, ARRAY[$array_sql] FROM generate_series(1, 100000) i;"
 );
 $node->safe_psql("postgres", "CREATE INDEX ON tst USING ivfflat (v vector_l2_ops);");
 
 # Get size
 my $size = $node->safe_psql("postgres", "SELECT pg_total_relation_size('tst_v_idx');");
 
-# Store values
-$node->safe_psql("postgres", "CREATE TABLE tmp AS SELECT * FROM tst;");
-
 # Delete all, vacuum, and insert same data
 $node->safe_psql("postgres", "DELETE FROM tst;");
 $node->safe_psql("postgres", "VACUUM tst;");
-$node->safe_psql("postgres", "INSERT INTO tst SELECT * FROM tmp;");
+$node->safe_psql("postgres",
+	"INSERT INTO tst SELECT i % 10, ARRAY[$array_sql] FROM generate_series(1, 100000) i;"
+);
 
 # Check size
 my $new_size = $node->safe_psql("postgres", "SELECT pg_total_relation_size('tst_v_idx');");

test/t/009_ivfflat_filtering.pl

@@ -94,7 +94,8 @@ like($explain, qr/Seq Scan/);
 $explain = $node->safe_psql("postgres", qq(
 	EXPLAIN ANALYZE SELECT i FROM tst WHERE v <-> '$query' < 1 ORDER BY v <-> '$query';
 ));
-like($explain, qr/Seq Scan/);
+# TODO Do not use index
+like($explain, qr/Index Scan using idx/);
 
 # Test attribute index
 $node->safe_psql("postgres", "CREATE INDEX attribute_idx ON tst (c);");
@@ -109,6 +110,7 @@ $node->safe_psql("postgres", "CREATE INDEX partial_idx ON tst USING ivfflat (v v
 $explain = $node->safe_psql("postgres", qq(
 	EXPLAIN ANALYZE SELECT i FROM tst WHERE c = $c ORDER BY v <-> '$query' LIMIT $limit;
 ));
-like($explain, qr/Index Scan using partial_idx/);
+# TODO Use partial index
+like($explain, qr/Index Scan using idx/);
 
 done_testing();

test/t/017_hnsw_filtering.pl

@@ -18,13 +18,9 @@ $node->start;
 # Create table and index
 $node->safe_psql("postgres", "CREATE EXTENSION vector;");
 $node->safe_psql("postgres", "CREATE TABLE tst (i int4, v vector($dim), c int4, t text);");
-$node->safe_psql("postgres", "CREATE TABLE cat (i int4 PRIMARY KEY, t text, b boolean);");
 $node->safe_psql("postgres",
 	"INSERT INTO tst SELECT i, ARRAY[$array_sql], i % $nc, 'test ' || i FROM generate_series(1, 10000) i;"
 );
-$node->safe_psql("postgres",
-	"INSERT INTO cat SELECT i, 'cat ' || i, i % 5 = 0 FROM generate_series(1, $nc) i;"
-);
 $node->safe_psql("postgres", "CREATE INDEX idx ON tst USING hnsw (v vector_l2_ops);");
 $node->safe_psql("postgres", "ANALYZE tst;");
 
@@ -41,7 +37,8 @@ my $c = int(rand() * $nc);
 my $explain = $node->safe_psql("postgres", qq(
 	EXPLAIN ANALYZE SELECT i FROM tst WHERE c = $c ORDER BY v <-> '$query' LIMIT $limit;
 ));
-like($explain, qr/Seq Scan/);
+# TODO Do not use index
+like($explain, qr/Index Scan using idx/);
 
 # Test attribute filtering with few rows removed
 $explain = $node->safe_psql("postgres", qq(
@@ -59,7 +56,8 @@ like($explain, qr/Index Scan using idx/);
 $explain = $node->safe_psql("postgres", qq(
 	EXPLAIN ANALYZE SELECT i FROM tst WHERE c < 1 ORDER BY v <-> '$query' LIMIT $limit;
 ));
-like($explain, qr/Seq Scan/);
+# TODO Do not use index
+like($explain, qr/Index Scan using idx/);
 
 # Test attribute filtering with few rows removed like
 $explain = $node->safe_psql("postgres", qq(
@@ -98,25 +96,13 @@ $explain = $node->safe_psql("postgres", qq(
 ));
 like($explain, qr/Seq Scan/);
 
-# Test join
-$explain = $node->safe_psql("postgres", qq(
-	EXPLAIN ANALYZE SELECT cat.t FROM cat INNER JOIN tst ON cat.i = tst.c ORDER BY v <-> '$query' LIMIT $limit;
-));
-like($explain, qr/Index Scan using idx/);
-
-# Test join with attribute filtering
-$explain = $node->safe_psql("postgres", qq(
-	EXPLAIN ANALYZE SELECT cat.t FROM cat INNER JOIN tst ON cat.i = tst.c WHERE cat.b = 't' ORDER BY v <-> '$query' LIMIT $limit;
-));
-like($explain, qr/Index Scan using idx/);
-
 # Test attribute index
 $node->safe_psql("postgres", "CREATE INDEX attribute_idx ON tst (c);");
 $explain = $node->safe_psql("postgres", qq(
 	EXPLAIN ANALYZE SELECT i FROM tst WHERE c = $c ORDER BY v <-> '$query' LIMIT $limit;
 ));
-# Use attribute index
-like($explain, qr/Bitmap Index Scan on attribute_idx/);
+# TODO Use attribute index
+like($explain, qr/Index Scan using idx/);
 
 # Test partial index
 $node->safe_psql("postgres", "CREATE INDEX partial_idx ON tst USING hnsw (v vector_l2_ops) WHERE (c = $c);");

test/t/033_comparison.pl

@@ -40,6 +40,10 @@ for (1 .. 50)
 	$actual = $node->safe_psql("postgres", "SELECT halfvec_cmp(v::halfvec, '$query'::real[]::halfvec) FROM tst");
 	is($expected, $actual);
 
+	# Test minivec
+	$actual = $node->safe_psql("postgres", "SELECT minivec_cmp(v::minivec, '$query'::real[]::minivec) FROM tst");
+	is($expected, $actual);
+
 	# Test sparsevec
 	$actual = $node->safe_psql("postgres", "SELECT sparsevec_cmp(v::vector::sparsevec, '$query'::real[]::vector::sparsevec) FROM tst");
 	is($expected, $actual);

test/t/034_distance_functions.pl

@@ -45,6 +45,10 @@ for my $function (@functions)
 		my $actual = $node->safe_psql("postgres", "SELECT $function(v::halfvec, '$query'::vector::halfvec) FROM tst");
 		is($expected, $actual, "halfvec $function");
 
+		# Test minivec
+		$actual = $node->safe_psql("postgres", "SELECT $function(v::minivec, '$query'::vector::minivec) FROM tst");
+		is($expected, $actual, "minivec $function");
+
 		# Test sparsevec
 		$actual = $node->safe_psql("postgres", "SELECT $function(v::sparsevec, '$query'::vector::sparsevec) FROM tst");
 		is($expected, $actual, "sparsevec $function");

test/t/037_inputs.pl

@@ -12,8 +12,8 @@ $node->start;
 # Create extension
 $node->safe_psql("postgres", "CREATE EXTENSION vector;");
 
-my @types = ("vector", "halfvec", "sparsevec");
-my @inputs = ("[1.23,4.56,7.89]", "[1.23,4.56,7.89]", "{1:1.23,2:4.56,3:7.89}/3");
+my @types = ("vector", "halfvec", "minivec", "sparsevec");
+my @inputs = ("[1.23,4.56,7.89]", "[1.23,4.56,7.89]", "[1.23,4.56,7.89]", "{1:1.23,2:4.56,3:7.89}/3");
 my @subs = (" ", " ", ",", ":", "-", "1", "9", "\0", "2147483648", "-2147483649");
 
 for my $i (0 .. $#types)

test/t/039_hnsw_cost.pl

@@ -1,60 +0,0 @@
-use strict;
-use warnings FATAL => 'all';
-use PostgreSQL::Test::Cluster;
-use PostgreSQL::Test::Utils;
-use Test::More;
-
-my @dims = (384, 1536);
-my $limit = 10;
-
-# Initialize node
-my $node = PostgreSQL::Test::Cluster->new('node');
-$node->init;
-$node->start;
-
-$node->safe_psql("postgres", "CREATE EXTENSION vector;");
-
-for my $dim (@dims)
-{
-	my $array_sql = join(",", ('random()') x $dim);
-
-	# Create table and index
-	$node->safe_psql("postgres", "CREATE TABLE tst (i int4, v vector($dim));");
-	$node->safe_psql("postgres",
-		"INSERT INTO tst SELECT i, ARRAY[$array_sql] FROM generate_series(1, 2000) i;"
-	);
-	$node->safe_psql("postgres", "CREATE INDEX idx ON tst USING hnsw (v vector_l2_ops);");
-	$node->safe_psql("postgres", "ANALYZE tst;");
-
-	# Generate query
-	my @r = ();
-	for (1 .. $dim)
-	{
-		push(@r, rand());
-	}
-	my $query = "[" . join(",", @r) . "]";
-
-	my $explain = $node->safe_psql("postgres", qq(
-		EXPLAIN ANALYZE SELECT i FROM tst ORDER BY v <-> '$query' LIMIT $limit;
-	));
-	like($explain, qr/Index Scan using idx/);
-
-	# 3x the rows are needed for distance filters
-	# since the planner uses DEFAULT_INEQ_SEL for the selectivity (should be 1)
-	# Recreate index for performance
-	$node->safe_psql("postgres", "DROP INDEX idx;");
-	$node->safe_psql("postgres",
-		"INSERT INTO tst SELECT i, ARRAY[$array_sql] FROM generate_series(2001, 6000) i;"
-	);
-	$node->safe_psql("postgres", "CREATE INDEX idx ON tst USING hnsw (v vector_l2_ops);");
-	$node->safe_psql("postgres", "ANALYZE tst;");
-
-	$explain = $node->safe_psql("postgres", qq(
-		EXPLAIN ANALYZE SELECT i FROM tst WHERE v <-> '$query' < 1 ORDER BY v <-> '$query' LIMIT $limit;
-	));
-	like($explain, qr/Index Scan using idx/);
-
-	$node->safe_psql("postgres", "DROP TABLE tst;");
-}
-
-done_testing();

test/t/039_hnsw_minivec_build_recall.pl

@@ -0,0 +1,132 @@
+use strict;
+use warnings FATAL => 'all';
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
+use Test::More;
+
+my $node;
+my @queries = ();
+my @expected;
+my $limit = 20;
+my $dim = 10;
+my $array_sql = join(",", ('2 * random() * random()') x $dim);
+
+sub test_recall
+{
+	my ($min, $operator) = @_;
+	my $correct = 0;
+	my $total = 0;
+
+	my $explain = $node->safe_psql("postgres", qq(
+		SET enable_seqscan = off;
+		EXPLAIN ANALYZE SELECT i FROM tst ORDER BY v $operator '$queries[0]' LIMIT $limit;
+	));
+	like($explain, qr/Index Scan/);
+
+	for my $i (0 .. $#queries)
+	{
+		my $actual = $node->safe_psql("postgres", qq(
+			SET enable_seqscan = off;
+			SELECT i FROM tst ORDER BY v $operator '$queries[$i]' LIMIT $limit;
+		));
+		my @actual_ids = split("\n", $actual);
+		my %actual_set = map { $_ => 1 } @actual_ids;
+
+		my @expected_ids = split("\n", $expected[$i]);
+
+		foreach (@expected_ids)
+		{
+			if (exists($actual_set{$_}))
+			{
+				$correct++;
+			}
+			$total++;
+		}
+	}
+
+	cmp_ok($correct / $total, ">=", $min, $operator);
+}
+
+# Initialize node
+$node = PostgreSQL::Test::Cluster->new('node');
+$node->init;
+$node->start;
+
+# Create table
+$node->safe_psql("postgres", "CREATE EXTENSION vector;");
+$node->safe_psql("postgres", "CREATE TABLE tst (i int4, v minivec($dim));");
+$node->safe_psql("postgres",
+	"INSERT INTO tst SELECT i, ARRAY[$array_sql] FROM generate_series(1, 10000) i;"
+);
+
+# Generate queries
+for (1 .. 20)
+{
+	my @r = ();
+	for (1 .. $dim)
+	{
+		push(@r, rand());
+	}
+	push(@queries, "[" . join(",", @r) . "]");
+}
+
+# Check each index type
+my @operators = ("<->", "<#>", "<=>", "<+>");
+my @opclasses = ("minivec_l2_ops", "minivec_ip_ops", "minivec_cosine_ops", "minivec_l1_ops");
+
+for my $i (0 .. $#operators)
+{
+	my $operator = $operators[$i];
+	my $opclass = $opclasses[$i];
+
+	# Get exact results
+	@expected = ();
+	foreach (@queries)
+	{
+		my $res = $node->safe_psql("postgres", "SELECT i FROM tst ORDER BY v $operator '$_' LIMIT $limit;");
+		push(@expected, $res);
+	}
+
+	# Build index serially
+	$node->safe_psql("postgres", qq(
+		SET max_parallel_maintenance_workers = 0;
+		CREATE INDEX idx ON tst USING hnsw (v $opclass);
+	));
+
+	# Test approximate results
+	my $min = 0.98;
+	test_recall($min, $operator);
+
+	$node->safe_psql("postgres", "DROP INDEX idx;");
+
+	# Build index in parallel in memory
+	my ($ret, $stdout, $stderr) = $node->psql("postgres", qq(
+		SET client_min_messages = DEBUG;
+		SET min_parallel_table_scan_size = 1;
+		CREATE INDEX idx ON tst USING hnsw (v $opclass);
+	));
+	is($ret, 0, $stderr);
+	like($stderr, qr/using \d+ parallel workers/);
+
+	# Test approximate results
+	test_recall($min, $operator);
+
+	$node->safe_psql("postgres", "DROP INDEX idx;");
+
+	# Build index in parallel on disk
+	# Set parallel_workers on table to use workers with low maintenance_work_mem
+	($ret, $stdout, $stderr) = $node->psql("postgres", qq(
+		ALTER TABLE tst SET (parallel_workers = 2);
+		SET client_min_messages = DEBUG;
+		SET maintenance_work_mem = '4MB';
+		CREATE INDEX idx ON tst USING hnsw (v $opclass);
+		ALTER TABLE tst RESET (parallel_workers);
+	));
+	is($ret, 0, $stderr);
+	like($stderr, qr/using \d+ parallel workers/);
+	like($stderr, qr/hnsw graph no longer fits into maintenance_work_mem/);
+
+	$node->safe_psql("postgres", "DROP INDEX idx;");
+}
+
+done_testing();

test/t/040_hnsw_minivec_insert_recall.pl

@@ -0,0 +1,113 @@
+use strict;
+use warnings FATAL => 'all';
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
+use Test::More;
+
+my $node;
+my @queries = ();
+my @expected;
+my $limit = 20;
+my $dim = 10;
+my $array_sql = join(",", ('2 * random() * random()') x $dim);
+
+sub test_recall
+{
+	my ($min, $operator) = @_;
+	my $correct = 0;
+	my $total = 0;
+
+	my $explain = $node->safe_psql("postgres", qq(
+		SET enable_seqscan = off;
+		EXPLAIN ANALYZE SELECT i FROM tst ORDER BY v $operator '$queries[0]' LIMIT $limit;
+	));
+	like($explain, qr/Index Scan/);
+
+	for my $i (0 .. $#queries)
+	{
+		my $actual = $node->safe_psql("postgres", qq(
+			SET enable_seqscan = off;
+			SELECT i FROM tst ORDER BY v $operator '$queries[$i]' LIMIT $limit;
+		));
+		my @actual_ids = split("\n", $actual);
+		my %actual_set = map { $_ => 1 } @actual_ids;
+
+		my @expected_ids = split("\n", $expected[$i]);
+
+		foreach (@expected_ids)
+		{
+			if (exists($actual_set{$_}))
+			{
+				$correct++;
+			}
+			$total++;
+		}
+	}
+
+	cmp_ok($correct / $total, ">=", $min, $operator);
+}
+
+# Initialize node
+$node = PostgreSQL::Test::Cluster->new('node');
+$node->init;
+$node->start;
+
+# Create table
+$node->safe_psql("postgres", "CREATE EXTENSION vector;");
+$node->safe_psql("postgres", "CREATE TABLE tst (i serial, v minivec($dim));");
+
+# Generate queries
+for (1 .. 20)
+{
+	my @r = ();
+	for (1 .. $dim)
+	{
+		push(@r, rand());
+	}
+	push(@queries, "[" . join(",", @r) . "]");
+}
+
+# Check each index type
+my @operators = ("<->", "<#>", "<=>", "<+>");
+my @opclasses = ("minivec_l2_ops", "minivec_ip_ops", "minivec_cosine_ops", "minivec_l1_ops");
+
+for my $i (0 .. $#operators)
+{
+	my $operator = $operators[$i];
+	my $opclass = $opclasses[$i];
+
+	# Add index
+	$node->safe_psql("postgres", "CREATE INDEX idx ON tst USING hnsw (v $opclass);");
+
+	# Use concurrent inserts
+	$node->pgbench(
+		"--no-vacuum --client=10 --transactions=1000",
+		0,
+		[qr{actually processed}],
+		[qr{^$}],
+		"concurrent INSERTs",
+		{
+			"040_hnsw_minivec_insert_recall_$opclass" => "INSERT INTO tst (v) VALUES (ARRAY[$array_sql]);"
+		}
+	);
+
+	# Get exact results
+	@expected = ();
+	foreach (@queries)
+	{
+		my $res = $node->safe_psql("postgres", qq(
+			SET enable_indexscan = off;
+			SELECT i FROM tst ORDER BY v $operator '$_' LIMIT $limit;
+		));
+		push(@expected, $res);
+	}
+
+	# Test approximate results
+	my $min = 0.98;
+	test_recall($min, $operator);
+
+	$node->safe_psql("postgres", "DROP INDEX idx;");
+	$node->safe_psql("postgres", "TRUNCATE tst;");
+}
+
+done_testing();

test/t/040_ivfflat_cost.pl

@@ -1,50 +0,0 @@
-use strict;
-use warnings FATAL => 'all';
-use PostgreSQL::Test::Cluster;
-use PostgreSQL::Test::Utils;
-use Test::More;
-
-my @dims = (384, 1536);
-my $limit = 10;
-
-# Initialize node
-my $node = PostgreSQL::Test::Cluster->new('node');
-$node->init;
-$node->start;
-
-$node->safe_psql("postgres", "CREATE EXTENSION vector;");
-
-for my $dim (@dims)
-{
-	my $array_sql = join(",", ('random()') x $dim);
-
-	# Create table and index
-	$node->safe_psql("postgres", "CREATE TABLE tst (i int4, v vector($dim));");
-	$node->safe_psql("postgres",
-		"INSERT INTO tst SELECT i, ARRAY[$array_sql] FROM generate_series(1, 5000) i;"
-	);
-	$node->safe_psql("postgres", "CREATE INDEX idx ON tst USING ivfflat (v vector_l2_ops) WITH (lists = 5);");
-	$node->safe_psql("postgres", "ANALYZE tst;");
-
-	# Generate query
-	my @r = ();
-	for (1 .. $dim)
-	{
-		push(@r, rand());
-	}
-	my $query = "[" . join(",", @r) . "]";
-
-	my $explain = $node->safe_psql("postgres", qq(
-		EXPLAIN ANALYZE SELECT i FROM tst ORDER BY v <-> '$query' LIMIT $limit;
-	));
-	like($explain, qr/Index Scan using idx/);
-
-	$explain = $node->safe_psql("postgres", qq(
-		EXPLAIN ANALYZE SELECT i FROM tst WHERE v <-> '$query' < 1 ORDER BY v <-> '$query' LIMIT $limit;
-	));
-	like($explain, qr/Index Scan using idx/);
-
-	$node->safe_psql("postgres", "DROP TABLE tst;");
-}
-
-done_testing();

test/t/041_hnsw_minivec_vacuum_recall.pl

@@ -0,0 +1,97 @@
+use strict;
+use warnings FATAL => 'all';
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
+use Test::More;
+
+my $node;
+my @queries = ();
+my @expected;
+my $limit = 20;
+
+sub test_recall
+{
+	my ($min, $ef_search, $test_name) = @_;
+	my $correct = 0;
+	my $total = 0;
+
+	my $explain = $node->safe_psql("postgres", qq(
+		SET enable_seqscan = off;
+		SET hnsw.ef_search = $ef_search;
+		EXPLAIN ANALYZE SELECT i FROM tst ORDER BY v <-> '$queries[0]' LIMIT $limit;
+	));
+	like($explain, qr/Index Scan/);
+
+	for my $i (0 .. $#queries)
+	{
+		my $actual = $node->safe_psql("postgres", qq(
+			SET enable_seqscan = off;
+			SET hnsw.ef_search = $ef_search;
+			SELECT i FROM tst ORDER BY v <-> '$queries[$i]' LIMIT $limit;
+		));
+		my @actual_ids = split("\n", $actual);
+		my %actual_set = map { $_ => 1 } @actual_ids;
+
+		my @expected_ids = split("\n", $expected[$i]);
+
+		foreach (@expected_ids)
+		{
+			if (exists($actual_set{$_}))
+			{
+				$correct++;
+			}
+			$total++;
+		}
+	}
+
+	cmp_ok($correct / $total, ">=", $min, $test_name);
+}
+
+# Initialize node
+$node = PostgreSQL::Test::Cluster->new('node');
+$node->init;
+$node->start;
+
+# Create table
+$node->safe_psql("postgres", "CREATE EXTENSION vector;");
+$node->safe_psql("postgres", "CREATE TABLE tst (i int4, v minivec(3));");
+$node->safe_psql("postgres", "ALTER TABLE tst SET (autovacuum_enabled = false);");
+$node->safe_psql("postgres",
+	"INSERT INTO tst SELECT i, ARRAY[random(), random(), random()] FROM generate_series(1, 10000) i;"
+);
+
+# Add index
+$node->safe_psql("postgres", "CREATE INDEX ON tst USING hnsw (v minivec_l2_ops) WITH (m = 4, ef_construction = 8);");
+
+# Delete data
+$node->safe_psql("postgres", "DELETE FROM tst WHERE i > 2500;");
+
+# Generate queries
+for (1 .. 20)
+{
+	my $r1 = rand();
+	my $r2 = rand();
+	my $r3 = rand();
+	push(@queries, "[$r1,$r2,$r3]");
+}
+
+# Get exact results
+@expected = ();
+foreach (@queries)
+{
+	my $res = $node->safe_psql("postgres", qq(
+		SET enable_indexscan = off;
+		SELECT i FROM tst ORDER BY v <-> '$_' LIMIT $limit;
+	));
+	push(@expected, $res);
+}
+
+test_recall(0.18, $limit, "before vacuum");
+test_recall(0.93, 100, "before vacuum");
+
+# TODO Test concurrent inserts with vacuum
+$node->safe_psql("postgres", "VACUUM tst;");
+
+test_recall(0.95, $limit, "after vacuum");
+
+done_testing();

test/t/041_ivfflat_inline_filtering.pl

@@ -1,197 +0,0 @@
-use strict;
-use warnings FATAL => 'all';
-use PostgreSQL::Test::Cluster;
-use PostgreSQL::Test::Utils;
-use Test::More;
-
-my $node;
-my @queries = ();
-my @where = ();
-my @expected;
-my $limit = 20;
-my $dim = 3;
-my $array_sql = join(",", ('random()') x $dim);
-my $nc = 100;
-my $nc2 = 10;
-
-sub test_recall
-{
-	my ($probes, $min, $operator) = @_;
-	my $correct = 0;
-	my $total = 0;
-
-	for my $j (0 .. 2)
-	{
-		my $explain = $node->safe_psql("postgres", qq(
-			SET enable_seqscan = off;
-			SET ivfflat.probes = $probes;
-			EXPLAIN ANALYZE SELECT i FROM tst WHERE $where[$j] ORDER BY v $operator '$queries[$j]' LIMIT $limit;
-		));
-		like($explain, qr/Index Cond/);
-	}
-
-	for my $i (0 .. $#queries)
-	{
-		my $actual = $node->safe_psql("postgres", qq(
-			SET enable_seqscan = off;
-			SET ivfflat.probes = $probes;
-			SELECT i FROM tst WHERE $where[$i] ORDER BY v $operator '$queries[$i]' LIMIT $limit;
-		));
-		my @actual_ids = split("\n", $actual);
-		my %actual_set = map { $_ => 1 } @actual_ids;
-
-		is(scalar(@actual_ids), $limit);
-
-		my @expected_ids = split("\n", $expected[$i]);
-
-		foreach (@expected_ids)
-		{
-			if (exists($actual_set{$_}))
-			{
-				$correct++;
-			}
-			$total++;
-		}
-	}
-
-	cmp_ok($correct / $total, ">=", $min, $operator);
-}
-
-# Initialize node
-$node = PostgreSQL::Test::Cluster->new('node');
-$node->init;
-$node->start;
-
-# Create table
-$node->safe_psql("postgres", "CREATE EXTENSION vector;");
-$node->safe_psql("postgres", "CREATE TABLE tst (i int4, v vector($dim), c int4, c2 int4);");
-$node->safe_psql("postgres",
-	"INSERT INTO tst SELECT i, ARRAY[$array_sql], i % $nc, i % $nc2 FROM generate_series(1, 50000) i;"
-);
-
-# Generate queries
-for my $i (1 .. 100)
-{
-	my @r = ();
-	for (1 .. $dim)
-	{
-		push(@r, rand());
-	}
-	push(@queries, "[" . join(",", @r) . "]");
-
-	if ($i % 3 == 0)
-	{
-		my $c = int(rand() * $nc);
-		push(@where, "c = $c");
-	}
-	elsif ($i % 3 == 1)
-	{
-		my $c2 = int(rand() * $nc2);
-		push(@where, "c2 = $c2");
-	}
-	else
-	{
-		# use c2 to ensure results
-		my $c2 = int(rand() * $nc2);
-		push(@where, "c = $c2 AND c2 = $c2");
-	}
-}
-
-# Add index
-$node->safe_psql("postgres", qq(
-	CREATE INDEX ON tst USING ivfflat (v vector_l2_ops, c, c2) WITH (lists = 100);
-));
-
-# Insert more rows
-$node->safe_psql("postgres",
-	"INSERT INTO tst SELECT i, ARRAY[$array_sql], i % $nc, i % $nc2 FROM generate_series(1, 50000) i;"
-);
-
-# Get exact results
-@expected = ();
-for my $i (0 .. $#queries)
-{
-	my $res = $node->safe_psql("postgres", qq(
-		SET enable_indexscan = off;
-		SELECT i FROM tst WHERE $where[$i] ORDER BY v <-> '$queries[$i]' LIMIT $limit;
-	));
-	push(@expected, $res);
-}
-
-# Test recall
-test_recall(10, 0.99, '<->');
-
-# Test vacuum
-$node->safe_psql("postgres", "DELETE FROM tst WHERE c > 5;");
-$node->safe_psql("postgres", "VACUUM tst;");
-
-# Test less than
-my $explain = $node->safe_psql("postgres", qq(
-	SET enable_seqscan = off;
-	EXPLAIN ANALYZE SELECT i FROM tst WHERE c < 10 ORDER BY v <-> '$queries[0]' LIMIT $limit;
-));
-like($explain, qr/Index Cond: \(c < 10\)/);
-
-# Test less than or equal
-$explain = $node->safe_psql("postgres", qq(
-	SET enable_seqscan = off;
-	EXPLAIN ANALYZE SELECT i FROM tst WHERE c <= 10 ORDER BY v <-> '$queries[0]' LIMIT $limit;
-));
-like($explain, qr/Index Cond: \(c <= 10\)/);
-
-# Test greater than or equal
-$explain = $node->safe_psql("postgres", qq(
-	SET enable_seqscan = off;
-	EXPLAIN ANALYZE SELECT i FROM tst WHERE c >= 90 ORDER BY v <-> '$queries[0]' LIMIT $limit;
-));
-like($explain, qr/Index Cond: \(c >= 90\)/);
-
-# Test greater than
-$explain = $node->safe_psql("postgres", qq(
-	SET enable_seqscan = off;
-	EXPLAIN ANALYZE SELECT i FROM tst WHERE c > 90 ORDER BY v <-> '$queries[0]' LIMIT $limit;
-));
-like($explain, qr/Index Cond: \(c > 90\)/);
-
-# Test multiple attribute columns
-$explain = $node->safe_psql("postgres", qq(
-	SET enable_seqscan = off;
-	EXPLAIN ANALYZE SELECT i FROM tst WHERE c = 1 AND c2 = 1 ORDER BY v <-> '$queries[0]' LIMIT $limit;
-));
-like($explain, qr/Index Cond: \(\(c = 1\) AND \(c2 = 1\)\)/);
-
-# Test only last attribute column
-$explain = $node->safe_psql("postgres", qq(
-	SET enable_seqscan = off;
-	EXPLAIN ANALYZE SELECT i FROM tst WHERE c2 = 1 ORDER BY v <-> '$queries[0]' LIMIT $limit;
-));
-like($explain, qr/Index Cond: \(c2 = 1\)/);
-
-# Test only vector column
-$explain = $node->safe_psql("postgres", qq(
-	SET enable_seqscan = off;
-	EXPLAIN ANALYZE SELECT i FROM tst ORDER BY v <-> '$queries[0]' LIMIT $limit;
-));
-like($explain, qr/Index Scan/);
-
-# Test only attribute columns
-$explain = $node->safe_psql("postgres", qq(
-	SET enable_seqscan = off;
-	EXPLAIN ANALYZE SELECT i FROM tst WHERE c = 1;
-));
-like($explain, qr/Seq Scan/);
-
-# Test columns
-my ($ret, $stdout, $stderr) = $node->psql("postgres", "CREATE INDEX ON tst USING ivfflat (c);");
-like($stderr, qr/first column must be a vector/);
-
-($ret, $stdout, $stderr) = $node->psql("postgres", "CREATE INDEX ON tst USING ivfflat (c, v vector_cosine_ops);");
-like($stderr, qr/first column must be a vector/);
-
-($ret, $stdout, $stderr) = $node->psql("postgres", "CREATE INDEX ON tst USING ivfflat (v vector_cosine_ops, c, c, c);");
-like($stderr, qr/index cannot have more than three columns/);
-
-($ret, $stdout, $stderr) = $node->psql("postgres", "CREATE INDEX ON tst USING ivfflat (v vector_cosine_ops, v vector_cosine_ops);");
-like($stderr, qr/column 2 cannot be a vector/);
-
-done_testing();

test/t/042_hnsw_minivec_duplicates.pl

@@ -0,0 +1,58 @@
+use strict;
+use warnings FATAL => 'all';
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
+use Test::More;
+
+# Initialize node
+my $node = PostgreSQL::Test::Cluster->new('node');
+$node->init;
+$node->start;
+
+# Create table
+$node->safe_psql("postgres", "CREATE EXTENSION vector;");
+$node->safe_psql("postgres", "CREATE TABLE tst (v minivec(3));");
+
+sub insert_vectors
+{
+	for my $i (1 .. 20)
+	{
+		$node->safe_psql("postgres", "INSERT INTO tst VALUES ('[1,1,1]');");
+	}
+}
+
+sub test_duplicates
+{
+	my $res = $node->safe_psql("postgres", qq(
+		SET enable_seqscan = off;
+		SET hnsw.ef_search = 1;
+		SELECT COUNT(*) FROM (SELECT * FROM tst ORDER BY v <-> '[1,1,1]') t;
+	));
+	is($res, 10);
+}
+
+# Test duplicates with build
+insert_vectors();
+$node->safe_psql("postgres", "CREATE INDEX idx ON tst USING hnsw (v minivec_l2_ops);");
+test_duplicates();
+
+# Reset
+$node->safe_psql("postgres", "TRUNCATE tst;");
+
+# Test duplicates with inserts
+insert_vectors();
+test_duplicates();
+
+# Test fallback path for inserts
+$node->pgbench(
+	"--no-vacuum --client=5 --transactions=100",
+	0,
+	[qr{actually processed}],
+	[qr{^$}],
+	"concurrent INSERTs",
+	{
+		"042_hnsw_minivec_duplicates" => "INSERT INTO tst VALUES ('[1,1,1]');"
+	}
+);
+
+done_testing();

test/t/043_ivfflat_minivec_build_recall.pl

@@ -0,0 +1,154 @@
+use strict;
+use warnings FATAL => 'all';
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
+use Test::More;
+
+my $node;
+my @queries = ();
+my @expected;
+my $limit = 20;
+my $dim = 10;
+my $array_sql = join(",", ('random()') x $dim);
+
+sub test_recall
+{
+	my ($probes, $min, $operator) = @_;
+	my $correct = 0;
+	my $total = 0;
+
+	my $explain = $node->safe_psql("postgres", qq(
+		SET enable_seqscan = off;
+		SET ivfflat.probes = $probes;
+		EXPLAIN ANALYZE SELECT i FROM tst ORDER BY v $operator '$queries[0]' LIMIT $limit;
+	));
+	like($explain, qr/Index Scan using idx on tst/);
+
+	for my $i (0 .. $#queries)
+	{
+		my $actual = $node->safe_psql("postgres", qq(
+			SET enable_seqscan = off;
+			SET ivfflat.probes = $probes;
+			SELECT i FROM tst ORDER BY v $operator '$queries[$i]' LIMIT $limit;
+		));
+		my @actual_ids = split("\n", $actual);
+
+		my @expected_ids = split("\n", $expected[$i]);
+		my %expected_set = map { $_ => 1 } @expected_ids;
+
+		foreach (@actual_ids)
+		{
+			if (exists($expected_set{$_}))
+			{
+				$correct++;
+			}
+		}
+
+		$total += $limit;
+	}
+
+	cmp_ok($correct / $total, ">=", $min, $operator);
+}
+
+# Initialize node
+$node = PostgreSQL::Test::Cluster->new('node');
+$node->init;
+$node->start;
+
+# Create table
+$node->safe_psql("postgres", "CREATE EXTENSION vector;");
+$node->safe_psql("postgres", "CREATE TABLE tst (i int4, v minivec($dim));");
+$node->safe_psql("postgres",
+	"INSERT INTO tst SELECT i, ARRAY[$array_sql] FROM generate_series(1, 100000) i;"
+);
+
+# Generate queries
+for (1 .. 20)
+{
+	my @r = ();
+	for (1 .. $dim)
+	{
+		push(@r, rand());
+	}
+	push(@queries, "[" . join(",", @r) . "]");
+}
+
+# Check each index type
+my @operators = ("<->", "<#>", "<=>");
+my @opclasses = ("minivec_l2_ops", "minivec_ip_ops", "minivec_cosine_ops");
+
+for my $i (0 .. $#operators)
+{
+	my $operator = $operators[$i];
+	my $opclass = $opclasses[$i];
+
+	# Get exact results
+	@expected = ();
+	foreach (@queries)
+	{
+		my $res = $node->safe_psql("postgres", qq(
+			WITH top AS (
+				SELECT v $operator '$_' AS distance FROM tst ORDER BY distance LIMIT $limit
+			)
+			SELECT i FROM tst WHERE (v $operator '$_') <= (SELECT MAX(distance) FROM top)
+		));
+		push(@expected, $res);
+	}
+
+	# Build index serially
+	$node->safe_psql("postgres", qq(
+		SET max_parallel_maintenance_workers = 0;
+		CREATE INDEX idx ON tst USING ivfflat (v $opclass);
+	));
+
+	# Test approximate results
+	if ($operator ne "<#>")
+	{
+		# TODO Fix test (uniform random vectors all have similar inner product)
+		test_recall(1, 0.33, $operator);
+		test_recall(10, 0.93, $operator);
+	}
+
+	# Test probes equals lists
+	if ($operator eq "<=>")
+	{
+		test_recall(100, 0.98, $operator);
+	}
+	else
+	{
+		test_recall(100, 1.00, $operator);
+	}
+
+	$node->safe_psql("postgres", "DROP INDEX idx;");
+
+	# Build index in parallel
+	my ($ret, $stdout, $stderr) = $node->psql("postgres", qq(
+		SET client_min_messages = DEBUG;
+		SET min_parallel_table_scan_size = 1;
+		CREATE INDEX idx ON tst USING ivfflat (v $opclass);
+	));
+	is($ret, 0, $stderr);
+	like($stderr, qr/using \d+ parallel workers/);
+
+	# Test approximate results
+	if ($operator ne "<#>")
+	{
+		# TODO Fix test (uniform random vectors all have similar inner product)
+		test_recall(1, 0.33, $operator);
+		test_recall(10, 0.93, $operator);
+	}
+
+	# Test probes equals lists
+	if ($operator eq "<=>")
+	{
+		test_recall(100, 0.98, $operator);
+	}
+	else
+	{
+		test_recall(100, 1.00, $operator);
+	}
+
+	$node->safe_psql("postgres", "DROP INDEX idx;");
+}
+
+done_testing();