Added search parameters to EXPLAIN [skip ci]

2026-07-22 03:57:34 +08:00 · 2024-10-28 01:20:59 -07:00
45 changed files with 382 additions and 1015 deletions
--- a/.dockerignore
+++ b/.dockerignore
@@ -0,0 +1,8 @@
+/.git/
+/dist/
+/results/
+/tmp_check/
+/sql/vector--?.?.?.sql
+regression.*
+*.o
+*.so
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -8,29 +8,27 @@ jobs:
      fail-fast: false
      matrix:
        include:
-          - postgres: 19
-            os: ubuntu-24.04
          - postgres: 18
            os: ubuntu-24.04
          - postgres: 17
            os: ubuntu-24.04
          - postgres: 16
-            os: ubuntu-24.04-arm
+            os: ubuntu-22.04
          - postgres: 15
            os: ubuntu-22.04
          - postgres: 14
-            os: ubuntu-22.04-arm
+            os: ubuntu-20.04
          - postgres: 13
-            os: ubuntu-22.04
+            os: ubuntu-20.04
    steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v4
      - uses: ankane/setup-postgres@v1
        with:
          postgres-version: ${{ matrix.postgres }}
          dev-files: true
      - run: make
        env:
-          PG_CFLAGS: -DUSE_ASSERT_CHECKING -Wall -Wextra -Werror -Wno-unused-parameter -Wno-sign-compare ${{ matrix.postgres >= 18 && '-Wno-missing-field-initializers' || '' }}
+          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
@@ -48,18 +46,18 @@ jobs:
      fail-fast: false
      matrix:
        include:
-          - postgres: 18
-            os: macos-26
+          - postgres: 16
+            os: macos-14
          - postgres: 14
-            os: macos-15-intel
+            os: macos-13
    steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v4
      - uses: ankane/setup-postgres@v1
        with:
          postgres-version: ${{ matrix.postgres }}
      - run: make
        env:
-          PG_CFLAGS: -DUSE_ASSERT_CHECKING -Wall -Wextra -Werror -Wno-unused-parameter -Wno-unknown-warning-option ${{ matrix.postgres >= 18 && '-Wno-missing-field-initializers' || '' }}
+          PG_CFLAGS: -DUSE_ASSERT_CHECKING -Wall -Wextra -Werror -Wno-unused-parameter
      - run: make install
      - run: make installcheck
      - if: ${{ failure() }}
@@ -72,35 +70,26 @@ jobs:
          tar xf $TAG.tar.gz
          mv postgres-$TAG postgres
        env:
-          TAG: ${{ matrix.postgres == 18 && 'REL_18_2' || 'REL_14_21' }}
+          TAG: ${{ matrix.postgres == 16 && 'REL_16_2' || 'REL_14_11' }}
      - run: make prove_installcheck PROVE_FLAGS="-I ./postgres/src/test/perl -I ./test/perl"
        env:
          PERL5LIB: /Users/runner/perl5/lib/perl5
-      - run: make clean && $(brew --prefix llvm@$LLVM_VERSION)/bin/scan-build --status-bugs make
+      - run: make clean && $(brew --prefix llvm@15)/bin/scan-build --status-bugs make
        env:
-          LLVM_VERSION: ${{ matrix.os == 'macos-26' && 20 || 18 }}
          PG_CFLAGS: -DUSE_ASSERT_CHECKING
  windows:
-    runs-on: ${{ matrix.os }}
+    runs-on: windows-latest
    if: ${{ !startsWith(github.ref_name, 'mac') }}
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - postgres: 17
-            os: windows-2025
-          - postgres: 14
-            os: windows-2022
    steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v4
      - uses: ankane/setup-postgres@v1
        with:
-          postgres-version: ${{ matrix.postgres }}
+          postgres-version: 14
      - run: |
-          call "C:\Program Files\Microsoft Visual Studio\${{ matrix.os == 'windows-2025' && 18 || 2022 }}\Enterprise\VC\Auxiliary\Build\vcvars64.bat" && ^
+          call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars64.bat" && ^
          nmake /NOLOGO /F Makefile.win && ^
          nmake /NOLOGO /F Makefile.win install && ^
-          nmake /NOLOGO /F Makefile.win installcheck ${{ matrix.postgres != 17 && 'PG_REGRESS=$(PGROOT)\bin\pg_regress' || '' }} && ^
+          nmake /NOLOGO /F Makefile.win installcheck && ^
          nmake /NOLOGO /F Makefile.win clean && ^
          nmake /NOLOGO /F Makefile.win uninstall
        shell: cmd
@@ -133,10 +122,10 @@ jobs:
    if: ${{ !startsWith(github.ref_name, 'mac') && !startsWith(github.ref_name, 'windows') }}
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v4
      - uses: ankane/setup-postgres-valgrind@v1
        with:
-          postgres-version: 18
+          postgres-version: 16
          check-ub: yes
      - run: make OPTFLAGS=""
      - run: sudo --preserve-env=PG_CONFIG make install
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,26 +1,10 @@
-## 0.8.3 (2026-06-17)
-
- Fixed possible index corruption with HNSW vacuuming
- Fixed performance regression with Hamming distance and Jaccard distance with Postgres 18
-
-## 0.8.2 (2026-02-25)
-
- Fixed buffer overflow with parallel HNSW index build - [more info](https://github.com/pgvector/pgvector/issues/959)
- Improved `install` target on Windows
- Fixed `Index Searches` in `EXPLAIN` output for Postgres 18
-
-## 0.8.1 (2025-09-04)
-
- Added support for Postgres 18 rc1
- Improved performance of `binary_quantize` function
-
-## 0.8.0 (2024-10-30)
+## 0.8.0 (unreleased)

 - Added support for iterative index scans
 - Added casts for arrays to `sparsevec`
- Improved cost estimation for better index selection when filtering
- Improved performance of HNSW index scans
+- Improved cost estimation
 - Improved performance of HNSW inserts and on-disk index builds
+- Reduced memory usage for HNSW index scans
 - Dropped support for Postgres 12

 ## 0.7.4 (2024-08-05)
--- a/7
+++ b/7
@@ -1,11 +1,8 @@
-# syntax=docker/dockerfile:1
-
 ARG PG_MAJOR=17
-ARG DEBIAN_CODENAME=bookworm
-FROM postgres:$PG_MAJOR-$DEBIAN_CODENAME
+FROM postgres:$PG_MAJOR
 ARG PG_MAJOR

-ADD https://github.com/pgvector/pgvector.git#v0.8.3 /tmp/pgvector
+COPY . /tmp/pgvector

 RUN apt-get update && \
 		apt-mark hold locales && \
--- a/2
+++ b/2
@@ -1,4 +1,4 @@
-Portions Copyright (c) 1996-2026, 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.8.3",
+	"version": "0.7.4",
 	"maintainer": [
 		"Andrew Kane <andrew@ankane.org>"
 	],
@@ -12,7 +12,7 @@
 	"prereqs": {
 		"runtime": {
 			"requires": {
-				"PostgreSQL": "13.0.0"
+				"PostgreSQL": "12.0.0"
 			}
 		}
 	},
@@ -20,7 +20,7 @@
 		"vector": {
 			"file": "sql/vector.sql",
 			"docfile": "README.md",
-			"version": "0.8.3",
+			"version": "0.7.4",
 			"abstract": "Open-source vector similarity search for Postgres"
 		}
 	},
--- a/14
+++ b/14
@@ -1,5 +1,5 @@
 EXTENSION = vector
-EXTVERSION = 0.8.3
+EXTVERSION = 0.7.4

 MODULE_big = vector
 DATA = $(wildcard sql/*--*--*.sql)
@@ -27,11 +27,6 @@ ifneq ($(filter ppc64%, $(shell uname -m)), )
 	OPTFLAGS =
 endif

-# RISC-V64 doesn't support -march=native
-ifeq ($(shell uname -m), riscv64)
-	OPTFLAGS =
-endif
-
 # For auto-vectorization:
 # - GCC (needs -ftree-vectorize OR -O3) - https://gcc.gnu.org/projects/tree-ssa/vectorization.html
 # - Clang (could use pragma instead) - https://llvm.org/docs/Vectorizers.html
@@ -81,9 +76,4 @@ docker:
 .PHONY: docker-release

 docker-release:
-	docker buildx build --push --pull --no-cache --platform linux/amd64,linux/arm64 --build-arg PG_MAJOR=$(PG_MAJOR) --build-arg DEBIAN_CODENAME=bookworm -t pgvector/pgvector:pg$(PG_MAJOR) -t pgvector/pgvector:pg$(PG_MAJOR)-bookworm -t pgvector/pgvector:$(EXTVERSION)-pg$(PG_MAJOR) -t pgvector/pgvector:$(EXTVERSION)-pg$(PG_MAJOR)-bookworm .
-
-.PHONY: docker-release-trixie
-
-docker-release-trixie:
-	docker buildx build --push --pull --no-cache --platform linux/amd64,linux/arm64 --build-arg PG_MAJOR=$(PG_MAJOR) --build-arg DEBIAN_CODENAME=trixie -t pgvector/pgvector:pg$(PG_MAJOR)-trixie -t pgvector/pgvector:$(EXTVERSION)-pg$(PG_MAJOR)-trixie .
+	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.8.3
+EXTVERSION = 0.7.4

 DATA_built = sql\$(EXTENSION)--$(EXTVERSION).sql
 OBJS = src\bitutils.obj src\bitvec.obj src\halfutils.obj src\halfvec.obj src\hnsw.obj src\hnswbuild.obj src\hnswinsert.obj src\hnswscan.obj src\hnswutils.obj src\hnswvacuum.obj src\ivfbuild.obj src\ivfflat.obj src\ivfinsert.obj src\ivfkmeans.obj src\ivfscan.obj src\ivfutils.obj src\ivfvacuum.obj src\sparsevec.obj src\vector.obj
@@ -31,9 +31,6 @@ LIBDIR = $(PGROOT)\lib
 PKGLIBDIR = $(PGROOT)\lib
 SHAREDIR = $(PGROOT)\share

-# Use $(PGROOT)\bin\pg_regress for Postgres < 17
-PG_REGRESS = $(LIBDIR)\pgxs\src\test\regress\pg_regress
-
 CFLAGS = /nologo /I"$(INCLUDEDIR_SERVER)\port\win32_msvc" /I"$(INCLUDEDIR_SERVER)\port\win32" /I"$(INCLUDEDIR_SERVER)" /I"$(INCLUDEDIR)"

 CFLAGS = $(CFLAGS) $(PG_CFLAGS)
@@ -57,11 +54,11 @@ install: all
 	copy $(SHLIB) "$(PKGLIBDIR)"
 	copy $(EXTENSION).control "$(SHAREDIR)\extension"
 	copy sql\$(EXTENSION)--*.sql "$(SHAREDIR)\extension"
-	if not exist "$(INCLUDEDIR_SERVER)\extension\$(EXTENSION)" mkdir "$(INCLUDEDIR_SERVER)\extension\$(EXTENSION)"
+	mkdir "$(INCLUDEDIR_SERVER)\extension\$(EXTENSION)"
 	for %f in ($(HEADERS)) do copy %f "$(INCLUDEDIR_SERVER)\extension\$(EXTENSION)"

 installcheck:
-	"$(PG_REGRESS)" --bindir="$(BINDIR)" $(REGRESS_OPTS) $(REGRESS)
+	"$(BINDIR)\pg_regress" --bindir="$(BINDIR)" $(REGRESS_OPTS) $(REGRESS)

 uninstall:
 	del /f "$(PKGLIBDIR)\$(SHLIB)"
--- a/README.md
+++ b/README.md
@@ -11,19 +11,17 @@ Store your vectors with the rest of your data. Supports:

 Plus [ACID](https://en.wikipedia.org/wiki/ACID) compliance, point-in-time recovery, JOINs, and all of the other [great features](https://www.postgresql.org/about/) of Postgres

-Have a lot of vectors? Use [quantization](#scaling) to scale
-
 [![Build Status](https://github.com/pgvector/pgvector/actions/workflows/build.yml/badge.svg)](https://github.com/pgvector/pgvector/actions)

 ## Installation

 ### Linux and Mac

-Compile and install the extension (supports Postgres 13+)
+Compile and install the extension (supports Postgres 12+)

 ```sh
 cd /tmp
-git clone --branch v0.8.3 https://github.com/pgvector/pgvector.git
+git clone --branch v0.7.4 https://github.com/pgvector/pgvector.git
 cd pgvector
 make
 make install # may need sudo
@@ -31,21 +29,31 @@ make install # may need sudo

 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), [pkg](#pkg), [APK](#apk), 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 `x64 Native Tools Command Prompt for VS [version]` as administrator. Then use `nmake` to build:
+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
-set "PGROOT=C:\Program Files\PostgreSQL\18"
+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.8.3 https://github.com/pgvector/pgvector.git
+git clone --branch v0.7.4 https://github.com/pgvector/pgvector.git
 cd pgvector
 nmake /F Makefile.win
 nmake /F Makefile.win install
 ```

+Note: Postgres 17 is not supported yet due to an upstream issue
+
 See the [installation notes](#installation-notes---windows) if you run into issues

 You can also install it with [Docker](#docker) or [conda-forge](#conda-forge).
@@ -76,7 +84,7 @@ Get the nearest neighbors by L2 distance
 SELECT * FROM items ORDER BY embedding <-> '[3,1,2]' LIMIT 5;
 ```

-Also supports inner product (`<#>`), cosine distance (`<=>`), and L1 distance (`<+>`)
+Also supports inner product (`<#>`), cosine distance (`<=>`), and L1 distance (`<+>`, added in 0.7.0)

 Note: `<#>` returns the negative inner product since Postgres only supports `ASC` order index scans on operators

@@ -140,9 +148,9 @@ Supported distance functions are:
 - `<->` - L2 distance
 - `<#>` - (negative) inner product
 - `<=>` - cosine distance
- `<+>` - L1 distance
- `<~>` - Hamming distance (binary vectors)
- `<%>` - Jaccard distance (binary vectors)
+- `<+>` - L1 distance (added in 0.7.0)
+- `<~>` - Hamming distance (binary vectors, added in 0.7.0)
+- `<%>` - Jaccard distance (binary vectors, added in 0.7.0)

 Get the nearest neighbors to a row

@@ -229,19 +237,19 @@ Cosine distance
 CREATE INDEX ON items USING hnsw (embedding vector_cosine_ops);
 ```

-L1 distance
+L1 distance - added in 0.7.0

 ```sql
 CREATE INDEX ON items USING hnsw (embedding vector_l1_ops);
 ```

-Hamming distance
+Hamming distance - added in 0.7.0

 ```sql
 CREATE INDEX ON items USING hnsw (embedding bit_hamming_ops);
 ```

-Jaccard distance
+Jaccard distance - added in 0.7.0

 ```sql
 CREATE INDEX ON items USING hnsw (embedding bit_jaccard_ops);
@@ -250,9 +258,9 @@ CREATE INDEX ON items USING hnsw (embedding bit_jaccard_ops);
 Supported types are:

 - `vector` - up to 2,000 dimensions
- `halfvec` - up to 4,000 dimensions
- `bit` - up to 64,000 dimensions
- `sparsevec` - up to 1,000 non-zero elements
+- `halfvec` - up to 4,000 dimensions (added in 0.7.0)
+- `bit` - up to 64,000 dimensions (added in 0.7.0)
+- `sparsevec` - up to 1,000 non-zero elements (added in 0.7.0)

 ### Index Options

@@ -306,21 +314,17 @@ Note: Do not set `maintenance_work_mem` so high that it exhausts the memory on t

 Like other index types, it’s faster to create an index after loading your initial data

-You can also speed up index creation by increasing the number of parallel workers (2 by default)
+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 need to increase `max_parallel_workers` (8 by default)
-
-The [index options](#index-options) also have a significant impact on build time (use the defaults unless seeing low recall)
-
-Use [binary quantization](#binary-quantization) for faster build times at scale
+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)
+Check [indexing progress](https://www.postgresql.org/docs/current/progress-reporting.html#CREATE-INDEX-PROGRESS-REPORTING) with Postgres 12+

 ```sql
 SELECT phase, round(100.0 * blocks_done / nullif(blocks_total, 0), 1) AS "%" FROM pg_stat_progress_create_index;
@@ -363,7 +367,7 @@ Cosine distance
 CREATE INDEX ON items USING ivfflat (embedding vector_cosine_ops) WITH (lists = 100);
 ```

-Hamming distance
+Hamming distance - added in 0.7.0

 ```sql
 CREATE INDEX ON items USING ivfflat (embedding bit_hamming_ops) WITH (lists = 100);
@@ -372,8 +376,8 @@ CREATE INDEX ON items USING ivfflat (embedding bit_hamming_ops) WITH (lists = 10
 Supported types are:

 - `vector` - up to 2,000 dimensions
- `halfvec` - up to 4,000 dimensions
- `bit` - up to 64,000 dimensions
+- `halfvec` - up to 4,000 dimensions (added in 0.7.0)
+- `bit` - up to 64,000 dimensions (added in 0.7.0)

 ### Query Options

@@ -406,7 +410,7 @@ For a large number of workers, you may also need to increase `max_parallel_worke

 ### Indexing Progress

-Check [indexing progress](https://www.postgresql.org/docs/current/progress-reporting.html#CREATE-INDEX-PROGRESS-REPORTING)
+Check [indexing progress](https://www.postgresql.org/docs/current/progress-reporting.html#CREATE-INDEX-PROGRESS-REPORTING) with Postgres 12+

 ```sql
 SELECT phase, round(100.0 * tuples_done / nullif(tuples_total, 0), 1) AS "%" FROM pg_stat_progress_create_index;
@@ -423,43 +427,25 @@ Note: `%` is only populated during the `loading tuples` phase

 ## Filtering

-There are a few ways to index nearest neighbor queries with a `WHERE` clause.
+There are a few ways to index nearest neighbor queries with a `WHERE` clause

 ```sql
 SELECT * FROM items WHERE category_id = 123 ORDER BY embedding <-> '[3,1,2]' LIMIT 5;
 ```

-A good place to start is creating an index on the filter column. This can provide fast, exact nearest neighbor search in many cases. Postgres has a number of [index types](https://www.postgresql.org/docs/current/indexes-types.html) for this: B-tree (default), hash, GiST, SP-GiST, GIN, and BRIN.
+Create an index on one [or more](https://www.postgresql.org/docs/current/indexes-multicolumn.html) of the `WHERE` columns for exact search

 ```sql
 CREATE INDEX ON items (category_id);
 ```

-For multiple columns, consider a [multicolumn index](https://www.postgresql.org/docs/current/indexes-multicolumn.html).
-
-```sql
-CREATE INDEX ON items (location_id, category_id);
-```
-
-Exact indexes work well for conditions that match a low percentage of rows. Otherwise, [approximate indexes](#indexing) can work better.
-
-```sql
-CREATE INDEX ON items USING hnsw (embedding vector_l2_ops);
-```
-
-With approximate indexes, filtering is applied *after* the index is scanned. If a condition matches 10% of rows, with HNSW and the default `hnsw.ef_search` of 40, only 4 rows will match on average. For more rows, enable [iterative index scans](#iterative-index-scans), which will automatically scan more of the index when needed.
-
-```sql
-SET hnsw.iterative_scan = strict_order;
-```
-
-If filtering by only a few distinct values, consider [partial indexing](https://www.postgresql.org/docs/current/indexes-partial.html).
+Or a [partial index](https://www.postgresql.org/docs/current/indexes-partial.html) on the vector column for approximate search

 ```sql
 CREATE INDEX ON items USING hnsw (embedding vector_l2_ops) WHERE (category_id = 123);
 ```

-If filtering by many different values, consider [partitioning](https://www.postgresql.org/docs/current/ddl-partitioning.html).
+Use [partitioning](https://www.postgresql.org/docs/current/ddl-partitioning.html) for approximate search on many different values of the `WHERE` columns

 ```sql
 CREATE TABLE items (embedding vector(3), category_id int) PARTITION BY LIST(category_id);
@@ -467,9 +453,11 @@ CREATE TABLE items (embedding vector(3), category_id int) PARTITION BY LIST(cate

 ## Iterative Index Scans

-With approximate indexes, queries with filtering can return less results since filtering is applied *after* the index is scanned. Starting with 0.8.0, you can enable iterative index scans, which will automatically scan more of the index until enough results are found (or it reaches `hnsw.max_scan_tuples` or `ivfflat.max_probes`).
+*Unreleased*

-Iterative scans can use strict or relaxed ordering.
+With approximate indexes, queries with filtering can return less results (due to post-filtering). Starting with 0.8.0, you can enable iterative index scans. If too few results from the initial scan match the filters, the scan will resume until enough results are found (or it reaches `hnsw.max_scan_tuples` or `ivfflat.max_probes`). This can significantly improve recall.
+
+There are two modes for iterative scans: strict and relaxed.

 Strict ensures results are in the exact order by distance

@@ -490,11 +478,9 @@ With relaxed ordering, you can use a [materialized CTE](https://www.postgresql.o
 ```sql
 WITH relaxed_results AS MATERIALIZED (
    SELECT id, embedding <-> '[1,2,3]' AS distance FROM items WHERE category_id = 123 ORDER BY distance LIMIT 5
-) SELECT * FROM relaxed_results ORDER BY distance + 0;
+) SELECT * FROM relaxed_results ORDER BY distance;
 ```

-Note: `+ 0` is needed for Postgres 17+
-
 For queries that filter by distance, use a materialized CTE and place the distance filter outside of it for best performance (due to the [current behavior](https://www.postgresql.org/message-id/flat/CAOdR5yGUoMQ6j7M5hNUXrySzaqZVGf_Ne%2B8fwZMRKTFxU1nbJg%40mail.gmail.com) of the Postgres executor)

 ```sql
@@ -507,7 +493,7 @@ Note: Place any other filters inside the CTE

 ### Iterative Scan Options

-Since scanning a large portion of an approximate index is expensive, there are options to control when a scan ends.
+Since scanning a large portion of an approximate index is expensive, there are options to control when a scan ends

 #### HNSW

@@ -525,7 +511,18 @@ Specify the max amount of memory to use, as a multiple of `work_mem` (1 by defau
 SET hnsw.scan_mem_multiplier = 2;
 ```

-Note: Try increasing this if increasing `hnsw.max_scan_tuples` does not improve recall
+You can see when increasing this is needed by enabling debug messages
+
+```sql
+SET client_min_messages = debug1;
+```
+
+which will show when a scan reaches the memory limit
+
+```text
+DEBUG:  hnsw index scan reached memory limit after 20000 tuples
+HINT:  Increase hnsw.scan_mem_multiplier to scan more tuples.
+```

 #### IVFFlat

@@ -539,6 +536,8 @@ Note: If this is lower than `ivfflat.probes`, `ivfflat.probes` will be used

 ## Half-Precision Vectors

+*Added in 0.7.0*
+
 Use the `halfvec` type to store half-precision vectors

 ```sql
@@ -547,6 +546,8 @@ CREATE TABLE items (id bigserial PRIMARY KEY, embedding halfvec(3));

 ## Half-Precision Indexing

+*Added in 0.7.0*
+
 Index vectors at half precision for smaller indexes

 ```sql
@@ -568,16 +569,24 @@ CREATE TABLE items (id bigserial PRIMARY KEY, embedding bit(3));
 INSERT INTO items (embedding) VALUES ('000'), ('111');
 ```

-Get the nearest neighbors by Hamming distance
+Get the nearest neighbors by Hamming distance (added in 0.7.0)

 ```sql
 SELECT * FROM items ORDER BY embedding <~> '101' LIMIT 5;
 ```

+Or (before 0.7.0)
+
+```sql
+SELECT * FROM items ORDER BY bit_count(embedding # '101') LIMIT 5;
+```
+
 Also supports Jaccard distance (`<%>`)

 ## Binary Quantization

+*Added in 0.7.0*
+
 Use expression indexing for binary quantization

 ```sql
@@ -600,6 +609,8 @@ SELECT * FROM (

 ## Sparse Vectors

+*Added in 0.7.0*
+
 Use the `sparsevec` type to store sparse vectors

 ```sql
@@ -633,6 +644,8 @@ You can use [Reciprocal Rank Fusion](https://github.com/pgvector/pgvector-python

 ## Indexing Subvectors

+*Added in 0.7.0*
+
 Use expression indexing to index subvectors

 ```sql
@@ -671,10 +684,6 @@ SHOW shared_buffers;

 Be sure to restart Postgres for changes to take effect.

-### Storing
-
-Use the `halfvec` type instead of `vector` for a smaller working set.
-
 ### Loading

 Use `COPY` for bulk loading data ([example](https://github.com/pgvector/pgvector-python/blob/master/examples/loading/example.py)).
@@ -689,8 +698,6 @@ Add any indexes *after* loading the initial data for best performance.

 See index build time for [HNSW](#index-build-time) and [IVFFlat](#index-build-time-1).

-Use [binary quantization](#binary-quantization) for smaller indexes and faster build times at scale.
-
 In production environments, create indexes concurrently to avoid blocking writes.

 ```sql
@@ -699,10 +706,10 @@ CREATE INDEX CONCURRENTLY ...

 ### Querying

-Use `EXPLAIN (ANALYZE, BUFFERS)` to debug performance.
+Use `EXPLAIN ANALYZE` to debug performance.

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

 #### Exact Search
@@ -721,8 +728,6 @@ SELECT * FROM items ORDER BY embedding <#> '[3,1,2]' LIMIT 5;

 #### Approximate Search

-Use [binary quantization](#binary-quantization) with re-ranking to keep indexes in-memory at scale.
-
 To speed up queries with an IVFFlat index, increase the number of inverted lists (at the expense of recall).

 ```sql
@@ -738,20 +743,23 @@ REINDEX INDEX CONCURRENTLY index_name;
 VACUUM table_name;
 ```

-## Scaling
-
-For a smaller working set:
-
-1. Use the `halfvec` type instead of `vector` for tables
-2. Use [binary quantization](#binary-quantization) for indexes (with re-ranking for search)
-
-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), [PgDog](https://github.com/pgdogdev/pgdog), or another approach for sharding ([example](https://github.com/pgvector/pgvector-python/blob/master/examples/citus/example.py)).
-
 ## Monitoring

-Use existing tools like [pg_stat_statements](https://www.postgresql.org/docs/current/pgstatstatements.html) or [PgHero](https://github.com/ankane/pghero) to monitor performance.
+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.

@@ -762,46 +770,42 @@ 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/example.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.

 Language | Libraries / Examples
 --- | ---
-Ada | [pgvector-ada](https://github.com/pgvector/pgvector-ada)
-Algol | [pgvector-algol](https://github.com/pgvector/pgvector-algol)
 C | [pgvector-c](https://github.com/pgvector/pgvector-c)
 C++ | [pgvector-cpp](https://github.com/pgvector/pgvector-cpp)
 C#, F#, Visual Basic | [pgvector-dotnet](https://github.com/pgvector/pgvector-dotnet)
-COBOL | [pgvector-cobol](https://github.com/pgvector/pgvector-cobol)
 Crystal | [pgvector-crystal](https://github.com/pgvector/pgvector-crystal)
-D | [pgvector-d](https://github.com/pgvector/pgvector-d)
 Dart | [pgvector-dart](https://github.com/pgvector/pgvector-dart)
 Elixir | [pgvector-elixir](https://github.com/pgvector/pgvector-elixir)
-Erlang | [pgvector-erlang](https://github.com/pgvector/pgvector-erlang)
-Fortran | [pgvector-fortran](https://github.com/pgvector/pgvector-fortran)
-Gleam | [pgvector-gleam](https://github.com/pgvector/pgvector-gleam)
 Go | [pgvector-go](https://github.com/pgvector/pgvector-go)
 Haskell | [pgvector-haskell](https://github.com/pgvector/pgvector-haskell)
 Java, Kotlin, Groovy, Scala | [pgvector-java](https://github.com/pgvector/pgvector-java)
 JavaScript, TypeScript | [pgvector-node](https://github.com/pgvector/pgvector-node)
-Julia | [Pgvector.jl](https://github.com/pgvector/Pgvector.jl)
+Julia | [pgvector-julia](https://github.com/pgvector/pgvector-julia)
 Lisp | [pgvector-lisp](https://github.com/pgvector/pgvector-lisp)
 Lua | [pgvector-lua](https://github.com/pgvector/pgvector-lua)
 Nim | [pgvector-nim](https://github.com/pgvector/pgvector-nim)
 OCaml | [pgvector-ocaml](https://github.com/pgvector/pgvector-ocaml)
-Pascal | [pgvector-pascal](https://github.com/pgvector/pgvector-pascal)
 Perl | [pgvector-perl](https://github.com/pgvector/pgvector-perl)
 PHP | [pgvector-php](https://github.com/pgvector/pgvector-php)
-Prolog | [pgvector-prolog](https://github.com/pgvector/pgvector-prolog)
 Python | [pgvector-python](https://github.com/pgvector/pgvector-python)
 R | [pgvector-r](https://github.com/pgvector/pgvector-r)
-Racket | [pgvector-racket](https://github.com/pgvector/pgvector-racket)
-Raku | [pgvector-raku](https://github.com/pgvector/pgvector-raku)
 Ruby | [pgvector-ruby](https://github.com/pgvector/pgvector-ruby), [Neighbor](https://github.com/ankane/neighbor)
 Rust | [pgvector-rust](https://github.com/pgvector/pgvector-rust)
 Swift | [pgvector-swift](https://github.com/pgvector/pgvector-swift)
-Tcl | [pgvector-tcl](https://github.com/pgvector/pgvector-tcl)
 Zig | [pgvector-zig](https://github.com/pgvector/pgvector-zig)

 ## Frequently Asked Questions
@@ -816,11 +820,11 @@ Yes, pgvector uses the write-ahead log (WAL), which allows for replication and p

 #### What if I want to index vectors with more than 2,000 dimensions?

-You can use [half-precision vectors](#half-precision-vectors) or [half-precision indexing](#half-precision-indexing) to index up to 4,000 dimensions or [binary quantization](#binary-quantization) to index up to 64,000 dimensions. Other options are [indexing subvectors](#indexing-subvectors) (for models that support it) or [dimensionality reduction](https://en.wikipedia.org/wiki/Dimensionality_reduction).
+You can use [half-precision indexing](#half-precision-indexing) to index up to 4,000 dimensions or [binary quantization](#binary-quantization) to index up to 64,000 dimensions. Another option is [dimensionality reduction](https://en.wikipedia.org/wiki/Dimensionality_reduction).

 #### Can I store vectors with different dimensions in the same column?

-You can use `vector` as the type (instead of `vector(n)`).
+You can use `vector` as the type (instead of `vector(3)`).

 ```sql
 CREATE TABLE embeddings (model_id bigint, item_id bigint, embedding vector, PRIMARY KEY (model_id, item_id));
@@ -875,8 +879,6 @@ No, but like other index types, you’ll likely see better performance if they d
 SELECT pg_size_pretty(pg_relation_size('index_name'));
 ```

-Use [half-precision indexing](#half-precision-indexing) or [binary quantization](#binary-quantization) for smaller indexes.
-
 ## Troubleshooting

 #### Why isn’t a query using an index?
@@ -922,7 +924,7 @@ 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`), which is 40 by default. There may be even less results due to dead tuples or filtering conditions in the query. Enabling [iterative index scans](#iterative-index-scans) can help address this.
+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.

 Also, note that `NULL` vectors are not indexed (as well as zero vectors for cosine distance).

@@ -934,7 +936,7 @@ 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`). Enabling [iterative index scans](#iterative-index-scans) can address this.
+Results can also be limited by the number of probes (`ivfflat.probes`).

 Also, note that `NULL` vectors are not indexed (as well as zero vectors for cosine distance).

@@ -1070,7 +1072,7 @@ l2_normalize(sparsevec) → sparsevec | Normalize with Euclidean norm | 0.7.0
 If your machine has multiple Postgres installations, specify the path to [pg_config](https://www.postgresql.org/docs/current/app-pgconfig.html) with:

 ```sh
-export PG_CONFIG=/Library/PostgreSQL/18/bin/pg_config
+export PG_CONFIG=/Library/PostgreSQL/17/bin/pg_config
 ```

 Then re-run the installation instructions (run `make clean` before `make` if needed). If `sudo` is needed for `make install`, use:
@@ -1081,11 +1083,11 @@ sudo --preserve-env=PG_CONFIG make install

 A few common paths on Mac are:

- EDB installer - `/Library/PostgreSQL/18/bin/pg_config`
- Homebrew (arm64) - `/opt/homebrew/opt/postgresql@18/bin/pg_config`
- Homebrew (x86-64) - `/usr/local/opt/postgresql@18/bin/pg_config`
+- EDB installer - `/Library/PostgreSQL/17/bin/pg_config`
+- Homebrew (arm64) - `/opt/homebrew/opt/postgresql@17/bin/pg_config`
+- Homebrew (x86-64) - `/usr/local/opt/postgresql@17/bin/pg_config`

-Note: Replace `18` with your Postgres server version
+Note: Replace `17` with your Postgres server version

 ### Missing Header

@@ -1094,20 +1096,14 @@ If compilation fails with `fatal error: postgres.h: No such file or directory`,
 For Ubuntu and Debian, use:

 ```sh
-sudo apt install postgresql-server-dev-18
+sudo apt install postgresql-server-dev-17
 ```

-Note: Replace `18` with your Postgres server version
+Note: Replace `17` with your Postgres server version

 ### Missing SDK

-If compilation fails and the output includes `warning: no such sysroot directory` on Mac, your Postgres installation points to a path that no longer exists.
-
-```sh
-pg_config --cppflags
-```
-
-Reinstall Postgres to fix this.
+If compilation fails and the output includes `warning: no such sysroot directory` on Mac, reinstall Xcode Command Line Tools.

 ### Portability

@@ -1125,14 +1121,6 @@ make OPTFLAGS=""

 If compilation fails with `Cannot open include file: 'postgres.h': No such file or directory`, make sure `PGROOT` is correct.

-### Mismatched Architecture
-
-If compilation fails with `error C2196: case value '4' already used`, make sure you’re using the `x64 Native Tools Command Prompt`. Then run `nmake /F Makefile.win clean` and re-run the installation instructions.
-
-### Missing Symbol
-
-If linking fails with `unresolved external symbol float_to_shortest_decimal_bufn` with Postgres 17.0-17.2, upgrade to Postgres 17.3+.
-
 ### Permissions

 If installation fails with `Access is denied`, re-run the installation instructions as an administrator.
@@ -1144,38 +1132,17 @@ If installation fails with `Access is denied`, re-run the installation instructi
 Get the [Docker image](https://hub.docker.com/r/pgvector/pgvector) with:

 ```sh
-docker pull pgvector/pgvector:pg18-trixie
+docker pull pgvector/pgvector:pg17
 ```

-This adds pgvector to the [Postgres image](https://hub.docker.com/_/postgres) (replace `18` with your Postgres server version, and run it the same way).
-
-Supported tags are:
-
- `pg18-trixie`, `0.8.3-pg18-trixie`
- `pg18-bookworm`, `0.8.3-pg18-bookworm`, `pg18`, `0.8.3-pg18`
- `pg17-trixie`, `0.8.3-pg17-trixie`
- `pg17-bookworm`, `0.8.3-pg17-bookworm`, `pg17`, `0.8.3-pg17`
- `pg16-trixie`, `0.8.3-pg16-trixie`
- `pg16-bookworm`, `0.8.3-pg16-bookworm`, `pg16`, `0.8.3-pg16`
- `pg15-trixie`, `0.8.3-pg15-trixie`
- `pg15-bookworm`, `0.8.3-pg15-bookworm`, `pg15`, `0.8.3-pg15`
- `pg14-trixie`, `0.8.3-pg14-trixie`
- `pg14-bookworm`, `0.8.3-pg14-bookworm`, `pg14`, `0.8.3-pg14`
- `pg13-trixie`, `0.8.3-pg13-trixie`
- `pg13-bookworm`, `0.8.3-pg13-bookworm`, `pg13`, `0.8.3-pg13`
+This adds pgvector to the [Postgres image](https://hub.docker.com/_/postgres) (replace `17` with your Postgres server version, and run it the same way).

 You can also build the image manually:

 ```sh
-git clone --branch v0.8.3 https://github.com/pgvector/pgvector.git
+git clone --branch v0.7.4 https://github.com/pgvector/pgvector.git
 cd pgvector
-docker build --pull --build-arg PG_MAJOR=18 -t myuser/pgvector .
-```
-
-If you increase `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 ...
+docker build --pull --build-arg PG_MAJOR=17 -t myuser/pgvector .
 ```

 ### Homebrew
@@ -1186,7 +1153,7 @@ With Homebrew Postgres, you can use:
 brew install pgvector
 ```

-Note: This only adds it to the `postgresql@18` and `postgresql@17` formulas
+Note: This only adds it to the `postgresql@17` and `postgresql@14` formulas

 ### PGXN

@@ -1201,29 +1168,29 @@ pgxn install vector
 Debian and Ubuntu packages are available from the [PostgreSQL APT Repository](https://wiki.postgresql.org/wiki/Apt). Follow the [setup instructions](https://wiki.postgresql.org/wiki/Apt#Quickstart) and run:

 ```sh
-sudo apt install postgresql-18-pgvector
+sudo apt install postgresql-17-pgvector
 ```

-Note: Replace `18` with your Postgres server version
+Note: Replace `17` with your Postgres server version

 ### Yum

 RPM packages are available from the [PostgreSQL Yum Repository](https://yum.postgresql.org/). Follow the [setup instructions](https://www.postgresql.org/download/linux/redhat/) for your distribution and run:

 ```sh
-sudo yum install pgvector_18
+sudo yum install pgvector_17
 # or
-sudo dnf install pgvector_18
+sudo dnf install pgvector_17
 ```

-Note: Replace `18` with your Postgres server version
+Note: Replace `17` with your Postgres server version

 ### pkg

 Install the FreeBSD package with:

 ```sh
-pkg install postgresql17-pgvector
+pkg install postgresql15-pgvector
 ```

 or the port with:
@@ -1233,14 +1200,6 @@ cd /usr/ports/databases/pgvector
 make install
 ```

-### APK
-
-Install the Alpine package with:
-
-```sh
-apk add postgresql-pgvector
-```
-
 ### conda-forge

 With Conda Postgres, install from [conda-forge](https://anaconda.org/conda-forge/pgvector) with:
@@ -1273,6 +1232,36 @@ You can check the version in the current database with:
 SELECT extversion FROM pg_extension WHERE extname = 'vector';
 ```

+## Upgrade Notes
+
+### 0.6.0
+
+#### 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 = external);
+```
+
+Then run `make install` and `ALTER EXTENSION vector UPDATE;`.
+
+#### Docker
+
+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).
+
+```sh
+docker pull pgvector/pgvector:pg16
+# or
+docker pull pgvector/pgvector:0.6.0-pg16
+```
+
+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

 Thanks to:
@@ -1329,7 +1318,7 @@ make clean && PG_CFLAGS="-DUSE_ASSERT_CHECKING" make && make install
 To enable benchmarking:

 ```sh
-make clean && PG_CFLAGS="-DHNSW_BENCH -DIVFFLAT_BENCH" make && make install
+make clean && PG_CFLAGS="-DIVFFLAT_BENCH" make && make install
 ```

 To show memory usage:
--- a/sql/vector--0.8.0--0.8.1.sql
+++ b/sql/vector--0.8.0--0.8.1.sql
@@ -1,2 +0,0 @@
-- complain if script is sourced in psql, rather than via CREATE EXTENSION
-\echo Use "ALTER EXTENSION vector UPDATE TO '0.8.1'" to load this file. \quit
--- a/sql/vector--0.8.1--0.8.2.sql
+++ b/sql/vector--0.8.1--0.8.2.sql
@@ -1,2 +0,0 @@
-- complain if script is sourced in psql, rather than via CREATE EXTENSION
-\echo Use "ALTER EXTENSION vector UPDATE TO '0.8.2'" to load this file. \quit
--- a/sql/vector--0.8.2--0.8.3.sql
+++ b/sql/vector--0.8.2--0.8.3.sql
@@ -1,2 +0,0 @@
-- complain if script is sourced in psql, rather than via CREATE EXTENSION
-\echo Use "ALTER EXTENSION vector UPDATE TO '0.8.3'" to load this file. \quit
--- a/src/bitutils.c
+++ b/src/bitutils.c
@@ -31,12 +31,10 @@
 #define BIT_TARGET_CLONES
 #endif

-/* Use built-ins when possible for Postgres < 19 for inlining */
-#if PG_VERSION_NUM >= 190000
-#define popcount64(x) pg_popcount64(x)
-#elif defined(HAVE__BUILTIN_POPCOUNT) && (defined(HAVE_LONG_INT_64) || SIZEOF_LONG == 8)
+/* Use built-ins when possible for inlining */
+#if defined(HAVE__BUILTIN_POPCOUNT) && defined(HAVE_LONG_INT_64)
 #define popcount64(x) __builtin_popcountl(x)
-#elif defined(HAVE__BUILTIN_POPCOUNT) && (defined(HAVE_LONG_LONG_INT_64) || SIZEOF_LONG_LONG == 8)
+#elif defined(HAVE__BUILTIN_POPCOUNT) && defined(HAVE_LONG_LONG_INT_64)
 #define popcount64(x) __builtin_popcountll(x)
 #elif !defined(_MSC_VER)
 /* Fails to resolve with MSVC */
@@ -171,7 +169,7 @@ BitJaccardDistanceAvx512Popcount(uint32 bytes, unsigned char *ax, unsigned char
 #endif

 TARGET_XSAVE static bool
-SupportsAvx512Popcount(void)
+SupportsAvx512Popcount()
 {
 	unsigned int exx[4] = {0, 0, 0, 0};

--- a/src/bitvec.c
+++ b/src/bitvec.c
@@ -2,7 +2,6 @@

 #include "bitutils.h"
 #include "bitvec.h"
-#include "fmgr.h"
 #include "utils/varbit.h"
 #include "vector.h"

--- a/src/halfutils.c
+++ b/src/halfutils.c
@@ -1,7 +1,5 @@
 #include "postgres.h"

-#include <math.h>
-
 #include "halfutils.h"
 #include "halfvec.h"

--- a/src/halfvec.c
+++ b/src/halfvec.c
@@ -13,20 +13,12 @@
 #include "port.h"				/* for strtof() */
 #include "sparsevec.h"
 #include "utils/array.h"
+#include "utils/builtins.h"
 #include "utils/float.h"
-#include "utils/fmgrprotos.h"
 #include "utils/lsyscache.h"
-#include "utils/varbit.h"
+#include "utils/numeric.h"
 #include "vector.h"

-#if PG_VERSION_NUM >= 160000
-#include "varatt.h"
-#endif
-
-#if PG_VERSION_NUM >= 170000
-#include "parser/scansup.h"
-#endif
-
 #define STATE_DIMS(x) (ARR_DIMS(x)[0] - 1)
 #define CreateStateDatums(dim) palloc(sizeof(Datum) * (dim + 1))

@@ -137,9 +129,9 @@ InitHalfVector(int dim)
 	return result;
 }

-#if PG_VERSION_NUM >= 170000
-#define halfvec_isspace(ch) scanner_isspace(ch)
-#else
+/*
+ * Check for whitespace, since array_isspace() is static
+ */
 static inline bool
 halfvec_isspace(char ch)
 {
@@ -152,7 +144,6 @@ halfvec_isspace(char ch)
 		return true;
 	return false;
 }
-#endif

 /*
 * Check state array
@@ -907,21 +898,8 @@ halfvec_binary_quantize(PG_FUNCTION_ARGS)
 	half	   *ax = a->x;
 	VarBit	   *result = InitBitVector(a->dim);
 	unsigned char *rx = VARBITS(result);
-	int			i = 0;
-	int			count = (a->dim / 8) * 8;

-	/* Auto-vectorized on aarch64 */
-	for (; i < count; i += 8)
-	{
-		unsigned char result_byte = 0;
-
-		for (int j = 0; j < 8; j++)
-			result_byte |= (HalfToFloat4(ax[i + j]) > 0) << (7 - j);
-
-		rx[i / 8] = result_byte;
-	}
-
-	for (; i < a->dim; i++)
+	for (int i = 0; i < a->dim; i++)
 		rx[i / 8] |= (HalfToFloat4(ax[i]) > 0) << (7 - (i % 8));

 	PG_RETURN_VARBIT_P(result);
--- a/src/hnsw.c
+++ b/src/hnsw.c
@@ -1,25 +1,18 @@
 #include "postgres.h"

 #include <float.h>
-#include <limits.h>
 #include <math.h>

 #include "access/amapi.h"
-#include "access/genam.h"
 #include "access/reloptions.h"
 #include "commands/progress.h"
 #include "commands/vacuum.h"
-#include "fmgr.h"
 #include "hnsw.h"
 #include "miscadmin.h"
-#include "nodes/pg_list.h"
-#include "storage/lwlock.h"
 #include "utils/float.h"
 #include "utils/guc.h"
-#include "utils/relcache.h"
 #include "utils/selfuncs.h"
 #include "utils/spccache.h"
-#include "vector.h"

 #if PG_VERSION_NUM < 150000
 #define MarkGUCPrefixReserved(x) EmitWarningsOnPlaceholders(x)
@@ -59,20 +52,12 @@ HnswInitLockTranche(void)
 								  sizeof(int) * 1,
 								  &found);
 	if (!found)
-	{
-#if PG_VERSION_NUM >= 190000
-		tranche_ids[0] = LWLockNewTrancheId("HnswBuild");
-#else
 		tranche_ids[0] = LWLockNewTrancheId();
-#endif
-	}
 	hnsw_lock_tranche_id = tranche_ids[0];
 	LWLockRelease(AddinShmemInitLock);

-#if PG_VERSION_NUM < 190000
 	/* Per-backend registration of the tranche ID */
 	LWLockRegisterTranche(hnsw_lock_tranche_id, "HnswBuild");
-#endif
 }

 /*
@@ -92,21 +77,21 @@ HnswInit(void)

 	DefineCustomIntVariable("hnsw.ef_search", "Sets the size of the dynamic candidate list for search",
 							"Valid range is 1..1000.", &hnsw_ef_search,
-							HNSW_DEFAULT_EF_SEARCH, HNSW_MIN_EF_SEARCH, HNSW_MAX_EF_SEARCH, PGC_USERSET, 0, NULL, NULL, NULL);
+							HNSW_DEFAULT_EF_SEARCH, HNSW_MIN_EF_SEARCH, HNSW_MAX_EF_SEARCH, PGC_USERSET, GUC_EXPLAIN, NULL, NULL, NULL);

 	DefineCustomEnumVariable("hnsw.iterative_scan", "Sets the mode for iterative scans",
 							 NULL, &hnsw_iterative_scan,
-							 HNSW_ITERATIVE_SCAN_OFF, hnsw_iterative_scan_options, PGC_USERSET, 0, NULL, NULL, NULL);
+							 HNSW_ITERATIVE_SCAN_OFF, hnsw_iterative_scan_options, PGC_USERSET, GUC_EXPLAIN, NULL, NULL, NULL);

 	/* This is approximate and does not affect the initial scan */
 	DefineCustomIntVariable("hnsw.max_scan_tuples", "Sets the max number of tuples to visit for iterative scans",
 							NULL, &hnsw_max_scan_tuples,
-							20000, 1, INT_MAX, PGC_USERSET, 0, NULL, NULL, NULL);
+							20000, 1, INT_MAX, PGC_USERSET, GUC_EXPLAIN, NULL, NULL, NULL);

 	/* Same range as hash_mem_multiplier */
 	DefineCustomRealVariable("hnsw.scan_mem_multiplier", "Sets the multiple of work_mem to use for iterative scans",
 							 NULL, &hnsw_scan_mem_multiplier,
-							 1, 1, 1000, PGC_USERSET, 0, NULL, NULL, NULL);
+							 1, 1, 1000, PGC_USERSET, GUC_EXPLAIN, NULL, NULL, NULL);

 	MarkGUCPrefixReserved("hnsw");
 }
@@ -145,7 +130,7 @@ hnswcostestimate(PlannerInfo *root, IndexPath *path, double loop_count,
 	Relation	index;

 	/* Never use index without order */
-	if (path->indexorderbys == NIL)
+	if (path->indexorderbys == NULL)
 	{
 		*indexStartupCost = get_float8_infinity();
 		*indexTotalCost = get_float8_infinity();
@@ -267,64 +252,6 @@ FUNCTION_PREFIX PG_FUNCTION_INFO_V1(hnswhandler);
 Datum
 hnswhandler(PG_FUNCTION_ARGS)
 {
-#if PG_VERSION_NUM >= 190000
-	static const IndexAmRoutine amroutine = {
-		.type = T_IndexAmRoutine,
-		.amstrategies = 0,
-		.amsupport = 3,
-		.amoptsprocnum = 0,
-		.amcanorder = false,
-		.amcanorderbyop = true,
-		.amcanhash = false,
-		.amconsistentequality = false,
-		.amconsistentordering = false,
-		.amcanbackward = false,
-		.amcanunique = false,
-		.amcanmulticol = false,
-		.amoptionalkey = true,
-		.amsearcharray = false,
-		.amsearchnulls = false,
-		.amstorage = false,
-		.amclusterable = false,
-		.ampredlocks = false,
-		.amcanparallel = false,
-		.amcanbuildparallel = true,
-		.amcaninclude = false,
-		.amusemaintenanceworkmem = false,
-		.amsummarizing = false,
-		.amparallelvacuumoptions = VACUUM_OPTION_PARALLEL_BULKDEL,
-		.amkeytype = InvalidOid,
-
-		.ambuild = hnswbuild,
-		.ambuildempty = hnswbuildempty,
-		.aminsert = hnswinsert,
-		.aminsertcleanup = NULL,
-		.ambulkdelete = hnswbulkdelete,
-		.amvacuumcleanup = hnswvacuumcleanup,
-		.amcanreturn = NULL,
-		.amcostestimate = hnswcostestimate,
-		.amgettreeheight = NULL,
-		.amoptions = hnswoptions,
-		.amproperty = NULL,
-		.ambuildphasename = hnswbuildphasename,
-		.amvalidate = hnswvalidate,
-		.amadjustmembers = NULL,
-		.ambeginscan = hnswbeginscan,
-		.amrescan = hnswrescan,
-		.amgettuple = hnswgettuple,
-		.amgetbitmap = NULL,
-		.amendscan = hnswendscan,
-		.ammarkpos = NULL,
-		.amrestrpos = NULL,
-		.amestimateparallelscan = NULL,
-		.aminitparallelscan = NULL,
-		.amparallelrescan = NULL,
-		.amtranslatestrategy = NULL,
-		.amtranslatecmptype = NULL,
-	};
-
-	PG_RETURN_POINTER(&amroutine);
-#else
 	IndexAmRoutine *amroutine = makeNode(IndexAmRoutine);

 	amroutine->amstrategies = 0;
@@ -332,11 +259,6 @@ hnswhandler(PG_FUNCTION_ARGS)
 	amroutine->amoptsprocnum = 0;
 	amroutine->amcanorder = false;
 	amroutine->amcanorderbyop = true;
-#if PG_VERSION_NUM >= 180000
-	amroutine->amcanhash = false;
-	amroutine->amconsistentequality = false;
-	amroutine->amconsistentordering = false;
-#endif
 	amroutine->amcanbackward = false;	/* can change direction mid-scan */
 	amroutine->amcanunique = false;
 	amroutine->amcanmulticol = false;
@@ -369,9 +291,6 @@ hnswhandler(PG_FUNCTION_ARGS)
 	amroutine->amvacuumcleanup = hnswvacuumcleanup;
 	amroutine->amcanreturn = NULL;
 	amroutine->amcostestimate = hnswcostestimate;
-#if PG_VERSION_NUM >= 180000
-	amroutine->amgettreeheight = NULL;
-#endif
 	amroutine->amoptions = hnswoptions;
 	amroutine->amproperty = NULL;	/* TODO AMPROP_DISTANCE_ORDERABLE */
 	amroutine->ambuildphasename = hnswbuildphasename;
@@ -392,11 +311,5 @@ hnswhandler(PG_FUNCTION_ARGS)
 	amroutine->aminitparallelscan = NULL;
 	amroutine->amparallelrescan = NULL;

-#if PG_VERSION_NUM >= 180000
-	amroutine->amtranslatestrategy = NULL;
-	amroutine->amtranslatecmptype = NULL;
-#endif
-
 	PG_RETURN_POINTER(amroutine);
-#endif
 }
--- a/src/hnsw.h
+++ b/src/hnsw.h
@@ -3,29 +3,15 @@

 #include "postgres.h"

-#include <math.h>
-
 #include "access/genam.h"
 #include "access/parallel.h"
 #include "lib/pairingheap.h"
 #include "nodes/execnodes.h"
 #include "port.h"				/* for random() */
-#include "storage/bufpage.h"
-#include "storage/condition_variable.h"
-#include "storage/lwlock.h"
-#include "storage/s_lock.h"
 #include "utils/relptr.h"
 #include "utils/sampling.h"
 #include "vector.h"

-#ifdef HNSW_BENCH
-#include "portability/instr_time.h"
-#endif
-
-#if PG_VERSION_NUM >= 190000
-typedef Pointer Item;
-#endif
-
 #define HNSW_MAX_DIM 2000
 #define HNSW_MAX_NNZ 1000

@@ -82,21 +68,6 @@ typedef Pointer Item;
 #define HnswPageGetOpaque(page)	((HnswPageOpaque) PageGetSpecialPointer(page))
 #define HnswPageGetMeta(page)	((HnswMetaPageData *) PageGetContents(page))

-#ifdef HNSW_BENCH
-#define HnswBench(name, code) \
-	do { \
-		instr_time	start; \
-		instr_time	duration; \
-		INSTR_TIME_SET_CURRENT(start); \
-		(code); \
-		INSTR_TIME_SET_CURRENT(duration); \
-		INSTR_TIME_SUBTRACT(duration, start); \
-		elog(INFO, "%s: %.3f ms", name, INSTR_TIME_GET_MILLISEC(duration)); \
-	} while (0)
-#else
-#define HnswBench(name, code) (code)
-#endif
-
 #if PG_VERSION_NUM >= 150000
 #define RandomDouble() pg_prng_double(&pg_global_prng_state)
 #define SeedRandom(seed) pg_prng_seed(&pg_global_prng_state, seed)
@@ -155,7 +126,7 @@ typedef struct HnswNeighborArray HnswNeighborArray;

 #define HnswPtrDeclare(type, relptrtype, ptrtype) \
 	relptr_declare(type, relptrtype); \
-	typedef union { type *ptr; relptrtype relptr; } ptrtype
+	typedef union { type *ptr; relptrtype relptr; } ptrtype;

 /* Pointers that can be absolute or relative */
 /* Use char for DatumPtr so works with Pointer */
@@ -431,7 +402,6 @@ typedef struct HnswVacuumState
 	BufferAccessStrategy bas;
 	HnswNeighborTuple ntup;
 	HnswElementData highestPoint;
-	HnswElementData fallbackPoint;

 	/* Memory */
 	MemoryContext tmpCtx;
@@ -454,7 +424,7 @@ void	   *HnswAlloc(HnswAllocator * allocator, Size size);
 HnswElement HnswInitElement(char *base, ItemPointer tid, int m, double ml, int maxLevel, HnswAllocator * alloc);
 HnswElement HnswInitElementFromBlock(BlockNumber blkno, OffsetNumber offno);
 void		HnswFindElementNeighbors(char *base, HnswElement element, HnswElement entryPoint, Relation index, HnswSupport * support, int m, int efConstruction, bool existing);
-HnswSearchCandidate *HnswEntryCandidate(char *base, HnswElement entryPoint, HnswQuery * q, Relation index, HnswSupport * support, bool loadVec);
+HnswSearchCandidate *HnswEntryCandidate(char *base, HnswElement em, HnswQuery * q, Relation rel, HnswSupport * support, bool loadVec);
 void		HnswUpdateMetaPage(Relation index, int updateEntry, HnswElement entryPoint, BlockNumber insertPage, ForkNumber forkNum, bool building);
 void		HnswSetNeighborTuple(char *base, HnswNeighborTuple ntup, HnswElement e, int m);
 void		HnswAddHeapTid(HnswElement element, ItemPointer heaptid);
--- a/src/hnswbuild.c
+++ b/src/hnswbuild.c
@@ -36,14 +36,11 @@
 */
 #include "postgres.h"

-#include <limits.h>
+#include <math.h>

-#include "access/genam.h"
 #include "access/parallel.h"
-#include "access/relscan.h"
 #include "access/table.h"
 #include "access/tableam.h"
-#include "access/tupdesc.h"
 #include "access/xact.h"
 #include "access/xloginsert.h"
 #include "catalog/index.h"
@@ -51,19 +48,11 @@
 #include "commands/progress.h"
 #include "hnsw.h"
 #include "miscadmin.h"
-#include "nodes/execnodes.h"
 #include "optimizer/optimizer.h"
 #include "storage/bufmgr.h"
-#include "storage/condition_variable.h"
 #include "tcop/tcopprot.h"
 #include "utils/datum.h"
 #include "utils/memutils.h"
-#include "utils/rel.h"
-#include "utils/snapmgr.h"
-
-#if PG_VERSION_NUM >= 160000
-#include "varatt.h"
-#endif

 #if PG_VERSION_NUM >= 140000
 #include "utils/backend_progress.h"
@@ -80,8 +69,6 @@
 #define PARALLEL_KEY_HNSW_AREA			UINT64CONST(0xA000000000000002)
 #define PARALLEL_KEY_QUERY_TEXT			UINT64CONST(0xA000000000000003)

-#define HNSW_MAX_GRAPH_MEMORY (SIZE_MAX / 2)
-
 /*
 * Create the metapage
 */
@@ -411,7 +398,7 @@ UpdateNeighborsInMemory(char *base, HnswSupport * support, HnswElement e, int m)
 * Update graph in memory
 */
 static void
-UpdateGraphInMemory(HnswSupport * support, HnswElement element, int m, HnswElement entryPoint, HnswBuildState * buildstate)
+UpdateGraphInMemory(HnswSupport * support, HnswElement element, int m, int efConstruction, HnswElement entryPoint, HnswBuildState * buildstate)
 {
 	HnswGraph  *graph = buildstate->graph;
 	char	   *base = buildstate->hnswarea;
@@ -473,7 +460,7 @@ InsertTupleInMemory(HnswBuildState * buildstate, HnswElement element)
 	HnswFindElementNeighbors(base, element, entryPoint, NULL, support, m, efConstruction, false);

 	/* Update graph in memory */
-	UpdateGraphInMemory(support, element, m, entryPoint, buildstate);
+	UpdateGraphInMemory(support, element, m, efConstruction, entryPoint, buildstate);

 	/* Release entry lock */
 	LWLockRelease(entryLock);
@@ -494,7 +481,6 @@ InsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heaptid, Hn
 	LWLock	   *flushLock = &graph->flushLock;
 	char	   *base = buildstate->hnswarea;
 	Datum		value;
-	Size		memoryMargin;

 	/* Form index value */
 	if (!HnswFormIndexValue(&value, values, isnull, buildstate->typeInfo, support))
@@ -503,9 +489,6 @@ InsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heaptid, Hn
 	/* Get datum size */
 	valueSize = VARSIZE_ANY(DatumGetPointer(value));

-	/* In a parallel build, add a margin so allocations never fail */
-	memoryMargin = base == NULL ? 0 : 1024 * 1024;
-
 	/* Ensure graph not flushed when inserting */
 	LWLockAcquire(flushLock, LW_SHARED);

@@ -527,7 +510,7 @@ InsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heaptid, Hn
 	 * Check that we have enough memory available for the new element now that
 	 * we have the allocator lock, and flush pages if needed.
 	 */
-	if (graph->memoryUsed + memoryMargin >= graph->memoryTotal)
+	if (graph->memoryUsed >= graph->memoryTotal)
 	{
 		LWLockRelease(&graph->allocatorLock);

@@ -562,7 +545,7 @@ InsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heaptid, Hn

 	/* Copy the datum */
 	memcpy(valuePtr, DatumGetPointer(value), valueSize);
-	HnswPtrStore(base, element->value, (char *) valuePtr);
+	HnswPtrStore(base, element->value, valuePtr);

 	/* Create a lock for the element */
 	LWLockInitialize(&element->lock, hnsw_lock_tranche_id);
@@ -620,7 +603,7 @@ InitGraph(HnswGraph * graph, char *base, Size memoryTotal)
 	HnswPtrStore(base, graph->head, (HnswElement) NULL);
 	HnswPtrStore(base, graph->entryPoint, (HnswElement) NULL);
 	graph->memoryUsed = 0;
-	graph->memoryTotal = Min(memoryTotal, HNSW_MAX_GRAPH_MEMORY);
+	graph->memoryTotal = memoryTotal;
 	graph->flushed = false;
 	graph->indtuples = 0;
 	SpinLockInit(&graph->lock);
@@ -661,17 +644,9 @@ static void *
 HnswSharedMemoryAlloc(Size size, void *state)
 {
 	HnswBuildState *buildstate = (HnswBuildState *) state;
-	Size		alignedSize = MAXALIGN(size);
-	void	   *chunk;
+	void	   *chunk = buildstate->hnswarea + buildstate->graph->memoryUsed;

-	if (alignedSize > 1024 * 1024)
-		elog(ERROR, "hnsw allocation too large");
-
-	if (buildstate->graph->memoryUsed + alignedSize > buildstate->graph->memoryTotal)
-		elog(ERROR, "hnsw allocator out of memory");
-
-	chunk = buildstate->hnswarea + buildstate->graph->memoryUsed;
-	buildstate->graph->memoryUsed += alignedSize;
+	buildstate->graph->memoryUsed += MAXALIGN(size);
 	return chunk;
 }

@@ -803,11 +778,7 @@ HnswParallelScanAndInsert(Relation heapRel, Relation indexRel, HnswShared * hnsw
 	buildstate.hnswarea = hnswarea;
 	InitAllocator(&buildstate.allocator, &HnswSharedMemoryAlloc, &buildstate);
 	scan = table_beginscan_parallel(heapRel,
-									ParallelTableScanFromHnswShared(hnswshared)
-#if PG_VERSION_NUM >= 190000
-									,SO_NONE
-#endif
-		);
+									ParallelTableScanFromHnswShared(hnswshared));
 	reltuples = table_index_build_scan(heapRel, indexRel, indexInfo,
 									   true, progress, BuildCallback,
 									   (void *) &buildstate, scan);
@@ -961,8 +932,6 @@ HnswBeginParallel(HnswBuildState * buildstate, bool isconcurrent, int request)
 	if (esthnswarea > estother)
 		esthnswarea -= estother;

-	esthnswarea = Min(esthnswarea, HNSW_MAX_GRAPH_MEMORY);
-
 	shm_toc_estimate_chunk(&pcxt->estimator, esthnswarea);
 	shm_toc_estimate_keys(&pcxt->estimator, 2);

@@ -1005,7 +974,8 @@ HnswBeginParallel(HnswBuildState * buildstate, bool isconcurrent, int request)
 								  snapshot);

 	hnswarea = (char *) shm_toc_allocate(pcxt->toc, esthnswarea);
-	InitGraph(&hnswshared->graphData, hnswarea, esthnswarea);
+	/* Report less than allocated so never fails */
+	InitGraph(&hnswshared->graphData, hnswarea, esthnswarea - 1024 * 1024);

 	/*
 	 * Avoid base address for relptr for Postgres < 14.5
@@ -1084,7 +1054,7 @@ ComputeParallelWorkers(Relation heap, Relation index)
 * Build graph
 */
 static void
-BuildGraph(HnswBuildState * buildstate)
+BuildGraph(HnswBuildState * buildstate, ForkNumber forkNum)
 {
 	int			parallel_workers = 0;

@@ -1132,7 +1102,7 @@ BuildIndex(Relation heap, Relation index, IndexInfo *indexInfo,

 	InitBuildState(buildstate, heap, index, indexInfo, forkNum);

-	BuildGraph(buildstate);
+	BuildGraph(buildstate, forkNum);

 	if (RelationNeedsWAL(index) || forkNum == INIT_FORKNUM)
 		log_newpage_range(index, forkNum, 0, RelationGetNumberOfBlocksInFork(index, forkNum), true);
--- a/src/hnswinsert.c
+++ b/src/hnswinsert.c
@@ -1,19 +1,13 @@
 #include "postgres.h"

-#include "access/genam.h"
+#include <math.h>
+
 #include "access/generic_xlog.h"
 #include "hnsw.h"
-#include "nodes/execnodes.h"
 #include "storage/bufmgr.h"
 #include "storage/lmgr.h"
-#include "storage/lwlock.h"
 #include "utils/datum.h"
 #include "utils/memutils.h"
-#include "utils/rel.h"
-
-#if PG_VERSION_NUM >= 160000
-#include "varatt.h"
-#endif

 /*
 * Get the insert page
@@ -666,7 +660,7 @@ FindDuplicateOnDisk(Relation index, HnswElement element, bool building)
 * Update graph on disk
 */
 static void
-UpdateGraphOnDisk(Relation index, HnswSupport * support, HnswElement element, int m, HnswElement entryPoint, bool building)
+UpdateGraphOnDisk(Relation index, HnswSupport * support, HnswElement element, int m, int efConstruction, HnswElement entryPoint, bool building)
 {
 	BlockNumber newInsertPage = InvalidBlockNumber;

@@ -714,7 +708,7 @@ HnswInsertTupleOnDisk(Relation index, HnswSupport * support, Datum value, ItemPo

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

 	/* Prevent concurrent inserts when likely updating entry point */
 	if (entryPoint == NULL || element->level > entryPoint->level)
@@ -734,7 +728,7 @@ HnswInsertTupleOnDisk(Relation index, HnswSupport * support, Datum value, ItemPo
 	HnswFindElementNeighbors(base, element, entryPoint, index, support, m, efConstruction, false);

 	/* Update graph on disk */
-	UpdateGraphOnDisk(index, support, element, m, entryPoint, building);
+	UpdateGraphOnDisk(index, support, element, m, efConstruction, entryPoint, building);

 	/* Release lock */
 	UnlockPage(index, HNSW_UPDATE_LOCK, lockmode);
--- a/src/hnswscan.c
+++ b/src/hnswscan.c
@@ -1,23 +1,12 @@
 #include "postgres.h"

-#include <limits.h>
-
-#include "access/genam.h"
 #include "access/relscan.h"
 #include "hnsw.h"
-#include "lib/pairingheap.h"
-#include "miscadmin.h"
-#include "nodes/pg_list.h"
 #include "pgstat.h"
+#include "storage/bufmgr.h"
 #include "storage/lmgr.h"
 #include "utils/float.h"
 #include "utils/memutils.h"
-#include "utils/relcache.h"
-#include "utils/snapmgr.h"
-
-#if PG_VERSION_NUM >= 160000
-#include "varatt.h"
-#endif

 /*
 * Algorithm 5 from paper
@@ -153,7 +142,7 @@ hnswbeginscan(Relation index, int nkeys, int norderbys)
 	/* Calculate max memory */
 	/* Add 256 extra bytes to fill last block when close */
 	maxMemory = (double) work_mem * hnsw_scan_mem_multiplier * 1024.0 + 256;
-	so->maxMemory = Min(maxMemory, (double) (SIZE_MAX / 2));
+	so->maxMemory = Min(maxMemory, (double) SIZE_MAX);

 	scan->opaque = so;

@@ -204,10 +193,6 @@ hnswgettuple(IndexScanDesc scan, ScanDirection dir)

 		/* Count index scan for stats */
 		pgstat_count_index_scan(scan->indexRelation);
-#if PG_VERSION_NUM >= 180000
-		if (scan->instrument)
-			scan->instrument->nsearches++;
-#endif

 		/* Safety check */
 		if (scan->orderByData == NULL)
@@ -255,8 +240,8 @@ hnswgettuple(IndexScanDesc scan, ScanDirection dir)
 			if (so->discarded == NULL)
 				break;

-			/* Reached max number of tuples or memory limit */
-			if (so->tuples >= hnsw_max_scan_tuples || MemoryContextMemAllocated(so->tmpCtx, false) > so->maxMemory)
+			/* Reached max number of tuples */
+			if (so->tuples >= hnsw_max_scan_tuples)
 			{
 				if (pairingheap_is_empty(so->discarded))
 					break;
@@ -264,6 +249,21 @@ hnswgettuple(IndexScanDesc scan, ScanDirection dir)
 				/* Return remaining tuples */
 				so->w = lappend(so->w, HnswGetSearchCandidate(w_node, pairingheap_remove_first(so->discarded)));
 			}
+			/* Prevent scans from consuming too much memory */
+			else if (MemoryContextMemAllocated(so->tmpCtx, false) > so->maxMemory)
+			{
+				if (pairingheap_is_empty(so->discarded))
+				{
+					ereport(DEBUG1,
+							(errmsg("hnsw index scan reached memory limit after " INT64_FORMAT " tuples", so->tuples),
+							 errhint("Increase hnsw.scan_mem_multiplier to scan more tuples.")));
+
+					break;
+				}
+
+				/* Return remaining tuples */
+				so->w = lappend(so->w, HnswGetSearchCandidate(w_node, pairingheap_remove_first(so->discarded)));
+			}
 			else
 			{
 				/*
--- a/src/hnswutils.c
+++ b/src/hnswutils.c
@@ -2,24 +2,18 @@

 #include <math.h>

-#include "access/genam.h"
 #include "access/generic_xlog.h"
+#include "catalog/pg_type.h"
+#include "catalog/pg_type_d.h"
 #include "common/hashfn.h"
 #include "fmgr.h"
 #include "hnsw.h"
 #include "lib/pairingheap.h"
-#include "nodes/pg_list.h"
-#include "port/atomics.h"
 #include "sparsevec.h"
 #include "storage/bufmgr.h"
 #include "utils/datum.h"
 #include "utils/memdebug.h"
 #include "utils/rel.h"
-#include "vector.h"
-
-#if PG_VERSION_NUM >= 160000
-#include "varatt.h"
-#endif

 #if PG_VERSION_NUM < 170000
 static inline uint64
@@ -262,7 +256,7 @@ HnswInitElement(char *base, ItemPointer heaptid, int m, double ml, int maxLevel,

 	HnswInitNeighbors(base, element, m, allocator);

-	HnswPtrStore(base, element->value, (char *) NULL);
+	HnswPtrStore(base, element->value, (Pointer) NULL);

 	return element;
 }
@@ -288,7 +282,7 @@ HnswInitElementFromBlock(BlockNumber blkno, OffsetNumber offno)
 	element->blkno = blkno;
 	element->offno = offno;
 	HnswPtrStore(base, element->neighbors, (HnswNeighborArrayPtr *) NULL);
-	HnswPtrStore(base, element->value, (char *) NULL);
+	HnswPtrStore(base, element->value, (Pointer) NULL);
 	return element;
 }

@@ -514,7 +508,7 @@ HnswLoadElementFromTuple(HnswElement element, HnswElementTuple etup, bool loadHe
 		char	   *base = NULL;
 		Datum		value = datumCopy(PointerGetDatum(&etup->data), false, -1);

-		HnswPtrStore(base, element->value, (char *) DatumGetPointer(value));
+		HnswPtrStore(base, element->value, DatumGetPointer(value));
 	}
 }

@@ -546,9 +540,6 @@ HnswLoadElementImpl(BlockNumber blkno, OffsetNumber offno, double *distance, Hns

 	Assert(HnswIsElementTuple(etup));

-	if (unlikely(etup->deleted))
-		elog(ERROR, "cannot load deleted element");
-
 	/* Calculate distance */
 	if (distance != NULL)
 	{
@@ -931,7 +922,7 @@ HnswSearchLayer(char *base, HnswQuery * q, List *ep, int ef, int lc, Relation in
 					continue;
 			}

-			if (!(eDistance < f->distance || alwaysAdd))
+			if (eElement == NULL || !(eDistance < f->distance || alwaysAdd))
 			{
 				if (discarded != NULL)
 				{
@@ -1402,7 +1393,7 @@ hnsw_halfvec_support(PG_FUNCTION_ARGS)
 	};

 	PG_RETURN_POINTER(&typeInfo);
-}
+};

 FUNCTION_PREFIX PG_FUNCTION_INFO_V1(hnsw_bit_support);
 Datum
@@ -1415,7 +1406,7 @@ hnsw_bit_support(PG_FUNCTION_ARGS)
 	};

 	PG_RETURN_POINTER(&typeInfo);
-}
+};

 FUNCTION_PREFIX PG_FUNCTION_INFO_V1(hnsw_sparsevec_support);
 Datum
@@ -1428,4 +1419,4 @@ hnsw_sparsevec_support(PG_FUNCTION_ARGS)
 	};

 	PG_RETURN_POINTER(&typeInfo);
-}
+};
--- a/src/hnswvacuum.c
+++ b/src/hnswvacuum.c
@@ -1,22 +1,13 @@
 #include "postgres.h"

-#include "access/genam.h"
+#include <math.h>
+
 #include "access/generic_xlog.h"
 #include "commands/vacuum.h"
 #include "hnsw.h"
-#include "nodes/pg_list.h"
 #include "storage/bufmgr.h"
 #include "storage/lmgr.h"
 #include "utils/memutils.h"
-#include "utils/rel.h"
-
-#if PG_VERSION_NUM >= 160000
-#include "varatt.h"
-#endif
-
-#if PG_VERSION_NUM >= 180000
-#define vacuum_delay_point() vacuum_delay_point(false)
-#endif

 /*
 * Check if deleted list contains an index TID
@@ -37,20 +28,17 @@ RemoveHeapTids(HnswVacuumState * vacuumstate)
 {
 	BlockNumber blkno = HNSW_HEAD_BLKNO;
 	HnswElement highestPoint = &vacuumstate->highestPoint;
-	HnswElement fallbackPoint = &vacuumstate->fallbackPoint;
 	Relation	index = vacuumstate->index;
 	BufferAccessStrategy bas = vacuumstate->bas;
+	HnswElement entryPoint = HnswGetEntryPoint(vacuumstate->index);
 	IndexBulkDeleteResult *stats = vacuumstate->stats;

-	/* Store separately since HnswElement level is uint8 */
+	/* Store separately since highestPoint.level is uint8 */
 	int			highestLevel = -1;
-	int			fallbackLevel = -1;

-	/* Initialize highest point and fallback point */
+	/* Initialize highest point */
 	highestPoint->blkno = InvalidBlockNumber;
 	highestPoint->offno = InvalidOffsetNumber;
-	fallbackPoint->blkno = InvalidBlockNumber;
-	fallbackPoint->offno = InvalidOffsetNumber;

 	while (BlockNumberIsValid(blkno))
 	{
@@ -122,31 +110,14 @@ RemoveHeapTids(HnswVacuumState * vacuumstate)
 				tidhash_insert(vacuumstate->deleted, ip, &found);
 				Assert(!found);
 			}
-			else if (etup->level > highestLevel)
+			else if (etup->level > highestLevel && !(entryPoint != NULL && blkno == entryPoint->blkno && offno == entryPoint->offno))
 			{
-				if (BlockNumberIsValid(highestPoint->blkno))
-				{
-					/* Current highest point becomes fallback */
-					fallbackPoint->blkno = highestPoint->blkno;
-					fallbackPoint->offno = highestPoint->offno;
-					fallbackPoint->level = highestPoint->level;
-					fallbackLevel = highestLevel;
-				}
-
-				/* Keep track of highest point */
+				/* Keep track of highest non-entry point */
 				highestPoint->blkno = blkno;
 				highestPoint->offno = offno;
 				highestPoint->level = etup->level;
 				highestLevel = etup->level;
 			}
-			else if (etup->level > fallbackLevel)
-			{
-				/* Keep track of second highest point */
-				fallbackPoint->blkno = blkno;
-				fallbackPoint->offno = offno;
-				fallbackPoint->level = etup->level;
-				fallbackLevel = etup->level;
-			}
 		}

 		blkno = HnswPageGetOpaque(page)->nextblkno;
@@ -158,10 +129,6 @@ RemoveHeapTids(HnswVacuumState * vacuumstate)

 		UnlockReleaseBuffer(buf);
 	}
-
-#ifdef HNSW_MEMORY
-	elog(INFO, "memory: %zu KB", MemoryContextMemAllocated(CurrentMemoryContext, true) / 1024);
-#endif
 }

 /*
@@ -203,12 +170,7 @@ NeedsUpdated(HnswVacuumState * vacuumstate, HnswElement element)
 	/* Also update if layer 0 is not full */
 	/* This could indicate too many candidates being deleted during insert */
 	if (!needsUpdated)
-	{
-		/* Keep clang-tidy happy */
-		Assert(ntup->count > 0);
-
 		needsUpdated = !ItemPointerIsValid(&ntup->indextids[ntup->count - 1]);
-	}

 	UnlockReleaseBuffer(buf);

@@ -293,27 +255,12 @@ RepairGraphEntryPoint(HnswVacuumState * vacuumstate)
 		/* Get a shared lock */
 		LockPage(index, HNSW_UPDATE_LOCK, ShareLock);

-		/* Get latest entry point */
-		entryPoint = HnswGetEntryPoint(index);
+		/* Load element */
+		HnswLoadElement(highestPoint, NULL, NULL, index, support, true, NULL);

-		/* Use fallback point if highest point is entry point */
-		if (entryPoint != NULL && entryPoint->blkno == highestPoint->blkno && entryPoint->offno == highestPoint->offno)
-		{
-			highestPoint = &vacuumstate->fallbackPoint;
-
-			if (!BlockNumberIsValid(highestPoint->blkno))
-				highestPoint = NULL;
-		}
-
-		if (highestPoint != NULL)
-		{
-			/* Load element */
-			HnswLoadElement(highestPoint, NULL, NULL, index, support, true, NULL);
-
-			/* Repair if needed */
-			if (NeedsUpdated(vacuumstate, highestPoint))
-				RepairGraphElement(vacuumstate, highestPoint, entryPoint);
-		}
+		/* Repair if needed */
+		if (NeedsUpdated(vacuumstate, highestPoint))
+			RepairGraphElement(vacuumstate, highestPoint, HnswGetEntryPoint(index));

 		/* Release lock */
 		UnlockPage(index, HNSW_UPDATE_LOCK, ShareLock);
@@ -480,99 +427,6 @@ RepairGraph(HnswVacuumState * vacuumstate)
 		/* Reset memory context */
 		MemoryContextSwitchTo(oldCtx);
 		MemoryContextReset(vacuumstate->tmpCtx);
-
-#ifdef HNSW_VACUUM_PROGRESS
-		if (!BlockNumberIsValid(blkno) || (blkno - HNSW_HEAD_BLKNO) % 1000 == 0)
-		{
-			BlockNumber totalBlocks = RelationGetNumberOfBlocks(index);
-			BlockNumber currentBlocks = BlockNumberIsValid(blkno) ? blkno : totalBlocks;
-
-			elog(INFO, "hnsw vacuum progress: %.1f%%", 100.0 * currentBlocks / totalBlocks);
-		}
-#endif
-	}
-}
-
-/*
- * Confirm graph was repaired
- */
-static void
-ConfirmRepaired(HnswVacuumState * vacuumstate)
-{
-	BlockNumber blkno = HNSW_HEAD_BLKNO;
-	Relation	index = vacuumstate->index;
-	BufferAccessStrategy bas = vacuumstate->bas;
-
-	while (BlockNumberIsValid(blkno))
-	{
-		Buffer		buf;
-		Page		page;
-		OffsetNumber offno;
-		OffsetNumber maxoffno;
-
-		vacuum_delay_point();
-
-		buf = ReadBufferExtended(index, MAIN_FORKNUM, blkno, RBM_NORMAL, bas);
-		LockBuffer(buf, BUFFER_LOCK_SHARE);
-		page = BufferGetPage(buf);
-		maxoffno = PageGetMaxOffsetNumber(page);
-
-		/* Iterate over nodes */
-		for (offno = FirstOffsetNumber; offno <= maxoffno; offno = OffsetNumberNext(offno))
-		{
-			HnswElementTuple etup = (HnswElementTuple) PageGetItem(page, PageGetItemId(page, offno));
-			HnswNeighborTuple ntup;
-			Buffer		nbuf;
-			Page		npage;
-			BlockNumber neighborPage;
-			OffsetNumber neighborOffno;
-
-			/* Skip neighbor tuples */
-			if (!HnswIsElementTuple(etup))
-				continue;
-
-			/* Skip if being deleted */
-			if (!ItemPointerIsValid(&etup->heaptids[0]))
-				continue;
-
-			/* Get neighbor page */
-			neighborPage = ItemPointerGetBlockNumber(&etup->neighbortid);
-			neighborOffno = ItemPointerGetOffsetNumber(&etup->neighbortid);
-
-			if (neighborPage == blkno)
-			{
-				nbuf = buf;
-				npage = page;
-			}
-			else
-			{
-				nbuf = ReadBufferExtended(index, MAIN_FORKNUM, neighborPage, RBM_NORMAL, bas);
-				LockBuffer(nbuf, BUFFER_LOCK_SHARE);
-				npage = BufferGetPage(nbuf);
-			}
-
-			ntup = (HnswNeighborTuple) PageGetItem(npage, PageGetItemId(npage, neighborOffno));
-
-			/* Check neighbors */
-			for (int i = 0; i < ntup->count; i++)
-			{
-				ItemPointer indextid = &ntup->indextids[i];
-
-				if (!ItemPointerIsValid(indextid))
-					continue;
-
-				/* Check if in deleted list */
-				if (DeletedContains(vacuumstate->deleted, indextid))
-					elog(ERROR, "hnsw graph not repaired");
-			}
-
-			if (nbuf != buf)
-				UnlockReleaseBuffer(nbuf);
-		}
-
-		blkno = HnswPageGetOpaque(page)->nextblkno;
-
-		UnlockReleaseBuffer(buf);
 	}
 }

@@ -666,9 +520,8 @@ MarkDeleted(HnswVacuumState * vacuumstate)
 			ntup = (HnswNeighborTuple) PageGetItem(npage, PageGetItemId(npage, neighborOffno));

 			/* Overwrite element */
-			/* Use memset instead of MemSet to keep clang-tidy happy */
 			etup->deleted = 1;
-			memset(&etup->data, 0, VARSIZE_ANY(&etup->data));
+			MemSet(&etup->data, 0, VARSIZE_ANY(&etup->data));

 			/* Overwrite neighbors */
 			for (int i = 0; i < ntup->count; i++)
@@ -766,16 +619,13 @@ hnswbulkdelete(IndexVacuumInfo *info, IndexBulkDeleteResult *stats,
 	InitVacuumState(&vacuumstate, info, stats, callback, callback_state);

 	/* Pass 1: Remove heap TIDs */
-	HnswBench("RemoveHeapTids", RemoveHeapTids(&vacuumstate));
+	RemoveHeapTids(&vacuumstate);

 	/* Pass 2: Repair graph */
-	HnswBench("RepairGraph", RepairGraph(&vacuumstate));
+	RepairGraph(&vacuumstate);

-	/* Pass 3: Confirm repaired */
-	HnswBench("ConfirmRepaired", ConfirmRepaired(&vacuumstate));
-
-	/* Pass 4: Mark as deleted */
-	HnswBench("MarkDeleted", MarkDeleted(&vacuumstate));
+	/* Pass 3: Mark as deleted */
+	MarkDeleted(&vacuumstate);

 	FreeVacuumState(&vacuumstate);

--- a/src/ivfbuild.c
+++ b/src/ivfbuild.c
@@ -2,37 +2,23 @@

 #include <float.h>

-#include "access/genam.h"
-#include "access/generic_xlog.h"
-#include "access/itup.h"
-#include "access/relscan.h"
 #include "access/table.h"
 #include "access/tableam.h"
-#include "access/tupdesc.h"
 #include "access/parallel.h"
 #include "access/xact.h"
-#include "access/xloginsert.h"
+#include "bitvec.h"
 #include "catalog/index.h"
 #include "catalog/pg_operator_d.h"
 #include "catalog/pg_type_d.h"
 #include "commands/progress.h"
-#include "fmgr.h"
+#include "halfvec.h"
 #include "ivfflat.h"
 #include "miscadmin.h"
-#include "nodes/execnodes.h"
 #include "optimizer/optimizer.h"
 #include "storage/bufmgr.h"
-#include "storage/condition_variable.h"
 #include "tcop/tcopprot.h"
 #include "utils/memutils.h"
-#include "utils/rel.h"
-#include "utils/sampling.h"
-#include "utils/snapmgr.h"
-#include "utils/tuplesort.h"
-
-#if PG_VERSION_NUM >= 160000
-#include "varatt.h"
-#endif
+#include "vector.h"

 #if PG_VERSION_NUM >= 140000
 #include "utils/backend_progress.h"
@@ -63,13 +49,15 @@ AddSample(Datum *values, IvfflatBuildState * buildstate)
 	Datum		value = PointerGetDatum(PG_DETOAST_DATUM(values[0]));

 	/*
-	 * Check with KMEANS_NORM_PROC that the value can be normalized since
-	 * spherical distance function expects unit vectors
+	 * Normalize with KMEANS_NORM_PROC since spherical distance function
+	 * expects unit vectors
 	 */
 	if (buildstate->kmeansnormprocinfo != NULL)
 	{
 		if (!IvfflatCheckNorm(buildstate->kmeansnormprocinfo, buildstate->collation, value))
 			return;
+
+		value = IvfflatNormValue(buildstate->typeInfo, buildstate->collation, value);
 	}

 	if (samples->length < targsamples)
@@ -80,7 +68,7 @@ AddSample(Datum *values, IvfflatBuildState * buildstate)
 	else
 	{
 		if (buildstate->rowstoskip < 0)
-			buildstate->rowstoskip = reservoir_get_next_S(&buildstate->rstate, buildstate->samplerows, targsamples);
+			buildstate->rowstoskip = reservoir_get_next_S(&buildstate->rstate, samples->length, targsamples);

 		if (buildstate->rowstoskip <= 0)
 		{
@@ -96,9 +84,6 @@ AddSample(Datum *values, IvfflatBuildState * buildstate)

 		buildstate->rowstoskip -= 1;
 	}
-
-	/* Increment after reservoir_get_next_S */
-	buildstate->samplerows += 1;
 }

 /*
@@ -135,7 +120,6 @@ SampleRows(IvfflatBuildState * buildstate)
 	int			targsamples = buildstate->samples->maxlen;
 	BlockNumber totalblocks = RelationGetNumberOfBlocks(buildstate->heap);

-	buildstate->samplerows = 0;
 	buildstate->rowstoskip = -1;

 	BlockSampler_Init(&buildstate->bs, totalblocks, targsamples, RandomInt());
@@ -145,24 +129,8 @@ SampleRows(IvfflatBuildState * buildstate)
 	{
 		BlockNumber targblock = BlockSampler_Next(&buildstate->bs);

-		/* Set anyvisible to false like table_index_build_scan */
 		table_index_build_range_scan(buildstate->heap, buildstate->index, buildstate->indexInfo,
-									 false, false, false, targblock, 1, SampleCallback, (void *) buildstate, NULL);
-	}
-
-	/* Normalize if needed */
-	if (buildstate->kmeansnormprocinfo != NULL)
-	{
-		VectorArray samples = buildstate->samples;
-
-		for (int i = 0; i < samples->length; i++)
-		{
-			Datum		value = PointerGetDatum(VectorArrayGet(samples, i));
-			Datum		normValue = IvfflatNormValue(buildstate->typeInfo, buildstate->collation, value);
-
-			VectorArraySet(samples, i, DatumGetPointer(normValue));
-			pfree(DatumGetPointer(normValue));
-		}
+									 false, true, false, targblock, 1, SampleCallback, (void *) buildstate, NULL);
 	}
 }

@@ -170,7 +138,7 @@ SampleRows(IvfflatBuildState * buildstate)
 * Add tuple to sort
 */
 static void
-AddTupleToSort(ItemPointer tid, Datum *values, IvfflatBuildState * buildstate)
+AddTupleToSort(Relation index, ItemPointer tid, Datum *values, IvfflatBuildState * buildstate)
 {
 	double		distance;
 	double		minDistance = DBL_MAX;
@@ -247,7 +215,7 @@ BuildCallback(Relation index, ItemPointer tid, Datum *values,
 	oldCtx = MemoryContextSwitchTo(buildstate->tmpCtx);

 	/* Add tuple to sort */
-	AddTupleToSort(tid, values, buildstate);
+	AddTupleToSort(index, tid, values, buildstate);

 	/* Reset memory context */
 	MemoryContextSwitchTo(oldCtx);
@@ -392,14 +360,10 @@ InitBuildState(IvfflatBuildState * buildstate, Relation heap, Relation index, In
 	buildstate->sortdesc = CreateTemplateTupleDesc(3);
 	TupleDescInitEntry(buildstate->sortdesc, (AttrNumber) 1, "list", INT4OID, -1, 0);
 	TupleDescInitEntry(buildstate->sortdesc, (AttrNumber) 2, "tid", TIDOID, -1, 0);
-	TupleDescInitEntry(buildstate->sortdesc, (AttrNumber) 3, "vector", TupleDescAttr(buildstate->tupdesc, 0)->atttypid, -1, 0);
-#if PG_VERSION_NUM >= 190000
-	TupleDescFinalize(buildstate->sortdesc);
-#endif
+	TupleDescInitEntry(buildstate->sortdesc, (AttrNumber) 3, "vector", buildstate->tupdesc->attrs[0].atttypid, -1, 0);

 	buildstate->slot = MakeSingleTupleTableSlot(buildstate->sortdesc, &TTSOpsVirtual);

-	/* TODO Ensure within maintenance_work_mem */
 	buildstate->centers = VectorArrayInit(buildstate->lists, buildstate->dimensions, buildstate->typeInfo->itemSize(buildstate->dimensions));
 	buildstate->listInfo = palloc(sizeof(ListInfo) * buildstate->lists);

@@ -458,7 +422,7 @@ ComputeCenters(IvfflatBuildState * buildstate)
 	buildstate->samples = VectorArrayInit(numSamples, buildstate->dimensions, buildstate->centers->itemsize);
 	if (buildstate->heap != NULL)
 	{
-		IvfflatBench("sample rows", SampleRows(buildstate));
+		SampleRows(buildstate);

 		if (buildstate->samples->length < buildstate->lists)
 		{
@@ -506,8 +470,8 @@ CreateMetaPage(Relation index, int dimensions, int lists, ForkNumber forkNum)
 * Create list pages
 */
 static void
-CreateListPages(Relation index, VectorArray centers, int lists,
-				ForkNumber forkNum, ListInfo * *listInfo)
+CreateListPages(Relation index, VectorArray centers, int dimensions,
+				int lists, ForkNumber forkNum, ListInfo * *listInfo)
 {
 	Buffer		buf;
 	Page		page;
@@ -673,11 +637,7 @@ IvfflatParallelScanAndSort(IvfflatSpool * ivfspool, IvfflatShared * ivfshared, S
 	ivfspool->sortstate = InitBuildSortState(buildstate.sortdesc, sortmem, coordinate);
 	buildstate.sortstate = ivfspool->sortstate;
 	scan = table_beginscan_parallel(ivfspool->heap,
-									ParallelTableScanFromIvfflatShared(ivfshared)
-#if PG_VERSION_NUM >= 190000
-									,SO_NONE
-#endif
-		);
+									ParallelTableScanFromIvfflatShared(ivfshared));
 	reltuples = table_index_build_scan(ivfspool->heap, ivfspool->index, indexInfo,
 									   true, progress, BuildCallback,
 									   (void *) &buildstate, scan);
@@ -1044,7 +1004,7 @@ BuildIndex(Relation heap, Relation index, IndexInfo *indexInfo,

 	/* Create pages */
 	CreateMetaPage(index, buildstate->dimensions, buildstate->lists, forkNum);
-	CreateListPages(index, buildstate->centers, buildstate->lists, forkNum, &buildstate->listInfo);
+	CreateListPages(index, buildstate->centers, buildstate->dimensions, buildstate->lists, forkNum, &buildstate->listInfo);
 	CreateEntryPages(buildstate, forkNum);

 	/* Write WAL for initialization fork since GenericXLog functions do not */
@@ -1063,10 +1023,6 @@ ivfflatbuild(Relation heap, Relation index, IndexInfo *indexInfo)
 	IndexBuildResult *result;
 	IvfflatBuildState buildstate;

-#ifdef IVFFLAT_BENCH
-	SeedRandom(42);
-#endif
-
 	BuildIndex(heap, index, indexInfo, &buildstate, MAIN_FORKNUM);

 	result = (IndexBuildResult *) palloc(sizeof(IndexBuildResult));
--- a/src/ivfflat.c
+++ b/src/ivfflat.c
@@ -3,19 +3,14 @@
 #include <float.h>

 #include "access/amapi.h"
-#include "access/genam.h"
 #include "access/reloptions.h"
 #include "commands/progress.h"
 #include "commands/vacuum.h"
-#include "fmgr.h"
 #include "ivfflat.h"
-#include "nodes/pg_list.h"
 #include "utils/float.h"
 #include "utils/guc.h"
-#include "utils/relcache.h"
 #include "utils/selfuncs.h"
 #include "utils/spccache.h"
-#include "vector.h"

 #if PG_VERSION_NUM < 150000
 #define MarkGUCPrefixReserved(x) EmitWarningsOnPlaceholders(x)
@@ -44,16 +39,16 @@ 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);
+							IVFFLAT_DEFAULT_PROBES, IVFFLAT_MIN_LISTS, IVFFLAT_MAX_LISTS, PGC_USERSET, GUC_EXPLAIN, NULL, NULL, NULL);

 	DefineCustomEnumVariable("ivfflat.iterative_scan", "Sets the mode for iterative scans",
 							 NULL, &ivfflat_iterative_scan,
-							 IVFFLAT_ITERATIVE_SCAN_OFF, ivfflat_iterative_scan_options, PGC_USERSET, 0, NULL, NULL, NULL);
+							 IVFFLAT_ITERATIVE_SCAN_OFF, ivfflat_iterative_scan_options, PGC_USERSET, GUC_EXPLAIN, NULL, NULL, NULL);

 	/* If this is less than probes, probes is used */
 	DefineCustomIntVariable("ivfflat.max_probes", "Sets the max number of probes for iterative scans",
 							NULL, &ivfflat_max_probes,
-							IVFFLAT_MAX_LISTS, IVFFLAT_MIN_LISTS, IVFFLAT_MAX_LISTS, PGC_USERSET, 0, NULL, NULL, NULL);
+							IVFFLAT_MAX_LISTS, IVFFLAT_MIN_LISTS, IVFFLAT_MAX_LISTS, PGC_USERSET, GUC_EXPLAIN, NULL, NULL, NULL);

 	MarkGUCPrefixReserved("ivfflat");
 }
@@ -97,7 +92,7 @@ ivfflatcostestimate(PlannerInfo *root, IndexPath *path, double loop_count,
 	Relation	index;

 	/* Never use index without order */
-	if (path->indexorderbys == NIL)
+	if (path->indexorderbys == NULL)
 	{
 		*indexStartupCost = get_float8_infinity();
 		*indexTotalCost = get_float8_infinity();
@@ -184,64 +179,6 @@ FUNCTION_PREFIX PG_FUNCTION_INFO_V1(ivfflathandler);
 Datum
 ivfflathandler(PG_FUNCTION_ARGS)
 {
-#if PG_VERSION_NUM >= 190000
-	static const IndexAmRoutine amroutine = {
-		.type = T_IndexAmRoutine,
-		.amstrategies = 0,
-		.amsupport = 5,
-		.amoptsprocnum = 0,
-		.amcanorder = false,
-		.amcanorderbyop = true,
-		.amcanhash = false,
-		.amconsistentequality = false,
-		.amconsistentordering = false,
-		.amcanbackward = false,
-		.amcanunique = false,
-		.amcanmulticol = false,
-		.amoptionalkey = true,
-		.amsearcharray = false,
-		.amsearchnulls = false,
-		.amstorage = false,
-		.amclusterable = false,
-		.ampredlocks = false,
-		.amcanparallel = false,
-		.amcanbuildparallel = true,
-		.amcaninclude = false,
-		.amusemaintenanceworkmem = false,
-		.amsummarizing = false,
-		.amparallelvacuumoptions = VACUUM_OPTION_PARALLEL_BULKDEL,
-		.amkeytype = InvalidOid,
-
-		.ambuild = ivfflatbuild,
-		.ambuildempty = ivfflatbuildempty,
-		.aminsert = ivfflatinsert,
-		.aminsertcleanup = NULL,
-		.ambulkdelete = ivfflatbulkdelete,
-		.amvacuumcleanup = ivfflatvacuumcleanup,
-		.amcanreturn = NULL,
-		.amcostestimate = ivfflatcostestimate,
-		.amgettreeheight = NULL,
-		.amoptions = ivfflatoptions,
-		.amproperty = NULL,
-		.ambuildphasename = ivfflatbuildphasename,
-		.amvalidate = ivfflatvalidate,
-		.amadjustmembers = NULL,
-		.ambeginscan = ivfflatbeginscan,
-		.amrescan = ivfflatrescan,
-		.amgettuple = ivfflatgettuple,
-		.amgetbitmap = NULL,
-		.amendscan = ivfflatendscan,
-		.ammarkpos = NULL,
-		.amrestrpos = NULL,
-		.amestimateparallelscan = NULL,
-		.aminitparallelscan = NULL,
-		.amparallelrescan = NULL,
-		.amtranslatestrategy = NULL,
-		.amtranslatecmptype = NULL,
-	};
-
-	PG_RETURN_POINTER(&amroutine);
-#else
 	IndexAmRoutine *amroutine = makeNode(IndexAmRoutine);

 	amroutine->amstrategies = 0;
@@ -249,11 +186,6 @@ ivfflathandler(PG_FUNCTION_ARGS)
 	amroutine->amoptsprocnum = 0;
 	amroutine->amcanorder = false;
 	amroutine->amcanorderbyop = true;
-#if PG_VERSION_NUM >= 180000
-	amroutine->amcanhash = false;
-	amroutine->amconsistentequality = false;
-	amroutine->amconsistentordering = false;
-#endif
 	amroutine->amcanbackward = false;	/* can change direction mid-scan */
 	amroutine->amcanunique = false;
 	amroutine->amcanmulticol = false;
@@ -286,9 +218,6 @@ ivfflathandler(PG_FUNCTION_ARGS)
 	amroutine->amvacuumcleanup = ivfflatvacuumcleanup;
 	amroutine->amcanreturn = NULL;	/* tuple not included in heapsort */
 	amroutine->amcostestimate = ivfflatcostestimate;
-#if PG_VERSION_NUM >= 180000
-	amroutine->amgettreeheight = NULL;
-#endif
 	amroutine->amoptions = ivfflatoptions;
 	amroutine->amproperty = NULL;	/* TODO AMPROP_DISTANCE_ORDERABLE */
 	amroutine->ambuildphasename = ivfflatbuildphasename;
@@ -309,11 +238,5 @@ ivfflathandler(PG_FUNCTION_ARGS)
 	amroutine->aminitparallelscan = NULL;
 	amroutine->amparallelrescan = NULL;

-#if PG_VERSION_NUM >= 180000
-	amroutine->amtranslatestrategy = NULL;
-	amroutine->amtranslatecmptype = NULL;
-#endif
-
 	PG_RETURN_POINTER(amroutine);
-#endif
 }
--- a/src/ivfflat.h
+++ b/src/ivfflat.h
@@ -9,15 +9,10 @@
 #include "lib/pairingheap.h"
 #include "nodes/execnodes.h"
 #include "port.h"				/* for random() */
-#include "storage/condition_variable.h"
 #include "utils/sampling.h"
 #include "utils/tuplesort.h"
 #include "vector.h"

-#if PG_VERSION_NUM >= 160000
-#include "varatt.h"
-#endif
-
 #if PG_VERSION_NUM >= 150000
 #include "common/pg_prng.h"
 #endif
@@ -26,10 +21,6 @@
 #include "portability/instr_time.h"
 #endif

-#if PG_VERSION_NUM >= 190000
-typedef Pointer Item;
-#endif
-
 #define IVFFLAT_MAX_DIM 2000

 /* Support functions */
@@ -82,11 +73,9 @@ typedef Pointer Item;
 #if PG_VERSION_NUM >= 150000
 #define RandomDouble() pg_prng_double(&pg_global_prng_state)
 #define RandomInt() pg_prng_uint32(&pg_global_prng_state)
-#define SeedRandom(seed) pg_prng_seed(&pg_global_prng_state, seed)
 #else
 #define RandomDouble() (((double) random()) / MAX_RANDOM_VALUE)
 #define RandomInt() random()
-#define SeedRandom(seed) srandom(seed)
 #endif

 /* Variables */
@@ -214,8 +203,7 @@ typedef struct IvfflatBuildState
 	/* Sampling */
 	BlockSamplerData bs;
 	ReservoirStateData rstate;
-	double		samplerows;
-	double		rowstoskip;
+	int			rowstoskip;

 	/* Sorting */
 	Tuplesortstate *sortstate;
--- a/src/ivfinsert.c
+++ b/src/ivfinsert.c
@@ -2,16 +2,11 @@

 #include <float.h>

-#include "access/genam.h"
 #include "access/generic_xlog.h"
-#include "access/itup.h"
-#include "fmgr.h"
 #include "ivfflat.h"
-#include "nodes/execnodes.h"
 #include "storage/bufmgr.h"
 #include "storage/lmgr.h"
 #include "utils/memutils.h"
-#include "utils/rel.h"

 /*
 * Find the list that minimizes the distance function
@@ -70,7 +65,7 @@ FindInsertPage(Relation index, Datum *values, BlockNumber *insertPage, ListInfo
 * Insert a tuple into the index
 */
 static void
-InsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heap_tid)
+InsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heap_tid, Relation heapRel)
 {
 	const		IvfflatTypeInfo *typeInfo = IvfflatGetTypeInfo(index);
 	IndexTuple	itup;
@@ -209,7 +204,7 @@ ivfflatinsert(Relation index, Datum *values, bool *isnull, ItemPointer heap_tid,
 	oldCtx = MemoryContextSwitchTo(insertCtx);

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

 	/* Delete memory context */
 	MemoryContextSwitchTo(oldCtx);
--- a/src/ivfkmeans.c
+++ b/src/ivfkmeans.c
@@ -1,19 +1,17 @@
 #include "postgres.h"

 #include <float.h>
-#include <limits.h>
 #include <math.h>

-#include "access/genam.h"
-#include "fmgr.h"
+#include "bitvec.h"
+#include "halfutils.h"
+#include "halfvec.h"
 #include "ivfflat.h"
 #include "miscadmin.h"
+#include "utils/builtins.h"
+#include "utils/datum.h"
 #include "utils/memutils.h"
-#include "utils/relcache.h"
-
-#if PG_VERSION_NUM >= 160000
-#include "varatt.h"
-#endif
+#include "vector.h"

 /*
 * Initialize with kmeans++
--- a/src/ivfscan.c
+++ b/src/ivfscan.c
@@ -2,26 +2,15 @@

 #include <float.h>

-#include "access/genam.h"
-#include "access/itup.h"
 #include "access/relscan.h"
-#include "access/tupdesc.h"
 #include "catalog/pg_operator_d.h"
 #include "catalog/pg_type_d.h"
-#include "fmgr.h"
 #include "lib/pairingheap.h"
 #include "ivfflat.h"
 #include "miscadmin.h"
 #include "pgstat.h"
 #include "storage/bufmgr.h"
 #include "utils/memutils.h"
-#include "utils/rel.h"
-#include "utils/snapmgr.h"
-#include "utils/tuplesort.h"
-
-#if PG_VERSION_NUM >= 160000
-#include "varatt.h"
-#endif

 #define GetScanList(ptr) pairingheap_container(IvfflatScanList, ph_node, ptr)
 #define GetScanListConst(ptr) pairingheap_const_container(IvfflatScanList, ph_node, ptr)
@@ -125,6 +114,7 @@ GetScanItems(IndexScanDesc scan, Datum value)
 {
 	IvfflatScanOpaque so = (IvfflatScanOpaque) scan->opaque;
 	TupleDesc	tupdesc = RelationGetDescr(scan->indexRelation);
+	double		tuples = 0;
 	TupleTableSlot *slot = so->vslot;
 	int			batchProbes = 0;

@@ -171,6 +161,8 @@ GetScanItems(IndexScanDesc scan, Datum value)
 				ExecStoreVirtualTuple(slot);

 				tuplesort_puttupleslot(so->sortstate, slot);
+
+				tuples++;
 			}

 			searchPage = IvfflatPageGetOpaque(page)->nextblkno;
@@ -179,6 +171,12 @@ GetScanItems(IndexScanDesc scan, Datum value)
 		}
 	}

+	if (tuples < 100 && ivfflat_iterative_scan == IVFFLAT_ITERATIVE_SCAN_OFF)
+		ereport(DEBUG1,
+				(errmsg("index scan found few tuples"),
+				 errdetail("Index may have been created with little data."),
+				 errhint("Recreate the index and possibly decrease lists.")));
+
 	tuplesort_performsort(so->sortstate);

 #if defined(IVFFLAT_MEMORY)
@@ -298,9 +296,6 @@ ivfflatbeginscan(Relation index, int nkeys, int norderbys)
 	so->tupdesc = CreateTemplateTupleDesc(2);
 	TupleDescInitEntry(so->tupdesc, (AttrNumber) 1, "distance", FLOAT8OID, -1, 0);
 	TupleDescInitEntry(so->tupdesc, (AttrNumber) 2, "heaptid", TIDOID, -1, 0);
-#if PG_VERSION_NUM >= 190000
-	TupleDescFinalize(so->tupdesc);
-#endif

 	/* Prep sort */
 	so->sortstate = InitScanSortState(so->tupdesc);
@@ -369,10 +364,6 @@ ivfflatgettuple(IndexScanDesc scan, ScanDirection dir)

 		/* Count index scan for stats */
 		pgstat_count_index_scan(scan->indexRelation);
-#if PG_VERSION_NUM >= 180000
-		if (scan->instrument)
-			scan->instrument->nsearches++;
-#endif

 		/* Safety check */
 		if (scan->orderByData == NULL)
--- a/src/ivfutils.c
+++ b/src/ivfutils.c
@@ -1,19 +1,13 @@
 #include "postgres.h"

-#include "access/genam.h"
 #include "access/generic_xlog.h"
+#include "bitvec.h"
+#include "catalog/pg_type.h"
 #include "fmgr.h"
 #include "halfutils.h"
 #include "halfvec.h"
 #include "ivfflat.h"
 #include "storage/bufmgr.h"
-#include "utils/relcache.h"
-#include "utils/varbit.h"
-#include "vector.h"
-
-#if PG_VERSION_NUM >= 160000
-#include "varatt.h"
-#endif

 /*
 * Allocate a vector array
@@ -265,8 +259,8 @@ VectorUpdateCenter(Pointer v, int dimensions, float *x)
 	SET_VARSIZE(vec, VECTOR_SIZE(dimensions));
 	vec->dim = dimensions;

-	for (int i = 0; i < dimensions; i++)
-		vec->x[i] = x[i];
+	for (int k = 0; k < dimensions; k++)
+		vec->x[k] = x[k];
 }

 static void
@@ -277,8 +271,8 @@ HalfvecUpdateCenter(Pointer v, int dimensions, float *x)
 	SET_VARSIZE(vec, HALFVEC_SIZE(dimensions));
 	vec->dim = dimensions;

-	for (int i = 0; i < dimensions; i++)
-		vec->x[i] = Float4ToHalfUnchecked(x[i]);
+	for (int k = 0; k < dimensions; k++)
+		vec->x[k] = Float4ToHalfUnchecked(x[k]);
 }

 static void
@@ -290,33 +284,29 @@ BitUpdateCenter(Pointer v, int dimensions, float *x)
 	SET_VARSIZE(vec, VARBITTOTALLEN(dimensions));
 	VARBITLEN(vec) = dimensions;

-	for (uint32 i = 0; i < VARBITBYTES(vec); i++)
-		nx[i] = 0;
+	for (uint32 k = 0; k < VARBITBYTES(vec); k++)
+		nx[k] = 0;

-	for (int i = 0; i < dimensions; i++)
-		nx[i / 8] |= (x[i] > 0.5 ? 1 : 0) << (7 - (i % 8));
+	for (int k = 0; k < dimensions; k++)
+		nx[k / 8] |= (x[k] > 0.5 ? 1 : 0) << (7 - (k % 8));
 }

 static void
 VectorSumCenter(Pointer v, float *x)
 {
 	Vector	   *vec = (Vector *) v;
-	int			dim = vec->dim;

-	/* Auto-vectorized */
-	for (int i = 0; i < dim; i++)
-		x[i] += vec->x[i];
+	for (int k = 0; k < vec->dim; k++)
+		x[k] += vec->x[k];
 }

 static void
 HalfvecSumCenter(Pointer v, float *x)
 {
 	HalfVector *vec = (HalfVector *) v;
-	int			dim = vec->dim;

-	/* Auto-vectorized on aarch64 */
-	for (int i = 0; i < dim; i++)
-		x[i] += HalfToFloat4(vec->x[i]);
+	for (int k = 0; k < vec->dim; k++)
+		x[k] += HalfToFloat4(vec->x[k]);
 }

 static void
@@ -324,8 +314,8 @@ BitSumCenter(Pointer v, float *x)
 {
 	VarBit	   *vec = (VarBit *) v;

-	for (int i = 0; i < VARBITLEN(vec); i++)
-		x[i] += (float) (((VARBITS(vec)[i / 8]) >> (7 - (i % 8))) & 0x01);
+	for (int k = 0; k < VARBITLEN(vec); k++)
+		x[k] += (float) (((VARBITS(vec)[k / 8]) >> (7 - (k % 8))) & 0x01);
 }

 /*
@@ -365,7 +355,7 @@ ivfflat_halfvec_support(PG_FUNCTION_ARGS)
 	};

 	PG_RETURN_POINTER(&typeInfo);
-}
+};

 FUNCTION_PREFIX PG_FUNCTION_INFO_V1(ivfflat_bit_support);
 Datum
@@ -380,4 +370,4 @@ ivfflat_bit_support(PG_FUNCTION_ARGS)
 	};

 	PG_RETURN_POINTER(&typeInfo);
-}
+};
--- a/src/ivfvacuum.c
+++ b/src/ivfvacuum.c
@@ -1,16 +1,9 @@
 #include "postgres.h"

-#include "access/genam.h"
 #include "access/generic_xlog.h"
-#include "access/itup.h"
 #include "commands/vacuum.h"
 #include "ivfflat.h"
 #include "storage/bufmgr.h"
-#include "utils/relcache.h"
-
-#if PG_VERSION_NUM >= 180000
-#define vacuum_delay_point() vacuum_delay_point(false)
-#endif

 /*
 * Bulk delete tuples from the index
--- a/src/sparsevec.c
+++ b/src/sparsevec.c
@@ -4,26 +4,23 @@
 #include <math.h>

 #include "catalog/pg_type.h"
-#include "common/shortest_dec.h"
+#include "common/string.h"
 #include "fmgr.h"
 #include "halfutils.h"
 #include "halfvec.h"
-#include "lib/stringinfo.h"
 #include "libpq/pqformat.h"
 #include "sparsevec.h"
 #include "utils/array.h"
 #include "utils/builtins.h"
-#include "utils/float.h"
-#include "utils/fmgrprotos.h"
 #include "utils/lsyscache.h"
 #include "vector.h"

-#if PG_VERSION_NUM >= 160000
-#include "varatt.h"
-#endif
-
-#if PG_VERSION_NUM >= 170000
-#include "parser/scansup.h"
+#if PG_VERSION_NUM >= 120000
+#include "common/shortest_dec.h"
+#include "utils/float.h"
+#else
+#include <float.h>
+#include "utils/builtins.h"
 #endif

 typedef struct SparseInputElement
@@ -159,9 +156,9 @@ InitSparseVector(int dim, int nnz)
 	return result;
 }

-#if PG_VERSION_NUM >= 170000
-#define sparsevec_isspace(ch) scanner_isspace(ch)
-#else
+/*
+ * Check for whitespace, since array_isspace() is static
+ */
 static inline bool
 sparsevec_isspace(char ch)
 {
@@ -174,7 +171,6 @@ sparsevec_isspace(char ch)
 		return true;
 	return false;
 }
-#endif

 /*
 * Compare indices
@@ -182,10 +178,10 @@ sparsevec_isspace(char ch)
 static int
 CompareIndices(const void *a, const void *b)
 {
-	if (((const SparseInputElement *) a)->index < ((const SparseInputElement *) b)->index)
+	if (((SparseInputElement *) a)->index < ((SparseInputElement *) b)->index)
 		return -1;

-	if (((const SparseInputElement *) a)->index > ((const SparseInputElement *) b)->index)
+	if (((SparseInputElement *) a)->index > ((SparseInputElement *) b)->index)
 		return 1;

 	return 0;
--- a/src/vector.c
+++ b/src/vector.c
@@ -16,20 +16,16 @@
 #include "port.h"				/* for strtof() */
 #include "sparsevec.h"
 #include "utils/array.h"
+#include "utils/builtins.h"
 #include "utils/float.h"
-#include "utils/fmgrprotos.h"
 #include "utils/lsyscache.h"
-#include "utils/varbit.h"
+#include "utils/numeric.h"
 #include "vector.h"

 #if PG_VERSION_NUM >= 160000
 #include "varatt.h"
 #endif

-#if PG_VERSION_NUM >= 170000
-#include "parser/scansup.h"
-#endif
-
 #define STATE_DIMS(x) (ARR_DIMS(x)[0] - 1)
 #define CreateStateDatums(dim) palloc(sizeof(Datum) * (dim + 1))

@@ -39,11 +35,7 @@
 #define VECTOR_TARGET_CLONES
 #endif

-#if PG_VERSION_NUM >= 180000
-PG_MODULE_MAGIC_EXT(.name = "vector", .version = "0.8.3");
-#else
 PG_MODULE_MAGIC;
-#endif

 /*
 * Initialize index options and variables
@@ -133,9 +125,9 @@ InitVector(int dim)
 	return result;
 }

-#if PG_VERSION_NUM >= 170000
-#define vector_isspace(ch) scanner_isspace(ch)
-#else
+/*
+ * Check for whitespace, since array_isspace() is static
+ */
 static inline bool
 vector_isspace(char ch)
 {
@@ -148,7 +140,6 @@ vector_isspace(char ch)
 		return true;
 	return false;
 }
-#endif

 /*
 * Check state array
@@ -929,13 +920,11 @@ vector_concat(PG_FUNCTION_ARGS)
 	CheckDim(dim);
 	result = InitVector(dim);

-	/* Auto-vectorized */
-	for (int i = 0, imax = a->dim; i < imax; i++)
+	for (int i = 0; i < a->dim; i++)
 		result->x[i] = a->x[i];

-	/* Auto-vectorized */
-	for (int i = 0, imax = b->dim, start = a->dim; i < imax; i++)
-		result->x[i + start] = b->x[i];
+	for (int i = 0; i < b->dim; i++)
+		result->x[i + a->dim] = b->x[i];

 	PG_RETURN_POINTER(result);
 }
@@ -951,21 +940,8 @@ binary_quantize(PG_FUNCTION_ARGS)
 	float	   *ax = a->x;
 	VarBit	   *result = InitBitVector(a->dim);
 	unsigned char *rx = VARBITS(result);
-	int			i = 0;
-	int			count = (a->dim / 8) * 8;

-	/* Auto-vectorized */
-	for (; i < count; i += 8)
-	{
-		unsigned char result_byte = 0;
-
-		for (int j = 0; j < 8; j++)
-			result_byte |= (ax[i + j] > 0) << (7 - j);
-
-		rx[i / 8] = result_byte;
-	}
-
-	for (; i < a->dim; i++)
+	for (int i = 0; i < a->dim; i++)
 		rx[i / 8] |= (ax[i] > 0) << (7 - (i % 8));

 	PG_RETURN_VARBIT_P(result);
--- a/test/expected/halfvec.out
+++ b/test/expected/halfvec.out
@@ -540,12 +540,6 @@ SELECT binary_quantize('[0,0.1,-0.2,-0.3,0.4,0.5,0.6,-0.7,0.8,-0.9,1]'::halfvec)
 01001110101
 (1 row)

-SELECT binary_quantize('[1,2,3,-4,5,6,-7,8,1,-2,-3,4,5,-6,7,8,-1,2,3]'::halfvec);
-   binary_quantize   
---------------------
- 1110110110011011011
-(1 row)
-
 SELECT subvector('[1,2,3,4,5]'::halfvec, 1, 3);
 subvector 
 -----------
--- a/test/expected/hnsw_vector.out
+++ b/test/expected/hnsw_vector.out
@@ -123,12 +123,6 @@ SELECT * FROM t ORDER BY val <-> '[3,3,3]';
 [0,0,0]
 (3 rows)

-TRUNCATE t;
-SELECT * FROM t ORDER BY val <-> '[3,3,3]';
- val 
-----
-(0 rows)
-
 RESET hnsw.iterative_scan;
 RESET hnsw.ef_search;
 DROP TABLE t;
@@ -196,6 +190,4 @@ SHOW hnsw.scan_mem_multiplier;

 SET hnsw.scan_mem_multiplier = 0;
 ERROR:  0 is outside the valid range for parameter "hnsw.scan_mem_multiplier" (1 .. 1000)
-SET hnsw.scan_mem_multiplier = 1001;
-ERROR:  1001 is outside the valid range for parameter "hnsw.scan_mem_multiplier" (1 .. 1000)
 DROP TABLE t;
--- a/test/expected/ivfflat_vector.out
+++ b/test/expected/ivfflat_vector.out
@@ -110,15 +110,6 @@ SELECT * FROM t ORDER BY val <-> '[3,3,3]';
 [1,1,1]
 (2 rows)

-TRUNCATE t;
-NOTICE:  ivfflat index created with little data
-DETAIL:  This will cause low recall.
-HINT:  Drop the index until the table has more data.
-SELECT * FROM t ORDER BY val <-> '[3,3,3]';
- val 
-----
-(0 rows)
-
 RESET ivfflat.iterative_scan;
 RESET ivfflat.max_probes;
 DROP TABLE t;
--- a/test/expected/vector_type.out
+++ b/test/expected/vector_type.out
@@ -576,12 +576,6 @@ SELECT binary_quantize('[0,0.1,-0.2,-0.3,0.4,0.5,0.6,-0.7,0.8,-0.9,1]'::vector);
 01001110101
 (1 row)

-SELECT binary_quantize('[1,2,3,-4,5,6,-7,8,1,-2,-3,4,5,-6,7,8,-1,2,3]'::vector);
-   binary_quantize   
---------------------
- 1110110110011011011
-(1 row)
-
 SELECT subvector('[1,2,3,4,5]'::vector, 1, 3);
 subvector 
 -----------
--- a/test/sql/halfvec.sql
+++ b/test/sql/halfvec.sql
@@ -121,7 +121,6 @@ SELECT l2_normalize('[65504]'::halfvec);

 SELECT binary_quantize('[1,0,-1]'::halfvec);
 SELECT binary_quantize('[0,0.1,-0.2,-0.3,0.4,0.5,0.6,-0.7,0.8,-0.9,1]'::halfvec);
-SELECT binary_quantize('[1,2,3,-4,5,6,-7,8,1,-2,-3,4,5,-6,7,8,-1,2,3]'::halfvec);

 SELECT subvector('[1,2,3,4,5]'::halfvec, 1, 3);
 SELECT subvector('[1,2,3,4,5]'::halfvec, 3, 2);
--- a/test/sql/hnsw_vector.sql
+++ b/test/sql/hnsw_vector.sql
@@ -70,9 +70,6 @@ SELECT * FROM t ORDER BY val <-> '[3,3,3]';
 SET hnsw.iterative_scan = relaxed_order;
 SELECT * FROM t ORDER BY val <-> '[3,3,3]';

-TRUNCATE t;
-SELECT * FROM t ORDER BY val <-> '[3,3,3]';
-
 RESET hnsw.iterative_scan;
 RESET hnsw.ef_search;
 DROP TABLE t;
@@ -112,6 +109,5 @@ SET hnsw.max_scan_tuples = 0;
 SHOW hnsw.scan_mem_multiplier;

 SET hnsw.scan_mem_multiplier = 0;
-SET hnsw.scan_mem_multiplier = 1001;

 DROP TABLE t;
--- a/test/sql/ivfflat_vector.sql
+++ b/test/sql/ivfflat_vector.sql
@@ -59,9 +59,6 @@ SELECT * FROM t ORDER BY val <-> '[3,3,3]';
 SET ivfflat.max_probes = 2;
 SELECT * FROM t ORDER BY val <-> '[3,3,3]';

-TRUNCATE t;
-SELECT * FROM t ORDER BY val <-> '[3,3,3]';
-
 RESET ivfflat.iterative_scan;
 RESET ivfflat.max_probes;
 DROP TABLE t;
--- a/test/sql/vector_type.sql
+++ b/test/sql/vector_type.sql
@@ -128,7 +128,6 @@ SELECT l2_normalize('[3e38]'::vector);

 SELECT binary_quantize('[1,0,-1]'::vector);
 SELECT binary_quantize('[0,0.1,-0.2,-0.3,0.4,0.5,0.6,-0.7,0.8,-0.9,1]'::vector);
-SELECT binary_quantize('[1,2,3,-4,5,6,-7,8,1,-2,-3,4,5,-6,7,8,-1,2,3]'::vector);

 SELECT subvector('[1,2,3,4,5]'::vector, 1, 3);
 SELECT subvector('[1,2,3,4,5]'::vector, 3, 2);
--- a/test/t/005_ivfflat_query_recall.pl
+++ b/test/t/005_ivfflat_query_recall.pl
@@ -16,19 +16,29 @@ $node->safe_psql("postgres",
 	"INSERT INTO tst SELECT i, ARRAY[random(), random(), random()] FROM generate_series(1, 100000) i;"
 );

-# Add index
-$node->safe_psql("postgres", "CREATE INDEX ON tst USING ivfflat (v vector_l2_ops);");
+# Check each index type
+my @operators = ("<->", "<#>", "<=>");
+my @opclasses = ("vector_l2_ops", "vector_ip_ops", "vector_cosine_ops");

-# Test 100% recall
-for (1 .. 20)
+for my $i (0 .. $#operators)
 {
-	my $id = int(rand() * 100000);
-	my $query = $node->safe_psql("postgres", "SELECT v FROM tst WHERE i = $id;");
-	my $res = $node->safe_psql("postgres", qq(
-		SET enable_seqscan = off;
-		SELECT v FROM tst ORDER BY v <-> '$query' LIMIT 1;
-	));
-	is($res, $query);
+	my $operator = $operators[$i];
+	my $opclass = $opclasses[$i];
+
+	# Add index
+	$node->safe_psql("postgres", "CREATE INDEX ON tst USING ivfflat (v $opclass);");
+
+	# Test 100% recall
+	for (1 .. 20)
+	{
+		my $id = int(rand() * 100000);
+		my $query = $node->safe_psql("postgres", "SELECT v FROM tst WHERE i = $id;");
+		my $res = $node->safe_psql("postgres", qq(
+			SET enable_seqscan = off;
+			SELECT v FROM tst ORDER BY v <-> '$query' LIMIT 1;
+		));
+		is($res, $query);
+	}
 }

 done_testing();
--- a/test/t/043_hnsw_iterative_scan.pl
+++ b/test/t/043_hnsw_iterative_scan.pl
@@ -56,4 +56,13 @@ foreach ((30000, 50000, 70000))
 	cmp_ok($avg, '<', $expected + 2);
 }

+my ($ret, $stdout, $stderr) = $node->psql("postgres", qq(
+	SET enable_seqscan = off;
+	SET hnsw.iterative_scan = relaxed_order;
+	SET client_min_messages = debug1;
+	SET work_mem = '1MB';
+	SELECT COUNT(*) FROM (SELECT v FROM tst WHERE i % 10000 = 0 ORDER BY v <-> (SELECT v FROM tst LIMIT 1) LIMIT 11) t;
+));
+like($stderr, qr/hnsw index scan reached memory limit after \d+ tuples/);
+
 done_testing();
--- a/test/t/045_hnsw_low_memory_build.pl
+++ b/test/t/045_hnsw_low_memory_build.pl
@@ -1,29 +0,0 @@
-use strict;
-use warnings FATAL => 'all';
-use PostgreSQL::Test::Cluster;
-use PostgreSQL::Test::Utils;
-use Test::More;
-
-# Initialize node
-my $node = PostgreSQL::Test::Cluster->new('node');
-$node->init;
-$node->start;
-
-# Create table
-$node->safe_psql("postgres", "CREATE EXTENSION vector;");
-$node->safe_psql("postgres", "CREATE TABLE tst (v vector(3));");
-$node->safe_psql("postgres",
-	"INSERT INTO tst SELECT ARRAY[random(), random(), random()] FROM generate_series(1, 1000) i;"
-);
-
-my ($ret, $stdout, $stderr) = $node->psql("postgres", qq(
-	SET client_min_messages = DEBUG;
-	SET maintenance_work_mem = '3073kB';
-	ALTER TABLE tst SET (parallel_workers = 1);
-	CREATE INDEX ON tst USING hnsw (v vector_l2_ops);
-));
-is($ret, 0, $stderr);
-like($stderr, qr/using \d+ parallel workers/);
-like($stderr, qr/hnsw graph no longer fits into maintenance_work_mem after 0 tuples/);
-
-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.8.3'
+default_version = '0.7.4'
 module_pathname = '$libdir/vector'
 relocatable = true