Added test for explicit zeros [skip ci]

This takes the approach from commit a713e2acaa further. Once we have
remove a candidate from the "closer" set, we still don't need to
recalculate everything that follows. Any candidates that were in the
closer set before still only need to be compared with any new
candidates that we have added.

.github/workflows/build.yml

@@ -8,6 +8,8 @@ jobs:
       fail-fast: false
       matrix:
         include:
+          - postgres: 17
+            os: ubuntu-22.04
           - postgres: 16
             os: ubuntu-22.04
           - postgres: 15
@@ -21,7 +23,7 @@ jobs:
           - postgres: 11
             os: ubuntu-20.04
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - uses: ankane/setup-postgres@v1
         with:
           postgres-version: ${{ matrix.postgres }}
@@ -43,7 +45,7 @@ jobs:
     runs-on: macos-latest
     if: ${{ !startsWith(github.ref_name, 'windows') }}
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - uses: ankane/setup-postgres@v1
         with:
           postgres-version: 14
@@ -65,7 +67,7 @@ jobs:
     runs-on: windows-latest
     if: ${{ !startsWith(github.ref_name, 'mac') }}
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - uses: ankane/setup-postgres@v1
         with:
           postgres-version: 14

CHANGELOG.md

@@ -1,7 +1,11 @@
-## 0.5.1 (unreleased)
+## 0.6.0 (unreleased)
 
-- Improved performance of index scans for IVFFlat after updates and deletes
+- Added support for sparse vectors
-- Fixed locking for index scans for HNSW
+
+## 0.5.1 (2023-10-10)
+
+- Improved performance of HNSW index builds
+- Added check for MVCC-compliant snapshot for index scans
 
 ## 0.5.0 (2023-08-28)
 

META.json

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

Makefile

@@ -1,10 +1,10 @@
 EXTENSION = vector
-EXTVERSION = 0.5.0
+EXTVERSION = 0.5.1
 
 MODULE_big = vector
 DATA = $(wildcard sql/*--*.sql)
-OBJS = src/hnsw.o src/hnswbuild.o src/hnswinsert.o src/hnswscan.o src/hnswutils.o src/hnswvacuum.o src/ivfbuild.o src/ivfflat.o src/ivfinsert.o src/ivfkmeans.o src/ivfscan.o src/ivfutils.o src/ivfvacuum.o src/vector.o
+OBJS = src/hnsw.o src/hnswbuild.o src/hnswinsert.o src/hnswscan.o src/hnswutils.o src/hnswvacuum.o src/ivfbuild.o src/ivfflat.o src/ivfinsert.o src/ivfkmeans.o src/ivfscan.o src/ivfutils.o src/ivfvacuum.o src/svector.o src/vector.o
-HEADERS = src/vector.h
+HEADERS = src/svector.h src/vector.h
 
 TESTS = $(wildcard test/sql/*.sql)
 REGRESS = $(patsubst test/sql/%.sql,%,$(TESTS))

Makefile.win

@@ -1,8 +1,8 @@
 EXTENSION = vector
-EXTVERSION = 0.5.0
+EXTVERSION = 0.5.1
 
-OBJS = src\hnsw.obj src\hnswbuild.obj src\hnswinsert.obj src\hnswscan.obj src\hnswutils.obj src\hnswvacuum.obj src\ivfbuild.obj src\ivfflat.obj src\ivfinsert.obj src\ivfkmeans.obj src\ivfscan.obj src\ivfutils.obj src\ivfvacuum.obj src\vector.obj
+OBJS = src\hnsw.obj src\hnswbuild.obj src\hnswinsert.obj src\hnswscan.obj src\hnswutils.obj src\hnswvacuum.obj src\ivfbuild.obj src\ivfflat.obj src\ivfinsert.obj src\ivfkmeans.obj src\ivfscan.obj src\ivfutils.obj src\ivfvacuum.obj src\svector.obj src\vector.obj
-HEADERS = src\vector.h
+HEADERS = src\svector.h src\vector.h
 
 REGRESS = btree cast copy functions input ivfflat_cosine ivfflat_ip ivfflat_l2 ivfflat_options ivfflat_unlogged
 REGRESS_OPTS = --inputdir=test --load-extension=$(EXTENSION)
@@ -56,7 +56,7 @@ install:
 	copy $(EXTENSION).control "$(SHAREDIR)\extension"
 	copy sql\$(EXTENSION)--*.sql "$(SHAREDIR)\extension"
 	mkdir "$(INCLUDEDIR_SERVER)\extension\$(EXTENSION)"
-	copy $(HEADERS) "$(INCLUDEDIR_SERVER)\extension\$(EXTENSION)"
+	for %f in ($(HEADERS)) do copy %f "$(INCLUDEDIR_SERVER)\extension\$(EXTENSION)"
 
 installcheck:
 	"$(BINDIR)\pg_regress" --bindir="$(BINDIR)" $(REGRESS_OPTS) $(REGRESS)

README.md

@@ -18,7 +18,7 @@ Compile and install the extension (supports Postgres 11+)
 
 ```sh
 cd /tmp
-git clone --branch v0.5.0 https://github.com/pgvector/pgvector.git
+git clone --branch v0.5.1 https://github.com/pgvector/pgvector.git
 cd pgvector
 make
 make install # may need sudo
@@ -26,7 +26,7 @@ make install # may need sudo
 
 See the [installation notes](#installation-notes) if you run into issues
 
-You can also install it with [Docker](#docker), [Homebrew](#homebrew), [PGXN](#pgxn), [APT](#apt), [Yum](#yum), or [conda-forge](#conda-forge), and it comes preinstalled with [Postgres.app](#postgresapp) and many [hosted providers](#hosted-postgres)
+You can also install it with [Docker](#docker), [Homebrew](#homebrew), [PGXN](#pgxn), [APT](#apt), [Yum](#yum), or [conda-forge](#conda-forge), and it comes preinstalled with [Postgres.app](#postgresapp) and many [hosted providers](#hosted-postgres). There are also instructions for [GitHub Actions](https://github.com/pgvector/setup-pgvector).
 
 ## Getting Started
 
@@ -215,6 +215,23 @@ SELECT ...
 COMMIT;
 ```
 
+### Indexing Progress
+
+Check [indexing progress](https://www.postgresql.org/docs/current/progress-reporting.html#CREATE-INDEX-PROGRESS-REPORTING) with Postgres 12+
+
+```sql
+SELECT phase, round(100.0 * tuples_done / nullif(tuples_total, 0), 1) AS "%" FROM pg_stat_progress_create_index;
+```
+
+The phases for IVFFlat are:
+
+1. `initializing`
+2. `performing k-means`
+3. `assigning tuples`
+4. `loading tuples`
+
+Note: `%` is only populated during the `loading tuples` phase
+
 ## HNSW
 
 An HNSW index creates a multilayer graph. It has slower build times and uses more memory than IVFFlat, but has better query performance (in terms of speed-recall tradeoff). There’s no training step like IVFFlat, so the index can be created without any data in the table.
@@ -271,22 +288,18 @@ SELECT ...
 COMMIT;
 ```
 
-## Indexing Progress
+### Indexing Progress
 
 Check [indexing progress](https://www.postgresql.org/docs/current/progress-reporting.html#CREATE-INDEX-PROGRESS-REPORTING) with Postgres 12+
 
 ```sql
-SELECT phase, tuples_done, tuples_total FROM pg_stat_progress_create_index;
+SELECT phase, round(100.0 * blocks_done / nullif(blocks_total, 0), 1) AS "%" FROM pg_stat_progress_create_index;
 ```
 
-The phases are:
+The phases for HNSW are:
 
 1. `initializing`
-2. `performing k-means` - IVFFlat only
+2. `loading tuples`
-3. `assigning tuples` - IVFFlat only
-4. `loading tuples`
-
-Note: `tuples_done` and `tuples_total` are only populated during the `loading tuples` phase
 
 ## Filtering
 
@@ -317,13 +330,15 @@ CREATE TABLE items (embedding vector(3), category_id int) PARTITION BY LIST(cate
 
 ## Hybrid Search
 
-Use together with Postgres [full-text search](https://www.postgresql.org/docs/current/textsearch-intro.html) for hybrid search ([Python example](https://github.com/pgvector/pgvector-python/blob/master/examples/hybrid_search.py)).
+Use together with Postgres [full-text search](https://www.postgresql.org/docs/current/textsearch-intro.html) for hybrid search.
 
 ```sql
 SELECT id, content FROM items, plainto_tsquery('hello search') query
     WHERE textsearch @@ query ORDER BY ts_rank_cd(textsearch, query) DESC LIMIT 5;
 ```
 
+You can use [Reciprocal Rank Fusion](https://github.com/pgvector/pgvector-python/blob/master/examples/hybrid_search_rrf.py) or a [cross-encoder](https://github.com/pgvector/pgvector-python/blob/master/examples/hybrid_search.py) to combine results.
+
 ## Performance
 
 Use `EXPLAIN ANALYZE` to debug performance.
@@ -354,12 +369,33 @@ To speed up queries with an IVFFlat index, increase the number of inverted lists
 CREATE INDEX ON items USING ivfflat (embedding vector_l2_ops) WITH (lists = 1000);
 ```
 
+## Sparse Vectors
+
+Create a sparse vector column with 10 dimensions
+
+```sql
+CREATE TABLE items (id bigserial PRIMARY KEY, embedding svector(10));
+```
+
+Insert vectors
+
+```sql
+INSERT INTO items (embedding) VALUES ('(0,1),(1,2),(2,3)|10|'), ('(0,4),(1,5),(4,6)|10|');
+```
+
+Get the nearest neighbors by L2 distance
+
+```sql
+SELECT * FROM items ORDER BY embedding <-> '(0,3),(1,1),(2,2)|10|' LIMIT 5;
+```
+
 ## Languages
 
 Use pgvector from any language with a Postgres client. You can even generate and store vectors in one language and query them in another.
 
 Language | Libraries / Examples
 --- | ---
+C | [pgvector-c](https://github.com/pgvector/pgvector-c)
 C++ | [pgvector-cpp](https://github.com/pgvector/pgvector-cpp)
 C# | [pgvector-dotnet](https://github.com/pgvector/pgvector-dotnet)
 Crystal | [pgvector-crystal](https://github.com/pgvector/pgvector-crystal)
@@ -367,10 +403,11 @@ Dart | [pgvector-dart](https://github.com/pgvector/pgvector-dart)
 Elixir | [pgvector-elixir](https://github.com/pgvector/pgvector-elixir)
 Go | [pgvector-go](https://github.com/pgvector/pgvector-go)
 Haskell | [pgvector-haskell](https://github.com/pgvector/pgvector-haskell)
-Java, Scala | [pgvector-java](https://github.com/pgvector/pgvector-java)
+Java, Kotlin, Groovy, Scala | [pgvector-java](https://github.com/pgvector/pgvector-java)
+JavaScript, TypeScript | [pgvector-node](https://github.com/pgvector/pgvector-node)
 Julia | [pgvector-julia](https://github.com/pgvector/pgvector-julia)
 Lua | [pgvector-lua](https://github.com/pgvector/pgvector-lua)
-Node.js | [pgvector-node](https://github.com/pgvector/pgvector-node)
+Nim | [pgvector-nim](https://github.com/pgvector/pgvector-nim)
 Perl | [pgvector-perl](https://github.com/pgvector/pgvector-perl)
 PHP | [pgvector-php](https://github.com/pgvector/pgvector-php)
 Python | [pgvector-python](https://github.com/pgvector/pgvector-python)
@@ -378,6 +415,7 @@ R | [pgvector-r](https://github.com/pgvector/pgvector-r)
 Ruby | [pgvector-ruby](https://github.com/pgvector/pgvector-ruby), [Neighbor](https://github.com/ankane/neighbor)
 Rust | [pgvector-rust](https://github.com/pgvector/pgvector-rust)
 Swift | [pgvector-swift](https://github.com/pgvector/pgvector-swift)
+Zig | [pgvector-zig](https://github.com/pgvector/pgvector-zig)
 
 ## Frequently Asked Questions
 
@@ -393,6 +431,55 @@ Yes, pgvector uses the write-ahead log (WAL), which allows for replication and p
 
 You’ll need to use [dimensionality reduction](https://en.wikipedia.org/wiki/Dimensionality_reduction) at the moment.
 
+#### Can I store vectors with different dimensions in the same column?
+
+You can use `vector` as the type (instead of `vector(3)`).
+
+```sql
+CREATE TABLE embeddings (model_id bigint, item_id bigint, embedding vector, PRIMARY KEY (model_id, item_id));
+```
+
+However, you can only create indexes on rows with the same number of dimensions (using [expression](https://www.postgresql.org/docs/current/indexes-expressional.html) and [partial](https://www.postgresql.org/docs/current/indexes-partial.html) indexing):
+
+```sql
+CREATE INDEX ON embeddings USING hnsw ((embedding::vector(3)) vector_l2_ops) WHERE (model_id = 123);
+```
+
+and query with:
+
+```sql
+SELECT * FROM embeddings WHERE model_id = 123 ORDER BY embedding::vector(3) <-> '[3,1,2]' LIMIT 5;
+```
+
+#### Can I store vectors with more precision?
+
+You can use the `double precision[]` or `numeric[]` type to store vectors with more precision.
+
+```sql
+CREATE TABLE items (id bigserial PRIMARY KEY, embedding double precision[]);
+
+-- use {} instead of [] for Postgres arrays
+INSERT INTO items (embedding) VALUES ('{1,2,3}'), ('{4,5,6}');
+```
+
+Optionally, add a [check constraint](https://www.postgresql.org/docs/current/ddl-constraints.html) to ensure data can be converted to the `vector` type and has the expected dimensions.
+
+```sql
+ALTER TABLE items ADD CHECK (vector_dims(embedding::vector) = 3);
+```
+
+Use [expression indexing](https://www.postgresql.org/docs/current/indexes-expressional.html) to index (at a lower precision):
+
+```sql
+CREATE INDEX ON items USING hnsw ((embedding::vector(3)) vector_l2_ops);
+```
+
+and query with:
+
+```sql
+SELECT * FROM items ORDER BY embedding::vector(3) <-> '[3,1,2]' LIMIT 5;
+```
+
 ## Troubleshooting
 
 #### Why isn’t a query using an index?
@@ -406,6 +493,8 @@ SELECT ...
 COMMIT;
 ```
 
+Also, if the table is small, a table scan may be faster.
+
 #### Why isn’t a query using a parallel table scan?
 
 The planner doesn’t consider [out-of-line storage](https://www.postgresql.org/docs/current/storage-toast.html) in cost estimates, which can make a serial scan look cheaper. You can reduce the cost of a parallel scan for a query with:
@@ -509,7 +598,7 @@ Then use `nmake` to build:
 
 ```cmd
 set "PGROOT=C:\Program Files\PostgreSQL\15"
-git clone --branch v0.5.0 https://github.com/pgvector/pgvector.git
+git clone --branch v0.5.1 https://github.com/pgvector/pgvector.git
 cd pgvector
 nmake /F Makefile.win
 nmake /F Makefile.win install
@@ -530,7 +619,7 @@ This adds pgvector to the [Postgres image](https://hub.docker.com/_/postgres) (r
 You can also build the image manually:
 
 ```sh
-git clone --branch v0.5.0 https://github.com/pgvector/pgvector.git
+git clone --branch v0.5.1 https://github.com/pgvector/pgvector.git
 cd pgvector
 docker build --build-arg PG_MAJOR=15 -t myuser/pgvector .
 ```
@@ -595,7 +684,7 @@ pgvector is available on [these providers](https://github.com/pgvector/pgvector/
 
 ## Upgrading
 
-Install the latest version. Then in each database you want to upgrade, run:
+[Install](#installation) the latest version (use the same method as the original installation). Then in each database you want to upgrade, run:
 
 ```sql
 ALTER EXTENSION vector UPDATE;

sql/vector--0.5.0--0.5.1.sql

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

sql/vector--0.5.1--0.6.0.sql

@@ -0,0 +1,79 @@
+-- complain if script is sourced in psql, rather than via CREATE EXTENSION
+\echo Use "ALTER EXTENSION vector UPDATE TO '0.6.0'" to load this file. \quit
+
+CREATE TYPE svector;
+
+CREATE FUNCTION svector_in(cstring, oid, integer) RETURNS svector
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION svector_out(svector) RETURNS cstring
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION svector_typmod_in(cstring[]) RETURNS integer
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION svector_recv(internal, oid, integer) RETURNS svector
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION svector_send(svector) RETURNS bytea
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE TYPE svector (
+	INPUT     = svector_in,
+	OUTPUT    = svector_out,
+	TYPMOD_IN = svector_typmod_in,
+	RECEIVE   = svector_recv,
+	SEND      = svector_send,
+	STORAGE   = external
+);
+
+CREATE FUNCTION l2_distance(svector, svector) RETURNS float8
+	AS 'MODULE_PATHNAME', 'svector_l2_distance' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION inner_product(svector, svector) RETURNS float8
+	AS 'MODULE_PATHNAME', 'svector_inner_product' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION cosine_distance(svector, svector) RETURNS float8
+	AS 'MODULE_PATHNAME', 'svector_cosine_distance' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION jaccard_distance(svector, svector) RETURNS float8
+	AS 'MODULE_PATHNAME', 'svector_jaccard_distance' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION svector_l2_squared_distance(svector, svector) RETURNS float8
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION svector_negative_inner_product(svector, svector) RETURNS float8
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION svector(svector, integer, boolean) RETURNS svector
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION vector_to_svector(vector, integer, boolean) RETURNS svector
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION svector_to_vector(svector, integer, boolean) RETURNS vector
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE CAST (svector AS svector)
+	WITH FUNCTION svector(svector, integer, boolean) AS IMPLICIT;
+
+CREATE CAST (svector AS vector)
+	WITH FUNCTION svector_to_vector(svector, integer, boolean) AS IMPLICIT;
+
+CREATE CAST (vector AS svector)
+	WITH FUNCTION vector_to_svector(vector, integer, boolean) AS IMPLICIT;
+
+CREATE OPERATOR <-> (
+	LEFTARG = svector, RIGHTARG = svector, PROCEDURE = l2_distance,
+	COMMUTATOR = '<->'
+);
+
+CREATE OPERATOR <#> (
+	LEFTARG = svector, RIGHTARG = svector, PROCEDURE = svector_negative_inner_product,
+	COMMUTATOR = '<#>'
+);
+
+CREATE OPERATOR <=> (
+	LEFTARG = svector, RIGHTARG = svector, PROCEDURE = cosine_distance,
+	COMMUTATOR = '<=>'
+);

sql/vector.sql

@@ -290,3 +290,92 @@ CREATE OPERATOR CLASS vector_cosine_ops
 	OPERATOR 1 <=> (vector, vector) FOR ORDER BY float_ops,
 	FUNCTION 1 vector_negative_inner_product(vector, vector),
 	FUNCTION 2 vector_norm(vector);
+
+--- svector type
+
+CREATE TYPE svector;
+
+CREATE FUNCTION svector_in(cstring, oid, integer) RETURNS svector
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION svector_out(svector) RETURNS cstring
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION svector_typmod_in(cstring[]) RETURNS integer
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION svector_recv(internal, oid, integer) RETURNS svector
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION svector_send(svector) RETURNS bytea
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE TYPE svector (
+	INPUT     = svector_in,
+	OUTPUT    = svector_out,
+	TYPMOD_IN = svector_typmod_in,
+	RECEIVE   = svector_recv,
+	SEND      = svector_send,
+	STORAGE   = external
+);
+
+-- svector functions
+
+CREATE FUNCTION l2_distance(svector, svector) RETURNS float8
+	AS 'MODULE_PATHNAME', 'svector_l2_distance' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION inner_product(svector, svector) RETURNS float8
+	AS 'MODULE_PATHNAME', 'svector_inner_product' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION cosine_distance(svector, svector) RETURNS float8
+	AS 'MODULE_PATHNAME', 'svector_cosine_distance' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION jaccard_distance(svector, svector) RETURNS float8
+	AS 'MODULE_PATHNAME', 'svector_jaccard_distance' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+-- svector private functions
+
+CREATE FUNCTION svector_l2_squared_distance(svector, svector) RETURNS float8
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION svector_negative_inner_product(svector, svector) RETURNS float8
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+-- svector cast functions
+
+CREATE FUNCTION svector(svector, integer, boolean) RETURNS svector
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION vector_to_svector(vector, integer, boolean) RETURNS svector
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION svector_to_vector(svector, integer, boolean) RETURNS vector
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+-- svector casts
+
+CREATE CAST (svector AS svector)
+	WITH FUNCTION svector(svector, integer, boolean) AS IMPLICIT;
+
+CREATE CAST (svector AS vector)
+	WITH FUNCTION svector_to_vector(svector, integer, boolean) AS IMPLICIT;
+
+CREATE CAST (vector AS svector)
+	WITH FUNCTION vector_to_svector(vector, integer, boolean) AS IMPLICIT;
+
+-- svector operators
+
+CREATE OPERATOR <-> (
+	LEFTARG = svector, RIGHTARG = svector, PROCEDURE = l2_distance,
+	COMMUTATOR = '<->'
+);
+
+CREATE OPERATOR <#> (
+	LEFTARG = svector, RIGHTARG = svector, PROCEDURE = svector_negative_inner_product,
+	COMMUTATOR = '<#>'
+);
+
+CREATE OPERATOR <=> (
+	LEFTARG = svector, RIGHTARG = svector, PROCEDURE = cosine_distance,
+	COMMUTATOR = '<=>'
+);

src/hnsw.h

@@ -57,6 +57,8 @@
 /* PROGRESS_CREATEIDX_SUBPHASE_INITIALIZE is 1 */
 #define PROGRESS_HNSW_PHASE_LOAD		2
 
+#define HNSW_MAX_SIZE (BLCKSZ - MAXALIGN(SizeOfPageHeaderData) - MAXALIGN(sizeof(HnswPageOpaqueData)) - sizeof(ItemIdData))
+
 #define HNSW_ELEMENT_TUPLE_SIZE(_dim)	MAXALIGN(offsetof(HnswElementTupleData, vec) + VECTOR_SIZE(_dim))
 #define HNSW_NEIGHBOR_TUPLE_SIZE(level, m)	MAXALIGN(offsetof(HnswNeighborTupleData, indextids) + ((level) + 2) * (m) * sizeof(ItemPointerData))
 
@@ -110,11 +112,13 @@ typedef struct HnswCandidate
 {
 	HnswElement element;
 	float		distance;
+	bool		closer;
 }			HnswCandidate;
 
 typedef struct HnswNeighborArray
 {
 	int			length;
+	bool		closerSet;
 	HnswCandidate *items;
 }			HnswNeighborArray;
 
@@ -258,7 +262,7 @@ typedef struct HnswVacuumState
 /* Methods */
 int			HnswGetM(Relation index);
 int			HnswGetEfConstruction(Relation index);
-FmgrInfo   *HnswOptionalProcInfo(Relation rel, uint16 procnum);
+FmgrInfo   *HnswOptionalProcInfo(Relation index, uint16 procnum);
 bool		HnswNormValue(FmgrInfo *procinfo, Oid collation, Datum *value, Vector * result);
 void		HnswCommitBuffer(Buffer buf, GenericXLogState *state);
 Buffer		HnswNewBuffer(Relation index, ForkNumber forkNum);

src/hnswbuild.c

@@ -81,7 +81,6 @@ HnswBuildAppendPage(Relation index, Buffer *buf, Page *page, GenericXLogState **
 	HnswPageGetOpaque(*page)->nextblkno = BufferGetBlockNumber(newbuf);
 
 	/* Commit */
-	MarkBufferDirty(*buf);
 	GenericXLogFinish(*state);
 	UnlockReleaseBuffer(*buf);
 
@@ -118,12 +117,12 @@ CreateElementPages(HnswBuildState * buildstate)
 	ListCell   *lc;
 
 	/* Calculate sizes */
-	maxSize = BLCKSZ - MAXALIGN(SizeOfPageHeaderData) - MAXALIGN(sizeof(HnswPageOpaqueData));
+	maxSize = HNSW_MAX_SIZE;
 	etupSize = HNSW_ELEMENT_TUPLE_SIZE(dimensions);
 
 	/* Allocate once */
 	etup = palloc0(etupSize);
-	ntup = palloc0(maxSize);
+	ntup = palloc0(BLCKSZ);
 
 	/* Prepare first page */
 	buf = HnswNewBuffer(index, forkNum);
@@ -179,7 +178,6 @@ CreateElementPages(HnswBuildState * buildstate)
 	insertPage = BufferGetBlockNumber(buf);
 
 	/* Commit */
-	MarkBufferDirty(buf);
 	GenericXLogFinish(state);
 	UnlockReleaseBuffer(buf);
 
@@ -227,7 +225,6 @@ CreateNeighborPages(HnswBuildState * buildstate)
 			elog(ERROR, "failed to add index item to \"%s\"", RelationGetRelationName(index));
 
 		/* Commit */
-		MarkBufferDirty(buf);
 		GenericXLogFinish(state);
 		UnlockReleaseBuffer(buf);
 	}

src/hnswinsert.c

@@ -135,7 +135,7 @@ WriteNewElementPages(Relation index, HnswElement e, int m, BlockNumber insertPag
 	etupSize = HNSW_ELEMENT_TUPLE_SIZE(dimensions);
 	ntupSize = HNSW_NEIGHBOR_TUPLE_SIZE(e->level, m);
 	combinedSize = etupSize + ntupSize + sizeof(ItemIdData);
-	maxSize = BLCKSZ - MAXALIGN(SizeOfPageHeaderData) - MAXALIGN(sizeof(HnswPageOpaqueData));
+	maxSize = HNSW_MAX_SIZE;
 	minCombinedSize = etupSize + HNSW_NEIGHBOR_TUPLE_SIZE(0, m) + sizeof(ItemIdData);
 
 	/* Prepare element tuple */
@@ -202,8 +202,6 @@ WriteNewElementPages(Relation index, HnswElement e, int m, BlockNumber insertPag
 			HnswInsertAppendPage(index, &newbuf, &newpage, state, page);
 
 			/* Commit */
-			MarkBufferDirty(newbuf);
-			MarkBufferDirty(buf);
 			GenericXLogFinish(state);
 
 			/* Unlock previous buffer */
@@ -270,9 +268,6 @@ WriteNewElementPages(Relation index, HnswElement e, int m, BlockNumber insertPag
 	}
 
 	/* Commit */
-	MarkBufferDirty(buf);
-	if (nbuf != buf)
-		MarkBufferDirty(nbuf);
 	GenericXLogFinish(state);
 	UnlockReleaseBuffer(buf);
 	if (nbuf != buf)
@@ -391,7 +386,6 @@ HnswUpdateNeighborPages(Relation index, FmgrInfo *procinfo, Oid collation, HnswE
 					elog(ERROR, "failed to add index item to \"%s\"", RelationGetRelationName(index));
 
 				/* Commit */
-				MarkBufferDirty(buf);
 				GenericXLogFinish(state);
 			}
 			else
@@ -445,7 +439,6 @@ HnswAddDuplicate(Relation index, HnswElement element, HnswElement dup)
 		elog(ERROR, "failed to add index item to \"%s\"", RelationGetRelationName(index));
 
 	/* Commit */
-	MarkBufferDirty(buf);
 	GenericXLogFinish(state);
 	UnlockReleaseBuffer(buf);
 

src/hnswscan.c

@@ -113,12 +113,6 @@ hnswbeginscan(Relation index, int nkeys, int norderbys)
 
 	scan->opaque = so;
 
-	/*
-	 * Get a shared lock. This allows vacuum to ensure no in-flight scans
-	 * before marking tuples as deleted.
-	 */
-	LockPage(scan->indexRelation, HNSW_SCAN_LOCK, ShareLock);
-
 	return scan;
 }
 
@@ -166,11 +160,25 @@ hnswgettuple(IndexScanDesc scan, ScanDirection dir)
 		if (scan->orderByData == NULL)
 			elog(ERROR, "cannot scan hnsw index without order");
 
+		/* Requires MVCC-compliant snapshot as not able to maintain a pin */
+		/* https://www.postgresql.org/docs/current/index-locking.html */
+		if (!IsMVCCSnapshot(scan->xs_snapshot))
+			elog(ERROR, "non-MVCC snapshots are not supported with hnsw");
+
 		/* Get scan value */
 		value = GetScanValue(scan);
 
+		/*
+		 * Get a shared lock. This allows vacuum to ensure no in-flight scans
+		 * before marking tuples as deleted.
+		 */
+		LockPage(scan->indexRelation, HNSW_SCAN_LOCK, ShareLock);
+
 		so->w = GetScanItems(scan, value);
 
+		/* Release shared lock */
+		UnlockPage(scan->indexRelation, HNSW_SCAN_LOCK, ShareLock);
+
 		so->first = false;
 	}
 
@@ -198,15 +206,6 @@ hnswgettuple(IndexScanDesc scan, ScanDirection dir)
 		scan->xs_ctup.t_self = *heaptid;
 #endif
 
-		/*
-		 * Typically, an index scan must maintain a pin on the index page
-		 * holding the item last returned by amgettuple. However, this is not
-		 * needed with the current vacuum strategy, which ensures scans do not
-		 * visit tuples in danger of being marked as deleted.
-		 *
-		 * https://www.postgresql.org/docs/current/index-locking.html
-		 */
-
 		scan->xs_recheckorderby = false;
 		return true;
 	}
@@ -223,9 +222,6 @@ hnswendscan(IndexScanDesc scan)
 {
 	HnswScanOpaque so = (HnswScanOpaque) scan->opaque;
 
-	/* Release shared lock */
-	UnlockPage(scan->indexRelation, HNSW_SCAN_LOCK, ShareLock);
-
 	MemoryContextDelete(so->tmpCtx);
 
 	pfree(so);

src/hnswutils.c

@@ -38,12 +38,12 @@ HnswGetEfConstruction(Relation index)
  * Get proc
  */
 FmgrInfo *
-HnswOptionalProcInfo(Relation rel, uint16 procnum)
+HnswOptionalProcInfo(Relation index, uint16 procnum)
 {
-	if (!OidIsValid(index_getprocid(rel, 1, procnum)))
+	if (!OidIsValid(index_getprocid(index, 1, procnum)))
 		return NULL;
 
-	return index_getprocinfo(rel, 1, procnum);
+	return index_getprocinfo(index, 1, procnum);
 }
 
 /*
@@ -117,7 +117,6 @@ HnswInitRegisterPage(Relation index, Buffer *buf, Page *page, GenericXLogState *
 void
 HnswCommitBuffer(Buffer buf, GenericXLogState *state)
 {
-	MarkBufferDirty(buf);
 	GenericXLogFinish(state);
 	UnlockReleaseBuffer(buf);
 }
@@ -140,9 +139,21 @@ HnswInitNeighbors(HnswElement element, int m)
 		a = &element->neighbors[lc];
 		a->length = 0;
 		a->items = palloc(sizeof(HnswCandidate) * lm);
+		a->closerSet = false;
 	}
 }
 
+/*
+ * Free neighbors
+ */
+static void
+HnswFreeNeighbors(HnswElement element)
+{
+	for (int lc = 0; lc <= element->level; lc++)
+		pfree(element->neighbors[lc].items);
+	pfree(element->neighbors);
+}
+
 /*
  * Allocate an element
  */
@@ -174,10 +185,8 @@ HnswInitElement(ItemPointer heaptid, int m, double ml, int maxLevel)
 void
 HnswFreeElement(HnswElement element)
 {
+	HnswFreeNeighbors(element);
 	list_free_deep(element->heaptids);
-	for (int lc = 0; lc <= element->level; lc++)
-		pfree(element->neighbors[lc].items);
-	pfree(element->neighbors);
 	pfree(element->vec);
 	pfree(element);
 }
@@ -684,6 +693,34 @@ HnswSearchLayer(Datum q, List *ep, int ef, int lc, Relation index, FmgrInfo *pro
 	return w;
 }
 
+/*
+ * Compare candidate distances
+ */
+static int
+#if PG_VERSION_NUM >= 130000
+CompareCandidateDistances(const ListCell *a, const ListCell *b)
+#else
+CompareCandidateDistances(const void *a, const void *b)
+#endif
+{
+	HnswCandidate *hca = lfirst((ListCell *) a);
+	HnswCandidate *hcb = lfirst((ListCell *) b);
+
+	if (hca->distance < hcb->distance)
+		return 1;
+
+	if (hca->distance > hcb->distance)
+		return -1;
+
+	if (hca->element < hcb->element)
+		return 1;
+
+	if (hca->element > hcb->element)
+		return -1;
+
+	return 0;
+}
+
 /*
  * Calculate the distance between elements
  */
@@ -740,33 +777,77 @@ CheckElementCloser(HnswCandidate * e, List *r, int lc, FmgrInfo *procinfo, Oid c
  * Algorithm 4 from paper
  */
 static List *
-SelectNeighbors(List *c, int m, int lc, FmgrInfo *procinfo, Oid collation, HnswCandidate * *pruned)
+SelectNeighbors(List *c, int m, int lc, FmgrInfo *procinfo, Oid collation, HnswElement e2, HnswCandidate * newCandidate, HnswCandidate * *pruned, bool sortCandidates)
 {
 	List	   *r = NIL;
 	List	   *w = list_copy(c);
 	pairingheap *wd;
+	bool		mustCalculate = !e2->neighbors[lc].closerSet;
+	List	   *added = NIL;
+	bool		removedAny = false;
 
 	if (list_length(w) <= m)
 		return w;
 
 	wd = pairingheap_allocate(CompareNearestCandidates, NULL);
 
+	/* Ensure order of candidates is deterministic for closer caching */
+	if (sortCandidates)
+		list_sort(w, CompareCandidateDistances);
+
 	while (list_length(w) > 0 && list_length(r) < m)
 	{
 		/* Assumes w is already ordered desc */
 		HnswCandidate *e = llast(w);
-		bool		closer;
 
 		w = list_delete_last(w);
 
-		closer = CheckElementCloser(e, r, lc, procinfo, collation);
+		/* Use previous state of r and wd to skip work when possible */
+		if (mustCalculate)
+			e->closer = CheckElementCloser(e, r, lc, procinfo, collation);
+		else if (list_length(added) > 0)
+		{
+			/*
+			 * If the current candidate was closer, we only need to compare it
+			 * with the other candidates that we have added.
+			 */
+			if (e->closer)
+			{
+				e->closer = CheckElementCloser(e, added, lc, procinfo, collation);
 
-		if (closer)
+				if (!e->closer)
+					removedAny = true;
+			}
+			else
+			{
+				/*
+				 * If we have removed any candidates from closer, a candidate
+				 * that was not closer earlier might now be.
+				 */
+				if (removedAny)
+				{
+					e->closer = CheckElementCloser(e, r, lc, procinfo, collation);
+					if (e->closer)
+						added = lappend(added, e);
+				}
+			}
+		}
+		else if (e == newCandidate)
+		{
+			e->closer = CheckElementCloser(e, r, lc, procinfo, collation);
+			if (e->closer)
+				added = lappend(added, e);
+		}
+
+		if (e->closer)
 			r = lappend(r, e);
 		else
 			pairingheap_add(wd, &(CreatePairingHeapNode(e)->ph_node));
 	}
 
+	/* Cached value can only be used in future if sorted deterministically */
+	e2->neighbors[lc].closerSet = sortCandidates;
+
 	/* Keep pruned connections */
 	while (!pairingheap_is_empty(wd) && list_length(r) < m)
 		r = lappend(r, ((HnswPairingHeapNode *) pairingheap_remove_first(wd))->inner);
@@ -820,28 +901,6 @@ AddConnections(HnswElement element, List *neighbors, int m, int lc)
 		a->items[a->length++] = *((HnswCandidate *) lfirst(lc2));
 }
 
-/*
- * Compare candidate distances
- */
-static int
-#if PG_VERSION_NUM >= 130000
-CompareCandidateDistances(const ListCell *a, const ListCell *b)
-#else
-CompareCandidateDistances(const void *a, const void *b)
-#endif
-{
-	HnswCandidate *hca = lfirst((ListCell *) a);
-	HnswCandidate *hcb = lfirst((ListCell *) b);
-
-	if (hca->distance < hcb->distance)
-		return 1;
-
-	if (hca->distance > hcb->distance)
-		return -1;
-
-	return 0;
-}
-
 /*
  * Update connections
  */
@@ -895,13 +954,12 @@ HnswUpdateConnection(HnswElement element, HnswCandidate * hc, int m, int lc, int
 		{
 			List	   *c = NIL;
 
-			/* Add and sort candidates */
+			/* Add candidates */
 			for (int i = 0; i < currentNeighbors->length; i++)
 				c = lappend(c, &currentNeighbors->items[i]);
 			c = lappend(c, &hc2);
-			list_sort(c, CompareCandidateDistances);
 
-			SelectNeighbors(c, m, lc, procinfo, collation, &pruned);
+			SelectNeighbors(c, m, lc, procinfo, collation, hc->element, &hc2, &pruned, true);
 
 			/* Should not happen */
 			if (pruned == NULL)
@@ -1000,7 +1058,12 @@ HnswInsertElement(HnswElement element, HnswElement entryPoint, Relation index, F
 		else
 			lw = w;
 
-		neighbors = SelectNeighbors(lw, lm, lc, procinfo, collation, NULL);
+		/*
+		 * Candidates are sorted, but not deterministically. Could set
+		 * sortCandidates to true for in-memory builds to enable closer
+		 * caching, but there does not seem to be a difference in performance.
+		 */
+		neighbors = SelectNeighbors(lw, lm, lc, procinfo, collation, element, NULL, NULL, false);
 
 		AddConnections(element, neighbors, lm, lc);
 

src/hnswvacuum.c

@@ -128,10 +128,7 @@ RemoveHeapTids(HnswVacuumState * vacuumstate)
 		blkno = HnswPageGetOpaque(page)->nextblkno;
 
 		if (updated)
-		{
-			MarkBufferDirty(buf);
 			GenericXLogFinish(state);
-		}
 		else
 			GenericXLogAbort(state);
 
@@ -229,7 +226,6 @@ RepairGraphElement(HnswVacuumState * vacuumstate, HnswElement element, HnswEleme
 		elog(ERROR, "failed to add index item to \"%s\"", RelationGetRelationName(index));
 
 	/* Commit */
-	MarkBufferDirty(buf);
 	GenericXLogFinish(state);
 	UnlockReleaseBuffer(buf);
 
@@ -547,9 +543,6 @@ MarkDeleted(HnswVacuumState * vacuumstate)
 				elog(ERROR, "failed to add index item to \"%s\"", RelationGetRelationName(index));
 
 			/* Commit */
-			MarkBufferDirty(buf);
-			if (nbuf != buf)
-				MarkBufferDirty(nbuf);
 			GenericXLogFinish(state);
 			if (nbuf != buf)
 				UnlockReleaseBuffer(nbuf);

src/ivfbuild.c

@@ -506,29 +506,30 @@ CreateListPages(Relation index, VectorArray centers, int dimensions,
 	Buffer		buf;
 	Page		page;
 	GenericXLogState *state;
-	OffsetNumber offno;
+	Size		listSize;
-	Size		itemsz;
 	IvfflatList list;
 
-	itemsz = MAXALIGN(IVFFLAT_LIST_SIZE(dimensions));
+	listSize = MAXALIGN(IVFFLAT_LIST_SIZE(dimensions));
-	list = palloc(itemsz);
+	list = palloc(listSize);
 
 	buf = IvfflatNewBuffer(index, forkNum);
 	IvfflatInitRegisterPage(index, &buf, &page, &state);
 
 	for (int i = 0; i < lists; i++)
 	{
+		OffsetNumber offno;
+
 		/* Load list */
 		list->startPage = InvalidBlockNumber;
 		list->insertPage = InvalidBlockNumber;
 		memcpy(&list->center, VectorArrayGet(centers, i), VECTOR_SIZE(dimensions));
 
 		/* Ensure free space */
-		if (PageGetFreeSpace(page) < itemsz)
+		if (PageGetFreeSpace(page) < listSize)
 			IvfflatAppendPage(index, &buf, &page, &state, forkNum);
 
 		/* Add the item */
-		offno = PageAddItem(page, (Item) list, itemsz, InvalidOffsetNumber, false, false);
+		offno = PageAddItem(page, (Item) list, listSize, InvalidOffsetNumber, false, false);
 		if (offno == InvalidOffsetNumber)
 			elog(ERROR, "failed to add index item to \"%s\"", RelationGetRelationName(index));
 

src/ivfflat.h

@@ -246,8 +246,6 @@ typedef struct IvfflatScanOpaqueData
 	int			probes;
 	int			dimensions;
 	bool		first;
-	Buffer		buf;
-	ItemPointerData heaptid;
 
 	/* Sorting */
 	Tuplesortstate *sortstate;
@@ -277,7 +275,7 @@ VectorArray VectorArrayInit(int maxlen, int dimensions);
 void		VectorArrayFree(VectorArray arr);
 void		PrintVectorArray(char *msg, VectorArray arr);
 void		IvfflatKmeans(Relation index, VectorArray samples, VectorArray centers);
-FmgrInfo   *IvfflatOptionalProcInfo(Relation rel, uint16 procnum);
+FmgrInfo   *IvfflatOptionalProcInfo(Relation index, uint16 procnum);
 bool		IvfflatNormValue(FmgrInfo *procinfo, Oid collation, Datum *value, Vector * result);
 int			IvfflatGetLists(Relation index);
 void		IvfflatGetMetaPageInfo(Relation index, int *lists, int *dimensions);

src/ivfinsert.c

@@ -11,36 +11,37 @@
  * Find the list that minimizes the distance function
  */
 static void
-FindInsertPage(Relation rel, Datum *values, BlockNumber *insertPage, ListInfo * listInfo)
+FindInsertPage(Relation index, Datum *values, BlockNumber *insertPage, ListInfo * listInfo)
 {
-	Buffer		cbuf;
-	Page		cpage;
-	IvfflatList list;
-	double		distance;
 	double		minDistance = DBL_MAX;
 	BlockNumber nextblkno = IVFFLAT_HEAD_BLKNO;
 	FmgrInfo   *procinfo;
 	Oid			collation;
-	OffsetNumber offno;
-	OffsetNumber maxoffno;
 
 	/* Avoid compiler warning */
 	listInfo->blkno = nextblkno;
 	listInfo->offno = FirstOffsetNumber;
 
-	procinfo = index_getprocinfo(rel, 1, IVFFLAT_DISTANCE_PROC);
+	procinfo = index_getprocinfo(index, 1, IVFFLAT_DISTANCE_PROC);
-	collation = rel->rd_indcollation[0];
+	collation = index->rd_indcollation[0];
 
 	/* Search all list pages */
 	while (BlockNumberIsValid(nextblkno))
 	{
-		cbuf = ReadBuffer(rel, nextblkno);
+		Buffer		cbuf;
+		Page		cpage;
+		OffsetNumber maxoffno;
+
+		cbuf = ReadBuffer(index, nextblkno);
 		LockBuffer(cbuf, BUFFER_LOCK_SHARE);
 		cpage = BufferGetPage(cbuf);
 		maxoffno = PageGetMaxOffsetNumber(cpage);
 
-		for (offno = FirstOffsetNumber; offno <= maxoffno; offno = OffsetNumberNext(offno))
+		for (OffsetNumber offno = FirstOffsetNumber; offno <= maxoffno; offno = OffsetNumberNext(offno))
 		{
+			IvfflatList list;
+			double		distance;
+
 			list = (IvfflatList) PageGetItem(cpage, PageGetItemId(cpage, offno));
 			distance = DatumGetFloat8(FunctionCall2Coll(procinfo, collation, values[0], PointerGetDatum(&list->center)));
 
@@ -63,7 +64,7 @@ FindInsertPage(Relation rel, Datum *values, BlockNumber *insertPage, ListInfo *
  * Insert a tuple into the index
  */
 static void
-InsertTuple(Relation rel, Datum *values, bool *isnull, ItemPointer heap_tid, Relation heapRel)
+InsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heap_tid, Relation heapRel)
 {
 	IndexTuple	itup;
 	Datum		value;
@@ -80,33 +81,33 @@ InsertTuple(Relation rel, Datum *values, bool *isnull, ItemPointer heap_tid, Rel
 	value = PointerGetDatum(PG_DETOAST_DATUM(values[0]));
 
 	/* Normalize if needed */
-	normprocinfo = IvfflatOptionalProcInfo(rel, IVFFLAT_NORM_PROC);
+	normprocinfo = IvfflatOptionalProcInfo(index, IVFFLAT_NORM_PROC);
 	if (normprocinfo != NULL)
 	{
-		if (!IvfflatNormValue(normprocinfo, rel->rd_indcollation[0], &value, NULL))
+		if (!IvfflatNormValue(normprocinfo, index->rd_indcollation[0], &value, NULL))
 			return;
 	}
 
 	/* Find the insert page - sets the page and list info */
-	FindInsertPage(rel, values, &insertPage, &listInfo);
+	FindInsertPage(index, values, &insertPage, &listInfo);
 	Assert(BlockNumberIsValid(insertPage));
 	originalInsertPage = insertPage;
 
 	/* Form tuple */
-	itup = index_form_tuple(RelationGetDescr(rel), &value, isnull);
+	itup = index_form_tuple(RelationGetDescr(index), &value, isnull);
 	itup->t_tid = *heap_tid;
 
 	/* Get tuple size */
 	itemsz = MAXALIGN(IndexTupleSize(itup));
-	Assert(itemsz <= BLCKSZ - MAXALIGN(SizeOfPageHeaderData) - MAXALIGN(sizeof(IvfflatPageOpaqueData)));
+	Assert(itemsz <= BLCKSZ - MAXALIGN(SizeOfPageHeaderData) - MAXALIGN(sizeof(IvfflatPageOpaqueData)) - sizeof(ItemIdData));
 
 	/* Find a page to insert the item */
 	for (;;)
 	{
-		buf = ReadBuffer(rel, insertPage);
+		buf = ReadBuffer(index, insertPage);
 		LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
 
-		state = GenericXLogStart(rel);
+		state = GenericXLogStart(index);
 		page = GenericXLogRegisterBuffer(state, buf, 0);
 
 		if (PageGetFreeSpace(page) >= itemsz)
@@ -126,9 +127,9 @@ InsertTuple(Relation rel, Datum *values, bool *isnull, ItemPointer heap_tid, Rel
 			Page		newpage;
 
 			/* Add a new page */
-			LockRelationForExtension(rel, ExclusiveLock);
+			LockRelationForExtension(index, ExclusiveLock);
-			newbuf = IvfflatNewBuffer(rel, MAIN_FORKNUM);
+			newbuf = IvfflatNewBuffer(index, MAIN_FORKNUM);
-			UnlockRelationForExtension(rel, ExclusiveLock);
+			UnlockRelationForExtension(index, ExclusiveLock);
 
 			/* Init new page */
 			newpage = GenericXLogRegisterBuffer(state, newbuf, GENERIC_XLOG_FULL_IMAGE);
@@ -141,15 +142,13 @@ InsertTuple(Relation rel, Datum *values, bool *isnull, ItemPointer heap_tid, Rel
 			IvfflatPageGetOpaque(page)->nextblkno = insertPage;
 
 			/* Commit */
-			MarkBufferDirty(newbuf);
-			MarkBufferDirty(buf);
 			GenericXLogFinish(state);
 
 			/* Unlock previous buffer */
 			UnlockReleaseBuffer(buf);
 
 			/* Prepare new buffer */
-			state = GenericXLogStart(rel);
+			state = GenericXLogStart(index);
 			buf = newbuf;
 			page = GenericXLogRegisterBuffer(state, buf, 0);
 			break;
@@ -158,13 +157,13 @@ InsertTuple(Relation rel, Datum *values, bool *isnull, ItemPointer heap_tid, Rel
 
 	/* Add to next offset */
 	if (PageAddItem(page, (Item) itup, itemsz, InvalidOffsetNumber, false, false) == InvalidOffsetNumber)
-		elog(ERROR, "failed to add index item to \"%s\"", RelationGetRelationName(rel));
+		elog(ERROR, "failed to add index item to \"%s\"", RelationGetRelationName(index));
 
 	IvfflatCommitBuffer(buf, state);
 
 	/* Update the insert page */
 	if (insertPage != originalInsertPage)
-		IvfflatUpdateList(rel, listInfo, insertPage, originalInsertPage, InvalidBlockNumber, MAIN_FORKNUM);
+		IvfflatUpdateList(index, listInfo, insertPage, originalInsertPage, InvalidBlockNumber, MAIN_FORKNUM);
 }
 
 /*

src/ivfkmeans.c

@@ -17,10 +17,6 @@ InitCenters(Relation index, VectorArray samples, VectorArray centers, float *low
 	FmgrInfo   *procinfo;
 	Oid			collation;
 	int64		j;
-	double		distance;
-	double		sum;
-	double		choice;
-	Vector	   *vec;
 	float	   *weight = palloc(samples->length * sizeof(float));
 	int			numCenters = centers->maxlen;
 	int			numSamples = samples->length;
@@ -33,17 +29,21 @@ InitCenters(Relation index, VectorArray samples, VectorArray centers, float *low
 	centers->length++;
 
 	for (j = 0; j < numSamples; j++)
-		weight[j] = DBL_MAX;
+		weight[j] = FLT_MAX;
 
 	for (int i = 0; i < numCenters; i++)
 	{
+		double		sum;
+		double		choice;
+
 		CHECK_FOR_INTERRUPTS();
 
 		sum = 0.0;
 
 		for (j = 0; j < numSamples; j++)
 		{
-			vec = VectorArrayGet(samples, j);
+			Vector	   *vec = VectorArrayGet(samples, j);
+			double		distance;
 
 			/* Only need to compute distance for new center */
 			/* TODO Use triangle inequality to reduce distance calculations */
@@ -112,7 +112,6 @@ CompareVectors(const void *a, const void *b)
 static void
 QuickCenters(Relation index, VectorArray samples, VectorArray centers)
 {
-	Vector	   *vec;
 	int			dimensions = centers->dim;
 	Oid			collation = index->rd_indcollation[0];
 	FmgrInfo   *normprocinfo = IvfflatOptionalProcInfo(index, IVFFLAT_KMEANS_NORM_PROC);
@@ -123,7 +122,7 @@ QuickCenters(Relation index, VectorArray samples, VectorArray centers)
 		qsort(samples->items, samples->length, VECTOR_SIZE(samples->dim), CompareVectors);
 		for (int i = 0; i < samples->length; i++)
 		{
-			vec = VectorArrayGet(samples, i);
+			Vector	   *vec = VectorArrayGet(samples, i);
 
 			if (i == 0 || CompareVectors(vec, VectorArrayGet(samples, i - 1)) != 0)
 			{
@@ -136,7 +135,7 @@ QuickCenters(Relation index, VectorArray samples, VectorArray centers)
 	/* Fill remaining with random data */
 	while (centers->length < centers->maxlen)
 	{
-		vec = VectorArrayGet(centers, centers->length);
+		Vector	   *vec = VectorArrayGet(centers, centers->length);
 
 		SET_VARSIZE(vec, VECTOR_SIZE(dimensions));
 		vec->dim = dimensions;
@@ -168,7 +167,6 @@ ElkanKmeans(Relation index, VectorArray samples, VectorArray centers)
 	Oid			collation;
 	Vector	   *vec;
 	Vector	   *newCenter;
-	int			iteration;
 	int64		j;
 	int64		k;
 	int			dimensions = centers->dim;
@@ -182,14 +180,6 @@ ElkanKmeans(Relation index, VectorArray samples, VectorArray centers)
 	float	   *s;
 	float	   *halfcdist;
 	float	   *newcdist;
-	int			changes;
-	double		minDistance;
-	int			closestCenter;
-	double		distance;
-	bool		rj;
-	bool		rjreset;
-	double		dxcx;
-	double		dxc;
 
 	/* Calculate allocation sizes */
 	Size		samplesSize = VECTOR_ARRAY_SIZE(samples->maxlen, samples->dim);
@@ -247,14 +237,14 @@ ElkanKmeans(Relation index, VectorArray samples, VectorArray centers)
 	/* Assign each x to its closest initial center c(x) = argmin d(x,c) */
 	for (j = 0; j < numSamples; j++)
 	{
-		minDistance = DBL_MAX;
+		float		minDistance = FLT_MAX;
-		closestCenter = 0;
+		int			closestCenter = 0;
 
 		/* Find closest center */
 		for (k = 0; k < numCenters; k++)
 		{
 			/* TODO Use Lemma 1 in k-means++ initialization */
-			distance = lowerBound[j * numCenters + k];
+			float		distance = lowerBound[j * numCenters + k];
 
 			if (distance < minDistance)
 			{
@@ -268,13 +258,14 @@ ElkanKmeans(Relation index, VectorArray samples, VectorArray centers)
 	}
 
 	/* Give 500 iterations to converge */
-	for (iteration = 0; iteration < 500; iteration++)
+	for (int iteration = 0; iteration < 500; iteration++)
 	{
+		int			changes = 0;
+		bool		rjreset;
+
 		/* Can take a while, so ensure we can interrupt */
 		CHECK_FOR_INTERRUPTS();
 
-		changes = 0;
-
 		/* Step 1: For all centers, compute distance */
 		for (j = 0; j < numCenters; j++)
 		{
@@ -282,7 +273,8 @@ ElkanKmeans(Relation index, VectorArray samples, VectorArray centers)
 
 			for (k = j + 1; k < numCenters; k++)
 			{
-				distance = 0.5 * DatumGetFloat8(FunctionCall2Coll(procinfo, collation, PointerGetDatum(vec), PointerGetDatum(VectorArrayGet(centers, k))));
+				float		distance = 0.5 * DatumGetFloat8(FunctionCall2Coll(procinfo, collation, PointerGetDatum(vec), PointerGetDatum(VectorArrayGet(centers, k))));
+
 				halfcdist[j * numCenters + k] = distance;
 				halfcdist[k * numCenters + j] = distance;
 			}
@@ -291,10 +283,12 @@ ElkanKmeans(Relation index, VectorArray samples, VectorArray centers)
 		/* For all centers c, compute s(c) */
 		for (j = 0; j < numCenters; j++)
 		{
-			minDistance = DBL_MAX;
+			float		minDistance = FLT_MAX;
 
 			for (k = 0; k < numCenters; k++)
 			{
+				float		distance;
+
 				if (j == k)
 					continue;
 
@@ -310,6 +304,8 @@ ElkanKmeans(Relation index, VectorArray samples, VectorArray centers)
 
 		for (j = 0; j < numSamples; j++)
 		{
+			bool		rj;
+
 			/* Step 2: Identify all points x such that u(x) <= s(c(x)) */
 			if (upperBound[j] <= s[closestCenters[j]])
 				continue;
@@ -318,6 +314,8 @@ ElkanKmeans(Relation index, VectorArray samples, VectorArray centers)
 
 			for (k = 0; k < numCenters; k++)
 			{
+				float		dxcx;
+
 				/* Step 3: For all remaining points x and centers c */
 				if (k == closestCenters[j])
 					continue;
@@ -347,7 +345,7 @@ ElkanKmeans(Relation index, VectorArray samples, VectorArray centers)
 				/* Step 3b */
 				if (dxcx > lowerBound[j * numCenters + k] || dxcx > halfcdist[closestCenters[j] * numCenters + k])
 				{
-					dxc = DatumGetFloat8(FunctionCall2Coll(procinfo, collation, PointerGetDatum(vec), PointerGetDatum(VectorArrayGet(centers, k))));
+					float		dxc = DatumGetFloat8(FunctionCall2Coll(procinfo, collation, PointerGetDatum(vec), PointerGetDatum(VectorArrayGet(centers, k))));
 
 					/* d(x,c) calculated */
 					lowerBound[j * numCenters + k] = dxc;
@@ -361,7 +359,6 @@ ElkanKmeans(Relation index, VectorArray samples, VectorArray centers)
 
 						changes++;
 					}
-
 				}
 			}
 		}
@@ -378,6 +375,8 @@ ElkanKmeans(Relation index, VectorArray samples, VectorArray centers)
 
 		for (j = 0; j < numSamples; j++)
 		{
+			int			closestCenter;
+
 			vec = VectorArrayGet(samples, j);
 			closestCenter = closestCenters[j];
 
@@ -426,7 +425,7 @@ ElkanKmeans(Relation index, VectorArray samples, VectorArray centers)
 		{
 			for (k = 0; k < numCenters; k++)
 			{
-				distance = lowerBound[j * numCenters + k] - newcdist[k];
+				float		distance = lowerBound[j * numCenters + k] - newcdist[k];
 
 				if (distance < 0)
 					distance = 0;
@@ -442,7 +441,7 @@ ElkanKmeans(Relation index, VectorArray samples, VectorArray centers)
 
 		/* Step 7 */
 		for (j = 0; j < numCenters; j++)
-			memcpy(VectorArrayGet(centers, j), VectorArrayGet(newCenters, j), VECTOR_SIZE(dimensions));
+			VectorArraySet(centers, j, VectorArrayGet(newCenters, j));
 
 		if (changes == 0 && iteration != 0)
 			break;
@@ -465,9 +464,6 @@ static void
 CheckCenters(Relation index, VectorArray centers)
 {
 	FmgrInfo   *normprocinfo;
-	Oid			collation;
-	Vector	   *vec;
-	double		norm;
 
 	if (centers->length != centers->maxlen)
 		elog(ERROR, "Not enough centers. Please report a bug.");
@@ -475,7 +471,7 @@ CheckCenters(Relation index, VectorArray centers)
 	/* Ensure no NaN or infinite values */
 	for (int i = 0; i < centers->length; i++)
 	{
-		vec = VectorArrayGet(centers, i);
+		Vector	   *vec = VectorArrayGet(centers, i);
 
 		for (int j = 0; j < vec->dim; j++)
 		{
@@ -501,11 +497,12 @@ CheckCenters(Relation index, VectorArray centers)
 	normprocinfo = IvfflatOptionalProcInfo(index, IVFFLAT_NORM_PROC);
 	if (normprocinfo != NULL)
 	{
-		collation = index->rd_indcollation[0];
+		Oid			collation = index->rd_indcollation[0];
 
 		for (int i = 0; i < centers->length; i++)
 		{
-			norm = DatumGetFloat8(FunctionCall1Coll(normprocinfo, collation, PointerGetDatum(VectorArrayGet(centers, i))));
+			double		norm = DatumGetFloat8(FunctionCall1Coll(normprocinfo, collation, PointerGetDatum(VectorArrayGet(centers, i))));
+
 			if (norm == 0)
 				elog(ERROR, "Zero norm detected. Please report a bug.");
 		}

src/ivfscan.c

@@ -143,10 +143,6 @@ GetScanItems(IndexScanDesc scan, Datum value)
 				bool		isnull;
 				ItemId		itemid = PageGetItemId(page, offno);
 
-				/* Skip dead tuples */
-				if (scan->ignore_killed_tuples && ItemIdIsDead(itemid))
-					continue;
-
 				itup = (IndexTuple) PageGetItem(page, itemid);
 				datum = index_getattr(itup, 1, tupdesc, &isnull);
 
@@ -161,8 +157,6 @@ GetScanItems(IndexScanDesc scan, Datum value)
 				slot->tts_isnull[0] = false;
 				slot->tts_values[1] = PointerGetDatum(&itup->t_tid);
 				slot->tts_isnull[1] = false;
-				slot->tts_values[2] = Int32GetDatum((int) searchPage);
-				slot->tts_isnull[2] = false;
 				ExecStoreVirtualTuple(slot);
 
 				tuplesort_puttupleslot(so->sortstate, slot);
@@ -187,55 +181,6 @@ GetScanItems(IndexScanDesc scan, Datum value)
 	tuplesort_performsort(so->sortstate);
 }
 
-/*
- * Mark prior tuple as dead
- */
-static void
-MarkPriorTupleDead(IndexScanDesc scan)
-{
-	IvfflatScanOpaque so = (IvfflatScanOpaque) scan->opaque;
-	Buffer		buf = so->buf;
-	Page		page;
-	OffsetNumber maxoffno;
-
-	/* Safety check */
-	if (!BufferIsValid(so->buf) || !ItemPointerIsValid(&so->heaptid))
-		return;
-
-	/* Only a shared locked is needed for ItemIdMarkDead */
-	LockBuffer(buf, BUFFER_LOCK_SHARE);
-	page = BufferGetPage(buf);
-	maxoffno = PageGetMaxOffsetNumber(page);
-
-	for (OffsetNumber offno = FirstOffsetNumber; offno <= maxoffno; offno = OffsetNumberNext(offno))
-	{
-		ItemId		itemid = PageGetItemId(page, offno);
-		IndexTuple	itup = (IndexTuple) PageGetItem(page, itemid);
-
-		/*
-		 * Find tuple. Since buffer has been pinned, tuple cannot have been
-		 * vacuumed (and heap TID reused).
-		 */
-		if (ItemPointerEquals(&itup->t_tid, &so->heaptid))
-		{
-			/*
-			 * Make sure tuple has not already been marked dead to avoid extra
-			 * WAL if wal_log_hints or data checksums enabled
-			 */
-			if (!ItemIdIsDead(itemid))
-			{
-				ItemIdMarkDead(itemid);
-				MarkBufferDirtyHint(buf, true);
-			}
-
-			break;
-		}
-	}
-
-	/* Unlock buffer */
-	LockBuffer(buf, BUFFER_LOCK_UNLOCK);
-}
-
 /*
  * Prepare for an index scan
  */
@@ -261,9 +206,7 @@ ivfflatbeginscan(Relation index, int nkeys, int norderbys)
 		probes = lists;
 
 	so = (IvfflatScanOpaque) palloc(offsetof(IvfflatScanOpaqueData, lists) + probes * sizeof(IvfflatScanList));
-	so->buf = InvalidBuffer;
 	so->first = true;
-	ItemPointerSetInvalid(&so->heaptid);
 	so->probes = probes;
 	so->dimensions = dimensions;
 
@@ -274,13 +217,12 @@ ivfflatbeginscan(Relation index, int nkeys, int norderbys)
 
 	/* Create tuple description for sorting */
 #if PG_VERSION_NUM >= 120000
-	so->tupdesc = CreateTemplateTupleDesc(3);
+	so->tupdesc = CreateTemplateTupleDesc(2);
 #else
-	so->tupdesc = CreateTemplateTupleDesc(3, false);
+	so->tupdesc = CreateTemplateTupleDesc(2, false);
 #endif
 	TupleDescInitEntry(so->tupdesc, (AttrNumber) 1, "distance", FLOAT8OID, -1, 0);
 	TupleDescInitEntry(so->tupdesc, (AttrNumber) 2, "heaptid", TIDOID, -1, 0);
-	TupleDescInitEntry(so->tupdesc, (AttrNumber) 3, "indexblkno", INT4OID, -1, 0);
 
 	/* Prep sort */
 	so->sortstate = tuplesort_begin_heap(so->tupdesc, 1, attNums, sortOperators, sortCollations, nullsFirstFlags, work_mem, NULL, false);
@@ -312,7 +254,6 @@ ivfflatrescan(IndexScanDesc scan, ScanKey keys, int nkeys, ScanKey orderbys, int
 #endif
 
 	so->first = true;
-	ItemPointerSetInvalid(&so->heaptid);
 	pairingheap_reset(so->listQueue);
 
 	if (keys && scan->numberOfKeys > 0)
@@ -347,6 +288,11 @@ ivfflatgettuple(IndexScanDesc scan, ScanDirection dir)
 		if (scan->orderByData == NULL)
 			elog(ERROR, "cannot scan ivfflat index without order");
 
+		/* Requires MVCC-compliant snapshot as not able to pin during sorting */
+		/* https://www.postgresql.org/docs/current/index-locking.html */
+		if (!IsMVCCSnapshot(scan->xs_snapshot))
+			elog(ERROR, "non-MVCC snapshots are not supported with ivfflat");
+
 		if (scan->orderByData->sk_flags & SK_ISNULL)
 			value = PointerGetDatum(InitVector(so->dimensions));
 		else
@@ -370,17 +316,10 @@ ivfflatgettuple(IndexScanDesc scan, ScanDirection dir)
 		if (value != scan->orderByData->sk_argument)
 			pfree(DatumGetPointer(value));
 	}
-	else
-	{
-		/* Mark prior tuple as dead */
-		if (scan->kill_prior_tuple)
-			MarkPriorTupleDead(scan);
-	}
 
 	if (tuplesort_gettupleslot(so->sortstate, true, false, so->slot, NULL))
 	{
 		ItemPointer heaptid = (ItemPointer) DatumGetPointer(slot_getattr(so->slot, 2, &so->isnull));
-		BlockNumber indexblkno = DatumGetInt32(slot_getattr(so->slot, 3, &so->isnull));
 
 #if PG_VERSION_NUM >= 120000
 		scan->xs_heaptid = *heaptid;
@@ -388,21 +327,6 @@ ivfflatgettuple(IndexScanDesc scan, ScanDirection dir)
 		scan->xs_ctup.t_self = *heaptid;
 #endif
 
-		/* Keep track of info needed to mark tuple as dead */
-		so->heaptid = *heaptid;
-
-		/* Unpin buffer */
-		if (BufferIsValid(so->buf))
-			ReleaseBuffer(so->buf);
-
-		/*
-		 * An index scan must maintain a pin on the index page holding the
-		 * item last returned by amgettuple
-		 *
-		 * https://www.postgresql.org/docs/current/index-locking.html
-		 */
-		so->buf = ReadBuffer(scan->indexRelation, indexblkno);
-
 		scan->xs_recheckorderby = false;
 		return true;
 	}
@@ -418,10 +342,6 @@ ivfflatendscan(IndexScanDesc scan)
 {
 	IvfflatScanOpaque so = (IvfflatScanOpaque) scan->opaque;
 
-	/* Release pin */
-	if (BufferIsValid(so->buf))
-		ReleaseBuffer(so->buf);
-
 	pairingheap_free(so->listQueue);
 	tuplesort_end(so->sortstate);
 

src/ivfutils.c

@@ -57,12 +57,12 @@ IvfflatGetLists(Relation index)
  * Get proc
  */
 FmgrInfo *
-IvfflatOptionalProcInfo(Relation rel, uint16 procnum)
+IvfflatOptionalProcInfo(Relation index, uint16 procnum)
 {
-	if (!OidIsValid(index_getprocid(rel, 1, procnum)))
+	if (!OidIsValid(index_getprocid(index, 1, procnum)))
 		return NULL;
 
-	return index_getprocinfo(rel, 1, procnum);
+	return index_getprocinfo(index, 1, procnum);
 }
 
 /*
@@ -136,7 +136,6 @@ IvfflatInitRegisterPage(Relation index, Buffer *buf, Page *page, GenericXLogStat
 void
 IvfflatCommitBuffer(Buffer buf, GenericXLogState *state)
 {
-	MarkBufferDirty(buf);
 	GenericXLogFinish(state);
 	UnlockReleaseBuffer(buf);
 }
@@ -160,8 +159,6 @@ IvfflatAppendPage(Relation index, Buffer *buf, Page *page, GenericXLogState **st
 	IvfflatInitPage(newbuf, newpage);
 
 	/* Commit */
-	MarkBufferDirty(*buf);
-	MarkBufferDirty(newbuf);
 	GenericXLogFinish(*state);
 
 	/* Unlock */

src/ivfvacuum.c

@@ -107,7 +107,6 @@ ivfflatbulkdelete(IndexVacuumInfo *info, IndexBulkDeleteResult *stats,
 				{
 					/* Delete tuples */
 					PageIndexMultiDelete(page, deletable, ndeletable);
-					MarkBufferDirty(buf);
 					GenericXLogFinish(state);
 				}
 				else

src/svector.c

@@ -0,0 +1,705 @@
+#include "postgres.h"
+
+#include <math.h>
+
+#include "fmgr.h"
+#include "libpq/pqformat.h"
+#include "svector.h"
+#include "utils/array.h"
+#include "vector.h"
+
+#if PG_VERSION_NUM >= 120000
+#include "common/shortest_dec.h"
+#include "utils/float.h"
+#else
+#include <float.h>
+#include "utils/builtins.h"
+#endif
+
+/*
+ * Ensure same dimensions
+ */
+static inline void
+CheckDims(SVector * a, SVector * b)
+{
+	if (a->dim != b->dim)
+		ereport(ERROR,
+				(errcode(ERRCODE_DATA_EXCEPTION),
+				 errmsg("different svector dimensions %d and %d", a->dim, b->dim)));
+}
+
+/*
+ * Ensure expected dimensions
+ */
+static inline void
+CheckExpectedDim(int32 typmod, int dim)
+{
+	if (typmod != -1 && typmod != dim)
+		ereport(ERROR,
+				(errcode(ERRCODE_DATA_EXCEPTION),
+				 errmsg("expected %d dimensions, not %d", typmod, dim)));
+}
+
+/*
+ * Ensure valid dimensions
+ */
+static inline void
+CheckDim(int dim)
+{
+	if (dim < 1)
+		ereport(ERROR,
+				(errcode(ERRCODE_DATA_EXCEPTION),
+				 errmsg("svector must have at least 1 dimension")));
+
+	if (dim > SVECTOR_MAX_DIM)
+		ereport(ERROR,
+				(errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
+				 errmsg("svector cannot have more than %d dimensions", SVECTOR_MAX_DIM)));
+}
+
+/*
+ * Ensure valid nnz
+ */
+static inline void
+CheckNnz(int nnz, int dim)
+{
+	if (nnz < 0)
+		ereport(ERROR,
+				(errcode(ERRCODE_DATA_EXCEPTION),
+				 errmsg("svector must have at least one element")));
+
+	if (nnz > dim)
+		ereport(ERROR,
+				(errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
+				 errmsg("svector cannot have more elements than dimensions")));
+}
+
+/*
+ * Ensure valid index
+ */
+static inline void
+CheckIndex(int32 *indices, int i, int dim)
+{
+	int32		index = indices[i];
+
+	if (index < 0)
+		ereport(ERROR,
+				(errcode(ERRCODE_DATA_EXCEPTION),
+				 errmsg("index must not be negative")));
+
+	if (index >= dim)
+		ereport(ERROR,
+				(errcode(ERRCODE_DATA_EXCEPTION),
+				 errmsg("index must be less than dimensions")));
+
+	if (i > 0)
+	{
+		if (index < indices[i - 1])
+			ereport(ERROR,
+					(errcode(ERRCODE_DATA_EXCEPTION),
+					 errmsg("indexes must be in ascending order")));
+
+		if (index == indices[i - 1])
+			ereport(ERROR,
+					(errcode(ERRCODE_DATA_EXCEPTION),
+					 errmsg("indexes must not contain duplicates")));
+	}
+}
+
+/*
+ * Ensure finite element
+ */
+static inline void
+CheckElement(float value)
+{
+	if (isnan(value))
+		ereport(ERROR,
+				(errcode(ERRCODE_DATA_EXCEPTION),
+				 errmsg("NaN not allowed in svector")));
+
+	if (isinf(value))
+		ereport(ERROR,
+				(errcode(ERRCODE_DATA_EXCEPTION),
+				 errmsg("infinite value not allowed in svector")));
+}
+
+/*
+ * Allocate and initialize a new sparse vector
+ */
+SVector *
+InitSVector(int dim, int nnz)
+{
+	SVector    *result;
+	int			size;
+
+	size = SVECTOR_SIZE(nnz);
+	result = (SVector *) palloc0(size);
+	SET_VARSIZE(result, size);
+	result->dim = dim;
+	result->nnz = nnz;
+
+	return result;
+}
+
+/*
+ * Convert textual representation to internal representation
+ */
+PGDLLEXPORT PG_FUNCTION_INFO_V1(svector_in);
+Datum
+svector_in(PG_FUNCTION_ARGS)
+{
+	char	   *str = PG_GETARG_CSTRING(0);
+	int32		typmod = PG_GETARG_INT32(2);
+	int			dim;
+	char	   *pt;
+	SVector    *result;
+	float	   *rvalues;
+	char	   *lit = pstrdup(str);
+	int			n;
+	int32	   *indices;
+	float	   *values;
+	int			index;
+	float		value;
+	int			maxNnz;
+	int			nnz = 0;
+
+	/* TODO Improve code and checks after deciding on format */
+
+	maxNnz = 1;
+	pt = str;
+	while (*pt != '\0')
+	{
+		if (*pt == ',')
+			maxNnz++;
+
+		pt++;
+	}
+	maxNnz /= 2;
+
+	indices = palloc(maxNnz * sizeof(int32));
+	values = palloc(maxNnz * sizeof(float));
+
+	while (sscanf(str, "(%d,%f)%n", &index, &value, &n) == 2)
+	{
+		/* TODO Better error */
+		if (nnz == maxNnz)
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
+					 errmsg("ran out of buffer: \"%s\"", lit)));
+
+		/* TODO Decide whether to store zero values */
+		indices[nnz] = index;
+		values[nnz] = value;
+		nnz++;
+
+		str += n;
+
+		if (*str == ',')
+			str++;
+		else if (*str == '|')
+			break;
+		else
+			ereport(ERROR,
+					(errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
+					 errmsg("malformed svector literal: \"%s\"", lit)));
+	}
+
+	if (sscanf(str, "|%d|%n", &dim, &n) != 1)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
+				 errmsg("malformed svector literal: \"%s\"", lit)));
+
+	str += n;
+
+	if (*str != '\0')
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
+				 errmsg("malformed svector literal: \"%s\"", lit),
+				 errdetail("Junk after closing pipe.")));
+
+	pfree(lit);
+
+	CheckDim(dim);
+	CheckExpectedDim(typmod, dim);
+
+	result = InitSVector(dim, nnz);
+	rvalues = SVECTOR_VALUES(result);
+	for (int i = 0; i < nnz; i++)
+	{
+		result->indices[i] = indices[i];
+		rvalues[i] = values[i];
+
+		CheckIndex(result->indices, i, dim);
+		CheckElement(rvalues[i]);
+	}
+
+	PG_RETURN_POINTER(result);
+}
+
+/*
+ * Convert internal representation to textual representation
+ */
+PGDLLEXPORT PG_FUNCTION_INFO_V1(svector_out);
+Datum
+svector_out(PG_FUNCTION_ARGS)
+{
+	SVector    *svector = PG_GETARG_SVECTOR_P(0);
+	float	   *values = SVECTOR_VALUES(svector);
+	char	   *buf;
+	char	   *ptr;
+	int			n;
+
+	/* TODO Improve code after deciding on format */
+
+#if PG_VERSION_NUM < 120000
+	int			ndig = FLT_DIG + extra_float_digits;
+
+	if (ndig < 1)
+		ndig = 1;
+
+#define FLOAT_SHORTEST_DECIMAL_LEN (ndig + 10)
+#endif
+
+	/* TODO Move */
+#define APPEND_CHAR(ptr, ch) (*(ptr)++ = (ch))
+
+	/* TODO Improve */
+	buf = (char *) palloc((FLOAT_SHORTEST_DECIMAL_LEN + 20) * svector->nnz + 20);
+	ptr = buf;
+
+	for (int i = 0; i < svector->nnz; i++)
+	{
+		if (i > 0)
+			APPEND_CHAR(ptr, ',');
+
+		n = sprintf(ptr, "(%d,", svector->indices[i]);
+		ptr += n;
+
+#if PG_VERSION_NUM >= 120000
+		n = float_to_shortest_decimal_bufn(values[i], ptr);
+#else
+		n = sprintf(ptr, "%.*g", ndig, values[i]);
+#endif
+		ptr += n;
+
+		APPEND_CHAR(ptr, ')');
+	}
+
+	n = sprintf(ptr, "|%d|", svector->dim);
+	ptr += n;
+
+	APPEND_CHAR(ptr, '\0');
+
+	PG_FREE_IF_COPY(svector, 0);
+	PG_RETURN_CSTRING(buf);
+}
+
+/*
+ * Convert type modifier
+ */
+PGDLLEXPORT PG_FUNCTION_INFO_V1(svector_typmod_in);
+Datum
+svector_typmod_in(PG_FUNCTION_ARGS)
+{
+	ArrayType  *ta = PG_GETARG_ARRAYTYPE_P(0);
+	int32	   *tl;
+	int			n;
+
+	tl = ArrayGetIntegerTypmods(ta, &n);
+
+	if (n != 1)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("invalid type modifier")));
+
+	if (*tl < 1)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("dimensions for type svector must be at least 1")));
+
+	if (*tl > SVECTOR_MAX_DIM)
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("dimensions for type svector cannot exceed %d", SVECTOR_MAX_DIM)));
+
+	PG_RETURN_INT32(*tl);
+}
+
+/*
+ * Convert external binary representation to internal representation
+ */
+PGDLLEXPORT PG_FUNCTION_INFO_V1(svector_recv);
+Datum
+svector_recv(PG_FUNCTION_ARGS)
+{
+	StringInfo	buf = (StringInfo) PG_GETARG_POINTER(0);
+	int32		typmod = PG_GETARG_INT32(2);
+	SVector    *result;
+	int32		dim;
+	int32		nnz;
+	int32		unused;
+	float	   *values;
+
+	dim = pq_getmsgint(buf, sizeof(int32));
+	nnz = pq_getmsgint(buf, sizeof(int32));
+	unused = pq_getmsgint(buf, sizeof(int32));
+
+	CheckDim(dim);
+	CheckNnz(nnz, dim);
+	CheckExpectedDim(typmod, dim);
+
+	if (unused != 0)
+		ereport(ERROR,
+				(errcode(ERRCODE_DATA_EXCEPTION),
+				 errmsg("expected unused to be 0, not %d", unused)));
+
+	result = InitSVector(dim, nnz);
+	values = SVECTOR_VALUES(result);
+
+	for (int i = 0; i < nnz; i++)
+	{
+		result->indices[i] = pq_getmsgint(buf, sizeof(int32));
+		CheckIndex(result->indices, i, dim);
+	}
+
+	for (int i = 0; i < nnz; i++)
+	{
+		values[i] = pq_getmsgfloat4(buf);
+		CheckElement(values[i]);
+	}
+
+	PG_RETURN_POINTER(result);
+}
+
+/*
+ * Convert internal representation to the external binary representation
+ */
+PGDLLEXPORT PG_FUNCTION_INFO_V1(svector_send);
+Datum
+svector_send(PG_FUNCTION_ARGS)
+{
+	SVector    *svec = PG_GETARG_SVECTOR_P(0);
+	float	   *values = SVECTOR_VALUES(svec);
+	StringInfoData buf;
+
+	pq_begintypsend(&buf);
+	pq_sendint(&buf, svec->dim, sizeof(int32));
+	pq_sendint(&buf, svec->nnz, sizeof(int32));
+	pq_sendint(&buf, svec->unused, sizeof(int32));
+	for (int i = 0; i < svec->nnz; i++)
+		pq_sendint(&buf, svec->indices[i], sizeof(int32));
+	for (int i = 0; i < svec->nnz; i++)
+		pq_sendfloat4(&buf, values[i]);
+
+	PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
+}
+
+/*
+ * Convert sparse vector to sparse vector
+ * This is needed to check the type modifier
+ */
+PGDLLEXPORT PG_FUNCTION_INFO_V1(svector);
+Datum
+svector(PG_FUNCTION_ARGS)
+{
+	SVector    *svec = PG_GETARG_SVECTOR_P(0);
+	int32		typmod = PG_GETARG_INT32(1);
+
+	CheckExpectedDim(typmod, svec->dim);
+
+	PG_RETURN_POINTER(svec);
+}
+
+/*
+ * Convert dense vector to sparse vector
+ */
+PGDLLEXPORT PG_FUNCTION_INFO_V1(vector_to_svector);
+Datum
+vector_to_svector(PG_FUNCTION_ARGS)
+{
+	Vector	   *vec = PG_GETARG_VECTOR_P(0);
+	int32		typmod = PG_GETARG_INT32(1);
+	SVector    *result;
+	int			dim = vec->dim;
+	int			nnz = 0;
+	float	   *values;
+	int			j = 0;
+
+	CheckDim(dim);
+	CheckExpectedDim(typmod, dim);
+
+	for (int i = 0; i < dim; i++)
+	{
+		if (vec->x[i] != 0)
+			nnz++;
+	}
+
+	result = InitSVector(dim, nnz);
+	values = SVECTOR_VALUES(result);
+	for (int i = 0; i < dim; i++)
+	{
+		if (vec->x[i] != 0)
+		{
+			/* Safety check */
+			if (j == nnz)
+				elog(ERROR, "safety check failed");
+
+			result->indices[j] = i;
+			values[j] = vec->x[i];
+			j++;
+		}
+	}
+
+	PG_RETURN_POINTER(result);
+}
+
+/*
+ *  Get the L2 squared distance between sparse vectors
+ */
+static double
+l2_distance_squared_internal(SVector * a, SVector * b)
+{
+	float	   *ax = SVECTOR_VALUES(a);
+	float	   *bx = SVECTOR_VALUES(b);
+	double		distance = 0.0;
+	int			bpos = 0;
+
+	for (int i = 0; i < a->nnz; i++)
+	{
+		int			ai = a->indices[i];
+		int			bi = -1;
+
+		for (int j = bpos; j < b->nnz; j++)
+		{
+			bi = b->indices[j];
+
+			if (ai == bi)
+			{
+				double		diff = ax[i] - bx[j];
+
+				distance += diff * diff;
+			}
+			else if (ai > bi)
+				distance += bx[j] * bx[j];
+
+			/* Update start for next iteration */
+			if (ai >= bi)
+				bpos = j + 1;
+
+			/* Found or passed it */
+			if (bi >= ai)
+				break;
+		}
+
+		if (ai != bi)
+			distance += ax[i] * ax[i];
+	}
+
+	for (int j = bpos; j < b->nnz; j++)
+		distance += bx[j] * bx[j];
+
+	return distance;
+}
+
+/*
+ * Get the L2 distance between sparse vectors
+ */
+PGDLLEXPORT PG_FUNCTION_INFO_V1(svector_l2_distance);
+Datum
+svector_l2_distance(PG_FUNCTION_ARGS)
+{
+	SVector    *a = PG_GETARG_SVECTOR_P(0);
+	SVector    *b = PG_GETARG_SVECTOR_P(1);
+
+	CheckDims(a, b);
+
+	PG_RETURN_FLOAT8(sqrt(l2_distance_squared_internal(a, b)));
+}
+
+/*
+ * Get the L2 squared distance between sparse vectors
+ * This saves a sqrt calculation
+ */
+PGDLLEXPORT PG_FUNCTION_INFO_V1(svector_l2_squared_distance);
+Datum
+svector_l2_squared_distance(PG_FUNCTION_ARGS)
+{
+	SVector    *a = PG_GETARG_SVECTOR_P(0);
+	SVector    *b = PG_GETARG_SVECTOR_P(1);
+
+	CheckDims(a, b);
+
+	PG_RETURN_FLOAT8(l2_distance_squared_internal(a, b));
+}
+
+/*
+ * Get the inner product of two sparse vectors
+ */
+static double
+inner_product_internal(SVector * a, SVector * b)
+{
+	float	   *ax = SVECTOR_VALUES(a);
+	float	   *bx = SVECTOR_VALUES(b);
+	double		distance = 0.0;
+	int			bpos = 0;
+
+	for (int i = 0; i < a->nnz; i++)
+	{
+		int			ai = a->indices[i];
+
+		for (int j = bpos; j < b->nnz; j++)
+		{
+			int			bi = b->indices[j];
+
+			/* Only update when the same index */
+			if (ai == bi)
+				distance += ax[i] * bx[j];
+
+			/* Update start for next iteration */
+			if (ai >= bi)
+				bpos = j + 1;
+
+			/* Found or passed it */
+			if (bi >= ai)
+				break;
+		}
+	}
+
+	return distance;
+}
+
+/*
+ * Get the inner product of two sparse vectors
+ */
+PGDLLEXPORT PG_FUNCTION_INFO_V1(svector_inner_product);
+Datum
+svector_inner_product(PG_FUNCTION_ARGS)
+{
+	SVector    *a = PG_GETARG_SVECTOR_P(0);
+	SVector    *b = PG_GETARG_SVECTOR_P(1);
+
+	CheckDims(a, b);
+
+	PG_RETURN_FLOAT8(inner_product_internal(a, b));
+}
+
+/*
+ * Get the negative inner product of two sparse vectors
+ */
+PGDLLEXPORT PG_FUNCTION_INFO_V1(svector_negative_inner_product);
+Datum
+svector_negative_inner_product(PG_FUNCTION_ARGS)
+{
+	SVector    *a = PG_GETARG_SVECTOR_P(0);
+	SVector    *b = PG_GETARG_SVECTOR_P(1);
+
+	CheckDims(a, b);
+
+	PG_RETURN_FLOAT8(-inner_product_internal(a, b));
+}
+
+/*
+ * Get the cosine distance between two sparse vectors
+ */
+PGDLLEXPORT PG_FUNCTION_INFO_V1(svector_cosine_distance);
+Datum
+svector_cosine_distance(PG_FUNCTION_ARGS)
+{
+	SVector    *a = PG_GETARG_SVECTOR_P(0);
+	SVector    *b = PG_GETARG_SVECTOR_P(1);
+	float	   *ax = SVECTOR_VALUES(a);
+	float	   *bx = SVECTOR_VALUES(b);
+	float		norma = 0.0;
+	float		normb = 0.0;
+	double		similarity;
+
+	CheckDims(a, b);
+
+	similarity = inner_product_internal(a, b);
+
+	/* Auto-vectorized */
+	for (int i = 0; i < a->nnz; i++)
+		norma += ax[i] * ax[i];
+
+	/* Auto-vectorized */
+	for (int i = 0; i < b->nnz; i++)
+		normb += bx[i] * bx[i];
+
+	/* Use sqrt(a * b) over sqrt(a) * sqrt(b) */
+	similarity /= sqrt((double) norma * (double) normb);
+
+#ifdef _MSC_VER
+	/* /fp:fast may not propagate NaN */
+	if (isnan(similarity))
+		PG_RETURN_FLOAT8(NAN);
+#endif
+
+	/* Keep in range */
+	if (similarity > 1)
+		similarity = 1.0;
+	else if (similarity < -1)
+		similarity = -1.0;
+
+	PG_RETURN_FLOAT8(1.0 - similarity);
+}
+
+/*
+ * Get the weighted Jaccard distance between two sparse vectors
+ */
+PGDLLEXPORT PG_FUNCTION_INFO_V1(svector_jaccard_distance);
+Datum
+svector_jaccard_distance(PG_FUNCTION_ARGS)
+{
+	SVector    *a = PG_GETARG_SVECTOR_P(0);
+	SVector    *b = PG_GETARG_SVECTOR_P(1);
+	float	   *ax = SVECTOR_VALUES(a);
+	float	   *bx = SVECTOR_VALUES(b);
+	double		num = 0.0;
+	double		denom = 0.0;
+	int			bpos = 0;
+
+	CheckDims(a, b);
+
+	/*
+	 * Weighted Jaccard distance is not defined for vectors with negative
+	 * values. Could check and return NaN if minimal impact on performance.
+	 */
+
+	for (int i = 0; i < a->nnz; i++)
+	{
+		int			ai = a->indices[i];
+		int			bi = -1;
+
+		for (int j = bpos; j < b->nnz; j++)
+		{
+			bi = b->indices[j];
+
+			if (ai == bi)
+			{
+				num += ax[i] < bx[j] ? ax[i] : bx[j];
+				denom += ax[i] > bx[j] ? ax[i] : bx[j];
+			}
+			else if (ai > bi)
+				denom += bx[j];
+
+			/* Update start for next iteration */
+			if (ai >= bi)
+				bpos = j + 1;
+
+			/* Found or passed it */
+			if (bi >= ai)
+				break;
+		}
+
+		if (ai != bi)
+			denom += ax[i];
+	}
+
+	for (int j = bpos; j < b->nnz; j++)
+		denom += bx[j];
+
+	if (denom > 0)
+		PG_RETURN_FLOAT8(1.0 - (num / denom));
+	else
+		PG_RETURN_FLOAT8(NAN);
+}

src/svector.h

@@ -0,0 +1,23 @@
+#ifndef SVECTOR_H
+#define SVECTOR_H
+
+#define SVECTOR_MAX_DIM 100000
+
+#define SVECTOR_SIZE(_nnz)		(offsetof(SVector, indices) + (_nnz) * sizeof(int32) + (_nnz * sizeof(float)))
+#define SVECTOR_VALUES(x)		((float *) (((char *) (x)) + offsetof(SVector, indices) + (x)->nnz * sizeof(int32)))
+#define DatumGetSVector(x)		((SVector *) PG_DETOAST_DATUM(x))
+#define PG_GETARG_SVECTOR_P(x)	DatumGetSVector(PG_GETARG_DATUM(x))
+#define PG_RETURN_SVECTOR_P(x)	PG_RETURN_POINTER(x)
+
+typedef struct SVector
+{
+	int32		vl_len_;		/* varlena header (do not touch directly!) */
+	int32		dim;			/* number of dimensions */
+	int32		nnz;
+	int32		unused;
+	int32		indices[FLEXIBLE_ARRAY_MEMBER];
+}			SVector;
+
+SVector    *InitSVector(int dim, int nnz);
+
+#endif

src/vector.c

@@ -9,6 +9,7 @@
 #include "lib/stringinfo.h"
 #include "libpq/pqformat.h"
 #include "port.h"				/* for strtof() */
+#include "svector.h"
 #include "utils/array.h"
 #include "utils/builtins.h"
 #include "utils/lsyscache.h"
@@ -89,7 +90,7 @@ CheckDim(int dim)
 }
 
 /*
- * Ensure finite elements
+ * Ensure finite element
  */
 static inline void
 CheckElement(float value)
@@ -437,17 +438,18 @@ vector_send(PG_FUNCTION_ARGS)
 
 /*
  * Convert vector to vector
+ * This is needed to check the type modifier
  */
 PGDLLEXPORT PG_FUNCTION_INFO_V1(vector);
 Datum
 vector(PG_FUNCTION_ARGS)
 {
-	Vector	   *arg = PG_GETARG_VECTOR_P(0);
+	Vector	   *vec = PG_GETARG_VECTOR_P(0);
 	int32		typmod = PG_GETARG_INT32(1);
 
-	CheckExpectedDim(typmod, arg->dim);
+	CheckExpectedDim(typmod, vec->dim);
 
-	PG_RETURN_POINTER(arg);
+	PG_RETURN_POINTER(vec);
 }
 
 /*
@@ -464,7 +466,6 @@ array_to_vector(PG_FUNCTION_ARGS)
 	bool		typbyval;
 	char		typalign;
 	Datum	   *elemsp;
-	bool	   *nullsp;
 	int			nelemsp;
 
 	if (ARR_NDIM(array) > 1)
@@ -478,7 +479,7 @@ array_to_vector(PG_FUNCTION_ARGS)
 				 errmsg("array must not contain nulls")));
 
 	get_typlenbyvalalign(ARR_ELEMTYPE(array), &typlen, &typbyval, &typalign);
-	deconstruct_array(array, ARR_ELEMTYPE(array), typlen, typbyval, typalign, &elemsp, &nullsp, &nelemsp);
+	deconstruct_array(array, ARR_ELEMTYPE(array), typlen, typbyval, typalign, &elemsp, NULL, &nelemsp);
 
 	CheckDim(nelemsp);
 	CheckExpectedDim(typmod, nelemsp);
@@ -512,6 +513,12 @@ array_to_vector(PG_FUNCTION_ARGS)
 				 errmsg("unsupported array type")));
 	}
 
+	/*
+	 * Free allocation from deconstruct_array. Do not free individual elements
+	 * when pass-by-reference since they point to original array.
+	 */
+	pfree(elemsp);
+
 	/* Check elements */
 	for (int i = 0; i < result->dim; i++)
 		CheckElement(result->x[i]);
@@ -1145,3 +1152,26 @@ vector_avg(PG_FUNCTION_ARGS)
 
 	PG_RETURN_POINTER(result);
 }
+
+/*
+ * Convert sparse vector to dense vector
+ */
+PGDLLEXPORT PG_FUNCTION_INFO_V1(svector_to_vector);
+Datum
+svector_to_vector(PG_FUNCTION_ARGS)
+{
+	SVector    *svec = PG_GETARG_SVECTOR_P(0);
+	int32		typmod = PG_GETARG_INT32(1);
+	Vector	   *result;
+	int			dim = svec->dim;
+	float	   *values = SVECTOR_VALUES(svec);
+
+	CheckDim(dim);
+	CheckExpectedDim(typmod, dim);
+
+	result = InitVector(dim);
+	for (int i = 0; i < svec->nnz; i++)
+		result->x[svec->indices[i]] = values[i];
+
+	PG_RETURN_POINTER(result);
+}

test/expected/functions.out

@@ -54,85 +54,85 @@ SELECT vector_norm('[3e37,4e37]')::real;
        5e+37
 (1 row)
 
-SELECT l2_distance('[0,0]', '[3,4]');
+SELECT l2_distance('[0,0]'::vector, '[3,4]');
  l2_distance 
 -------------
            5
 (1 row)
 
-SELECT l2_distance('[0,0]', '[0,1]');
+SELECT l2_distance('[0,0]'::vector, '[0,1]');
  l2_distance 
 -------------
            1
 (1 row)
 
-SELECT l2_distance('[1,2]', '[3]');
+SELECT l2_distance('[1,2]'::vector, '[3]');
 ERROR:  different vector dimensions 2 and 1
-SELECT l2_distance('[3e38]', '[-3e38]');
+SELECT l2_distance('[3e38]'::vector, '[-3e38]');
  l2_distance 
 -------------
     Infinity
 (1 row)
 
-SELECT inner_product('[1,2]', '[3,4]');
+SELECT inner_product('[1,2]'::vector, '[3,4]');
  inner_product 
 ---------------
             11
 (1 row)
 
-SELECT inner_product('[1,2]', '[3]');
+SELECT inner_product('[1,2]'::vector, '[3]');
 ERROR:  different vector dimensions 2 and 1
-SELECT inner_product('[3e38]', '[3e38]');
+SELECT inner_product('[3e38]'::vector, '[3e38]');
  inner_product 
 ---------------
       Infinity
 (1 row)
 
-SELECT cosine_distance('[1,2]', '[2,4]');
+SELECT cosine_distance('[1,2]'::vector, '[2,4]');
  cosine_distance 
 -----------------
                0
 (1 row)
 
-SELECT cosine_distance('[1,2]', '[0,0]');
+SELECT cosine_distance('[1,2]'::vector, '[0,0]');
  cosine_distance 
 -----------------
              NaN
 (1 row)
 
-SELECT cosine_distance('[1,1]', '[1,1]');
+SELECT cosine_distance('[1,1]'::vector, '[1,1]');
  cosine_distance 
 -----------------
                0
 (1 row)
 
-SELECT cosine_distance('[1,0]', '[0,2]');
+SELECT cosine_distance('[1,0]'::vector, '[0,2]');
  cosine_distance 
 -----------------
                1
 (1 row)
 
-SELECT cosine_distance('[1,1]', '[-1,-1]');
+SELECT cosine_distance('[1,1]'::vector, '[-1,-1]');
  cosine_distance 
 -----------------
                2
 (1 row)
 
-SELECT cosine_distance('[1,2]', '[3]');
+SELECT cosine_distance('[1,2]'::vector, '[3]');
 ERROR:  different vector dimensions 2 and 1
-SELECT cosine_distance('[1,1]', '[1.1,1.1]');
+SELECT cosine_distance('[1,1]'::vector, '[1.1,1.1]');
  cosine_distance 
 -----------------
                0
 (1 row)
 
-SELECT cosine_distance('[1,1]', '[-1.1,-1.1]');
+SELECT cosine_distance('[1,1]'::vector, '[-1.1,-1.1]');
  cosine_distance 
 -----------------
                2
 (1 row)
 
-SELECT cosine_distance('[3e38]', '[3e38]');
+SELECT cosine_distance('[3e38]'::vector, '[3e38]');
  cosine_distance 
 -----------------
              NaN

test/expected/svector.out

@@ -0,0 +1,140 @@
+SELECT '(0,1.5),(2,3.5)|5|'::svector;
+      svector       
+--------------------
+ (0,1.5),(2,3.5)|5|
+(1 row)
+
+SELECT '(0,1.5),(2,3.5)|5|'::svector::vector;
+     vector      
+-----------------
+ [1.5,0,3.5,0,0]
+(1 row)
+
+SELECT '(0,1.5),(2,3.5)|5|'::svector::vector(5);
+     vector      
+-----------------
+ [1.5,0,3.5,0,0]
+(1 row)
+
+SELECT '(0,1.5),(2,3.5)|5|'::svector::vector(4);
+ERROR:  expected 4 dimensions, not 5
+SELECT '[0,1.5,0,3.5,0]'::vector::svector;
+      svector       
+--------------------
+ (1,1.5),(3,3.5)|5|
+(1 row)
+
+SELECT '(0,0),(1,1),(2,0)|3|'::svector;
+       svector        
+----------------------
+ (0,0),(1,1),(2,0)|3|
+(1 row)
+
+SELECT '|5|'::svector;
+ svector 
+---------
+ |5|
+(1 row)
+
+SELECT '|-1|'::svector;
+ERROR:  svector must have at least 1 dimension
+LINE 1: SELECT '|-1|'::svector;
+               ^
+SELECT '|100001|'::svector;
+ERROR:  svector cannot have more than 100000 dimensions
+LINE 1: SELECT '|100001|'::svector;
+               ^
+SELECT '|16001|'::svector::vector;
+ERROR:  vector cannot have more than 16000 dimensions
+SELECT '(-1,1)|1|'::svector;
+ERROR:  index must not be negative
+LINE 1: SELECT '(-1,1)|1|'::svector;
+               ^
+SELECT '(1,1)|1|'::svector;
+ERROR:  index must be less than dimensions
+LINE 1: SELECT '(1,1)|1|'::svector;
+               ^
+SELECT '|1|'::svector(2);
+ERROR:  expected 2 dimensions, not 1
+SELECT l2_distance('|2|'::svector, '(0,3),(1,4)|2|');
+ l2_distance 
+-------------
+           5
+(1 row)
+
+SELECT l2_distance('|2|'::svector, '(1,1)|2|');
+ l2_distance 
+-------------
+           1
+(1 row)
+
+SELECT '|2|'::svector <-> '(0,3),(1,4)|2|';
+ ?column? 
+----------
+        5
+(1 row)
+
+SELECT inner_product('(0,1),(1,2)|2|'::svector, '(0,2),(1,4)|2|');
+ inner_product 
+---------------
+            10
+(1 row)
+
+SELECT svector_negative_inner_product('(0,1),(1,2)|2|', '(0,2),(1,4)|2|');
+ svector_negative_inner_product 
+--------------------------------
+                            -10
+(1 row)
+
+SELECT cosine_distance('(0,1),(1,2)|2|'::svector, '(0,2),(1,4)|2|');
+ cosine_distance 
+-----------------
+               0
+(1 row)
+
+SELECT cosine_distance('(0,1),(1,2)|2|'::svector, '|2|');
+ cosine_distance 
+-----------------
+             NaN
+(1 row)
+
+SELECT cosine_distance('(0,1),(1,1)|2|'::svector, '(0,-1),(1,-1)|2|');
+ cosine_distance 
+-----------------
+               2
+(1 row)
+
+SELECT cosine_distance('(0,1)|2|'::svector, '(1,2)|2|');
+ cosine_distance 
+-----------------
+               1
+(1 row)
+
+SELECT cosine_distance('|1|'::svector, '|1|');
+ cosine_distance 
+-----------------
+             NaN
+(1 row)
+
+SELECT cosine_distance('(0,1)|2|'::svector, '(0,1)|3|');
+ERROR:  different svector dimensions 2 and 3
+SELECT jaccard_distance('(0,1)|2|', '(0,1)|2|');
+ jaccard_distance 
+------------------
+                0
+(1 row)
+
+SELECT jaccard_distance('(0,1)|2|', '(1,1)|2|');
+ jaccard_distance 
+------------------
+                1
+(1 row)
+
+SELECT jaccard_distance('|1|', '|1|');
+ jaccard_distance 
+------------------
+              NaN
+(1 row)
+
+SELECT jaccard_distance('(0,1)|2|', '(0,1)|3|');
+ERROR:  different svector dimensions 2 and 3

test/sql/functions.sql

@@ -13,24 +13,24 @@ SELECT vector_norm('[3,4]');
 SELECT vector_norm('[0,1]');
 SELECT vector_norm('[3e37,4e37]')::real;
 
-SELECT l2_distance('[0,0]', '[3,4]');
+SELECT l2_distance('[0,0]'::vector, '[3,4]');
-SELECT l2_distance('[0,0]', '[0,1]');
+SELECT l2_distance('[0,0]'::vector, '[0,1]');
-SELECT l2_distance('[1,2]', '[3]');
+SELECT l2_distance('[1,2]'::vector, '[3]');
-SELECT l2_distance('[3e38]', '[-3e38]');
+SELECT l2_distance('[3e38]'::vector, '[-3e38]');
 
-SELECT inner_product('[1,2]', '[3,4]');
+SELECT inner_product('[1,2]'::vector, '[3,4]');
-SELECT inner_product('[1,2]', '[3]');
+SELECT inner_product('[1,2]'::vector, '[3]');
-SELECT inner_product('[3e38]', '[3e38]');
+SELECT inner_product('[3e38]'::vector, '[3e38]');
 
-SELECT cosine_distance('[1,2]', '[2,4]');
+SELECT cosine_distance('[1,2]'::vector, '[2,4]');
-SELECT cosine_distance('[1,2]', '[0,0]');
+SELECT cosine_distance('[1,2]'::vector, '[0,0]');
-SELECT cosine_distance('[1,1]', '[1,1]');
+SELECT cosine_distance('[1,1]'::vector, '[1,1]');
-SELECT cosine_distance('[1,0]', '[0,2]');
+SELECT cosine_distance('[1,0]'::vector, '[0,2]');
-SELECT cosine_distance('[1,1]', '[-1,-1]');
+SELECT cosine_distance('[1,1]'::vector, '[-1,-1]');
-SELECT cosine_distance('[1,2]', '[3]');
+SELECT cosine_distance('[1,2]'::vector, '[3]');
-SELECT cosine_distance('[1,1]', '[1.1,1.1]');
+SELECT cosine_distance('[1,1]'::vector, '[1.1,1.1]');
-SELECT cosine_distance('[1,1]', '[-1.1,-1.1]');
+SELECT cosine_distance('[1,1]'::vector, '[-1.1,-1.1]');
-SELECT cosine_distance('[3e38]', '[3e38]');
+SELECT cosine_distance('[3e38]'::vector, '[3e38]');
 
 SELECT l1_distance('[0,0]', '[3,4]');
 SELECT l1_distance('[0,0]', '[0,1]');

test/sql/svector.sql

@@ -0,0 +1,36 @@
+SELECT '(0,1.5),(2,3.5)|5|'::svector;
+SELECT '(0,1.5),(2,3.5)|5|'::svector::vector;
+SELECT '(0,1.5),(2,3.5)|5|'::svector::vector(5);
+SELECT '(0,1.5),(2,3.5)|5|'::svector::vector(4);
+SELECT '[0,1.5,0,3.5,0]'::vector::svector;
+
+SELECT '(0,0),(1,1),(2,0)|3|'::svector;
+
+SELECT '|5|'::svector;
+SELECT '|-1|'::svector;
+SELECT '|100001|'::svector;
+SELECT '|16001|'::svector::vector;
+
+SELECT '(-1,1)|1|'::svector;
+SELECT '(1,1)|1|'::svector;
+
+SELECT '|1|'::svector(2);
+
+SELECT l2_distance('|2|'::svector, '(0,3),(1,4)|2|');
+SELECT l2_distance('|2|'::svector, '(1,1)|2|');
+SELECT '|2|'::svector <-> '(0,3),(1,4)|2|';
+
+SELECT inner_product('(0,1),(1,2)|2|'::svector, '(0,2),(1,4)|2|');
+SELECT svector_negative_inner_product('(0,1),(1,2)|2|', '(0,2),(1,4)|2|');
+
+SELECT cosine_distance('(0,1),(1,2)|2|'::svector, '(0,2),(1,4)|2|');
+SELECT cosine_distance('(0,1),(1,2)|2|'::svector, '|2|');
+SELECT cosine_distance('(0,1),(1,1)|2|'::svector, '(0,-1),(1,-1)|2|');
+SELECT cosine_distance('(0,1)|2|'::svector, '(1,2)|2|');
+SELECT cosine_distance('|1|'::svector, '|1|');
+SELECT cosine_distance('(0,1)|2|'::svector, '(0,1)|3|');
+
+SELECT jaccard_distance('(0,1)|2|', '(0,1)|2|');
+SELECT jaccard_distance('(0,1)|2|', '(1,1)|2|');
+SELECT jaccard_distance('|1|', '|1|');
+SELECT jaccard_distance('(0,1)|2|', '(0,1)|3|');

vector.control

@@ -1,4 +1,4 @@
 comment = 'vector data type and ivfflat and hnsw access methods'
-default_version = '0.5.0'
+default_version = '0.5.1'
 module_pathname = '$libdir/vector'
 relocatable = true