Version bump to 0.6.2 [skip ci]

Updated changelog [skip ci]
Moved example [skip ci]
2026-07-22 03:57:34 +08:00 · 2024-03-18 10:21:04 -07:00 · 2024-03-18 10:11:45 -07:00 · 2024-03-16 15:20:26 -07:00 · 2024-03-16 12:02:45 -07:00 · 2024-03-16 11:47:18 -07:00
34 changed files with 1613 additions and 855 deletions
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -20,8 +20,6 @@ jobs:
            os: ubuntu-20.04
          - postgres: 12
            os: ubuntu-20.04
-          - postgres: 11
-            os: ubuntu-20.04
    steps:
      - uses: actions/checkout@v4
      - uses: ankane/setup-postgres@v1
@@ -30,7 +28,7 @@ jobs:
          dev-files: true
      - run: make
        env:
-          PG_CFLAGS: -Wall -Wextra -Werror -Wno-unused-parameter -Wno-sign-compare
+          PG_CFLAGS: -DUSE_ASSERT_CHECKING -Wall -Wextra -Werror -Wno-unused-parameter -Wno-sign-compare
      - run: |
          export PG_CONFIG=`which pg_config`
          sudo --preserve-env=PG_CONFIG make install
@@ -51,7 +49,7 @@ jobs:
          postgres-version: 14
      - run: make
        env:
-          PG_CFLAGS: -Wall -Wextra -Werror -Wno-unused-parameter
+          PG_CFLAGS: -DUSE_ASSERT_CHECKING -Wall -Wextra -Werror -Wno-unused-parameter
      - run: make install
      - run: make installcheck
      - if: ${{ failure() }}
@@ -59,10 +57,12 @@ jobs:
      - run: |
          brew install cpanm
          cpanm --notest IPC::Run
-          wget -q https://github.com/postgres/postgres/archive/refs/tags/REL_14_5.tar.gz
-          tar xf REL_14_5.tar.gz
-      - run: make prove_installcheck PROVE_FLAGS="-I ./postgres-REL_14_5/src/test/perl" PERL5LIB="/Users/runner/perl5/lib/perl5"
+          wget -q https://github.com/postgres/postgres/archive/refs/tags/REL_14_10.tar.gz
+          tar xf REL_14_10.tar.gz
+      - run: make prove_installcheck PROVE_FLAGS="-I ./postgres-REL_14_10/src/test/perl" PERL5LIB="/Users/runner/perl5/lib/perl5"
      - run: make clean && /usr/local/opt/llvm@15/bin/scan-build --status-bugs make
+        env:
+          PG_CFLAGS: -DUSE_ASSERT_CHECKING
  windows:
    runs-on: windows-latest
    if: ${{ !startsWith(github.ref_name, 'mac') }}
@@ -73,6 +73,7 @@ jobs:
          postgres-version: 14
      - run: |
          call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars64.bat" && ^
+          cd %TEMP% && ^
          nmake /NOLOGO /F Makefile.win && ^
          nmake /NOLOGO /F Makefile.win install && ^
          nmake /NOLOGO /F Makefile.win installcheck && ^
@@ -83,10 +84,10 @@ jobs:
    if: ${{ !startsWith(github.ref_name, 'mac') && !startsWith(github.ref_name, 'windows') }}
    runs-on: ubuntu-latest
    container:
-      image: debian:11
+      image: debian:12
      options: --platform linux/386
    steps:
-      - run: apt-get update && apt-get install -y build-essential git libipc-run-perl postgresql-13 postgresql-server-dev-13 sudo
+      - run: apt-get update && apt-get install -y build-essential git libipc-run-perl postgresql-15 postgresql-server-dev-15 sudo
      - run: service postgresql start
      - run: |
          git clone https://github.com/${{ github.repository }}.git pgvector
@@ -99,4 +100,15 @@ jobs:
          sudo -u postgres make installcheck
          sudo -u postgres make prove_installcheck
        env:
-          PG_CFLAGS: -Wall -Wextra -Werror -Wno-unused-parameter -Wno-sign-compare
+          PG_CFLAGS: -DUSE_ASSERT_CHECKING -Wall -Wextra -Werror -Wno-unused-parameter -Wno-sign-compare
+  valgrind:
+    if: ${{ !startsWith(github.ref_name, 'mac') && !startsWith(github.ref_name, 'windows') }}
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: ankane/setup-postgres-valgrind@v1
+        with:
+          postgres-version: 16
+      - run: make
+      - run: sudo --preserve-env=PG_CONFIG make install
+      - run: make installcheck
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,10 +1,28 @@
-## 0.5.2 (unreleased)
+## 0.6.2 (2024-03-18)

+- Reduced lock contention with parallel HNSW index builds
+
+## 0.6.1 (2024-03-04)
+
+- Fixed error with `ANALYZE` and vectors with different dimensions
+- Fixed segmentation fault with `shared_preload_libraries`
+- Fixed vector subtraction being marked as commutative
+
+## 0.6.0 (2024-01-29)
+
+If upgrading with Postgres 12 or Docker, see [these notes](https://github.com/pgvector/pgvector#060).
+
+- Added support for parallel index builds for HNSW
+- Added validation for GUC parameters
+- Changed storage for vector from `extended` to `external`
 - Improved performance of HNSW
- Added support for on-disk parallel index builds for HNSW
 - Reduced memory usage for HNSW index builds
 - Reduced WAL generation for HNSW index builds
- Fixed `invalid memory alloc request size` error with HNSW index build
+- Fixed error with logical replication
+- Fixed `invalid memory alloc request size` error with HNSW index builds
+- Moved Docker image to `pgvector` org
+- Added Docker tags for each supported version of Postgres
+- Dropped support for Postgres 11

 ## 0.5.1 (2023-10-10)

@@ -52,7 +70,7 @@

 ## 0.4.0 (2023-01-11)

-If upgrading with Postgres < 13, see [this note](https://github.com/pgvector/pgvector#040).
+If upgrading with Postgres < 13, see [this note](https://github.com/pgvector/pgvector/blob/v0.4.0/README.md#040).

 - Changed text representation for vector elements to match `real`
 - Changed storage for vector from `plain` to `extended`
@@ -69,7 +87,7 @@ If upgrading with Postgres < 13, see [this note](https://github.com/pgvector/pgv

 ## 0.3.1 (2022-11-02)

-If upgrading from 0.2.7 or 0.3.0, [recreate](https://github.com/pgvector/pgvector#031) all `ivfflat` indexes after upgrading to ensure all data is indexed.
+If upgrading from 0.2.7 or 0.3.0, [recreate](https://github.com/pgvector/pgvector/blob/v0.3.1/README.md#031) all `ivfflat` indexes after upgrading to ensure all data is indexed.

 - Fixed issue with inserts silently corrupting `ivfflat` indexes (introduced in 0.2.7)
 - Fixed segmentation fault with index creation when lists > 6500
--- a/2
+++ b/2
@@ -1,4 +1,4 @@
-ARG PG_MAJOR=15
+ARG PG_MAJOR=16
 FROM postgres:$PG_MAJOR
 ARG PG_MAJOR

--- a/2
+++ b/2
@@ -1,4 +1,4 @@
-Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group

 Portions Copyright (c) 1994, The Regents of the University of California

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

 MODULE_big = vector
 DATA = $(wildcard sql/*--*.sql)
@@ -65,13 +65,15 @@ dist:
 	mkdir -p dist
 	git archive --format zip --prefix=$(EXTENSION)-$(EXTVERSION)/ --output dist/$(EXTENSION)-$(EXTVERSION).zip master

+# for Docker
+PG_MAJOR ?= 16
+
 .PHONY: docker

 docker:
-	docker build --pull --no-cache --platform linux/amd64 -t ankane/pgvector:latest .
+	docker build --pull --no-cache --build-arg PG_MAJOR=$(PG_MAJOR) -t pgvector/pgvector:pg$(PG_MAJOR) -t pgvector/pgvector:$(EXTVERSION)-pg$(PG_MAJOR) .

 .PHONY: docker-release

 docker-release:
-	docker buildx build --push --pull --no-cache --platform linux/amd64,linux/arm64 -t ankane/pgvector:latest .
-	docker buildx build --push --platform linux/amd64,linux/arm64 -t ankane/pgvector:v$(EXTVERSION) .
+	docker buildx build --push --pull --no-cache --platform linux/amd64,linux/arm64 --build-arg PG_MAJOR=$(PG_MAJOR) -t pgvector/pgvector:pg$(PG_MAJOR) -t pgvector/pgvector:$(EXTVERSION)-pg$(PG_MAJOR) .
--- a/Makefile.win
+++ b/Makefile.win
@@ -1,5 +1,5 @@
 EXTENSION = vector
-EXTVERSION = 0.5.1
+EXTVERSION = 0.6.2

 OBJS = src\hnsw.obj src\hnswbuild.obj src\hnswinsert.obj src\hnswscan.obj src\hnswutils.obj src\hnswvacuum.obj src\ivfbuild.obj src\ivfflat.obj src\ivfinsert.obj src\ivfkmeans.obj src\ivfscan.obj src\ivfutils.obj src\ivfvacuum.obj src\vector.obj
 HEADERS = src\vector.h
--- a/README.md
+++ b/README.md
@@ -14,19 +14,46 @@ Plus [ACID](https://en.wikipedia.org/wiki/ACID) compliance, point-in-time recove

 ## Installation

-Compile and install the extension (supports Postgres 11+)
+### Linux and Mac
+
+Compile and install the extension (supports Postgres 12+)

 ```sh
 cd /tmp
-git clone --branch v0.5.1 https://github.com/pgvector/pgvector.git
+git clone --branch v0.6.2 https://github.com/pgvector/pgvector.git
 cd pgvector
 make
 make install # may need sudo
 ```

-See the [installation notes](#installation-notes) if you run into issues
+See the [installation notes](#installation-notes---linux-and-mac) if you run into issues

-You can also install it with [Docker](#docker), [Homebrew](#homebrew), [PGXN](#pgxn), [APT](#apt), [Yum](#yum), or [conda-forge](#conda-forge), and it comes preinstalled with [Postgres.app](#postgresapp) and many [hosted providers](#hosted-postgres). There are also instructions for [GitHub Actions](https://github.com/pgvector/setup-pgvector).
+You can also install it with [Docker](#docker), [Homebrew](#homebrew), [PGXN](#pgxn), [APT](#apt), [Yum](#yum), [pkg](#pkg), or [conda-forge](#conda-forge), and it comes preinstalled with [Postgres.app](#postgresapp) and many [hosted providers](#hosted-postgres). There are also instructions for [GitHub Actions](https://github.com/pgvector/setup-pgvector).
+
+### Windows
+
+Ensure [C++ support in Visual Studio](https://learn.microsoft.com/en-us/cpp/build/building-on-the-command-line?view=msvc-170#download-and-install-the-tools) is installed, and run:
+
+```cmd
+call "C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Auxiliary\Build\vcvars64.bat"
+```
+
+Note: The exact path will vary depending on your Visual Studio version and edition
+
+Then use `nmake` to build:
+
+```cmd
+set "PGROOT=C:\Program Files\PostgreSQL\16"
+cd %TEMP%
+git clone --branch v0.6.2 https://github.com/pgvector/pgvector.git
+cd pgvector
+nmake /F Makefile.win
+nmake /F Makefile.win install
+```
+
+See the [installation notes](#installation-notes---windows) if you run into issues
+
+You can also install it with [Docker](#docker) or [conda-forge](#conda-forge).

 ## Getting Started

@@ -78,6 +105,12 @@ Insert vectors
 INSERT INTO items (embedding) VALUES ('[1,2,3]'), ('[4,5,6]');
 ```

+Or load vectors in bulk using `COPY` ([example](https://github.com/pgvector/pgvector-python/blob/master/examples/bulk_loading.py))
+
+```sql
+COPY items (embedding) FROM STDIN WITH (FORMAT BINARY);
+```
+
 Upsert vectors

 ```sql
@@ -240,6 +273,16 @@ HINT:  Increase maintenance_work_mem to speed up builds.

 Note: Do not set `maintenance_work_mem` so high that it exhausts the memory on the server

+Like other index types, it’s faster to create an index after loading your initial data
+
+Starting with 0.6.0, you can also speed up index creation by increasing the number of parallel workers (2 by default)
+
+```sql
+SET max_parallel_maintenance_workers = 7; -- plus leader
+```
+
+For a large number of workers, you may also need to increase `max_parallel_workers` (8 by default)
+
 ### Indexing Progress

 Check [indexing progress](https://www.postgresql.org/docs/current/progress-reporting.html#CREATE-INDEX-PROGRESS-REPORTING) with Postgres 12+
@@ -304,6 +347,16 @@ SELECT ...
 COMMIT;
 ```

+### Index Build Time
+
+Speed up index creation on large tables by increasing the number of parallel workers (2 by default)
+
+```sql
+SET max_parallel_maintenance_workers = 7; -- plus leader
+```
+
+For a large number of workers, you may also need to increase `max_parallel_workers` (8 by default)
+
 ### Indexing Progress

 Check [indexing progress](https://www.postgresql.org/docs/current/progress-reporting.html#CREATE-INDEX-PROGRESS-REPORTING) with Postgres 12+
@@ -360,13 +413,39 @@ You can use [Reciprocal Rank Fusion](https://github.com/pgvector/pgvector-python

 ## Performance

+### Tuning
+
+Use a tool like [PgTune](https://pgtune.leopard.in.ua/) to set initial values for Postgres server parameters.
+
+### Loading
+
+Use `COPY` for bulk loading data ([example](https://github.com/pgvector/pgvector-python/blob/master/examples/bulk_loading.py)).
+
+```sql
+COPY items (embedding) FROM STDIN WITH (FORMAT BINARY);
+```
+
+Add any indexes *after* loading the initial data for best performance.
+
+### Indexing
+
+See index build time for [HNSW](#index-build-time) and [IVFFlat](#index-build-time-1).
+
+In production environments, create indexes concurrently to avoid blocking writes.
+
+```sql
+CREATE INDEX CONCURRENTLY ...
+```
+
+### Querying
+
 Use `EXPLAIN ANALYZE` to debug performance.

 ```sql
 EXPLAIN ANALYZE SELECT * FROM items ORDER BY embedding <-> '[3,1,2]' LIMIT 5;
 ```

-### Exact Search
+#### Exact Search

 To speed up queries without an index, increase `max_parallel_workers_per_gather`.

@@ -380,7 +459,7 @@ If vectors are normalized to length 1 (like [OpenAI embeddings](https://platform
 SELECT * FROM items ORDER BY embedding <#> '[3,1,2]' LIMIT 5;
 ```

-### Approximate Search
+#### Approximate Search

 To speed up queries with an IVFFlat index, increase the number of inverted lists (at the expense of recall).

@@ -388,6 +467,50 @@ To speed up queries with an IVFFlat index, increase the number of inverted lists
 CREATE INDEX ON items USING ivfflat (embedding vector_l2_ops) WITH (lists = 1000);
 ```

+### Vacuuming
+
+Vacuuming can take a while for HNSW indexes. Speed it up by reindexing first.
+
+```sql
+REINDEX INDEX CONCURRENTLY index_name;
+VACUUM table_name;
+```
+
+## Monitoring
+
+Monitor performance with [pg_stat_statements](https://www.postgresql.org/docs/current/pgstatstatements.html) (be sure to add it to `shared_preload_libraries`).
+
+```sql
+CREATE EXTENSION pg_stat_statements;
+```
+
+Get the most time-consuming queries with:
+
+```sql
+SELECT query, calls, ROUND((total_plan_time + total_exec_time) / calls) AS avg_time_ms,
+    ROUND((total_plan_time + total_exec_time) / 60000) AS total_time_min
+    FROM pg_stat_statements ORDER BY total_plan_time + total_exec_time DESC LIMIT 20;
+```
+
+Note: Replace `total_plan_time + total_exec_time` with `total_time` for Postgres < 13
+
+Monitor recall by comparing results from approximate search with exact search.
+
+```sql
+BEGIN;
+SET LOCAL enable_indexscan = off; -- use exact search
+SELECT ...
+COMMIT;
+```
+
+## Scaling
+
+Scale pgvector the same way you scale Postgres.
+
+Scale vertically by increasing memory, CPU, and storage on a single instance. Use existing tools to [tune parameters](#tuning) and [monitor performance](#monitoring).
+
+Scale horizontally with [replicas](https://www.postgresql.org/docs/current/hot-standby.html), or use [Citus](https://github.com/citusdata/citus) or another approach for sharding ([example](https://github.com/pgvector/pgvector-python/blob/master/examples/citus.py)).
+
 ## Languages

 Use pgvector from any language with a Postgres client. You can even generate and store vectors in one language and query them in another.
@@ -493,7 +616,17 @@ SELECT pg_size_pretty(pg_relation_size('index_name'));

 #### Why isn’t a query using an index?

-The cost estimation in pgvector < 0.4.3 does not always work well with the planner. You can encourage the planner to use an index for a query with:
+The query needs to have an `ORDER BY` and `LIMIT`, and the `ORDER BY` must be the result of a distance operator, not an expression.
+
+```sql
+-- index
+ORDER BY embedding <=> '[3,1,2]' LIMIT 5;
+
+-- no index
+ORDER BY 1 - (embedding <=> '[3,1,2]') DESC LIMIT 5;
+```
+
+You can encourage the planner to use an index for a query with:

 ```sql
 BEGIN;
@@ -522,6 +655,10 @@ or choose to store vectors inline:
 ALTER TABLE items ALTER COLUMN embedding SET STORAGE PLAIN;
 ```

+#### Why are there less results for a query after adding an HNSW index?
+
+Results are limited by the size of the dynamic candidate list (`hnsw.ef_search`). There may be even less results due to dead tuples or filtering conditions in the query. We recommend setting `hnsw.ef_search` to at least twice the `LIMIT` of the query. If you need more than 500 results, use an IVFFlat index instead.
+
 #### Why are there less results for a query after adding an IVFFlat index?

 The index was likely created with too little data for the number of lists. Drop the index until the table has more data.
@@ -530,6 +667,8 @@ The index was likely created with too little data for the number of lists. Drop
 DROP INDEX index_name;
 ```

+Results can also be limited by the number of probes (`ivfflat.probes`).
+
 ## Reference

 ### Vector Type
@@ -565,14 +704,14 @@ Function | Description | Added
 avg(vector) → vector | average |
 sum(vector) → vector | sum | 0.5.0

-## Installation Notes
+## Installation Notes - Linux and Mac

 ### Postgres Location

 If your machine has multiple Postgres installations, specify the path to [pg_config](https://www.postgresql.org/docs/current/app-pgconfig.html) with:

 ```sh
-export PG_CONFIG=/Applications/Postgres.app/Contents/Versions/latest/bin/pg_config
+export PG_CONFIG=/Library/PostgreSQL/16/bin/pg_config
 ```

 Then re-run the installation instructions (run `make clean` before `make` if needed). If `sudo` is needed for `make install`, use:
@@ -581,6 +720,14 @@ Then re-run the installation instructions (run `make clean` before `make` if nee
 sudo --preserve-env=PG_CONFIG make install
 ```

+A few common paths on Mac are:
+
+- EDB installer - `/Library/PostgreSQL/16/bin/pg_config`
+- Homebrew (arm64) - `/opt/homebrew/opt/postgresql@16/bin/pg_config`
+- Homebrew (x86-64) - `/usr/local/opt/postgresql@16/bin/pg_config`
+
+Note: Replace `16` with your Postgres server version
+
 ### Missing Header

 If compilation fails with `fatal error: postgres.h: No such file or directory`, make sure Postgres development files are installed on the server.
@@ -593,44 +740,48 @@ sudo apt install postgresql-server-dev-16

 Note: Replace `16` with your Postgres server version

-### Windows
+### Missing SDK

-Support for Windows is currently experimental. Ensure [C++ support in Visual Studio](https://learn.microsoft.com/en-us/cpp/build/building-on-the-command-line?view=msvc-170#download-and-install-the-tools) is installed, and run:
+If compilation fails and the output includes `warning: no such sysroot directory` on Mac, reinstall Xcode Command Line Tools.

-```cmd
-call "C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Auxiliary\Build\vcvars64.bat"
+### Portability
+
+By default, pgvector compiles with `-march=native` on some platforms for best performance. However, this can lead to `Illegal instruction` errors if trying to run the compiled extension on a different machine.
+
+To compile for portability, use:
+
+```sh
+make OPTFLAGS=""
 ```

-Note: The exact path will vary depending on your Visual Studio version and edition
+## Installation Notes - Windows

-Then use `nmake` to build:
+### Missing Header

-```cmd
-set "PGROOT=C:\Program Files\PostgreSQL\16"
-git clone --branch v0.5.1 https://github.com/pgvector/pgvector.git
-cd pgvector
-nmake /F Makefile.win
-nmake /F Makefile.win install
-```
+If compilation fails with `Cannot open include file: 'postgres.h': No such file or directory`, make sure `PGROOT` is correct.
+
+### Permissions
+
+If installation fails with `Access is denied`, re-run the installation instructions as an administrator.

 ## Additional Installation Methods

 ### Docker

-Get the [Docker image](https://hub.docker.com/r/ankane/pgvector) with:
+Get the [Docker image](https://hub.docker.com/r/pgvector/pgvector) with:

 ```sh
-docker pull ankane/pgvector
+docker pull pgvector/pgvector:pg16
 ```

-This adds pgvector to the [Postgres image](https://hub.docker.com/_/postgres) (run it the same way).
+This adds pgvector to the [Postgres image](https://hub.docker.com/_/postgres) (replace `16` with your Postgres server version, and run it the same way).

 You can also build the image manually:

 ```sh
-git clone --branch v0.5.1 https://github.com/pgvector/pgvector.git
+git clone --branch v0.6.2 https://github.com/pgvector/pgvector.git
 cd pgvector
-docker build --build-arg PG_MAJOR=15 -t myuser/pgvector .
+docker build --build-arg PG_MAJOR=16 -t myuser/pgvector .
 ```

 ### Homebrew
@@ -673,6 +824,21 @@ sudo dnf install pgvector_16

 Note: Replace `16` with your Postgres server version

+### pkg
+
+Install the FreeBSD package with:
+
+```sh
+pkg install postgresql15-pg_vector
+```
+
+or the port with:
+
+```sh
+cd /usr/ports/databases/pgvector
+make install
+```
+
 ### conda-forge

 With Conda Postgres, install from [conda-forge](https://anaconda.org/conda-forge/pgvector) with:
@@ -707,28 +873,32 @@ SELECT extversion FROM pg_extension WHERE extname = 'vector';

 ## Upgrade Notes

-### 0.4.0
+### 0.6.0

-If upgrading with Postgres < 13, remove this line from `sql/vector--0.3.2--0.4.0.sql`:
+#### Postgres 12
+
+If upgrading with Postgres 12, remove this line from `sql/vector--0.5.1--0.6.0.sql`:

 ```sql
-ALTER TYPE vector SET (STORAGE = extended);
+ALTER TYPE vector SET (STORAGE = external);
 ```

 Then run `make install` and `ALTER EXTENSION vector UPDATE;`.

-### 0.3.1
+#### Docker

-If upgrading from 0.2.7 or 0.3.0, recreate all `ivfflat` indexes after upgrading to ensure all data is indexed.
+The Docker image is now published in the `pgvector` org, and there are tags for each supported version of Postgres (rather than a `latest` tag).

-```sql
-- Postgres 12+
-REINDEX INDEX CONCURRENTLY index_name;
+```sh
+docker pull pgvector/pgvector:pg16
+# or
+docker pull pgvector/pgvector:0.6.0-pg16
+```

-- Postgres < 12
-CREATE INDEX CONCURRENTLY temp_name ON table USING ivfflat (column opclass);
-DROP INDEX CONCURRENTLY index_name;
-ALTER INDEX temp_name RENAME TO index_name;
+Also, if you’ve increased `maintenance_work_mem`, make sure `--shm-size` is at least that size to avoid an error with parallel HNSW index builds.
+
+```sh
+docker run --shm-size=1g ...
 ```

 ## Thanks
@@ -774,14 +944,32 @@ make prove_installcheck  # TAP tests
 To run single tests:

 ```sh
-make installcheck REGRESS=functions                    # regression test
-make prove_installcheck PROVE_TESTS=test/t/001_wal.pl  # TAP test
+make installcheck REGRESS=functions                            # regression test
+make prove_installcheck PROVE_TESTS=test/t/001_ivfflat_wal.pl  # TAP test
+```
+
+To enable assertions:
+
+```sh
+make clean && PG_CFLAGS="-DUSE_ASSERT_CHECKING" make && make install
 ```

 To enable benchmarking:

 ```sh
-make clean && PG_CFLAGS=-DIVFFLAT_BENCH make && make install
+make clean && PG_CFLAGS="-DIVFFLAT_BENCH" make && make install
+```
+
+To show memory usage:
+
+```sh
+make clean && PG_CFLAGS="-DHNSW_MEMORY -DIVFFLAT_MEMORY" make && make install
+```
+
+To get k-means metrics:
+
+```sh
+make clean && PG_CFLAGS="-DIVFFLAT_KMEANS_DEBUG" make && make install
 ```

 Resources for contributors
--- a/sql/vector--0.5.1--0.6.0.sql
+++ b/sql/vector--0.5.1--0.6.0.sql
@@ -0,0 +1,5 @@
+-- complain if script is sourced in psql, rather than via CREATE EXTENSION
+\echo Use "ALTER EXTENSION vector UPDATE TO '0.6.0'" to load this file. \quit
+
+-- remove this single line for Postgres < 13
+ALTER TYPE vector SET (STORAGE = external);
--- a/sql/vector--0.6.0--0.6.1.sql
+++ b/sql/vector--0.6.0--0.6.1.sql
@@ -0,0 +1,16 @@
+-- complain if script is sourced in psql, rather than via CREATE EXTENSION
+\echo Use "ALTER EXTENSION vector UPDATE TO '0.6.1'" to load this file. \quit
+
+DROP OPERATOR - (vector, vector);
+
+CREATE OPERATOR - (
+	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = vector_sub
+);
+
+ALTER OPERATOR <= (vector, vector) SET (
+	RESTRICT = scalarlesel, JOIN = scalarlejoinsel
+);
+
+ALTER OPERATOR >= (vector, vector) SET (
+	RESTRICT = scalargesel, JOIN = scalargejoinsel
+);
--- a/sql/vector--0.6.1--0.6.2.sql
+++ b/sql/vector--0.6.1--0.6.2.sql
@@ -0,0 +1,2 @@
+-- complain if script is sourced in psql, rather than via CREATE EXTENSION
+\echo Use "ALTER EXTENSION vector UPDATE TO '0.6.2'" to load this file. \quit
--- a/sql/vector.sql
+++ b/sql/vector.sql
@@ -26,7 +26,7 @@ CREATE TYPE vector (
 	TYPMOD_IN = vector_typmod_in,
 	RECEIVE   = vector_recv,
 	SEND      = vector_send,
-	STORAGE   = extended
+	STORAGE   = external
 );

 -- functions
@@ -180,8 +180,7 @@ CREATE OPERATOR + (
 );

 CREATE OPERATOR - (
-	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = vector_sub,
-	COMMUTATOR = -
+	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = vector_sub
 );

 CREATE OPERATOR * (
@@ -195,11 +194,10 @@ CREATE OPERATOR < (
 	RESTRICT = scalarltsel, JOIN = scalarltjoinsel
 );

-- should use scalarlesel and scalarlejoinsel, but not supported in Postgres < 11
 CREATE OPERATOR <= (
 	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = vector_le,
 	COMMUTATOR = >= , NEGATOR = > ,
-	RESTRICT = scalarltsel, JOIN = scalarltjoinsel
+	RESTRICT = scalarlesel, JOIN = scalarlejoinsel
 );

 CREATE OPERATOR = (
@@ -214,11 +212,10 @@ CREATE OPERATOR <> (
 	RESTRICT = eqsel, JOIN = eqjoinsel
 );

-- should use scalargesel and scalargejoinsel, but not supported in Postgres < 11
 CREATE OPERATOR >= (
 	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = vector_ge,
 	COMMUTATOR = <= , NEGATOR = < ,
-	RESTRICT = scalargtsel, JOIN = scalargtjoinsel
+	RESTRICT = scalargesel, JOIN = scalargejoinsel
 );

 CREATE OPERATOR > (
--- a/src/hnsw.c
+++ b/src/hnsw.c
@@ -4,25 +4,59 @@
 #include <math.h>

 #include "access/amapi.h"
+#include "access/reloptions.h"
+#include "commands/progress.h"
 #include "commands/vacuum.h"
 #include "hnsw.h"
+#include "miscadmin.h"
 #include "utils/guc.h"
 #include "utils/selfuncs.h"

-#if PG_VERSION_NUM >= 120000
-#include "commands/progress.h"
+#if PG_VERSION_NUM < 150000
+#define MarkGUCPrefixReserved(x) EmitWarningsOnPlaceholders(x)
 #endif

 int			hnsw_ef_search;
-bool		hnsw_enable_parallel_build;
+int			hnsw_lock_tranche_id;
 static relopt_kind hnsw_relopt_kind;

+/*
+ * Assign a tranche ID for our LWLocks. This only needs to be done by one
+ * backend, as the tranche ID is remembered in shared memory.
+ *
+ * This shared memory area is very small, so we just allocate it from the
+ * "slop" that PostgreSQL reserves for small allocations like this. If
+ * this grows bigger, we should use a shmem_request_hook and
+ * RequestAddinShmemSpace() to pre-reserve space for this.
+ */
+void
+HnswInitLockTranche(void)
+{
+	int		   *tranche_ids;
+	bool		found;
+
+	LWLockAcquire(AddinShmemInitLock, LW_EXCLUSIVE);
+	tranche_ids = ShmemInitStruct("hnsw LWLock ids",
+								  sizeof(int) * 1,
+								  &found);
+	if (!found)
+		tranche_ids[0] = LWLockNewTrancheId();
+	hnsw_lock_tranche_id = tranche_ids[0];
+	LWLockRelease(AddinShmemInitLock);
+
+	/* Per-backend registration of the tranche ID */
+	LWLockRegisterTranche(hnsw_lock_tranche_id, "HnswBuild");
+}
+
 /*
 * Initialize index options and variables
 */
 void
 HnswInit(void)
 {
+	if (!process_shared_preload_libraries_in_progress)
+		HnswInitLockTranche();
+
 	hnsw_relopt_kind = add_reloption_kind();
 	add_int_reloption(hnsw_relopt_kind, "m", "Max number of connections",
 					  HNSW_DEFAULT_M, HNSW_MIN_M, HNSW_MAX_M
@@ -41,16 +75,12 @@ HnswInit(void)
 							"Valid range is 1..1000.", &hnsw_ef_search,
 							HNSW_DEFAULT_EF_SEARCH, HNSW_MIN_EF_SEARCH, HNSW_MAX_EF_SEARCH, PGC_USERSET, 0, NULL, NULL, NULL);

-	/* Behind a variable for now since can be slower than building in memory */
-	DefineCustomBoolVariable("hnsw.enable_parallel_build", "Enables or disables building indexes in parallel",
-							 NULL, &hnsw_enable_parallel_build,
-							 false, PGC_USERSET, 0, NULL, NULL, NULL);
+	MarkGUCPrefixReserved("hnsw");
 }

 /*
 * Get the name of index build phase
 */
-#if PG_VERSION_NUM >= 120000
 static char *
 hnswbuildphasename(int64 phasenum)
 {
@@ -64,7 +94,6 @@ hnswbuildphasename(int64 phasenum)
 			return NULL;
 	}
 }
-#endif

 /*
 * Estimate the cost of an index scan
@@ -79,9 +108,6 @@ hnswcostestimate(PlannerInfo *root, IndexPath *path, double loop_count,
 	int			m;
 	int			entryLevel;
 	Relation	index;
-#if PG_VERSION_NUM < 120000
-	List	   *qinfos;
-#endif

 	/* Never use index without order */
 	if (path->indexorderbys == NULL)
@@ -107,12 +133,7 @@ hnswcostestimate(PlannerInfo *root, IndexPath *path, double loop_count,
 	/* Account for number of tuples (or entry level), m, and ef_search */
 	costs.numIndexTuples = (entryLevel + 2) * m;

-#if PG_VERSION_NUM >= 120000
 	genericcostestimate(root, path, loop_count, &costs);
-#else
-	qinfos = deconstruct_indexquals(path);
-	genericcostestimate(root, path, loop_count, qinfos, &costs);
-#endif

 	/* Use total cost since most work happens before first tuple is returned */
 	*indexStartupCost = costs.indexTotalCost;
@@ -206,9 +227,7 @@ hnswhandler(PG_FUNCTION_ARGS)
 	amroutine->amcostestimate = hnswcostestimate;
 	amroutine->amoptions = hnswoptions;
 	amroutine->amproperty = NULL;	/* TODO AMPROP_DISTANCE_ORDERABLE */
-#if PG_VERSION_NUM >= 120000
 	amroutine->ambuildphasename = hnswbuildphasename;
-#endif
 	amroutine->amvalidate = hnswvalidate;
 #if PG_VERSION_NUM >= 140000
 	amroutine->amadjustmembers = NULL;
--- a/src/hnsw.h
+++ b/src/hnsw.h
@@ -3,21 +3,17 @@

 #include "postgres.h"

-#include "access/generic_xlog.h"
+#include "access/genam.h"
 #include "access/parallel.h"
-#include "access/reloptions.h"
-#include "lib/ilist.h"
+#include "lib/pairingheap.h"
 #include "nodes/execnodes.h"
 #include "port.h"				/* for random() */
+#include "utils/relptr.h"
 #include "utils/sampling.h"
 #include "vector.h"

-#if PG_VERSION_NUM < 110000
-#error "Requires PostgreSQL 11+"
-#endif
-
 #if PG_VERSION_NUM < 120000
-#include "access/relscan.h"
+#error "Requires PostgreSQL 12+"
 #endif

 #define HNSW_MAX_DIM 2000
@@ -64,10 +60,13 @@
 #define PROGRESS_HNSW_PHASE_LOAD		2

 #define HNSW_MAX_SIZE (BLCKSZ - MAXALIGN(SizeOfPageHeaderData) - MAXALIGN(sizeof(HnswPageOpaqueData)) - sizeof(ItemIdData))
+#define HNSW_TUPLE_ALLOC_SIZE BLCKSZ

 #define HNSW_ELEMENT_TUPLE_SIZE(size)	MAXALIGN(offsetof(HnswElementTupleData, data) + (size))
 #define HNSW_NEIGHBOR_TUPLE_SIZE(level, m)	MAXALIGN(offsetof(HnswNeighborTupleData, indextids) + ((level) + 2) * (m) * sizeof(ItemPointerData))

+#define HNSW_NEIGHBOR_ARRAY_SIZE(lm)	(offsetof(HnswNeighborArray, items) + sizeof(HnswCandidate) * (lm))
+
 #define HnswPageGetOpaque(page)	((HnswPageOpaque) PageGetSpecialPointer(page))
 #define HnswPageGetMeta(page)	((HnswMetaPageData *) PageGetContents(page))

@@ -81,7 +80,7 @@

 #if PG_VERSION_NUM < 130000
 #define list_delete_last(list) list_truncate(list, list_length(list) - 1)
-#define list_sort(list, cmp) list_qsort(list, cmp)
+#define list_sort(list, cmp) ((list) = list_qsort(list, cmp))
 #endif

 #define HnswIsElementTuple(tup) ((tup)->type == HNSW_ELEMENT_TUPLE_TYPE)
@@ -96,43 +95,72 @@
 /* Ensure fits on page and in uint8 */
 #define HnswGetMaxLevel(m) Min(((BLCKSZ - MAXALIGN(SizeOfPageHeaderData) - MAXALIGN(sizeof(HnswPageOpaqueData)) - offsetof(HnswNeighborTupleData, indextids) - sizeof(ItemIdData)) / (sizeof(ItemPointerData)) / (m)) - 2, 255)

-#define HnswGetNeighbors(element, lc) (AssertMacro((element)->level >= (lc)), &(element)->neighbors[lc])
+#define HnswGetValue(base, element) PointerGetDatum(HnswPtrAccess(base, (element)->value))
+
+#if PG_VERSION_NUM < 140005
+#define relptr_offset(rp) ((rp).relptr_off - 1)
+#endif
+
+/* Pointer macros */
+#define HnswPtrAccess(base, hp) ((base) == NULL ? (hp).ptr : relptr_access(base, (hp).relptr))
+#define HnswPtrStore(base, hp, value) ((base) == NULL ? (void) ((hp).ptr = (value)) : (void) relptr_store(base, (hp).relptr, value))
+#define HnswPtrIsNull(base, hp) ((base) == NULL ? (hp).ptr == NULL : relptr_is_null((hp).relptr))
+#define HnswPtrEqual(base, hp1, hp2) ((base) == NULL ? (hp1).ptr == (hp2).ptr : relptr_offset((hp1).relptr) == relptr_offset((hp2).relptr))
+
+/* For code paths dedicated to each type */
+#define HnswPtrPointer(hp) (hp).ptr
+#define HnswPtrOffset(hp) relptr_offset((hp).relptr)

 /* Variables */
 extern int	hnsw_ef_search;
-extern bool hnsw_enable_parallel_build;
+extern int	hnsw_lock_tranche_id;

-typedef struct HnswElementData
+typedef struct HnswElementData HnswElementData;
+typedef struct HnswNeighborArray HnswNeighborArray;
+
+#define HnswPtrDeclare(type, relptrtype, ptrtype) \
+	relptr_declare(type, relptrtype); \
+	typedef union { type *ptr; relptrtype relptr; } ptrtype;
+
+/* Pointers that can be absolute or relative */
+/* Use char for DatumPtr so works with Pointer */
+HnswPtrDeclare(HnswElementData, HnswElementRelptr, HnswElementPtr);
+HnswPtrDeclare(HnswNeighborArray, HnswNeighborArrayRelptr, HnswNeighborArrayPtr);
+HnswPtrDeclare(HnswNeighborArrayPtr, HnswNeighborsRelptr, HnswNeighborsPtr);
+HnswPtrDeclare(char, DatumRelptr, DatumPtr);
+
+struct HnswElementData
 {
-	slist_node	next;
+	HnswElementPtr next;
 	ItemPointerData heaptids[HNSW_HEAPTIDS];
 	uint8		heaptidsLength;
 	uint8		level;
 	uint8		deleted;
 	uint32		hash;
-	struct HnswNeighborArray *neighbors;
+	HnswNeighborsPtr neighbors;
 	BlockNumber blkno;
 	OffsetNumber offno;
 	OffsetNumber neighborOffno;
 	BlockNumber neighborPage;
-	Datum		value;
-}			HnswElementData;
+	DatumPtr	value;
+	LWLock		lock;
+};

 typedef HnswElementData * HnswElement;

 typedef struct HnswCandidate
 {
-	HnswElement element;
+	HnswElementPtr element;
 	float		distance;
 	bool		closer;
 }			HnswCandidate;

-typedef struct HnswNeighborArray
+struct HnswNeighborArray
 {
 	int			length;
 	bool		closerSet;
-	HnswCandidate *items;
-}			HnswNeighborArray;
+	HnswCandidate items[FLEXIBLE_ARRAY_MEMBER];
+};

 typedef struct HnswPairingHeapNode
 {
@@ -150,19 +178,25 @@ typedef struct HnswOptions

 typedef struct HnswGraph
 {
-	slist_head	elements;
-	HnswElement entryPoint;
+	/* Graph state */
+	slock_t		lock;
+	HnswElementPtr head;
+	double		indtuples;
+
+	/* Entry state */
+	LWLock		entryLock;
+	LWLock		entryWaitLock;
+	HnswElementPtr entryPoint;
+
+	/* Allocations state */
+	LWLock		allocatorLock;
 	long		memoryUsed;
 	long		memoryTotal;
-	bool		flushed;
-	double		indtuples;
-}			HnswGraph;

-typedef struct HnswSpool
-{
-	Relation	heap;
-	Relation	index;
-}			HnswSpool;
+	/* Flushed state */
+	LWLock		flushLock;
+	bool		flushed;
+}			HnswGraph;

 typedef struct HnswShared
 {
@@ -170,7 +204,6 @@ typedef struct HnswShared
 	Oid			heaprelid;
 	Oid			indexrelid;
 	bool		isconcurrent;
-	int			scantuplesortstates;

 	/* Worker progress */
 	ConditionVariable workersdonecv;
@@ -182,16 +215,10 @@ typedef struct HnswShared
 	int			nparticipantsdone;
 	double		reltuples;
 	HnswGraph	graphData;
-
-#if PG_VERSION_NUM < 120000
-	ParallelHeapScanDescData heapdesc;	/* must come last */
-#endif
 }			HnswShared;

-#if PG_VERSION_NUM >= 120000
 #define ParallelTableScanFromHnswShared(shared) \
 	(ParallelTableScanDesc) ((char *) (shared) + BUFFERALIGN(sizeof(HnswShared)))
-#endif

 typedef struct HnswLeader
 {
@@ -199,8 +226,15 @@ typedef struct HnswLeader
 	int			nparticipanttuplesorts;
 	HnswShared *hnswshared;
 	Snapshot	snapshot;
+	char	   *hnswarea;
 }			HnswLeader;

+typedef struct HnswAllocator
+{
+	void	   *(*alloc) (Size size, void *state);
+	void	   *state;
+}			HnswAllocator;
+
 typedef struct HnswBuildState
 {
 	/* Info */
@@ -233,10 +267,12 @@ typedef struct HnswBuildState
 	/* Memory */
 	MemoryContext graphCtx;
 	MemoryContext tmpCtx;
+	HnswAllocator allocator;

 	/* Parallel builds */
 	HnswLeader *hnswleader;
 	HnswShared *hnswshared;
+	char	   *hnswarea;
 }			HnswBuildState;

 typedef struct HnswMetaPageData
@@ -335,24 +371,26 @@ bool		HnswNormValue(FmgrInfo *procinfo, Oid collation, Datum *value, Vector * re
 Buffer		HnswNewBuffer(Relation index, ForkNumber forkNum);
 void		HnswInitPage(Buffer buf, Page page);
 void		HnswInit(void);
-List	   *HnswSearchLayer(Datum q, List *ep, int ef, int lc, Relation index, FmgrInfo *procinfo, Oid collation, int m, bool inserting, HnswElement skipElement);
+List	   *HnswSearchLayer(char *base, Datum q, List *ep, int ef, int lc, Relation index, FmgrInfo *procinfo, Oid collation, int m, bool inserting, HnswElement skipElement);
 HnswElement HnswGetEntryPoint(Relation index);
 void		HnswGetMetaPageInfo(Relation index, int *m, HnswElement * entryPoint);
-HnswElement HnswInitElement(ItemPointer tid, int m, double ml, int maxLevel);
+void	   *HnswAlloc(HnswAllocator * allocator, Size size);
+HnswElement HnswInitElement(char *base, ItemPointer tid, int m, double ml, int maxLevel, HnswAllocator * alloc);
 HnswElement HnswInitElementFromBlock(BlockNumber blkno, OffsetNumber offno);
-void		HnswInsertElement(HnswElement element, HnswElement entryPoint, Relation index, FmgrInfo *procinfo, Oid collation, int m, int efConstruction, bool existing);
-HnswCandidate *HnswEntryCandidate(HnswElement em, Datum q, Relation rel, FmgrInfo *procinfo, Oid collation, bool loadVec);
+void		HnswFindElementNeighbors(char *base, HnswElement element, HnswElement entryPoint, Relation index, FmgrInfo *procinfo, Oid collation, int m, int efConstruction, bool existing);
+HnswCandidate *HnswEntryCandidate(char *base, HnswElement em, Datum q, Relation rel, FmgrInfo *procinfo, Oid collation, bool loadVec);
 void		HnswUpdateMetaPage(Relation index, int updateEntry, HnswElement entryPoint, BlockNumber insertPage, ForkNumber forkNum, bool building);
-void		HnswSetNeighborTuple(HnswNeighborTuple ntup, HnswElement e, int m);
+void		HnswSetNeighborTuple(char *base, HnswNeighborTuple ntup, HnswElement e, int m);
 void		HnswAddHeapTid(HnswElement element, ItemPointer heaptid);
-void		HnswInitNeighbors(HnswElement element, int m);
-bool		HnswInsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heap_tid, Relation heapRel, bool building);
-void		HnswUpdateNeighborPages(Relation index, FmgrInfo *procinfo, Oid collation, HnswElement e, int m, bool checkExisting, bool building);
+void		HnswInitNeighbors(char *base, HnswElement element, int m, HnswAllocator * alloc);
+bool		HnswInsertTupleOnDisk(Relation index, Datum value, Datum *values, bool *isnull, ItemPointer heap_tid, bool building);
+void		HnswUpdateNeighborsOnDisk(Relation index, FmgrInfo *procinfo, Oid collation, HnswElement e, int m, bool checkExisting, bool building);
 void		HnswLoadElementFromTuple(HnswElement element, HnswElementTuple etup, bool loadHeaptids, bool loadVec);
 void		HnswLoadElement(HnswElement element, float *distance, Datum *q, Relation index, FmgrInfo *procinfo, Oid collation, bool loadVec);
-void		HnswSetElementTuple(HnswElementTuple etup, HnswElement element);
-void		HnswUpdateConnection(HnswElement element, HnswCandidate * hc, int m, int lc, int *updateIdx, Relation index, FmgrInfo *procinfo, Oid collation);
+void		HnswSetElementTuple(char *base, HnswElementTuple etup, HnswElement element);
+void		HnswUpdateConnection(char *base, HnswElement element, HnswCandidate * hc, int lm, int lc, int *updateIdx, Relation index, FmgrInfo *procinfo, Oid collation);
 void		HnswLoadNeighbors(HnswElement element, Relation index, int m);
+void		HnswInitLockTranche(void);
 PGDLLEXPORT void HnswParallelBuildMain(dsm_segment *seg, shm_toc *toc);

 /* Index access methods */
@@ -371,6 +409,16 @@ void		hnswrescan(IndexScanDesc scan, ScanKey keys, int nkeys, ScanKey orderbys,
 bool		hnswgettuple(IndexScanDesc scan, ScanDirection dir);
 void		hnswendscan(IndexScanDesc scan);

+static inline HnswNeighborArray *
+HnswGetNeighbors(char *base, HnswElement element, int lc)
+{
+	HnswNeighborArrayPtr *neighborList = HnswPtrAccess(base, element->neighbors);
+
+	Assert(element->level >= lc);
+
+	return HnswPtrAccess(base, neighborList[lc]);
+}
+
 /* Hash tables */
 typedef struct TidHashEntry
 {
@@ -398,4 +446,17 @@ typedef struct PointerHashEntry
 #define SH_DECLARE
 #include "lib/simplehash.h"

+typedef struct OffsetHashEntry
+{
+	Size		offset;
+	char		status;
+}			OffsetHashEntry;
+
+#define SH_PREFIX offsethash
+#define SH_ELEMENT_TYPE OffsetHashEntry
+#define SH_KEY_TYPE Size
+#define SH_SCOPE extern
+#define SH_DECLARE
+#include "lib/simplehash.h"
+
 #endif
--- a/src/hnswbuild.c
+++ b/src/hnswbuild.c
--- a/src/hnswinsert.c
+++ b/src/hnswinsert.c
@@ -2,6 +2,7 @@

 #include <math.h>

+#include "access/generic_xlog.h"
 #include "hnsw.h"
 #include "storage/bufmgr.h"
 #include "storage/lmgr.h"
@@ -116,7 +117,7 @@ HnswInsertAppendPage(Relation index, Buffer *nbuf, Page *npage, GenericXLogState
 * Add to element and neighbor pages
 */
 static void
-WriteNewElementPages(Relation index, HnswElement e, int m, BlockNumber insertPage, BlockNumber *updatedInsertPage, bool building)
+AddElementOnDisk(Relation index, HnswElement e, int m, BlockNumber insertPage, BlockNumber *updatedInsertPage, bool building)
 {
 	Buffer		buf;
 	Page		page;
@@ -134,9 +135,10 @@ WriteNewElementPages(Relation index, HnswElement e, int m, BlockNumber insertPag
 	OffsetNumber freeOffno = InvalidOffsetNumber;
 	OffsetNumber freeNeighborOffno = InvalidOffsetNumber;
 	BlockNumber newInsertPage = InvalidBlockNumber;
+	char	   *base = NULL;

 	/* Calculate sizes */
-	etupSize = HNSW_ELEMENT_TUPLE_SIZE(VARSIZE_ANY(DatumGetPointer(e->value)));
+	etupSize = HNSW_ELEMENT_TUPLE_SIZE(VARSIZE_ANY(HnswPtrAccess(base, e->value)));
 	ntupSize = HNSW_NEIGHBOR_TUPLE_SIZE(e->level, m);
 	combinedSize = etupSize + ntupSize + sizeof(ItemIdData);
 	maxSize = HNSW_MAX_SIZE;
@@ -144,11 +146,11 @@ WriteNewElementPages(Relation index, HnswElement e, int m, BlockNumber insertPag

 	/* Prepare element tuple */
 	etup = palloc0(etupSize);
-	HnswSetElementTuple(etup, e);
+	HnswSetElementTuple(base, etup, e);

 	/* Prepare neighbor tuple */
 	ntup = palloc0(ntupSize);
-	HnswSetNeighborTuple(ntup, e, m);
+	HnswSetNeighborTuple(base, ntup, e, m);

 	/* Find a page (or two if needed) to insert the tuples */
 	for (;;)
@@ -338,12 +340,14 @@ ConnectionExists(HnswElement e, HnswNeighborTuple ntup, int startIdx, int lm)
 * Update neighbors
 */
 void
-HnswUpdateNeighborPages(Relation index, FmgrInfo *procinfo, Oid collation, HnswElement e, int m, bool checkExisting, bool building)
+HnswUpdateNeighborsOnDisk(Relation index, FmgrInfo *procinfo, Oid collation, HnswElement e, int m, bool checkExisting, bool building)
 {
+	char	   *base = NULL;
+
 	for (int lc = e->level; lc >= 0; lc--)
 	{
 		int			lm = HnswGetLayerM(m, lc);
-		HnswNeighborArray *neighbors = HnswGetNeighbors(e, lc);
+		HnswNeighborArray *neighbors = HnswGetNeighbors(base, e, lc);

 		for (int i = 0; i < neighbors->length; i++)
 		{
@@ -351,16 +355,15 @@ HnswUpdateNeighborPages(Relation index, FmgrInfo *procinfo, Oid collation, HnswE
 			Buffer		buf;
 			Page		page;
 			GenericXLogState *state;
-			ItemId		itemid;
 			HnswNeighborTuple ntup;
-			Size		ntupSize;
 			int			idx = -1;
 			int			startIdx;
-			OffsetNumber offno = hc->element->neighborOffno;
+			HnswElement neighborElement = HnswPtrAccess(base, hc->element);
+			OffsetNumber offno = neighborElement->neighborOffno;

 			/* Get latest neighbors since they may have changed */
 			/* Do not lock yet since selecting neighbors can take time */
-			HnswLoadNeighbors(hc->element, index, m);
+			HnswLoadNeighbors(neighborElement, index, m);

 			/*
 			 * Could improve performance for vacuuming by checking neighbors
@@ -370,14 +373,14 @@ HnswUpdateNeighborPages(Relation index, FmgrInfo *procinfo, Oid collation, HnswE
 			 */

 			/* Select neighbors */
-			HnswUpdateConnection(e, hc, lm, lc, &idx, index, procinfo, collation);
+			HnswUpdateConnection(NULL, e, hc, lm, lc, &idx, index, procinfo, collation);

 			/* New element was not selected as a neighbor */
 			if (idx == -1)
 				continue;

 			/* Register page */
-			buf = ReadBuffer(index, hc->element->neighborPage);
+			buf = ReadBuffer(index, neighborElement->neighborPage);
 			LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
 			if (building)
 			{
@@ -391,12 +394,10 @@ HnswUpdateNeighborPages(Relation index, FmgrInfo *procinfo, Oid collation, HnswE
 			}

 			/* Get tuple */
-			itemid = PageGetItemId(page, offno);
-			ntup = (HnswNeighborTuple) PageGetItem(page, itemid);
-			ntupSize = ItemIdGetLength(itemid);
+			ntup = (HnswNeighborTuple) PageGetItem(page, PageGetItemId(page, offno));

 			/* Calculate index for update */
-			startIdx = (hc->element->level - lc) * m;
+			startIdx = (neighborElement->level - lc) * m;

 			/* Check for existing connection */
 			if (checkExisting && ConnectionExists(e, ntup, startIdx, lm))
@@ -422,13 +423,9 @@ HnswUpdateNeighborPages(Relation index, FmgrInfo *procinfo, Oid collation, HnswE
 			{
 				ItemPointer indextid = &ntup->indextids[idx];

-				/* Update neighbor */
+				/* Update neighbor on the buffer */
 				ItemPointerSet(indextid, e->blkno, e->offno);

-				/* Overwrite tuple */
-				if (!PageIndexTupleOverwrite(page, offno, (Item) ntup, ntupSize))
-					elog(ERROR, "failed to add index item to \"%s\"", RelationGetRelationName(index));
-
 				/* Commit */
 				if (building)
 					MarkBufferDirty(buf);
@@ -447,14 +444,12 @@ HnswUpdateNeighborPages(Relation index, FmgrInfo *procinfo, Oid collation, HnswE
 * Add a heap TID to an existing element
 */
 static bool
-HnswAddDuplicate(Relation index, HnswElement element, HnswElement dup, bool building)
+AddDuplicateOnDisk(Relation index, HnswElement element, HnswElement dup, bool building)
 {
 	Buffer		buf;
 	Page		page;
 	GenericXLogState *state;
-	ItemId		itemid;
 	HnswElementTuple etup;
-	Size		etupSize;
 	int			i;

 	/* Read page */
@@ -472,9 +467,7 @@ HnswAddDuplicate(Relation index, HnswElement element, HnswElement dup, bool buil
 	}

 	/* Find space */
-	itemid = PageGetItemId(page, dup->offno);
-	etup = (HnswElementTuple) PageGetItem(page, itemid);
-	etupSize = ItemIdGetLength(itemid);
+	etup = (HnswElementTuple) PageGetItem(page, PageGetItemId(page, dup->offno));
 	for (i = 0; i < HNSW_HEAPTIDS; i++)
 	{
 		if (!ItemPointerIsValid(&etup->heaptids[i]))
@@ -490,13 +483,9 @@ HnswAddDuplicate(Relation index, HnswElement element, HnswElement dup, bool buil
 		return false;
 	}

-	/* Add heap TID */
+	/* Add heap TID, modifying the tuple on the page directly */
 	etup->heaptids[i] = element->heaptids[0];

-	/* Overwrite tuple */
-	if (!PageIndexTupleOverwrite(page, dup->offno, (Item) etup, etupSize))
-		elog(ERROR, "failed to add index item to \"%s\"", RelationGetRelationName(index));
-
 	/* Commit */
 	if (building)
 		MarkBufferDirty(buf);
@@ -511,19 +500,23 @@ HnswAddDuplicate(Relation index, HnswElement element, HnswElement dup, bool buil
 * Find duplicate element
 */
 static bool
-HnswFindDuplicate(Relation index, HnswElement element, bool building)
+FindDuplicateOnDisk(Relation index, HnswElement element, bool building)
 {
-	HnswNeighborArray *neighbors = HnswGetNeighbors(element, 0);
+	char	   *base = NULL;
+	HnswNeighborArray *neighbors = HnswGetNeighbors(base, element, 0);
+	Datum		value = HnswGetValue(base, element);

 	for (int i = 0; i < neighbors->length; i++)
 	{
 		HnswCandidate *neighbor = &neighbors->items[i];
+		HnswElement neighborElement = HnswPtrAccess(base, neighbor->element);
+		Datum		neighborValue = HnswGetValue(base, neighborElement);

 		/* Exit early since ordered by distance */
-		if (!datumIsEqual(element->value, neighbor->element->value, false, -1))
+		if (!datumIsEqual(value, neighborValue, false, -1))
 			return false;

-		if (HnswAddDuplicate(index, element, neighbor->element, building))
+		if (AddDuplicateOnDisk(index, element, neighborElement, building))
 			return true;
 	}

@@ -531,26 +524,26 @@ HnswFindDuplicate(Relation index, HnswElement element, bool building)
 }

 /*
- * Write changes to disk
+ * Update graph on disk
 */
 static void
-WriteElement(Relation index, FmgrInfo *procinfo, Oid collation, HnswElement element, int m, int efConstruction, HnswElement entryPoint, bool building)
+UpdateGraphOnDisk(Relation index, FmgrInfo *procinfo, Oid collation, HnswElement element, int m, int efConstruction, HnswElement entryPoint, bool building)
 {
 	BlockNumber newInsertPage = InvalidBlockNumber;

 	/* Look for duplicate */
-	if (HnswFindDuplicate(index, element, building))
+	if (FindDuplicateOnDisk(index, element, building))
 		return;

-	/* Write element and neighbor tuples */
-	WriteNewElementPages(index, element, m, GetInsertPage(index), &newInsertPage, building);
+	/* Add element */
+	AddElementOnDisk(index, element, m, GetInsertPage(index), &newInsertPage, building);

 	/* Update insert page if needed */
 	if (BlockNumberIsValid(newInsertPage))
 		HnswUpdateMetaPage(index, 0, NULL, newInsertPage, MAIN_FORKNUM, building);

 	/* Update neighbors */
-	HnswUpdateNeighborPages(index, procinfo, collation, element, m, false, building);
+	HnswUpdateNeighborsOnDisk(index, procinfo, collation, element, m, false, building);

 	/* Update entry point if needed */
 	if (entryPoint == NULL || element->level > entryPoint->level)
@@ -561,10 +554,8 @@ WriteElement(Relation index, FmgrInfo *procinfo, Oid collation, HnswElement elem
 * Insert a tuple into the index
 */
 bool
-HnswInsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heap_tid, Relation heapRel, bool building)
+HnswInsertTupleOnDisk(Relation index, Datum value, Datum *values, bool *isnull, ItemPointer heap_tid, bool building)
 {
-	Datum		value;
-	FmgrInfo   *normprocinfo;
 	HnswElement entryPoint;
 	HnswElement element;
 	int			m;
@@ -572,17 +563,7 @@ HnswInsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heap_ti
 	FmgrInfo   *procinfo = index_getprocinfo(index, 1, HNSW_DISTANCE_PROC);
 	Oid			collation = index->rd_indcollation[0];
 	LOCKMODE	lockmode = ShareLock;
-
-	/* Detoast once for all calls */
-	value = PointerGetDatum(PG_DETOAST_DATUM(values[0]));
-
-	/* Normalize if needed */
-	normprocinfo = HnswOptionalProcInfo(index, HNSW_NORM_PROC);
-	if (normprocinfo != NULL)
-	{
-		if (!HnswNormValue(normprocinfo, collation, &value, NULL))
-			return false;
-	}
+	char	   *base = NULL;

 	/*
 	 * Get a shared lock. This allows vacuum to ensure no in-flight inserts
@@ -595,8 +576,8 @@ HnswInsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heap_ti
 	HnswGetMetaPageInfo(index, &m, &entryPoint);

 	/* Create an element */
-	element = HnswInitElement(heap_tid, m, HnswGetMl(m), HnswGetMaxLevel(m));
-	element->value = value;
+	element = HnswInitElement(base, heap_tid, m, HnswGetMl(m), HnswGetMaxLevel(m), NULL);
+	HnswPtrStore(base, element->value, DatumGetPointer(value));

 	/* Prevent concurrent inserts when likely updating entry point */
 	if (entryPoint == NULL || element->level > entryPoint->level)
@@ -612,11 +593,11 @@ HnswInsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heap_ti
 		entryPoint = HnswGetEntryPoint(index);
 	}

-	/* Insert element in graph */
-	HnswInsertElement(element, entryPoint, index, procinfo, collation, m, efConstruction, false);
+	/* Find neighbors for element */
+	HnswFindElementNeighbors(base, element, entryPoint, index, procinfo, collation, m, efConstruction, false);

-	/* Write to disk */
-	WriteElement(index, procinfo, collation, element, m, efConstruction, entryPoint, building);
+	/* Update graph on disk */
+	UpdateGraphOnDisk(index, procinfo, collation, element, m, efConstruction, entryPoint, building);

 	/* Release lock */
 	UnlockPage(index, HNSW_UPDATE_LOCK, lockmode);
@@ -624,6 +605,30 @@ HnswInsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heap_ti
 	return true;
 }

+/*
+ * Insert a tuple into the index
+ */
+static void
+HnswInsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heap_tid)
+{
+	Datum		value;
+	FmgrInfo   *normprocinfo;
+	Oid			collation = index->rd_indcollation[0];
+
+	/* Detoast once for all calls */
+	value = PointerGetDatum(PG_DETOAST_DATUM(values[0]));
+
+	/* Normalize if needed */
+	normprocinfo = HnswOptionalProcInfo(index, HNSW_NORM_PROC);
+	if (normprocinfo != NULL)
+	{
+		if (!HnswNormValue(normprocinfo, collation, &value, NULL))
+			return;
+	}
+
+	HnswInsertTupleOnDisk(index, value, values, isnull, heap_tid, false);
+}
+
 /*
 * Insert a tuple into the index
 */
@@ -650,7 +655,7 @@ hnswinsert(Relation index, Datum *values, bool *isnull, ItemPointer heap_tid,
 	oldCtx = MemoryContextSwitchTo(insertCtx);

 	/* Insert tuple */
-	HnswInsertTuple(index, values, isnull, heap_tid, heap, false);
+	HnswInsertTuple(index, values, isnull, heap_tid);

 	/* Delete memory context */
 	MemoryContextSwitchTo(oldCtx);
--- a/src/hnswscan.c
+++ b/src/hnswscan.c
@@ -21,6 +21,7 @@ GetScanItems(IndexScanDesc scan, Datum q)
 	List	   *w;
 	int			m;
 	HnswElement entryPoint;
+	char	   *base = NULL;

 	/* Get m and entry point */
 	HnswGetMetaPageInfo(index, &m, &entryPoint);
@@ -28,15 +29,15 @@ GetScanItems(IndexScanDesc scan, Datum q)
 	if (entryPoint == NULL)
 		return NIL;

-	ep = list_make1(HnswEntryCandidate(entryPoint, q, index, procinfo, collation, false));
+	ep = list_make1(HnswEntryCandidate(base, entryPoint, q, index, procinfo, collation, false));

 	for (int lc = entryPoint->level; lc >= 1; lc--)
 	{
-		w = HnswSearchLayer(q, ep, 1, lc, index, procinfo, collation, m, false, NULL);
+		w = HnswSearchLayer(base, q, ep, 1, lc, index, procinfo, collation, m, false, NULL);
 		ep = w;
 	}

-	return HnswSearchLayer(q, ep, hnsw_ef_search, 0, index, procinfo, collation, m, false, NULL);
+	return HnswSearchLayer(base, q, ep, hnsw_ef_search, 0, index, procinfo, collation, m, false, NULL);
 }

 /*
@@ -184,26 +185,24 @@ hnswgettuple(IndexScanDesc scan, ScanDirection dir)

 	while (list_length(so->w) > 0)
 	{
+		char	   *base = NULL;
 		HnswCandidate *hc = llast(so->w);
+		HnswElement element = HnswPtrAccess(base, hc->element);
 		ItemPointer heaptid;

 		/* Move to next element if no valid heap TIDs */
-		if (hc->element->heaptidsLength == 0)
+		if (element->heaptidsLength == 0)
 		{
 			so->w = list_delete_last(so->w);
 			continue;
 		}

-		heaptid = &hc->element->heaptids[--hc->element->heaptidsLength];
+		heaptid = &element->heaptids[--element->heaptidsLength];

 		MemoryContextSwitchTo(oldCtx);

-#if PG_VERSION_NUM >= 120000
 		scan->xs_heaptid = *heaptid;
-#else
-		scan->xs_ctup.t_self = *heaptid;
-#endif
-
+		scan->xs_recheck = false;
 		scan->xs_recheckorderby = false;
 		return true;
 	}
--- a/src/hnswutils.c
+++ b/src/hnswutils.c
@@ -2,9 +2,13 @@

 #include <math.h>

+#include "access/generic_xlog.h"
 #include "hnsw.h"
+#include "lib/pairingheap.h"
 #include "storage/bufmgr.h"
 #include "utils/datum.h"
+#include "utils/memdebug.h"
+#include "utils/rel.h"
 #include "vector.h"

 #if PG_VERSION_NUM >= 130000
@@ -56,13 +60,6 @@ hash_tid(ItemPointerData tid)
 #define SH_DEFINE
 #include "lib/simplehash.h"

-/* Needed to include simplehash.h twice */
-#if PG_VERSION_NUM < 120000
-#undef SH_EQUAL
-#define sh_log2 pointerhash_sh_log2
-#define sh_pow2 pointerhash_sh_pow2
-#endif
-
 /* Pointer hash table */
 static uint32
 hash_pointer(uintptr_t ptr)
@@ -84,9 +81,31 @@ hash_pointer(uintptr_t ptr)
 #define SH_DEFINE
 #include "lib/simplehash.h"

+/* Offset hash table */
+static uint32
+hash_offset(Size offset)
+{
+#if SIZEOF_SIZE_T == 8
+	return murmurhash64((uint64) offset);
+#else
+	return murmurhash32((uint32) offset);
+#endif
+}
+
+#define SH_PREFIX		offsethash
+#define SH_ELEMENT_TYPE	OffsetHashEntry
+#define SH_KEY_TYPE		Size
+#define	SH_KEY			offset
+#define SH_HASH_KEY(tb, key)	hash_offset(key)
+#define SH_EQUAL(tb, a, b)		(a == b)
+#define	SH_SCOPE		extern
+#define SH_DEFINE
+#include "lib/simplehash.h"
+
 typedef union
 {
 	pointerhash_hash *pointers;
+	offsethash_hash *offsets;
 	tidhash_hash *tids;
 }			visited_hash;

@@ -184,35 +203,53 @@ HnswInitPage(Buffer buf, Page page)
 	HnswPageGetOpaque(page)->page_id = HNSW_PAGE_ID;
 }

+/*
+ * Allocate a neighbor array
+ */
+static HnswNeighborArray *
+HnswInitNeighborArray(int lm, HnswAllocator * allocator)
+{
+	HnswNeighborArray *a = HnswAlloc(allocator, HNSW_NEIGHBOR_ARRAY_SIZE(lm));
+
+	a->length = 0;
+	a->closerSet = false;
+	return a;
+}
+
 /*
 * Allocate neighbors
 */
 void
-HnswInitNeighbors(HnswElement element, int m)
+HnswInitNeighbors(char *base, HnswElement element, int m, HnswAllocator * allocator)
 {
 	int			level = element->level;
+	HnswNeighborArrayPtr *neighborList = (HnswNeighborArrayPtr *) HnswAlloc(allocator, sizeof(HnswNeighborArrayPtr) * (level + 1));

-	element->neighbors = palloc(sizeof(HnswNeighborArray) * (level + 1));
+	HnswPtrStore(base, element->neighbors, neighborList);

 	for (int lc = 0; lc <= level; lc++)
-	{
-		HnswNeighborArray *a;
-		int			lm = HnswGetLayerM(m, lc);
+		HnswPtrStore(base, neighborList[lc], HnswInitNeighborArray(HnswGetLayerM(m, lc), allocator));
+}

-		a = &element->neighbors[lc];
-		a->length = 0;
-		a->items = palloc(sizeof(HnswCandidate) * lm);
-		a->closerSet = false;
-	}
+/*
+ * Allocate memory from the allocator
+ */
+void *
+HnswAlloc(HnswAllocator * allocator, Size size)
+{
+	if (allocator)
+		return (*(allocator)->alloc) (size, (allocator)->state);
+
+	return palloc(size);
 }

 /*
 * Allocate an element
 */
 HnswElement
-HnswInitElement(ItemPointer heaptid, int m, double ml, int maxLevel)
+HnswInitElement(char *base, ItemPointer heaptid, int m, double ml, int maxLevel, HnswAllocator * allocator)
 {
-	HnswElement element = palloc(sizeof(HnswElementData));
+	HnswElement element = HnswAlloc(allocator, sizeof(HnswElementData));

 	int			level = (int) (-log(RandomDouble()) * ml);

@@ -226,9 +263,9 @@ HnswInitElement(ItemPointer heaptid, int m, double ml, int maxLevel)
 	element->level = level;
 	element->deleted = 0;

-	HnswInitNeighbors(element, m);
+	HnswInitNeighbors(base, element, m, allocator);

-	element->value = PointerGetDatum(NULL);
+	HnswPtrStore(base, element->value, (Pointer) NULL);

 	return element;
 }
@@ -249,11 +286,12 @@ HnswElement
 HnswInitElementFromBlock(BlockNumber blkno, OffsetNumber offno)
 {
 	HnswElement element = palloc(sizeof(HnswElementData));
+	char	   *base = NULL;

 	element->blkno = blkno;
 	element->offno = offno;
-	element->neighbors = NULL;
-	element->value = PointerGetDatum(NULL);
+	HnswPtrStore(base, element->neighbors, (HnswNeighborArrayPtr *) NULL);
+	HnswPtrStore(base, element->value, (Pointer) NULL);
 	return element;
 }

@@ -278,7 +316,10 @@ HnswGetMetaPageInfo(Relation index, int *m, HnswElement * entryPoint)
 	if (entryPoint != NULL)
 	{
 		if (BlockNumberIsValid(metap->entryBlkno))
+		{
 			*entryPoint = HnswInitElementFromBlock(metap->entryBlkno, metap->entryOffno);
+			(*entryPoint)->level = metap->entryLevel;
+		}
 		else
 			*entryPoint = NULL;
 	}
@@ -363,8 +404,10 @@ HnswUpdateMetaPage(Relation index, int updateEntry, HnswElement entryPoint, Bloc
 * Set element tuple, except for neighbor info
 */
 void
-HnswSetElementTuple(HnswElementTuple etup, HnswElement element)
+HnswSetElementTuple(char *base, HnswElementTuple etup, HnswElement element)
 {
+	Pointer		valuePtr = HnswPtrAccess(base, element->value);
+
 	etup->type = HNSW_ELEMENT_TUPLE_TYPE;
 	etup->level = element->level;
 	etup->deleted = 0;
@@ -375,14 +418,14 @@ HnswSetElementTuple(HnswElementTuple etup, HnswElement element)
 		else
 			ItemPointerSetInvalid(&etup->heaptids[i]);
 	}
-	memcpy(&etup->data, DatumGetPointer(element->value), VARSIZE_ANY(DatumGetPointer(element->value)));
+	memcpy(&etup->data, valuePtr, VARSIZE_ANY(valuePtr));
 }

 /*
 * Set neighbor tuple
 */
 void
-HnswSetNeighborTuple(HnswNeighborTuple ntup, HnswElement e, int m)
+HnswSetNeighborTuple(char *base, HnswNeighborTuple ntup, HnswElement e, int m)
 {
 	int			idx = 0;

@@ -390,7 +433,7 @@ HnswSetNeighborTuple(HnswNeighborTuple ntup, HnswElement e, int m)

 	for (int lc = e->level; lc >= 0; lc--)
 	{
-		HnswNeighborArray *neighbors = HnswGetNeighbors(e, lc);
+		HnswNeighborArray *neighbors = HnswGetNeighbors(base, e, lc);
 		int			lm = HnswGetLayerM(m, lc);

 		for (int i = 0; i < lm; i++)
@@ -400,8 +443,9 @@ HnswSetNeighborTuple(HnswNeighborTuple ntup, HnswElement e, int m)
 			if (i < neighbors->length)
 			{
 				HnswCandidate *hc = &neighbors->items[i];
+				HnswElement hce = HnswPtrAccess(base, hc->element);

-				ItemPointerSet(indextid, hc->element->blkno, hc->element->offno);
+				ItemPointerSet(indextid, hce->blkno, hce->offno);
 			}
 			else
 				ItemPointerSetInvalid(indextid);
@@ -417,12 +461,14 @@ HnswSetNeighborTuple(HnswNeighborTuple ntup, HnswElement e, int m)
 static void
 LoadNeighborsFromPage(HnswElement element, Relation index, Page page, int m)
 {
+	char	   *base = NULL;
+
 	HnswNeighborTuple ntup = (HnswNeighborTuple) PageGetItem(page, PageGetItemId(page, element->neighborOffno));
 	int			neighborCount = (element->level + 2) * m;

 	Assert(HnswIsNeighborTuple(ntup));

-	HnswInitNeighbors(element, m);
+	HnswInitNeighbors(base, element, m, NULL);

 	/* Ensure expected neighbors */
 	if (ntup->count != neighborCount)
@@ -448,9 +494,9 @@ LoadNeighborsFromPage(HnswElement element, Relation index, Page page, int m)
 		if (level < 0)
 			level = 0;

-		neighbors = HnswGetNeighbors(element, level);
+		neighbors = HnswGetNeighbors(base, element, level);
 		hc = &neighbors->items[neighbors->length++];
-		hc->element = e;
+		HnswPtrStore(base, hc->element, e);
 	}
 }

@@ -497,7 +543,12 @@ HnswLoadElementFromTuple(HnswElement element, HnswElementTuple etup, bool loadHe
 	}

 	if (loadVec)
-		element->value = datumCopy(PointerGetDatum(&etup->data), false, -1);
+	{
+		char	   *base = NULL;
+		Datum		value = datumCopy(PointerGetDatum(&etup->data), false, -1);
+
+		HnswPtrStore(base, element->value, DatumGetPointer(value));
+	}
 }

 /*
@@ -533,24 +584,27 @@ HnswLoadElement(HnswElement element, float *distance, Datum *q, Relation index,
 * Get the distance for a candidate
 */
 static float
-GetCandidateDistance(HnswCandidate * hc, Datum q, FmgrInfo *procinfo, Oid collation)
+GetCandidateDistance(char *base, HnswCandidate * hc, Datum q, FmgrInfo *procinfo, Oid collation)
 {
-	return DatumGetFloat8(FunctionCall2Coll(procinfo, collation, q, hc->element->value));
+	HnswElement hce = HnswPtrAccess(base, hc->element);
+	Datum		value = HnswGetValue(base, hce);
+
+	return DatumGetFloat8(FunctionCall2Coll(procinfo, collation, q, value));
 }

 /*
 * Create a candidate for the entry point
 */
 HnswCandidate *
-HnswEntryCandidate(HnswElement entryPoint, Datum q, Relation index, FmgrInfo *procinfo, Oid collation, bool loadVec)
+HnswEntryCandidate(char *base, HnswElement entryPoint, Datum q, Relation index, FmgrInfo *procinfo, Oid collation, bool loadVec)
 {
 	HnswCandidate *hc = palloc(sizeof(HnswCandidate));

-	hc->element = entryPoint;
+	HnswPtrStore(base, hc->element, entryPoint);
 	if (index == NULL)
-		hc->distance = GetCandidateDistance(hc, q, procinfo, collation);
+		hc->distance = GetCandidateDistance(base, hc, q, procinfo, collation);
 	else
-		HnswLoadElement(hc->element, &hc->distance, &q, index, procinfo, collation, loadVec);
+		HnswLoadElement(entryPoint, &hc->distance, &q, index, procinfo, collation, loadVec);
 	return hc;
 }

@@ -596,34 +650,79 @@ CreatePairingHeapNode(HnswCandidate * c)
 	return node;
 }

+/*
+ * Init visited
+ */
+static inline void
+InitVisited(char *base, visited_hash * v, Relation index, int ef, int m)
+{
+	if (index != NULL)
+		v->tids = tidhash_create(CurrentMemoryContext, ef * m * 2, NULL);
+	else if (base != NULL)
+		v->offsets = offsethash_create(CurrentMemoryContext, ef * m * 2, NULL);
+	else
+		v->pointers = pointerhash_create(CurrentMemoryContext, ef * m * 2, NULL);
+}
+
 /*
 * Add to visited
 */
 static inline void
-AddToVisited(visited_hash v, HnswCandidate * hc, Relation index, bool *found)
+AddToVisited(char *base, visited_hash * v, HnswCandidate * hc, Relation index, bool *found)
 {
-	if (index == NULL)
+	if (index != NULL)
+	{
+		HnswElement element = HnswPtrAccess(base, hc->element);
+		ItemPointerData indextid;
+
+		ItemPointerSet(&indextid, element->blkno, element->offno);
+		tidhash_insert(v->tids, indextid, found);
+	}
+	else if (base != NULL)
 	{
 #if PG_VERSION_NUM >= 130000
-		pointerhash_insert_hash(v.pointers, (uintptr_t) hc->element, hc->element->hash, found);
+		HnswElement element = HnswPtrAccess(base, hc->element);
+
+		offsethash_insert_hash(v->offsets, HnswPtrOffset(hc->element), element->hash, found);
 #else
-		pointerhash_insert(v.pointers, (uintptr_t) hc->element, found);
+		offsethash_insert(v->offsets, HnswPtrOffset(hc->element), found);
 #endif
 	}
 	else
 	{
-		ItemPointerData indextid;
+#if PG_VERSION_NUM >= 130000
+		HnswElement element = HnswPtrAccess(base, hc->element);

-		ItemPointerSet(&indextid, hc->element->blkno, hc->element->offno);
-		tidhash_insert(v.tids, indextid, found);
+		pointerhash_insert_hash(v->pointers, (uintptr_t) HnswPtrPointer(hc->element), element->hash, found);
+#else
+		pointerhash_insert(v->pointers, (uintptr_t) HnswPtrPointer(hc->element), found);
+#endif
 	}
 }

+/*
+ * Count element towards ef
+ */
+static inline bool
+CountElement(char *base, HnswElement skipElement, HnswCandidate * hc)
+{
+	HnswElement e;
+
+	if (skipElement == NULL)
+		return true;
+
+	/* Ensure does not access heaptidsLength during in-memory build */
+	pg_memory_barrier();
+
+	e = HnswPtrAccess(base, hc->element);
+	return e->heaptidsLength != 0;
+}
+
 /*
 * Algorithm 2 from paper
 */
 List *
-HnswSearchLayer(Datum q, List *ep, int ef, int lc, Relation index, FmgrInfo *procinfo, Oid collation, int m, bool inserting, HnswElement skipElement)
+HnswSearchLayer(char *base, Datum q, List *ep, int ef, int lc, Relation index, FmgrInfo *procinfo, Oid collation, int m, bool inserting, HnswElement skipElement)
 {
 	List	   *w = NIL;
 	pairingheap *C = pairingheap_allocate(CompareNearestCandidates, NULL);
@@ -631,12 +730,17 @@ HnswSearchLayer(Datum q, List *ep, int ef, int lc, Relation index, FmgrInfo *pro
 	int			wlen = 0;
 	visited_hash v;
 	ListCell   *lc2;
+	HnswNeighborArray *neighborhoodData = NULL;
+	Size		neighborhoodSize;

-	/* Create hash table */
+	InitVisited(base, &v, index, ef, m);
+
+	/* Create local memory for neighborhood if needed */
 	if (index == NULL)
-		v.pointers = pointerhash_create(CurrentMemoryContext, ef * m * 2, NULL);
-	else
-		v.tids = tidhash_create(CurrentMemoryContext, ef * m * 2, NULL);
+	{
+		neighborhoodSize = HNSW_NEIGHBOR_ARRAY_SIZE(HnswGetLayerM(m, lc));
+		neighborhoodData = palloc(neighborhoodSize);
+	}

 	/* Add entry points to v, C, and W */
 	foreach(lc2, ep)
@@ -644,7 +748,7 @@ HnswSearchLayer(Datum q, List *ep, int ef, int lc, Relation index, FmgrInfo *pro
 		HnswCandidate *hc = (HnswCandidate *) lfirst(lc2);
 		bool		found;

-		AddToVisited(v, hc, index, &found);
+		AddToVisited(base, &v, hc, index, &found);

 		pairingheap_add(C, &(CreatePairingHeapNode(hc)->ph_node));
 		pairingheap_add(W, &(CreatePairingHeapNode(hc)->ph_node));
@@ -654,7 +758,7 @@ HnswSearchLayer(Datum q, List *ep, int ef, int lc, Relation index, FmgrInfo *pro
 		 * would be ideal to do this for inserts as well, but this could
 		 * affect insert performance.
 		 */
-		if (skipElement == NULL || hc->element->heaptidsLength != 0)
+		if (CountElement(base, skipElement, hc))
 			wlen++;
 	}

@@ -663,38 +767,51 @@ HnswSearchLayer(Datum q, List *ep, int ef, int lc, Relation index, FmgrInfo *pro
 		HnswNeighborArray *neighborhood;
 		HnswCandidate *c = ((HnswPairingHeapNode *) pairingheap_remove_first(C))->inner;
 		HnswCandidate *f = ((HnswPairingHeapNode *) pairingheap_first(W))->inner;
+		HnswElement cElement;

 		if (c->distance > f->distance)
 			break;

-		if (c->element->neighbors == NULL)
-			HnswLoadNeighbors(c->element, index, m);
+		cElement = HnswPtrAccess(base, c->element);
+
+		if (HnswPtrIsNull(base, cElement->neighbors))
+			HnswLoadNeighbors(cElement, index, m);

 		/* Get the neighborhood at layer lc */
-		neighborhood = HnswGetNeighbors(c->element, lc);
+		neighborhood = HnswGetNeighbors(base, cElement, lc);
+
+		/* Copy neighborhood to local memory if needed */
+		if (index == NULL)
+		{
+			LWLockAcquire(&cElement->lock, LW_SHARED);
+			memcpy(neighborhoodData, neighborhood, neighborhoodSize);
+			LWLockRelease(&cElement->lock);
+			neighborhood = neighborhoodData;
+		}

 		for (int i = 0; i < neighborhood->length; i++)
 		{
 			HnswCandidate *e = &neighborhood->items[i];
 			bool		visited;

-			AddToVisited(v, e, index, &visited);
+			AddToVisited(base, &v, e, index, &visited);

 			if (!visited)
 			{
 				float		eDistance;
+				HnswElement eElement = HnswPtrAccess(base, e->element);

 				f = ((HnswPairingHeapNode *) pairingheap_first(W))->inner;

 				if (index == NULL)
-					eDistance = GetCandidateDistance(e, q, procinfo, collation);
+					eDistance = GetCandidateDistance(base, e, q, procinfo, collation);
 				else
-					HnswLoadElement(e->element, &eDistance, &q, index, procinfo, collation, inserting);
+					HnswLoadElement(eElement, &eDistance, &q, index, procinfo, collation, inserting);

-				Assert(!e->element->deleted);
+				Assert(!eElement->deleted);

 				/* Make robust to issues */
-				if (e->element->level < lc)
+				if (eElement->level < lc)
 					continue;

 				if (eDistance < f->distance || wlen < ef)
@@ -702,7 +819,7 @@ HnswSearchLayer(Datum q, List *ep, int ef, int lc, Relation index, FmgrInfo *pro
 					/* Copy e */
 					HnswCandidate *ec = palloc(sizeof(HnswCandidate));

-					ec->element = e->element;
+					HnswPtrStore(base, ec->element, eElement);
 					ec->distance = eDistance;

 					pairingheap_add(C, &(CreatePairingHeapNode(ec)->ph_node));
@@ -713,7 +830,7 @@ HnswSearchLayer(Datum q, List *ep, int ef, int lc, Relation index, FmgrInfo *pro
 					 * vacuuming. It would be ideal to do this for inserts as
 					 * well, but this could affect insert performance.
 					 */
-					if (skipElement == NULL || e->element->heaptidsLength != 0)
+					if (CountElement(base, skipElement, e))
 					{
 						wlen++;

@@ -738,17 +855,20 @@ HnswSearchLayer(Datum q, List *ep, int ef, int lc, Relation index, FmgrInfo *pro
 }

 /*
- * Compare candidate distances
+ * Compare candidate distances with pointer tie-breaker
 */
 static int
 #if PG_VERSION_NUM >= 130000
 CompareCandidateDistances(const ListCell *a, const ListCell *b)
+{
+	HnswCandidate *hca = lfirst(a);
+	HnswCandidate *hcb = lfirst(b);
 #else
 CompareCandidateDistances(const void *a, const void *b)
-#endif
 {
-	HnswCandidate *hca = lfirst((ListCell *) a);
-	HnswCandidate *hcb = lfirst((ListCell *) b);
+	HnswCandidate *hca = lfirst(*(ListCell **) a);
+	HnswCandidate *hcb = lfirst(*(ListCell **) b);
+#endif

 	if (hca->distance < hcb->distance)
 		return 1;
@@ -756,10 +876,41 @@ CompareCandidateDistances(const void *a, const void *b)
 	if (hca->distance > hcb->distance)
 		return -1;

-	if (hca->element < hcb->element)
+	if (HnswPtrPointer(hca->element) < HnswPtrPointer(hcb->element))
 		return 1;

-	if (hca->element > hcb->element)
+	if (HnswPtrPointer(hca->element) > HnswPtrPointer(hcb->element))
+		return -1;
+
+	return 0;
+}
+
+/*
+ * Compare candidate distances with offset tie-breaker
+ */
+static int
+#if PG_VERSION_NUM >= 130000
+CompareCandidateDistancesOffset(const ListCell *a, const ListCell *b)
+{
+	HnswCandidate *hca = lfirst(a);
+	HnswCandidate *hcb = lfirst(b);
+#else
+CompareCandidateDistancesOffset(const void *a, const void *b)
+{
+	HnswCandidate *hca = lfirst(*(ListCell **) a);
+	HnswCandidate *hcb = lfirst(*(ListCell **) b);
+#endif
+
+	if (hca->distance < hcb->distance)
+		return 1;
+
+	if (hca->distance > hcb->distance)
+		return -1;
+
+	if (HnswPtrOffset(hca->element) < HnswPtrOffset(hcb->element))
+		return 1;
+
+	if (HnswPtrOffset(hca->element) > HnswPtrOffset(hcb->element))
 		return -1;

 	return 0;
@@ -769,46 +920,28 @@ CompareCandidateDistances(const void *a, const void *b)
 * Calculate the distance between elements
 */
 static float
-HnswGetDistance(HnswElement a, HnswElement b, int lc, FmgrInfo *procinfo, Oid collation)
+HnswGetDistance(char *base, HnswElement a, HnswElement b, FmgrInfo *procinfo, Oid collation)
 {
-	/* Look for cached distance */
-	if (a->neighbors != NULL)
-	{
-		HnswNeighborArray *neighbors = HnswGetNeighbors(a, lc);
+	Datum		aValue = HnswGetValue(base, a);
+	Datum		bValue = HnswGetValue(base, b);

-		for (int i = 0; i < neighbors->length; i++)
-		{
-			if (neighbors->items[i].element == b)
-				return neighbors->items[i].distance;
-		}
-	}
-
-	if (b->neighbors != NULL)
-	{
-		HnswNeighborArray *neighbors = HnswGetNeighbors(b, lc);
-
-		for (int i = 0; i < neighbors->length; i++)
-		{
-			if (neighbors->items[i].element == a)
-				return neighbors->items[i].distance;
-		}
-	}
-
-	return DatumGetFloat8(FunctionCall2Coll(procinfo, collation, a->value, b->value));
+	return DatumGetFloat8(FunctionCall2Coll(procinfo, collation, aValue, bValue));
 }

 /*
 * Check if an element is closer to q than any element from R
 */
 static bool
-CheckElementCloser(HnswCandidate * e, List *r, int lc, FmgrInfo *procinfo, Oid collation)
+CheckElementCloser(char *base, HnswCandidate * e, List *r, FmgrInfo *procinfo, Oid collation)
 {
+	HnswElement eElement = HnswPtrAccess(base, e->element);
 	ListCell   *lc2;

 	foreach(lc2, r)
 	{
 		HnswCandidate *ri = lfirst(lc2);
-		float		distance = HnswGetDistance(e->element, ri->element, lc, procinfo, collation);
+		HnswElement riElement = HnswPtrAccess(base, ri->element);
+		float		distance = HnswGetDistance(base, eElement, riElement, procinfo, collation);

 		if (distance <= e->distance)
 			return false;
@@ -821,26 +954,33 @@ CheckElementCloser(HnswCandidate * e, List *r, int lc, FmgrInfo *procinfo, Oid c
 * Algorithm 4 from paper
 */
 static List *
-SelectNeighbors(List *c, int m, int lc, FmgrInfo *procinfo, Oid collation, HnswElement e2, HnswCandidate * newCandidate, HnswCandidate * *pruned, bool sortCandidates)
+SelectNeighbors(char *base, List *c, int lm, int lc, FmgrInfo *procinfo, Oid collation, HnswElement e2, HnswCandidate * newCandidate, HnswCandidate * *pruned, bool sortCandidates)
 {
 	List	   *r = NIL;
 	List	   *w = list_copy(c);
-	pairingheap *wd;
-	HnswNeighborArray *neighbors = HnswGetNeighbors(e2, lc);
+	HnswCandidate **wd;
+	int			wdlen = 0;
+	int			wdoff = 0;
+	HnswNeighborArray *neighbors = HnswGetNeighbors(base, e2, lc);
 	bool		mustCalculate = !neighbors->closerSet;
 	List	   *added = NIL;
 	bool		removedAny = false;

-	if (list_length(w) <= m)
+	if (list_length(w) <= lm)
 		return w;

-	wd = pairingheap_allocate(CompareNearestCandidates, NULL);
+	wd = palloc(sizeof(HnswCandidate *) * list_length(w));

 	/* Ensure order of candidates is deterministic for closer caching */
 	if (sortCandidates)
-		list_sort(w, CompareCandidateDistances);
+	{
+		if (base == NULL)
+			list_sort(w, CompareCandidateDistances);
+		else
+			list_sort(w, CompareCandidateDistancesOffset);
+	}

-	while (list_length(w) > 0 && list_length(r) < m)
+	while (list_length(w) > 0 && list_length(r) < lm)
 	{
 		/* Assumes w is already ordered desc */
 		HnswCandidate *e = llast(w);
@@ -849,16 +989,20 @@ SelectNeighbors(List *c, int m, int lc, FmgrInfo *procinfo, Oid collation, HnswE

 		/* Use previous state of r and wd to skip work when possible */
 		if (mustCalculate)
-			e->closer = CheckElementCloser(e, r, lc, procinfo, collation);
+			e->closer = CheckElementCloser(base, e, r, procinfo, collation);
 		else if (list_length(added) > 0)
 		{
+			/* Keep Valgrind happy for in-memory, parallel builds */
+			if (base != NULL)
+				VALGRIND_MAKE_MEM_DEFINED(&e->closer, 1);
+
 			/*
 			 * If the current candidate was closer, we only need to compare it
 			 * with the other candidates that we have added.
 			 */
 			if (e->closer)
 			{
-				e->closer = CheckElementCloser(e, added, lc, procinfo, collation);
+				e->closer = CheckElementCloser(base, e, added, procinfo, collation);

 				if (!e->closer)
 					removedAny = true;
@@ -871,7 +1015,7 @@ SelectNeighbors(List *c, int m, int lc, FmgrInfo *procinfo, Oid collation, HnswE
 				 */
 				if (removedAny)
 				{
-					e->closer = CheckElementCloser(e, r, lc, procinfo, collation);
+					e->closer = CheckElementCloser(base, e, r, procinfo, collation);
 					if (e->closer)
 						added = lappend(added, e);
 				}
@@ -879,29 +1023,33 @@ SelectNeighbors(List *c, int m, int lc, FmgrInfo *procinfo, Oid collation, HnswE
 		}
 		else if (e == newCandidate)
 		{
-			e->closer = CheckElementCloser(e, r, lc, procinfo, collation);
+			e->closer = CheckElementCloser(base, e, r, procinfo, collation);
 			if (e->closer)
 				added = lappend(added, e);
 		}

+		/* Keep Valgrind happy for in-memory, parallel builds */
+		if (base != NULL)
+			VALGRIND_MAKE_MEM_DEFINED(&e->closer, 1);
+
 		if (e->closer)
 			r = lappend(r, e);
 		else
-			pairingheap_add(wd, &(CreatePairingHeapNode(e)->ph_node));
+			wd[wdlen++] = e;
 	}

 	/* Cached value can only be used in future if sorted deterministically */
 	neighbors->closerSet = sortCandidates;

 	/* Keep pruned connections */
-	while (!pairingheap_is_empty(wd) && list_length(r) < m)
-		r = lappend(r, ((HnswPairingHeapNode *) pairingheap_remove_first(wd))->inner);
+	while (wdoff < wdlen && list_length(r) < lm)
+		r = lappend(r, wd[wdoff++]);

 	/* Return pruned for update connections */
 	if (pruned != NULL)
 	{
-		if (!pairingheap_is_empty(wd))
-			*pruned = ((HnswPairingHeapNode *) pairingheap_first(wd))->inner;
+		if (wdoff < wdlen)
+			*pruned = wd[wdoff];
 		else
 			*pruned = linitial(w);
 	}
@@ -913,10 +1061,10 @@ SelectNeighbors(List *c, int m, int lc, FmgrInfo *procinfo, Oid collation, HnswE
 * Add connections
 */
 static void
-AddConnections(HnswElement element, List *neighbors, int m, int lc)
+AddConnections(char *base, HnswElement element, List *neighbors, int lc)
 {
 	ListCell   *lc2;
-	HnswNeighborArray *a = HnswGetNeighbors(element, lc);
+	HnswNeighborArray *a = HnswGetNeighbors(base, element, lc);

 	foreach(lc2, neighbors)
 		a->items[a->length++] = *((HnswCandidate *) lfirst(lc2));
@@ -926,16 +1074,16 @@ AddConnections(HnswElement element, List *neighbors, int m, int lc)
 * Update connections
 */
 void
-HnswUpdateConnection(HnswElement element, HnswCandidate * hc, int m, int lc, int *updateIdx, Relation index, FmgrInfo *procinfo, Oid collation)
+HnswUpdateConnection(char *base, HnswElement element, HnswCandidate * hc, int lm, int lc, int *updateIdx, Relation index, FmgrInfo *procinfo, Oid collation)
 {
-	HnswNeighborArray *currentNeighbors = HnswGetNeighbors(hc->element, lc);
-
+	HnswElement hce = HnswPtrAccess(base, hc->element);
+	HnswNeighborArray *currentNeighbors = HnswGetNeighbors(base, hce, lc);
 	HnswCandidate hc2;

-	hc2.element = element;
+	HnswPtrStore(base, hc2.element, element);
 	hc2.distance = hc->distance;

-	if (currentNeighbors->length < m)
+	if (currentNeighbors->length < lm)
 	{
 		currentNeighbors->items[currentNeighbors->length++] = hc2;

@@ -951,19 +1099,20 @@ HnswUpdateConnection(HnswElement element, HnswCandidate * hc, int m, int lc, int
 		/* Load elements on insert */
 		if (index != NULL)
 		{
-			Datum		q = hc->element->value;
+			Datum		q = HnswGetValue(base, hce);

 			for (int i = 0; i < currentNeighbors->length; i++)
 			{
 				HnswCandidate *hc3 = &currentNeighbors->items[i];
+				HnswElement hc3Element = HnswPtrAccess(base, hc3->element);

-				if (DatumGetPointer(hc3->element->value) == NULL)
-					HnswLoadElement(hc3->element, &hc3->distance, &q, index, procinfo, collation, true);
+				if (HnswPtrIsNull(base, hc3Element->value))
+					HnswLoadElement(hc3Element, &hc3->distance, &q, index, procinfo, collation, true);
 				else
-					hc3->distance = GetCandidateDistance(hc3, q, procinfo, collation);
+					hc3->distance = GetCandidateDistance(base, hc3, q, procinfo, collation);

 				/* Prune element if being deleted */
-				if (hc3->element->heaptidsLength == 0)
+				if (hc3Element->heaptidsLength == 0)
 				{
 					pruned = &currentNeighbors->items[i];
 					break;
@@ -980,7 +1129,7 @@ HnswUpdateConnection(HnswElement element, HnswCandidate * hc, int m, int lc, int
 				c = lappend(c, &currentNeighbors->items[i]);
 			c = lappend(c, &hc2);

-			SelectNeighbors(c, m, lc, procinfo, collation, hc->element, &hc2, &pruned, true);
+			SelectNeighbors(base, c, lm, lc, procinfo, collation, hce, &hc2, &pruned, true);

 			/* Should not happen */
 			if (pruned == NULL)
@@ -990,7 +1139,7 @@ HnswUpdateConnection(HnswElement element, HnswCandidate * hc, int m, int lc, int
 		/* Find and replace the pruned element */
 		for (int i = 0; i < currentNeighbors->length; i++)
 		{
-			if (currentNeighbors->items[i].element == pruned->element)
+			if (HnswPtrEqual(base, currentNeighbors->items[i].element, pruned->element))
 			{
 				currentNeighbors->items[i] = hc2;

@@ -1008,43 +1157,65 @@ HnswUpdateConnection(HnswElement element, HnswCandidate * hc, int m, int lc, int
 * Remove elements being deleted or skipped
 */
 static List *
-RemoveElements(List *w, HnswElement skipElement)
+RemoveElements(char *base, List *w, HnswElement skipElement)
 {
 	ListCell   *lc2;
 	List	   *w2 = NIL;

+	/* Ensure does not access heaptidsLength during in-memory build */
+	pg_memory_barrier();
+
 	foreach(lc2, w)
 	{
 		HnswCandidate *hc = (HnswCandidate *) lfirst(lc2);
+		HnswElement hce = HnswPtrAccess(base, hc->element);

 		/* Skip self for vacuuming update */
-		if (skipElement != NULL && hc->element->blkno == skipElement->blkno && hc->element->offno == skipElement->offno)
+		if (skipElement != NULL && hce->blkno == skipElement->blkno && hce->offno == skipElement->offno)
 			continue;

-		if (hc->element->heaptidsLength != 0)
+		if (hce->heaptidsLength != 0)
 			w2 = lappend(w2, hc);
 	}

 	return w2;
 }

+#if PG_VERSION_NUM >= 130000
+/*
+ * Precompute hash
+ */
+static void
+PrecomputeHash(char *base, HnswElement element)
+{
+	HnswElementPtr ptr;
+
+	HnswPtrStore(base, ptr, element);
+
+	if (base == NULL)
+		element->hash = hash_pointer((uintptr_t) HnswPtrPointer(ptr));
+	else
+		element->hash = hash_offset(HnswPtrOffset(ptr));
+}
+#endif
+
 /*
 * Algorithm 1 from paper
 */
 void
-HnswInsertElement(HnswElement element, HnswElement entryPoint, Relation index, FmgrInfo *procinfo, Oid collation, int m, int efConstruction, bool existing)
+HnswFindElementNeighbors(char *base, HnswElement element, HnswElement entryPoint, Relation index, FmgrInfo *procinfo, Oid collation, int m, int efConstruction, bool existing)
 {
 	List	   *ep;
 	List	   *w;
 	int			level = element->level;
 	int			entryLevel;
-	Datum		q = element->value;
+	Datum		q = HnswGetValue(base, element);
 	HnswElement skipElement = existing ? element : NULL;

 #if PG_VERSION_NUM >= 130000
 	/* Precompute hash */
 	if (index == NULL)
-		element->hash = hash_pointer((uintptr_t) element);
+		PrecomputeHash(base, element);
 #endif

 	/* No neighbors if no entry point */
@@ -1052,13 +1223,13 @@ HnswInsertElement(HnswElement element, HnswElement entryPoint, Relation index, F
 		return;

 	/* Get entry point and level */
-	ep = list_make1(HnswEntryCandidate(entryPoint, q, index, procinfo, collation, true));
+	ep = list_make1(HnswEntryCandidate(base, entryPoint, q, index, procinfo, collation, true));
 	entryLevel = entryPoint->level;

 	/* 1st phase: greedy search to insert level */
 	for (int lc = entryLevel; lc >= level + 1; lc--)
 	{
-		w = HnswSearchLayer(q, ep, 1, lc, index, procinfo, collation, m, true, skipElement);
+		w = HnswSearchLayer(base, q, ep, 1, lc, index, procinfo, collation, m, true, skipElement);
 		ep = w;
 	}

@@ -1076,12 +1247,12 @@ HnswInsertElement(HnswElement element, HnswElement entryPoint, Relation index, F
 		List	   *neighbors;
 		List	   *lw;

-		w = HnswSearchLayer(q, ep, efConstruction, lc, index, procinfo, collation, m, true, skipElement);
+		w = HnswSearchLayer(base, q, ep, efConstruction, lc, index, procinfo, collation, m, true, skipElement);

 		/* Elements being deleted or skipped can help with search */
 		/* but should be removed before selecting neighbors */
 		if (index != NULL)
-			lw = RemoveElements(w, skipElement);
+			lw = RemoveElements(base, w, skipElement);
 		else
 			lw = w;

@@ -1090,9 +1261,9 @@ HnswInsertElement(HnswElement element, HnswElement entryPoint, Relation index, F
 		 * sortCandidates to true for in-memory builds to enable closer
 		 * caching, but there does not seem to be a difference in performance.
 		 */
-		neighbors = SelectNeighbors(lw, lm, lc, procinfo, collation, element, NULL, NULL, false);
+		neighbors = SelectNeighbors(base, lw, lm, lc, procinfo, collation, element, NULL, NULL, false);

-		AddConnections(element, neighbors, lm, lc);
+		AddConnections(base, element, neighbors, lc);

 		ep = w;
 	}
--- a/src/hnswvacuum.c
+++ b/src/hnswvacuum.c
@@ -2,6 +2,7 @@

 #include <math.h>

+#include "access/generic_xlog.h"
 #include "commands/vacuum.h"
 #include "hnsw.h"
 #include "storage/bufmgr.h"
@@ -59,8 +60,7 @@ RemoveHeapTids(HnswVacuumState * vacuumstate)
 		/* Iterate over nodes */
 		for (offno = FirstOffsetNumber; offno <= maxoffno; offno = OffsetNumberNext(offno))
 		{
-			ItemId		itemid = PageGetItemId(page, offno);
-			HnswElementTuple etup = (HnswElementTuple) PageGetItem(page, itemid);
+			HnswElementTuple etup = (HnswElementTuple) PageGetItem(page, PageGetItemId(page, offno));
 			int			idx = 0;
 			bool		itemUpdated = false;

@@ -91,15 +91,10 @@ RemoveHeapTids(HnswVacuumState * vacuumstate)

 				if (itemUpdated)
 				{
-					Size		etupSize = ItemIdGetLength(itemid);
-
 					/* Mark rest as invalid */
 					for (int i = idx; i < HNSW_HEAPTIDS; i++)
 						ItemPointerSetInvalid(&etup->heaptids[i]);

-					if (!PageIndexTupleOverwrite(page, offno, (Item) etup, etupSize))
-						elog(ERROR, "failed to add index item to \"%s\"", RelationGetRelationName(index));
-
 					updated = true;
 				}
 			}
@@ -199,21 +194,25 @@ RepairGraphElement(HnswVacuumState * vacuumstate, HnswElement element, HnswEleme
 	BufferAccessStrategy bas = vacuumstate->bas;
 	HnswNeighborTuple ntup = vacuumstate->ntup;
 	Size		ntupSize = HNSW_NEIGHBOR_TUPLE_SIZE(element->level, m);
+	char	   *base = NULL;

 	/* Skip if element is entry point */
 	if (entryPoint != NULL && element->blkno == entryPoint->blkno && element->offno == entryPoint->offno)
 		return;

 	/* Init fields */
-	HnswInitNeighbors(element, m);
+	HnswInitNeighbors(base, element, m, NULL);
 	element->heaptidsLength = 0;

-	/* Add element to graph, skipping itself */
-	HnswInsertElement(element, entryPoint, index, procinfo, collation, m, efConstruction, true);
+	/* Find neighbors for element, skipping itself */
+	HnswFindElementNeighbors(base, element, entryPoint, index, procinfo, collation, m, efConstruction, true);
+
+	/* Zero memory for each element */
+	MemSet(ntup, 0, HNSW_TUPLE_ALLOC_SIZE);

 	/* Update neighbor tuple */
 	/* Do this before getting page to minimize locking */
-	HnswSetNeighborTuple(ntup, element, m);
+	HnswSetNeighborTuple(base, ntup, element, m);

 	/* Get neighbor page */
 	buf = ReadBufferExtended(index, MAIN_FORKNUM, element->neighborPage, RBM_NORMAL, bas);
@@ -230,7 +229,7 @@ RepairGraphElement(HnswVacuumState * vacuumstate, HnswElement element, HnswEleme
 	UnlockReleaseBuffer(buf);

 	/* Update neighbors */
-	HnswUpdateNeighborPages(index, procinfo, collation, element, m, true, false);
+	HnswUpdateNeighborsOnDisk(index, procinfo, collation, element, m, true, false);
 }

 /*
@@ -301,7 +300,7 @@ RepairGraphEntryPoint(HnswVacuumState * vacuumstate)
 			{
 				/* Reset neighbors from previous update */
 				if (highestPoint != NULL)
-					highestPoint->neighbors = NULL;
+					HnswPtrStore((char *) NULL, highestPoint->neighbors, (HnswNeighborArrayPtr *) NULL);

 				RepairGraphElement(vacuumstate, entryPoint, highestPoint);
 			}
@@ -477,11 +476,8 @@ MarkDeleted(HnswVacuumState * vacuumstate)
 		/* Update element and neighbors together */
 		for (offno = FirstOffsetNumber; offno <= maxoffno; offno = OffsetNumberNext(offno))
 		{
-			ItemId		itemid = PageGetItemId(page, offno);
-			HnswElementTuple etup = (HnswElementTuple) PageGetItem(page, itemid);
+			HnswElementTuple etup = (HnswElementTuple) PageGetItem(page, PageGetItemId(page, offno));
 			HnswNeighborTuple ntup;
-			Size		etupSize;
-			Size		ntupSize;
 			Buffer		nbuf;
 			Page		npage;
 			BlockNumber neighborPage;
@@ -505,10 +501,6 @@ MarkDeleted(HnswVacuumState * vacuumstate)
 			if (ItemPointerIsValid(&etup->heaptids[0]))
 				continue;

-			/* Calculate sizes */
-			etupSize = ItemIdGetLength(itemid);
-			ntupSize = HNSW_NEIGHBOR_TUPLE_SIZE(etup->level, vacuumstate->m);
-
 			/* Get neighbor page */
 			neighborPage = ItemPointerGetBlockNumber(&etup->neighbortid);
 			neighborOffno = ItemPointerGetOffsetNumber(&etup->neighbortid);
@@ -535,13 +527,10 @@ MarkDeleted(HnswVacuumState * vacuumstate)
 			for (int i = 0; i < ntup->count; i++)
 				ItemPointerSetInvalid(&ntup->indextids[i]);

-			/* Overwrite element tuple */
-			if (!PageIndexTupleOverwrite(page, offno, (Item) etup, etupSize))
-				elog(ERROR, "failed to add index item to \"%s\"", RelationGetRelationName(index));
-
-			/* Overwrite neighbor tuple */
-			if (!PageIndexTupleOverwrite(npage, neighborOffno, (Item) ntup, ntupSize))
-				elog(ERROR, "failed to add index item to \"%s\"", RelationGetRelationName(index));
+			/*
+			 * We modified the tuples in place, no need to call
+			 * PageIndexTupleOverwrite
+			 */

 			/* Commit */
 			GenericXLogFinish(state);
@@ -586,7 +575,7 @@ InitVacuumState(HnswVacuumState * vacuumstate, IndexVacuumInfo *info, IndexBulkD
 	vacuumstate->bas = GetAccessStrategy(BAS_BULKREAD);
 	vacuumstate->procinfo = index_getprocinfo(index, 1, HNSW_DISTANCE_PROC);
 	vacuumstate->collation = index->rd_indcollation[0];
-	vacuumstate->ntup = palloc0(BLCKSZ);
+	vacuumstate->ntup = palloc0(HNSW_TUPLE_ALLOC_SIZE);
 	vacuumstate->tmpCtx = AllocSetContextCreate(CurrentMemoryContext,
 												"Hnsw vacuum temporary context",
 												ALLOCSET_DEFAULT_SIZES);
--- a/src/ivfbuild.c
+++ b/src/ivfbuild.c
@@ -2,30 +2,25 @@

 #include <float.h>

+#include "access/table.h"
+#include "access/tableam.h"
 #include "access/parallel.h"
 #include "access/xact.h"
 #include "catalog/index.h"
 #include "catalog/pg_operator_d.h"
 #include "catalog/pg_type_d.h"
+#include "commands/progress.h"
 #include "ivfflat.h"
 #include "miscadmin.h"
+#include "optimizer/optimizer.h"
 #include "storage/bufmgr.h"
 #include "tcop/tcopprot.h"
 #include "utils/memutils.h"

 #if PG_VERSION_NUM >= 140000
 #include "utils/backend_progress.h"
-#elif PG_VERSION_NUM >= 120000
-#include "pgstat.h"
-#endif
-
-#if PG_VERSION_NUM >= 120000
-#include "access/tableam.h"
-#include "commands/progress.h"
 #else
-#define PROGRESS_CREATEIDX_SUBPHASE 0
-#define PROGRESS_CREATEIDX_TUPLES_TOTAL 0
-#define PROGRESS_CREATEIDX_TUPLES_DONE 0
+#include "pgstat.h"
 #endif

 #if PG_VERSION_NUM >= 130000
@@ -34,26 +29,11 @@
 #define CALLBACK_ITEM_POINTER HeapTuple hup
 #endif

-#if PG_VERSION_NUM >= 120000
-#define UpdateProgress(index, val) pgstat_progress_update_param(index, val)
-#else
-#define UpdateProgress(index, val) ((void)val)
-#endif
-
 #if PG_VERSION_NUM >= 140000
 #include "utils/backend_status.h"
 #include "utils/wait_event.h"
 #endif

-#if PG_VERSION_NUM >= 120000
-#include "access/table.h"
-#include "optimizer/optimizer.h"
-#else
-#include "access/heapam.h"
-#include "optimizer/planner.h"
-#include "pgstat.h"
-#endif
-
 #define PARALLEL_KEY_IVFFLAT_SHARED		UINT64CONST(0xA000000000000001)
 #define PARALLEL_KEY_TUPLESORT			UINT64CONST(0xA000000000000002)
 #define PARALLEL_KEY_IVFFLAT_CENTERS	UINT64CONST(0xA000000000000003)
@@ -150,13 +130,8 @@ SampleRows(IvfflatBuildState * buildstate)
 	{
 		BlockNumber targblock = BlockSampler_Next(&buildstate->bs);

-#if PG_VERSION_NUM >= 120000
 		table_index_build_range_scan(buildstate->heap, buildstate->index, buildstate->indexInfo,
 									 false, true, false, targblock, 1, SampleCallback, (void *) buildstate, NULL);
-#else
-		IndexBuildHeapRangeScan(buildstate->heap, buildstate->index, buildstate->indexInfo,
-								false, true, targblock, 1, SampleCallback, (void *) buildstate, NULL);
-#endif
 	}
 }

@@ -282,16 +257,12 @@ InsertTuples(Relation index, IvfflatBuildState * buildstate, ForkNumber forkNum)
 	IndexTuple	itup = NULL;	/* silence compiler warning */
 	int64		inserted = 0;

-#if PG_VERSION_NUM >= 120000
 	TupleTableSlot *slot = MakeSingleTupleTableSlot(buildstate->tupdesc, &TTSOpsMinimalTuple);
-#else
-	TupleTableSlot *slot = MakeSingleTupleTableSlot(buildstate->tupdesc);
-#endif
 	TupleDesc	tupdesc = RelationGetDescr(index);

-	UpdateProgress(PROGRESS_CREATEIDX_SUBPHASE, PROGRESS_IVFFLAT_PHASE_LOAD);
+	pgstat_progress_update_param(PROGRESS_CREATEIDX_SUBPHASE, PROGRESS_IVFFLAT_PHASE_LOAD);

-	UpdateProgress(PROGRESS_CREATEIDX_TUPLES_TOTAL, buildstate->indtuples);
+	pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_TOTAL, buildstate->indtuples);

 	GetNextTuple(buildstate->sortstate, tupdesc, slot, &itup, &list);

@@ -327,7 +298,7 @@ InsertTuples(Relation index, IvfflatBuildState * buildstate, ForkNumber forkNum)

 			pfree(itup);

-			UpdateProgress(PROGRESS_CREATEIDX_TUPLES_DONE, ++inserted);
+			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE, ++inserted);

 			GetNextTuple(buildstate->sortstate, tupdesc, slot, &itup, &list);
 		}
@@ -375,20 +346,12 @@ InitBuildState(IvfflatBuildState * buildstate, Relation heap, Relation index, In
 		elog(ERROR, "dimensions must be greater than one for this opclass");

 	/* Create tuple description for sorting */
-#if PG_VERSION_NUM >= 120000
 	buildstate->tupdesc = CreateTemplateTupleDesc(3);
-#else
-	buildstate->tupdesc = CreateTemplateTupleDesc(3, false);
-#endif
 	TupleDescInitEntry(buildstate->tupdesc, (AttrNumber) 1, "list", INT4OID, -1, 0);
 	TupleDescInitEntry(buildstate->tupdesc, (AttrNumber) 2, "tid", TIDOID, -1, 0);
 	TupleDescInitEntry(buildstate->tupdesc, (AttrNumber) 3, "vector", RelationGetDescr(index)->attrs[0].atttypid, -1, 0);

-#if PG_VERSION_NUM >= 120000
 	buildstate->slot = MakeSingleTupleTableSlot(buildstate->tupdesc, &TTSOpsVirtual);
-#else
-	buildstate->slot = MakeSingleTupleTableSlot(buildstate->tupdesc);
-#endif

 	buildstate->centers = VectorArrayInit(buildstate->lists, buildstate->dimensions);
 	buildstate->listInfo = palloc(sizeof(ListInfo) * buildstate->lists);
@@ -435,7 +398,7 @@ ComputeCenters(IvfflatBuildState * buildstate)
 {
 	int			numSamples;

-	UpdateProgress(PROGRESS_CREATEIDX_SUBPHASE, PROGRESS_IVFFLAT_PHASE_KMEANS);
+	pgstat_progress_update_param(PROGRESS_CREATEIDX_SUBPHASE, PROGRESS_IVFFLAT_PHASE_KMEANS);

 	/* Target 50 samples per list, with at least 10000 samples */
 	/* The number of samples has a large effect on index build time */
@@ -510,7 +473,7 @@ CreateListPages(Relation index, VectorArray centers, int dimensions,
 	IvfflatList list;

 	listSize = MAXALIGN(IVFFLAT_LIST_SIZE(dimensions));
-	list = palloc(listSize);
+	list = palloc0(listSize);

 	buf = IvfflatNewBuffer(index, forkNum);
 	IvfflatInitRegisterPage(index, &buf, &page, &state);
@@ -631,11 +594,7 @@ IvfflatParallelScanAndSort(IvfflatSpool * ivfspool, IvfflatShared * ivfshared, S
 {
 	SortCoordinate coordinate;
 	IvfflatBuildState buildstate;
-#if PG_VERSION_NUM >= 120000
 	TableScanDesc scan;
-#else
-	HeapScanDesc scan;
-#endif
 	double		reltuples;
 	IndexInfo  *indexInfo;

@@ -659,18 +618,11 @@ IvfflatParallelScanAndSort(IvfflatSpool * ivfspool, IvfflatShared * ivfshared, S
 	buildstate.centers->length = buildstate.centers->maxlen;
 	ivfspool->sortstate = tuplesort_begin_heap(buildstate.tupdesc, 1, attNums, sortOperators, sortCollations, nullsFirstFlags, sortmem, coordinate, false);
 	buildstate.sortstate = ivfspool->sortstate;
-#if PG_VERSION_NUM >= 120000
 	scan = table_beginscan_parallel(ivfspool->heap,
 									ParallelTableScanFromIvfflatShared(ivfshared));
 	reltuples = table_index_build_scan(ivfspool->heap, ivfspool->index, indexInfo,
 									   true, progress, BuildCallback,
 									   (void *) &buildstate, scan);
-#else
-	scan = heap_beginscan_parallel(ivfspool->heap, &ivfshared->heapdesc);
-	reltuples = IndexBuildHeapScan(ivfspool->heap, ivfspool->index, indexInfo,
-								   true, BuildCallback,
-								   (void *) &buildstate, scan);
-#endif

 	/* Execute this worker's part of the sort */
 	tuplesort_performsort(ivfspool->sortstate);
@@ -740,11 +692,7 @@ IvfflatParallelBuildMain(dsm_segment *seg, shm_toc *toc)
 	}

 	/* Open relations within worker */
-#if PG_VERSION_NUM >= 120000
 	heapRel = table_open(ivfshared->heaprelid, heapLockmode);
-#else
-	heapRel = heap_open(ivfshared->heaprelid, heapLockmode);
-#endif
 	indexRel = index_open(ivfshared->indexrelid, indexLockmode);

 	/* Initialize worker's own spool */
@@ -764,11 +712,7 @@ IvfflatParallelBuildMain(dsm_segment *seg, shm_toc *toc)

 	/* Close relations within worker */
 	index_close(indexRel, indexLockmode);
-#if PG_VERSION_NUM >= 120000
 	table_close(heapRel, heapLockmode);
-#else
-	heap_close(heapRel, heapLockmode);
-#endif
 }

 /*
@@ -793,19 +737,7 @@ IvfflatEndParallel(IvfflatLeader * ivfleader)
 static Size
 ParallelEstimateShared(Relation heap, Snapshot snapshot)
 {
-#if PG_VERSION_NUM >= 120000
 	return add_size(BUFFERALIGN(sizeof(IvfflatShared)), table_parallelscan_estimate(heap, snapshot));
-#else
-	if (!IsMVCCSnapshot(snapshot))
-	{
-		Assert(snapshot == SnapshotAny);
-		return sizeof(IvfflatShared);
-	}
-
-	return add_size(offsetof(IvfflatShared, heapdesc) +
-					offsetof(ParallelHeapScanDescData, phs_snapshot_data),
-					EstimateSnapshotSpace(snapshot));
-#endif
 }

 /*
@@ -856,11 +788,7 @@ IvfflatBeginParallel(IvfflatBuildState * buildstate, bool isconcurrent, int requ
 	/* Enter parallel mode and create context */
 	EnterParallelMode();
 	Assert(request > 0);
-#if PG_VERSION_NUM >= 120000
 	pcxt = CreateParallelContext("vector", "IvfflatParallelBuildMain", request);
-#else
-	pcxt = CreateParallelContext("vector", "IvfflatParallelBuildMain", request, true);
-#endif

 	scantuplesortstates = leaderparticipates ? request + 1 : request;

@@ -918,13 +846,9 @@ IvfflatBeginParallel(IvfflatBuildState * buildstate, bool isconcurrent, int requ
 #ifdef IVFFLAT_KMEANS_DEBUG
 	ivfshared->inertia = 0;
 #endif
-#if PG_VERSION_NUM >= 120000
 	table_parallelscan_initialize(buildstate->heap,
 								  ParallelTableScanFromIvfflatShared(ivfshared),
 								  snapshot);
-#else
-	heap_parallelscan_initialize(&ivfshared->heapdesc, buildstate->heap, snapshot);
-#endif

 	/* Store shared tuplesort-private state, for which we reserved space */
 	sharedsort = (Sharedsort *) shm_toc_allocate(pcxt->toc, estsort);
@@ -995,7 +919,7 @@ AssignTuples(IvfflatBuildState * buildstate)
 	Oid			sortCollations[] = {InvalidOid};
 	bool		nullsFirstFlags[] = {false};

-	UpdateProgress(PROGRESS_CREATEIDX_SUBPHASE, PROGRESS_IVFFLAT_PHASE_ASSIGN);
+	pgstat_progress_update_param(PROGRESS_CREATEIDX_SUBPHASE, PROGRESS_IVFFLAT_PHASE_ASSIGN);

 	/* Calculate parallel workers */
 	if (buildstate->heap != NULL)
@@ -1023,15 +947,8 @@ AssignTuples(IvfflatBuildState * buildstate)
 		if (buildstate->ivfleader)
 			buildstate->reltuples = ParallelHeapScan(buildstate);
 		else
-		{
-#if PG_VERSION_NUM >= 120000
 			buildstate->reltuples = table_index_build_scan(buildstate->heap, buildstate->index, buildstate->indexInfo,
 														   true, true, BuildCallback, (void *) buildstate, NULL);
-#else
-			buildstate->reltuples = IndexBuildHeapScan(buildstate->heap, buildstate->index, buildstate->indexInfo,
-													   true, BuildCallback, (void *) buildstate, NULL);
-#endif
-		}

 #ifdef IVFFLAT_KMEANS_DEBUG
 		PrintKmeansMetrics(buildstate);
--- a/src/ivfflat.c
+++ b/src/ivfflat.c
@@ -3,14 +3,16 @@
 #include <float.h>

 #include "access/amapi.h"
+#include "access/reloptions.h"
+#include "commands/progress.h"
 #include "commands/vacuum.h"
 #include "ivfflat.h"
 #include "utils/guc.h"
 #include "utils/selfuncs.h"
 #include "utils/spccache.h"

-#if PG_VERSION_NUM >= 120000
-#include "commands/progress.h"
+#if PG_VERSION_NUM < 150000
+#define MarkGUCPrefixReserved(x) EmitWarningsOnPlaceholders(x)
 #endif

 int			ivfflat_probes;
@@ -33,12 +35,13 @@ IvfflatInit(void)
 	DefineCustomIntVariable("ivfflat.probes", "Sets the number of probes",
 							"Valid range is 1..lists.", &ivfflat_probes,
 							IVFFLAT_DEFAULT_PROBES, IVFFLAT_MIN_LISTS, IVFFLAT_MAX_LISTS, PGC_USERSET, 0, NULL, NULL, NULL);
+
+	MarkGUCPrefixReserved("ivfflat");
 }

 /*
 * Get the name of index build phase
 */
-#if PG_VERSION_NUM >= 120000
 static char *
 ivfflatbuildphasename(int64 phasenum)
 {
@@ -56,7 +59,6 @@ ivfflatbuildphasename(int64 phasenum)
 			return NULL;
 	}
 }
-#endif

 /*
 * Estimate the cost of an index scan
@@ -72,9 +74,6 @@ ivfflatcostestimate(PlannerInfo *root, IndexPath *path, double loop_count,
 	double		ratio;
 	double		spc_seq_page_cost;
 	Relation	index;
-#if PG_VERSION_NUM < 120000
-	List	   *qinfos;
-#endif

 	/* Never use index without order */
 	if (path->indexorderbys == NULL)
@@ -105,12 +104,7 @@ ivfflatcostestimate(PlannerInfo *root, IndexPath *path, double loop_count,
 	 */
 	costs.numIndexTuples = path->indexinfo->tuples * ratio;

-#if PG_VERSION_NUM >= 120000
 	genericcostestimate(root, path, loop_count, &costs);
-#else
-	qinfos = deconstruct_indexquals(path);
-	genericcostestimate(root, path, loop_count, qinfos, &costs);
-#endif

 	get_tablespace_page_costs(path->indexinfo->reltablespace, NULL, &spc_seq_page_cost);

@@ -227,9 +221,7 @@ ivfflathandler(PG_FUNCTION_ARGS)
 	amroutine->amcostestimate = ivfflatcostestimate;
 	amroutine->amoptions = ivfflatoptions;
 	amroutine->amproperty = NULL;	/* TODO AMPROP_DISTANCE_ORDERABLE */
-#if PG_VERSION_NUM >= 120000
 	amroutine->ambuildphasename = ivfflatbuildphasename;
-#endif
 	amroutine->amvalidate = ivfflatvalidate;
 #if PG_VERSION_NUM >= 140000
 	amroutine->amadjustmembers = NULL;
--- a/src/ivfflat.h
+++ b/src/ivfflat.h
@@ -3,9 +3,10 @@

 #include "postgres.h"

+#include "access/genam.h"
 #include "access/generic_xlog.h"
 #include "access/parallel.h"
-#include "access/reloptions.h"
+#include "lib/pairingheap.h"
 #include "nodes/execnodes.h"
 #include "port.h"				/* for random() */
 #include "utils/sampling.h"
@@ -16,10 +17,6 @@
 #include "common/pg_prng.h"
 #endif

-#if PG_VERSION_NUM < 120000
-#include "access/relscan.h"
-#endif
-
 #ifdef IVFFLAT_BENCH
 #include "portability/instr_time.h"
 #endif
@@ -135,16 +132,10 @@ typedef struct IvfflatShared
 #ifdef IVFFLAT_KMEANS_DEBUG
 	double		inertia;
 #endif
-
-#if PG_VERSION_NUM < 120000
-	ParallelHeapScanDescData heapdesc;	/* must come last */
-#endif
 }			IvfflatShared;

-#if PG_VERSION_NUM >= 120000
 #define ParallelTableScanFromIvfflatShared(shared) \
 	(ParallelTableScanDesc) ((char *) (shared) + BUFFERALIGN(sizeof(IvfflatShared)))
-#endif

 typedef struct IvfflatLeader
 {
--- a/src/ivfinsert.c
+++ b/src/ivfinsert.c
@@ -2,6 +2,7 @@

 #include <float.h>

+#include "access/generic_xlog.h"
 #include "ivfflat.h"
 #include "storage/bufmgr.h"
 #include "storage/lmgr.h"
--- a/src/ivfscan.c
+++ b/src/ivfscan.c
@@ -5,6 +5,7 @@
 #include "access/relscan.h"
 #include "catalog/pg_operator_d.h"
 #include "catalog/pg_type_d.h"
+#include "lib/pairingheap.h"
 #include "ivfflat.h"
 #include "miscadmin.h"
 #include "pgstat.h"
@@ -105,12 +106,7 @@ GetScanItems(IndexScanDesc scan, Datum value)
 	IvfflatScanOpaque so = (IvfflatScanOpaque) scan->opaque;
 	TupleDesc	tupdesc = RelationGetDescr(scan->indexRelation);
 	double		tuples = 0;
-
-#if PG_VERSION_NUM >= 120000
 	TupleTableSlot *slot = MakeSingleTupleTableSlot(so->tupdesc, &TTSOpsVirtual);
-#else
-	TupleTableSlot *slot = MakeSingleTupleTableSlot(so->tupdesc);
-#endif

 	/*
 	 * Reuse same set of shared buffers for scan
@@ -216,22 +212,14 @@ ivfflatbeginscan(Relation index, int nkeys, int norderbys)
 	so->collation = index->rd_indcollation[0];

 	/* Create tuple description for sorting */
-#if PG_VERSION_NUM >= 120000
 	so->tupdesc = CreateTemplateTupleDesc(2);
-#else
-	so->tupdesc = CreateTemplateTupleDesc(2, false);
-#endif
 	TupleDescInitEntry(so->tupdesc, (AttrNumber) 1, "distance", FLOAT8OID, -1, 0);
 	TupleDescInitEntry(so->tupdesc, (AttrNumber) 2, "heaptid", TIDOID, -1, 0);

 	/* Prep sort */
 	so->sortstate = tuplesort_begin_heap(so->tupdesc, 1, attNums, sortOperators, sortCollations, nullsFirstFlags, work_mem, NULL, false);

-#if PG_VERSION_NUM >= 120000
 	so->slot = MakeSingleTupleTableSlot(so->tupdesc, &TTSOpsMinimalTuple);
-#else
-	so->slot = MakeSingleTupleTableSlot(so->tupdesc);
-#endif

 	so->listQueue = pairingheap_allocate(CompareLists, scan);

@@ -321,12 +309,8 @@ ivfflatgettuple(IndexScanDesc scan, ScanDirection dir)
 	{
 		ItemPointer heaptid = (ItemPointer) DatumGetPointer(slot_getattr(so->slot, 2, &so->isnull));

-#if PG_VERSION_NUM >= 120000
 		scan->xs_heaptid = *heaptid;
-#else
-		scan->xs_ctup.t_self = *heaptid;
-#endif
-
+		scan->xs_recheck = false;
 		scan->xs_recheckorderby = false;
 		return true;
 	}
--- a/src/ivfutils.c
+++ b/src/ivfutils.c
@@ -1,5 +1,6 @@
 #include "postgres.h"

+#include "access/generic_xlog.h"
 #include "ivfflat.h"
 #include "storage/bufmgr.h"
 #include "vector.h"
--- a/src/ivfvacuum.c
+++ b/src/ivfvacuum.c
@@ -1,5 +1,6 @@
 #include "postgres.h"

+#include "access/generic_xlog.h"
 #include "commands/vacuum.h"
 #include "ivfflat.h"
 #include "storage/bufmgr.h"
--- a/src/vector.c
+++ b/src/vector.c
@@ -3,6 +3,7 @@
 #include <math.h>

 #include "catalog/pg_type.h"
+#include "common/shortest_dec.h"
 #include "fmgr.h"
 #include "hnsw.h"
 #include "ivfflat.h"
@@ -11,6 +12,7 @@
 #include "port.h"				/* for strtof() */
 #include "utils/array.h"
 #include "utils/builtins.h"
+#include "utils/float.h"
 #include "utils/lsyscache.h"
 #include "utils/numeric.h"
 #include "vector.h"
@@ -19,13 +21,6 @@
 #include "varatt.h"
 #endif

-#if PG_VERSION_NUM >= 120000
-#include "common/shortest_dec.h"
-#include "utils/float.h"
-#else
-#include <float.h>
-#endif
-
 #if PG_VERSION_NUM < 130000
 #define TYPALIGN_DOUBLE 'd'
 #define TYPALIGN_INT 'i'
@@ -177,14 +172,15 @@ PGDLLEXPORT PG_FUNCTION_INFO_V1(vector_in);
 Datum
 vector_in(PG_FUNCTION_ARGS)
 {
-	char	   *str = PG_GETARG_CSTRING(0);
+	char	   *lit = PG_GETARG_CSTRING(0);
 	int32		typmod = PG_GETARG_INT32(2);
 	float		x[VECTOR_MAX_DIM];
 	int			dim = 0;
 	char	   *pt;
 	char	   *stringEnd;
 	Vector	   *result;
-	char	   *lit = pstrdup(str);
+	char	   *litcopy = pstrdup(lit);
+	char	   *str = litcopy;

 	while (vector_isspace(*str))
 		str++;
@@ -268,7 +264,7 @@ vector_in(PG_FUNCTION_ARGS)
 				(errcode(ERRCODE_DATA_EXCEPTION),
 				 errmsg("vector must have at least 1 dimension")));

-	pfree(lit);
+	pfree(litcopy);

 	CheckExpectedDim(typmod, dim);

@@ -292,15 +288,6 @@ vector_out(PG_FUNCTION_ARGS)
 	char	   *ptr;
 	int			n;

-#if PG_VERSION_NUM < 120000
-	int			ndig = FLT_DIG + extra_float_digits;
-
-	if (ndig < 1)
-		ndig = 1;
-
-#define FLOAT_SHORTEST_DECIMAL_LEN (ndig + 10)
-#endif
-
 	/*
 	 * Need:
 	 *
@@ -324,11 +311,7 @@ vector_out(PG_FUNCTION_ARGS)
 			ptr++;
 		}

-#if PG_VERSION_NUM >= 120000
 		n = float_to_shortest_decimal_bufn(vector->x[i], ptr);
-#else
-		n = sprintf(ptr, "%.*g", ndig, vector->x[i]);
-#endif
 		ptr += n;
 	}
 	*ptr = ']';
@@ -883,9 +866,10 @@ vector_mul(PG_FUNCTION_ARGS)
 int
 vector_cmp_internal(Vector * a, Vector * b)
 {
-	CheckDims(a, b);
+	int			dim = Min(a->dim, b->dim);

-	for (int i = 0; i < a->dim; i++)
+	/* Check values before dimensions to be consistent with Postgres arrays */
+	for (int i = 0; i < dim; i++)
 	{
 		if (a->x[i] < b->x[i])
 			return -1;
@@ -893,6 +877,13 @@ vector_cmp_internal(Vector * a, Vector * b)
 		if (a->x[i] > b->x[i])
 			return 1;
 	}
+
+	if (a->dim < b->dim)
+		return -1;
+
+	if (a->dim > b->dim)
+		return 1;
+
 	return 0;
 }

@@ -906,6 +897,9 @@ vector_lt(PG_FUNCTION_ARGS)
 	Vector	   *a = PG_GETARG_VECTOR_P(0);
 	Vector	   *b = PG_GETARG_VECTOR_P(1);

+	/* TODO Remove in 0.7.0 */
+	CheckDims(a, b);
+
 	PG_RETURN_BOOL(vector_cmp_internal(a, b) < 0);
 }

@@ -919,6 +913,9 @@ vector_le(PG_FUNCTION_ARGS)
 	Vector	   *a = PG_GETARG_VECTOR_P(0);
 	Vector	   *b = PG_GETARG_VECTOR_P(1);

+	/* TODO Remove in 0.7.0 */
+	CheckDims(a, b);
+
 	PG_RETURN_BOOL(vector_cmp_internal(a, b) <= 0);
 }

@@ -932,6 +929,9 @@ vector_eq(PG_FUNCTION_ARGS)
 	Vector	   *a = PG_GETARG_VECTOR_P(0);
 	Vector	   *b = PG_GETARG_VECTOR_P(1);

+	/* TODO Remove in 0.7.0 */
+	CheckDims(a, b);
+
 	PG_RETURN_BOOL(vector_cmp_internal(a, b) == 0);
 }

@@ -945,6 +945,9 @@ vector_ne(PG_FUNCTION_ARGS)
 	Vector	   *a = PG_GETARG_VECTOR_P(0);
 	Vector	   *b = PG_GETARG_VECTOR_P(1);

+	/* TODO Remove in 0.7.0 */
+	CheckDims(a, b);
+
 	PG_RETURN_BOOL(vector_cmp_internal(a, b) != 0);
 }

@@ -958,6 +961,9 @@ vector_ge(PG_FUNCTION_ARGS)
 	Vector	   *a = PG_GETARG_VECTOR_P(0);
 	Vector	   *b = PG_GETARG_VECTOR_P(1);

+	/* TODO Remove in 0.7.0 */
+	CheckDims(a, b);
+
 	PG_RETURN_BOOL(vector_cmp_internal(a, b) >= 0);
 }

@@ -971,6 +977,9 @@ vector_gt(PG_FUNCTION_ARGS)
 	Vector	   *a = PG_GETARG_VECTOR_P(0);
 	Vector	   *b = PG_GETARG_VECTOR_P(1);

+	/* TODO Remove in 0.7.0 */
+	CheckDims(a, b);
+
 	PG_RETURN_BOOL(vector_cmp_internal(a, b) > 0);
 }

--- a/test/expected/functions.out
+++ b/test/expected/functions.out
@@ -24,6 +24,56 @@ SELECT '[1e37]'::vector * '[1e37]';
 ERROR:  value out of range: overflow
 SELECT '[1e-37]'::vector * '[1e-37]';
 ERROR:  value out of range: underflow
+SELECT '[1,2,3]'::vector = '[1,2,3]';
+ ?column? 
+----------
+ t
+(1 row)
+
+SELECT '[1,2,3]'::vector = '[1,2]';
+ERROR:  different vector dimensions 3 and 2
+SELECT vector_cmp('[1,2,3]', '[1,2,3]');
+ vector_cmp 
+------------
+          0
+(1 row)
+
+SELECT vector_cmp('[1,2,3]', '[0,0,0]');
+ vector_cmp 
+------------
+          1
+(1 row)
+
+SELECT vector_cmp('[0,0,0]', '[1,2,3]');
+ vector_cmp 
+------------
+         -1
+(1 row)
+
+SELECT vector_cmp('[1,2]', '[1,2,3]');
+ vector_cmp 
+------------
+         -1
+(1 row)
+
+SELECT vector_cmp('[1,2,3]', '[1,2]');
+ vector_cmp 
+------------
+          1
+(1 row)
+
+SELECT vector_cmp('[1,2]', '[2,3,4]');
+ vector_cmp 
+------------
+         -1
+(1 row)
+
+SELECT vector_cmp('[2,3]', '[1,2,3]');
+ vector_cmp 
+------------
+          1
+(1 row)
+
 SELECT vector_dims('[1,2,3]');
 vector_dims 
 -------------
--- a/test/sql/functions.sql
+++ b/test/sql/functions.sql
@@ -6,6 +6,17 @@ SELECT '[1,2,3]'::vector * '[4,5,6]';
 SELECT '[1e37]'::vector * '[1e37]';
 SELECT '[1e-37]'::vector * '[1e-37]';

+SELECT '[1,2,3]'::vector = '[1,2,3]';
+SELECT '[1,2,3]'::vector = '[1,2]';
+
+SELECT vector_cmp('[1,2,3]', '[1,2,3]');
+SELECT vector_cmp('[1,2,3]', '[0,0,0]');
+SELECT vector_cmp('[0,0,0]', '[1,2,3]');
+SELECT vector_cmp('[1,2]', '[1,2,3]');
+SELECT vector_cmp('[1,2,3]', '[1,2]');
+SELECT vector_cmp('[1,2]', '[2,3,4]');
+SELECT vector_cmp('[2,3]', '[1,2,3]');
+
 SELECT vector_dims('[1,2,3]');

 SELECT round(vector_norm('[1,1]')::numeric, 5);
--- a/test/t/012_hnsw_build_recall.pl
+++ b/test/t/012_hnsw_build_recall.pl
@@ -95,11 +95,10 @@ for my $i (0 .. $#operators)

 	$node->safe_psql("postgres", "DROP INDEX idx;");

-	# Build index in parallel
+	# Build index in parallel in memory
 	my ($ret, $stdout, $stderr) = $node->psql("postgres", qq(
 		SET client_min_messages = DEBUG;
 		SET min_parallel_table_scan_size = 1;
-		SET hnsw.enable_parallel_build = on;
 		CREATE INDEX idx ON tst USING hnsw (v $opclass);
 	));
 	is($ret, 0, $stderr);
@@ -109,6 +108,21 @@ for my $i (0 .. $#operators)
 	test_recall($min, $operator);

 	$node->safe_psql("postgres", "DROP INDEX idx;");
+
+	# Build index in parallel on disk
+	# Set parallel_workers on table to use workers with low maintenance_work_mem
+	($ret, $stdout, $stderr) = $node->psql("postgres", qq(
+		ALTER TABLE tst SET (parallel_workers = 2);
+		SET client_min_messages = DEBUG;
+		SET maintenance_work_mem = '4MB';
+		CREATE INDEX idx ON tst USING hnsw (v $opclass);
+		ALTER TABLE tst RESET (parallel_workers);
+	));
+	is($ret, 0, $stderr);
+	like($stderr, qr/using \d+ parallel workers/);
+	like($stderr, qr/hnsw graph no longer fits into maintenance_work_mem/);
+
+	$node->safe_psql("postgres", "DROP INDEX idx;");
 }

 done_testing();
--- a/test/t/018_hnsw_filtering.pl
+++ b/test/t/018_hnsw_filtering.pl
@@ -0,0 +1,114 @@
+use strict;
+use warnings;
+use PostgresNode;
+use TestLib;
+use Test::More;
+
+my $dim = 3;
+my $nc = 50;
+my $limit = 20;
+
+my $array_sql = join(",", ('random()') x $dim);
+
+# Initialize node
+my $node = get_new_node('node');
+$node->init;
+$node->start;
+
+# Create table and index
+$node->safe_psql("postgres", "CREATE EXTENSION vector;");
+$node->safe_psql("postgres", "CREATE TABLE tst (i int4, v vector($dim), c int4, t text);");
+$node->safe_psql("postgres",
+	"INSERT INTO tst SELECT i, ARRAY[$array_sql], i % $nc, 'test ' || i FROM generate_series(1, 10000) i;"
+);
+$node->safe_psql("postgres", "CREATE INDEX idx ON tst USING hnsw (v vector_l2_ops);");
+$node->safe_psql("postgres", "ANALYZE tst;");
+
+# Generate query
+my @r = ();
+for (1 .. $dim)
+{
+	push(@r, rand());
+}
+my $query = "[" . join(",", @r) . "]";
+my $c = int(rand() * $nc);
+
+# Test attribute filtering
+my $explain = $node->safe_psql("postgres", qq(
+	EXPLAIN ANALYZE SELECT i FROM tst WHERE c = $c ORDER BY v <-> '$query' LIMIT $limit;
+));
+# TODO Do not use index
+like($explain, qr/Index Scan using idx/);
+
+# Test attribute filtering with few rows removed
+$explain = $node->safe_psql("postgres", qq(
+	EXPLAIN ANALYZE SELECT i FROM tst WHERE c != $c ORDER BY v <-> '$query' LIMIT $limit;
+));
+like($explain, qr/Index Scan using idx/);
+
+# Test attribute filtering with few rows removed comparison
+$explain = $node->safe_psql("postgres", qq(
+	EXPLAIN ANALYZE SELECT i FROM tst WHERE c >= 1 ORDER BY v <-> '$query' LIMIT $limit;
+));
+like($explain, qr/Index Scan using idx/);
+
+# Test attribute filtering with many rows removed comparison
+$explain = $node->safe_psql("postgres", qq(
+	EXPLAIN ANALYZE SELECT i FROM tst WHERE c < 1 ORDER BY v <-> '$query' LIMIT $limit;
+));
+# TODO Do not use index
+like($explain, qr/Index Scan using idx/);
+
+# Test attribute filtering with few rows removed like
+$explain = $node->safe_psql("postgres", qq(
+	EXPLAIN ANALYZE SELECT i FROM tst WHERE t LIKE '%%test%%' ORDER BY v <-> '$query' LIMIT $limit;
+));
+like($explain, qr/Index Scan using idx/);
+
+# Test attribute filtering with many rows removed like
+$explain = $node->safe_psql("postgres", qq(
+	EXPLAIN ANALYZE SELECT i FROM tst WHERE t LIKE '%%other%%' ORDER BY v <-> '$query' LIMIT $limit;
+));
+like($explain, qr/Seq Scan/);
+
+# Test distance filtering
+$explain = $node->safe_psql("postgres", qq(
+	EXPLAIN ANALYZE SELECT i FROM tst WHERE v <-> '$query' < 1 ORDER BY v <-> '$query' LIMIT $limit;
+));
+like($explain, qr/Index Scan using idx/);
+
+# Test distance filtering greater than distance
+$explain = $node->safe_psql("postgres", qq(
+	EXPLAIN ANALYZE SELECT i FROM tst WHERE v <-> '$query' > 1 ORDER BY v <-> '$query' LIMIT $limit;
+));
+# TODO Do not use index
+like($explain, qr/Index Scan using idx/);
+
+# Test distance filtering without order
+$explain = $node->safe_psql("postgres", qq(
+	EXPLAIN ANALYZE SELECT i FROM tst WHERE v <-> '$query' < 1;
+));
+like($explain, qr/Seq Scan/);
+
+# Test distance filtering without limit
+$explain = $node->safe_psql("postgres", qq(
+	EXPLAIN ANALYZE SELECT i FROM tst WHERE v <-> '$query' < 1 ORDER BY v <-> '$query';
+));
+like($explain, qr/Seq Scan/);
+
+# Test attribute index
+$node->safe_psql("postgres", "CREATE INDEX attribute_idx ON tst (c);");
+$explain = $node->safe_psql("postgres", qq(
+	EXPLAIN ANALYZE SELECT i FROM tst WHERE c = $c ORDER BY v <-> '$query' LIMIT $limit;
+));
+# TODO Use attribute index
+like($explain, qr/Index Scan using idx/);
+
+# Test partial index
+$node->safe_psql("postgres", "CREATE INDEX partial_idx ON tst USING hnsw (v vector_l2_ops) WHERE (c = $c);");
+$explain = $node->safe_psql("postgres", qq(
+	EXPLAIN ANALYZE SELECT i FROM tst WHERE c = $c ORDER BY v <-> '$query' LIMIT $limit;
+));
+like($explain, qr/Index Scan using partial_idx/);
+
+done_testing();
--- a/test/t/018_ivfflat_deletes.pl
+++ b/test/t/018_ivfflat_deletes.pl
@@ -1,43 +0,0 @@
-use strict;
-use warnings;
-use PostgresNode;
-use TestLib;
-use Test::More;
-
-my $dim = 3;
-
-my $array_sql = join(",", ('random()') x $dim);
-
-# Initialize node
-my $node = get_new_node('node');
-$node->init;
-$node->start;
-
-# Create table and index
-$node->safe_psql("postgres", "CREATE EXTENSION vector;");
-$node->safe_psql("postgres", "CREATE TABLE tst (i serial, v vector($dim));");
-$node->safe_psql("postgres",
-	"INSERT INTO tst (v) SELECT ARRAY[$array_sql] FROM generate_series(1, 10000) i;"
-);
-$node->safe_psql("postgres", "CREATE INDEX ON tst USING ivfflat (v vector_l2_ops);");
-
-# Delete data
-$node->safe_psql("postgres", "DELETE FROM tst WHERE i % 100 != 0;");
-
-my $exp = $node->safe_psql("postgres", qq(
-	SET enable_indexscan = off;
-	SELECT i FROM tst ORDER BY v <-> '[0,0,0]';
-));
-
-# Run twice to make sure correct tuples marked as dead
-for (1 .. 2)
-{
-	my $res = $node->safe_psql("postgres", qq(
-		SET enable_seqscan = off;
-		SET ivfflat.probes = 100;
-		SELECT i FROM tst ORDER BY v <-> '[0,0,0]';
-	));
-	is($res, $exp);
-}
-
-done_testing();
--- a/test/t/019_ivfflat_filtering.pl
+++ b/test/t/019_ivfflat_filtering.pl
@@ -0,0 +1,116 @@
+use strict;
+use warnings;
+use PostgresNode;
+use TestLib;
+use Test::More;
+
+my $dim = 3;
+my $nc = 50;
+my $limit = 20;
+
+my $array_sql = join(",", ('random()') x $dim);
+
+# Initialize node
+my $node = get_new_node('node');
+$node->init;
+$node->start;
+
+# Create table and index
+$node->safe_psql("postgres", "CREATE EXTENSION vector;");
+$node->safe_psql("postgres", "CREATE TABLE tst (i int4, v vector($dim), c int4, t text);");
+$node->safe_psql("postgres",
+	"INSERT INTO tst SELECT i, ARRAY[$array_sql], i % $nc, 'test ' || i FROM generate_series(1, 10000) i;"
+);
+$node->safe_psql("postgres", "CREATE INDEX idx ON tst USING ivfflat (v vector_l2_ops) WITH (lists = 100);");
+$node->safe_psql("postgres", "ANALYZE tst;");
+
+# Generate query
+my @r = ();
+for (1 .. $dim)
+{
+	push(@r, rand());
+}
+my $query = "[" . join(",", @r) . "]";
+my $c = int(rand() * $nc);
+
+# Test attribute filtering
+my $explain = $node->safe_psql("postgres", qq(
+	EXPLAIN ANALYZE SELECT i FROM tst WHERE c = $c ORDER BY v <-> '$query' LIMIT $limit;
+));
+# TODO Do not use index
+like($explain, qr/Index Scan using idx/);
+
+# Test attribute filtering with few rows removed
+$explain = $node->safe_psql("postgres", qq(
+	EXPLAIN ANALYZE SELECT i FROM tst WHERE c != $c ORDER BY v <-> '$query' LIMIT $limit;
+));
+like($explain, qr/Index Scan using idx/);
+
+# Test attribute filtering with few rows removed comparison
+$explain = $node->safe_psql("postgres", qq(
+	EXPLAIN ANALYZE SELECT i FROM tst WHERE c >= 1 ORDER BY v <-> '$query' LIMIT $limit;
+));
+like($explain, qr/Index Scan using idx/);
+
+# Test attribute filtering with many rows removed comparison
+$explain = $node->safe_psql("postgres", qq(
+	EXPLAIN ANALYZE SELECT i FROM tst WHERE c < 1 ORDER BY v <-> '$query' LIMIT $limit;
+));
+# TODO Do not use index
+like($explain, qr/Index Scan using idx/);
+
+# Test attribute filtering with few rows removed like
+$explain = $node->safe_psql("postgres", qq(
+	EXPLAIN ANALYZE SELECT i FROM tst WHERE t LIKE '%%test%%' ORDER BY v <-> '$query' LIMIT $limit;
+));
+like($explain, qr/Index Scan using idx/);
+
+# Test attribute filtering with many rows removed like
+$explain = $node->safe_psql("postgres", qq(
+	EXPLAIN ANALYZE SELECT i FROM tst WHERE t LIKE '%%other%%' ORDER BY v <-> '$query' LIMIT $limit;
+));
+like($explain, qr/Seq Scan/);
+
+# Test distance filtering
+$explain = $node->safe_psql("postgres", qq(
+	EXPLAIN ANALYZE SELECT i FROM tst WHERE v <-> '$query' < 1 ORDER BY v <-> '$query' LIMIT $limit;
+));
+like($explain, qr/Index Scan using idx/);
+
+# Test distance filtering greater than distance
+$explain = $node->safe_psql("postgres", qq(
+	EXPLAIN ANALYZE SELECT i FROM tst WHERE v <-> '$query' > 1 ORDER BY v <-> '$query' LIMIT $limit;
+));
+# TODO Do not use index
+like($explain, qr/Index Scan using idx/);
+
+# Test distance filtering without order
+$explain = $node->safe_psql("postgres", qq(
+	EXPLAIN ANALYZE SELECT i FROM tst WHERE v <-> '$query' < 1;
+));
+like($explain, qr/Seq Scan/);
+
+# Test distance filtering without limit
+$explain = $node->safe_psql("postgres", qq(
+	EXPLAIN ANALYZE SELECT i FROM tst WHERE v <-> '$query' < 1 ORDER BY v <-> '$query';
+));
+# TODO Do not use index
+like($explain, qr/Index Scan using idx/);
+
+# Test attribute index
+$node->safe_psql("postgres", "CREATE INDEX attribute_idx ON tst (c);");
+$explain = $node->safe_psql("postgres", qq(
+	EXPLAIN ANALYZE SELECT i FROM tst WHERE c = $c ORDER BY v <-> '$query' LIMIT $limit;
+));
+# TODO Use attribute index
+like($explain, qr/Index Scan using idx/);
+
+# Test partial index
+$node->safe_psql("postgres", "CREATE INDEX partial_idx ON tst USING ivfflat (v vector_l2_ops) WITH (lists = 5) WHERE (c = $c);");
+$explain = $node->safe_psql("postgres", qq(
+	EXPLAIN ANALYZE SELECT i FROM tst WHERE c = $c ORDER BY v <-> '$query' LIMIT $limit;
+));
+# TODO Use partial index
+like($explain, qr/Index Scan using idx/);
+
+done_testing();
--- a/vector.control
+++ b/vector.control
@@ -1,4 +1,4 @@
 comment = 'vector data type and ivfflat and hnsw access methods'
-default_version = '0.5.1'
+default_version = '0.6.2'
 module_pathname = '$libdir/vector'
 relocatable = true
Author	SHA1	Message	Date
Andrew Kane	96ff19be44	Version bump to 0.6.2 [skip ci]	2024-03-18 10:21:04 -07:00
Andrew Kane	6c969bebad	Updated changelog [skip ci]	2024-03-18 10:11:45 -07:00
Andrew Kane	b64a1482d9	Moved example [skip ci]	2024-03-16 15:20:26 -07:00
Andrew Kane	a5f2d70bc2	Use temp directory for installation instructions on Windows [skip ci]	2024-03-16 12:02:45 -07:00
Andrew Kane	f3fcb5e005	Moved installation notes for Windows [skip ci]	2024-03-16 11:47:18 -07:00
Andrew Kane	3a6e0afb9c	Added installation notes for Windows [skip ci]	2024-03-16 11:35:55 -07:00
Andrew Kane	183d50bdbd	Added note about creating indexes concurrently [skip ci]	2024-03-16 10:45:09 -07:00
Andrew Kane	bd776fee68	Updated readme [skip ci]	2024-03-16 10:44:45 -07:00
Andrew Kane	d30b113e4b	Updated readme [skip ci]	2024-03-15 21:54:58 -07:00
Andrew Kane	fd3200f718	Updated readme [skip ci]	2024-03-15 21:47:57 -07:00
Andrew Kane	02c815d876	Added docs on tuning, monitoring, and scaling [skip ci]	2024-03-15 19:00:49 -07:00
Andrew Kane	4b2a7cc49d	Improved performance section [skip ci]	2024-03-15 17:54:14 -07:00
Andrew Kane	da0ff998e9	Updated readme [skip ci]	2024-03-15 14:23:56 -07:00
Andrew Kane	cb36e24289	Improved portability section [skip ci]	2024-03-15 14:23:04 -07:00
Andrew Kane	b1d0d4c7a3	Improved troubleshooting docs [skip ci]	2024-03-15 14:01:24 -07:00
Andrew Kane	1dc6514b66	Updated comment [skip ci]	2024-03-15 12:38:14 -07:00
Andrew Kane	6c53f7ca02	Updated comment [skip ci]	2024-03-15 12:37:47 -07:00
Heikki Linnakangas	0d35a14198	Fix compiler warnings in strict C99 mode (#487 ) Redefining a typedef is a C11 feature: In file included from src/hnsw.c:10: src/hnsw.h:147:5: warning: redefinition of typedef 'HnswElementData' is a C11 feature [-Wtypedef-redefinition] } HnswElementData; ^ src/hnsw.h:118:32: note: previous definition is here typedef struct HnswElementData HnswElementData; ^ src/hnsw.h:163:5: warning: redefinition of typedef 'HnswNeighborArray' is a C11 feature [-Wtypedef-redefinition] } HnswNeighborArray; ^ src/hnsw.h:119:34: note: previous definition is here typedef struct HnswNeighborArray HnswNeighborArray; ^ 2 warnings generated. I got these warnings when I built PostgreSQL with "CC=clang CFLAGS=-std=gnu99"; other similar options would surely produce the warnings too.	2024-03-12 02:02:33 -07:00
Andrew Kane	3ea2ce89be	Reduced lock contention with parallel HNSW index builds	2024-03-11 20:16:55 -07:00
Andrew Kane	62350b1589	Added note about IVFFlat results [skip ci]	2024-03-06 00:29:55 -08:00
Andrew Kane	dd57309281	Added section about HNSW results - #480 [skip ci]	2024-03-06 00:27:50 -08:00
Andrew Kane	c6ddf62a29	Version bump to 0.6.1 [skip ci]	2024-03-04 10:27:59 -08:00
Andrew Kane	801be04d8b	Updated CI [skip ci]	2024-03-02 17:06:11 -08:00
Andrew Kane	587e9ba97c	Added link to bulk loading example [skip ci]	2024-02-29 21:25:11 -08:00
Andrew Kane	d57047a935	Moved COPY example and added FORMAT [skip ci]	2024-02-29 20:35:01 -08:00
oneturkmen	f1db1f17e3	Update README.md (#472 )	2024-02-29 20:27:53 -08:00
Andrew Kane	2f48c0fac4	Updated changelog [skip ci]	2024-02-29 18:10:19 -08:00
Andrew Kane	84a8aa8176	Added note about HNSW build time [skip ci]	2024-02-29 16:25:58 -08:00
Andrew Kane	f64ebbef50	Added OPTFLAGS to readme [skip ci]	2024-02-29 16:15:22 -08:00
Andrew Kane	ac8156509b	Updated vector operators for <= and >=	2024-02-29 15:43:29 -08:00
Andrew Kane	82bf69b479	Fixed vector subtraction being marked as commutative - fixes #475	2024-02-29 14:36:18 -08:00
Andrew Kane	4be2f57916	Updated license year [skip ci]	2024-02-29 13:44:58 -08:00
Andrew Kane	91e3d2905f	Fixed sort function for Postgres 12	2024-02-28 16:26:41 -08:00
Andrew Kane	fe2406564f	Replaced pairing heap with array in SelectNeighbors - closes #447 Co-authored-by: Heikki Linnakangas <heikki.linnakangas@iki.fi>	2024-02-28 15:47:26 -08:00
Andrew Kane	fa52511eaa	Fixed closer caching for Postgres 12	2024-02-28 15:44:38 -08:00
Andrew Kane	447ef4d27a	Specify Postgres version for Valgrind [skip ci]	2024-02-28 14:16:48 -08:00
Andrew Kane	b36cd22ccc	Enable assertions on CI	2024-02-28 14:15:34 -08:00
Andrew Kane	b447ae4989	Avoid base address for relptr for Postgres < 14.5	2024-02-28 14:10:14 -08:00
Andrew Kane	efed873a3e	Revert "Replaced pairing heap with array in SelectNeighbors - closes #447 " This reverts commit `14b278dec9`.	2024-02-28 11:33:14 -08:00
Andrew Kane	14b278dec9	Replaced pairing heap with array in SelectNeighbors - closes #447 Co-authored-by: Heikki Linnakangas <heikki.linnakangas@iki.fi>	2024-02-28 11:25:12 -08:00
Andrew Kane	133a728e48	Updated changelog [skip ci]	2024-02-20 16:38:05 -08:00
Andrew Kane	ca10cbaa7d	Revert "Remove offsethash" This reverts commit `1cbd204f52`.	2024-02-20 16:07:32 -08:00
Andrew Kane	eb29019a14	Revert "Eliminate a few HnswPtrAccess invocations" This reverts commit `334c386a45`.	2024-02-20 16:07:21 -08:00
Heikki Linnakangas	334c386a45	Eliminate a few HnswPtrAccess invocations HnswPtrAccess() is pretty cheap, but it stills seems worthwhile to avoid repeated calls in the hot paths when it can be easily avoided.	2024-02-19 14:13:18 +02:00
Heikki Linnakangas	1cbd204f52	Remove offsethash The original motivation was to eliminate the superfluous HnswPtrAccess call from AddToVisited. The caller has to call HnswPtrAccess() anyway, so it makes sense to pass the HnswElement rather than HnswElementPtr to AddToVisited(). But then I realized that we can use the pointer-variant even with shared memory, because the visited-hash is backend-private, and the addresses where the elements are mapped to in shared memory are stable within the backend.	2024-02-19 14:12:26 +02:00
Andrew Kane	5ba62fca84	Fixed crash with shared_preload_libraries - fixes #460	2024-02-14 17:13:30 -08:00
Andrew Kane	22cb2a3fe7	Simplified Docker tasks [skip ci]	2024-02-07 12:03:33 -08:00
Andrew Kane	72b144906a	Added Valgrind to CI	2024-02-07 09:43:01 -08:00
Andrew Kane	a618c1bc78	Updated port name [skip ci]	2024-02-06 12:43:20 -08:00
Andrew Kane	f43cd0ed98	Improved type [skip ci]	2024-02-05 19:38:52 -08:00
Andrew Kane	51df640961	Added instructions for pkg [skip ci]	2024-02-05 17:01:36 -08:00
Andrew Kane	2716a223a6	Fixed error with ANALYZE and vectors with different dimensions - fixes #451	2024-02-02 10:47:48 -08:00
Andrew Kane	3697043898	Added note about vacuuming - closes #450 [skip ci]	2024-01-31 14:35:27 -08:00
Andrew Kane	c22740962c	Added note for Docker [skip ci]	2024-01-29 15:33:29 -08:00
Andrew Kane	a55ecf3281	Updated changelog [skip ci]	2024-01-29 11:20:33 -08:00
Andrew Kane	fecdd5794e	Updated readme [skip ci]	2024-01-29 10:57:54 -08:00
Andrew Kane	281d4fcf60	Version bump to 0.6.0 [skip ci]	2024-01-29 10:54:44 -08:00
Andrew Kane	5b43aaad5a	Removed unneeded item ids	2024-01-28 23:14:52 -08:00
Andrew Kane	797ce8034c	Ran pgindent [skip ci]	2024-01-28 23:03:48 -08:00
Andrew Kane	cad9e22d9a	Updated variable name to be consistent with CreateGraphPages [skip ci]	2024-01-28 23:02:13 -08:00
Andrew Kane	a7d43904f7	Zero memory for each element	2024-01-28 23:00:39 -08:00
Andrew Kane	ded649891b	DRY HNSW tuple alloc size [skip ci]	2024-01-28 22:58:38 -08:00
Heikki Linnakangas	2d092016fc	Remove unnecessary PageIndexTupleOverwrite calls that caused UB (#438 ) These places called PageIndexTupleOverwrite(), with the new tuple pointing directly to the original page. The PageIndexTupleOverwrite() call is unnecessary in these cases, as we have already modified the tuple on the page directly. Moreover, PageIndexTupleOverWrite() will call memcpy with same src and dst arguments, which is undefined behavior. It's OK to modify the pages on disk directly, and we don't need critical sections, because we either use the generic xlog functions which create a temporary copy of the page, or we are building a new index so if we crash the whole index is invisible and will be dropped anyway.	2024-01-28 22:52:56 -08:00
Andrew Kane	86b31fdf96	Revert "Update neighbor tuples in-place for HNSW index build" This reverts commit `270dd8189a`.	2024-01-28 22:18:22 -08:00
Andrew Kane	5023269f0d	Updated changelog [skip ci]	2024-01-28 21:42:30 -08:00
Andrew Kane	642ee1f423	Improved function names	2024-01-28 21:00:12 -08:00
Andrew Kane	270dd8189a	Update neighbor tuples in-place for HNSW index build	2024-01-28 20:53:56 -08:00
Andrew Kane	ba2776850b	Fixed Valgrind check for HNSW in-memory, parallel index builds - closes #441	2024-01-28 16:19:32 -08:00
Andrew Kane	0cc883b944	Removed checking neighbors for cached distance	2024-01-28 02:11:24 -08:00
Andrew Kane	e8e69278eb	Fixed test name [skip ci]	2024-01-27 21:18:49 -08:00
Andrew Kane	a4893d9d5f	Updated Postgres for Mac TAP tests on CI [skip ci]	2024-01-27 20:28:03 -08:00
Andrew Kane	10416b841f	Fixed uninitialized memory in scan->xs_recheck [skip ci]	2024-01-27 19:54:16 -08:00
Andrew Kane	d0f13d4e7f	Fixed possibly uninitialized memory in lists [skip ci]	2024-01-27 19:51:34 -08:00
Andrew Kane	705e71015f	Fixed uninitialized entry point level - fixes #439 and closes #440	2024-01-27 19:49:40 -08:00
Heikki Linnakangas	121f53b8ff	Remove unused heapRel arguments (#443 )	2024-01-26 12:45:10 -08:00
Andrew Kane	8765e79ec2	Added note about max_parallel_maintenance_workers for HNSW [skip ci]	2024-01-25 13:32:35 -08:00
Andrew Kane	7fff6cd138	Moved Windows instructions [skip ci]	2024-01-25 02:11:21 -08:00
Heikki Linnakangas	571697fee7	Remove unnecessary UpdateProgress() wrappers (#433 ) Now that we require PostgreSQL v12, we can use pgstat_progress_update_param directly.	2024-01-25 00:07:57 -08:00
Andrew Kane	f7eda7bd20	DRY neighbor array size [skip ci]	2024-01-24 17:54:33 -08:00
Andrew Kane	2260e13315	Condensed code [skip ci]	2024-01-24 16:20:00 -08:00
Andrew Kane	90e0a14bda	Moved allocating neighbor array to separate function [skip ci]	2024-01-24 16:17:34 -08:00
Andrew Kane	c816b5d0d1	Added note about --shm-size [skip ci]	2024-01-24 14:49:38 -08:00
Andrew Kane	b7b11cd8d5	Updated changelog [skip ci]	2024-01-24 14:31:41 -08:00
Andrew Kane	54c560c5cb	Removed previous upgrade notes [skip ci]	2024-01-24 14:25:58 -08:00
Andrew Kane	8a6c52f649	Moved Docker image to pgvector org and added tags for each supported version of Postgres [skip ci]	2024-01-24 14:18:44 -08:00
Heikki Linnakangas	c8be3a369b	Include generic_xlog.h directly in the .c files where it's needed There are no references to anything that's in generic_xlog.h in the header files.	2024-01-23 13:04:03 +02:00
Heikki Linnakangas	e5d1a6bdbb	Include reloptions.h directly in the .c files where it's needed There are no references to anything that's in reloptions.h in the header files. They need to include genam.h instead, which defines IndexScanDesc.	2024-01-23 13:02:24 +02:00
Heikki Linnakangas	f31d708c2b	Add direct include to pairingheap.h in headers ivfflat.h and hnsw.h have references to pairingheap_node, so they need to include lib/pairingheap.h. It happened to work, because lib/pairingheap.h was being included indirectly through nodes/execnodes.h, but let's be explicit. Remove the include from hnswbuild.c, because there are no calls to pairingheap functions in that file. Instead, add the includes to hnswutils.c and ivfscan.c, which do have such calls. They are not strictly necessary again because of the indirect include from hnsw.h and ivfflat.h, but let's be explicit while we're messing with this.	2024-01-23 12:53:22 +02:00
Heikki Linnakangas	a1b1c99ff7	Remove unused #include pg_list.h has not been used in hnswbuild.c since commit `cb4c770df2`.	2024-01-23 12:53:13 +02:00
Andrew Kane	3ace98add6	Changed storage for vector from extended to external	2024-01-23 00:00:12 -08:00
Andrew Kane	083008c21e	Added validation for GUC parameters	2024-01-22 23:55:30 -08:00
Andrew Kane	a1e526ef82	Dropped support for Postgres 11	2024-01-22 23:52:54 -08:00
Andrew Kane	8ffb3718a4	Leave more space for other shared memory	2024-01-22 23:31:55 -08:00
Andrew Kane	2d0f162bd7	Added support for in-memory parallel index builds for HNSW Co-authored-by: Heikki Linnakangas <heikki.linnakangas@iki.fi>	2024-01-22 23:19:10 -08:00
Heikki Linnakangas	4c6928bd3c	Remove HnswSpool It was just used to pass heap/index relations to HnswParallelScanAndInsert. I think it was copied from nbtsort.c, which is more complicated. I don't think we need a struct like this. (That said, I actually think that we should have a state object that would hold fields like 'heap', 'index', 'procinfo', 'collation' etc. Passing that object around would simplify the signatures of many functions. But that's a different story).	2024-01-22 23:11:25 -08:00
Heikki Linnakangas	6fd05dd6f6	Remove unused 'scantuplesortstates' field	2024-01-22 23:08:20 -08:00
Andrew Kane	70106f5413	Use assert checking for scan-build [skip ci]	2024-01-22 23:05:49 -08:00
Andrew Kane	44b90be452	Made variable name consistent across functions [skip ci]	2024-01-22 19:02:33 -08:00
Andrew Kane	31572a7b28	Removed unused parameter [skip ci]	2024-01-22 19:00:45 -08:00
Andrew Kane	2427290ea9	Pass hash by reference	2024-01-22 18:34:40 -08:00
Andrew Kane	ca71ef7a51	Added analyze to filtering tests	2024-01-21 18:08:16 -08:00
Andrew Kane	8bd01ff006	Added filtering tests for like [skip ci]	2024-01-21 18:01:42 -08:00
Andrew Kane	cdb1c9a6d3	Fixed test logic [skip ci]	2024-01-21 16:07:44 -08:00
Andrew Kane	bf34ceef7c	Added more filtering tests	2024-01-21 16:03:22 -08:00
Andrew Kane	61b1566ea2	Updated CI to Debian 12 [skip ci]	2024-01-21 12:40:55 -08:00
Andrew Kane	91acc3c178	Added test for filtering with IVFFlat	2024-01-20 21:38:40 -08:00
Andrew Kane	885dd5b665	Fixed test warning [skip ci]	2024-01-20 21:10:24 -08:00
Andrew Kane	2a7b38bf1f	Added test for filtering with few rows removed	2024-01-20 21:09:14 -08:00
Andrew Kane	4bd4a0996b	Improved filtering test [skip ci]	2024-01-20 21:01:57 -08:00
Andrew Kane	490522b883	Added test for filtering with HNSW	2024-01-20 18:06:54 -08:00
Andrew Kane	a1a38156d7	Removed unneeded test [skip ci]	2024-01-20 15:28:48 -08:00
Andrew Kane	042ddfdc8a	Updated readme [skip ci]	2024-01-20 11:40:49 -08:00
Andrew Kane	56870ce04d	Added common paths on Mac [skip ci]	2024-01-19 21:43:55 -08:00
Andrew Kane	4ab77f3d24	Added section on missing SDK [skip ci]	2024-01-19 20:47:23 -08:00
Andrew Kane	cc9e6a6778	Added section on max_parallel_maintenance_workers [skip ci]	2024-01-18 21:57:38 -08:00
Andrew Kane	8f1b669c4f	Added IVFFLAT_KMEANS_DEBUG to readme [skip ci]	2024-01-17 22:12:39 -08:00
Andrew Kane	1ff9ab5133	Revert "Improved vector_in" This reverts commit `4894dc5da1`.	2024-01-17 17:14:42 -08:00
Andrew Kane	4894dc5da1	Improved vector_in	2024-01-17 16:57:16 -08:00
Andrew Kane	7390f31261	Updated changelog [skip ci]	2024-01-17 10:50:07 -08:00
Heikki Linnakangas	b7304a3a4a	Don't modify input string in vector_in() (#413 ) Fixes issue #399	2024-01-17 10:49:04 -08:00
Andrew Kane	018ceb7a46	Updated PG_CONFIG example [skip ci]	2024-01-16 22:26:28 -08:00
Andrew Kane	0b2be00622	Added more defines to contributing docs [skip ci]	2024-01-16 17:21:33 -08:00