Added support for inline filtering with HNSW [skip ci]

Added instructions for APK [skip ci]
Added links [skip ci]
2026-07-22 12:07:34 +08:00 · 2025-12-10 14:09:22 -08:00 · 2025-12-01 22:52:23 -08:00 · 2025-11-24 12:41:30 -08:00 · 2025-10-30 22:29:36 -07:00 · 2025-10-30 11:48:44 -07:00
41 changed files with 963 additions and 381 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: 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,10 +1,24 @@
-## 0.8.0 (unreleased)
+## 0.9.0 (unreleased)
+
+- Added support for inline filtering with HNSW
+
+## 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 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
@@ -29,31 +29,21 @@ make install # may need sudo

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

-You can also install it with [Docker](#docker), [Homebrew](#homebrew), [PGXN](#pgxn), [APT](#apt), [Yum](#yum), [pkg](#pkg), or [conda-forge](#conda-forge), and it comes preinstalled with [Postgres.app](#postgresapp) and many [hosted providers](#hosted-postgres). There are also instructions for [GitHub Actions](https://github.com/pgvector/setup-pgvector).
+You can also install it with [Docker](#docker), [Homebrew](#homebrew), [PGXN](#pgxn), [APT](#apt), [Yum](#yum), [pkg](#pkg), [APK](#apk), or [conda-forge](#conda-forge), and it comes preinstalled with [Postgres.app](#postgresapp) and many [hosted providers](#hosted-postgres). There are also instructions for [GitHub Actions](https://github.com/pgvector/setup-pgvector).

 ### 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,37 +419,65 @@ 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 [partial index](https://www.postgresql.org/docs/current/indexes-partial.html) on the vector column for approximate search
+For multiple columns, consider a [multicolumn index](https://www.postgresql.org/docs/current/indexes-multicolumn.html).
+
+```sql
+CREATE INDEX ON items (location_id, category_id);
+```
+
+Exact indexes work well for conditions that match a low percentage of rows. Otherwise, [approximate indexes](#indexing) can work better.
+
+```sql
+CREATE INDEX ON items USING hnsw (embedding vector_l2_ops);
+```
+
+With approximate indexes, filtering is applied *after* the index is scanned. If a condition matches 10% of rows, with HNSW and the default `hnsw.ef_search` of 40, only 4 rows will match on average. For more rows, 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);
 ```

+Or a composite HNSW index (added in 0.9.0)
+
+```sql
+CREATE INDEX ON items USING hnsw (embedding vector_l2_ops, category_id);
+```
+
 ## Iterative Index Scans

-*Unreleased*
+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`).

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

 Strict ensures results are in the exact order by distance

@@ -478,9 +498,11 @@ With relaxed ordering, you can use a [materialized CTE](https://www.postgresql.o
 ```sql
 WITH relaxed_results AS MATERIALIZED (
    SELECT id, embedding <-> '[1,2,3]' AS distance FROM items WHERE category_id = 123 ORDER BY distance LIMIT 5
-) SELECT * FROM relaxed_results ORDER BY distance;
+) 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
@@ -493,7 +515,7 @@ Note: Place any other filters inside the CTE

 ### Iterative Scan Options

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

 #### HNSW

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

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

 #### IVFFlat

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

 ## Half-Precision Vectors

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

 ```sql
@@ -546,8 +555,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
@@ -569,24 +576,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
@@ -609,8 +608,6 @@ SELECT * FROM (

 ## Sparse Vectors

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

 ```sql
@@ -644,8 +641,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
@@ -706,10 +701,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
@@ -759,8 +754,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
@@ -784,25 +777,35 @@ 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)
+Algol | [pgvector-algol](https://github.com/pgvector/pgvector-algol)
 C | [pgvector-c](https://github.com/pgvector/pgvector-c)
 C++ | [pgvector-cpp](https://github.com/pgvector/pgvector-cpp)
 C#, F#, Visual Basic | [pgvector-dotnet](https://github.com/pgvector/pgvector-dotnet)
 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)
+Prolog | [pgvector-prolog](https://github.com/pgvector/pgvector-prolog)
 Python | [pgvector-python](https://github.com/pgvector/pgvector-python)
 R | [pgvector-r](https://github.com/pgvector/pgvector-r)
+Racket | [pgvector-racket](https://github.com/pgvector/pgvector-racket)
+Raku | [pgvector-raku](https://github.com/pgvector/pgvector-raku)
 Ruby | [pgvector-ruby](https://github.com/pgvector/pgvector-ruby), [Neighbor](https://github.com/ankane/neighbor)
 Rust | [pgvector-rust](https://github.com/pgvector/pgvector-rust)
 Swift | [pgvector-swift](https://github.com/pgvector/pgvector-swift)
@@ -820,11 +823,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));
@@ -924,7 +927,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).

@@ -936,7 +939,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).

@@ -1072,7 +1075,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:
@@ -1083,11 +1086,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

@@ -1096,14 +1099,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

@@ -1121,6 +1130,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.
@@ -1132,17 +1149,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
@@ -1153,7 +1191,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

@@ -1168,29 +1206,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:
@@ -1200,6 +1238,14 @@ cd /usr/ports/databases/pgvector
 make install
 ```

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

 With Conda Postgres, install from [conda-forge](https://anaconda.org/conda-forge/pgvector) with:
@@ -1232,36 +1278,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:
@@ -1272,6 +1288,7 @@ 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.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--0.8.1--0.9.0.sql
+++ b/sql/vector--0.8.1--0.9.0.sql
@@ -0,0 +1,10 @@
+-- complain if script is sourced in psql, rather than via CREATE EXTENSION
+\echo Use "ALTER EXTENSION vector UPDATE TO '0.9.0'" to load this file. \quit
+
+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.sql
+++ b/sql/vector.sql
@@ -916,3 +916,13 @@ 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
@@ -52,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
 }

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

 	DefineCustomIntVariable("hnsw.ef_search", "Sets the size of the dynamic candidate list for search",
 							"Valid range is 1..1000.", &hnsw_ef_search,
-							HNSW_DEFAULT_EF_SEARCH, HNSW_MIN_EF_SEARCH, HNSW_MAX_EF_SEARCH, PGC_USERSET, GUC_EXPLAIN, NULL, NULL, NULL);
+							HNSW_DEFAULT_EF_SEARCH, HNSW_MIN_EF_SEARCH, HNSW_MAX_EF_SEARCH, 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, GUC_EXPLAIN, NULL, NULL, NULL);
+							 HNSW_ITERATIVE_SCAN_OFF, hnsw_iterative_scan_options, 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, GUC_EXPLAIN, NULL, NULL, NULL);
+							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, GUC_EXPLAIN, NULL, NULL, NULL);
+							 1, 1, 1000, PGC_USERSET, 0, NULL, NULL, NULL);

 	MarkGUCPrefixReserved("hnsw");
 }
@@ -130,7 +138,7 @@ 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();
@@ -255,13 +263,18 @@ hnswhandler(PG_FUNCTION_ARGS)
 	IndexAmRoutine *amroutine = makeNode(IndexAmRoutine);

 	amroutine->amstrategies = 0;
-	amroutine->amsupport = 3;
+	amroutine->amsupport = 4;
 	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;
+	amroutine->amcanmulticol = true;
 	amroutine->amoptionalkey = true;
 	amroutine->amsearcharray = false;
 	amroutine->amsearchnulls = false;
@@ -291,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;
@@ -311,5 +327,24 @@ 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,6 +19,7 @@
 #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
@@ -107,6 +108,8 @@
 #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_scan;
@@ -126,7 +129,7 @@ typedef struct HnswNeighborArray HnswNeighborArray;

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

 /* Pointers that can be absolute or relative */
 /* Use char for DatumPtr so works with Pointer */
@@ -134,6 +137,7 @@ HnswPtrDeclare(HnswElementData, HnswElementRelptr, HnswElementPtr);
 HnswPtrDeclare(HnswNeighborArray, HnswNeighborArrayRelptr, HnswNeighborArrayPtr);
 HnswPtrDeclare(HnswNeighborArrayPtr, HnswNeighborsRelptr, HnswNeighborsPtr);
 HnswPtrDeclare(char, DatumRelptr, DatumPtr);
+HnswPtrDeclare(IndexTupleData, IndexTupleRelptr, IndexTuplePtr);

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

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

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

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

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

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

 	/* Memory */
 	MemoryContext graphCtx;
@@ -417,30 +427,32 @@ 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, 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, bool inMemory, visited_hash * v, pairingheap **discarded, bool initVisited, int64 *tuples);
 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);
-HnswSearchCandidate *HnswEntryCandidate(char *base, HnswElement em, HnswQuery * q, Relation rel, HnswSupport * support, bool loadVec);
+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		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, Datum value, ItemPointer heaptid, bool building);
+bool		HnswInsertTupleOnDisk(Relation index, HnswSupport * support, IndexTuple itup, ItemPointer heaptid, bool building, TupleDesc tupdesc);
 void		HnswUpdateNeighborsOnDisk(Relation index, HnswSupport * support, HnswElement e, int m, bool checkExisting, bool building);
-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		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		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,6 +152,7 @@ CreateGraphPages(HnswBuildState * buildstate)
 	Page		page;
 	HnswElementPtr iter = buildstate->graph->head;
 	char	   *base = buildstate->hnswarea;
+	bool		useIndexTuple = buildstate->useIndexTuple;

 	/* Calculate sizes */
 	maxSize = HNSW_MAX_SIZE;
@@ -167,7 +172,6 @@ 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 = HNSW_ELEMENT_TUPLE_SIZE(VARSIZE_ANY(valuePtr));
+		etupSize = HnswGetElementTupleSize(base, element, useIndexTuple);
 		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);
+		HnswSetElementTuple(base, etup, element, useIndexTuple);

 		/* Keep element and neighbors on the same page if possible */
 		if (PageGetFreeSpace(page) < etupSize || (combinedSize <= maxSize && PageGetFreeSpace(page) < combinedSize))
@@ -327,19 +331,18 @@ AddDuplicateInMemory(HnswElement element, HnswElement dup)
 * Find duplicate element
 */
 static bool
-FindDuplicateInMemory(char *base, HnswElement element)
+FindDuplicateInMemory(char *base, HnswElement element, bool useIndexTuple, TupleDesc tupdesc)
 {
 	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);

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

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

 			LWLockAcquire(&neighborElement->lock, LW_EXCLUSIVE);
-			HnswUpdateConnection(base, HnswGetNeighbors(base, neighborElement, lc), e, hc->distance, lm, NULL, NULL, support);
+			HnswUpdateConnection(base, HnswGetNeighbors(base, neighborElement, lc), e, hc->distance, lm, NULL, index, support);
 			LWLockRelease(&neighborElement->lock);
 		}
 	}
@@ -398,20 +401,20 @@ UpdateNeighborsInMemory(char *base, HnswSupport * support, HnswElement e, int m)
 * 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))
+	if (FindDuplicateInMemory(base, element, buildstate->useIndexTuple, buildstate->tupdesc))
 		return;

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

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

 	/* Update entry point if needed (already have lock) */
 	if (entryPoint == NULL || element->level > entryPoint->level)
@@ -424,6 +427,7 @@ 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, NULL, support, m, efConstruction, false);
+	HnswFindElementNeighbors(base, element, entryPoint, index, 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,18 +480,20 @@ 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;
-	Datum		value;
+	TupleDesc	tupdesc = buildstate->tupdesc;
+	IndexTuple	itup;
+	Size		itupSize;
+	IndexTuple	itupShared;
+	bool		unused;

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

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

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

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

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

 		LWLockRelease(flushLock);

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

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

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

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

 	/* Create a lock for the element */
 	LWLockInitialize(&element->lock, hnsw_lock_tranche_id);
@@ -672,6 +679,19 @@ 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,
@@ -698,6 +718,8 @@ 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",
@@ -1054,7 +1076,7 @@ ComputeParallelWorkers(Relation heap, Relation index)
 * Build graph
 */
 static void
-BuildGraph(HnswBuildState * buildstate, ForkNumber forkNum)
+BuildGraph(HnswBuildState * buildstate)
 {
 	int			parallel_workers = 0;

@@ -1102,7 +1124,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,9 +160,10 @@ 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 = HNSW_ELEMENT_TUPLE_SIZE(VARSIZE_ANY(HnswPtrAccess(base, e->value)));
+	etupSize = HnswGetElementTupleSize(base, e, useIndexTuple);
 	ntupSize = HNSW_NEIGHBOR_TUPLE_SIZE(e->level, m);
 	combinedSize = etupSize + ntupSize + sizeof(ItemIdData);
 	maxSize = HNSW_MAX_SIZE;
@@ -166,7 +171,7 @@ AddElementOnDisk(Relation index, HnswElement e, int m, BlockNumber insertPage, B

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

 	/* Prepare neighbor tuple */
 	ntup = palloc0(ntupSize);
@@ -383,8 +388,9 @@ 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, q, index, support, true, NULL);
+		HnswLoadElement(element, &distance, &matches, q, index, support, true, NULL);
 		hc->distance = distance;

 		/* Prune element if being deleted */
@@ -428,6 +434,8 @@ 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);

@@ -633,21 +641,30 @@ AddDuplicateOnDisk(Relation index, HnswElement element, HnswElement dup, bool bu
 * Find duplicate element
 */
 static bool
-FindDuplicateOnDisk(Relation index, HnswElement element, bool building)
+FindDuplicateOnDisk(Relation index, HnswElement element, bool building, TupleDesc tupdesc)
 {
 	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);

-		/* Exit early since ordered by distance */
-		if (!datumIsEqual(value, neighborValue, false, -1))
-			return false;
+		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;
+		}

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

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

 	/* Add element */
@@ -687,7 +704,7 @@ UpdateGraphOnDisk(Relation index, HnswSupport * support, HnswElement element, in
 * Insert a tuple into the index
 */
 bool
-HnswInsertTupleOnDisk(Relation index, HnswSupport * support, Datum value, ItemPointer heaptid, bool building)
+HnswInsertTupleOnDisk(Relation index, HnswSupport * support, IndexTuple itup, ItemPointer heaptid, bool building, TupleDesc tupdesc)
 {
 	HnswElement entryPoint;
 	HnswElement element;
@@ -695,6 +712,7 @@ HnswInsertTupleOnDisk(Relation index, HnswSupport * support, Datum value, ItemPo
 	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
@@ -708,7 +726,8 @@ HnswInsertTupleOnDisk(Relation index, HnswSupport * support, Datum value, ItemPo

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

 	/* Prevent concurrent inserts when likely updating entry point */
 	if (entryPoint == NULL || element->level > entryPoint->level)
@@ -725,10 +744,10 @@ HnswInsertTupleOnDisk(Relation index, HnswSupport * support, Datum value, ItemPo
 	}

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

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

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

 	HnswInitSupport(&support, index);

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

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

 /*
--- a/src/hnswscan.c
+++ b/src/hnswscan.c
@@ -22,26 +22,30 @@ 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));
+	ep = list_make1(HnswEntryCandidate(base, entryPoint, q, index, support, false, inMemory));

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

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

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

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

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

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

 	return value;
@@ -193,6 +197,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)
@@ -240,8 +248,8 @@ hnswgettuple(IndexScanDesc scan, ScanDirection dir)
 			if (so->discarded == NULL)
 				break;

-			/* Reached max number of tuples */
-			if (so->tuples >= hnsw_max_scan_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;
@@ -249,21 +257,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) > so->maxMemory)
-			{
-				if (pairingheap_is_empty(so->discarded))
-				{
-					ereport(DEBUG1,
-							(errmsg("hnsw index scan reached memory limit after " INT64_FORMAT " tuples", so->tuples),
-							 errhint("Increase hnsw.scan_mem_multiplier to scan more tuples.")));
-
-					break;
-				}
-
-				/* Return remaining tuples */
-				so->w = lappend(so->w, HnswGetSearchCandidate(w_node, pairingheap_remove_first(so->discarded)));
-			}
 			else
 			{
 				/*
@@ -294,7 +287,7 @@ hnswgettuple(IndexScanDesc scan, ScanDirection dir)
 		element = HnswPtrAccess(base, sc->element);

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

--- a/src/hnswutils.c
+++ b/src/hnswutils.c
@@ -15,6 +15,10 @@
 #include "utils/memdebug.h"
 #include "utils/rel.h"

+#if PG_VERSION_NUM >= 160000
+#include "varatt.h"
+#endif
+
 #if PG_VERSION_NUM < 170000
 static inline uint64
 murmurhash64(uint64 data)
@@ -146,11 +150,39 @@ HnswOptionalProcInfo(Relation index, uint16 procnum)
 void
 HnswInitSupport(HnswSupport * support, Relation index)
 {
-	support->procinfo = index_getprocinfo(index, 1, HNSW_DISTANCE_PROC);
-	support->collation = index->rd_indcollation[0];
+	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->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
 */
@@ -166,7 +198,38 @@ HnswNormValue(const HnswTypeInfo * typeInfo, Oid collation, Datum value)
 bool
 HnswCheckNorm(HnswSupport * support, Datum value)
 {
-	return DatumGetFloat8(FunctionCall1Coll(support->normprocinfo, support->collation, value)) > 0;
+	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;
 }

 /*
@@ -257,6 +320,7 @@ 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;
 }
@@ -283,6 +347,7 @@ 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;
 }

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

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

@@ -413,10 +480,14 @@ HnswFormIndexValue(Datum *out, Datum *values, bool *isnull, const HnswTypeInfo *
 		if (!HnswCheckNorm(support, value))
 			return false;

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

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

 	return true;
 }
@@ -425,10 +496,8 @@ HnswFormIndexValue(Datum *out, Datum *values, bool *isnull, const HnswTypeInfo *
 * Set element tuple, except for neighbor info
 */
 void
-HnswSetElementTuple(char *base, HnswElementTuple etup, HnswElement element)
+HnswSetElementTuple(char *base, HnswElementTuple etup, HnswElement element, bool useIndexTuple)
 {
-	Pointer		valuePtr = HnswPtrAccess(base, element->value);
-
 	etup->type = HNSW_ELEMENT_TUPLE_TYPE;
 	etup->level = element->level;
 	etup->deleted = 0;
@@ -440,7 +509,19 @@ HnswSetElementTuple(char *base, HnswElementTuple etup, HnswElement element)
 		else
 			ItemPointerSetInvalid(&etup->heaptids[i]);
 	}
-	memcpy(&etup->data, valuePtr, VARSIZE_ANY(valuePtr));
+
+	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));
+	}
 }

 /*
@@ -482,7 +563,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)
+HnswLoadElementFromTuple(HnswElement element, HnswElementTuple etup, bool loadHeaptids, bool loadVec, Relation index)
 {
 	element->level = etup->level;
 	element->deleted = etup->deleted;
@@ -506,26 +587,128 @@ HnswLoadElementFromTuple(HnswElement element, HnswElementTuple etup, bool loadHe
 	if (loadVec)
 	{
 		char	   *base = NULL;
-		Datum		value = datumCopy(PointerGetDatum(&etup->data), false, -1);

-		HnswPtrStore(base, element->value, DatumGetPointer(value));
+		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));
+		}
 	}
 }

+/*
+ * 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 inline double
-HnswGetDistance(Datum a, Datum b, HnswSupport * support)
+static double
+HnswGetDistance(IndexTuple itup, Datum vec, HnswQuery * q, Relation index, HnswSupport * support, bool *matches)
 {
-	return DatumGetFloat8(FunctionCall2Coll(support->procinfo, support->collation, a, b));
+	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;
 }

 /*
 * Load an element and optionally get its distance from q
 */
 static void
-HnswLoadElementImpl(BlockNumber blkno, OffsetNumber offno, double *distance, HnswQuery * q, Relation index, HnswSupport * support, bool loadVec, double *maxDistance, HnswElement * element)
+HnswLoadElementImpl(BlockNumber blkno, OffsetNumber offno, double *distance, bool *matches, HnswQuery * q, Relation index, HnswSupport * support, bool loadVec, double *maxDistance, HnswElement * element)
 {
 	Buffer		buf;
 	Page		page;
@@ -543,10 +726,23 @@ HnswLoadElementImpl(BlockNumber blkno, OffsetNumber offno, double *distance, Hns
 	/* Calculate distance */
 	if (distance != NULL)
 	{
-		if (DatumGetPointer(q->value) == NULL)
-			*distance = 0;
+		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);
+		}
 		else
-			*distance = HnswGetDistance(q->value, PointerGetDatum(&etup->data), support);
+		{
+			value = PointerGetDatum(&etup->data);
+		}
+
+		*distance = HnswGetDistance(itup, value, q, index, support, matches);
 	}

 	/* Load element */
@@ -555,7 +751,7 @@ HnswLoadElementImpl(BlockNumber blkno, OffsetNumber offno, double *distance, Hns
 		if (*element == NULL)
 			*element = HnswInitElementFromBlock(blkno, offno);

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

 	UnlockReleaseBuffer(buf);
@@ -565,32 +761,34 @@ HnswLoadElementImpl(BlockNumber blkno, OffsetNumber offno, double *distance, Hns
 * Load an element and optionally get its distance from q
 */
 void
-HnswLoadElement(HnswElement element, double *distance, HnswQuery * q, Relation index, HnswSupport * support, bool loadVec, double *maxDistance)
+HnswLoadElement(HnswElement element, double *distance, bool *matches, HnswQuery * q, Relation index, HnswSupport * support, bool loadVec, double *maxDistance)
 {
-	HnswLoadElementImpl(element->blkno, element->offno, distance, q, index, support, loadVec, maxDistance, &element);
+	HnswLoadElementImpl(element->blkno, element->offno, distance, matches, q, index, support, loadVec, maxDistance, &element);
 }

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

-	return HnswGetDistance(q->value, value, support);
+	return HnswGetDistance(itup, value, q, index, support, matches);
 }

 /*
 * Allocate a search candidate
 */
 static HnswSearchCandidate *
-HnswInitSearchCandidate(char *base, HnswElement element, double distance)
+HnswInitSearchCandidate(char *base, HnswElement element, double distance, bool matches)
 {
 	HnswSearchCandidate *sc = palloc(sizeof(HnswSearchCandidate));

 	HnswPtrStore(base, sc->element, element);
 	sc->distance = distance;
+	sc->matches = matches;
 	return sc;
 }

@@ -598,17 +796,17 @@ HnswInitSearchCandidate(char *base, HnswElement element, double distance)
 * Create a candidate for the entry point
 */
 HnswSearchCandidate *
-HnswEntryCandidate(char *base, HnswElement entryPoint, HnswQuery * q, Relation index, HnswSupport * support, bool loadVec)
+HnswEntryCandidate(char *base, HnswElement entryPoint, HnswQuery * q, Relation index, HnswSupport * support, bool loadVec, bool inMemory)
 {
-	bool		inMemory = index == NULL;
 	double		distance;
+	bool		matches;

 	if (inMemory)
-		distance = GetElementDistance(base, entryPoint, q, support);
+		distance = GetElementDistance(base, entryPoint, &matches, q, index, support);
 	else
-		HnswLoadElement(entryPoint, &distance, q, index, support, loadVec, NULL);
+		HnswLoadElement(entryPoint, &distance, &matches, q, index, support, loadVec, NULL);

-	return HnswInitSearchCandidate(base, entryPoint, distance);
+	return HnswInitSearchCandidate(base, entryPoint, distance, matches);
 }

 /*
@@ -811,7 +1009,7 @@ HnswLoadUnvisitedFromDisk(HnswElement element, HnswUnvisited * unvisited, int *u
 * 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, 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, bool inMemory, visited_hash * v, pairingheap **discarded, bool initVisited, int64 *tuples)
 {
 	List	   *w = NIL;
 	pairingheap *C = pairingheap_allocate(CompareNearestCandidates, NULL);
@@ -824,7 +1022,8 @@ 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;
-	bool		inMemory = index == NULL;
+	uint64		additional = 0;
+	uint64		maxAdditional = q->keyData && lc == 0 ? 10000 : 0;

 	if (v == NULL)
 	{
@@ -865,6 +1064,10 @@ 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
@@ -899,6 +1102,7 @@ HnswSearchLayer(char *base, HnswQuery * q, List *ep, int ef, int lc, Relation in
 			HnswElement eElement;
 			HnswSearchCandidate *e;
 			double		eDistance;
+			bool		eMatches;
 			bool		alwaysAdd = wlen < ef;

 			f = HnswGetSearchCandidate(w_node, pairingheap_first(W));
@@ -906,7 +1110,7 @@ HnswSearchLayer(char *base, HnswQuery * q, List *ep, int ef, int lc, Relation in
 			if (inMemory)
 			{
 				eElement = unvisited[i].element;
-				eDistance = GetElementDistance(base, eElement, q, support);
+				eDistance = GetElementDistance(base, eElement, &eMatches, q, index, support);
 			}
 			else
 			{
@@ -916,7 +1120,7 @@ HnswSearchLayer(char *base, HnswQuery * q, List *ep, int ef, int lc, Relation in

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

 				if (eElement == NULL)
 					continue;
@@ -927,7 +1131,7 @@ HnswSearchLayer(char *base, HnswQuery * q, List *ep, int ef, int lc, Relation in
 				if (discarded != NULL)
 				{
 					/* Create a new candidate */
-					e = HnswInitSearchCandidate(base, eElement, eDistance);
+					e = HnswInitSearchCandidate(base, eElement, eDistance, eMatches);
 					pairingheap_add(*discarded, &e->w_node);
 				}

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

 			/* Create a new candidate */
-			e = HnswInitSearchCandidate(base, eElement, eDistance);
+			e = HnswInitSearchCandidate(base, eElement, eDistance, eMatches);
 			pairingheap_add(C, &e->c_node);
 			pairingheap_add(W, &e->w_node);

@@ -950,6 +1154,10 @@ 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 */
@@ -1027,18 +1235,24 @@ 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, HnswSupport * support)
+CheckElementCloser(char *base, HnswCandidate * e, List *r, Relation index, HnswSupport * support)
 {
 	HnswElement eElement = HnswPtrAccess(base, e->element);
-	Datum		eValue = HnswGetValue(base, eElement);
+	HnswQuery	q;
 	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);
-		float		distance = HnswGetDistance(eValue, riValue, support);
+		IndexTuple	ritup = HnswPtrAccess(base, riElement->itup);
+		bool		matches;
+		float		distance = HnswGetDistance(ritup, riValue, &q, index, support, &matches);

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

 		/* Use previous state of r and wd to skip work when possible */
 		if (mustCalculate)
-			e->closer = CheckElementCloser(base, e, r, support);
+			e->closer = CheckElementCloser(base, e, r, index, support);
 		else if (list_length(added) > 0)
 		{
 			/* Keep Valgrind happy for in-memory, parallel builds */
@@ -1098,8 +1312,7 @@ SelectNeighbors(char *base, List *c, int lm, HnswSupport * support, bool *closer
 			 */
 			if (e->closer)
 			{
-				e->closer = CheckElementCloser(base, e, added, support);
-
+				e->closer = CheckElementCloser(base, e, added, index, support);
 				if (!e->closer)
 					removedAny = true;
 			}
@@ -1111,7 +1324,7 @@ SelectNeighbors(char *base, List *c, int lm, HnswSupport * support, bool *closer
 				 */
 				if (removedAny)
 				{
-					e->closer = CheckElementCloser(base, e, r, support);
+					e->closer = CheckElementCloser(base, e, r, index, support);
 					if (e->closer)
 						added = lappend(added, e);
 				}
@@ -1119,7 +1332,7 @@ SelectNeighbors(char *base, List *c, int lm, HnswSupport * support, bool *closer
 		}
 		else if (e == newCandidate)
 		{
-			e->closer = CheckElementCloser(base, e, r, support);
+			e->closer = CheckElementCloser(base, e, r, index, support);
 			if (e->closer)
 				added = lappend(added, e);
 		}
@@ -1196,7 +1409,7 @@ HnswUpdateConnection(char *base, HnswNeighborArray * neighbors, HnswElement newE
 			c = lappend(c, &neighbors->items[i]);
 		c = lappend(c, &newHc);

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

 		/* Should not happen */
 		if (pruned == NULL)
@@ -1267,17 +1480,19 @@ 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)
+HnswFindElementNeighbors(char *base, HnswElement element, HnswElement entryPoint, Relation index, HnswSupport * support, int m, int efConstruction, bool existing, bool inMemory)
 {
 	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)
@@ -1288,13 +1503,13 @@ HnswFindElementNeighbors(char *base, HnswElement element, HnswElement entryPoint
 		return;

 	/* Get entry point and level */
-	ep = list_make1(HnswEntryCandidate(base, entryPoint, &q, index, support, true));
+	ep = list_make1(HnswEntryCandidate(base, entryPoint, &q, index, support, true, inMemory));
 	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, NULL, NULL, true, NULL);
+		w = HnswSearchLayer(base, &q, ep, 1, lc, index, support, m, true, skipElement, inMemory, NULL, NULL, true, NULL);
 		ep = w;
 	}

@@ -1313,7 +1528,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, NULL, NULL, true, NULL);
+		w = HnswSearchLayer(base, &q, ep, efConstruction, lc, index, support, m, true, skipElement, inMemory, NULL, NULL, true, NULL);

 		/* Convert search candidates to candidates */
 		foreach(lc2, w)
@@ -1337,7 +1552,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, support, &HnswGetNeighbors(base, element, lc)->closerSet, NULL, NULL, false);
+		neighbors = SelectNeighbors(base, lw, lm, index, support, &HnswGetNeighbors(base, element, lc)->closerSet, NULL, NULL, false);

 		AddConnections(base, element, neighbors, lc);

@@ -1393,7 +1608,7 @@ hnsw_halfvec_support(PG_FUNCTION_ARGS)
 	};

 	PG_RETURN_POINTER(&typeInfo);
-};
+}

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

 	PG_RETURN_POINTER(&typeInfo);
-};
+}

 FUNCTION_PREFIX PG_FUNCTION_INFO_V1(hnsw_sparsevec_support);
 Datum
@@ -1419,4 +1634,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);
+	HnswFindElementNeighbors(base, element, entryPoint, index, support, m, efConstruction, true, false);

 	/* 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, index, support, true, NULL);
+		HnswLoadElement(highestPoint, NULL, 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, index, support, true, NULL);
+			HnswLoadElement(entryPoint, NULL, 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);
+			HnswLoadElementFromTuple(element, etup, false, true, index);

 			elements = lappend(elements, element);
 		}
@@ -440,6 +448,7 @@ 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
@@ -521,7 +530,14 @@ MarkDeleted(HnswVacuumState * vacuumstate)

 			/* Overwrite element */
 			etup->deleted = 1;
-			MemSet(&etup->data, 0, VARSIZE_ANY(&etup->data));
+			if (useIndexTuple)
+			{
+				IndexTuple	itup = (IndexTuple) &etup->data;
+
+				MemSet(itup, 0, IndexTupleSize(itup));
+			}
+			else
+				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, IvfflatBuildState * buildstate)
+AddTupleToSort(ItemPointer tid, Datum *values, IvfflatBuildState * buildstate)
 {
 	double		distance;
 	double		minDistance = DBL_MAX;
@@ -215,7 +219,7 @@ BuildCallback(Relation index, ItemPointer tid, Datum *values,
 	oldCtx = MemoryContextSwitchTo(buildstate->tmpCtx);

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

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

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

@@ -470,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;
@@ -1004,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 */
@@ -1023,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
@@ -39,16 +39,16 @@ IvfflatInit(void)

 	DefineCustomIntVariable("ivfflat.probes", "Sets the number of probes",
 							"Valid range is 1..lists.", &ivfflat_probes,
-							IVFFLAT_DEFAULT_PROBES, IVFFLAT_MIN_LISTS, IVFFLAT_MAX_LISTS, PGC_USERSET, GUC_EXPLAIN, NULL, NULL, NULL);
+							IVFFLAT_DEFAULT_PROBES, IVFFLAT_MIN_LISTS, IVFFLAT_MAX_LISTS, 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, GUC_EXPLAIN, NULL, NULL, NULL);
+							 IVFFLAT_ITERATIVE_SCAN_OFF, ivfflat_iterative_scan_options, 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, GUC_EXPLAIN, NULL, NULL, NULL);
+							IVFFLAT_MAX_LISTS, IVFFLAT_MIN_LISTS, IVFFLAT_MAX_LISTS, PGC_USERSET, 0, NULL, NULL, NULL);

 	MarkGUCPrefixReserved("ivfflat");
 }
@@ -92,7 +92,7 @@ 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();
@@ -186,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;
@@ -218,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;
@@ -238,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,9 +77,11 @@
 #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 */
--- 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;
@@ -204,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
@@ -114,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;

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

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

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

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

 #if defined(IVFFLAT_MEMORY)
@@ -364,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)
--- 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
@@ -123,6 +123,12 @@ SELECT * FROM t ORDER BY val <-> '[3,3,3]';
 [0,0,0]
 (3 rows)

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

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

+TRUNCATE t;
+NOTICE:  ivfflat index created with little data
+DETAIL:  This will cause low recall.
+HINT:  Drop the index until the table has more data.
+SELECT * FROM t ORDER BY val <-> '[3,3,3]';
+ val 
+-----
+(0 rows)
+
 RESET ivfflat.iterative_scan;
 RESET ivfflat.max_probes;
 DROP TABLE t;
--- a/test/expected/vector_type.out
+++ b/test/expected/vector_type.out
@@ -576,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
@@ -70,6 +70,9 @@ 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;
@@ -109,5 +112,6 @@ SET hnsw.max_scan_tuples = 0;
 SHOW hnsw.scan_mem_multiplier;

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

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

+TRUNCATE t;
+SELECT * FROM t ORDER BY val <-> '[3,3,3]';
+
 RESET ivfflat.iterative_scan;
 RESET ivfflat.max_probes;
 DROP TABLE t;
--- a/test/sql/vector_type.sql
+++ b/test/sql/vector_type.sql
@@ -128,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/043_hnsw_iterative_scan.pl
+++ b/test/t/043_hnsw_iterative_scan.pl
@@ -56,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_scan = relaxed_order;
-	SET client_min_messages = debug1;
-	SET work_mem = '1MB';
-	SELECT COUNT(*) FROM (SELECT v FROM tst WHERE i % 10000 = 0 ORDER BY v <-> (SELECT v FROM tst LIMIT 1) LIMIT 11) t;
-));
-like($stderr, qr/hnsw index scan reached memory limit after \d+ tuples/);
-
 done_testing();
--- a/test/t/045_hnsw_hqann.pl
+++ b/test/t/045_hnsw_hqann.pl
@@ -0,0 +1,113 @@
+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	a2e0f4df80	Added support for inline filtering with HNSW [skip ci]	2025-12-10 14:09:22 -08:00
Andrew Kane	b7c0085afe	Added instructions for APK [skip ci]	2025-12-01 22:52:23 -08:00
Andrew Kane	2b742576b4	Added links [skip ci]	2025-11-24 12:41:30 -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