Version bump to 0.3.1 [skip ci]

This reverts commit 94eeb83abe.

.dockerignore

@@ -0,0 +1,8 @@
+/.git/
+/dist/
+/results/
+/tmp_check/
+/sql/vector--?.?.?.sql
+regression.*
+*.o
+*.so

.editorconfig

@@ -1,6 +1,6 @@
 root = true
 
-[*.{c,h}]
+[*.{c,h,pl,pm}]
 indent_style = tab
 indent_size = tab
 tab_width = 4

.github/workflows/build.yml

@@ -2,25 +2,37 @@ name: build
 on: [push, pull_request]
 jobs:
   build:
-    if: "!contains(github.event.head_commit.message, '[skip ci]')"
-    runs-on: ubuntu-latest
+    runs-on: ${{ matrix.os }}
     strategy:
       fail-fast: false
       matrix:
-        postgres: [13, 12, 11, 10, 9.6]
+        os: [ubuntu-latest]
+        postgres: [15, 14, 13, 12, 11, 10]
+        include:
+        - os: macos-latest
+          postgres: 14
     steps:
-    - uses: actions/checkout@v2
-    - run: |
-        sudo sh -c 'echo "deb http://apt.postgresql.org/pub/repos/apt $(lsb_release -cs)-pgdg main" > /etc/apt/sources.list.d/pgdg.list'
-        wget --quiet -O - https://www.postgresql.org/media/keys/ACCC4CF8.asc | sudo apt-key add -
-        sudo apt-get update
+    - uses: actions/checkout@v3
     - uses: ankane/setup-postgres@v1
       with:
         postgres-version: ${{ matrix.postgres }}
-    - run: sudo apt-get install postgresql-server-dev-${{ matrix.postgres }} libipc-run-perl
+    - if: ${{ startsWith(matrix.os, 'ubuntu') }}
+      run: sudo apt-get update && sudo apt-get install postgresql-server-dev-${{ matrix.postgres }} libipc-run-perl
     - run: make
-    - run: |
+    - if: ${{ startsWith(matrix.os, 'ubuntu') }}
+      run: |
         export PG_CONFIG=`which pg_config`
         sudo --preserve-env=PG_CONFIG make install
+    - if: ${{ startsWith(matrix.os, 'macos') }}
+      run: make install
     - run: make installcheck
-    - run: make prove_installcheck
+    - if: ${{ failure() }}
+      run: cat regression.diffs
+    - if: ${{ startsWith(matrix.os, 'ubuntu') }}
+      run: make prove_installcheck
+    - if: ${{ startsWith(matrix.os, 'macos') }}
+      run: |
+        brew install cpanm && cpanm IPC::Run
+        wget -q https://github.com/postgres/postgres/archive/refs/tags/REL_14_5.tar.gz
+        tar xf REL_14_5.tar.gz
+        make prove_installcheck PROVE=prove PROVE_FLAGS="-I ./postgres-REL_14_5/src/test/perl" PERL5LIB="/Users/runner/perl5/lib/perl5"

.gitignore

@@ -1,5 +1,8 @@
-results
-tmp_check
+/dist/
+/results/
+/tmp_check/
+/sql/vector--?.?.?.sql
 regression.*
 *.o
 *.so
+*.bc

CHANGELOG.md

@@ -1,3 +1,87 @@
+## 0.3.1 (2022-11-02)
+
+If upgrading from 0.2.7 or 0.3.0, [recreate](https://github.com/pgvector/pgvector#031) all `ivfflat` indexes after upgrading to ensure all data is indexed.
+
+- Fixed issue with inserts silently corrupting `ivfflat` indexes (introduced in 0.2.7)
+- Fixed segmentation fault with index creation when lists > 6500
+
+## 0.3.0 (2022-10-15)
+
+- Added support for Postgres 15
+- Dropped support for Postgres 9.6
+
+## 0.2.7 (2022-07-31)
+
+- Fixed `unexpected data beyond EOF` error
+
+## 0.2.6 (2022-05-22)
+
+- Improved performance of index creation for Postgres < 12
+
+## 0.2.5 (2022-02-11)
+
+- Reduced memory usage during index creation
+- Fixed index creation exceeding `maintenance_work_mem`
+- Fixed error with index creation when lists > 1600
+
+## 0.2.4 (2022-02-06)
+
+- Added support for parallel vacuum
+- Fixed issue with index not reusing space
+
+## 0.2.3 (2022-01-30)
+
+- Added indexing progress for Postgres 12+
+- Improved interrupt handling during index creation
+
+## 0.2.2 (2022-01-15)
+
+- Fixed compilation error on Mac ARM
+
+## 0.2.1 (2022-01-02)
+
+- Fixed `operator is not unique` error
+
+## 0.2.0 (2021-10-03)
+
+- Added support for Postgres 14
+
+## 0.1.8 (2021-09-07)
+
+- Added cast for `vector` to `real[]`
+
+## 0.1.7 (2021-06-13)
+
+- Added cast for `numeric[]` to `vector`
+
+## 0.1.6 (2021-06-09)
+
+- Fixed segmentation fault with `COUNT`
+
+## 0.1.5 (2021-05-25)
+
+- Reduced memory usage during index creation
+
+## 0.1.4 (2021-05-09)
+
+- Fixed kmeans for inner product
+- Fixed multiple definition error with GCC 10
+
+## 0.1.3 (2021-05-06)
+
+- Added Dockerfile
+- Fixed version
+
+## 0.1.2 (2021-04-26)
+
+- Vectorized distance calculations
+- Improved cost estimation
+
+## 0.1.1 (2021-04-25)
+
+- Added binary representation for `COPY`
+- Marked functions as `PARALLEL SAFE`
+
 ## 0.1.0 (2021-04-20)
 
 - First release

Dockerfile

@@ -0,0 +1,16 @@
+FROM postgres:15
+
+COPY . /tmp/pgvector
+
+RUN apt-get update && \
+		apt-get install -y --no-install-recommends build-essential postgresql-server-dev-15 && \
+		cd /tmp/pgvector && \
+		make clean && \
+		make OPTFLAGS="" && \
+		make install && \
+		mkdir /usr/share/doc/pgvector && \
+		cp LICENSE README.md /usr/share/doc/pgvector && \
+		rm -r /tmp/pgvector && \
+		apt-get remove -y build-essential postgresql-server-dev-15 && \
+		apt-get autoremove -y && \
+		rm -rf /var/lib/apt/lists/*

META.json

@@ -0,0 +1,49 @@
+{
+	"name": "vector",
+	"abstract": "Open-source vector similarity search for Postgres",
+	"description": "Supports L2 distance, inner product, and cosine distance",
+	"version": "0.3.1",
+	"maintainer": [
+		"Andrew Kane <andrew@ankane.org>"
+	],
+	"license": {
+		"PostgreSQL": "http://www.postgresql.org/about/licence"
+	},
+	"prereqs": {
+		"runtime": {
+			"requires": {
+				"PostgreSQL": "10.0.0"
+			}
+		}
+	},
+	"provides": {
+		"vector": {
+			"file": "sql/vector.sql",
+			"docfile": "README.md",
+			"version": "0.3.1",
+			"abstract": "Open-source vector similarity search for Postgres"
+		}
+	},
+	"resources": {
+		"homepage": "https://github.com/pgvector/pgvector",
+		"bugtracker": {
+			"web": "https://github.com/pgvector/pgvector/issues"
+		},
+		"repository": {
+			"url":  "https://github.com/pgvector/pgvector.git",
+			"web":  "https://github.com/pgvector/pgvector",
+			"type": "git"
+		}
+	},
+	"generated_by": "Andrew Kane",
+	"meta-spec": {
+		"version": "1.0.0",
+		"url": "http://pgxn.org/meta/spec.txt"
+	},
+	"tags": [
+		"vectors",
+		"datatype",
+		"nearest neighbor search",
+		"approximate nearest neighbors"
+	]
+}

Makefile

@@ -1,16 +1,59 @@
 EXTENSION = vector
-DATA = vector--0.1.0.sql
+EXTVERSION = 0.3.1
+
 MODULE_big = vector
+DATA = $(wildcard sql/*--*.sql)
 OBJS = src/ivfbuild.o src/ivfflat.o src/ivfinsert.o src/ivfkmeans.o src/ivfscan.o src/ivfutils.o src/ivfvacuum.o src/vector.o
 
-TESTS = $(wildcard sql/*.sql)
+TESTS = $(wildcard test/sql/*.sql)
+REGRESS = $(patsubst test/sql/%.sql,%,$(TESTS))
+REGRESS_OPTS = --inputdir=test
 
-REGRESS = btree cast functions ivfflat_cosine ivfflat_ip ivfflat_l2 ivfflat_unlogged vector
+OPTFLAGS = -march=native
+
+# Mac ARM doesn't support -march=native
+ifeq ($(shell uname -s), Darwin)
+	ifeq ($(shell uname -p), arm)
+		OPTFLAGS =
+	endif
+endif
+
+# For auto-vectorization:
+# - GCC (needs -ftree-vectorize OR -O3) - https://gcc.gnu.org/projects/tree-ssa/vectorization.html
+# - Clang (could use pragma instead) - https://llvm.org/docs/Vectorizers.html
+PG_CFLAGS += $(OPTFLAGS) -ftree-vectorize -fassociative-math -fno-signed-zeros -fno-trapping-math
+
+# Debug GCC auto-vectorization
+# PG_CFLAGS += -fopt-info-vec
+
+# Debug Clang auto-vectorization
+# PG_CFLAGS += -Rpass=loop-vectorize -Rpass-analysis=loop-vectorize
+
+all: sql/$(EXTENSION)--$(EXTVERSION).sql
+
+sql/$(EXTENSION)--$(EXTVERSION).sql: sql/$(EXTENSION).sql
+	cp $< $@
+
+EXTRA_CLEAN = sql/$(EXTENSION)--$(EXTVERSION).sql
 
 PG_CONFIG ?= pg_config
 PGXS := $(shell $(PG_CONFIG) --pgxs)
 include $(PGXS)
 
+# for Postgres 15
+PROVE_FLAGS += -I ./test/perl
+
 prove_installcheck:
 	rm -rf $(CURDIR)/tmp_check
-	cd $(srcdir) && TESTDIR='$(CURDIR)' PATH="$(bindir):$$PATH" PGPORT='6$(DEF_PGPORT)' PG_REGRESS='$(top_builddir)/src/test/regress/pg_regress' $(PROVE) $(PG_PROVE_FLAGS) $(PROVE_FLAGS) $(if $(PROVE_TESTS),$(PROVE_TESTS),t/*.pl)
+	cd $(srcdir) && TESTDIR='$(CURDIR)' PATH="$(bindir):$$PATH" PGPORT='6$(DEF_PGPORT)' PG_REGRESS='$(top_builddir)/src/test/regress/pg_regress' $(PROVE) $(PG_PROVE_FLAGS) $(PROVE_FLAGS) $(if $(PROVE_TESTS),$(PROVE_TESTS),test/t/*.pl)
+
+.PHONY: dist
+
+dist:
+	mkdir -p dist
+	git archive --format zip --prefix=$(EXTENSION)-$(EXTVERSION)/ --output dist/$(EXTENSION)-$(EXTVERSION).zip master
+
+.PHONY: docker
+
+docker:
+	docker build --pull --no-cache -t ankane/pgvector:latest .

README.md

@@ -3,21 +3,21 @@
 Open-source vector similarity search for Postgres
 
 ```sql
-CREATE TABLE table (column vector(3));
-CREATE INDEX ON table USING ivfflat (column);
-SELECT * FROM table ORDER BY column <-> '[1,2,3]' LIMIT 5;
+CREATE TABLE items (embedding vector(3));
+CREATE INDEX ON items USING ivfflat (embedding vector_l2_ops);
+SELECT * FROM items ORDER BY embedding <-> '[1,2,3]' LIMIT 5;
 ```
 
 Supports L2 distance, inner product, and cosine distance
 
-[![Build Status](https://github.com/ankane/pgvector/workflows/build/badge.svg?branch=master)](https://github.com/ankane/pgvector/actions)
+[![Build Status](https://github.com/pgvector/pgvector/workflows/build/badge.svg?branch=master)](https://github.com/pgvector/pgvector/actions)
 
 ## Installation
 
-Compile and install the extension (supports Postgres 9.6+)
+Compile and install the extension (supports Postgres 10+)
 
 ```sh
-git clone https://github.com/ankane/pgvector.git
+git clone --branch v0.3.1 https://github.com/pgvector/pgvector.git
 cd pgvector
 make
 make install # may need sudo
@@ -29,24 +29,26 @@ Then load it in databases where you want to use it
 CREATE EXTENSION vector;
 ```
 
+You can also install it with [Docker](#docker), [Homebrew](#homebrew), or [PGXN](#pgxn)
+
 ## Getting Started
 
-Create a vector column with 3 dimensions (replace `table` and `column` with non-reserved names)
+Create a vector column with 3 dimensions
 
 ```sql
-CREATE TABLE table (column vector(3));
+CREATE TABLE items (embedding vector(3));
 ```
 
 Insert values
 
 ```sql
-INSERT INTO table VALUES ('[1,2,3]'), ('[4,5,6]');
+INSERT INTO items VALUES ('[1,2,3]'), ('[4,5,6]');
 ```
 
 Get the nearest neighbor by L2 distance
 
 ```sql
-SELECT * FROM table ORDER BY column <-> '[3,1,2]' LIMIT 1;
+SELECT * FROM items ORDER BY embedding <-> '[3,1,2]' LIMIT 1;
 ```
 
 Also supports inner product (`<#>`) and cosine distance (`<=>`)
@@ -60,31 +62,33 @@ Speed up queries with an approximate index. Add an index for each distance funct
 L2 distance
 
 ```sql
-CREATE INDEX ON table USING ivfflat (column);
+CREATE INDEX ON items USING ivfflat (embedding vector_l2_ops);
 ```
 
 Inner product
 
 ```sql
-CREATE INDEX ON table USING ivfflat (column vector_ip_ops);
+CREATE INDEX ON items USING ivfflat (embedding vector_ip_ops);
 ```
 
 Cosine distance
 
 ```sql
-CREATE INDEX ON table USING ivfflat (column vector_cosine_ops);
+CREATE INDEX ON items USING ivfflat (embedding vector_cosine_ops);
 ```
 
-Indexes should be created after the table has data for optimal clustering. Also, unlike typical indexes which only affect performance, you may see different results for queries after adding an approximate index.
+Indexes should be created after the table has some data for optimal clustering. Also, unlike typical indexes which only affect performance, you may see different results for queries after adding an approximate index.
 
 ### Index Options
 
 Specify the number of inverted lists (100 by default)
 
 ```sql
-CREATE INDEX ON table USING ivfflat (column) WITH (lists = 100);
+CREATE INDEX ON items USING ivfflat (embedding vector_l2_ops) WITH (lists = 100);
 ```
 
+A [good place to start](https://github.com/facebookresearch/faiss/issues/112) is `4 * sqrt(rows)`
+
 ### Query Options
 
 Specify the number of probes (1 by default)
@@ -104,6 +108,58 @@ 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, tuples_done, tuples_total FROM pg_stat_progress_create_index;
+```
+
+The phases are:
+
+1. `initializing`
+2. `sampling table`
+3. `performing k-means`
+4. `sorting tuples`
+5. `loading tuples`
+
+Note: `tuples_done` and `tuples_total` are only populated during the `loading tuples` phase
+
+### Partial Indexes
+
+Consider [partial indexes](https://www.postgresql.org/docs/current/indexes-partial.html) for queries with a `WHERE` clause
+
+```sql
+SELECT * FROM items WHERE category_id = 123 ORDER BY embedding <-> '[3,1,2]' LIMIT 5;
+```
+
+can be indexed with:
+
+```sql
+CREATE INDEX ON items USING ivfflat (embedding vector_l2_ops) WHERE (category_id = 123);
+```
+
+To index many different values of `category_id`, consider [partitioning](https://www.postgresql.org/docs/current/ddl-partitioning.html) on `category_id`.
+
+```sql
+CREATE TABLE items (embedding vector(3), category_id int) PARTITION BY LIST(category_id);
+```
+
+## Performance
+
+To speed up queries without an index, increase `max_parallel_workers_per_gather`.
+
+```sql
+SET max_parallel_workers_per_gather = 4;
+```
+
+To speed up queries with an index, increase the number of inverted lists (at the expense of recall).
+
+```sql
+CREATE INDEX ON items USING ivfflat (embedding vector_l2_ops) WITH (lists = 1000);
+```
+
 ## Reference
 
 ### Vector Type
@@ -130,6 +186,106 @@ l2_distance(vector, vector) | Euclidean distance
 vector_dims(vector) | number of dimensions
 vector_norm(vector) | Euclidean norm
 
+## Libraries
+
+Libraries that use pgvector:
+
+- [pgvector-python](https://github.com/pgvector/pgvector-python) (Python)
+- [Neighbor](https://github.com/ankane/neighbor) (Ruby)
+- [pgvector-ruby](https://github.com/pgvector/pgvector-ruby) (Ruby)
+- [pgvector-node](https://github.com/pgvector/pgvector-node) (Node.js)
+- [pgvector-go](https://github.com/pgvector/pgvector-go) (Go)
+- [pgvector-php](https://github.com/pgvector/pgvector-php) (PHP)
+- [pgvector-rust](https://github.com/pgvector/pgvector-rust) (Rust)
+- [pgvector-cpp](https://github.com/pgvector/pgvector-cpp) (C++)
+- [pgvector-elixir](https://github.com/pgvector/pgvector-elixir) (Elixir)
+
+## Frequently Asked Questions
+
+#### How many vectors can be stored in a single table?
+
+A non-partitioned table has a limit of 32 TB by default in Postgres. A partitioned table can have thousands of partitions of that size.
+
+#### Is replication supported?
+
+Yes, pgvector uses the write-ahead log (WAL), which allows for replication and point-in-time recovery.
+
+#### What if my data has more than 1024 dimensions?
+
+Two things you can try are:
+
+1. use dimensionality reduction
+2. compile Postgres with a larger block size (`./configure --with-blocksize=32`) and edit the limit in `src/vector.h`
+
+## Additional Installation Methods
+
+### Docker
+
+Get the [Docker image](https://hub.docker.com/r/ankane/pgvector) with:
+
+```sh
+docker pull ankane/pgvector
+```
+
+This adds pgvector to the [Postgres image](https://hub.docker.com/_/postgres).
+
+You can also build the image manually
+
+```sh
+git clone --branch v0.3.1 https://github.com/pgvector/pgvector.git
+cd pgvector
+docker build -t pgvector .
+```
+
+### Homebrew
+
+With Homebrew Postgres, you can use:
+
+```sh
+brew install pgvector/brew/pgvector
+```
+
+### PGXN
+
+Install from the [PostgreSQL Extension Network](https://pgxn.org/dist/vector) with:
+
+```sh
+pgxn install vector
+```
+
+## Hosted Postgres
+
+Some Postgres providers only support specific extensions. To request a new extension:
+
+- Amazon RDS - follow the instructions on [this page](https://aws.amazon.com/rds/postgresql/faqs/)
+- Google Cloud SQL - follow the instructions on [this page](https://cloud.google.com/sql/docs/postgres/extensions#requesting-support-for-a-new-extension)
+- DigitalOcean Managed Databases - vote or comment on [this page](https://ideas.digitalocean.com/app-framework-services/p/pgvector-extension-for-postgresql)
+- Azure Database for PostgreSQL - follow the instructions on [this page](https://docs.microsoft.com/en-us/azure/postgresql/concepts-extensions#next-steps)
+
+## Upgrading
+
+Install the latest version and run:
+
+```sql
+ALTER EXTENSION vector UPDATE;
+```
+
+## Upgrade Notes
+
+### 0.3.1
+
+If upgrading from 0.2.7 or 0.3.0, recreate all `ivfflat` indexes after upgrading to ensure all data is indexed.
+
+```sql
+-- Postgres 12+
+REINDEX INDEX CONCURRENTLY index_name;
+
+-- Postgres < 12
+CREATE INDEX CONCURRENTLY temp_name ON table USING ivfflat (column opclass);
+DROP INDEX CONCURRENTLY index_name;
+ALTER INDEX temp_name RENAME TO index_name;
+```
+
 ## Thanks
 
 Thanks to:
@@ -142,21 +298,21 @@ Thanks to:
 
 ## History
 
-View the [changelog](https://github.com/ankane/pgvector/blob/master/CHANGELOG.md)
+View the [changelog](https://github.com/pgvector/pgvector/blob/master/CHANGELOG.md)
 
 ## Contributing
 
 Everyone is encouraged to help improve this project. Here are a few ways you can help:
 
-- [Report bugs](https://github.com/ankane/pgvector/issues)
-- Fix bugs and [submit pull requests](https://github.com/ankane/pgvector/pulls)
+- [Report bugs](https://github.com/pgvector/pgvector/issues)
+- Fix bugs and [submit pull requests](https://github.com/pgvector/pgvector/pulls)
 - Write, clarify, or fix documentation
 - Suggest or add new features
 
 To get started with development:
 
 ```sh
-git clone https://github.com/ankane/pgvector.git
+git clone https://github.com/pgvector/pgvector.git
 cd pgvector
 make
 make install
@@ -172,15 +328,15 @@ make prove_installcheck  # TAP tests
 To run single tests:
 
 ```sh
-make installcheck REGRESS=vector                  # regression test
-make prove_installcheck PROVE_TESTS=t/001_wal.pl  # TAP test
+make installcheck REGRESS=functions                    # regression test
+make prove_installcheck PROVE_TESTS=test/t/001_wal.pl  # TAP test
 ```
 
-Directories
+To enable benchmarking:
 
-- `expected` - expected output for regression tests
-- `sql` - regression tests
-- `t` - TAP tests
+```sh
+make clean && PG_CFLAGS=-DIVFFLAT_BENCH make && make install
+```
 
 Resources for contributors
 

sql/vector--0.1.0--0.1.1.sql

@@ -0,0 +1,39 @@
+-- complain if script is sourced in psql, rather than via CREATE EXTENSION
+\echo Use "ALTER EXTENSION vector UPDATE TO '0.1.1'" to load this file. \quit
+
+CREATE FUNCTION vector_recv(internal, oid, integer) RETURNS vector
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT;
+
+CREATE FUNCTION vector_send(vector) RETURNS bytea
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT;
+
+ALTER TYPE vector SET ( RECEIVE = vector_recv, SEND = vector_send );
+
+-- functions
+
+ALTER FUNCTION vector_in(cstring, oid, integer) PARALLEL SAFE;
+ALTER FUNCTION vector_out(vector) PARALLEL SAFE;
+ALTER FUNCTION vector_typmod_in(cstring[]) PARALLEL SAFE;
+ALTER FUNCTION vector_recv(internal, oid, integer) PARALLEL SAFE;
+ALTER FUNCTION vector_send(vector) PARALLEL SAFE;
+ALTER FUNCTION l2_distance(vector, vector) PARALLEL SAFE;
+ALTER FUNCTION inner_product(vector, vector) PARALLEL SAFE;
+ALTER FUNCTION cosine_distance(vector, vector) PARALLEL SAFE;
+ALTER FUNCTION vector_dims(vector) PARALLEL SAFE;
+ALTER FUNCTION vector_norm(vector) PARALLEL SAFE;
+ALTER FUNCTION vector_add(vector, vector) PARALLEL SAFE;
+ALTER FUNCTION vector_sub(vector, vector) PARALLEL SAFE;
+ALTER FUNCTION vector_lt(vector, vector) PARALLEL SAFE;
+ALTER FUNCTION vector_le(vector, vector) PARALLEL SAFE;
+ALTER FUNCTION vector_eq(vector, vector) PARALLEL SAFE;
+ALTER FUNCTION vector_ne(vector, vector) PARALLEL SAFE;
+ALTER FUNCTION vector_ge(vector, vector) PARALLEL SAFE;
+ALTER FUNCTION vector_gt(vector, vector) PARALLEL SAFE;
+ALTER FUNCTION vector_cmp(vector, vector) PARALLEL SAFE;
+ALTER FUNCTION vector_l2_squared_distance(vector, vector) PARALLEL SAFE;
+ALTER FUNCTION vector_negative_inner_product(vector, vector) PARALLEL SAFE;
+ALTER FUNCTION vector_spherical_distance(vector, vector) PARALLEL SAFE;
+ALTER FUNCTION vector(vector, integer, boolean) PARALLEL SAFE;
+ALTER FUNCTION array_to_vector(integer[], integer, boolean) PARALLEL SAFE;
+ALTER FUNCTION array_to_vector(real[], integer, boolean) PARALLEL SAFE;
+ALTER FUNCTION array_to_vector(double precision[], integer, boolean) PARALLEL SAFE;

sql/vector--0.1.1--0.1.3.sql

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

sql/vector--0.1.3--0.1.4.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.1.4'" to load this file. \quit

sql/vector--0.1.4--0.1.5.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.1.5'" to load this file. \quit

sql/vector--0.1.5--0.1.6.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.1.6'" to load this file. \quit

sql/vector--0.1.6--0.1.7.sql

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

sql/vector--0.1.7--0.1.8.sql

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

sql/vector--0.1.8--0.2.0.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.2.0'" to load this file. \quit

sql/vector--0.2.0--0.2.1.sql

@@ -0,0 +1,19 @@
+-- complain if script is sourced in psql, rather than via CREATE EXTENSION
+\echo Use "ALTER EXTENSION vector UPDATE TO '0.2.1'" to load this file. \quit
+
+DROP CAST (integer[] AS vector);
+DROP CAST (real[] AS vector);
+DROP CAST (double precision[] AS vector);
+DROP CAST (numeric[] AS vector);
+
+CREATE CAST (integer[] AS vector)
+  WITH FUNCTION array_to_vector(integer[], integer, boolean) AS ASSIGNMENT;
+
+CREATE CAST (real[] AS vector)
+  WITH FUNCTION array_to_vector(real[], integer, boolean) AS ASSIGNMENT;
+
+CREATE CAST (double precision[] AS vector)
+  WITH FUNCTION array_to_vector(double precision[], integer, boolean) AS ASSIGNMENT;
+
+CREATE CAST (numeric[] AS vector)
+  WITH FUNCTION array_to_vector(numeric[], integer, boolean) AS ASSIGNMENT;

sql/vector--0.2.1--0.2.2.sql

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

sql/vector--0.2.2--0.2.3.sql

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

sql/vector--0.2.3--0.2.4.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.2.4'" to load this file. \quit

sql/vector--0.2.4--0.2.5.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.2.5'" to load this file. \quit

sql/vector--0.2.5--0.2.6.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.2.6'" to load this file. \quit

sql/vector--0.2.6--0.2.7.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.2.7'" to load this file. \quit

sql/vector--0.2.7--0.3.0.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.3.0'" to load this file. \quit

sql/vector--0.3.0--0.3.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.3.1'" to load this file. \quit

sql/vector.sql

@@ -1,15 +1,230 @@
-SET client_min_messages = warning;
-CREATE EXTENSION IF NOT EXISTS vector;
+-- complain if script is sourced in psql, rather than via CREATE EXTENSION
+\echo Use "CREATE EXTENSION vector" to load this file. \quit
 
-SELECT '[1,2,3]'::vector;
-SELECT '[-1,2,3]'::vector;
-SELECT '[hello,1]'::vector;
-SELECT '[NaN,1]'::vector;
-SELECT '[Infinity,1]'::vector;
-SELECT '[-Infinity,1]'::vector;
-SELECT '[1,2,3'::vector;
-SELECT '[1,2,3]9'::vector;
-SELECT '1,2,3'::vector;
-SELECT '[]'::vector;
-SELECT '[1,]'::vector;
-SELECT '[1,2,3]'::vector(2);
+-- type
+
+CREATE TYPE vector;
+
+CREATE FUNCTION vector_in(cstring, oid, integer) RETURNS vector
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION vector_out(vector) RETURNS cstring
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION vector_typmod_in(cstring[]) RETURNS integer
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION vector_recv(internal, oid, integer) RETURNS vector
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION vector_send(vector) RETURNS bytea
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE TYPE vector (
+	INPUT     = vector_in,
+	OUTPUT    = vector_out,
+	TYPMOD_IN = vector_typmod_in,
+	RECEIVE   = vector_recv,
+	SEND      = vector_send
+);
+
+-- functions
+
+CREATE FUNCTION l2_distance(vector, vector) RETURNS float8
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION inner_product(vector, vector) RETURNS float8
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION cosine_distance(vector, vector) RETURNS float8
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION vector_dims(vector) RETURNS integer
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION vector_norm(vector) RETURNS float8
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION vector_add(vector, vector) RETURNS vector
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION vector_sub(vector, vector) RETURNS vector
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+-- private functions
+
+CREATE FUNCTION vector_lt(vector, vector) RETURNS bool
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION vector_le(vector, vector) RETURNS bool
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION vector_eq(vector, vector) RETURNS bool
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION vector_ne(vector, vector) RETURNS bool
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION vector_ge(vector, vector) RETURNS bool
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION vector_gt(vector, vector) RETURNS bool
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION vector_cmp(vector, vector) RETURNS int4
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION vector_l2_squared_distance(vector, vector) RETURNS float8
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION vector_negative_inner_product(vector, vector) RETURNS float8
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION vector_spherical_distance(vector, vector) RETURNS float8
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+-- cast functions
+
+CREATE FUNCTION vector(vector, integer, boolean) RETURNS vector
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION array_to_vector(integer[], integer, boolean) RETURNS vector
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION array_to_vector(real[], integer, boolean) RETURNS vector
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION array_to_vector(double precision[], integer, boolean) RETURNS vector
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION array_to_vector(numeric[], integer, boolean) RETURNS vector
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION vector_to_float4(vector, integer, boolean) RETURNS real[]
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+-- casts
+
+CREATE CAST (vector AS vector)
+	WITH FUNCTION vector(vector, integer, boolean) AS IMPLICIT;
+
+CREATE CAST (vector AS real[])
+	WITH FUNCTION vector_to_float4(vector, integer, boolean) AS IMPLICIT;
+
+CREATE CAST (integer[] AS vector)
+	WITH FUNCTION array_to_vector(integer[], integer, boolean) AS ASSIGNMENT;
+
+CREATE CAST (real[] AS vector)
+	WITH FUNCTION array_to_vector(real[], integer, boolean) AS ASSIGNMENT;
+
+CREATE CAST (double precision[] AS vector)
+	WITH FUNCTION array_to_vector(double precision[], integer, boolean) AS ASSIGNMENT;
+
+CREATE CAST (numeric[] AS vector)
+	WITH FUNCTION array_to_vector(numeric[], integer, boolean) AS ASSIGNMENT;
+
+-- operators
+
+CREATE OPERATOR <-> (
+	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = l2_distance,
+	COMMUTATOR = '<->'
+);
+
+CREATE OPERATOR <#> (
+	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = vector_negative_inner_product,
+	COMMUTATOR = '<#>'
+);
+
+CREATE OPERATOR <=> (
+	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = cosine_distance,
+	COMMUTATOR = '<=>'
+);
+
+CREATE OPERATOR + (
+	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = vector_add,
+	COMMUTATOR = +
+);
+
+CREATE OPERATOR - (
+	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = vector_sub,
+	COMMUTATOR = -
+);
+
+CREATE OPERATOR < (
+	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = vector_lt,
+	COMMUTATOR = > , NEGATOR = >= ,
+	RESTRICT = scalarltsel, JOIN = scalarltjoinsel
+);
+
+-- should use scalarlesel and scalarlejoinsel, but not supported in Postgres < 11
+CREATE OPERATOR <= (
+	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = vector_le,
+	COMMUTATOR = >= , NEGATOR = > ,
+	RESTRICT = scalarltsel, JOIN = scalarltjoinsel
+);
+
+CREATE OPERATOR = (
+	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = vector_eq,
+	COMMUTATOR = = , NEGATOR = <> ,
+	RESTRICT = eqsel, JOIN = eqjoinsel
+);
+
+CREATE OPERATOR <> (
+	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = vector_ne,
+	COMMUTATOR = <> , NEGATOR = = ,
+	RESTRICT = eqsel, JOIN = eqjoinsel
+);
+
+-- should use scalargesel and scalargejoinsel, but not supported in Postgres < 11
+CREATE OPERATOR >= (
+	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = vector_ge,
+	COMMUTATOR = <= , NEGATOR = < ,
+	RESTRICT = scalargtsel, JOIN = scalargtjoinsel
+);
+
+CREATE OPERATOR > (
+	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = vector_gt,
+	COMMUTATOR = < , NEGATOR = <= ,
+	RESTRICT = scalargtsel, JOIN = scalargtjoinsel
+);
+
+-- access method
+
+CREATE FUNCTION ivfflathandler(internal) RETURNS index_am_handler
+	AS 'MODULE_PATHNAME' LANGUAGE C;
+
+CREATE ACCESS METHOD ivfflat TYPE INDEX HANDLER ivfflathandler;
+
+COMMENT ON ACCESS METHOD ivfflat IS 'ivfflat index access method';
+
+-- opclasses
+
+CREATE OPERATOR CLASS vector_ops
+	DEFAULT FOR TYPE vector USING btree AS
+	OPERATOR 1 < ,
+	OPERATOR 2 <= ,
+	OPERATOR 3 = ,
+	OPERATOR 4 >= ,
+	OPERATOR 5 > ,
+	FUNCTION 1 vector_cmp(vector, vector);
+
+CREATE OPERATOR CLASS vector_l2_ops
+	DEFAULT FOR TYPE vector USING ivfflat AS
+	OPERATOR 1 <-> (vector, vector) FOR ORDER BY float_ops,
+	FUNCTION 1 vector_l2_squared_distance(vector, vector),
+	FUNCTION 3 l2_distance(vector, vector);
+
+CREATE OPERATOR CLASS vector_ip_ops
+	FOR TYPE vector USING ivfflat AS
+	OPERATOR 1 <#> (vector, vector) FOR ORDER BY float_ops,
+	FUNCTION 1 vector_negative_inner_product(vector, vector),
+	FUNCTION 3 vector_spherical_distance(vector, vector),
+	FUNCTION 4 vector_norm(vector);
+
+CREATE OPERATOR CLASS vector_cosine_ops
+	FOR TYPE vector USING ivfflat AS
+	OPERATOR 1 <=> (vector, vector) FOR ORDER BY float_ops,
+	FUNCTION 1 vector_negative_inner_product(vector, vector),
+	FUNCTION 2 vector_norm(vector),
+	FUNCTION 3 vector_spherical_distance(vector, vector),
+	FUNCTION 4 vector_norm(vector);

src/ivfbuild.c

@@ -7,8 +7,19 @@
 #include "miscadmin.h"
 #include "storage/bufmgr.h"
 
+#if PG_VERSION_NUM >= 140000
+#include "utils/backend_progress.h"
+#elif PG_VERSION_NUM >= 120000
+#include "pgstat.h"
+#endif
+
 #if PG_VERSION_NUM >= 120000
 #include "access/tableam.h"
+#include "commands/progress.h"
+#else
+#define PROGRESS_CREATEIDX_SUBPHASE 0
+#define PROGRESS_CREATEIDX_TUPLES_TOTAL 0
+#define PROGRESS_CREATEIDX_TUPLES_DONE 0
 #endif
 
 #if PG_VERSION_NUM >= 110000
@@ -25,6 +36,12 @@
 #define CALLBACK_ITEM_POINTER HeapTuple hup
 #endif
 
+#if PG_VERSION_NUM >= 120000
+#define UpdateProgress(index, val) pgstat_progress_update_param(index, val)
+#else
+#define UpdateProgress(index, val) ((void)val)
+#endif
+
 /*
  * Callback for sampling
  */
@@ -41,10 +58,13 @@ SampleCallback(Relation index, CALLBACK_ITEM_POINTER, Datum *values,
 	if (isnull[0])
 		return;
 
-	/* Normalize the value */
-	if (buildstate->normprocinfo != NULL)
+	/*
+	 * Normalize with KMEANS_NORM_PROC since spherical distance function
+	 * expects unit vectors
+	 */
+	if (buildstate->kmeansnormprocinfo != NULL)
 	{
-		if (!IvfflatNormValue(buildstate->normprocinfo, buildstate->collation, &value, buildstate->normvec))
+		if (!IvfflatNormValue(buildstate->kmeansnormprocinfo, buildstate->collation, &value, buildstate->normvec))
 			return;
 	}
 
@@ -60,7 +80,11 @@ SampleCallback(Relation index, CALLBACK_ITEM_POINTER, Datum *values,
 
 		if (buildstate->rowstoskip <= 0)
 		{
+#if PG_VERSION_NUM >= 150000
+			int			k = (int) (targsamples * sampler_random_fract(&buildstate->rstate.randstate));
+#else
 			int			k = (int) (targsamples * sampler_random_fract(buildstate->rstate.randstate));
+#endif
 
 			Assert(k >= 0 && k < targsamples);
 			VectorArraySet(samples, k, DatumGetVector(value));
@@ -79,6 +103,8 @@ SampleRows(IvfflatBuildState * buildstate)
 	int			targsamples = buildstate->samples->maxlen;
 	BlockNumber totalblocks = RelationGetNumberOfBlocks(buildstate->heap);
 
+	UpdateProgress(PROGRESS_CREATEIDX_SUBPHASE, PROGRESS_IVFFLAT_PHASE_SAMPLE);
+
 	buildstate->rowstoskip = -1;
 
 	BlockSampler_Init(&buildstate->bs, totalblocks, targsamples, random());
@@ -90,13 +116,13 @@ SampleRows(IvfflatBuildState * buildstate)
 
 #if PG_VERSION_NUM >= 120000
 		table_index_build_range_scan(buildstate->heap, buildstate->index, buildstate->indexInfo,
-									 false, true, true, targblock, 1, SampleCallback, (void *) buildstate, NULL);
+									 false, true, false, targblock, 1, SampleCallback, (void *) buildstate, NULL);
 #elif PG_VERSION_NUM >= 110000
 		IndexBuildHeapRangeScan(buildstate->heap, buildstate->index, buildstate->indexInfo,
-								true, true, targblock, 1, SampleCallback, (void *) buildstate, NULL);
+								false, true, targblock, 1, SampleCallback, (void *) buildstate, NULL);
 #else
 		IndexBuildHeapRangeScan(buildstate->heap, buildstate->index, buildstate->indexInfo,
-								true, true, targblock, 1, SampleCallback, (void *) buildstate);
+								false, true, targblock, 1, SampleCallback, (void *) buildstate);
 #endif
 	}
 }
@@ -143,16 +169,20 @@ BuildCallback(Relation index, CALLBACK_ITEM_POINTER, Datum *values,
 		}
 	}
 
+#ifdef IVFFLAT_KMEANS_DEBUG
+	buildstate->inertia += minDistance;
+	buildstate->listSums[closestCenter] += minDistance;
+	buildstate->listCounts[closestCenter]++;
+#endif
+
 	/* Create a virtual tuple */
 	ExecClearTuple(slot);
 	slot->tts_values[0] = Int32GetDatum(closestCenter);
 	slot->tts_isnull[0] = false;
-	slot->tts_values[1] = Int32GetDatum(ItemPointerGetBlockNumberNoCheck(tid));
+	slot->tts_values[1] = PointerGetDatum(tid);
 	slot->tts_isnull[1] = false;
-	slot->tts_values[2] = Int32GetDatum(ItemPointerGetOffsetNumberNoCheck(tid));
+	slot->tts_values[2] = value;
 	slot->tts_isnull[2] = false;
-	slot->tts_values[3] = value;
-	slot->tts_isnull[3] = false;
 	ExecStoreVirtualTuple(slot);
 
 	/*
@@ -162,6 +192,8 @@ BuildCallback(Relation index, CALLBACK_ITEM_POINTER, Datum *values,
 	 * need not save it.
 	 */
 	tuplesort_puttupleslot(buildstate->sortstate, slot);
+
+	buildstate->indtuples++;
 }
 
 /*
@@ -172,8 +204,6 @@ GetNextTuple(Tuplesortstate *sortstate, TupleDesc tupdesc, TupleTableSlot *slot,
 {
 	Datum		value;
 	bool		isnull;
-	int			tupblk;
-	int			tupoff;
 
 #if PG_VERSION_NUM >= 100000
 	if (tuplesort_gettupleslot(sortstate, true, false, slot, NULL))
@@ -182,13 +212,11 @@ GetNextTuple(Tuplesortstate *sortstate, TupleDesc tupdesc, TupleTableSlot *slot,
 #endif
 	{
 		*list = DatumGetInt32(slot_getattr(slot, 1, &isnull));
-		tupblk = DatumGetInt32(slot_getattr(slot, 2, &isnull));
-		tupoff = DatumGetInt32(slot_getattr(slot, 3, &isnull));
-		value = slot_getattr(slot, 4, &isnull);
+		value = slot_getattr(slot, 3, &isnull);
 
 		/* Form the index tuple */
 		*itup = index_form_tuple(tupdesc, &value, &isnull);
-		ItemPointerSet(&(*itup)->t_tid, tupblk, tupoff);
+		(*itup)->t_tid = *((ItemPointer) DatumGetPointer(slot_getattr(slot, 2, &isnull)));
 	}
 	else
 		*list = -1;
@@ -205,10 +233,11 @@ InsertTuples(Relation index, IvfflatBuildState * buildstate, ForkNumber forkNum)
 	GenericXLogState *state;
 	int			list;
 	IndexTuple	itup = NULL;	/* silence compiler warning */
-	BlockNumber startPage = InvalidBlockNumber;
-	BlockNumber insertPage = InvalidBlockNumber;
+	BlockNumber startPage;
+	BlockNumber insertPage;
 	Size		itemsz;
 	int			i;
+	int64		inserted = 0;
 
 #if PG_VERSION_NUM >= 120000
 	TupleTableSlot *slot = MakeSingleTupleTableSlot(buildstate->tupdesc, &TTSOpsMinimalTuple);
@@ -217,12 +246,20 @@ InsertTuples(Relation index, IvfflatBuildState * buildstate, ForkNumber forkNum)
 #endif
 	TupleDesc	tupdesc = RelationGetDescr(index);
 
+	UpdateProgress(PROGRESS_CREATEIDX_SUBPHASE, PROGRESS_IVFFLAT_PHASE_LOAD);
+
+	UpdateProgress(PROGRESS_CREATEIDX_TUPLES_TOTAL, buildstate->indtuples);
+
 	GetNextTuple(buildstate->sortstate, tupdesc, slot, &itup, &list);
 
 	for (i = 0; i < buildstate->centers->length; i++)
 	{
+		/* Can take a while, so ensure we can interrupt */
+		/* Needs to be called when no buffer locks are held */
+		CHECK_FOR_INTERRUPTS();
+
 		buf = IvfflatNewBuffer(index, forkNum);
-		IvfflatInitPage(index, &buf, &page, &state);
+		IvfflatInitRegisterPage(index, &buf, &page, &state);
 
 		startPage = BufferGetBlockNumber(buf);
 
@@ -238,7 +275,9 @@ InsertTuples(Relation index, IvfflatBuildState * buildstate, ForkNumber forkNum)
 			if (PageAddItem(page, (Item) itup, itemsz, InvalidOffsetNumber, false, false) == InvalidOffsetNumber)
 				elog(ERROR, "failed to add index item to \"%s\"", RelationGetRelationName(index));
 
-			buildstate->indtuples += 1;
+			pfree(itup);
+
+			UpdateProgress(PROGRESS_CREATEIDX_TUPLES_DONE, ++inserted);
 
 			GetNextTuple(buildstate->sortstate, tupdesc, slot, &itup, &list);
 		}
@@ -248,7 +287,7 @@ InsertTuples(Relation index, IvfflatBuildState * buildstate, ForkNumber forkNum)
 		IvfflatCommitBuffer(buf, state);
 
 		/* Set the start and insert pages */
-		IvfflatUpdateList(index, state, buildstate->listInfo[i], insertPage, startPage, forkNum);
+		IvfflatUpdateList(index, state, buildstate->listInfo[i], insertPage, InvalidBlockNumber, startPage, forkNum);
 	}
 }
 
@@ -275,21 +314,27 @@ InitBuildState(IvfflatBuildState * buildstate, Relation heap, Relation index, In
 	/* Get support functions */
 	buildstate->procinfo = index_getprocinfo(index, 1, IVFFLAT_DISTANCE_PROC);
 	buildstate->normprocinfo = IvfflatOptionalProcInfo(index, IVFFLAT_NORM_PROC);
+	buildstate->kmeansnormprocinfo = IvfflatOptionalProcInfo(index, IVFFLAT_KMEANS_NORM_PROC);
 	buildstate->collation = index->rd_indcollation[0];
 
+	/* Require more than one dimension for spherical k-means */
+	/* Lists check for backwards compatibility */
+	/* TODO Remove lists check in 0.3.0 */
+	if (buildstate->kmeansnormprocinfo != NULL && buildstate->dimensions == 1 && buildstate->lists > 1)
+		elog(ERROR, "dimensions must be greater than one for this opclass");
+
 	/* Create tuple description for sorting */
 #if PG_VERSION_NUM >= 120000
-	buildstate->tupdesc = CreateTemplateTupleDesc(4);
+	buildstate->tupdesc = CreateTemplateTupleDesc(3);
 #else
-	buildstate->tupdesc = CreateTemplateTupleDesc(4, false);
+	buildstate->tupdesc = CreateTemplateTupleDesc(3, false);
 #endif
 	TupleDescInitEntry(buildstate->tupdesc, (AttrNumber) 1, "list", INT4OID, -1, 0);
-	TupleDescInitEntry(buildstate->tupdesc, (AttrNumber) 2, "blkno", INT4OID, -1, 0);
-	TupleDescInitEntry(buildstate->tupdesc, (AttrNumber) 3, "offset", INT4OID, -1, 0);
+	TupleDescInitEntry(buildstate->tupdesc, (AttrNumber) 2, "tid", TIDOID, -1, 0);
 #if PG_VERSION_NUM >= 110000
-	TupleDescInitEntry(buildstate->tupdesc, (AttrNumber) 4, "vector", RelationGetDescr(index)->attrs[0].atttypid, -1, 0);
+	TupleDescInitEntry(buildstate->tupdesc, (AttrNumber) 3, "vector", RelationGetDescr(index)->attrs[0].atttypid, -1, 0);
 #else
-	TupleDescInitEntry(buildstate->tupdesc, (AttrNumber) 4, "vector", RelationGetDescr(index)->attrs[0]->atttypid, -1, 0);
+	TupleDescInitEntry(buildstate->tupdesc, (AttrNumber) 3, "vector", RelationGetDescr(index)->attrs[0]->atttypid, -1, 0);
 #endif
 
 #if PG_VERSION_NUM >= 120000
@@ -303,6 +348,12 @@ InitBuildState(IvfflatBuildState * buildstate, Relation heap, Relation index, In
 
 	/* Reuse for each tuple */
 	buildstate->normvec = InitVector(buildstate->dimensions);
+
+#ifdef IVFFLAT_KMEANS_DEBUG
+	buildstate->inertia = 0;
+	buildstate->listSums = palloc0(sizeof(double) * buildstate->lists);
+	buildstate->listCounts = palloc0(sizeof(int) * buildstate->lists);
+#endif
 }
 
 /*
@@ -314,6 +365,11 @@ FreeBuildState(IvfflatBuildState * buildstate)
 	pfree(buildstate->centers);
 	pfree(buildstate->listInfo);
 	pfree(buildstate->normvec);
+
+#ifdef IVFFLAT_KMEANS_DEBUG
+	pfree(buildstate->listSums);
+	pfree(buildstate->listCounts);
+#endif
 }
 
 /*
@@ -330,13 +386,19 @@ ComputeCenters(IvfflatBuildState * buildstate)
 	if (numSamples < 10000)
 		numSamples = 10000;
 
-	/* Sample samples */
+	/* Skip samples for unlogged table */
+	if (buildstate->heap == NULL)
+		numSamples = 1;
+
+	/* Sample rows */
+	/* TODO Ensure within maintenance_work_mem */
 	buildstate->samples = VectorArrayInit(numSamples, buildstate->dimensions);
 	if (buildstate->heap != NULL)
 		SampleRows(buildstate);
 
 	/* Calculate centers */
-	IvfflatKmeans(buildstate->index, buildstate->samples, buildstate->centers);
+	UpdateProgress(PROGRESS_CREATEIDX_SUBPHASE, PROGRESS_IVFFLAT_PHASE_KMEANS);
+	IvfflatBench("k-means", IvfflatKmeans(buildstate->index, buildstate->samples, buildstate->centers));
 
 	/* Free samples before we allocate more memory */
 	pfree(buildstate->samples);
@@ -354,7 +416,7 @@ CreateMetaPage(Relation index, int dimensions, int lists, ForkNumber forkNum)
 	IvfflatMetaPage metap;
 
 	buf = IvfflatNewBuffer(index, forkNum);
-	IvfflatInitPage(index, &buf, &page, &state);
+	IvfflatInitRegisterPage(index, &buf, &page, &state);
 
 	/* Set metapage data */
 	metap = IvfflatPageGetMeta(page);
@@ -387,7 +449,7 @@ CreateListPages(Relation index, VectorArray centers, int dimensions,
 	list = palloc(itemsz);
 
 	buf = IvfflatNewBuffer(index, forkNum);
-	IvfflatInitPage(index, &buf, &page, &state);
+	IvfflatInitRegisterPage(index, &buf, &page, &state);
 
 	for (i = 0; i < lists; i++)
 	{
@@ -415,6 +477,51 @@ CreateListPages(Relation index, VectorArray centers, int dimensions,
 	pfree(list);
 }
 
+/*
+ * Print k-means metrics
+ */
+#ifdef IVFFLAT_KMEANS_DEBUG
+static void
+PrintKmeansMetrics(IvfflatBuildState * buildstate)
+{
+	elog(INFO, "inertia: %.3e", buildstate->inertia);
+
+	/* Calculate Davies-Bouldin index */
+	if (buildstate->lists > 1)
+	{
+		double		db = 0.0;
+
+		/* Calculate average distance */
+		for (int i = 0; i < buildstate->lists; i++)
+		{
+			if (buildstate->listCounts[i] > 0)
+				buildstate->listSums[i] /= buildstate->listCounts[i];
+		}
+
+		for (int i = 0; i < buildstate->lists; i++)
+		{
+			double		max = 0.0;
+			double		distance;
+
+			for (int j = 0; j < buildstate->lists; j++)
+			{
+				if (j == i)
+					continue;
+
+				distance = DatumGetFloat8(FunctionCall2Coll(buildstate->procinfo, buildstate->collation, PointerGetDatum(VectorArrayGet(buildstate->centers, i)), PointerGetDatum(VectorArrayGet(buildstate->centers, j))));
+				distance = (buildstate->listSums[i] + buildstate->listSums[j]) / distance;
+
+				if (distance > max)
+					max = distance;
+			}
+			db += max;
+		}
+		db /= buildstate->lists;
+		elog(INFO, "davies-bouldin: %.3f", db);
+	}
+}
+#endif
+
 /*
  * Create entry pages
  */
@@ -426,6 +533,8 @@ CreateEntryPages(IvfflatBuildState * buildstate, ForkNumber forkNum)
 	Oid			sortCollations[] = {InvalidOid};
 	bool		nullsFirstFlags[] = {false};
 
+	UpdateProgress(PROGRESS_CREATEIDX_SUBPHASE, PROGRESS_IVFFLAT_PHASE_SORT);
+
 #if PG_VERSION_NUM >= 110000
 	buildstate->sortstate = tuplesort_begin_heap(buildstate->tupdesc, 1, attNums, sortOperators, sortCollations, nullsFirstFlags, maintenance_work_mem, NULL, false);
 #else
@@ -447,8 +556,14 @@ CreateEntryPages(IvfflatBuildState * buildstate, ForkNumber forkNum)
 #endif
 	}
 
-	/* Sort and insert */
+	/* Sort */
 	tuplesort_performsort(buildstate->sortstate);
+
+#ifdef IVFFLAT_KMEANS_DEBUG
+	PrintKmeansMetrics(buildstate);
+#endif
+
+	/* Insert */
 	InsertTuples(buildstate->index, buildstate, forkNum);
 	tuplesort_end(buildstate->sortstate);
 }
@@ -467,7 +582,7 @@ BuildIndex(Relation heap, Relation index, IndexInfo *indexInfo,
 	/* Create pages */
 	CreateMetaPage(index, buildstate->dimensions, buildstate->lists, forkNum);
 	CreateListPages(index, buildstate->centers, buildstate->dimensions, buildstate->lists, forkNum, &buildstate->listInfo);
-	CreateEntryPages(buildstate, forkNum);
+	IvfflatBench("CreateEntryPages", CreateEntryPages(buildstate, forkNum));
 
 	FreeBuildState(buildstate);
 }

src/ivfflat.c

@@ -1,11 +1,18 @@
 #include "postgres.h"
 
+#include <float.h>
+
 #include "access/amapi.h"
 #include "commands/vacuum.h"
 #include "ivfflat.h"
 #include "utils/guc.h"
 #include "utils/selfuncs.h"
 
+#if PG_VERSION_NUM >= 120000
+#include "commands/progress.h"
+#endif
+
+int			ivfflat_probes;
 static relopt_kind ivfflat_relopt_kind;
 
 /*
@@ -27,10 +34,33 @@ _PG_init(void)
 							1, 1, IVFFLAT_MAX_LISTS, PGC_USERSET, 0, NULL, NULL, NULL);
 }
 
+/*
+ * Get the name of index build phase
+ */
+#if PG_VERSION_NUM >= 120000
+static char *
+ivfflatbuildphasename(int64 phasenum)
+{
+	switch (phasenum)
+	{
+		case PROGRESS_CREATEIDX_SUBPHASE_INITIALIZE:
+			return "initializing";
+		case PROGRESS_IVFFLAT_PHASE_SAMPLE:
+			return "sampling table";
+		case PROGRESS_IVFFLAT_PHASE_KMEANS:
+			return "performing k-means";
+		case PROGRESS_IVFFLAT_PHASE_SORT:
+			return "sorting tuples";
+		case PROGRESS_IVFFLAT_PHASE_LOAD:
+			return "loading tuples";
+		default:
+			return NULL;
+	}
+}
+#endif
+
 /*
  * Estimate the cost of an index scan
- *
- * TODO Improve cost estimation
  */
 static void
 ivfflatcostestimate(PlannerInfo *root, IndexPath *path, double loop_count,
@@ -42,22 +72,47 @@ ivfflatcostestimate(PlannerInfo *root, IndexPath *path, double loop_count,
 )
 {
 	GenericCosts costs;
-
+	int			lists;
+	double		ratio;
+	Relation	indexRel;
 #if PG_VERSION_NUM < 120000
 	List	   *qinfos;
-
-	qinfos = deconstruct_indexquals(path);
 #endif
 
+	/* Never use index without order */
+	if (path->indexorderbys == NULL)
+	{
+		*indexStartupCost = DBL_MAX;
+		*indexTotalCost = DBL_MAX;
+		*indexSelectivity = 0;
+		*indexCorrelation = 0;
+#if PG_VERSION_NUM >= 100000
+		*indexPages = 0;
+#endif
+		return;
+	}
+
 	MemSet(&costs, 0, sizeof(costs));
 
 #if PG_VERSION_NUM >= 120000
 	genericcostestimate(root, path, loop_count, &costs);
 #else
+	qinfos = deconstruct_indexquals(path);
 	genericcostestimate(root, path, loop_count, qinfos, &costs);
 #endif
 
-	*indexStartupCost = costs.indexStartupCost;
+	indexRel = index_open(path->indexinfo->indexoid, NoLock);
+	lists = IvfflatGetLists(indexRel);
+	index_close(indexRel, NoLock);
+
+	ratio = ((double) ivfflat_probes) / lists;
+	if (ratio > 1)
+		ratio = 1;
+
+	costs.indexTotalCost *= ratio;
+
+	/* Startup cost and total cost are same */
+	*indexStartupCost = costs.indexTotalCost;
 	*indexTotalCost = costs.indexTotalCost;
 	*indexSelectivity = costs.indexSelectivity;
 	*indexCorrelation = costs.indexCorrelation;
@@ -104,6 +159,11 @@ ivfflatvalidate(Oid opclassoid)
 	return true;
 }
 
+/*
+ * Define index handler
+ *
+ * See https://www.postgresql.org/docs/current/index-api.html
+ */
 PG_FUNCTION_INFO_V1(ivfflathandler);
 Datum
 ivfflathandler(PG_FUNCTION_ARGS)
@@ -134,23 +194,27 @@ ivfflathandler(PG_FUNCTION_ARGS)
 #endif
 #if PG_VERSION_NUM >= 130000
 	amroutine->amusemaintenanceworkmem = false; /* not used during VACUUM */
-	amroutine->amparallelvacuumoptions = VACUUM_OPTION_NO_PARALLEL; /* TODO support parallel */
+	amroutine->amparallelvacuumoptions = VACUUM_OPTION_PARALLEL_BULKDEL;
 #endif
 	amroutine->amkeytype = InvalidOid;
 
+	/* Interface functions */
 	amroutine->ambuild = ivfflatbuild;
 	amroutine->ambuildempty = ivfflatbuildempty;
 	amroutine->aminsert = ivfflatinsert;
 	amroutine->ambulkdelete = ivfflatbulkdelete;
 	amroutine->amvacuumcleanup = ivfflatvacuumcleanup;
-	amroutine->amcanreturn = NULL;
+	amroutine->amcanreturn = NULL;	/* tuple not included in heapsort */
 	amroutine->amcostestimate = ivfflatcostestimate;
 	amroutine->amoptions = ivfflatoptions;
 	amroutine->amproperty = NULL;	/* TODO AMPROP_DISTANCE_ORDERABLE */
 #if PG_VERSION_NUM >= 120000
-	amroutine->ambuildphasename = NULL;
+	amroutine->ambuildphasename = ivfflatbuildphasename;
 #endif
 	amroutine->amvalidate = ivfflatvalidate;
+#if PG_VERSION_NUM >= 140000
+	amroutine->amadjustmembers = NULL;
+#endif
 	amroutine->ambeginscan = ivfflatbeginscan;
 	amroutine->amrescan = ivfflatrescan;
 	amroutine->amgettuple = ivfflatgettuple;
@@ -158,6 +222,8 @@ ivfflathandler(PG_FUNCTION_ARGS)
 	amroutine->amendscan = ivfflatendscan;
 	amroutine->ammarkpos = NULL;
 	amroutine->amrestrpos = NULL;
+
+	/* Interface functions to support parallel index scans */
 #if PG_VERSION_NUM >= 100000
 	amroutine->amestimateparallelscan = NULL;
 	amroutine->aminitparallelscan = NULL;

src/ivfflat.h

@@ -10,6 +10,14 @@
 #include "utils/tuplesort.h"
 #include "vector.h"
 
+#ifdef IVFFLAT_BENCH
+#include "portability/instr_time.h"
+#endif
+
+#if PG_VERSION_NUM < 100000
+#error "Requires PostgreSQL 10+"
+#endif
+
 /* Support functions */
 #define IVFFLAT_DISTANCE_PROC 1
 #define IVFFLAT_NORM_PROC 2
@@ -27,18 +35,35 @@
 #define IVFFLAT_DEFAULT_LISTS	100
 #define IVFFLAT_MAX_LISTS		32768
 
+/* Build phases */
+/* PROGRESS_CREATEIDX_SUBPHASE_INITIALIZE is 1 */
+#define PROGRESS_IVFFLAT_PHASE_SAMPLE	2
+#define PROGRESS_IVFFLAT_PHASE_KMEANS	3
+#define PROGRESS_IVFFLAT_PHASE_SORT		4
+#define PROGRESS_IVFFLAT_PHASE_LOAD		5
+
 #define IVFFLAT_LIST_SIZE(_dim)	(offsetof(IvfflatListData, center) + VECTOR_SIZE(_dim))
 
 #define IvfflatPageGetOpaque(page)	((IvfflatPageOpaque) PageGetSpecialPointer(page))
 #define IvfflatPageGetMeta(page)	((IvfflatMetaPageData *) PageGetContents(page))
 
-#if PG_VERSION_NUM < 100000
-#define ItemPointerGetBlockNumberNoCheck ItemPointerGetBlockNumber
-#define ItemPointerGetOffsetNumberNoCheck ItemPointerGetOffsetNumber
+#ifdef IVFFLAT_BENCH
+#define IvfflatBench(name, code) \
+	do { \
+		instr_time	start; \
+		instr_time	duration; \
+		INSTR_TIME_SET_CURRENT(start); \
+		(code); \
+		INSTR_TIME_SET_CURRENT(duration); \
+		INSTR_TIME_SUBTRACT(duration, start); \
+		elog(INFO, "%s: %.3f ms", name, INSTR_TIME_GET_MILLISEC(duration)); \
+	} while (0)
+#else
+#define IvfflatBench(name, code) (code)
 #endif
 
 /* Variables */
-int			ivfflat_probes;
+extern int	ivfflat_probes;
 
 typedef struct VectorArrayData
 {
@@ -81,6 +106,7 @@ typedef struct IvfflatBuildState
 	/* Support functions */
 	FmgrInfo   *procinfo;
 	FmgrInfo   *normprocinfo;
+	FmgrInfo   *kmeansnormprocinfo;
 	Oid			collation;
 
 	/* Variables */
@@ -89,6 +115,12 @@ typedef struct IvfflatBuildState
 	ListInfo   *listInfo;
 	Vector	   *normvec;
 
+#ifdef IVFFLAT_KMEANS_DEBUG
+	double		inertia;
+	double	   *listSums;
+	int		   *listCounts;
+#endif
+
 	/* Sampling */
 	BlockSamplerData bs;
 	ReservoirStateData rstate;
@@ -130,6 +162,7 @@ typedef IvfflatListData * IvfflatList;
 
 typedef struct IvfflatScanList
 {
+	pairingheap_node ph_node;
 	BlockNumber startPage;
 	double		distance;
 }			IvfflatScanList;
@@ -151,6 +184,8 @@ typedef struct IvfflatScanOpaqueData
 	FmgrInfo   *normprocinfo;
 	Oid			collation;
 
+	/* Lists */
+	pairingheap *listQueue;
 	IvfflatScanList lists[FLEXIBLE_ARRAY_MEMBER];	/* must come last */
 }			IvfflatScanOpaqueData;
 
@@ -169,16 +204,20 @@ void		IvfflatKmeans(Relation index, VectorArray samples, VectorArray centers);
 FmgrInfo   *IvfflatOptionalProcInfo(Relation rel, uint16 procnum);
 bool		IvfflatNormValue(FmgrInfo *procinfo, Oid collation, Datum *value, Vector * result);
 int			IvfflatGetLists(Relation index);
-void		IvfflatUpdateList(Relation index, GenericXLogState *state, ListInfo listInfo, BlockNumber insertPage, BlockNumber startPage, ForkNumber forkNum);
+void		IvfflatUpdateList(Relation index, GenericXLogState *state, ListInfo listInfo, BlockNumber insertPage, BlockNumber originalInsertPage, BlockNumber startPage, ForkNumber forkNum);
 void		IvfflatCommitBuffer(Buffer buf, GenericXLogState *state);
 void		IvfflatAppendPage(Relation index, Buffer *buf, Page *page, GenericXLogState **state, ForkNumber forkNum);
 Buffer		IvfflatNewBuffer(Relation index, ForkNumber forkNum);
-void		IvfflatInitPage(Relation index, Buffer *buf, Page *page, GenericXLogState **state);
+void		IvfflatInitPage(Buffer buf, Page page);
+void		IvfflatInitRegisterPage(Relation index, Buffer *buf, Page *page, GenericXLogState **state);
 
 /* Index access methods */
 IndexBuildResult *ivfflatbuild(Relation heap, Relation index, IndexInfo *indexInfo);
 void		ivfflatbuildempty(Relation index);
 bool		ivfflatinsert(Relation index, Datum *values, bool *isnull, ItemPointer heap_tid, Relation heap, IndexUniqueCheck checkUnique
+#if PG_VERSION_NUM >= 140000
+						  ,bool indexUnchanged
+#endif
 #if PG_VERSION_NUM >= 100000
 						  ,IndexInfo *indexInfo
 #endif

src/ivfinsert.c

@@ -53,18 +53,6 @@ FindInsertPage(Relation rel, Datum *values, BlockNumber *insertPage, ListInfo *
 	}
 }
 
-/*
- * Prepare to insert an index tuple
- */
-static void
-LoadInsertPage(Relation index, Buffer *buf, Page *page, GenericXLogState **state, BlockNumber insertPage)
-{
-	*buf = ReadBuffer(index, insertPage);
-	LockBuffer(*buf, BUFFER_LOCK_EXCLUSIVE);
-	*state = GenericXLogStart(index);
-	*page = GenericXLogRegisterBuffer(*state, *buf, 0);
-}
-
 /*
  * Insert a tuple into the index
  */
@@ -77,20 +65,28 @@ InsertTuple(Relation rel, IndexTuple itup, Relation heapRel, Datum *values)
 	Size		itemsz;
 	BlockNumber insertPage = InvalidBlockNumber;
 	ListInfo	listInfo;
-	bool		newPage = false;
+	BlockNumber originalInsertPage;
 
 	/* Find the insert page - sets the page and list info */
 	FindInsertPage(rel, values, &insertPage, &listInfo);
 	Assert(BlockNumberIsValid(insertPage));
+	originalInsertPage = insertPage;
 
 	itemsz = MAXALIGN(IndexTupleSize(itup));
 	Assert(itemsz <= BLCKSZ - MAXALIGN(SizeOfPageHeaderData) - MAXALIGN(sizeof(IvfflatPageOpaqueData)));
 
-	LoadInsertPage(rel, &buf, &page, &state, insertPage);
-
 	/* Find a page to insert the item */
-	while (PageGetFreeSpace(page) < itemsz)
+	for (;;)
 	{
+		buf = ReadBuffer(rel, insertPage);
+		LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
+
+		state = GenericXLogStart(rel);
+		page = GenericXLogRegisterBuffer(state, buf, 0);
+
+		if (PageGetFreeSpace(page) >= itemsz)
+			break;
+
 		insertPage = IvfflatPageGetOpaque(page)->nextblkno;
 
 		if (BlockNumberIsValid(insertPage))
@@ -98,16 +94,42 @@ InsertTuple(Relation rel, IndexTuple itup, Relation heapRel, Datum *values)
 			/* Move to next page */
 			GenericXLogAbort(state);
 			UnlockReleaseBuffer(buf);
-
-			LoadInsertPage(rel, &buf, &page, &state, insertPage);
 		}
 		else
 		{
-			/* Add a new page */
-			IvfflatAppendPage(rel, &buf, &page, &state, MAIN_FORKNUM);
+			Buffer		metabuf;
+			Buffer		newbuf;
+			Page		newpage;
 
-			insertPage = BufferGetBlockNumber(buf);
-			newPage = true;
+			/*
+			 * From ReadBufferExtended: Caller is responsible for ensuring
+			 * that only one backend tries to extend a relation at the same
+			 * time!
+			 */
+			metabuf = ReadBuffer(rel, IVFFLAT_METAPAGE_BLKNO);
+			LockBuffer(metabuf, BUFFER_LOCK_EXCLUSIVE);
+
+			/* Add a new page */
+			newbuf = IvfflatNewBuffer(rel, MAIN_FORKNUM);
+			newpage = GenericXLogRegisterBuffer(state, newbuf, GENERIC_XLOG_FULL_IMAGE);
+
+			insertPage = BufferGetBlockNumber(newbuf);
+
+			/* Update previous buffer */
+			IvfflatPageGetOpaque(page)->nextblkno = insertPage;
+
+			/* Init page */
+			IvfflatInitPage(newbuf, newpage);
+
+			/* Commit */
+			MarkBufferDirty(buf);
+			MarkBufferDirty(newbuf);
+			GenericXLogFinish(state);
+
+			/* Unlock */
+			UnlockReleaseBuffer(buf);
+			UnlockReleaseBuffer(newbuf);
+			UnlockReleaseBuffer(metabuf);
 		}
 	}
 
@@ -118,8 +140,8 @@ InsertTuple(Relation rel, IndexTuple itup, Relation heapRel, Datum *values)
 	IvfflatCommitBuffer(buf, state);
 
 	/* Update the insert page */
-	if (newPage)
-		IvfflatUpdateList(rel, state, listInfo, insertPage, InvalidBlockNumber, MAIN_FORKNUM);
+	if (insertPage != originalInsertPage)
+		IvfflatUpdateList(rel, state, listInfo, insertPage, originalInsertPage, InvalidBlockNumber, MAIN_FORKNUM);
 }
 
 /*
@@ -128,6 +150,9 @@ InsertTuple(Relation rel, IndexTuple itup, Relation heapRel, Datum *values)
 bool
 ivfflatinsert(Relation index, Datum *values, bool *isnull, ItemPointer heap_tid,
 			  Relation heap, IndexUniqueCheck checkUnique
+#if PG_VERSION_NUM >= 140000
+			  ,bool indexUnchanged
+#endif
 #if PG_VERSION_NUM >= 100000
 			  ,IndexInfo *indexInfo
 #endif

src/ivfkmeans.c

@@ -5,23 +5,33 @@
 #include "ivfflat.h"
 #include "miscadmin.h"
 
+#if PG_VERSION_NUM >= 150000
+#include "common/pg_prng.h"
+#endif
+
+#if PG_VERSION_NUM >= 150000
+#define RandomDouble() pg_prng_double(&pg_global_prng_state)
+#else
+#define RandomDouble() (((double) random()) / MAX_RANDOM_VALUE)
+#endif
+
 /*
  * Initialize with kmeans++
  *
  * https://theory.stanford.edu/~sergei/papers/kMeansPP-soda.pdf
  */
 static void
-InitCenters(Relation index, VectorArray samples, VectorArray centers, double *lowerBound)
+InitCenters(Relation index, VectorArray samples, VectorArray centers, float *lowerBound)
 {
 	FmgrInfo   *procinfo;
 	Oid			collation;
 	int			i;
-	int			j;
+	int64		j;
 	double		distance;
 	double		sum;
 	double		choice;
 	Vector	   *vec;
-	double	   *weight = palloc(samples->length * sizeof(double));
+	float	   *weight = palloc(samples->length * sizeof(float));
 	int			numCenters = centers->maxlen;
 	int			numSamples = samples->length;
 
@@ -66,7 +76,7 @@ InitCenters(Relation index, VectorArray samples, VectorArray centers, double *lo
 			break;
 
 		/* Choose new center using weighted probability distribution. */
-		choice = sum * (((double) random()) / MAX_RANDOM_VALUE);
+		choice = sum * RandomDouble();
 		for (j = 0; j < numSamples - 1; j++)
 		{
 			choice -= weight[j];
@@ -121,15 +131,18 @@ QuickCenters(Relation index, VectorArray samples, VectorArray centers)
 	FmgrInfo   *normprocinfo = IvfflatOptionalProcInfo(index, IVFFLAT_KMEANS_NORM_PROC);
 
 	/* Copy existing vectors while avoiding duplicates */
-	qsort(samples->items, samples->length, VECTOR_SIZE(samples->dim), CompareVectors);
-	for (i = 0; i < samples->length; i++)
+	if (samples->length > 0)
 	{
-		vec = VectorArrayGet(samples, i);
-
-		if (i == 0 || CompareVectors(vec, VectorArrayGet(samples, i - 1)) != 0)
+		qsort(samples->items, samples->length, VECTOR_SIZE(samples->dim), CompareVectors);
+		for (i = 0; i < samples->length; i++)
 		{
-			VectorArraySet(centers, centers->length, vec);
-			centers->length++;
+			vec = VectorArrayGet(samples, i);
+
+			if (i == 0 || CompareVectors(vec, VectorArrayGet(samples, i - 1)) != 0)
+			{
+				VectorArraySet(centers, centers->length, vec);
+				centers->length++;
+			}
 		}
 	}
 
@@ -142,7 +155,7 @@ QuickCenters(Relation index, VectorArray samples, VectorArray centers)
 		vec->dim = dimensions;
 
 		for (j = 0; j < dimensions; j++)
-			vec->x[j] = ((double) random()) / MAX_RANDOM_VALUE;
+			vec->x[j] = RandomDouble();
 
 		/* Normalize if needed (only needed for random centers) */
 		if (normprocinfo != NULL)
@@ -169,19 +182,19 @@ ElkanKmeans(Relation index, VectorArray samples, VectorArray centers)
 	Vector	   *vec;
 	Vector	   *newCenter;
 	int			iteration;
-	int			j;
-	int			k;
+	int64		j;
+	int64		k;
 	int			dimensions = centers->dim;
 	int			numCenters = centers->maxlen;
 	int			numSamples = samples->length;
 	VectorArray newCenters;
 	int		   *centerCounts;
 	int		   *closestCenters;
-	double	   *lowerBound;
-	double	   *upperBound;
-	double	   *s;
-	double	   *halfcdist;
-	double	   *newcdist;
+	float	   *lowerBound;
+	float	   *upperBound;
+	float	   *s;
+	float	   *halfcdist;
+	float	   *newcdist;
 	int			changes;
 	double		minDistance;
 	int			closestCenter;
@@ -191,19 +204,47 @@ ElkanKmeans(Relation index, VectorArray samples, VectorArray centers)
 	double		dxcx;
 	double		dxc;
 
+	/* Calculate allocation sizes */
+	Size		samplesSize = VECTOR_ARRAY_SIZE(samples->maxlen, samples->dim);
+	Size		centersSize = VECTOR_ARRAY_SIZE(centers->maxlen, centers->dim);
+	Size		newCentersSize = VECTOR_ARRAY_SIZE(numCenters, dimensions);
+	Size		centerCountsSize = sizeof(int) * numCenters;
+	Size		closestCentersSize = sizeof(int) * numSamples;
+	Size		lowerBoundSize = sizeof(float) * numSamples * numCenters;
+	Size		upperBoundSize = sizeof(float) * numSamples;
+	Size		sSize = sizeof(float) * numCenters;
+	Size		halfcdistSize = sizeof(float) * numCenters * numCenters;
+	Size		newcdistSize = sizeof(float) * numCenters;
+
+	/* Calculate total size */
+	Size		totalSize = samplesSize + centersSize + newCentersSize + centerCountsSize + closestCentersSize + lowerBoundSize + upperBoundSize + sSize + halfcdistSize + newcdistSize;
+
+	/* Check memory requirements */
+	/* Add one to error message to ceil */
+	if (totalSize / 1024 > maintenance_work_mem)
+		ereport(ERROR,
+				(errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
+				 errmsg("memory required is %zu MB, maintenance_work_mem is %d MB",
+						totalSize / (1024 * 1024) + 1, maintenance_work_mem / 1024)));
+
+	/* Ensure indexing does not overflow */
+	if (numCenters * numCenters > INT_MAX)
+		elog(ERROR, "Indexing overflow detected. Please report a bug.");
+
 	/* Set support functions */
 	procinfo = index_getprocinfo(index, 1, IVFFLAT_KMEANS_DISTANCE_PROC);
 	normprocinfo = IvfflatOptionalProcInfo(index, IVFFLAT_KMEANS_NORM_PROC);
 	collation = index->rd_indcollation[0];
 
 	/* Allocate space */
-	centerCounts = palloc(sizeof(int) * numCenters);
-	closestCenters = palloc(sizeof(int) * numSamples);
-	lowerBound = palloc(sizeof(double) * numSamples * numCenters);
-	upperBound = palloc(sizeof(double) * numSamples);
-	s = palloc(sizeof(double) * numCenters);
-	halfcdist = palloc(sizeof(double) * numCenters * numCenters);
-	newcdist = palloc(sizeof(double) * numCenters);
+	/* Use float instead of double to save memory */
+	centerCounts = palloc(centerCountsSize);
+	closestCenters = palloc(closestCentersSize);
+	lowerBound = palloc_extended(lowerBoundSize, MCXT_ALLOC_HUGE);
+	upperBound = palloc(upperBoundSize);
+	s = palloc(sSize);
+	halfcdist = palloc(halfcdistSize);
+	newcdist = palloc(newcdistSize);
 
 	newCenters = VectorArrayInit(numCenters, dimensions);
 	for (j = 0; j < numCenters; j++)
@@ -222,8 +263,6 @@ ElkanKmeans(Relation index, VectorArray samples, VectorArray centers)
 		minDistance = DBL_MAX;
 		closestCenter = -1;
 
-		vec = VectorArrayGet(samples, j);
-
 		/* Find closest center */
 		for (k = 0; k < numCenters; k++)
 		{
@@ -376,7 +415,7 @@ ElkanKmeans(Relation index, VectorArray samples, VectorArray centers)
 			{
 				/* TODO Handle empty centers properly */
 				for (k = 0; k < dimensions; k++)
-					vec->x[k] = ((double) random()) / MAX_RANDOM_VALUE;
+					vec->x[k] = RandomDouble();
 			}
 
 			/* Normalize if needed */

src/ivfscan.c

@@ -1,5 +1,7 @@
 #include "postgres.h"
 
+#include <float.h>
+
 #include "access/relscan.h"
 #include "ivfflat.h"
 #include "miscadmin.h"
@@ -17,14 +19,12 @@
  * Compare list distances
  */
 static int
-CompareLists(const void *a, const void *b)
+CompareLists(const pairingheap_node *a, const pairingheap_node *b, void *arg)
 {
-	double		diff = (((IvfflatScanList *) a)->distance - ((IvfflatScanList *) b)->distance);
-
-	if (diff > 0)
+	if (((const IvfflatScanList *) a)->distance > ((const IvfflatScanList *) b)->distance)
 		return 1;
 
-	if (diff < 0)
+	if (((const IvfflatScanList *) a)->distance < ((const IvfflatScanList *) b)->distance)
 		return -1;
 
 	return 0;
@@ -45,6 +45,8 @@ GetScanLists(IndexScanDesc scan, Datum value)
 	int			listCount = 0;
 	IvfflatScanOpaque so = (IvfflatScanOpaque) scan->opaque;
 	double		distance;
+	IvfflatScanList *scanlist;
+	double		maxDistance = DBL_MAX;
 
 	/* Search all list pages */
 	while (BlockNumberIsValid(nextblkno))
@@ -62,21 +64,39 @@ GetScanLists(IndexScanDesc scan, Datum value)
 			/* Use procinfo from the index instead of scan key for performance */
 			distance = DatumGetFloat8(FunctionCall2Coll(so->procinfo, so->collation, PointerGetDatum(&list->center), value));
 
-			so->lists[listCount].startPage = list->startPage;
-			so->lists[listCount].distance = distance;
-			listCount++;
+			if (listCount < so->probes)
+			{
+				scanlist = &so->lists[listCount];
+				scanlist->startPage = list->startPage;
+				scanlist->distance = distance;
+				listCount++;
+
+				/* Add to heap */
+				pairingheap_add(so->listQueue, &scanlist->ph_node);
+
+				/* Calculate max distance */
+				if (listCount == so->probes)
+					maxDistance = ((IvfflatScanList *) pairingheap_first(so->listQueue))->distance;
+			}
+			else if (distance < maxDistance)
+			{
+				/* Remove */
+				scanlist = (IvfflatScanList *) pairingheap_remove_first(so->listQueue);
+
+				/* Reuse */
+				scanlist->startPage = list->startPage;
+				scanlist->distance = distance;
+				pairingheap_add(so->listQueue, &scanlist->ph_node);
+
+				/* Update max distance */
+				maxDistance = ((IvfflatScanList *) pairingheap_first(so->listQueue))->distance;
+			}
 		}
 
 		nextblkno = IvfflatPageGetOpaque(cpage)->nextblkno;
 
 		UnlockReleaseBuffer(cbuf);
 	}
-
-	/* Sort by distance */
-	qsort(so->lists, listCount, sizeof(IvfflatScanList), CompareLists);
-
-	if (so->probes > listCount)
-		so->probes = listCount;
 }
 
 /*
@@ -94,7 +114,6 @@ GetScanItems(IndexScanDesc scan, Datum value)
 	OffsetNumber maxoffno;
 	Datum		datum;
 	bool		isnull;
-	int			i;
 	TupleDesc	tupdesc = RelationGetDescr(scan->indexRelation);
 
 #if PG_VERSION_NUM >= 120000
@@ -111,9 +130,9 @@ GetScanItems(IndexScanDesc scan, Datum value)
 	BufferAccessStrategy bas = GetAccessStrategy(BAS_BULKREAD);
 
 	/* Search closest probes lists */
-	for (i = 0; i < so->probes; i++)
+	while (!pairingheap_is_empty(so->listQueue))
 	{
-		searchPage = so->lists[i].startPage;
+		searchPage = ((IvfflatScanList *) pairingheap_remove_first(so->listQueue))->startPage;
 
 		/* Search all entry pages for list */
 		while (BlockNumberIsValid(searchPage))
@@ -137,12 +156,10 @@ GetScanItems(IndexScanDesc scan, Datum value)
 				ExecClearTuple(slot);
 				slot->tts_values[0] = FunctionCall2Coll(so->procinfo, so->collation, datum, value);
 				slot->tts_isnull[0] = false;
-				slot->tts_values[1] = Int32GetDatum((int) ItemPointerGetBlockNumberNoCheck(&itup->t_tid));
+				slot->tts_values[1] = PointerGetDatum(&itup->t_tid);
 				slot->tts_isnull[1] = false;
-				slot->tts_values[2] = Int32GetDatum((int) ItemPointerGetOffsetNumberNoCheck(&itup->t_tid));
+				slot->tts_values[2] = Int32GetDatum((int) searchPage);
 				slot->tts_isnull[2] = false;
-				slot->tts_values[3] = Int32GetDatum((int) searchPage);
-				slot->tts_isnull[3] = false;
 				ExecStoreVirtualTuple(slot);
 
 				tuplesort_puttupleslot(so->sortstate, slot);
@@ -153,6 +170,8 @@ GetScanItems(IndexScanDesc scan, Datum value)
 			UnlockReleaseBuffer(buf);
 		}
 	}
+
+	tuplesort_performsort(so->sortstate);
 }
 
 /*
@@ -168,13 +187,18 @@ ivfflatbeginscan(Relation index, int nkeys, int norderbys)
 	Oid			sortOperators[] = {Float8LessOperator};
 	Oid			sortCollations[] = {InvalidOid};
 	bool		nullsFirstFlags[] = {false};
+	int			probes = ivfflat_probes;
 
 	scan = RelationGetIndexScan(index, nkeys, norderbys);
 	lists = IvfflatGetLists(scan->indexRelation);
 
-	so = (IvfflatScanOpaque) palloc(offsetof(IvfflatScanOpaqueData, lists) + lists * sizeof(IvfflatScanList));
+	if (probes > lists)
+		probes = lists;
+
+	so = (IvfflatScanOpaque) palloc(offsetof(IvfflatScanOpaqueData, lists) + probes * sizeof(IvfflatScanList));
 	so->buf = InvalidBuffer;
 	so->first = true;
+	so->probes = probes;
 
 	/* Set support functions */
 	so->procinfo = index_getprocinfo(index, 1, IVFFLAT_DISTANCE_PROC);
@@ -183,14 +207,13 @@ ivfflatbeginscan(Relation index, int nkeys, int norderbys)
 
 	/* Create tuple description for sorting */
 #if PG_VERSION_NUM >= 120000
-	so->tupdesc = CreateTemplateTupleDesc(4);
+	so->tupdesc = CreateTemplateTupleDesc(3);
 #else
-	so->tupdesc = CreateTemplateTupleDesc(4, false);
+	so->tupdesc = CreateTemplateTupleDesc(3, false);
 #endif
 	TupleDescInitEntry(so->tupdesc, (AttrNumber) 1, "distance", FLOAT8OID, -1, 0);
-	TupleDescInitEntry(so->tupdesc, (AttrNumber) 2, "blkno", INT4OID, -1, 0);
-	TupleDescInitEntry(so->tupdesc, (AttrNumber) 3, "offset", INT4OID, -1, 0);
-	TupleDescInitEntry(so->tupdesc, (AttrNumber) 4, "indexblkno", INT4OID, -1, 0);
+	TupleDescInitEntry(so->tupdesc, (AttrNumber) 2, "tid", TIDOID, -1, 0);
+	TupleDescInitEntry(so->tupdesc, (AttrNumber) 3, "indexblkno", INT4OID, -1, 0);
 
 	/* Prep sort */
 #if PG_VERSION_NUM >= 110000
@@ -205,6 +228,8 @@ ivfflatbeginscan(Relation index, int nkeys, int norderbys)
 	so->slot = MakeSingleTupleTableSlot(so->tupdesc);
 #endif
 
+	so->listQueue = pairingheap_allocate(CompareLists, scan);
+
 	scan->opaque = so;
 
 	return scan;
@@ -224,7 +249,7 @@ ivfflatrescan(IndexScanDesc scan, ScanKey keys, int nkeys, ScanKey orderbys, int
 #endif
 
 	so->first = true;
-	so->probes = ivfflat_probes;
+	pairingheap_reset(so->listQueue);
 
 	if (keys && scan->numberOfKeys > 0)
 		memmove(scan->keyData, keys, scan->numberOfKeys * sizeof(ScanKeyData));
@@ -251,6 +276,10 @@ ivfflatgettuple(IndexScanDesc scan, ScanDirection dir)
 	{
 		Datum		value;
 
+		/* Safety check */
+		if (scan->orderByData == NULL)
+			elog(ERROR, "cannot scan ivfflat index without order");
+
 		/* No items will match if null */
 		if (scan->orderByData->sk_flags & SK_ISNULL)
 			return false;
@@ -264,9 +293,8 @@ ivfflatgettuple(IndexScanDesc scan, ScanDirection dir)
 				return false;
 		}
 
-		GetScanLists(scan, value);
-		GetScanItems(scan, value);
-		tuplesort_performsort(so->sortstate);
+		IvfflatBench("GetScanLists", GetScanLists(scan, value));
+		IvfflatBench("GetScanItems", GetScanItems(scan, value));
 		so->first = false;
 
 		/* Clean up if we allocated a new value */
@@ -280,14 +308,13 @@ ivfflatgettuple(IndexScanDesc scan, ScanDirection dir)
 	if (tuplesort_gettupleslot(so->sortstate, true, so->slot, NULL))
 #endif
 	{
-		BlockNumber blkno = DatumGetInt32(slot_getattr(so->slot, 2, &so->isnull));
-		OffsetNumber offset = DatumGetInt32(slot_getattr(so->slot, 3, &so->isnull));
-		BlockNumber indexblkno = DatumGetInt32(slot_getattr(so->slot, 4, &so->isnull));
+		ItemPointer tid = (ItemPointer) DatumGetPointer(slot_getattr(so->slot, 2, &so->isnull));
+		BlockNumber indexblkno = DatumGetInt32(slot_getattr(so->slot, 3, &so->isnull));
 
 #if PG_VERSION_NUM >= 120000
-		ItemPointerSet(&scan->xs_heaptid, blkno, offset);
+		scan->xs_heaptid = *tid;
 #else
-		ItemPointerSet(&scan->xs_ctup.t_self, blkno, offset);
+		scan->xs_ctup.t_self = *tid;
 #endif
 
 		if (BufferIsValid(so->buf))
@@ -320,6 +347,7 @@ ivfflatendscan(IndexScanDesc scan)
 	if (BufferIsValid(so->buf))
 		ReleaseBuffer(so->buf);
 
+	pairingheap_free(so->listQueue);
 	tuplesort_end(so->sortstate);
 
 	pfree(so);

src/ivfutils.c

@@ -107,13 +107,22 @@ IvfflatNewBuffer(Relation index, ForkNumber forkNum)
  * Init page
  */
 void
-IvfflatInitPage(Relation index, Buffer *buf, Page *page, GenericXLogState **state)
+IvfflatInitPage(Buffer buf, Page page)
+{
+	PageInit(page, BufferGetPageSize(buf), sizeof(IvfflatPageOpaqueData));
+	IvfflatPageGetOpaque(page)->nextblkno = InvalidBlockNumber;
+	IvfflatPageGetOpaque(page)->page_id = IVFFLAT_PAGE_ID;
+}
+
+/*
+ * Init and register page
+ */
+void
+IvfflatInitRegisterPage(Relation index, Buffer *buf, Page *page, GenericXLogState **state)
 {
 	*state = GenericXLogStart(index);
 	*page = GenericXLogRegisterBuffer(*state, *buf, GENERIC_XLOG_FULL_IMAGE);
-	PageInit(*page, BufferGetPageSize(*buf), sizeof(IvfflatPageOpaqueData));
-	IvfflatPageGetOpaque(*page)->nextblkno = InvalidBlockNumber;
-	IvfflatPageGetOpaque(*page)->page_id = IVFFLAT_PAGE_ID;
+	IvfflatInitPage(*buf, *page);
 }
 
 /*
@@ -135,17 +144,27 @@ IvfflatCommitBuffer(Buffer buf, GenericXLogState *state)
 void
 IvfflatAppendPage(Relation index, Buffer *buf, Page *page, GenericXLogState **state, ForkNumber forkNum)
 {
-	Buffer		prevbuf = *buf;
-
 	/* Get new buffer */
-	*buf = IvfflatNewBuffer(index, forkNum);
+	Buffer		newbuf = IvfflatNewBuffer(index, forkNum);
+	Page		newpage = GenericXLogRegisterBuffer(*state, newbuf, GENERIC_XLOG_FULL_IMAGE);
 
-	/* Update and commit previous buffer */
-	IvfflatPageGetOpaque(*page)->nextblkno = BufferGetBlockNumber(*buf);
-	IvfflatCommitBuffer(prevbuf, *state);
+	/* Update the previous buffer */
+	IvfflatPageGetOpaque(*page)->nextblkno = BufferGetBlockNumber(newbuf);
 
 	/* Init new page */
-	IvfflatInitPage(index, buf, page, state);
+	IvfflatInitPage(newbuf, newpage);
+
+	/* Commit */
+	MarkBufferDirty(*buf);
+	MarkBufferDirty(newbuf);
+	GenericXLogFinish(*state);
+
+	/* Unlock */
+	UnlockReleaseBuffer(*buf);
+
+	*state = GenericXLogStart(index);
+	*page = GenericXLogRegisterBuffer(*state, newbuf, GENERIC_XLOG_FULL_IMAGE);
+	*buf = newbuf;
 }
 
 /*
@@ -153,11 +172,13 @@ IvfflatAppendPage(Relation index, Buffer *buf, Page *page, GenericXLogState **st
  */
 void
 IvfflatUpdateList(Relation index, GenericXLogState *state, ListInfo listInfo,
-				  BlockNumber insertPage, BlockNumber startPage, ForkNumber forkNum)
+				  BlockNumber insertPage, BlockNumber originalInsertPage,
+				  BlockNumber startPage, ForkNumber forkNum)
 {
 	Buffer		buf;
 	Page		page;
 	IvfflatList list;
+	bool		changed = false;
 
 	buf = ReadBufferExtended(index, forkNum, listInfo.blkno, RBM_NORMAL, NULL);
 	LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
@@ -165,12 +186,29 @@ IvfflatUpdateList(Relation index, GenericXLogState *state, ListInfo listInfo,
 	page = GenericXLogRegisterBuffer(state, buf, 0);
 	list = (IvfflatList) PageGetItem(page, PageGetItemId(page, listInfo.offno));
 
-	if (BlockNumberIsValid(insertPage))
-		list->insertPage = insertPage;
+	if (BlockNumberIsValid(insertPage) && insertPage != list->insertPage)
+	{
+		/* Skip update if insert page is lower than original insert page  */
+		/* This is needed to prevent insert from overwriting vacuum */
+		if (!BlockNumberIsValid(originalInsertPage) || insertPage >= originalInsertPage)
+		{
+			list->insertPage = insertPage;
+			changed = true;
+		}
+	}
 
-	if (BlockNumberIsValid(startPage))
+	if (BlockNumberIsValid(startPage) && startPage != list->startPage)
+	{
 		list->startPage = startPage;
+		changed = true;
+	}
 
-	/* Could only commit if changed, but extra complexity isn't needed */
-	IvfflatCommitBuffer(buf, state);
+	/* Only commit if changed */
+	if (changed)
+		IvfflatCommitBuffer(buf, state);
+	else
+	{
+		GenericXLogAbort(state);
+		UnlockReleaseBuffer(buf);
+	}
 }

src/ivfvacuum.c

@@ -21,7 +21,7 @@ ivfflatbulkdelete(IndexVacuumInfo *info, IndexBulkDeleteResult *stats,
 	ItemPointer htup;
 	OffsetNumber deletable[MaxOffsetNumber];
 	int			ndeletable;
-	OffsetNumber startPages[MaxOffsetNumber];
+	BlockNumber startPages[MaxOffsetNumber];
 	BlockNumber nextblkno = IVFFLAT_HEAD_BLKNO;
 	BlockNumber searchPage;
 	BlockNumber insertPage;
@@ -98,6 +98,11 @@ ivfflatbulkdelete(IndexVacuumInfo *info, IndexBulkDeleteResult *stats,
 						stats->num_index_tuples++;
 				}
 
+				/* Set to first free page */
+				/* Must be set before searchPage is updated */
+				if (!BlockNumberIsValid(insertPage) && ndeletable > 0)
+					insertPage = searchPage;
+
 				searchPage = IvfflatPageGetOpaque(page)->nextblkno;
 
 				if (ndeletable > 0)
@@ -106,10 +111,6 @@ ivfflatbulkdelete(IndexVacuumInfo *info, IndexBulkDeleteResult *stats,
 					PageIndexMultiDelete(page, deletable, ndeletable);
 					MarkBufferDirty(buf);
 					GenericXLogFinish(state);
-
-					/* Set to first free page */
-					if (!BlockNumberIsValid(insertPage))
-						insertPage = searchPage;
 				}
 				else
 					GenericXLogAbort(state);
@@ -123,10 +124,10 @@ ivfflatbulkdelete(IndexVacuumInfo *info, IndexBulkDeleteResult *stats,
 			 * We don't add or delete items from lists pages, so offset won't
 			 * change.
 			 */
-			if (!BlockNumberIsValid(insertPage))
+			if (BlockNumberIsValid(insertPage))
 			{
 				listInfo.offno = coffno;
-				IvfflatUpdateList(index, state, listInfo, insertPage, InvalidBlockNumber, MAIN_FORKNUM);
+				IvfflatUpdateList(index, state, listInfo, insertPage, InvalidBlockNumber, InvalidBlockNumber, MAIN_FORKNUM);
 			}
 		}
 	}

src/vector.c

@@ -6,14 +6,20 @@
 #include "fmgr.h"
 #include "catalog/pg_type.h"
 #include "lib/stringinfo.h"
+#include "libpq/pqformat.h"
 #include "utils/array.h"
 #include "utils/builtins.h"
 #include "utils/lsyscache.h"
+#include "utils/numeric.h"
 
 #if PG_VERSION_NUM >= 120000
 #include "utils/float.h"
 #endif
 
+#if PG_VERSION_NUM < 130000
+#define TYPALIGN_INT 'i'
+#endif
+
 PG_MODULE_MAGIC;
 
 /*
@@ -40,6 +46,21 @@ CheckExpectedDim(int32 typmod, int dim)
 				 errmsg("expected %d dimensions, not %d", typmod, dim)));
 }
 
+
+static inline void
+CheckDim(int dim)
+{
+	if (dim < 1)
+		ereport(ERROR,
+				(errcode(ERRCODE_DATA_EXCEPTION),
+				 errmsg("vector must have at least 1 dimension")));
+
+	if (dim > VECTOR_MAX_DIM)
+		ereport(ERROR,
+				(errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
+				 errmsg("vector cannot have more than %d dimensions", VECTOR_MAX_DIM)));
+}
+
 /*
  * Ensure finite elements
  */
@@ -217,6 +238,58 @@ vector_typmod_in(PG_FUNCTION_ARGS)
 	PG_RETURN_INT32(*tl);
 }
 
+/*
+ * Convert external binary representation to internal representation
+ */
+PG_FUNCTION_INFO_V1(vector_recv);
+Datum
+vector_recv(PG_FUNCTION_ARGS)
+{
+	StringInfo	buf = (StringInfo) PG_GETARG_POINTER(0);
+	int32		typmod = PG_GETARG_INT32(2);
+	Vector	   *result;
+	int16		dim;
+	int16		unused;
+	int			i;
+
+	dim = pq_getmsgint(buf, sizeof(int16));
+	unused = pq_getmsgint(buf, sizeof(int16));
+
+	CheckDim(dim);
+	CheckExpectedDim(typmod, dim);
+
+	if (unused != 0)
+		ereport(ERROR,
+				(errcode(ERRCODE_DATA_EXCEPTION),
+				 errmsg("expected unused to be 0, not %d", unused)));
+
+	result = InitVector(dim);
+	for (i = 0; i < dim; i++)
+		result->x[i] = pq_getmsgfloat4(buf);
+
+	PG_RETURN_POINTER(result);
+}
+
+/*
+ * Convert internal representation to the external binary representation
+ */
+PG_FUNCTION_INFO_V1(vector_send);
+Datum
+vector_send(PG_FUNCTION_ARGS)
+{
+	Vector	   *vec = PG_GETARG_VECTOR_P(0);
+	StringInfoData buf;
+	int			i;
+
+	pq_begintypsend(&buf);
+	pq_sendint(&buf, vec->dim, sizeof(int16));
+	pq_sendint(&buf, vec->unused, sizeof(int16));
+	for (i = 0; i < vec->dim; i++)
+		pq_sendfloat4(&buf, vec->x[i]);
+
+	PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
+}
+
 /*
  * Convert vector to vector
  */
@@ -259,17 +332,7 @@ array_to_vector(PG_FUNCTION_ARGS)
 	deconstruct_array(array, ARR_ELEMTYPE(array), typlen, typbyval, typalign, &elemsp, &nullsp, &nelemsp);
 
 	if (typmod == -1)
-	{
-		if (nelemsp < 1)
-			ereport(ERROR,
-					(errcode(ERRCODE_DATA_EXCEPTION),
-					 errmsg("vector must have at least 1 dimension")));
-
-		if (nelemsp > VECTOR_MAX_DIM)
-			ereport(ERROR,
-					(errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
-					 errmsg("vector cannot have more than %d dimensions", VECTOR_MAX_DIM)));
-	}
+		CheckDim(nelemsp);
 	else
 		CheckExpectedDim(typmod, nelemsp);
 
@@ -287,6 +350,8 @@ array_to_vector(PG_FUNCTION_ARGS)
 			result->x[i] = DatumGetFloat8(elemsp[i]);
 		else if (ARR_ELEMTYPE(array) == FLOAT4OID)
 			result->x[i] = DatumGetFloat4(elemsp[i]);
+		else if (ARR_ELEMTYPE(array) == NUMERICOID)
+			result->x[i] = DatumGetFloat4(DirectFunctionCall1(numeric_float4, NumericGetDatum(elemsp[i])));
 		else
 			ereport(ERROR,
 					(errcode(ERRCODE_DATA_EXCEPTION),
@@ -298,6 +363,29 @@ array_to_vector(PG_FUNCTION_ARGS)
 	PG_RETURN_POINTER(result);
 }
 
+/*
+ * Convert vector to float4[]
+ */
+PG_FUNCTION_INFO_V1(vector_to_float4);
+Datum
+vector_to_float4(PG_FUNCTION_ARGS)
+{
+	Vector	   *vec = PG_GETARG_VECTOR_P(0);
+	Datum	   *d;
+	ArrayType  *result;
+	int			i;
+
+	d = (Datum *) palloc(sizeof(Datum) * vec->dim);
+
+	for (i = 0; i < vec->dim; i++)
+		d[i] = Float4GetDatum(vec->x[i]);
+
+	/* Use TYPALIGN_INT for float4 */
+	result = construct_array(d, vec->dim, FLOAT4OID, sizeof(float4), true, TYPALIGN_INT);
+
+	PG_RETURN_POINTER(result);
+}
+
 /*
  * Get the L2 distance between vectors
  */
@@ -308,11 +396,15 @@ l2_distance(PG_FUNCTION_ARGS)
 	Vector	   *a = PG_GETARG_VECTOR_P(0);
 	Vector	   *b = PG_GETARG_VECTOR_P(1);
 	double		distance = 0.0;
+	double		diff;
 
 	CheckDims(a, b);
 
 	for (int i = 0; i < a->dim; i++)
-		distance += pow(a->x[i] - b->x[i], 2);
+	{
+		diff = a->x[i] - b->x[i];
+		distance += diff * diff;
+	}
 
 	PG_RETURN_FLOAT8(sqrt(distance));
 }
@@ -328,11 +420,15 @@ vector_l2_squared_distance(PG_FUNCTION_ARGS)
 	Vector	   *a = PG_GETARG_VECTOR_P(0);
 	Vector	   *b = PG_GETARG_VECTOR_P(1);
 	double		distance = 0.0;
+	double		diff;
 
 	CheckDims(a, b);
 
 	for (int i = 0; i < a->dim; i++)
-		distance += pow(a->x[i] - b->x[i], 2);
+	{
+		diff = a->x[i] - b->x[i];
+		distance += diff * diff;
+	}
 
 	PG_RETURN_FLOAT8(distance);
 }
@@ -393,8 +489,8 @@ cosine_distance(PG_FUNCTION_ARGS)
 	for (int i = 0; i < a->dim; i++)
 	{
 		distance += a->x[i] * b->x[i];
-		norma += pow(a->x[i], 2);
-		normb += pow(b->x[i], 2);
+		norma += a->x[i] * a->x[i];
+		normb += b->x[i] * b->x[i];
 	}
 
 	PG_RETURN_FLOAT8(1 - (distance / (sqrt(norma) * sqrt(normb))));
@@ -450,7 +546,7 @@ vector_norm(PG_FUNCTION_ARGS)
 	double		norm = 0.0;
 
 	for (int i = 0; i < a->dim; i++)
-		norm += pow(a->x[i], 2);
+		norm += a->x[i] * a->x[i];
 
 	PG_RETURN_FLOAT8(sqrt(norm));
 }

test/expected/cast.out

@@ -6,6 +6,12 @@ SELECT ARRAY[1,2,3]::vector;
  [1,2,3]
 (1 row)
 
+SELECT ARRAY[1.0,2.0,3.0]::vector;
+  array  
+---------
+ [1,2,3]
+(1 row)
+
 SELECT ARRAY[1,2,3]::float4[]::vector;
   array  
 ---------
@@ -28,3 +34,18 @@ SELECT '{-Infinity}'::real[]::vector;
 ERROR:  infinite value not allowed in vector
 SELECT '{}'::real[]::vector;
 ERROR:  vector must have at least 1 dimension
+SELECT '[1,2,3]'::vector::real[];
+ float4  
+---------
+ {1,2,3}
+(1 row)
+
+SELECT array_agg(n)::vector FROM generate_series(1, 1025) n;
+ERROR:  vector cannot have more than 1024 dimensions
+-- ensure no error
+SELECT ARRAY[1,2,3] = ARRAY[1,2,3];
+ ?column? 
+----------
+ t
+(1 row)
+

test/expected/copy.out

@@ -0,0 +1,18 @@
+SET client_min_messages = warning;
+CREATE EXTENSION IF NOT EXISTS vector;
+CREATE TABLE t (val vector(3));
+INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
+CREATE TABLE t2 (val vector(3));
+\copy t TO '/tmp/data.bin' WITH (FORMAT binary)
+\copy t2 FROM '/tmp/data.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;

test/expected/input.out

@@ -53,3 +53,12 @@ LINE 1: SELECT '[1,]'::vector;
                ^
 SELECT '[1,2,3]'::vector(2);
 ERROR:  expected 2 dimensions, not 3
+SELECT unnest('{"[1,2,3]", "[4,5,6]"}'::vector[]);
+ unnest  
+---------
+ [1,2,3]
+ [4,5,6]
+(2 rows)
+
+SELECT '{"[1,2,3]"}'::vector(2)[];
+ERROR:  expected 2 dimensions, not 3

test/expected/ivfflat_l2.out

@@ -19,4 +19,10 @@ SELECT * FROM t ORDER BY val <-> (SELECT NULL::vector);
 -----
 (0 rows)
 
+SELECT COUNT(*) FROM t;
+ count 
+-------
+     5
+(1 row)
+
 DROP TABLE t;

test/expected/ivfflat_options.out

@@ -0,0 +1,17 @@
+SET client_min_messages = warning;
+CREATE EXTENSION IF NOT EXISTS vector;
+SET enable_seqscan = off;
+CREATE TABLE t (val vector(3));
+CREATE INDEX ON t USING ivfflat (val) WITH (lists = 0);
+ERROR:  value 0 out of bounds for option "lists"
+DETAIL:  Valid values are between "1" and "32768".
+CREATE INDEX ON t USING ivfflat (val) WITH (lists = 32769);
+ERROR:  value 32769 out of bounds for option "lists"
+DETAIL:  Valid values are between "1" and "32768".
+SHOW ivfflat.probes;
+ ivfflat.probes 
+----------------
+ 1
+(1 row)
+
+DROP TABLE t;

test/perl/PostgresNode.pm

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

test/perl/TestLib.pm

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

test/sql/cast.sql

@@ -2,6 +2,7 @@ SET client_min_messages = warning;
 CREATE EXTENSION IF NOT EXISTS vector;
 
 SELECT ARRAY[1,2,3]::vector;
+SELECT ARRAY[1.0,2.0,3.0]::vector;
 SELECT ARRAY[1,2,3]::float4[]::vector;
 SELECT ARRAY[1,2,3]::float8[]::vector;
 SELECT '{NULL}'::real[]::vector;
@@ -9,3 +10,8 @@ SELECT '{NaN}'::real[]::vector;
 SELECT '{Infinity}'::real[]::vector;
 SELECT '{-Infinity}'::real[]::vector;
 SELECT '{}'::real[]::vector;
+SELECT '[1,2,3]'::vector::real[];
+SELECT array_agg(n)::vector FROM generate_series(1, 1025) n;
+
+-- ensure no error
+SELECT ARRAY[1,2,3] = ARRAY[1,2,3];

test/sql/copy.sql

@@ -0,0 +1,15 @@
+SET client_min_messages = warning;
+CREATE EXTENSION IF NOT EXISTS vector;
+
+CREATE TABLE t (val vector(3));
+INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
+
+CREATE TABLE t2 (val vector(3));
+
+\copy t TO '/tmp/data.bin' WITH (FORMAT binary)
+\copy t2 FROM '/tmp/data.bin' WITH (FORMAT binary)
+
+SELECT * FROM t2 ORDER BY val;
+
+DROP TABLE t;
+DROP TABLE t2;

test/sql/input.sql

@@ -0,0 +1,18 @@
+SET client_min_messages = warning;
+CREATE EXTENSION IF NOT EXISTS vector;
+
+SELECT '[1,2,3]'::vector;
+SELECT '[-1,2,3]'::vector;
+SELECT '[hello,1]'::vector;
+SELECT '[NaN,1]'::vector;
+SELECT '[Infinity,1]'::vector;
+SELECT '[-Infinity,1]'::vector;
+SELECT '[1,2,3'::vector;
+SELECT '[1,2,3]9'::vector;
+SELECT '1,2,3'::vector;
+SELECT '[]'::vector;
+SELECT '[1,]'::vector;
+SELECT '[1,2,3]'::vector(2);
+
+SELECT unnest('{"[1,2,3]", "[4,5,6]"}'::vector[]);
+SELECT '{"[1,2,3]"}'::vector(2)[];

test/sql/ivfflat_l2.sql

@@ -10,5 +10,6 @@ INSERT INTO t (val) VALUES ('[1,2,4]');
 
 SELECT * FROM t ORDER BY val <-> '[3,3,3]';
 SELECT * FROM t ORDER BY val <-> (SELECT NULL::vector);
+SELECT COUNT(*) FROM t;
 
 DROP TABLE t;

test/t/001_wal.pl

@@ -7,6 +7,8 @@ use PostgresNode;
 use TestLib;
 use Test::More tests => 31;
 
+my $dim = 32;
+
 my $node_primary;
 my $node_replica;
 
@@ -21,21 +23,25 @@ sub test_index_replay
 	my $caughtup_query;
 	my $server_version_num = $node_primary->safe_psql("postgres", "SHOW server_version_num");
 	if ($server_version_num >= 100000) {
-		$caughtup_query = "SELECT pg_current_wal_lsn() <= write_lsn FROM pg_stat_replication WHERE application_name = '$applname';";
+		$caughtup_query = "SELECT pg_current_wal_lsn() <= replay_lsn FROM pg_stat_replication WHERE application_name = '$applname';";
 	} else {
+		# TODO figure out why replay location doesn't work
 		$caughtup_query = "SELECT pg_current_xlog_location() <= write_location FROM pg_stat_replication WHERE application_name = '$applname';";
 	}
 
 	$node_primary->poll_query_until('postgres', $caughtup_query)
 	  or die "Timed out while waiting for replica 1 to catch up";
 
-	my $r1 = rand();
-	my $r2 = rand();
-	my $r3 = rand();
+	my @r = ();
+	for (1 .. $dim) {
+		push(@r, rand());
+	}
+	my $sql = join(",", @r);
 
-	my $queries = qq(SET enable_seqscan=off;
-SELECT * FROM tst ORDER BY v <-> '[$r1,$r2,$r3]' LIMIT 10;
-);
+	my $queries = qq(
+		SET enable_seqscan = off;
+		SELECT * FROM tst ORDER BY v <-> '[$sql]' LIMIT 10;
+	);
 
 	# Run test queries and compare their result
 	my $primary_result = $node_primary->safe_psql("postgres", $queries);
@@ -45,9 +51,18 @@ SELECT * FROM tst ORDER BY v <-> '[$r1,$r2,$r3]' LIMIT 10;
 	return;
 }
 
+# Use ARRAY[random(), random(), random(), ...] over
+# SELECT array_agg(random()) FROM generate_series(1, $dim)
+# to generate different values for each row
+my $array_sql = join(",", ('random()') x $dim);
+
 # Initialize primary node
 $node_primary = get_new_node('primary');
 $node_primary->init(allows_streaming => 1);
+if ($dim > 32) {
+	# TODO use wal_keep_segments for Postgres < 13
+	$node_primary->append_conf('postgresql.conf', qq(wal_keep_size = 1GB));
+}
 $node_primary->start;
 my $backup_name = 'my_backup';
 
@@ -62,12 +77,11 @@ $node_replica->start;
 
 # Create ivfflat index on primary
 $node_primary->safe_psql("postgres", "CREATE EXTENSION vector;");
-$node_primary->safe_psql("postgres", "CREATE TABLE tst (i int4, v vector(3));");
+$node_primary->safe_psql("postgres", "CREATE TABLE tst (i int4, v vector($dim));");
 $node_primary->safe_psql("postgres",
-	"INSERT INTO tst SELECT i%10, ARRAY[random(), random(), random()] FROM generate_series(1,100000) i;"
+	"INSERT INTO tst SELECT i % 10, ARRAY[$array_sql] FROM generate_series(1, 100000) i;"
 );
-$node_primary->safe_psql("postgres",
-	"CREATE INDEX ON tst USING ivfflat (v);");
+$node_primary->safe_psql("postgres", "CREATE INDEX ON tst USING ivfflat (v);");
 
 # Test that queries give same result
 test_index_replay('initial');
@@ -81,7 +95,7 @@ for my $i (1 .. 10)
 	test_index_replay("vacuum $i");
 	my ($start, $end) = (100001 + ($i - 1) * 10000, 100000 + $i * 10000);
 	$node_primary->safe_psql("postgres",
-		"INSERT INTO tst SELECT i%10, ARRAY[random(), random(), random()] FROM generate_series($start,$end) i;"
+		"INSERT INTO tst SELECT i % 10, ARRAY[$array_sql] FROM generate_series($start, $end) i;"
 	);
 	test_index_replay("insert $i");
 }

test/t/002_vacuum.pl

@@ -0,0 +1,32 @@
+use strict;
+use warnings;
+use PostgresNode;
+use TestLib;
+use Test::More tests => 1;
+
+# Initialize node
+my $node = get_new_node('node');
+$node->init;
+$node->start;
+
+# Create table and index
+$node->safe_psql("postgres", "CREATE EXTENSION vector;");
+$node->safe_psql("postgres", "CREATE TABLE tst (i int4, v vector(3));");
+$node->safe_psql("postgres",
+	"INSERT INTO tst SELECT i % 10, ARRAY[i % 1000, i % 333, i % 55] FROM generate_series(1, 100000) i;"
+);
+$node->safe_psql("postgres", "CREATE INDEX ON tst USING ivfflat (v);");
+
+# Get size
+my $size = $node->safe_psql("postgres", "SELECT pg_total_relation_size('tst_v_idx');");
+
+# 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 i % 10, ARRAY[i % 1000, i % 333, i % 55] FROM generate_series(1, 100000) i;"
+);
+
+# Check size
+my $new_size = $node->safe_psql("postgres", "SELECT pg_total_relation_size('tst_v_idx');");
+is($size, $new_size, "size does not change");

test/t/003_recall.pl

@@ -0,0 +1,88 @@
+use strict;
+use warnings;
+use PostgresNode;
+use TestLib;
+use Test::More tests => 9;
+
+my $node;
+my @queries = ();
+my @expected;
+my $limit = 20;
+
+sub test_recall
+{
+	my ($probes, $min, $operator) = @_;
+	my $correct = 0;
+	my $total = 0;
+
+	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 %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 = get_new_node('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(3));");
+$node->safe_psql("postgres",
+	"INSERT INTO tst SELECT i, ARRAY[random(), random(), random()] FROM generate_series(1, 100000) i;"
+);
+
+# Generate queries
+for (1..20) {
+	my $r1 = rand();
+	my $r2 = rand();
+	my $r3 = rand();
+	push(@queries, "[$r1,$r2,$r3]");
+}
+
+# Check each index type
+my @operators = ("<->", "<#>", "<=>");
+
+foreach (@operators) {
+	my $operator = $_;
+
+	# 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);
+	}
+
+	# Add index
+	my $opclass;
+	if ($operator == "<->") {
+		$opclass = "vector_l2_ops";
+	} elsif ($operator == "<#>") {
+		$opclass = "vector_ip_ops";
+	} else {
+		$opclass = "vector_cosine_ops";
+	}
+	$node->safe_psql("postgres", "CREATE INDEX ON tst USING ivfflat (v $opclass);");
+
+	# Test approximate results
+	test_recall(1, 0.75, $operator);
+	test_recall(10, 0.95, $operator);
+	test_recall(100, 1.0, $operator);
+}

test/t/004_centers.pl

@@ -0,0 +1,36 @@
+use strict;
+use warnings;
+use PostgresNode;
+use TestLib;
+use Test::More tests => 3;
+
+# Initialize node
+my $node = get_new_node('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(3));");
+$node->safe_psql("postgres",
+	"INSERT INTO tst SELECT i, '[1,2,3]' FROM generate_series(1, 10) i;"
+);
+
+sub test_centers
+{
+	my ($lists, $min) = @_;
+
+	my ($ret, $stdout, $stderr) = $node->psql("postgres", "CREATE INDEX ON tst USING ivfflat (v) WITH (lists = $lists);");
+	is($ret, 0, $stderr);
+}
+
+# Test no error for duplicate centers
+test_centers(5);
+test_centers(10);
+
+$node->safe_psql("postgres",
+	"INSERT INTO tst SELECT i, '[4,5,6]' FROM generate_series(1, 10) i;"
+);
+
+# Test no error for duplicate centers
+test_centers(10);

test/t/005_query_recall.pl

@@ -0,0 +1,45 @@
+use strict;
+use warnings;
+use PostgresNode;
+use TestLib;
+use Test::More tests => 60;
+
+# Initialize node
+my $node = get_new_node('node');
+$node->init;
+$node->start;
+
+# Create table
+$node->safe_psql("postgres", "CREATE EXTENSION vector;");
+$node->safe_psql("postgres", "CREATE TABLE tst (i int4 primary key, v vector(3));");
+$node->safe_psql("postgres",
+	"INSERT INTO tst SELECT i, ARRAY[random(), random(), random()] FROM generate_series(1, 100000) i;"
+);
+
+# Check each index type
+my @operators = ("<->", "<#>", "<=>");
+foreach (@operators) {
+	my $operator = $_;
+
+	# Add index
+	my $opclass;
+	if ($operator == "<->") {
+		$opclass = "vector_l2_ops";
+	} elsif ($operator == "<#>") {
+		$opclass = "vector_ip_ops";
+	} else {
+		$opclass = "vector_cosine_ops";
+	}
+	$node->safe_psql("postgres", "CREATE INDEX ON tst USING ivfflat (v $opclass);");
+
+	# Test 100% recall
+	for (1..20) {
+		my $i = int(rand() * 100000);
+		my $query = $node->safe_psql("postgres", "SELECT v FROM tst WHERE i = $i;");
+		my $res = $node->safe_psql("postgres", qq(
+			SET enable_seqscan = off;
+			SELECT v FROM tst ORDER BY v <-> '$query' LIMIT 1;
+		));
+		is($res, $query);
+	}
+}

test/t/006_lists.pl

@@ -0,0 +1,31 @@
+use strict;
+use warnings;
+use PostgresNode;
+use TestLib;
+use Test::More tests => 3;
+
+# Initialize node
+my $node = get_new_node('node');
+$node->init;
+$node->start;
+
+# Create table
+$node->safe_psql("postgres", "CREATE EXTENSION vector;");
+$node->safe_psql("postgres", "CREATE TABLE tst (v vector(3));");
+$node->safe_psql("postgres",
+	"INSERT INTO tst SELECT ARRAY[random(), random(), random()] FROM generate_series(1, 100000) i;"
+);
+
+$node->safe_psql("postgres", "CREATE INDEX lists50 ON tst USING ivfflat (v) WITH (lists = 50);");
+$node->safe_psql("postgres", "CREATE INDEX lists100 ON tst USING ivfflat (v) WITH (lists = 100);");
+
+# Test prefers more lists
+my $res = $node->safe_psql("postgres", "EXPLAIN SELECT v FROM tst ORDER BY v <-> '[0.5,0.5,0.5]' LIMIT 10;");
+like($res, qr/lists100/);
+unlike($res, qr/lists50/);
+
+# Test errors with too much memory
+my ($ret, $stdout, $stderr) = $node->psql("postgres",
+	"CREATE INDEX lists10000 ON tst USING ivfflat (v) WITH (lists = 10000);"
+);
+like($stderr, qr/memory required is/);

test/t/007_inserts.pl

@@ -0,0 +1,45 @@
+use strict;
+use warnings;
+use PostgresNode;
+use TestLib;
+use Test::More tests => 5;
+
+my $dim = 768;
+
+my $array_sql = join(",", ('random()') x $dim);
+
+# Initialize node
+my $node = get_new_node('node');
+$node->init;
+$node->start;
+
+# Create table and index
+$node->safe_psql("postgres", "CREATE EXTENSION vector;");
+$node->safe_psql("postgres", "CREATE TABLE tst (v vector($dim));");
+$node->safe_psql("postgres",
+	"INSERT INTO tst SELECT ARRAY[$array_sql] FROM generate_series(1, 10000) i;"
+);
+$node->safe_psql("postgres", "CREATE INDEX ON tst USING ivfflat (v);");
+
+$node->pgbench(
+	"--no-vacuum --client=5 --transactions=100",
+	0,
+	[qr{actually processed}],
+	[qr{^$}],
+	"concurrent INSERTs",
+	{
+		"007_inserts" => "INSERT INTO tst SELECT ARRAY[$array_sql] FROM generate_series(1, 10) i;"
+	}
+);
+
+my $expected = 10000 + 5 * 100 * 10;
+
+my $count = $node->safe_psql("postgres", "SELECT COUNT(*) FROM tst;");
+is($count, $expected);
+
+$count = $node->safe_psql("postgres", qq(
+	SET enable_seqscan = off;
+	SET ivfflat.probes = 100;
+	SELECT COUNT(*) FROM (SELECT v FROM tst ORDER BY v <-> (SELECT v FROM tst LIMIT 1)) t;
+));
+is($count, $expected);

vector--0.1.0.sql

@@ -1,210 +0,0 @@
--- complain if script is sourced in psql, rather than via CREATE EXTENSION
-\echo Use "CREATE EXTENSION vector" to load this file. \quit
-
--- type
-
-CREATE TYPE vector;
-
-CREATE FUNCTION vector_in(cstring, oid, integer) RETURNS vector
-	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT;
-
-CREATE FUNCTION vector_out(vector) RETURNS cstring
-	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT;
-
-CREATE FUNCTION vector_typmod_in(cstring[]) RETURNS integer
-	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT;
-
-CREATE TYPE vector (
-	INPUT     = vector_in,
-	OUTPUT    = vector_out,
-	TYPMOD_IN = vector_typmod_in
-);
-
--- functions
-
-CREATE FUNCTION l2_distance(vector, vector) RETURNS float8
-	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT;
-
-CREATE FUNCTION inner_product(vector, vector) RETURNS float8
-	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT;
-
-CREATE FUNCTION cosine_distance(vector, vector) RETURNS float8
-	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT;
-
-CREATE FUNCTION vector_dims(vector) RETURNS integer
-	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT;
-
-CREATE FUNCTION vector_norm(vector) RETURNS float8
-	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT;
-
-CREATE FUNCTION vector_add(vector, vector) RETURNS vector
-	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT;
-
-CREATE FUNCTION vector_sub(vector, vector) RETURNS vector
-	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT;
-
--- private functions
-
-CREATE FUNCTION vector_lt(vector, vector) RETURNS bool
-	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT;
-
-CREATE FUNCTION vector_le(vector, vector) RETURNS bool
-	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT;
-
-CREATE FUNCTION vector_eq(vector, vector) RETURNS bool
-	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT;
-
-CREATE FUNCTION vector_ne(vector, vector) RETURNS bool
-	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT;
-
-CREATE FUNCTION vector_ge(vector, vector) RETURNS bool
-	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT;
-
-CREATE FUNCTION vector_gt(vector, vector) RETURNS bool
-	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT;
-
-CREATE FUNCTION vector_cmp(vector, vector) RETURNS int4
-	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT;
-
-CREATE FUNCTION vector_l2_squared_distance(vector, vector) RETURNS float8
-	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT;
-
-CREATE FUNCTION vector_negative_inner_product(vector, vector) RETURNS float8
-	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT;
-
-CREATE FUNCTION vector_spherical_distance(vector, vector) RETURNS float8
-	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT;
-
--- cast functions
-
-CREATE FUNCTION vector(vector, integer, boolean) RETURNS vector
-	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT;
-
-CREATE FUNCTION array_to_vector(integer[], integer, boolean) RETURNS vector
-	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT;
-
-CREATE FUNCTION array_to_vector(real[], integer, boolean) RETURNS vector
-	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT;
-
-CREATE FUNCTION array_to_vector(double precision[], integer, boolean) RETURNS vector
-	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT;
-
--- casts
-
-CREATE CAST (vector AS vector)
-	WITH FUNCTION vector(vector, integer, boolean) AS IMPLICIT;
-
-CREATE CAST (integer[] AS vector)
-	WITH FUNCTION array_to_vector(integer[], integer, boolean) AS IMPLICIT;
-
-CREATE CAST (real[] AS vector)
-	WITH FUNCTION array_to_vector(real[], integer, boolean) AS IMPLICIT;
-
-CREATE CAST (double precision[] AS vector)
-	WITH FUNCTION array_to_vector(double precision[], integer, boolean) AS IMPLICIT;
-
--- operators
-
-CREATE OPERATOR <-> (
-	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = l2_distance,
-	COMMUTATOR = '<->'
-);
-
-CREATE OPERATOR <#> (
-	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = vector_negative_inner_product,
-	COMMUTATOR = '<#>'
-);
-
-CREATE OPERATOR <=> (
-	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = cosine_distance,
-	COMMUTATOR = '<=>'
-);
-
-CREATE OPERATOR + (
-	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = vector_add,
-	COMMUTATOR = +
-);
-
-CREATE OPERATOR - (
-	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = vector_sub,
-	COMMUTATOR = -
-);
-
-CREATE OPERATOR < (
-	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = vector_lt,
-	COMMUTATOR = > , NEGATOR = >= ,
-	RESTRICT = scalarltsel, JOIN = scalarltjoinsel
-);
-
--- should use scalarlesel and scalarlejoinsel, but not supported in Postgres < 11
-CREATE OPERATOR <= (
-	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = vector_le,
-	COMMUTATOR = >= , NEGATOR = > ,
-	RESTRICT = scalarltsel, JOIN = scalarltjoinsel
-);
-
-CREATE OPERATOR = (
-	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = vector_eq,
-	COMMUTATOR = = , NEGATOR = <> ,
-	RESTRICT = eqsel, JOIN = eqjoinsel
-);
-
-CREATE OPERATOR <> (
-	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = vector_ne,
-	COMMUTATOR = <> , NEGATOR = = ,
-	RESTRICT = eqsel, JOIN = eqjoinsel
-);
-
--- should use scalargesel and scalargejoinsel, but not supported in Postgres < 11
-CREATE OPERATOR >= (
-	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = vector_ge,
-	COMMUTATOR = <= , NEGATOR = < ,
-	RESTRICT = scalargtsel, JOIN = scalargtjoinsel
-);
-
-CREATE OPERATOR > (
-	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = vector_gt,
-	COMMUTATOR = < , NEGATOR = <= ,
-	RESTRICT = scalargtsel, JOIN = scalargtjoinsel
-);
-
--- access method
-
-CREATE FUNCTION ivfflathandler(internal) RETURNS index_am_handler
-	AS 'MODULE_PATHNAME' LANGUAGE C;
-
-CREATE ACCESS METHOD ivfflat TYPE INDEX HANDLER ivfflathandler;
-
-COMMENT ON ACCESS METHOD ivfflat IS 'ivfflat index access method';
-
--- opclasses
-
-CREATE OPERATOR CLASS vector_ops
-	DEFAULT FOR TYPE vector USING btree AS
-	OPERATOR 1 < ,
-	OPERATOR 2 <= ,
-	OPERATOR 3 = ,
-	OPERATOR 4 >= ,
-	OPERATOR 5 > ,
-	FUNCTION 1 vector_cmp(vector, vector);
-
-CREATE OPERATOR CLASS vector_l2_ops
-	DEFAULT FOR TYPE vector USING ivfflat AS
-	OPERATOR 1 <-> (vector, vector) FOR ORDER BY float_ops,
-	FUNCTION 1 vector_l2_squared_distance(vector, vector),
-	FUNCTION 3 l2_distance(vector, vector);
-
-CREATE OPERATOR CLASS vector_ip_ops
-	FOR TYPE vector USING ivfflat AS
-	OPERATOR 1 <#> (vector, vector) FOR ORDER BY float_ops,
-	FUNCTION 1 vector_negative_inner_product(vector, vector),
-	FUNCTION 3 vector_spherical_distance(vector, vector),
-	FUNCTION 4 vector_norm(vector);
-
-CREATE OPERATOR CLASS vector_cosine_ops
-	FOR TYPE vector USING ivfflat AS
-	OPERATOR 1 <=> (vector, vector) FOR ORDER BY float_ops,
-	FUNCTION 1 vector_negative_inner_product(vector, vector),
-	FUNCTION 2 vector_norm(vector),
-	FUNCTION 3 vector_spherical_distance(vector, vector),
-	FUNCTION 4 vector_norm(vector);

vector.control

@@ -1,4 +1,4 @@
 comment = 'vector data type and ivfflat access method'
-default_version = '0.1.0'
+default_version = '0.3.1'
 module_pathname = '$libdir/vector'
 relocatable = true