Added support for async I/O [skip ci]

Added link to pgvector-ada [skip ci]
Updated changelog [skip ci]
2026-07-22 03:57:34 +08:00 · 2025-11-18 22:44:20 -08:00 · 2025-10-30 22:29:36 -07:00 · 2025-10-30 11:48:44 -07:00 · 2025-10-30 11:40:29 -07:00 · 2025-10-30 11:03:59 -07:00
44 changed files with 1005 additions and 924 deletions
--- a/.dockerignore
+++ b/.dockerignore
@@ -1,8 +0,0 @@
-/.git/
-/dist/
-/results/
-/tmp_check/
-/sql/vector--?.?.?.sql
-regression.*
-*.o
-*.so
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -8,27 +8,29 @@ jobs:
      fail-fast: false
      matrix:
        include:
-          # - postgres: 18
-          #   os: ubuntu-24.04
+          - postgres: 19
+            os: ubuntu-24.04
+          - postgres: 18
+            os: ubuntu-24.04
          - postgres: 17
            os: ubuntu-24.04
          - postgres: 16
-            os: ubuntu-22.04
+            os: ubuntu-24.04-arm
          - postgres: 15
            os: ubuntu-22.04
          - postgres: 14
-            os: ubuntu-20.04
+            os: ubuntu-22.04-arm
          - postgres: 13
-            os: ubuntu-20.04
+            os: ubuntu-22.04
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
      - 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
+          PG_CFLAGS: -DUSE_ASSERT_CHECKING -Wall -Wextra -Werror -Wno-unused-parameter -Wno-sign-compare ${{ matrix.postgres >= 18 && '-Wno-missing-field-initializers' || '' }}
      - run: |
          export PG_CONFIG=`which pg_config`
          sudo --preserve-env=PG_CONFIG make install
@@ -46,18 +48,18 @@ jobs:
      fail-fast: false
      matrix:
        include:
-          - postgres: 16
-            os: macos-14
+          - postgres: 18
+            os: macos-26
          - postgres: 14
-            os: macos-13
+            os: macos-15-intel
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
      - uses: ankane/setup-postgres@v1
        with:
          postgres-version: ${{ matrix.postgres }}
      - run: make
        env:
-          PG_CFLAGS: -DUSE_ASSERT_CHECKING -Wall -Wextra -Werror -Wno-unused-parameter
+          PG_CFLAGS: -DUSE_ASSERT_CHECKING -Wall -Wextra -Werror -Wno-unused-parameter -Wno-unknown-warning-option ${{ matrix.postgres >= 18 && '-Wno-missing-field-initializers' || '' }}
      - run: make install
      - run: make installcheck
      - if: ${{ failure() }}
@@ -70,26 +72,35 @@ jobs:
          tar xf $TAG.tar.gz
          mv postgres-$TAG postgres
        env:
-          TAG: ${{ matrix.postgres == 16 && 'REL_16_2' || 'REL_14_11' }}
+          TAG: ${{ matrix.postgres == 18 && 'REL_18_0' || 'REL_14_19' }}
      - 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@15)/bin/scan-build --status-bugs make
+      - run: make clean && $(brew --prefix llvm@$LLVM_VERSION)/bin/scan-build --status-bugs make
        env:
+          LLVM_VERSION: ${{ matrix.os == 'macos-26' && 20 || 18 }}
          PG_CFLAGS: -DUSE_ASSERT_CHECKING
  windows:
-    runs-on: windows-latest
+    runs-on: ${{ matrix.os }}
    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@v4
+      - uses: actions/checkout@v5
      - uses: ankane/setup-postgres@v1
        with:
-          postgres-version: 14
+          postgres-version: ${{ matrix.postgres }}
      - run: |
          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 && ^
+          nmake /NOLOGO /F Makefile.win installcheck ${{ matrix.postgres != 17 && 'PG_REGRESS=$(PGROOT)\bin\pg_regress' || '' }} && ^
          nmake /NOLOGO /F Makefile.win clean && ^
          nmake /NOLOGO /F Makefile.win uninstall
        shell: cmd
@@ -122,10 +133,10 @@ jobs:
    if: ${{ !startsWith(github.ref_name, 'mac') && !startsWith(github.ref_name, 'windows') }}
    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v5
      - uses: ankane/setup-postgres-valgrind@v1
        with:
-          postgres-version: 16
+          postgres-version: 18
          check-ub: yes
      - run: make OPTFLAGS=""
      - run: sudo --preserve-env=PG_CONFIG make install
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,11 +1,20 @@
-## 0.8.0 (unreleased)
+## 0.8.2 (unreleased)
+
+- 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)

- Added support for inline filtering with HNSW
 - Added support for iterative index scans
 - Added casts for arrays to `sparsevec`
- Improved cost estimation
+- Improved cost estimation for better index selection when filtering
+- Improved performance of HNSW index scans
 - 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,8 +1,11 @@
+# syntax=docker/dockerfile:1
+
 ARG PG_MAJOR=17
-FROM postgres:$PG_MAJOR
+ARG DEBIAN_CODENAME=bookworm
+FROM postgres:$PG_MAJOR-$DEBIAN_CODENAME
 ARG PG_MAJOR

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

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

 MODULE_big = vector
 DATA = $(wildcard sql/*--*--*.sql)
@@ -76,4 +76,9 @@ docker:
 .PHONY: docker-release

 docker-release:
-	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) .
+	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 .
--- a/Makefile.win
+++ b/Makefile.win
@@ -1,5 +1,5 @@
 EXTENSION = vector
-EXTVERSION = 0.7.4
+EXTVERSION = 0.8.1

 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,6 +31,9 @@ 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)
@@ -54,11 +57,11 @@ install: all
 	copy $(SHLIB) "$(PKGLIBDIR)"
 	copy $(EXTENSION).control "$(SHAREDIR)\extension"
 	copy sql\$(EXTENSION)--*.sql "$(SHAREDIR)\extension"
-	mkdir "$(INCLUDEDIR_SERVER)\extension\$(EXTENSION)"
+	if not exist "$(INCLUDEDIR_SERVER)\extension\$(EXTENSION)" mkdir "$(INCLUDEDIR_SERVER)\extension\$(EXTENSION)"
 	for %f in ($(HEADERS)) do copy %f "$(INCLUDEDIR_SERVER)\extension\$(EXTENSION)"

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

 uninstall:
 	del /f "$(PKGLIBDIR)\$(SHLIB)"
--- a/README.md
+++ b/README.md
@@ -17,11 +17,11 @@ Plus [ACID](https://en.wikipedia.org/wiki/ACID) compliance, point-in-time recove

 ### Linux and Mac

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

 ```sh
 cd /tmp
-git clone --branch v0.7.4 https://github.com/pgvector/pgvector.git
+git clone --branch v0.8.1 https://github.com/pgvector/pgvector.git
 cd pgvector
 make
 make install # may need sudo
@@ -33,27 +33,17 @@ You can also install it with [Docker](#docker), [Homebrew](#homebrew), [PGXN](#p

 ### 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:
+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:

 ```cmd
-call "C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Auxiliary\Build\vcvars64.bat"
-```
-
-Note: The exact path will vary depending on your Visual Studio version and edition
-
-Then use `nmake` to build:
-
-```cmd
-set "PGROOT=C:\Program Files\PostgreSQL\16"
+set "PGROOT=C:\Program Files\PostgreSQL\18"
 cd %TEMP%
-git clone --branch v0.7.4 https://github.com/pgvector/pgvector.git
+git clone --branch v0.8.1 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).
@@ -84,7 +74,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 (`<+>`, added in 0.7.0)
+Also supports inner product (`<#>`), cosine distance (`<=>`), and L1 distance (`<+>`)

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

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

 Get the nearest neighbors to a row

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

-L1 distance - added in 0.7.0
+L1 distance

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

-Hamming distance - added in 0.7.0
+Hamming distance

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

-Jaccard distance - added in 0.7.0
+Jaccard distance

 ```sql
 CREATE INDEX ON items USING hnsw (embedding bit_jaccard_ops);
@@ -258,9 +248,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 (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)
+- `halfvec` - up to 4,000 dimensions
+- `bit` - up to 64,000 dimensions
+- `sparsevec` - up to 1,000 non-zero elements

 ### Index Options

@@ -314,17 +304,19 @@ 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

-Starting with 0.6.0, you can also speed up index creation by increasing the number of parallel workers (2 by default)
+You can also speed up index creation by increasing the number of parallel workers (2 by default)

 ```sql
 SET max_parallel_maintenance_workers = 7; -- plus leader
 ```

-For a large number of workers, you may also need to increase `max_parallel_workers` (8 by default)
+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)

 ### Indexing Progress

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

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

-Hamming distance - added in 0.7.0
+Hamming distance

 ```sql
 CREATE INDEX ON items USING ivfflat (embedding bit_hamming_ops) WITH (lists = 100);
@@ -376,8 +368,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 (added in 0.7.0)
- `bit` - up to 64,000 dimensions (added in 0.7.0)
+- `halfvec` - up to 4,000 dimensions
+- `bit` - up to 64,000 dimensions

 ### Query Options

@@ -410,7 +402,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) with Postgres 12+
+Check [indexing progress](https://www.postgresql.org/docs/current/progress-reporting.html#CREATE-INDEX-PROGRESS-REPORTING)

 ```sql
 SELECT phase, round(100.0 * tuples_done / nullif(tuples_total, 0), 1) AS "%" FROM pg_stat_progress_create_index;
@@ -427,39 +419,127 @@ 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;
 ```

-Create an index on one [or more](https://www.postgresql.org/docs/current/indexes-multicolumn.html) of the `WHERE` columns for exact search
+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.

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

-Or a composite HNSW index for approximate search (added in 0.8.0)
+For multiple columns, consider a [multicolumn index](https://www.postgresql.org/docs/current/indexes-multicolumn.html).

 ```sql
-CREATE INDEX ON items USING hnsw (embedding vector_l2_ops, category_id);
+CREATE INDEX ON items (location_id, category_id);
 ```

-Or a [partial index](https://www.postgresql.org/docs/current/indexes-partial.html) on the vector column for approximate search
+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, increase `hnsw.ef_search`.
+
+```sql
+SET hnsw.ef_search = 200;
+```
+
+Starting with 0.8.0, you can 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).

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

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

 ```sql
 CREATE TABLE items (embedding vector(3), category_id int) PARTITION BY LIST(category_id);
 ```

-## Half-Precision Vectors
+## Iterative Index Scans

-*Added in 0.7.0*
+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`).
+
+Iterative scans can use strict or relaxed ordering.
+
+Strict ensures results are in the exact order by distance
+
+```sql
+SET hnsw.iterative_scan = strict_order;
+```
+
+Relaxed allows results to be slightly out of order by distance, but provides better recall
+
+```sql
+SET hnsw.iterative_scan = relaxed_order;
+# or
+SET ivfflat.iterative_scan = relaxed_order;
+```
+
+With relaxed ordering, you can use a [materialized CTE](https://www.postgresql.org/docs/current/queries-with.html#QUERIES-WITH-CTE-MATERIALIZATION) to get strict ordering
+
+```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;
+```
+
+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
+WITH nearest_results AS MATERIALIZED (
+    SELECT id, embedding <-> '[1,2,3]' AS distance FROM items ORDER BY distance LIMIT 5
+) SELECT * FROM nearest_results WHERE distance < 5 ORDER BY distance;
+```
+
+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.
+
+#### HNSW
+
+Specify the max number of tuples to visit (20,000 by default)
+
+```sql
+SET hnsw.max_scan_tuples = 20000;
+```
+
+Note: This is approximate and does not affect the initial scan
+
+Specify the max amount of memory to use, as a multiple of `work_mem` (1 by default)
+
+```sql
+SET hnsw.scan_mem_multiplier = 2;
+```
+
+Note: Try increasing this if increasing `hnsw.max_scan_tuples` does not improve recall
+
+#### IVFFlat
+
+Specify the max number of probes
+
+```sql
+SET ivfflat.max_probes = 100;
+```
+
+Note: If this is lower than `ivfflat.probes`, `ivfflat.probes` will be used
+
+## Half-Precision Vectors

 Use the `halfvec` type to store half-precision vectors

@@ -469,8 +549,6 @@ 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
@@ -492,24 +570,16 @@ CREATE TABLE items (id bigserial PRIMARY KEY, embedding bit(3));
 INSERT INTO items (embedding) VALUES ('000'), ('111');
 ```

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

 ```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
@@ -532,8 +602,6 @@ SELECT * FROM (

 ## Sparse Vectors

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

 ```sql
@@ -567,8 +635,6 @@ 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
@@ -629,10 +695,10 @@ CREATE INDEX CONCURRENTLY ...

 ### Querying

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

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

 #### Exact Search
@@ -682,8 +748,6 @@ SELECT query, calls, ROUND((total_plan_time + total_exec_time) / calls) AS avg_t
    FROM pg_stat_statements ORDER BY total_plan_time + total_exec_time DESC LIMIT 20;
 ```

-Note: Replace `total_plan_time + total_exec_time` with `total_time` for Postgres < 13
-
 Monitor recall by comparing results from approximate search with exact search.

 ```sql
@@ -707,25 +771,32 @@ Use pgvector from any language with a Postgres client. You can even generate and

 Language | Libraries / Examples
 --- | ---
+Ada | [pgvector-ada](https://github.com/pgvector/pgvector-ada)
 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)
 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-julia](https://github.com/pgvector/pgvector-julia)
+Julia | [Pgvector.jl](https://github.com/pgvector/Pgvector.jl)
 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)
 Python | [pgvector-python](https://github.com/pgvector/pgvector-python)
 R | [pgvector-r](https://github.com/pgvector/pgvector-r)
+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)
@@ -743,11 +814,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 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).
+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).

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

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

 ```sql
 CREATE TABLE embeddings (model_id bigint, item_id bigint, embedding vector, PRIMARY KEY (model_id, item_id));
@@ -847,7 +918,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`). 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.
+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.

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

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

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

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

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

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

 A few common paths on Mac are:

- EDB installer - `/Library/PostgreSQL/17/bin/pg_config`
- Homebrew (arm64) - `/opt/homebrew/opt/postgresql@17/bin/pg_config`
- Homebrew (x86-64) - `/usr/local/opt/postgresql@17/bin/pg_config`
+- EDB installer - `/Library/PostgreSQL/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`

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

 ### Missing Header

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

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

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

 ### Missing SDK

-If compilation fails and the output includes `warning: no such sysroot directory` on Mac, reinstall Xcode Command Line Tools.
+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.

 ### Portability

@@ -1044,6 +1121,14 @@ 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.
@@ -1055,17 +1140,38 @@ If installation fails with `Access is denied`, re-run the installation instructi
 Get the [Docker image](https://hub.docker.com/r/pgvector/pgvector) with:

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

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

 You can also build the image manually:

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

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

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

 ### PGXN

@@ -1091,29 +1197,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-17-pgvector
+sudo apt install postgresql-18-pgvector
 ```

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

 ### Yum

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

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

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

 ### pkg

 Install the FreeBSD package with:

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

 or the port with:
@@ -1155,36 +1261,6 @@ 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:
@@ -1195,7 +1271,6 @@ Thanks to:
 - [k-means++: The Advantage of Careful Seeding](https://theory.stanford.edu/~sergei/papers/kMeansPP-soda.pdf)
 - [Concept Decompositions for Large Sparse Text Data using Clustering](https://www.cs.utexas.edu/users/inderjit/public_papers/concept_mlj.pdf)
 - [Efficient and Robust Approximate Nearest Neighbor Search using Hierarchical Navigable Small World Graphs](https://arxiv.org/ftp/arxiv/papers/1603/1603.09320.pdf)
- [HQANN: Efficient and Robust Similarity Search for Hybrid Queries with Structured and Unstructured Constraints](https://arxiv.org/pdf/2207.07940.pdf)

 ## History

--- a/sql/vector--0.7.4--0.8.0.sql
+++ b/sql/vector--0.7.4--0.8.0.sql
@@ -24,11 +24,3 @@ CREATE CAST (double precision[] AS sparsevec)

 CREATE CAST (numeric[] AS sparsevec)
 	WITH FUNCTION array_to_sparsevec(numeric[], integer, boolean) AS ASSIGNMENT;
-
-CREATE FUNCTION hnsw_attribute_distance(integer, integer) RETURNS float8
-	AS 'MODULE_PATHNAME', 'hnsw_int4_attribute_distance' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-
-CREATE OPERATOR CLASS vector_integer_ops
-	DEFAULT FOR TYPE integer USING hnsw AS
-	OPERATOR 2 = (integer, integer),
-	FUNCTION 4 hnsw_attribute_distance(integer, integer);
--- a/sql/vector--0.8.0--0.8.1.sql
+++ b/sql/vector--0.8.0--0.8.1.sql
@@ -0,0 +1,2 @@
+-- complain if script is sourced in psql, rather than via CREATE EXTENSION
+\echo Use "ALTER EXTENSION vector UPDATE TO '0.8.1'" to load this file. \quit
--- a/sql/vector.sql
+++ b/sql/vector.sql
@@ -916,13 +916,3 @@ CREATE OPERATOR CLASS sparsevec_l1_ops
 	OPERATOR 1 <+> (sparsevec, sparsevec) FOR ORDER BY float_ops,
 	FUNCTION 1 l1_distance(sparsevec, sparsevec),
 	FUNCTION 3 hnsw_sparsevec_support(internal);
-
-- hnsw attributes
-
-CREATE FUNCTION hnsw_attribute_distance(integer, integer) RETURNS float8
-	AS 'MODULE_PATHNAME', 'hnsw_int4_attribute_distance' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-
-CREATE OPERATOR CLASS vector_integer_ops
-	DEFAULT FOR TYPE integer USING hnsw AS
-	OPERATOR 2 = (integer, integer),
-	FUNCTION 4 hnsw_attribute_distance(integer, integer);
--- a/src/halfvec.c
+++ b/src/halfvec.c
@@ -898,8 +898,21 @@ 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;

-	for (int i = 0; i < a->dim; i++)
+	/* 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++)
 		rx[i / 8] |= (HalfToFloat4(ax[i]) > 0) << (7 - (i % 8));

 	PG_RETURN_VARBIT_P(result);
--- a/src/hnsw.c
+++ b/src/hnsw.c
@@ -18,16 +18,17 @@
 #define MarkGUCPrefixReserved(x) EmitWarningsOnPlaceholders(x)
 #endif

-static const struct config_enum_entry hnsw_iterative_search_options[] = {
-	{"off", HNSW_ITERATIVE_SEARCH_OFF, false},
-	{"on", HNSW_ITERATIVE_SEARCH_RELAXED, false},
-	{"strict", HNSW_ITERATIVE_SEARCH_STRICT, false},
+static const struct config_enum_entry hnsw_iterative_scan_options[] = {
+	{"off", HNSW_ITERATIVE_SCAN_OFF, false},
+	{"relaxed_order", HNSW_ITERATIVE_SCAN_RELAXED, false},
+	{"strict_order", HNSW_ITERATIVE_SCAN_STRICT, false},
 	{NULL, 0, false}
 };

 int			hnsw_ef_search;
-int			hnsw_iterative_search_max_tuples;
-int			hnsw_iterative_search;
+int			hnsw_iterative_scan;
+int			hnsw_max_scan_tuples;
+double		hnsw_scan_mem_multiplier;
 int			hnsw_lock_tranche_id;
 static relopt_kind hnsw_relopt_kind;

@@ -51,12 +52,20 @@ 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
 }

 /*
@@ -78,14 +87,19 @@ HnswInit(void)
 							"Valid range is 1..1000.", &hnsw_ef_search,
 							HNSW_DEFAULT_EF_SEARCH, HNSW_MIN_EF_SEARCH, HNSW_MAX_EF_SEARCH, PGC_USERSET, 0, NULL, NULL, NULL);

-	DefineCustomEnumVariable("hnsw.iterative_search", "Sets iterative search",
-							 NULL, &hnsw_iterative_search,
-							 HNSW_ITERATIVE_SEARCH_OFF, hnsw_iterative_search_options, PGC_USERSET, 0, 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);

-	/* TODO Ensure ivfflat.max_probes uses same value for "all" */
-	DefineCustomIntVariable("hnsw.iterative_search_max_tuples", "Sets the max number of candidates to visit for iterative search",
-							"-1 means all", &hnsw_iterative_search_max_tuples,
-							-1, -1, INT_MAX, PGC_USERSET, 0, 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);
+
+	/* 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);

 	MarkGUCPrefixReserved("hnsw");
 }
@@ -124,13 +138,17 @@ hnswcostestimate(PlannerInfo *root, IndexPath *path, double loop_count,
 	Relation	index;

 	/* Never use index without order */
-	if (path->indexorderbys == NULL)
+	if (path->indexorderbys == NIL)
 	{
 		*indexStartupCost = get_float8_infinity();
 		*indexTotalCost = get_float8_infinity();
 		*indexSelectivity = 0;
 		*indexCorrelation = 0;
 		*indexPages = 0;
+#if PG_VERSION_NUM >= 180000
+		/* See "On disable_cost" thread on pgsql-hackers */
+		path->path.disabled_nodes = 2;
+#endif
 		return;
 	}

@@ -245,13 +263,18 @@ hnswhandler(PG_FUNCTION_ARGS)
 	IndexAmRoutine *amroutine = makeNode(IndexAmRoutine);

 	amroutine->amstrategies = 0;
-	amroutine->amsupport = 4;
+	amroutine->amsupport = 3;
 	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 = true;
+	amroutine->amcanmulticol = false;
 	amroutine->amoptionalkey = true;
 	amroutine->amsearcharray = false;
 	amroutine->amsearchnulls = false;
@@ -281,6 +304,9 @@ 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;
@@ -301,19 +327,10 @@ 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);
 }
-
-/*
- * Get the distance between two int4 attributes
- */
-PGDLLEXPORT PG_FUNCTION_INFO_V1(hnsw_int4_attribute_distance);
-Datum
-hnsw_int4_attribute_distance(PG_FUNCTION_ARGS)
-{
-	int32		a = PG_GETARG_INT32(0);
-	int32		b = PG_GETARG_INT32(1);
-	double		distance = ((double) a) - ((double) b);
-
-	PG_RETURN_FLOAT8(distance);
-}
--- a/src/hnsw.h
+++ b/src/hnsw.h
@@ -19,7 +19,6 @@
 #define HNSW_DISTANCE_PROC 1
 #define HNSW_NORM_PROC 2
 #define HNSW_TYPE_INFO_PROC 3
-#define HNSW_ATTRIBUTE_DISTANCE_PROC 4

 #define HNSW_VERSION	1
 #define HNSW_MAGIC_NUMBER 0xA953A953
@@ -108,27 +107,26 @@
 #define HnswPtrPointer(hp) (hp).ptr
 #define HnswPtrOffset(hp) relptr_offset((hp).relptr)

-#define HnswUseIndexTuple(index) (IndexRelationGetNumberOfAttributes(index) > 1)
-
 /* Variables */
 extern int	hnsw_ef_search;
-extern int	hnsw_iterative_search;
-extern int	hnsw_iterative_search_max_tuples;
+extern int	hnsw_iterative_scan;
+extern int	hnsw_max_scan_tuples;
+extern double hnsw_scan_mem_multiplier;
 extern int	hnsw_lock_tranche_id;

-typedef enum HnswIterativeSearchType
+typedef enum HnswIterativeScanMode
 {
-	HNSW_ITERATIVE_SEARCH_OFF,
-	HNSW_ITERATIVE_SEARCH_RELAXED,
-	HNSW_ITERATIVE_SEARCH_STRICT
-}			HnswIterativeSearchType;
+	HNSW_ITERATIVE_SCAN_OFF,
+	HNSW_ITERATIVE_SCAN_RELAXED,
+	HNSW_ITERATIVE_SCAN_STRICT
+}			HnswIterativeScanMode;

 typedef struct HnswElementData HnswElementData;
 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 */
@@ -136,7 +134,6 @@ HnswPtrDeclare(HnswElementData, HnswElementRelptr, HnswElementPtr);
 HnswPtrDeclare(HnswNeighborArray, HnswNeighborArrayRelptr, HnswNeighborArrayPtr);
 HnswPtrDeclare(HnswNeighborArrayPtr, HnswNeighborsRelptr, HnswNeighborsPtr);
 HnswPtrDeclare(char, DatumRelptr, DatumPtr);
-HnswPtrDeclare(IndexTupleData, IndexTupleRelptr, IndexTuplePtr);

 struct HnswElementData
 {
@@ -153,7 +150,6 @@ struct HnswElementData
 	OffsetNumber neighborOffno;
 	BlockNumber neighborPage;
 	DatumPtr	value;
-	IndexTuplePtr itup;
 	LWLock		lock;
 };

@@ -179,7 +175,6 @@ typedef struct HnswSearchCandidate
 	pairingheap_node w_node;
 	HnswElementPtr element;
 	double		distance;
-	bool		matches;
 }			HnswSearchCandidate;

 /* HNSW index options */
@@ -258,16 +253,14 @@ typedef struct HnswTypeInfo

 typedef struct HnswSupport
 {
-	FmgrInfo   *procinfo[2];
+	FmgrInfo   *procinfo;
 	FmgrInfo   *normprocinfo;
-	Oid		   *collation;
+	Oid			collation;
 }			HnswSupport;

 typedef struct HnswQuery
 {
 	Datum		value;
-	IndexTuple	itup;
-	ScanKeyData *keyData;
 }			HnswQuery;

 typedef struct HnswBuildState
@@ -296,8 +289,6 @@ typedef struct HnswBuildState
 	HnswGraph  *graph;
 	double		ml;
 	int			maxLevel;
-	bool		useIndexTuple;
-	TupleDesc	tupdesc;

 	/* Memory */
 	MemoryContext graphCtx;
@@ -371,6 +362,13 @@ typedef union
 	ItemPointerData indextid;
 }			HnswUnvisited;

+typedef struct HnswReadStreamData
+{
+	HnswUnvisited *unvisited;
+	int			unvisitedLength;
+	int			visited;
+}			HnswReadStreamData;
+
 typedef struct HnswScanOpaqueData
 {
 	const		HnswTypeInfo *typeInfo;
@@ -382,6 +380,7 @@ typedef struct HnswScanOpaqueData
 	int			m;
 	int64		tuples;
 	double		previousDistance;
+	Size		maxMemory;
 	MemoryContext tmpCtx;

 	/* Support functions */
@@ -425,32 +424,30 @@ bool		HnswCheckNorm(HnswSupport * support, Datum value);
 Buffer		HnswNewBuffer(Relation index, ForkNumber forkNum);
 void		HnswInitPage(Buffer buf, Page page);
 void		HnswInit(void);
-List	   *HnswSearchLayer(char *base, HnswQuery * q, List *ep, int ef, int lc, Relation index, HnswSupport * support, int m, bool inserting, HnswElement skipElement, bool inMemory, visited_hash * v, pairingheap **discarded, bool initVisited, int64 *tuples);
+List	   *HnswSearchLayer(char *base, HnswQuery * q, List *ep, int ef, int lc, Relation index, HnswSupport * support, int m, bool inserting, HnswElement skipElement, visited_hash * v, pairingheap **discarded, bool initVisited, int64 *tuples, bool maintenance);
 HnswElement HnswGetEntryPoint(Relation index);
 void		HnswGetMetaPageInfo(Relation index, int *m, HnswElement * entryPoint);
 void	   *HnswAlloc(HnswAllocator * allocator, Size size);
 HnswElement HnswInitElement(char *base, ItemPointer tid, int m, double ml, int maxLevel, HnswAllocator * alloc);
 HnswElement HnswInitElementFromBlock(BlockNumber blkno, OffsetNumber offno);
-void		HnswFindElementNeighbors(char *base, HnswElement element, HnswElement entryPoint, Relation index, HnswSupport * support, int m, int efConstruction, bool existing, bool inMemory);
-HnswSearchCandidate *HnswEntryCandidate(char *base, HnswElement em, HnswQuery * q, Relation rel, HnswSupport * support, bool loadVec, bool inMemory);
+void		HnswFindElementNeighbors(char *base, HnswElement element, HnswElement entryPoint, Relation index, HnswSupport * support, int m, int efConstruction, bool existing, bool maintenance);
+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);
 HnswNeighborArray *HnswInitNeighborArray(int lm, HnswAllocator * allocator);
 void		HnswInitNeighbors(char *base, HnswElement element, int m, HnswAllocator * alloc);
-bool		HnswInsertTupleOnDisk(Relation index, HnswSupport * support, IndexTuple itup, ItemPointer heaptid, bool building, TupleDesc tupdesc);
+bool		HnswInsertTupleOnDisk(Relation index, HnswSupport * support, Datum value, ItemPointer heaptid, bool building);
 void		HnswUpdateNeighborsOnDisk(Relation index, HnswSupport * support, HnswElement e, int m, bool checkExisting, bool building);
-void		HnswLoadElementFromTuple(HnswElement element, HnswElementTuple etup, bool loadHeaptids, bool loadVec, Relation index);
-void		HnswLoadElement(HnswElement element, double *distance, bool *matches, HnswQuery * q, Relation index, HnswSupport * support, bool loadVec, double *maxDistance);
-void		HnswSetElementTuple(char *base, HnswElementTuple etup, HnswElement element, bool useIndexTuple);
+void		HnswLoadElementFromTuple(HnswElement element, HnswElementTuple etup, bool loadHeaptids, bool loadVec);
+void		HnswLoadElement(HnswElement element, double *distance, HnswQuery * q, Relation index, HnswSupport * support, bool loadVec, double *maxDistance);
+bool		HnswFormIndexValue(Datum *out, Datum *values, bool *isnull, const HnswTypeInfo * typeInfo, HnswSupport * support);
+void		HnswSetElementTuple(char *base, HnswElementTuple etup, HnswElement element);
 void		HnswUpdateConnection(char *base, HnswNeighborArray * neighbors, HnswElement newElement, float distance, int lm, int *updateIdx, Relation index, HnswSupport * support);
-bool		HnswFormIndexTuple(IndexTuple *out, Datum *values, bool *isnull, const HnswTypeInfo * typeInfo, HnswSupport * support, TupleDesc tupdesc);
 bool		HnswLoadNeighborTids(HnswElement element, ItemPointerData *indextids, Relation index, int m, int lm, int lc);
 void		HnswInitLockTranche(void);
 const		HnswTypeInfo *HnswGetTypeInfo(Relation index);
 PGDLLEXPORT void HnswParallelBuildMain(dsm_segment *seg, shm_toc *toc);
-Size		HnswGetElementTupleSize(char *base, HnswElement element, bool useIndexTuple);
-bool		HnswIndexTupleIsEqual(IndexTuple a, IndexTuple b, TupleDesc tupdesc);

 /* Index access methods */
 IndexBuildResult *hnswbuild(Relation heap, Relation index, IndexInfo *indexInfo);
--- a/src/hnswbuild.c
+++ b/src/hnswbuild.c
@@ -54,6 +54,10 @@
 #include "utils/datum.h"
 #include "utils/memutils.h"

+#if PG_VERSION_NUM >= 160000
+#include "varatt.h"
+#endif
+
 #if PG_VERSION_NUM >= 140000
 #include "utils/backend_progress.h"
 #else
@@ -148,7 +152,6 @@ CreateGraphPages(HnswBuildState * buildstate)
 	Page		page;
 	HnswElementPtr iter = buildstate->graph->head;
 	char	   *base = buildstate->hnswarea;
-	bool		useIndexTuple = buildstate->useIndexTuple;

 	/* Calculate sizes */
 	maxSize = HNSW_MAX_SIZE;
@@ -168,6 +171,7 @@ CreateGraphPages(HnswBuildState * buildstate)
 		Size		etupSize;
 		Size		ntupSize;
 		Size		combinedSize;
+		Pointer		valuePtr = HnswPtrAccess(base, element->value);

 		/* Update iterator */
 		iter = element->next;
@@ -176,7 +180,7 @@ CreateGraphPages(HnswBuildState * buildstate)
 		MemSet(etup, 0, HNSW_TUPLE_ALLOC_SIZE);

 		/* Calculate sizes */
-		etupSize = HnswGetElementTupleSize(base, element, useIndexTuple);
+		etupSize = HNSW_ELEMENT_TUPLE_SIZE(VARSIZE_ANY(valuePtr));
 		ntupSize = HNSW_NEIGHBOR_TUPLE_SIZE(element->level, buildstate->m);
 		combinedSize = etupSize + ntupSize + sizeof(ItemIdData);

@@ -186,7 +190,7 @@ CreateGraphPages(HnswBuildState * buildstate)
 					(errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
 					 errmsg("index tuple too large")));

-		HnswSetElementTuple(base, etup, element, useIndexTuple);
+		HnswSetElementTuple(base, etup, element);

 		/* Keep element and neighbors on the same page if possible */
 		if (PageGetFreeSpace(page) < etupSize || (combinedSize <= maxSize && PageGetFreeSpace(page) < combinedSize))
@@ -327,18 +331,19 @@ AddDuplicateInMemory(HnswElement element, HnswElement dup)
 * Find duplicate element
 */
 static bool
-FindDuplicateInMemory(char *base, HnswElement element, bool useIndexTuple, TupleDesc tupdesc)
+FindDuplicateInMemory(char *base, HnswElement element)
 {
 	HnswNeighborArray *neighbors = HnswGetNeighbors(base, element, 0);
-	IndexTuple	itup = HnswPtrAccess(base, element->itup);
+	Datum		value = HnswGetValue(base, element);

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

 		/* Exit early since ordered by distance */
-		if (!HnswIndexTupleIsEqual(itup, HnswPtrAccess(base, neighborElement->itup), tupdesc))
+		if (!datumIsEqual(value, neighborValue, false, -1))
 			return false;

 		/* Check for space */
@@ -365,7 +370,7 @@ AddElementInMemory(char *base, HnswGraph * graph, HnswElement element)
 * Update neighbors
 */
 static void
-UpdateNeighborsInMemory(char *base, Relation index, HnswSupport * support, HnswElement e, int m)
+UpdateNeighborsInMemory(char *base, HnswSupport * support, HnswElement e, int m)
 {
 	for (int lc = e->level; lc >= 0; lc--)
 	{
@@ -387,7 +392,7 @@ UpdateNeighborsInMemory(char *base, Relation index, HnswSupport * support, HnswE
 			Assert(neighborElement);

 			LWLockAcquire(&neighborElement->lock, LW_EXCLUSIVE);
-			HnswUpdateConnection(base, HnswGetNeighbors(base, neighborElement, lc), e, hc->distance, lm, NULL, index, support);
+			HnswUpdateConnection(base, HnswGetNeighbors(base, neighborElement, lc), e, hc->distance, lm, NULL, NULL, support);
 			LWLockRelease(&neighborElement->lock);
 		}
 	}
@@ -397,20 +402,20 @@ UpdateNeighborsInMemory(char *base, Relation index, HnswSupport * support, HnswE
 * Update graph in memory
 */
 static void
-UpdateGraphInMemory(HnswSupport * support, HnswElement element, int m, int efConstruction, HnswElement entryPoint, HnswBuildState * buildstate)
+UpdateGraphInMemory(HnswSupport * support, HnswElement element, int m, HnswElement entryPoint, HnswBuildState * buildstate)
 {
 	HnswGraph  *graph = buildstate->graph;
 	char	   *base = buildstate->hnswarea;

 	/* Look for duplicate */
-	if (FindDuplicateInMemory(base, element, buildstate->useIndexTuple, buildstate->tupdesc))
+	if (FindDuplicateInMemory(base, element))
 		return;

 	/* Add element */
 	AddElementInMemory(base, graph, element);

 	/* Update neighbors */
-	UpdateNeighborsInMemory(base, buildstate->index, support, element, m);
+	UpdateNeighborsInMemory(base, support, element, m);

 	/* Update entry point if needed (already have lock) */
 	if (entryPoint == NULL || element->level > entryPoint->level)
@@ -423,7 +428,6 @@ UpdateGraphInMemory(HnswSupport * support, HnswElement element, int m, int efCon
 static void
 InsertTupleInMemory(HnswBuildState * buildstate, HnswElement element)
 {
-	Relation	index = buildstate->index;
 	HnswGraph  *graph = buildstate->graph;
 	HnswSupport *support = &buildstate->support;
 	HnswElement entryPoint;
@@ -457,10 +461,10 @@ InsertTupleInMemory(HnswBuildState * buildstate, HnswElement element)
 	}

 	/* Find neighbors for element */
-	HnswFindElementNeighbors(base, element, entryPoint, index, support, m, efConstruction, false, true);
+	HnswFindElementNeighbors(base, element, entryPoint, NULL, support, m, efConstruction, false, true);

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

 	/* Release entry lock */
 	LWLockRelease(entryLock);
@@ -476,20 +480,18 @@ InsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heaptid, Hn
 	HnswElement element;
 	HnswAllocator *allocator = &buildstate->allocator;
 	HnswSupport *support = &buildstate->support;
+	Size		valueSize;
+	Pointer		valuePtr;
 	LWLock	   *flushLock = &graph->flushLock;
 	char	   *base = buildstate->hnswarea;
-	TupleDesc	tupdesc = buildstate->tupdesc;
-	IndexTuple	itup;
-	Size		itupSize;
-	IndexTuple	itupShared;
-	bool		unused;
+	Datum		value;

-	/* Form index tuple */
-	if (!HnswFormIndexTuple(&itup, values, isnull, buildstate->typeInfo, support, tupdesc))
+	/* Form index value */
+	if (!HnswFormIndexValue(&value, values, isnull, buildstate->typeInfo, support))
 		return false;

-	/* Get tuple size */
-	itupSize = IndexTupleSize(itup);
+	/* Get datum size */
+	valueSize = VARSIZE_ANY(DatumGetPointer(value));

 	/* Ensure graph not flushed when inserting */
 	LWLockAcquire(flushLock, LW_SHARED);
@@ -499,7 +501,7 @@ InsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heaptid, Hn
 	{
 		LWLockRelease(flushLock);

-		return HnswInsertTupleOnDisk(index, support, itup, heaptid, true, tupdesc);
+		return HnswInsertTupleOnDisk(index, support, value, heaptid, true);
 	}

 	/*
@@ -531,12 +533,12 @@ InsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heaptid, Hn

 		LWLockRelease(flushLock);

-		return HnswInsertTupleOnDisk(index, support, itup, heaptid, true, tupdesc);
+		return HnswInsertTupleOnDisk(index, support, value, heaptid, true);
 	}

 	/* Ok, we can proceed to allocate the element */
 	element = HnswInitElement(base, heaptid, buildstate->m, buildstate->ml, buildstate->maxLevel, allocator);
-	itupShared = HnswAlloc(allocator, itupSize);
+	valuePtr = HnswAlloc(allocator, valueSize);

 	/*
 	 * We have now allocated the space needed for the element, so we don't
@@ -545,10 +547,9 @@ InsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heaptid, Hn
 	 */
 	LWLockRelease(&graph->allocatorLock);

-	/* Copy the tuple */
-	memcpy(itupShared, itup, itupSize);
-	HnswPtrStore(base, element->itup, itupShared);
-	HnswPtrStore(base, element->value, DatumGetPointer(index_getattr(itupShared, 1, tupdesc, &unused)));
+	/* Copy the datum */
+	memcpy(valuePtr, DatumGetPointer(value), valueSize);
+	HnswPtrStore(base, element->value, valuePtr);

 	/* Create a lock for the element */
 	LWLockInitialize(&element->lock, hnsw_lock_tranche_id);
@@ -675,19 +676,6 @@ InitBuildState(HnswBuildState * buildstate, Relation heap, Relation index, Index
 				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 				 errmsg("type not supported for hnsw index")));

-	/* TODO See if needed */
-	if (IndexRelationGetNumberOfKeyAttributes(index) > 2)
-		elog(ERROR, "index cannot have more than two columns");
-
-	if (!OidIsValid(index_getprocid(index, 1, HNSW_DISTANCE_PROC)))
-		elog(ERROR, "first column must be a vector");
-
-	for (int i = 1; i < IndexRelationGetNumberOfKeyAttributes(index); i++)
-	{
-		if (!OidIsValid(index_getprocid(index, i + 1, HNSW_ATTRIBUTE_DISTANCE_PROC)))
-			elog(ERROR, "column %d cannot be a vector", i + 1);
-	}
-
 	/* Require column to have dimensions to be indexed */
 	if (buildstate->dimensions < 0)
 		ereport(ERROR,
@@ -714,8 +702,6 @@ InitBuildState(HnswBuildState * buildstate, Relation heap, Relation index, Index
 	buildstate->graph = &buildstate->graphData;
 	buildstate->ml = HnswGetMl(buildstate->m);
 	buildstate->maxLevel = HnswGetMaxLevel(buildstate->m);
-	buildstate->useIndexTuple = HnswUseIndexTuple(index);
-	buildstate->tupdesc = RelationGetDescr(index);

 	buildstate->graphCtx = GenerationContextCreate(CurrentMemoryContext,
 												   "Hnsw build graph context",
@@ -1072,7 +1058,7 @@ ComputeParallelWorkers(Relation heap, Relation index)
 * Build graph
 */
 static void
-BuildGraph(HnswBuildState * buildstate, ForkNumber forkNum)
+BuildGraph(HnswBuildState * buildstate)
 {
 	int			parallel_workers = 0;

@@ -1120,7 +1106,7 @@ BuildIndex(Relation heap, Relation index, IndexInfo *indexInfo,

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

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

 	if (RelationNeedsWAL(index) || forkNum == INIT_FORKNUM)
 		log_newpage_range(index, forkNum, 0, RelationGetNumberOfBlocksInFork(index, forkNum), true);
--- a/src/hnswinsert.c
+++ b/src/hnswinsert.c
@@ -9,6 +9,10 @@
 #include "utils/datum.h"
 #include "utils/memutils.h"

+#if PG_VERSION_NUM >= 160000
+#include "varatt.h"
+#endif
+
 /*
 * Get the insert page
 */
@@ -156,10 +160,9 @@ AddElementOnDisk(Relation index, HnswElement e, int m, BlockNumber insertPage, B
 	BlockNumber newInsertPage = InvalidBlockNumber;
 	uint8		tupleVersion;
 	char	   *base = NULL;
-	bool		useIndexTuple = HnswUseIndexTuple(index);

 	/* Calculate sizes */
-	etupSize = HnswGetElementTupleSize(base, e, useIndexTuple);
+	etupSize = HNSW_ELEMENT_TUPLE_SIZE(VARSIZE_ANY(HnswPtrAccess(base, e->value)));
 	ntupSize = HNSW_NEIGHBOR_TUPLE_SIZE(e->level, m);
 	combinedSize = etupSize + ntupSize + sizeof(ItemIdData);
 	maxSize = HNSW_MAX_SIZE;
@@ -167,7 +170,7 @@ AddElementOnDisk(Relation index, HnswElement e, int m, BlockNumber insertPage, B

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

 	/* Prepare neighbor tuple */
 	ntup = palloc0(ntupSize);
@@ -384,9 +387,8 @@ LoadElementsForInsert(HnswNeighborArray * neighbors, HnswQuery * q, int *idx, Re
 		HnswCandidate *hc = &neighbors->items[i];
 		HnswElement element = HnswPtrAccess(base, hc->element);
 		double		distance;
-		bool		matches;

-		HnswLoadElement(element, &distance, &matches, q, index, support, true, NULL);
+		HnswLoadElement(element, &distance, q, index, support, true, NULL);
 		hc->distance = distance;

 		/* Prune element if being deleted */
@@ -430,8 +432,6 @@ GetUpdateIndex(HnswElement element, HnswElement newElement, float distance, int
 		HnswQuery	q;

 		q.value = HnswGetValue(base, element);
-		q.itup = HnswPtrAccess(base, element->itup);
-		q.keyData = NULL;

 		LoadElementsForInsert(neighbors, &q, &idx, index, support);

@@ -637,30 +637,21 @@ AddDuplicateOnDisk(Relation index, HnswElement element, HnswElement dup, bool bu
 * Find duplicate element
 */
 static bool
-FindDuplicateOnDisk(Relation index, HnswElement element, bool building, TupleDesc tupdesc)
+FindDuplicateOnDisk(Relation index, HnswElement element, bool building)
 {
 	char	   *base = NULL;
 	HnswNeighborArray *neighbors = HnswGetNeighbors(base, element, 0);
 	Datum		value = HnswGetValue(base, element);
-	IndexTuple	itup = HnswPtrAccess(base, element->itup);

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

-		if (HnswUseIndexTuple(index))
-		{
-			/* Exit early since ordered by distance */
-			if (!HnswIndexTupleIsEqual(itup, HnswPtrAccess(base, neighborElement->itup), tupdesc))
-				return false;
-		}
-		else
-		{
-			/* Exit early since ordered by distance */
-			if (!datumIsEqual(value, HnswGetValue(base, neighborElement), false, -1))
-				return false;
-		}
+		/* Exit early since ordered by distance */
+		if (!datumIsEqual(value, neighborValue, false, -1))
+			return false;

 		if (AddDuplicateOnDisk(index, element, neighborElement, building))
 			return true;
@@ -673,12 +664,12 @@ FindDuplicateOnDisk(Relation index, HnswElement element, bool building, TupleDes
 * Update graph on disk
 */
 static void
-UpdateGraphOnDisk(Relation index, HnswSupport * support, HnswElement element, int m, int efConstruction, HnswElement entryPoint, bool building, TupleDesc tupdesc)
+UpdateGraphOnDisk(Relation index, HnswSupport * support, HnswElement element, int m, HnswElement entryPoint, bool building)
 {
 	BlockNumber newInsertPage = InvalidBlockNumber;

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

 	/* Add element */
@@ -700,7 +691,7 @@ UpdateGraphOnDisk(Relation index, HnswSupport * support, HnswElement element, in
 * Insert a tuple into the index
 */
 bool
-HnswInsertTupleOnDisk(Relation index, HnswSupport * support, IndexTuple itup, ItemPointer heaptid, bool building, TupleDesc tupdesc)
+HnswInsertTupleOnDisk(Relation index, HnswSupport * support, Datum value, ItemPointer heaptid, bool building)
 {
 	HnswElement entryPoint;
 	HnswElement element;
@@ -708,7 +699,6 @@ HnswInsertTupleOnDisk(Relation index, HnswSupport * support, IndexTuple itup, It
 	int			efConstruction = HnswGetEfConstruction(index);
 	LOCKMODE	lockmode = ShareLock;
 	char	   *base = NULL;
-	bool		unused;

 	/*
 	 * Get a shared lock. This allows vacuum to ensure no in-flight inserts
@@ -722,8 +712,7 @@ HnswInsertTupleOnDisk(Relation index, HnswSupport * support, IndexTuple itup, It

 	/* Create an element */
 	element = HnswInitElement(base, heaptid, m, HnswGetMl(m), HnswGetMaxLevel(m), NULL);
-	HnswPtrStore(base, element->itup, itup);
-	HnswPtrStore(base, element->value, DatumGetPointer(index_getattr(itup, 1, tupdesc, &unused)));
+	HnswPtrStore(base, element->value, DatumGetPointer(value));

 	/* Prevent concurrent inserts when likely updating entry point */
 	if (entryPoint == NULL || element->level > entryPoint->level)
@@ -740,10 +729,10 @@ HnswInsertTupleOnDisk(Relation index, HnswSupport * support, IndexTuple itup, It
 	}

 	/* Find neighbors for element */
-	HnswFindElementNeighbors(base, element, entryPoint, index, support, m, efConstruction, false, false);
+	HnswFindElementNeighbors(base, element, entryPoint, index, support, m, efConstruction, false, building);

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

 	/* Release lock */
 	UnlockPage(index, HNSW_UPDATE_LOCK, lockmode);
@@ -757,18 +746,17 @@ HnswInsertTupleOnDisk(Relation index, HnswSupport * support, IndexTuple itup, It
 static void
 HnswInsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heaptid)
 {
-	IndexTuple	itup;
+	Datum		value;
 	const		HnswTypeInfo *typeInfo = HnswGetTypeInfo(index);
-	TupleDesc	tupdesc = RelationGetDescr(index);
 	HnswSupport support;

 	HnswInitSupport(&support, index);

-	/* Form index tuple */
-	if (!HnswFormIndexTuple(&itup, values, isnull, typeInfo, &support, tupdesc))
+	/* Form index value */
+	if (!HnswFormIndexValue(&value, values, isnull, typeInfo, &support))
 		return;

-	HnswInsertTupleOnDisk(index, &support, itup, heaptid, false, tupdesc);
+	HnswInsertTupleOnDisk(index, &support, value, heaptid, false);
 }

 /*
--- a/src/hnswscan.c
+++ b/src/hnswscan.c
@@ -22,30 +22,26 @@ GetScanItems(IndexScanDesc scan, Datum value)
 	int			m;
 	HnswElement entryPoint;
 	char	   *base = NULL;
-	bool		inMemory = false;
 	HnswQuery  *q = &so->q;

-	q->value = value;
-	q->itup = NULL;
-	q->keyData = scan->keyData;
-
 	/* Get m and entry point */
 	HnswGetMetaPageInfo(index, &m, &entryPoint);

+	q->value = value;
 	so->m = m;

 	if (entryPoint == NULL)
 		return NIL;

-	ep = list_make1(HnswEntryCandidate(base, entryPoint, q, index, support, false, inMemory));
+	ep = list_make1(HnswEntryCandidate(base, entryPoint, q, index, support, false));

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

-	return HnswSearchLayer(base, q, ep, hnsw_ef_search, 0, index, support, m, false, NULL, inMemory, &so->v, hnsw_iterative_search != HNSW_ITERATIVE_SEARCH_OFF ? &so->discarded : NULL, true, &so->tuples);
+	return HnswSearchLayer(base, q, ep, hnsw_ef_search, 0, index, support, m, false, NULL, &so->v, hnsw_iterative_scan != HNSW_ITERATIVE_SCAN_OFF ? &so->discarded : NULL, true, &so->tuples, false);
 }

 /*
@@ -76,7 +72,7 @@ ResumeScanItems(IndexScanDesc scan)
 		ep = lappend(ep, sc);
 	}

-	return HnswSearchLayer(base, &so->q, ep, batch_size, 0, index, &so->support, so->m, false, NULL, false, &so->v, &so->discarded, false, &so->tuples);
+	return HnswSearchLayer(base, &so->q, ep, batch_size, 0, index, &so->support, so->m, false, NULL, &so->v, &so->discarded, false, &so->tuples, false);
 }

 /*
@@ -100,12 +96,23 @@ GetScanValue(IndexScanDesc scan)

 		/* Normalize if needed */
 		if (so->support.normprocinfo != NULL)
-			value = HnswNormValue(so->typeInfo, so->support.collation[0], value);
+			value = HnswNormValue(so->typeInfo, so->support.collation, value);
 	}

 	return value;
 }

+#if defined(HNSW_MEMORY)
+/*
+ * Show memory usage
+ */
+static void
+ShowMemoryUsage(HnswScanOpaque so)
+{
+	elog(INFO, "memory: %zu KB, tuples: " INT64_FORMAT, MemoryContextMemAllocated(so->tmpCtx, false) / 1024, so->tuples);
+}
+#endif
+
 /*
 * Prepare for an index scan
 */
@@ -114,21 +121,29 @@ hnswbeginscan(Relation index, int nkeys, int norderbys)
 {
 	IndexScanDesc scan;
 	HnswScanOpaque so;
+	double		maxMemory;

 	scan = RelationGetIndexScan(index, nkeys, norderbys);

 	so = (HnswScanOpaque) palloc(sizeof(HnswScanOpaqueData));
 	so->typeInfo = HnswGetTypeInfo(index);
-	so->first = true;
-	so->v.tids = NULL;
-	so->discarded = NULL;
-	so->tmpCtx = AllocSetContextCreate(CurrentMemoryContext,
-									   "Hnsw scan temporary context",
-									   ALLOCSET_DEFAULT_SIZES);

 	/* Set support functions */
 	HnswInitSupport(&so->support, index);

+	/*
+	 * Use a lower max allocation size than default to allow scanning more
+	 * tuples for iterative search before exceeding work_mem
+	 */
+	so->tmpCtx = AllocSetContextCreate(CurrentMemoryContext,
+									   "Hnsw scan temporary context",
+									   0, 8 * 1024, 256 * 1024);
+
+	/* 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);
+
 	scan->opaque = so;

 	return scan;
@@ -142,13 +157,10 @@ hnswrescan(IndexScanDesc scan, ScanKey keys, int nkeys, ScanKey orderbys, int no
 {
 	HnswScanOpaque so = (HnswScanOpaque) scan->opaque;

-	if (so->v.tids != NULL)
-		tidhash_reset(so->v.tids);
-
-	if (so->discarded != NULL)
-		pairingheap_reset(so->discarded);
-
 	so->first = true;
+	/* v and discarded are allocated in tmpCtx */
+	so->v.tids = NULL;
+	so->discarded = NULL;
 	so->tuples = 0;
 	so->previousDistance = -get_float8_infinity();
 	MemoryContextReset(so->tmpCtx);
@@ -181,6 +193,10 @@ 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)
@@ -208,7 +224,7 @@ hnswgettuple(IndexScanDesc scan, ScanDirection dir)
 		so->first = false;

 #if defined(HNSW_MEMORY)
-		elog(INFO, "memory: %zu KB", MemoryContextMemAllocated(so->tmpCtx, false) / 1024);
+		ShowMemoryUsage(so);
 #endif
 	}

@@ -221,15 +237,15 @@ hnswgettuple(IndexScanDesc scan, ScanDirection dir)

 		if (list_length(so->w) == 0)
 		{
-			if (hnsw_iterative_search == HNSW_ITERATIVE_SEARCH_OFF)
+			if (hnsw_iterative_scan == HNSW_ITERATIVE_SCAN_OFF)
 				break;

 			/* Empty index */
 			if (so->discarded == NULL)
 				break;

-			/* Reached max number of additional tuples */
-			if (hnsw_iterative_search_max_tuples != -1 && so->tuples >= hnsw_iterative_search_max_tuples)
+			/* Reached max number of tuples or memory limit */
+			if (so->tuples >= hnsw_max_scan_tuples || MemoryContextMemAllocated(so->tmpCtx, false) > so->maxMemory)
 			{
 				if (pairingheap_is_empty(so->discarded))
 					break;
@@ -237,21 +253,6 @@ 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) > (Size) work_mem * 1024L)
-			{
-				if (pairingheap_is_empty(so->discarded))
-				{
-					ereport(DEBUG1,
-							(errmsg("hnsw index scan exceeded work_mem after " INT64_FORMAT " tuples", so->tuples),
-							 errhint("Increase work_mem to scan more tuples.")));
-
-					break;
-				}
-
-				/* Return remaining tuples */
-				so->w = lappend(so->w, HnswGetSearchCandidate(w_node, pairingheap_remove_first(so->discarded)));
-			}
 			else
 			{
 				/*
@@ -270,7 +271,7 @@ hnswgettuple(IndexScanDesc scan, ScanDirection dir)
 				UnlockPage(scan->indexRelation, HNSW_SCAN_LOCK, ShareLock);

 #if defined(HNSW_MEMORY)
-				elog(INFO, "memory: %zu KB", MemoryContextMemAllocated(so->tmpCtx, false) / 1024);
+				ShowMemoryUsage(so);
 #endif
 			}

@@ -282,12 +283,12 @@ hnswgettuple(IndexScanDesc scan, ScanDirection dir)
 		element = HnswPtrAccess(base, sc->element);

 		/* Move to next element if no valid heap TIDs */
-		if (!sc->matches || element->heaptidsLength == 0)
+		if (element->heaptidsLength == 0)
 		{
 			so->w = list_delete_last(so->w);

 			/* Mark memory as free for next iteration */
-			if (hnsw_iterative_search != HNSW_ITERATIVE_SEARCH_OFF)
+			if (hnsw_iterative_scan != HNSW_ITERATIVE_SCAN_OFF)
 			{
 				pfree(element);
 				pfree(sc);
@@ -298,7 +299,7 @@ hnswgettuple(IndexScanDesc scan, ScanDirection dir)

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

-		if (hnsw_iterative_search == HNSW_ITERATIVE_SEARCH_STRICT)
+		if (hnsw_iterative_scan == HNSW_ITERATIVE_SCAN_STRICT)
 		{
 			if (sc->distance < so->previousDistance)
 				continue;
--- a/src/hnswutils.c
+++ b/src/hnswutils.c
@@ -15,6 +15,14 @@
 #include "utils/memdebug.h"
 #include "utils/rel.h"

+#if PG_VERSION_NUM >= 160000
+#include "varatt.h"
+#endif
+
+#if PG_VERSION_NUM >= 170000
+#include "storage/read_stream.h"
+#endif
+
 #if PG_VERSION_NUM < 170000
 static inline uint64
 murmurhash64(uint64 data)
@@ -146,39 +154,11 @@ HnswOptionalProcInfo(Relation index, uint16 procnum)
 void
 HnswInitSupport(HnswSupport * support, Relation index)
 {
-	support->procinfo[0] = index_getprocinfo(index, 1, HNSW_DISTANCE_PROC);
-
-	if (IndexRelationGetNumberOfKeyAttributes(index) > 1)
-		support->procinfo[1] = index_getprocinfo(index, 2, HNSW_ATTRIBUTE_DISTANCE_PROC);
-
-	support->collation = index->rd_indcollation;
+	support->procinfo = index_getprocinfo(index, 1, HNSW_DISTANCE_PROC);
+	support->collation = index->rd_indcollation[0];
 	support->normprocinfo = HnswOptionalProcInfo(index, HNSW_NORM_PROC);
 }

-/*
- * Get element tuple size
- */
-Size
-HnswGetElementTupleSize(char *base, HnswElement element, bool useIndexTuple)
-{
-	Size		size;
-
-	if (useIndexTuple)
-	{
-		IndexTuple	itup = HnswPtrAccess(base, element->itup);
-
-		size = IndexTupleSize(itup);
-	}
-	else
-	{
-		Pointer		valuePtr = HnswPtrAccess(base, element->value);
-
-		size = VARSIZE_ANY(valuePtr);
-	}
-
-	return HNSW_ELEMENT_TUPLE_SIZE(size);
-}
-
 /*
 * Normalize value
 */
@@ -194,38 +174,7 @@ HnswNormValue(const HnswTypeInfo * typeInfo, Oid collation, Datum value)
 bool
 HnswCheckNorm(HnswSupport * support, Datum value)
 {
-	return DatumGetFloat8(FunctionCall1Coll(support->normprocinfo, support->collation[0], value)) > 0;
-}
-
-/*
- * Check if index tuples are equal
- */
-bool
-HnswIndexTupleIsEqual(IndexTuple a, IndexTuple b, TupleDesc tupdesc)
-{
-	for (int i = 0; i < tupdesc->natts; i++)
-	{
-		bool		nullA;
-		bool		nullB;
-
-		Datum		datumA = index_getattr(a, i + 1, tupdesc, &nullA);
-		Datum		datumB = index_getattr(b, i + 1, tupdesc, &nullB);
-
-		if (nullA || nullB)
-		{
-			if (nullA != nullB)
-				return false;
-		}
-		else
-		{
-			Form_pg_attribute att = TupleDescAttr(tupdesc, i);
-
-			if (!datumIsEqual(datumA, datumB, att->attbyval, att->attlen))
-				return false;
-		}
-	}
-
-	return true;
+	return DatumGetFloat8(FunctionCall1Coll(support->normprocinfo, support->collation, value)) > 0;
 }

 /*
@@ -316,7 +265,6 @@ HnswInitElement(char *base, ItemPointer heaptid, int m, double ml, int maxLevel,
 	HnswInitNeighbors(base, element, m, allocator);

 	HnswPtrStore(base, element->value, (Pointer) NULL);
-	HnswPtrStore(base, element->itup, (IndexTuple) NULL);

 	return element;
 }
@@ -343,7 +291,6 @@ HnswInitElementFromBlock(BlockNumber blkno, OffsetNumber offno)
 	element->offno = offno;
 	HnswPtrStore(base, element->neighbors, (HnswNeighborArrayPtr *) NULL);
 	HnswPtrStore(base, element->value, (Pointer) NULL);
-	HnswPtrStore(base, element->itup, (IndexTuple) NULL);
 	return element;
 }

@@ -456,13 +403,11 @@ HnswUpdateMetaPage(Relation index, int updateEntry, HnswElement entryPoint, Bloc
 }

 /*
- * Form index tuple
+ * Form index value
 */
 bool
-HnswFormIndexTuple(IndexTuple *out, Datum *values, bool *isnull, const HnswTypeInfo * typeInfo, HnswSupport * support, TupleDesc tupdesc)
+HnswFormIndexValue(Datum *out, Datum *values, bool *isnull, const HnswTypeInfo * typeInfo, HnswSupport * support)
 {
-	Datum		newValues[2];
-
 	/* Detoast once for all calls */
 	Datum		value = PointerGetDatum(PG_DETOAST_DATUM(values[0]));

@@ -476,14 +421,10 @@ HnswFormIndexTuple(IndexTuple *out, Datum *values, bool *isnull, const HnswTypeI
 		if (!HnswCheckNorm(support, value))
 			return false;

-		value = HnswNormValue(typeInfo, support->collation[0], value);
+		value = HnswNormValue(typeInfo, support->collation, value);
 	}

-	newValues[0] = value;
-	for (int i = 1; i < tupdesc->natts; i++)
-		newValues[i] = values[i];
-
-	*out = index_form_tuple(tupdesc, newValues, isnull);
+	*out = value;

 	return true;
 }
@@ -492,8 +433,10 @@ HnswFormIndexTuple(IndexTuple *out, Datum *values, bool *isnull, const HnswTypeI
 * Set element tuple, except for neighbor info
 */
 void
-HnswSetElementTuple(char *base, HnswElementTuple etup, HnswElement element, bool useIndexTuple)
+HnswSetElementTuple(char *base, HnswElementTuple etup, HnswElement element)
 {
+	Pointer		valuePtr = HnswPtrAccess(base, element->value);
+
 	etup->type = HNSW_ELEMENT_TUPLE_TYPE;
 	etup->level = element->level;
 	etup->deleted = 0;
@@ -505,19 +448,7 @@ HnswSetElementTuple(char *base, HnswElementTuple etup, HnswElement element, bool
 		else
 			ItemPointerSetInvalid(&etup->heaptids[i]);
 	}
-
-	if (useIndexTuple)
-	{
-		IndexTuple	itup = HnswPtrAccess(base, element->itup);
-
-		memcpy(&etup->data, itup, IndexTupleSize(itup));
-	}
-	else
-	{
-		Pointer		valuePtr = HnswPtrAccess(base, element->value);
-
-		memcpy(&etup->data, valuePtr, VARSIZE_ANY(valuePtr));
-	}
+	memcpy(&etup->data, valuePtr, VARSIZE_ANY(valuePtr));
 }

 /*
@@ -559,7 +490,7 @@ HnswSetNeighborTuple(char *base, HnswNeighborTuple ntup, HnswElement e, int m)
 * Load an element from a tuple
 */
 void
-HnswLoadElementFromTuple(HnswElement element, HnswElementTuple etup, bool loadHeaptids, bool loadVec, Relation index)
+HnswLoadElementFromTuple(HnswElement element, HnswElementTuple etup, bool loadHeaptids, bool loadVec)
 {
 	element->level = etup->level;
 	element->deleted = etup->deleted;
@@ -583,135 +514,31 @@ HnswLoadElementFromTuple(HnswElement element, HnswElementTuple etup, bool loadHe
 	if (loadVec)
 	{
 		char	   *base = NULL;
+		Datum		value = datumCopy(PointerGetDatum(&etup->data), false, -1);

-		if (HnswUseIndexTuple(index))
-		{
-			IndexTuple	itup = CopyIndexTuple((IndexTuple) &etup->data);
-			TupleDesc	tupdesc = RelationGetDescr(index);
-			bool		unused;
-
-			HnswPtrStore(base, element->itup, itup);
-			HnswPtrStore(base, element->value, DatumGetPointer(index_getattr(itup, 1, tupdesc, &unused)));
-		}
-		else
-		{
-			Datum		value = datumCopy(PointerGetDatum(&etup->data), false, -1);
-
-			HnswPtrStore(base, element->value, DatumGetPointer(value));
-		}
+		HnswPtrStore(base, element->value, DatumGetPointer(value));
 	}
 }

-/*
- * Get the attribute distance
- */
-static inline double
-AttributeDistance(double e)
-{
-	/* TODO Better bias */
-	/* must be >> max(w * g) + 1 / log10(2) */
-	double		bias = 4.32;
-
-	return e > 0 ? bias - 1.0 / log10(e + 1) : 0;
-}
-
 /*
 * Calculate the distance between values
 */
-static double
-HnswGetDistance(IndexTuple itup, Datum vec, HnswQuery * q, Relation index, HnswSupport * support, bool *matches)
+static inline double
+HnswGetDistance(Datum a, Datum b, HnswSupport * support)
 {
-	double		g;
-
-	if (DatumGetPointer(q->value) == NULL)
-		g = 0;
-	else
-		g = DatumGetFloat8(FunctionCall2Coll(support->procinfo[0], support->collation[0], q->value, vec));
-
-	Assert(PointerIsValid(matches));
-	*matches = true;
-
-	if (IndexRelationGetNumberOfKeyAttributes(index) > 1)
-	{
-		double		w = 0.25;
-		double		e = 0.0;
-		TupleDesc	tupdesc = RelationGetDescr(index);
-
-		if (q->keyData)
-		{
-			/* TODO need to pass length of key data */
-			int			keyCount = 1;
-
-			for (int i = 0; i < keyCount; i++)
-			{
-				ScanKey		key = &q->keyData[i];
-				bool		isnull;
-				Datum		value = index_getattr(itup, key->sk_attno, tupdesc, &isnull);
-				bool		attnull = key->sk_flags & SK_ISNULL;
-
-				if (isnull || attnull)
-				{
-					if (isnull != attnull)
-					{
-						e += 1000;
-						*matches = false;
-					}
-				}
-				else if (!DatumGetBool(FunctionCall2Coll(&key->sk_func, key->sk_collation, value, key->sk_argument)))
-				{
-					double		ei = fabs(DatumGetFloat8(FunctionCall2Coll(support->procinfo[key->sk_attno - 1], support->collation[key->sk_attno - 1], value, key->sk_argument)));
-
-					if (ei > 0)
-						e += ei;
-					else
-						/* Distance is zero for inequality */
-						e += 1000;
-
-					*matches = false;
-				}
-			}
-
-			return w * g + AttributeDistance(e);
-		}
-		else if (q->itup)
-		{
-			int			keyCount = IndexRelationGetNumberOfKeyAttributes(index) - 1;
-
-			for (int i = 0; i < keyCount; i++)
-			{
-				bool		isnull;
-				bool		attnull;
-				Datum		value = index_getattr(itup, i + 2, tupdesc, &isnull);
-				Datum		value2 = index_getattr(q->itup, i + 2, tupdesc, &attnull);
-
-				if (isnull || attnull)
-				{
-					if (isnull != attnull)
-						e += 1000;
-				}
-				else
-					e += fabs(DatumGetFloat8(FunctionCall2Coll(support->procinfo[i + 1], support->collation[i + 1], value, value2)));
-			}
-
-			return w * g + AttributeDistance(e);
-		}
-	}
-
-	return g;
+	return DatumGetFloat8(FunctionCall2Coll(support->procinfo, support->collation, a, b));
 }

 /*
 * Load an element and optionally get its distance from q
 */
 static void
-HnswLoadElementImpl(BlockNumber blkno, OffsetNumber offno, double *distance, bool *matches, HnswQuery * q, Relation index, HnswSupport * support, bool loadVec, double *maxDistance, HnswElement * element)
+HnswLoadElementImpl(Buffer buf, OffsetNumber offno, double *distance, HnswQuery * q, Relation index, HnswSupport * support, bool loadVec, double *maxDistance, HnswElement * element)
 {
-	Buffer		buf;
 	Page		page;
 	HnswElementTuple etup;

 	/* Read vector */
-	buf = ReadBuffer(index, blkno);
 	LockBuffer(buf, BUFFER_LOCK_SHARE);
 	page = BufferGetPage(buf);

@@ -722,32 +549,19 @@ HnswLoadElementImpl(BlockNumber blkno, OffsetNumber offno, double *distance, boo
 	/* Calculate distance */
 	if (distance != NULL)
 	{
-		IndexTuple	itup = NULL;
-		Datum		value;
-
-		if (HnswUseIndexTuple(index))
-		{
-			TupleDesc	tupdesc = RelationGetDescr(index);
-			bool		unused;
-
-			itup = (IndexTuple) &etup->data;
-			value = index_getattr(itup, 1, tupdesc, &unused);
-		}
+		if (DatumGetPointer(q->value) == NULL)
+			*distance = 0;
 		else
-		{
-			value = PointerGetDatum(&etup->data);
-		}
-
-		*distance = HnswGetDistance(itup, value, q, index, support, matches);
+			*distance = HnswGetDistance(q->value, PointerGetDatum(&etup->data), support);
 	}

 	/* Load element */
 	if (distance == NULL || maxDistance == NULL || *distance < *maxDistance)
 	{
 		if (*element == NULL)
-			*element = HnswInitElementFromBlock(blkno, offno);
+			*element = HnswInitElementFromBlock(BufferGetBlockNumber(buf), offno);

-		HnswLoadElementFromTuple(*element, etup, true, loadVec, index);
+		HnswLoadElementFromTuple(*element, etup, true, loadVec);
 	}

 	UnlockReleaseBuffer(buf);
@@ -757,37 +571,52 @@ HnswLoadElementImpl(BlockNumber blkno, OffsetNumber offno, double *distance, boo
 * Load an element and optionally get its distance from q
 */
 void
-HnswLoadElement(HnswElement element, double *distance, bool *matches, HnswQuery * q, Relation index, HnswSupport * support, bool loadVec, double *maxDistance)
+HnswLoadElement(HnswElement element, double *distance, HnswQuery * q, Relation index, HnswSupport * support, bool loadVec, double *maxDistance)
 {
-	HnswLoadElementImpl(element->blkno, element->offno, distance, matches, q, index, support, loadVec, maxDistance, &element);
+	Buffer		buf = ReadBuffer(index, element->blkno);
+
+	HnswLoadElementImpl(buf, element->offno, distance, q, index, support, loadVec, maxDistance, &element);
 }

 /*
 * Get the distance for an element
 */
 static double
-GetElementDistance(char *base, HnswElement element, bool *matches, HnswQuery * q, Relation index, HnswSupport * support)
+GetElementDistance(char *base, HnswElement element, HnswQuery * q, HnswSupport * support)
 {
 	Datum		value = HnswGetValue(base, element);
-	IndexTuple	itup = HnswPtrAccess(base, element->itup);

-	return HnswGetDistance(itup, value, q, index, support, matches);
+	return HnswGetDistance(q->value, value, support);
+}
+
+/*
+ * Allocate a search candidate
+ */
+static HnswSearchCandidate *
+HnswInitSearchCandidate(char *base, HnswElement element, double distance)
+{
+	HnswSearchCandidate *sc = palloc(sizeof(HnswSearchCandidate));
+
+	HnswPtrStore(base, sc->element, element);
+	sc->distance = distance;
+	return sc;
 }

 /*
 * Create a candidate for the entry point
 */
 HnswSearchCandidate *
-HnswEntryCandidate(char *base, HnswElement entryPoint, HnswQuery * q, Relation index, HnswSupport * support, bool loadVec, bool inMemory)
+HnswEntryCandidate(char *base, HnswElement entryPoint, HnswQuery * q, Relation index, HnswSupport * support, bool loadVec)
 {
-	HnswSearchCandidate *sc = palloc(sizeof(HnswSearchCandidate));
+	bool		inMemory = index == NULL;
+	double		distance;

-	HnswPtrStore(base, sc->element, entryPoint);
 	if (inMemory)
-		sc->distance = GetElementDistance(base, entryPoint, &sc->matches, q, index, support);
+		distance = GetElementDistance(base, entryPoint, q, support);
 	else
-		HnswLoadElement(entryPoint, &sc->distance, &sc->matches, q, index, support, loadVec, NULL);
-	return sc;
+		HnswLoadElement(entryPoint, &distance, q, index, support, loadVec, NULL);
+
+	return HnswInitSearchCandidate(base, entryPoint, distance);
 }

 /*
@@ -986,11 +815,31 @@ HnswLoadUnvisitedFromDisk(HnswElement element, HnswUnvisited * unvisited, int *u
 	}
 }

+#if PG_VERSION_NUM >= 170000
+/*
+ * Get next block number for read stream
+ */
+static BlockNumber
+HnswReadStreamNextBlock(ReadStream *stream, void *callback_private_data, void *per_buffer_data)
+{
+	HnswReadStreamData *streamData = callback_private_data;
+	OffsetNumber *offno = per_buffer_data;
+	HnswUnvisited *uv;
+
+	if (streamData->visited == streamData->unvisitedLength)
+		return InvalidBlockNumber;
+
+	uv = &streamData->unvisited[streamData->visited++];
+	*offno = ItemPointerGetOffsetNumber(&uv->indextid);
+	return ItemPointerGetBlockNumber(&uv->indextid);
+}
+#endif
+
 /*
 * Algorithm 2 from paper
 */
 List *
-HnswSearchLayer(char *base, HnswQuery * q, List *ep, int ef, int lc, Relation index, HnswSupport * support, int m, bool inserting, HnswElement skipElement, bool inMemory, visited_hash * v, pairingheap **discarded, bool initVisited, int64 *tuples)
+HnswSearchLayer(char *base, HnswQuery * q, List *ep, int ef, int lc, Relation index, HnswSupport * support, int m, bool inserting, HnswElement skipElement, visited_hash * v, pairingheap **discarded, bool initVisited, int64 *tuples, bool maintenance)
 {
 	List	   *w = NIL;
 	pairingheap *C = pairingheap_allocate(CompareNearestCandidates, NULL);
@@ -1003,8 +852,28 @@ HnswSearchLayer(char *base, HnswQuery * q, List *ep, int ef, int lc, Relation in
 	int			lm = HnswGetLayerM(m, lc);
 	HnswUnvisited *unvisited = palloc(lm * sizeof(HnswUnvisited));
 	int			unvisitedLength;
-	uint64		additional = 0;
-	uint64		maxAdditional = q->keyData && lc == 0 ? 10000 : 0;
+	bool		inMemory = index == NULL;
+
+#if PG_VERSION_NUM >= 170000
+	HnswReadStreamData streamData;
+	ReadStream *stream = NULL;
+
+	if (!inMemory)
+	{
+		int			flags = READ_STREAM_DEFAULT;
+
+		if (maintenance)
+		{
+			flags |= READ_STREAM_MAINTENANCE;
+		}
+
+#if PG_VERSION_NUM >= 180000
+		flags |= READ_STREAM_USE_BATCHING;
+#endif
+
+		stream = read_stream_begin_relation(flags, NULL, index, MAIN_FORKNUM, HnswReadStreamNextBlock, &streamData, sizeof(OffsetNumber));
+	}
+#endif

 	if (v == NULL)
 	{
@@ -1037,6 +906,7 @@ HnswSearchLayer(char *base, HnswQuery * q, List *ep, int ef, int lc, Relation in
 		{
 			AddToVisited(base, v, sc->element, inMemory, &found);

+			/* OK to count elements instead of tuples */
 			if (tuples != NULL)
 				(*tuples)++;
 		}
@@ -1044,10 +914,6 @@ HnswSearchLayer(char *base, HnswQuery * q, List *ep, int ef, int lc, Relation in
 		pairingheap_add(C, &sc->c_node);
 		pairingheap_add(W, &sc->w_node);

-		/* Do not count elements that do not match filter towards ef */
-		if (!sc->matches && ++additional <= maxAdditional)
-			continue;
-
 		/*
 		 * Do not count elements being deleted towards ef when vacuuming. It
 		 * would be ideal to do this for inserts as well, but this could
@@ -1071,35 +937,67 @@ HnswSearchLayer(char *base, HnswQuery * q, List *ep, int ef, int lc, Relation in
 		if (inMemory)
 			HnswLoadUnvisitedFromMemory(base, cElement, unvisited, &unvisitedLength, v, lc, localNeighborhood, neighborhoodSize);
 		else
+		{
 			HnswLoadUnvisitedFromDisk(cElement, unvisited, &unvisitedLength, v, index, m, lm, lc);

+#if PG_VERSION_NUM >= 170000
+			read_stream_resume(stream);
+
+			streamData.unvisited = unvisited;
+			streamData.unvisitedLength = unvisitedLength;
+			streamData.visited = 0;
+#endif
+		}
+
+		/* OK to count elements instead of tuples */
 		if (tuples != NULL)
 			(*tuples) += unvisitedLength;

-		for (int i = 0; i < unvisitedLength; i++)
+		for (int i = 0;; i++)
 		{
 			HnswElement eElement;
 			HnswSearchCandidate *e;
 			double		eDistance;
-			bool		eMatches;
 			bool		alwaysAdd = wlen < ef;

 			f = HnswGetSearchCandidate(w_node, pairingheap_first(W));

 			if (inMemory)
 			{
+				if (i == unvisitedLength)
+					break;
+
 				eElement = unvisited[i].element;
-				eDistance = GetElementDistance(base, eElement, &eMatches, q, index, support);
+				eDistance = GetElementDistance(base, eElement, q, support);
 			}
 			else
 			{
-				ItemPointer indextid = &unvisited[i].indextid;
-				BlockNumber blkno = ItemPointerGetBlockNumber(indextid);
-				OffsetNumber offno = ItemPointerGetOffsetNumber(indextid);
+				Buffer		buf;
+				OffsetNumber offno;
+
+#if PG_VERSION_NUM >= 170000
+				void	   *offnoPtr;
+
+				buf = read_stream_next_buffer(stream, &offnoPtr);
+
+				if (!BufferIsValid(buf))
+					break;
+
+				offno = *((OffsetNumber *) offnoPtr);
+#else
+				ItemPointer indextid;
+
+				if (i == unvisitedLength)
+					break;
+
+				indextid = &unvisited[i].indextid;
+				buf = ReadBuffer(index, ItemPointerGetBlockNumber(indextid));
+				offno = ItemPointerGetOffsetNumber(indextid);
+#endif

 				/* Avoid any allocations if not adding */
 				eElement = NULL;
-				HnswLoadElementImpl(blkno, offno, &eDistance, &eMatches, q, index, support, inserting, alwaysAdd || discarded != NULL ? NULL : &f->distance, &eElement);
+				HnswLoadElementImpl(buf, offno, &eDistance, q, index, support, inserting, alwaysAdd || discarded != NULL ? NULL : &f->distance, &eElement);

 				if (eElement == NULL)
 					continue;
@@ -1110,9 +1008,7 @@ HnswSearchLayer(char *base, HnswQuery * q, List *ep, int ef, int lc, Relation in
 				if (discarded != NULL)
 				{
 					/* Create a new candidate */
-					e = palloc(sizeof(HnswSearchCandidate));
-					HnswPtrStore(base, e->element, eElement);
-					e->distance = eDistance;
+					e = HnswInitSearchCandidate(base, eElement, eDistance);
 					pairingheap_add(*discarded, &e->w_node);
 				}

@@ -1124,10 +1020,7 @@ HnswSearchLayer(char *base, HnswQuery * q, List *ep, int ef, int lc, Relation in
 				continue;

 			/* Create a new candidate */
-			e = palloc(sizeof(HnswSearchCandidate));
-			HnswPtrStore(base, e->element, eElement);
-			e->distance = eDistance;
-			e->matches = eMatches;
+			e = HnswInitSearchCandidate(base, eElement, eDistance);
 			pairingheap_add(C, &e->c_node);
 			pairingheap_add(W, &e->w_node);

@@ -1138,10 +1031,6 @@ HnswSearchLayer(char *base, HnswQuery * q, List *ep, int ef, int lc, Relation in
 			 */
 			if (CountElement(skipElement, eElement))
 			{
-				/* Do not count elements that do not match filter towards ef */
-				if (!e->matches && ++additional <= maxAdditional)
-					continue;
-
 				wlen++;

 				/* No need to decrement wlen */
@@ -1164,6 +1053,11 @@ HnswSearchLayer(char *base, HnswQuery * q, List *ep, int ef, int lc, Relation in
 		w = lappend(w, sc);
 	}

+#if PG_VERSION_NUM >= 170000
+	if (!inMemory)
+		read_stream_end(stream);
+#endif
+
 	return w;
 }

@@ -1219,24 +1113,18 @@ CompareCandidateDistancesOffset(const ListCell *a, const ListCell *b)
 * Check if an element is closer to q than any element from R
 */
 static bool
-CheckElementCloser(char *base, HnswCandidate * e, List *r, Relation index, HnswSupport * support)
+CheckElementCloser(char *base, HnswCandidate * e, List *r, HnswSupport * support)
 {
 	HnswElement eElement = HnswPtrAccess(base, e->element);
-	HnswQuery	q;
+	Datum		eValue = HnswGetValue(base, eElement);
 	ListCell   *lc2;

-	q.value = HnswGetValue(base, eElement);
-	q.itup = HnswPtrAccess(base, eElement->itup);
-	q.keyData = NULL;
-
 	foreach(lc2, r)
 	{
 		HnswCandidate *ri = lfirst(lc2);
 		HnswElement riElement = HnswPtrAccess(base, ri->element);
 		Datum		riValue = HnswGetValue(base, riElement);
-		IndexTuple	ritup = HnswPtrAccess(base, riElement->itup);
-		bool		matches;
-		float		distance = HnswGetDistance(ritup, riValue, &q, index, support, &matches);
+		float		distance = HnswGetDistance(eValue, riValue, support);

 		if (distance <= e->distance)
 			return false;
@@ -1249,7 +1137,7 @@ CheckElementCloser(char *base, HnswCandidate * e, List *r, Relation index, HnswS
 * Algorithm 4 from paper
 */
 static List *
-SelectNeighbors(char *base, List *c, int lm, Relation index, HnswSupport * support, bool *closerSet, HnswCandidate * newCandidate, HnswCandidate * *pruned, bool sortCandidates)
+SelectNeighbors(char *base, List *c, int lm, HnswSupport * support, bool *closerSet, HnswCandidate * newCandidate, HnswCandidate * *pruned, bool sortCandidates)
 {
 	List	   *r = NIL;
 	List	   *w = list_copy(c);
@@ -1283,7 +1171,7 @@ SelectNeighbors(char *base, List *c, int lm, Relation index, HnswSupport * suppo

 		/* Use previous state of r and wd to skip work when possible */
 		if (mustCalculate)
-			e->closer = CheckElementCloser(base, e, r, index, support);
+			e->closer = CheckElementCloser(base, e, r, support);
 		else if (list_length(added) > 0)
 		{
 			/* Keep Valgrind happy for in-memory, parallel builds */
@@ -1296,7 +1184,8 @@ SelectNeighbors(char *base, List *c, int lm, Relation index, HnswSupport * suppo
 			 */
 			if (e->closer)
 			{
-				e->closer = CheckElementCloser(base, e, added, index, support);
+				e->closer = CheckElementCloser(base, e, added, support);
+
 				if (!e->closer)
 					removedAny = true;
 			}
@@ -1308,7 +1197,7 @@ SelectNeighbors(char *base, List *c, int lm, Relation index, HnswSupport * suppo
 				 */
 				if (removedAny)
 				{
-					e->closer = CheckElementCloser(base, e, r, index, support);
+					e->closer = CheckElementCloser(base, e, r, support);
 					if (e->closer)
 						added = lappend(added, e);
 				}
@@ -1316,7 +1205,7 @@ SelectNeighbors(char *base, List *c, int lm, Relation index, HnswSupport * suppo
 		}
 		else if (e == newCandidate)
 		{
-			e->closer = CheckElementCloser(base, e, r, index, support);
+			e->closer = CheckElementCloser(base, e, r, support);
 			if (e->closer)
 				added = lappend(added, e);
 		}
@@ -1393,7 +1282,7 @@ HnswUpdateConnection(char *base, HnswNeighborArray * neighbors, HnswElement newE
 			c = lappend(c, &neighbors->items[i]);
 		c = lappend(c, &newHc);

-		SelectNeighbors(base, c, lm, index, support, &neighbors->closerSet, &newHc, &pruned, true);
+		SelectNeighbors(base, c, lm, support, &neighbors->closerSet, &newHc, &pruned, true);

 		/* Should not happen */
 		if (pruned == NULL)
@@ -1464,19 +1353,17 @@ PrecomputeHash(char *base, HnswElement element)
 * Algorithm 1 from paper
 */
 void
-HnswFindElementNeighbors(char *base, HnswElement element, HnswElement entryPoint, Relation index, HnswSupport * support, int m, int efConstruction, bool existing, bool inMemory)
+HnswFindElementNeighbors(char *base, HnswElement element, HnswElement entryPoint, Relation index, HnswSupport * support, int m, int efConstruction, bool existing, bool maintenance)
 {
 	List	   *ep;
 	List	   *w;
 	int			level = element->level;
 	int			entryLevel;
 	HnswQuery	q;
-
 	HnswElement skipElement = existing ? element : NULL;
+	bool		inMemory = index == NULL;

 	q.value = HnswGetValue(base, element);
-	q.itup = HnswPtrAccess(base, element->itup);
-	q.keyData = NULL;

 	/* Precompute hash */
 	if (inMemory)
@@ -1487,13 +1374,13 @@ HnswFindElementNeighbors(char *base, HnswElement element, HnswElement entryPoint
 		return;

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

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

@@ -1512,7 +1399,7 @@ HnswFindElementNeighbors(char *base, HnswElement element, HnswElement entryPoint
 		List	   *lw = NIL;
 		ListCell   *lc2;

-		w = HnswSearchLayer(base, &q, ep, efConstruction, lc, index, support, m, true, skipElement, inMemory, NULL, NULL, true, NULL);
+		w = HnswSearchLayer(base, &q, ep, efConstruction, lc, index, support, m, true, skipElement, NULL, NULL, true, NULL, maintenance);

 		/* Convert search candidates to candidates */
 		foreach(lc2, w)
@@ -1536,7 +1423,7 @@ HnswFindElementNeighbors(char *base, HnswElement element, HnswElement entryPoint
 		 * sortCandidates to true for in-memory builds to enable closer
 		 * caching, but there does not seem to be a difference in performance.
 		 */
-		neighbors = SelectNeighbors(base, lw, lm, index, support, &HnswGetNeighbors(base, element, lc)->closerSet, NULL, NULL, false);
+		neighbors = SelectNeighbors(base, lw, lm, support, &HnswGetNeighbors(base, element, lc)->closerSet, NULL, NULL, false);

 		AddConnections(base, element, neighbors, lc);

@@ -1592,7 +1479,7 @@ hnsw_halfvec_support(PG_FUNCTION_ARGS)
 	};

 	PG_RETURN_POINTER(&typeInfo);
-};
+}

 FUNCTION_PREFIX PG_FUNCTION_INFO_V1(hnsw_bit_support);
 Datum
@@ -1605,7 +1492,7 @@ hnsw_bit_support(PG_FUNCTION_ARGS)
 	};

 	PG_RETURN_POINTER(&typeInfo);
-};
+}

 FUNCTION_PREFIX PG_FUNCTION_INFO_V1(hnsw_sparsevec_support);
 Datum
@@ -1618,4 +1505,4 @@ hnsw_sparsevec_support(PG_FUNCTION_ARGS)
 	};

 	PG_RETURN_POINTER(&typeInfo);
-};
+}
--- a/src/hnswvacuum.c
+++ b/src/hnswvacuum.c
@@ -9,6 +9,14 @@
 #include "storage/lmgr.h"
 #include "utils/memutils.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
 */
@@ -204,7 +212,7 @@ RepairGraphElement(HnswVacuumState * vacuumstate, HnswElement element, HnswEleme
 	element->heaptidsLength = 0;

 	/* Find neighbors for element, skipping itself */
-	HnswFindElementNeighbors(base, element, entryPoint, index, support, m, efConstruction, true, false);
+	HnswFindElementNeighbors(base, element, entryPoint, index, support, m, efConstruction, true, true);

 	/* Zero memory for each element */
 	MemSet(ntup, 0, HNSW_TUPLE_ALLOC_SIZE);
@@ -256,7 +264,7 @@ RepairGraphEntryPoint(HnswVacuumState * vacuumstate)
 		LockPage(index, HNSW_UPDATE_LOCK, ShareLock);

 		/* Load element */
-		HnswLoadElement(highestPoint, NULL, NULL, NULL, index, support, true, NULL);
+		HnswLoadElement(highestPoint, NULL, NULL, index, support, true, NULL);

 		/* Repair if needed */
 		if (NeedsUpdated(vacuumstate, highestPoint))
@@ -294,7 +302,7 @@ RepairGraphEntryPoint(HnswVacuumState * vacuumstate)
 			 * is outdated, this can remove connections at higher levels in
 			 * the graph until they are repaired, but this should be fine.
 			 */
-			HnswLoadElement(entryPoint, NULL, NULL, NULL, index, support, true, NULL);
+			HnswLoadElement(entryPoint, NULL, NULL, index, support, true, NULL);

 			if (NeedsUpdated(vacuumstate, entryPoint))
 			{
@@ -370,7 +378,7 @@ RepairGraph(HnswVacuumState * vacuumstate)

 			/* Create an element */
 			element = HnswInitElementFromBlock(blkno, offno);
-			HnswLoadElementFromTuple(element, etup, false, true, index);
+			HnswLoadElementFromTuple(element, etup, false, true);

 			elements = lappend(elements, element);
 		}
@@ -440,7 +448,6 @@ MarkDeleted(HnswVacuumState * vacuumstate)
 	BlockNumber insertPage = InvalidBlockNumber;
 	Relation	index = vacuumstate->index;
 	BufferAccessStrategy bas = vacuumstate->bas;
-	bool		useIndexTuple = HnswUseIndexTuple(index);

 	/*
 	 * Wait for index scans to complete. Scans before this point may contain
@@ -522,14 +529,7 @@ MarkDeleted(HnswVacuumState * vacuumstate)

 			/* Overwrite element */
 			etup->deleted = 1;
-			if (useIndexTuple)
-			{
-				IndexTuple	itup = (IndexTuple) &etup->data;
-
-				MemSet(itup, 0, IndexTupleSize(itup));
-			}
-			else
-				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++)
--- a/src/ivfbuild.c
+++ b/src/ivfbuild.c
@@ -20,6 +20,10 @@
 #include "utils/memutils.h"
 #include "vector.h"

+#if PG_VERSION_NUM >= 160000
+#include "varatt.h"
+#endif
+
 #if PG_VERSION_NUM >= 140000
 #include "utils/backend_progress.h"
 #else
@@ -138,7 +142,7 @@ SampleRows(IvfflatBuildState * buildstate)
 * Add tuple to sort
 */
 static void
-AddTupleToSort(Relation index, ItemPointer tid, Datum *values, bool *isnull, IvfflatBuildState * buildstate)
+AddTupleToSort(ItemPointer tid, Datum *values, IvfflatBuildState * buildstate)
 {
 	double		distance;
 	double		minDistance = DBL_MAX;
@@ -184,11 +188,6 @@ AddTupleToSort(Relation index, ItemPointer tid, Datum *values, bool *isnull, Ivf
 	slot->tts_isnull[1] = false;
 	slot->tts_values[2] = value;
 	slot->tts_isnull[2] = false;
-	for (int i = 1; i < buildstate->tupdesc->natts; i++)
-	{
-		slot->tts_values[2 + i] = values[i];
-		slot->tts_isnull[2 + i] = isnull[i];
-	}
 	ExecStoreVirtualTuple(slot);

 	/*
@@ -220,7 +219,7 @@ BuildCallback(Relation index, ItemPointer tid, Datum *values,
 	oldCtx = MemoryContextSwitchTo(buildstate->tmpCtx);

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

 	/* Reset memory context */
 	MemoryContextSwitchTo(oldCtx);
@@ -231,20 +230,19 @@ BuildCallback(Relation index, ItemPointer tid, Datum *values,
 * Get index tuple from sort state
 */
 static inline void
-GetNextTuple(Tuplesortstate *sortstate, TupleDesc tupdesc, TupleTableSlot *slot, Datum *values, bool *isnull, IndexTuple *itup, int *list)
+GetNextTuple(Tuplesortstate *sortstate, TupleDesc tupdesc, TupleTableSlot *slot, IndexTuple *itup, int *list)
 {
 	if (tuplesort_gettupleslot(sortstate, true, false, slot, NULL))
 	{
-		bool		unused;
+		Datum		value;
+		bool		isnull;

-		*list = DatumGetInt32(slot_getattr(slot, 1, &unused));
-
-		for (int i = 0; i < tupdesc->natts; i++)
-			values[i] = slot_getattr(slot, 3 + i, &isnull[i]);
+		*list = DatumGetInt32(slot_getattr(slot, 1, &isnull));
+		value = slot_getattr(slot, 3, &isnull);

 		/* Form the index tuple */
-		*itup = index_form_tuple(tupdesc, values, isnull);
-		(*itup)->t_tid = *((ItemPointer) DatumGetPointer(slot_getattr(slot, 2, &unused)));
+		*itup = index_form_tuple(tupdesc, &value, &isnull);
+		(*itup)->t_tid = *((ItemPointer) DatumGetPointer(slot_getattr(slot, 2, &isnull)));
 	}
 	else
 		*list = -1;
@@ -262,14 +260,12 @@ InsertTuples(Relation index, IvfflatBuildState * buildstate, ForkNumber forkNum)

 	TupleTableSlot *slot = MakeSingleTupleTableSlot(buildstate->sortdesc, &TTSOpsMinimalTuple);
 	TupleDesc	tupdesc = buildstate->tupdesc;
-	Datum	   *values = palloc(tupdesc->natts * sizeof(Datum));
-	bool	   *isnull = palloc(tupdesc->natts * sizeof(bool));

 	pgstat_progress_update_param(PROGRESS_CREATEIDX_SUBPHASE, PROGRESS_IVFFLAT_PHASE_LOAD);

 	pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_TOTAL, buildstate->indtuples);

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

 	for (int i = 0; i < buildstate->centers->length; i++)
 	{
@@ -305,7 +301,7 @@ InsertTuples(Relation index, IvfflatBuildState * buildstate, ForkNumber forkNum)

 			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE, ++inserted);

-			GetNextTuple(buildstate->sortstate, tupdesc, slot, values, isnull, &itup, &list);
+			GetNextTuple(buildstate->sortstate, tupdesc, slot, &itup, &list);
 		}

 		insertPage = BufferGetBlockNumber(buf);
@@ -315,9 +311,6 @@ InsertTuples(Relation index, IvfflatBuildState * buildstate, ForkNumber forkNum)
 		/* Set the start and insert pages */
 		IvfflatUpdateList(index, buildstate->listInfo[i], insertPage, InvalidBlockNumber, startPage, forkNum);
 	}
-
-	pfree(values);
-	pfree(isnull);
 }

 /*
@@ -368,11 +361,10 @@ InitBuildState(IvfflatBuildState * buildstate, Relation heap, Relation index, In
 				 errmsg("dimensions must be greater than one for this opclass")));

 	/* Create tuple description for sorting */
-	buildstate->sortdesc = CreateTemplateTupleDesc(2 + buildstate->tupdesc->natts);
+	buildstate->sortdesc = CreateTemplateTupleDesc(3);
 	TupleDescInitEntry(buildstate->sortdesc, (AttrNumber) 1, "list", INT4OID, -1, 0);
 	TupleDescInitEntry(buildstate->sortdesc, (AttrNumber) 2, "tid", TIDOID, -1, 0);
-	for (int i = 0; i < buildstate->tupdesc->natts; i++)
-		TupleDescInitEntry(buildstate->sortdesc, (AttrNumber) (3 + i), NULL, buildstate->tupdesc->attrs[i].atttypid, -1, 0);
+	TupleDescInitEntry(buildstate->sortdesc, (AttrNumber) 3, "vector", TupleDescAttr(buildstate->tupdesc, 0)->atttypid, -1, 0);

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

@@ -482,8 +474,8 @@ CreateMetaPage(Relation index, int dimensions, int lists, ForkNumber forkNum)
 * Create list pages
 */
 static void
-CreateListPages(Relation index, VectorArray centers, int dimensions,
-				int lists, ForkNumber forkNum, ListInfo * *listInfo)
+CreateListPages(Relation index, VectorArray centers, int lists,
+				ForkNumber forkNum, ListInfo * *listInfo)
 {
 	Buffer		buf;
 	Page		page;
@@ -1016,7 +1008,7 @@ BuildIndex(Relation heap, Relation index, IndexInfo *indexInfo,

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

 	/* Write WAL for initialization fork since GenericXLog functions do not */
@@ -1035,6 +1027,10 @@ 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
@@ -17,13 +17,13 @@
 #endif

 int			ivfflat_probes;
-int			ivfflat_iterative_search;
-int			ivfflat_iterative_search_max_probes;
+int			ivfflat_iterative_scan;
+int			ivfflat_max_probes;
 static relopt_kind ivfflat_relopt_kind;

-static const struct config_enum_entry ivfflat_iterative_search_options[] = {
-	{"off", IVFFLAT_ITERATIVE_SEARCH_OFF, false},
-	{"on", IVFFLAT_ITERATIVE_SEARCH_RELAXED, false},
+static const struct config_enum_entry ivfflat_iterative_scan_options[] = {
+	{"off", IVFFLAT_ITERATIVE_SCAN_OFF, false},
+	{"relaxed_order", IVFFLAT_ITERATIVE_SCAN_RELAXED, false},
 	{NULL, 0, false}
 };

@@ -41,13 +41,14 @@ IvfflatInit(void)
 							"Valid range is 1..lists.", &ivfflat_probes,
 							IVFFLAT_DEFAULT_PROBES, IVFFLAT_MIN_LISTS, IVFFLAT_MAX_LISTS, PGC_USERSET, 0, NULL, NULL, NULL);

-	DefineCustomEnumVariable("ivfflat.iterative_search", "Sets whether to use iterative search",
-							 NULL, &ivfflat_iterative_search,
-							 IVFFLAT_ITERATIVE_SEARCH_OFF, ivfflat_iterative_search_options, PGC_USERSET, 0, 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);

-	DefineCustomIntVariable("ivfflat.iterative_search_max_probes", "Sets the max number of probes for iterative search",
-							"Zero sets to the number of lists", &ivfflat_iterative_search_max_probes,
-							0, 0, IVFFLAT_MAX_LISTS, PGC_USERSET, 0, 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);

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

 	/* Never use index without order */
-	if (path->indexorderbys == NULL)
+	if (path->indexorderbys == NIL)
 	{
 		*indexStartupCost = get_float8_infinity();
 		*indexTotalCost = get_float8_infinity();
 		*indexSelectivity = 0;
 		*indexCorrelation = 0;
 		*indexPages = 0;
+#if PG_VERSION_NUM >= 180000
+		/* See "On disable_cost" thread on pgsql-hackers */
+		path->path.disabled_nodes = 2;
+#endif
 		return;
 	}

@@ -181,6 +186,11 @@ 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;
@@ -213,6 +223,9 @@ 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;
@@ -233,5 +246,10 @@ 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);
 }
--- a/src/ivfflat.h
+++ b/src/ivfflat.h
@@ -13,6 +13,10 @@
 #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
@@ -73,21 +77,23 @@
 #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 */
 extern int	ivfflat_probes;
-extern int	ivfflat_iterative_search;
-extern int	ivfflat_iterative_search_max_probes;
+extern int	ivfflat_iterative_scan;
+extern int	ivfflat_max_probes;

-typedef enum IvfflatIterativeSearchType
+typedef enum IvfflatIterativeScanMode
 {
-	IVFFLAT_ITERATIVE_SEARCH_OFF,
-	IVFFLAT_ITERATIVE_SEARCH_RELAXED
-}			IvfflatIterativeSearchType;
+	IVFFLAT_ITERATIVE_SCAN_OFF,
+	IVFFLAT_ITERATIVE_SCAN_RELAXED
+}			IvfflatIterativeScanMode;

 typedef struct VectorArrayData
 {
@@ -260,6 +266,7 @@ typedef struct IvfflatScanOpaqueData
 	int			dimensions;
 	bool		first;
 	Datum		value;
+	MemoryContext tmpCtx;

 	/* Sorting */
 	Tuplesortstate *sortstate;
@@ -278,7 +285,7 @@ typedef struct IvfflatScanOpaqueData
 	pairingheap *listQueue;
 	BlockNumber *listPages;
 	int			listIndex;
-	IvfflatScanList lists[FLEXIBLE_ARRAY_MEMBER];	/* must come last */
+	IvfflatScanList *lists;
 }			IvfflatScanOpaqueData;

 typedef IvfflatScanOpaqueData * IvfflatScanOpaque;
--- a/src/ivfinsert.c
+++ b/src/ivfinsert.c
@@ -65,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, Relation heapRel)
+InsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heap_tid)
 {
 	const		IvfflatTypeInfo *typeInfo = IvfflatGetTypeInfo(index);
 	IndexTuple	itup;
@@ -78,8 +78,6 @@ InsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heap_tid, R
 	BlockNumber insertPage = InvalidBlockNumber;
 	ListInfo	listInfo;
 	BlockNumber originalInsertPage;
-	TupleDesc	tupdesc = RelationGetDescr(index);
-	Datum	   *newValues = palloc(tupdesc->natts * sizeof(Datum));

 	/* Detoast once for all calls */
 	value = PointerGetDatum(PG_DETOAST_DATUM(values[0]));
@@ -104,12 +102,8 @@ InsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heap_tid, R
 	Assert(BlockNumberIsValid(insertPage));
 	originalInsertPage = insertPage;

-	newValues[0] = value;
-	for (int i = 1; i < tupdesc->natts; i++)
-		newValues[i] = values[i];
-
 	/* Form tuple */
-	itup = index_form_tuple(tupdesc, newValues, isnull);
+	itup = index_form_tuple(RelationGetDescr(index), &value, isnull);
 	itup->t_tid = *heap_tid;

 	/* Get tuple size */
@@ -210,7 +204,7 @@ ivfflatinsert(Relation index, Datum *values, bool *isnull, ItemPointer heap_tid,
 	oldCtx = MemoryContextSwitchTo(insertCtx);

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

 	/* Delete memory context */
 	MemoryContextSwitchTo(oldCtx);
--- a/src/ivfkmeans.c
+++ b/src/ivfkmeans.c
@@ -13,6 +13,10 @@
 #include "utils/memutils.h"
 #include "vector.h"

+#if PG_VERSION_NUM >= 160000
+#include "varatt.h"
+#endif
+
 /*
 * Initialize with kmeans++
 *
--- a/src/ivfscan.c
+++ b/src/ivfscan.c
@@ -10,10 +10,7 @@
 #include "miscadmin.h"
 #include "pgstat.h"
 #include "storage/bufmgr.h"
-
-#ifdef IVFFLAT_MEMORY
 #include "utils/memutils.h"
-#endif

 #define GetScanList(ptr) pairingheap_container(IvfflatScanList, ph_node, ptr)
 #define GetScanListConst(ptr) pairingheap_const_container(IvfflatScanList, ph_node, ptr)
@@ -117,7 +114,6 @@ 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;

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

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

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

-	if (tuples < 100 && ivfflat_iterative_search == IVFFLAT_ITERATIVE_SEARCH_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)
@@ -221,7 +209,13 @@ GetScanValue(IndexScanDesc scan)

 		/* Normalize if needed */
 		if (so->normprocinfo != NULL)
+		{
+			MemoryContext oldCtx = MemoryContextSwitchTo(so->tmpCtx);
+
 			value = IvfflatNormValue(so->typeInfo, so->collation, value);
+
+			MemoryContextSwitchTo(oldCtx);
+		}
 	}

 	return value;
@@ -253,26 +247,25 @@ ivfflatbeginscan(Relation index, int nkeys, int norderbys)
 	int			dimensions;
 	int			probes = ivfflat_probes;
 	int			maxProbes;
+	MemoryContext oldCtx;

 	scan = RelationGetIndexScan(index, nkeys, norderbys);

 	/* Get lists and dimensions from metapage */
 	IvfflatGetMetaPageInfo(index, &lists, &dimensions);

-	if (probes > lists)
-		probes = lists;
-
-	if (ivfflat_iterative_search != IVFFLAT_ITERATIVE_SEARCH_OFF)
-	{
-		if (ivfflat_iterative_search_max_probes == 0)
-			maxProbes = lists;
-		else
-			maxProbes = Min(ivfflat_iterative_search_max_probes, lists);
-	}
+	if (ivfflat_iterative_scan != IVFFLAT_ITERATIVE_SCAN_OFF)
+		maxProbes = Max(ivfflat_max_probes, probes);
 	else
 		maxProbes = probes;

-	so = (IvfflatScanOpaque) palloc(offsetof(IvfflatScanOpaqueData, lists) + maxProbes * sizeof(IvfflatScanList));
+	if (probes > lists)
+		probes = lists;
+
+	if (maxProbes > lists)
+		maxProbes = lists;
+
+	so = (IvfflatScanOpaque) palloc(sizeof(IvfflatScanOpaqueData));
 	so->typeInfo = IvfflatGetTypeInfo(index);
 	so->first = true;
 	so->probes = probes;
@@ -284,6 +277,12 @@ ivfflatbeginscan(Relation index, int nkeys, int norderbys)
 	so->normprocinfo = IvfflatOptionalProcInfo(index, IVFFLAT_NORM_PROC);
 	so->collation = index->rd_indcollation[0];

+	so->tmpCtx = AllocSetContextCreate(CurrentMemoryContext,
+									   "Ivfflat scan temporary context",
+									   ALLOCSET_DEFAULT_SIZES);
+
+	oldCtx = MemoryContextSwitchTo(so->tmpCtx);
+
 	/* Create tuple description for sorting */
 	so->tupdesc = CreateTemplateTupleDesc(2);
 	TupleDescInitEntry(so->tupdesc, (AttrNumber) 1, "distance", FLOAT8OID, -1, 0);
@@ -306,6 +305,9 @@ ivfflatbeginscan(Relation index, int nkeys, int norderbys)
 	so->listQueue = pairingheap_allocate(CompareLists, scan);
 	so->listPages = palloc(maxProbes * sizeof(BlockNumber));
 	so->listIndex = 0;
+	so->lists = palloc(maxProbes * sizeof(IvfflatScanList));
+
+	MemoryContextSwitchTo(oldCtx);

 	scan->opaque = so;

@@ -353,6 +355,10 @@ 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)
@@ -368,8 +374,6 @@ ivfflatgettuple(IndexScanDesc scan, ScanDirection dir)
 		IvfflatBench("GetScanItems", GetScanItems(scan, value));
 		so->first = false;
 		so->value = value;
-
-		/* TODO clean up if we allocated a new value */
 	}

 	while (!tuplesort_gettupleslot(so->sortstate, true, false, so->mslot, NULL))
@@ -396,13 +400,10 @@ ivfflatendscan(IndexScanDesc scan)
 {
 	IvfflatScanOpaque so = (IvfflatScanOpaque) scan->opaque;

-	pairingheap_free(so->listQueue);
-	pfree(so->listPages);
+	/* Free any temporary files */
 	tuplesort_end(so->sortstate);
-	FreeAccessStrategy(so->bas);
-	FreeTupleDesc(so->tupdesc);

-	/* TODO Free vslot and mslot without freeing TupleDesc */
+	MemoryContextDelete(so->tmpCtx);

 	pfree(so);
 	scan->opaque = NULL;
--- a/src/ivfutils.c
+++ b/src/ivfutils.c
@@ -259,8 +259,8 @@ VectorUpdateCenter(Pointer v, int dimensions, float *x)
 	SET_VARSIZE(vec, VECTOR_SIZE(dimensions));
 	vec->dim = dimensions;

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

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

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

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

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

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

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

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

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

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

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

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

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

 	PG_RETURN_POINTER(&typeInfo);
-};
+}

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

 	PG_RETURN_POINTER(&typeInfo);
-};
+}
--- a/src/ivfvacuum.c
+++ b/src/ivfvacuum.c
@@ -5,6 +5,10 @@
 #include "ivfflat.h"
 #include "storage/bufmgr.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,6 +4,7 @@
 #include <math.h>

 #include "catalog/pg_type.h"
+#include "common/shortest_dec.h"
 #include "common/string.h"
 #include "fmgr.h"
 #include "halfutils.h"
@@ -12,17 +13,10 @@
 #include "sparsevec.h"
 #include "utils/array.h"
 #include "utils/builtins.h"
+#include "utils/float.h"
 #include "utils/lsyscache.h"
 #include "vector.h"

-#if PG_VERSION_NUM >= 120000
-#include "common/shortest_dec.h"
-#include "utils/float.h"
-#else
-#include <float.h>
-#include "utils/builtins.h"
-#endif
-
 typedef struct SparseInputElement
 {
 	int32		index;
--- a/src/vector.c
+++ b/src/vector.c
@@ -35,7 +35,11 @@
 #define VECTOR_TARGET_CLONES
 #endif

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

 /*
 * Initialize index options and variables
@@ -920,11 +924,13 @@ vector_concat(PG_FUNCTION_ARGS)
 	CheckDim(dim);
 	result = InitVector(dim);

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

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

 	PG_RETURN_POINTER(result);
 }
@@ -940,8 +946,21 @@ 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;

-	for (int i = 0; i < a->dim; i++)
+	/* 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++)
 		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,6 +540,12 @@ 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
@@ -99,6 +99,38 @@ SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <+> (SELECT NULL::vector)) t2
     4
 (1 row)

+DROP TABLE t;
+-- iterative
+CREATE TABLE t (val vector(3));
+INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
+CREATE INDEX ON t USING hnsw (val vector_l2_ops);
+SET hnsw.iterative_scan = strict_order;
+SET hnsw.ef_search = 1;
+SELECT * FROM t ORDER BY val <-> '[3,3,3]';
+   val   
+---------
+ [1,2,3]
+ [1,1,1]
+ [0,0,0]
+(3 rows)
+
+SET hnsw.iterative_scan = relaxed_order;
+SELECT * FROM t ORDER BY val <-> '[3,3,3]';
+   val   
+---------
+ [1,2,3]
+ [1,1,1]
+ [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;
 -- unlogged
 CREATE UNLOGGED TABLE t (val vector(3));
@@ -139,4 +171,31 @@ SET hnsw.ef_search = 0;
 ERROR:  0 is outside the valid range for parameter "hnsw.ef_search" (1 .. 1000)
 SET hnsw.ef_search = 1001;
 ERROR:  1001 is outside the valid range for parameter "hnsw.ef_search" (1 .. 1000)
+SHOW hnsw.iterative_scan;
+ hnsw.iterative_scan 
+---------------------
+ off
+(1 row)
+
+SET hnsw.iterative_scan = on;
+ERROR:  invalid value for parameter "hnsw.iterative_scan": "on"
+HINT:  Available values: off, relaxed_order, strict_order.
+SHOW hnsw.max_scan_tuples;
+ hnsw.max_scan_tuples 
+----------------------
+ 20000
+(1 row)
+
+SET hnsw.max_scan_tuples = 0;
+ERROR:  0 is outside the valid range for parameter "hnsw.max_scan_tuples" (1 .. 2147483647)
+SHOW hnsw.scan_mem_multiplier;
+ hnsw.scan_mem_multiplier 
+--------------------------
+ 1
+(1 row)
+
+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
@@ -81,6 +81,46 @@ SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <=> (SELECT NULL::vector)) t2
     3
 (1 row)

+DROP TABLE t;
+-- iterative
+CREATE TABLE t (val vector(3));
+INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
+CREATE INDEX ON t USING ivfflat (val vector_l2_ops) WITH (lists = 3);
+SET ivfflat.iterative_scan = relaxed_order;
+SELECT * FROM t ORDER BY val <-> '[3,3,3]';
+   val   
+---------
+ [1,2,3]
+ [1,1,1]
+ [0,0,0]
+(3 rows)
+
+SET ivfflat.max_probes = 1;
+SELECT * FROM t ORDER BY val <-> '[3,3,3]';
+   val   
+---------
+ [1,2,3]
+(1 row)
+
+SET ivfflat.max_probes = 2;
+SELECT * FROM t ORDER BY val <-> '[3,3,3]';
+   val   
+---------
+ [1,2,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;
 -- unlogged
 CREATE UNLOGGED TABLE t (val vector(3));
@@ -109,4 +149,27 @@ SHOW ivfflat.probes;
 1
 (1 row)

+SET ivfflat.probes = 0;
+ERROR:  0 is outside the valid range for parameter "ivfflat.probes" (1 .. 32768)
+SET ivfflat.probes = 32769;
+ERROR:  32769 is outside the valid range for parameter "ivfflat.probes" (1 .. 32768)
+SHOW ivfflat.iterative_scan;
+ ivfflat.iterative_scan 
+------------------------
+ off
+(1 row)
+
+SET ivfflat.iterative_scan = on;
+ERROR:  invalid value for parameter "ivfflat.iterative_scan": "on"
+HINT:  Available values: off, relaxed_order.
+SHOW ivfflat.max_probes;
+ ivfflat.max_probes 
+--------------------
+ 32768
+(1 row)
+
+SET ivfflat.max_probes = 0;
+ERROR:  0 is outside the valid range for parameter "ivfflat.max_probes" (1 .. 32768)
+SET ivfflat.max_probes = 32769;
+ERROR:  32769 is outside the valid range for parameter "ivfflat.max_probes" (1 .. 32768)
 DROP TABLE t;
--- a/test/expected/vector_type.out
+++ b/test/expected/vector_type.out
@@ -576,6 +576,12 @@ 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,6 +121,7 @@ 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
@@ -57,6 +57,26 @@ SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <+> (SELECT NULL::vector)) t2

 DROP TABLE t;

+-- iterative
+
+CREATE TABLE t (val vector(3));
+INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
+CREATE INDEX ON t USING hnsw (val vector_l2_ops);
+
+SET hnsw.iterative_scan = strict_order;
+SET hnsw.ef_search = 1;
+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;
+
 -- unlogged

 CREATE UNLOGGED TABLE t (val vector(3));
@@ -81,4 +101,17 @@ SHOW hnsw.ef_search;
 SET hnsw.ef_search = 0;
 SET hnsw.ef_search = 1001;

+SHOW hnsw.iterative_scan;
+
+SET hnsw.iterative_scan = on;
+
+SHOW hnsw.max_scan_tuples;
+
+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
@@ -44,6 +44,28 @@ SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <=> (SELECT NULL::vector)) t2

 DROP TABLE t;

+-- iterative
+
+CREATE TABLE t (val vector(3));
+INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
+CREATE INDEX ON t USING ivfflat (val vector_l2_ops) WITH (lists = 3);
+
+SET ivfflat.iterative_scan = relaxed_order;
+SELECT * FROM t ORDER BY val <-> '[3,3,3]';
+
+SET ivfflat.max_probes = 1;
+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;
+
 -- unlogged

 CREATE UNLOGGED TABLE t (val vector(3));
@@ -62,4 +84,16 @@ CREATE INDEX ON t USING ivfflat (val vector_l2_ops) WITH (lists = 32769);

 SHOW ivfflat.probes;

+SET ivfflat.probes = 0;
+SET ivfflat.probes = 32769;
+
+SHOW ivfflat.iterative_scan;
+
+SET ivfflat.iterative_scan = on;
+
+SHOW ivfflat.max_probes;
+
+SET ivfflat.max_probes = 0;
+SET ivfflat.max_probes = 32769;
+
 DROP TABLE t;
--- a/test/sql/vector_type.sql
+++ b/test/sql/vector_type.sql
@@ -128,6 +128,7 @@ 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/041_ivfflat_iterative_search.pl
+++ b/test/t/041_ivfflat_iterative_search.pl
@@ -23,7 +23,7 @@ $node->safe_psql("postgres", "CREATE INDEX ON tst USING ivfflat (v vector_l2_ops
 my $count = $node->safe_psql("postgres", qq(
 	SET enable_seqscan = off;
 	SET ivfflat.probes = 10;
-	SET ivfflat.iterative_search = on;
+	SET ivfflat.iterative_scan = relaxed_order;
 	SELECT COUNT(*) FROM (SELECT v FROM tst WHERE i % 10000 = 0 ORDER BY v <-> (SELECT v FROM tst LIMIT 1) LIMIT 11) t;
 ));
 is($count, 10);
@@ -39,8 +39,8 @@ foreach ((30, 50, 70))
 		$count = $node->safe_psql("postgres", qq(
 			SET enable_seqscan = off;
 			SET ivfflat.probes = 10;
-			SET ivfflat.iterative_search = on;
-			SET ivfflat.iterative_search_max_probes = $max_probes;
+			SET ivfflat.iterative_scan = relaxed_order;
+			SET ivfflat.max_probes = $max_probes;
 			SELECT COUNT(*) FROM (SELECT v FROM tst WHERE i % 10000 = 0 ORDER BY v <-> (SELECT v FROM tst WHERE i = $i) LIMIT 11) t;
 		));
 		$sum += $count;
--- a/test/t/042_ivfflat_iterative_search_recall.pl
+++ b/test/t/042_ivfflat_iterative_search_recall.pl
@@ -19,7 +19,7 @@ sub test_recall
 	my $explain = $node->safe_psql("postgres", qq(
 		SET enable_seqscan = off;
 		SET ivfflat.probes = $probes;
-		SET ivfflat.iterative_search = on;
+		SET ivfflat.iterative_scan = relaxed_order;
 		EXPLAIN ANALYZE SELECT i FROM tst WHERE i % $c = 0 ORDER BY v $operator '$queries[0]' LIMIT $limit;
 	));
 	like($explain, qr/Index Scan using idx on tst/);
@@ -29,7 +29,7 @@ sub test_recall
 		my $actual = $node->safe_psql("postgres", qq(
 			SET enable_seqscan = off;
 			SET ivfflat.probes = $probes;
-			SET ivfflat.iterative_search = on;
+			SET ivfflat.iterative_scan = relaxed_order;
 			SELECT i FROM tst WHERE i % $c = 0 ORDER BY v $operator '$queries[$i]' LIMIT $limit;
 		));
 		my @actual_ids = split("\n", $actual);
@@ -48,7 +48,7 @@ sub test_recall
 		$total += $limit;
 	}

-	cmp_ok($correct / $total, ">=", $min, $operator);
+	cmp_ok($correct / $total, ">=", $min, "$operator $c");
 }

 # Initialize node
@@ -103,7 +103,7 @@ for my $i (0 .. $#operators)

 		if ($c == 100)
 		{
-			test_recall($c, 1, 0.58, $operator);
+			test_recall($c, 1, 0.57, $operator);
 			test_recall($c, 10, 0.98, $operator);
 		}
 		else
--- a/test/t/043_hnsw_iterative_search.pl
+++ b/test/t/043_hnsw_iterative_search.pl
@@ -26,8 +26,9 @@ $node->safe_psql("postgres", qq(

 my $count = $node->safe_psql("postgres", qq(
 	SET enable_seqscan = off;
-	SET hnsw.iterative_search = on;
-	SET work_mem = '8MB';
+	SET hnsw.iterative_scan = relaxed_order;
+	SET hnsw.max_scan_tuples = 100000;
+	SET hnsw.scan_mem_multiplier = 2;
 	SELECT COUNT(*) FROM (SELECT v FROM tst WHERE i % 10000 = 0 ORDER BY v <-> (SELECT v FROM tst LIMIT 1) LIMIT 11) t;
 ));
 is($count, 10);
@@ -42,9 +43,9 @@ foreach ((30000, 50000, 70000))
 	{
 		$count = $node->safe_psql("postgres", qq(
 			SET enable_seqscan = off;
-			SET hnsw.iterative_search = on;
-			SET hnsw.iterative_search_max_tuples = $max_tuples;
-			SET work_mem = '8MB';
+			SET hnsw.iterative_scan = relaxed_order;
+			SET hnsw.max_scan_tuples = $max_tuples;
+			SET hnsw.scan_mem_multiplier = 2;
 			SELECT COUNT(*) FROM (SELECT v FROM tst WHERE i % 10000 = 0 ORDER BY v <-> (SELECT v FROM tst WHERE i = $i) LIMIT 11) t;
 		));
 		$sum += $count;
@@ -55,13 +56,4 @@ foreach ((30000, 50000, 70000))
 	cmp_ok($avg, '<', $expected + 2);
 }

-my ($ret, $stdout, $stderr) = $node->psql("postgres", qq(
-	SET enable_seqscan = off;
-	SET hnsw.iterative_search = on;
-	SET client_min_messages = debug1;
-	SET work_mem = '2MB';
-	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 exceeded work_mem after \d+ tuples/);
-
 done_testing();
--- a/test/t/044_hnsw_iterative_search_recall.pl
+++ b/test/t/044_hnsw_iterative_search_recall.pl
@@ -10,18 +10,18 @@ my @expected;
 my $limit = 20;
 my $dim = 3;
 my $array_sql = join(",", ('random()') x $dim);
-my @cs = (100, 1000);
+my @cs = (50, 500);

 sub test_recall
 {
-	my ($c, $ef_search, $min, $operator) = @_;
+	my ($c, $ef_search, $min, $operator, $mode) = @_;
 	my $correct = 0;
 	my $total = 0;

 	my $explain = $node->safe_psql("postgres", qq(
 		SET enable_seqscan = off;
 		SET hnsw.ef_search = $ef_search;
-		SET hnsw.iterative_search = on;
+		SET hnsw.iterative_scan = $mode;
 		EXPLAIN ANALYZE SELECT i FROM tst WHERE i % $c = 0 ORDER BY v $operator '$queries[0]' LIMIT $limit;
 	));
 	like($explain, qr/Index Scan using idx on tst/);
@@ -31,7 +31,7 @@ sub test_recall
 		my $actual = $node->safe_psql("postgres", qq(
 			SET enable_seqscan = off;
 			SET hnsw.ef_search = $ef_search;
-			SET hnsw.iterative_search = on;
+			SET hnsw.iterative_scan = $mode;
 			SELECT i FROM tst WHERE i % $c = 0 ORDER BY v $operator '$queries[$i]' LIMIT $limit;
 		));
 		my @actual_ids = split("\n", $actual);
@@ -50,7 +50,7 @@ sub test_recall
 		$total += $limit;
 	}

-	cmp_ok($correct / $total, ">=", $min, $operator);
+	cmp_ok($correct / $total, ">=", $min, "$operator $mode $c");
 }

 # Initialize node
@@ -62,7 +62,7 @@ $node->start;
 $node->safe_psql("postgres", "CREATE EXTENSION vector;");
 $node->safe_psql("postgres", "CREATE TABLE tst (i int4, v vector($dim));");
 $node->safe_psql("postgres",
-	"INSERT INTO tst SELECT i, ARRAY[$array_sql] FROM generate_series(1, 100000) i;"
+	"INSERT INTO tst SELECT i, ARRAY[$array_sql] FROM generate_series(1, 50000) i;"
 );

 # Generate queries
@@ -108,21 +108,8 @@ for my $i (0 .. $#operators)
 			push(@expected, $res);
 		}

-		if ($c == 100)
-		{
-			test_recall($c, 40, 0.99, $operator);
-		}
-		else
-		{
-			if ($operator eq "<->")
-			{
-				test_recall($c, 40, 0.99, $operator);
-			}
-			else
-			{
-				test_recall($c, 40, 0.99, $operator);
-			}
-		}
+		test_recall($c, 40, 0.99, $operator, "strict_order");
+		test_recall($c, 40, 0.99, $operator, "relaxed_order");
 	}

 	$node->safe_psql("postgres", "DROP INDEX idx;");
--- a/test/t/045_hnsw_hqann.pl
+++ b/test/t/045_hnsw_hqann.pl
@@ -1,113 +0,0 @@
-use strict;
-use warnings FATAL => 'all';
-use PostgreSQL::Test::Cluster;
-use PostgreSQL::Test::Utils;
-use Test::More;
-
-my $node;
-my @queries = ();
-my @cs = ();
-my @expected;
-my $limit = 20;
-my $dim = 3;
-my $array_sql = join(",", ('random()') x $dim);
-my $nc = 1000;
-
-sub test_recall
-{
-	my ($min, $operator) = @_;
-	my $correct = 0;
-	my $total = 0;
-
-	my $explain = $node->safe_psql("postgres", qq(
-		SET enable_seqscan = off;
-		EXPLAIN ANALYZE SELECT i FROM tst WHERE c = $cs[0] ORDER BY v $operator '$queries[0]' LIMIT $limit;
-	));
-	like($explain, qr/Index Cond/);
-
-	for my $i (0 .. $#queries)
-	{
-		my $actual = $node->safe_psql("postgres", qq(
-			SET enable_seqscan = off;
-			SELECT i FROM tst WHERE c = $cs[$i] ORDER BY v $operator '$queries[$i]' LIMIT $limit;
-		));
-		my @actual_ids = split("\n", $actual);
-		my %actual_set = map { $_ => 1 } @actual_ids;
-
-		is(scalar(@actual_ids), $limit);
-
-		my @expected_ids = split("\n", $expected[$i]);
-
-		foreach (@expected_ids)
-		{
-			if (exists($actual_set{$_}))
-			{
-				$correct++;
-			}
-			$total++;
-		}
-	}
-
-	cmp_ok($correct / $total, ">=", $min, $operator);
-}
-
-# Initialize node
-$node = PostgreSQL::Test::Cluster->new('node');
-$node->init;
-$node->start;
-
-# Create table
-$node->safe_psql("postgres", "CREATE EXTENSION vector;");
-$node->safe_psql("postgres", "CREATE TABLE tst (i int4, v vector($dim), c int4);");
-$node->safe_psql("postgres",
-	"INSERT INTO tst SELECT i, ARRAY[$array_sql], i % $nc FROM generate_series(1, 20000) i;"
-);
-
-# Generate queries
-for (1 .. 20)
-{
-	my @r = ();
-	for (1 .. $dim)
-	{
-		push(@r, rand());
-	}
-	push(@queries, "[" . join(",", @r) . "]");
-	push(@cs, int(rand() * $nc));
-}
-
-# Get exact results
-@expected = ();
-for my $i (0 .. $#queries)
-{
-	my $res = $node->safe_psql("postgres", "SELECT i FROM tst WHERE c = $cs[$i] ORDER BY v <=> '$queries[$i]' LIMIT $limit;");
-	push(@expected, $res);
-}
-
-# Add index
-$node->safe_psql("postgres", qq(
-	SET maintenance_work_mem = '256MB';
-	SET max_parallel_maintenance_workers = 2;
-	CREATE INDEX ON tst USING hnsw (v vector_cosine_ops, c);
-));
-
-# Test recall
-test_recall(0.99, '<=>');
-
-# Test vacuum
-$node->safe_psql("postgres", "DELETE FROM tst WHERE c > 5;");
-$node->safe_psql("postgres", "VACUUM tst;");
-
-# Test columns
-my ($ret, $stdout, $stderr) = $node->psql("postgres", "CREATE INDEX ON tst USING hnsw (c);");
-like($stderr, qr/first column must be a vector/);
-
-($ret, $stdout, $stderr) = $node->psql("postgres", "CREATE INDEX ON tst USING hnsw (c, v vector_cosine_ops);");
-like($stderr, qr/first column must be a vector/);
-
-($ret, $stdout, $stderr) = $node->psql("postgres", "CREATE INDEX ON tst USING hnsw (v vector_cosine_ops, c, c);");
-like($stderr, qr/index cannot have more than two columns/);
-
-($ret, $stdout, $stderr) = $node->psql("postgres", "CREATE INDEX ON tst USING hnsw (v vector_cosine_ops, v vector_cosine_ops);");
-like($stderr, qr/column 2 cannot be a vector/);
-
-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.7.4'
+default_version = '0.8.1'
 module_pathname = '$libdir/vector'
 relocatable = true
Author	SHA1	Message	Date
Andrew Kane	67c72ac8c3	Added support for async I/O [skip ci]	2025-11-18 22:44:20 -08:00
Andrew Kane	a126c02184	Added link to pgvector-ada [skip ci]	2025-10-30 22:29:36 -07:00
Andrew Kane	744362305b	Updated changelog [skip ci]	2025-10-30 11:48:44 -07:00
Andrew Kane	69e78e36a3	Added link to pgvetor-pascal [skip ci]	2025-10-30 11:40:29 -07:00
Andrew Kane	8dd37d4fb2	Improved install target for Windows - #917 [skip ci]	2025-10-30 11:03:59 -07:00
Andrew Kane	a24125839a	Updated readme [skip ci]	2025-10-28 10:25:34 -07:00
Andrew Kane	2ee3113417	Updated readme [skip ci]	2025-10-22 13:10:58 -07:00
Andrew Kane	3ebb9a506e	Added varatt headers for Postgres 16+	2025-10-22 11:56:05 -07:00
Andrew Kane	727d4836d2	Fixed Index Searches in EXPLAIN output for Postgres 18	2025-10-22 11:47:11 -07:00
Andrew Kane	d823c44591	Removed unused parameter [skip ci]	2025-09-27 15:58:18 -07:00
Andrew Kane	8f4aa0751c	Removed unused parameters [skip ci]	2025-09-27 15:51:32 -07:00
Andrew Kane	1ff30720c7	Updated readme [skip ci]	2025-09-26 13:02:37 -07:00
Andrew Kane	4cef9213ec	Added Docker images for Postgres 18 [skip ci]	2025-09-25 20:00:10 -07:00
Andrew Kane	90add68d6f	Updated style to be consistent with Mac [skip ci]	2025-09-25 15:55:30 -07:00
Andrew Kane	bc05dbf312	Updated CI for Postgres 18 [skip ci]	2025-09-25 15:54:37 -07:00
Andrew Kane	02fefc0e3f	Updated readme for Postgres 18 [skip ci]	2025-09-25 15:46:28 -07:00
Andrew Kane	e7899b1250	Updated checkout action [skip ci]	2025-09-22 11:55:01 -07:00
Andrew Kane	9e29dff78c	Updated CI [skip ci]	2025-09-19 19:16:08 -07:00
Andrew Kane	13c0dbf530	Test with macos-15-intel on CI [skip ci]	2025-09-19 18:34:51 -07:00
Andrew Kane	c205a12107	Updated CI [skip ci]	2025-09-05 17:03:37 -07:00
Andrew Kane	db3755a58f	Added windows-2025 to CI [skip ci]	2025-09-05 16:41:22 -07:00
Andrew Kane	778dacf20c	Version bump to 0.8.1 [skip ci]	2025-09-04 17:51:09 -07:00
Andrew Kane	3f687687ee	Fixed compilation error with Postgres 19	2025-09-04 15:58:23 -07:00
Andrew Kane	815f48e489	Updated changelog [skip ci]	2025-09-04 15:36:18 -07:00
Andrew Kane	67e648b13e	Added another test for binary_quantize function [skip ci]	2025-08-29 01:09:18 -07:00
Andrew Kane	c3ff955231	Reordered supported Docker tags [skip ci]	2025-08-23 19:57:14 -07:00
Andrew Kane	6f46a1035d	Added new Docker images to readme [skip ci]	2025-08-23 19:46:07 -07:00
Andrew Kane	bbe66e821b	Added Docker images for Debian 13 / Trixie [skip ci]	2025-08-23 19:34:11 -07:00
Julien Rouhaud	dd3a1e9137	Use NIL for empty lists (#890 ) Postgres standard way to check for list emptiness is to compare a pointer to NIL rather than NULL.	2025-08-23 03:31:22 -07:00
Andrew Kane	ea4746f6c0	Updated comment [skip ci]	2025-08-19 14:26:36 -07:00
Andrew Kane	6aec80ccdb	Improved performance of binary_quantize function for halfvec	2025-08-19 13:47:11 -07:00
Luca Giacchino	0c9070ba82	Add autovectorized implementation of binary quantize	2025-08-19 13:18:50 -07:00
Andrew Kane	30382418da	Ran pgindent [skip ci]	2025-08-19 12:44:54 -07:00
Andrew Kane	26b50e536f	Updated FreeBSD package name in readme [skip ci]	2025-08-09 12:09:29 -07:00
Andrew Kane	e29fc3aa1a	Switched to PG_MODULE_MAGIC_EXT for Postgres 18+ [skip ci]	2025-07-31 19:59:27 -07:00
Andrew Kane	6ef7fccb5c	Added Postgres 19 to CI [skip ci]	2025-07-27 19:50:46 -07:00
Andrew Kane	5b8b68ba1d	Use consistent style [skip ci]	2025-07-27 18:19:28 -07:00
Andrew Kane	3be8693c13	Added supported Docker tags to readme [skip ci]	2025-07-27 13:44:59 -07:00
Andrew Kane	247c8dc8a5	Updated changelog [skip ci]	2025-07-27 13:25:51 -07:00
Andrew Kane	3600ab93e5	Added Docker images with -bookworm suffix [skip ci]	2025-07-27 13:14:29 -07:00
Andrew Kane	665db75a3c	Updated Dockerfile to use release [skip ci]	2025-07-27 12:34:23 -07:00
Andrew Kane	44163d0a97	Revert "Added OS to Dockerfile [skip ci]" This reverts commit `33ca8a61e2`.	2025-07-09 22:01:34 -07:00
Andrew Kane	33ca8a61e2	Added OS to Dockerfile [skip ci]	2025-07-09 16:25:05 -07:00
Andrew Kane	742e2d1d28	Synced .dockerignore with .gitignore [skip ci]	2025-07-09 16:22:43 -07:00
Andrew Kane	a7c49d8283	Updated readme [skip ci]	2025-07-01 11:13:29 -07:00
Andrew Kane	ae9ee81e4d	Fixed relaxed results example for Postgres 17 - #862 [skip ci]	2025-07-01 10:11:50 -07:00
Andrew Kane	fa1dee4e3b	Updated link [skip ci]	2025-07-01 03:35:26 -07:00
Andrew Kane	e6bad96a03	Ran pgindent [skip ci]	2025-06-18 20:07:46 -07:00
Jon Daniel	3a49d141b3	Vectorizing vector_concat for improved performance (#861 ) * Vectorizing vector_concat for improved performance On an ARM chip this should generate SIMD instructions to copy the two incoming vectors to the new vector as opposed to doing it all in software. * Moving declarations to above CheckDim * Removing const from dims * Formatting	2025-06-18 20:06:32 -07:00
Andrew Kane	ce09c9a27a	Improved variable names [skip ci]	2025-06-18 17:32:37 -07:00
Andrew Kane	870ca6724d	Fixed CI [skip ci]	2025-06-18 16:26:30 -07:00
Andrew Kane	8ad680f009	Ran pgindent [skip ci]	2025-06-18 16:11:15 -07:00
Jon Daniel	fe697e8788	vectorize: optimize VectorSumCenter and HalfvecSumCenter (#860 ) * vectorize: optimize VectorSumCenter and HalfvecSumCenter The functions VectorSumCenter and HalfvecSumCenter were not being vectorized by the compiler. A few slight changes will allow these optimizations to take place and get a performance boost by utilizing SIMD instructions. This optimization helps improve performance of vector operations in IVF index building and updating. * Removing const, commenting that it is only vectoirzed on ARM	2025-06-18 16:09:43 -07:00
Andrew Kane	bf28ed8176	Set random seed for IVFFLAT_BENCH [skip ci]	2025-06-18 10:57:18 -07:00
Andrew Kane	799cfebf70	Updated readme [skip ci]	2025-06-04 14:29:53 -07:00
Andrew Kane	3cd1f09f66	Updated Windows installation instructions - #593 [skip ci]	2025-06-04 14:18:53 -07:00
Andrew Kane	e2efe62fe5	Updated readme [skip ci]	2025-05-12 13:11:43 -07:00
Andrew Kane	7b58352336	Updated readme [skip ci]	2025-05-06 21:39:51 -07:00
Andrew Kane	83d410eae9	Updated readme [skip ci]	2025-04-13 13:07:31 -07:00
Andrew Kane	ebbfe8dba0	Fixed CI for Postgres 18 [skip ci]	2025-04-05 13:05:27 -07:00
Andrew Kane	e575866297	Revert "Fixed warnings with Postgres 18 [skip ci]" This reverts commit `32e95a8598`.	2025-04-05 12:56:00 -07:00
Andrew Kane	35f4f7fc80	Improved warning check [skip ci]	2025-04-05 12:38:30 -07:00
Andrew Kane	32e95a8598	Fixed warnings with Postgres 18 [skip ci]	2025-04-05 12:13:38 -07:00
Andrew Kane	a03dc5b7d0	Added fields to IndexAmRoutine for Postgres 18 [skip ci]	2025-04-05 11:31:57 -07:00
Andrew Kane	d365aac370	Added note about index options to index build time docs - #807 [skip ci]	2025-03-26 11:56:38 -07:00
Andrew Kane	05182479a2	Added ARM to CI [skip ci]	2025-03-24 19:26:52 -07:00
Andrew Kane	cc0958dec5	Removed deprecated runner image [skip ci]	2025-03-24 19:18:01 -07:00
Andrew Kane	4af2b06dc5	Improved installation note [skip ci]	2025-03-23 14:59:28 -07:00
Andrew Kane	880dc4d6b9	Added Windows installation note about mismatched architecture - #593 #797 #804 [skip ci]	2025-03-23 11:51:10 -07:00
Andrew Kane	fef635c9e5	Updated readme [skip ci]	2025-02-20 00:05:35 -08:00
Andrew Kane	78ed8f1157	Fixed compilation error with Postgres 18 - fixes #779	2025-02-17 16:38:14 -08:00
Andrew Kane	f11e4d7b20	Updated readme [skip ci]	2025-02-17 13:22:50 -08:00
Andrew Kane	aafdf4167d	Improved missing SDK docs [skip ci]	2025-02-17 13:16:31 -08:00
Andrew Kane	656b059258	Added tests for iterative index scan with empty index - resolves #679 [skip ci]	2025-02-13 16:28:14 -08:00
Andrew Kane	7cf9980696	Updated Windows installation notes for Postgres 17.3 - closes #669 [skip ci]	2025-02-13 10:04:22 -08:00
Andrew Kane	2fe560dc58	Fixed extra-semi warnings [skip ci]	2025-01-18 13:08:11 -08:00
Andrew Kane	b46beada1a	Restored assertion checking on CI for Postgres 18 [skip ci]	2025-01-15 19:24:24 -08:00
Andrew Kane	0a42bc7aa5	Fixed undefined symbol: verify_compact_attribute error with Postgres 18 on CI	2025-01-10 13:54:18 -08:00
Andrew Kane	f5df32c41d	Updated license year [skip ci]	2025-01-10 08:51:07 -08:00
Andrew Kane	2c53c30415	Fixed compilation error with Postgres 18	2025-01-10 08:50:51 -08:00
Rui Chen	b4bc010459	chore(ci): update to use pg 17 (#755 ) * chore(ci): update to use pg 17 Signed-off-by: Rui Chen <rui@chenrui.dev> * chore(ci): update pg 14 to `REL_14_15` Signed-off-by: Rui Chen <rui@chenrui.dev> --------- Signed-off-by: Rui Chen <rui@chenrui.dev>	2025-01-10 08:39:32 -08:00
Andrew Kane	7b4ff9b59f	Updated CI to support macos-15 [skip ci]	2025-01-10 08:37:52 -08:00
Andrew Kane	cfdcbd75d1	Updated FreeBSD docs [skip ci]	2024-12-09 08:11:11 -08:00
Andrew Kane	5136983f35	Added link to pgvector-fortran [skip ci]	2024-12-06 09:39:02 -08:00
Andrew Kane	4ab4b89980	Added link to pgvector-erlang [skip ci]	2024-12-06 06:16:34 -08:00
Andrew Kane	85f0e3ccf6	Added link to pgvector-gleam [skip ci]	2024-12-05 19:29:57 -08:00
Andrew Kane	28e797cb5a	Added link to pgvector-d [skip ci]	2024-12-05 16:56:21 -08:00
Andrew Kane	1263d753be	Added link to pgvector-raku [skip ci]	2024-12-05 07:13:39 -08:00
Andrew Kane	5bc7937715	Added iterative index scans to troubleshooting docs [skip ci]	2024-11-22 15:22:06 -08:00
Andrew Kane	e7e899e9af	Updated readme [skip ci]	2024-11-22 11:55:46 -08:00
Andrew Kane	2627c5ff77	Version bump to 0.8.0 [skip ci]	2024-10-30 13:06:34 -07:00
Andrew Kane	34b3cfdc43	Updated min Postgres version in META.json [skip ci]	2024-10-30 13:06:12 -07:00
Andrew Kane	cd218aae5a	Removed unneeded code	2024-10-30 13:05:10 -07:00
Andrew Kane	ba9367f86c	Updated readme [skip ci]	2024-10-30 12:58:00 -07:00
Andrew Kane	9c20550a41	Updated readme	2024-10-30 12:54:42 -07:00
Andrew Kane	e3e74fe94e	Updated readme [skip ci]	2024-10-29 00:04:35 -07:00
Andrew Kane	96a5a44632	Updated readme [skip ci]	2024-10-28 23:52:16 -07:00
Andrew Kane	67e1392a83	Updated readme [skip ci]	2024-10-28 22:58:56 -07:00
Andrew Kane	e530a1a026	Updated readme [skip ci]	2024-10-28 22:49:41 -07:00
Andrew Kane	6170e2645b	Updated readme [skip ci]	2024-10-28 22:44:44 -07:00
Andrew Kane	e6bae175f1	Updated readme [skip ci]	2024-10-28 22:26:50 -07:00
Andrew Kane	52b777e04a	Updated readme [skip ci]	2024-10-28 22:01:27 -07:00
Andrew Kane	307271214f	Updated readme [skip ci]	2024-10-28 21:42:05 -07:00
Andrew Kane	6e9f74ddce	Updated readme [skip ci]	2024-10-28 20:04:09 -07:00
Andrew Kane	258215ad97	Improved test [skip ci]	2024-10-28 15:54:39 -07:00
Andrew Kane	fb87b6da91	Fixed test	2024-10-28 13:55:26 -07:00
Andrew Kane	a2a0b377f0	Removed memory limit debug message from HNSW index scans (EXPLAIN ANALYZE can be used instead)	2024-10-28 13:46:49 -07:00
Andrew Kane	2f770307b8	Removed unused variable [skip ci]	2024-10-28 13:38:42 -07:00
Andrew Kane	c04e16ff5b	Removed debug message from IVFFlat index scans [skip ci]	2024-10-28 13:36:57 -07:00
Andrew Kane	bd4d272f26	Updated changelog [skip ci]	2024-10-28 13:05:27 -07:00
Andrew Kane	8bb797cc2f	Updated changelog [skip ci]	2024-10-28 13:00:55 -07:00
Andrew Kane	fe6ec03dac	Improved filtering section [skip ci]	2024-10-28 12:08:27 -07:00
Andrew Kane	c1161f8889	Updated readme [skip ci]	2024-10-28 02:08:53 -07:00
Andrew Kane	c530a3c490	Updated comment [skip ci]	2024-10-28 00:56:10 -07:00
Andrew Kane	d8b9e8ef73	Updated readme [skip ci]	2024-10-28 00:55:25 -07:00
Andrew Kane	00894efed5	Updated readme [skip ci]	2024-10-28 00:45:26 -07:00
Andrew Kane	0aa0f6619b	Updated readme [skip ci]	2024-10-28 00:43:39 -07:00
Andrew Kane	38d053001e	Updated readme [skip ci]	2024-10-28 00:32:12 -07:00
Andrew Kane	ccb95407e7	Updated readme [skip ci]	2024-10-28 00:09:26 -07:00
Andrew Kane	04d5e934a1	Scan 2000 more tuples with default work_mem	2024-10-27 22:23:28 -07:00
Andrew Kane	b163b5b196	Moved code [skip ci]	2024-10-27 22:21:43 -07:00
Andrew Kane	6a30c1e824	Fixed test [skip ci]	2024-10-27 21:10:51 -07:00
Andrew Kane	2db1b19644	Use greater than [skip ci]	2024-10-27 21:07:22 -07:00
Andrew Kane	305d62146e	Updated comment [skip ci]	2024-10-27 21:05:32 -07:00
Andrew Kane	f9d627c9a9	Updated default value of hnsw.scan_mem_multiplier [skip ci]	2024-10-27 21:05:04 -07:00
Andrew Kane	38f42820be	Added test for hnsw.scan_mem_multiplier [skip ci]	2024-10-27 20:05:58 -07:00
Andrew Kane	15c8245b42	Updated readme [skip ci]	2024-10-27 19:30:40 -07:00
Andrew Kane	572a9ab404	Updated readme [skip ci]	2024-10-27 18:58:50 -07:00
Andrew Kane	00492d7e57	Ensure max memory fits into Size for HNSW index scans	2024-10-27 14:21:15 -07:00
Andrew Kane	857d716d9e	Renamed iterative_search to iterative_scan	2024-10-27 14:02:22 -07:00
Andrew Kane	c5dd2af750	Added comments [skip ci]	2024-10-25 21:39:03 -07:00
Andrew Kane	78b877bdaf	Revert "Renamed iterative_search to iterative_scan" This reverts commit `7043cce893`.	2024-10-24 20:32:07 -07:00
Andrew Kane	7043cce893	Renamed iterative_search to iterative_scan	2024-10-24 20:31:43 -07:00
Andrew Kane	62039d74f6	Added iterative search section to readme [skip ci]	2024-10-24 18:05:29 -07:00
Andrew Kane	ac6576e53a	Added hnsw.search_mem_multiplier option	2024-10-24 18:02:20 -07:00
Andrew Kane	67eff41c44	Updated changelog [skip ci]	2024-10-23 15:12:40 -07:00
Andrew Kane	1291b12090	Added Postgres 18 to CI [skip ci]	2024-10-22 00:38:19 -07:00
Andrew Kane	24522700b8	Improved hnswrescan	2024-10-21 23:41:32 -07:00
Andrew Kane	bfb3a45b31	Use consistent order [skip ci]	2024-10-21 21:47:03 -07:00
Andrew Kane	e718eb8da4	Updated range and defaults for iterative search parameters	2024-10-21 20:38:50 -07:00
Andrew Kane	049972a4a3	Improved test output [skip ci]	2024-10-13 17:22:49 -07:00
Andrew Kane	61027645e9	Improved test output [skip ci]	2024-10-13 17:21:38 -07:00
Andrew Kane	a41b327b33	Speed up test [skip ci]	2024-10-13 17:12:12 -07:00
Andrew Kane	7f735ebd9b	Added test for strict order [skip ci]	2024-10-13 17:04:03 -07:00
Andrew Kane	02b01e1ca9	Show tuples with memory usage [skip ci]	2024-10-12 22:05:13 -07:00
Andrew Kane	388e42f6e6	Fixed flaky test [skip ci]	2024-10-11 15:48:19 -07:00
Andrew Kane	bf379eed86	Use a memory context for IVFFlat index scans	2024-10-11 15:46:38 -07:00
Andrew Kane	e1bc929429	Simplify lists for IvfflatScanOpaque [skip ci]	2024-10-11 15:29:23 -07:00
Andrew Kane	38285aacc7	Revert "Updated IVFFlat to support multiple attributes (not enabled yet)" This reverts commit `772ab69de6`.	2024-10-11 15:01:54 -07:00
Andrew Kane	a2408e60fa	Revert "Added IndexTuple to HNSW elements (first step to support multiple attributes)" This reverts commit `53a8734bac`.	2024-10-11 14:57:57 -07:00
Andrew Kane	53a8734bac	Added IndexTuple to HNSW elements (first step to support multiple attributes)	2024-10-11 14:12:01 -07:00
Andrew Kane	7484625227	Added comments [skip ci]	2024-10-11 11:59:36 -07:00
Andrew Kane	d1ebb8db73	Use -1 for no limit for ivfflat.max_probes [skip ci]	2024-10-11 11:43:32 -07:00
Andrew Kane	42af8aa1d1	Updated GUC descriptions [skip ci]	2024-10-11 11:26:27 -07:00
Andrew Kane	9d15a76b60	Improved enum naming [skip ci]	2024-10-11 11:20:36 -07:00
Andrew Kane	a3a20f9816	Simplified GUC names [skip ci]	2024-10-11 11:18:01 -07:00
Andrew Kane	b26a21b848	Added regression tests for iterative search [skip ci]	2024-10-11 11:07:11 -07:00
Andrew Kane	2dc392ed6c	Updated GUC names [skip ci]	2024-10-10 23:50:11 -07:00
Andrew Kane	960d2848cb	Updated comment [skip ci]	2024-10-10 21:02:33 -07:00
Andrew Kane	8e88b481a6	Use a lower max allocation size than default to allow scanning more tuples for iterative search before exceeding work_mem [skip ci]	2024-10-10 20:57:57 -07:00
Andrew Kane	124018b8dd	Added HnswInitSearchCandidate function	2024-10-10 19:30:47 -07:00