Improved tests for rescans / nested loop joins [skip ci]

Co-authored-by: zthhhhh <97zthhhh@gmail.com>

.github/workflows/build.yml

@@ -8,10 +8,12 @@ jobs:
       fail-fast: false
       matrix:
         include:
+          - postgres: 20
+            os: ubuntu-26.04
           - postgres: 19
-            os: ubuntu-24.04
+            os: ubuntu-26.04
           - postgres: 18
-            os: ubuntu-24.04
+            os: ubuntu-26.04-arm
           - postgres: 17
             os: ubuntu-24.04
           - postgres: 16
@@ -23,7 +25,7 @@ jobs:
           - postgres: 13
             os: ubuntu-22.04
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v7
       - uses: ankane/setup-postgres@v1
         with:
           postgres-version: ${{ matrix.postgres }}
@@ -53,7 +55,7 @@ jobs:
           - postgres: 14
             os: macos-15-intel
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v7
       - uses: ankane/setup-postgres@v1
         with:
           postgres-version: ${{ matrix.postgres }}
@@ -92,7 +94,7 @@ jobs:
           - postgres: 14
             os: windows-2022
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v7
       - uses: ankane/setup-postgres@v1
         with:
           postgres-version: ${{ matrix.postgres }}
@@ -133,7 +135,7 @@ jobs:
     if: ${{ !startsWith(github.ref_name, 'mac') && !startsWith(github.ref_name, 'windows') }}
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v7
       - uses: ankane/setup-postgres-valgrind@v1
         with:
           postgres-version: 18

CHANGELOG.md

@@ -1,4 +1,19 @@
-## 0.8.3 (unreleased)
+## 0.8.6 (unreleased)
+
+- Fixed array to `sparsevec` cast not limiting non-zero elements
+- Fixed memory usage for IVFFlat index scans with nested loop joins
+
+## 0.8.5 (2026-07-08)
+
+- Reduced memory usage for small tables for IVFFlat index builds
+
+## 0.8.4 (2026-06-30)
+
+- Fixed `hnsw graph not repaired` error with HNSW vacuuming
+- Fixed possible error with inserts during HNSW vacuuming
+- Fixed memory exceeding `maintenance_work_mem` with IVFFlat index builds
+
+## 0.8.3 (2026-06-17)
 
 - Fixed possible index corruption with HNSW vacuuming
 - Fixed performance regression with Hamming distance and Jaccard distance with Postgres 18

Dockerfile

@@ -5,7 +5,7 @@ ARG DEBIAN_CODENAME=bookworm
 FROM postgres:$PG_MAJOR-$DEBIAN_CODENAME
 ARG PG_MAJOR
 
-ADD https://github.com/pgvector/pgvector.git#v0.8.2 /tmp/pgvector
+ADD https://github.com/pgvector/pgvector.git#v0.8.5 /tmp/pgvector
 
 RUN apt-get update && \
 		apt-mark hold locales && \

META.json

@@ -2,12 +2,12 @@
 	"name": "vector",
 	"abstract": "Open-source vector similarity search for Postgres",
 	"description": "Supports L2 distance, inner product, and cosine distance",
-	"version": "0.8.2",
+	"version": "0.8.5",
 	"maintainer": [
 		"Andrew Kane <andrew@ankane.org>"
 	],
 	"license": {
-		"PostgreSQL": "http://www.postgresql.org/about/licence"
+		"PostgreSQL": "https://www.postgresql.org/about/licence"
 	},
 	"prereqs": {
 		"runtime": {
@@ -20,7 +20,7 @@
 		"vector": {
 			"file": "sql/vector.sql",
 			"docfile": "README.md",
-			"version": "0.8.2",
+			"version": "0.8.5",
 			"abstract": "Open-source vector similarity search for Postgres"
 		}
 	},
@@ -38,7 +38,7 @@
 	"generated_by": "Andrew Kane",
 	"meta-spec": {
 		"version": "1.0.0",
-		"url": "http://pgxn.org/meta/spec.txt"
+		"url": "https://pgxn.org/meta/spec.txt"
 	},
 	"tags": [
 		"vectors",

Makefile

@@ -1,5 +1,5 @@
 EXTENSION = vector
-EXTVERSION = 0.8.2
+EXTVERSION = 0.8.5
 
 MODULE_big = vector
 DATA = $(wildcard sql/*--*--*.sql)

Makefile.win

@@ -1,5 +1,5 @@
 EXTENSION = vector
-EXTVERSION = 0.8.2
+EXTVERSION = 0.8.5
 
 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

README.md

@@ -23,7 +23,7 @@ Compile and install the extension (supports Postgres 13+)
 
 ```sh
 cd /tmp
-git clone --branch v0.8.2 https://github.com/pgvector/pgvector.git
+git clone --branch v0.8.5 https://github.com/pgvector/pgvector.git
 cd pgvector
 make
 make install # may need sudo
@@ -40,7 +40,7 @@ Ensure [C++ support in Visual Studio](https://learn.microsoft.com/en-us/cpp/buil
 ```cmd
 set "PGROOT=C:\Program Files\PostgreSQL\18"
 cd %TEMP%
-git clone --branch v0.8.2 https://github.com/pgvector/pgvector.git
+git clone --branch v0.8.5 https://github.com/pgvector/pgvector.git
 cd pgvector
 nmake /F Makefile.win
 nmake /F Makefile.win install
@@ -465,6 +465,16 @@ If filtering by many different values, consider [partitioning](https://www.postg
 CREATE TABLE items (embedding vector(3), category_id int) PARTITION BY LIST(category_id);
 ```
 
+## Multitenancy
+
+For applications with multiple tenants, sharing an approximate index between tenants means vectors from one tenant can affect recall (and speed) for other tenants.
+
+For tenant isolation, use [list partitioning](https://www.postgresql.org/docs/current/ddl-partitioning.html) or separate tables.
+
+```sql
+CREATE TABLE items (customer_id int, embedding vector(3)) PARTITION BY LIST(customer_id);
+```
+
 ## Iterative Index Scans
 
 With approximate indexes, queries with filtering can return less results since filtering is applied *after* the index is scanned. Starting with 0.8.0, you can enable iterative index scans, which will automatically scan more of the index until enough results are found (or it reaches `hnsw.max_scan_tuples` or `ivfflat.max_probes`).
@@ -1151,23 +1161,23 @@ This adds pgvector to the [Postgres image](https://hub.docker.com/_/postgres) (r
 
 Supported tags are:
 
-- `pg18-trixie`, `0.8.2-pg18-trixie`
-- `pg18-bookworm`, `0.8.2-pg18-bookworm`, `pg18`, `0.8.2-pg18`
-- `pg17-trixie`, `0.8.2-pg17-trixie`
-- `pg17-bookworm`, `0.8.2-pg17-bookworm`, `pg17`, `0.8.2-pg17`
-- `pg16-trixie`, `0.8.2-pg16-trixie`
-- `pg16-bookworm`, `0.8.2-pg16-bookworm`, `pg16`, `0.8.2-pg16`
-- `pg15-trixie`, `0.8.2-pg15-trixie`
-- `pg15-bookworm`, `0.8.2-pg15-bookworm`, `pg15`, `0.8.2-pg15`
-- `pg14-trixie`, `0.8.2-pg14-trixie`
-- `pg14-bookworm`, `0.8.2-pg14-bookworm`, `pg14`, `0.8.2-pg14`
-- `pg13-trixie`, `0.8.2-pg13-trixie`
-- `pg13-bookworm`, `0.8.2-pg13-bookworm`, `pg13`, `0.8.2-pg13`
+- `pg18-trixie`, `0.8.5-pg18-trixie`
+- `pg18-bookworm`, `0.8.5-pg18-bookworm`, `pg18`, `0.8.5-pg18`
+- `pg17-trixie`, `0.8.5-pg17-trixie`
+- `pg17-bookworm`, `0.8.5-pg17-bookworm`, `pg17`, `0.8.5-pg17`
+- `pg16-trixie`, `0.8.5-pg16-trixie`
+- `pg16-bookworm`, `0.8.5-pg16-bookworm`, `pg16`, `0.8.5-pg16`
+- `pg15-trixie`, `0.8.5-pg15-trixie`
+- `pg15-bookworm`, `0.8.5-pg15-bookworm`, `pg15`, `0.8.5-pg15`
+- `pg14-trixie`, `0.8.5-pg14-trixie`
+- `pg14-bookworm`, `0.8.5-pg14-bookworm`, `pg14`, `0.8.5-pg14`
+- `pg13-trixie`, `0.8.5-pg13-trixie`
+- `pg13-bookworm`, `0.8.5-pg13-bookworm`, `pg13`, `0.8.5-pg13`
 
 You can also build the image manually:
 
 ```sh
-git clone --branch v0.8.2 https://github.com/pgvector/pgvector.git
+git clone --branch v0.8.5 https://github.com/pgvector/pgvector.git
 cd pgvector
 docker build --pull --build-arg PG_MAJOR=18 -t myuser/pgvector .
 ```
@@ -1223,7 +1233,7 @@ Note: Replace `18` with your Postgres server version
 Install the FreeBSD package with:
 
 ```sh
-pkg install postgresql17-pgvector
+pkg install postgresql18-pgvector
 ```
 
 or the port with:

sql/vector--0.8.2--0.8.3.sql

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

sql/vector--0.8.3--0.8.4.sql

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

sql/vector--0.8.4--0.8.5.sql

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

src/halfvec.c

@@ -27,8 +27,12 @@
 #include "parser/scansup.h"
 #endif
 
+#if PG_VERSION_NUM < 140006
+#define palloc_array(type, count) ((type *) palloc(sizeof(type) * (count)))
+#endif
+
 #define STATE_DIMS(x) (ARR_DIMS(x)[0] - 1)
-#define CreateStateDatums(dim) palloc(sizeof(Datum) * (dim + 1))
+#define CreateStateDatums(dim) palloc_array(Datum, (dim) + 1)
 
 /*
  * Get a half from a message buffer
@@ -513,7 +517,7 @@ halfvec_to_float4(PG_FUNCTION_ARGS)
 	Datum	   *datums;
 	ArrayType  *result;
 
-	datums = (Datum *) palloc(sizeof(Datum) * vec->dim);
+	datums = palloc_array(Datum, vec->dim);
 
 	for (int i = 0; i < vec->dim; i++)
 		datums[i] = Float4GetDatum(HalfToFloat4(vec->x[i]));

src/hnsw.c

@@ -290,11 +290,7 @@ hnswhandler(PG_FUNCTION_ARGS)
 		.amcanparallel = false,
 		.amcanbuildparallel = true,
 		.amcaninclude = false,
-#if PG_VERSION_NUM >= 170000
-		.amusemaintenanceworkmem = true,
-#else
 		.amusemaintenanceworkmem = false,
-#endif
 		.amsummarizing = false,
 		.amparallelvacuumoptions = VACUUM_OPTION_PARALLEL_BULKDEL,
 		.amkeytype = InvalidOid,
@@ -355,11 +351,7 @@ hnswhandler(PG_FUNCTION_ARGS)
 	amroutine->amcanbuildparallel = true;
 #endif
 	amroutine->amcaninclude = false;
-#if PG_VERSION_NUM >= 170000
-	amroutine->amusemaintenanceworkmem = true;
-#else
-	amroutine->amusemaintenanceworkmem = false;
-#endif
+	amroutine->amusemaintenanceworkmem = false; /* not used during VACUUM */
 #if PG_VERSION_NUM >= 160000
 	amroutine->amsummarizing = false;
 #endif

src/hnsw.h

@@ -26,12 +26,6 @@
 typedef Pointer Item;
 #endif
 
-#if PG_VERSION_NUM >= 170000
-#define HnswTidStore TidStore
-#else
-#define HnswTidStore tidhash_hash
-#endif
-
 #define HNSW_MAX_DIM 2000
 #define HNSW_MAX_NNZ 1000
 
@@ -111,6 +105,12 @@ typedef Pointer Item;
 #define SeedRandom(seed) srandom(seed)
 #endif
 
+#if PG_VERSION_NUM < 140006
+#define palloc_object(type) ((type *) palloc(sizeof(type)))
+#define palloc0_object(type) ((type *) palloc0(sizeof(type)))
+#define palloc_array(type, count) ((type *) palloc(sizeof(type) * (count)))
+#endif
+
 #define HnswIsElementTuple(tup) ((tup)->type == HNSW_ELEMENT_TUPLE_TYPE)
 #define HnswIsNeighborTuple(tup) ((tup)->type == HNSW_NEIGHBOR_TUPLE_TYPE)
 
@@ -433,7 +433,7 @@ typedef struct HnswVacuumState
 	HnswSupport support;
 
 	/* Variables */
-	struct HnswTidStore *deleted;
+	struct tidhash_hash *deleting;
 	BufferAccessStrategy bas;
 	HnswNeighborTuple ntup;
 	HnswElementData highestPoint;

src/hnswbuild.c

@@ -719,7 +719,7 @@ InitBuildState(HnswBuildState * buildstate, Relation heap, Relation index, Index
 	/* Get support functions */
 	HnswInitSupport(&buildstate->support, index);
 
-	InitGraph(&buildstate->graphData, NULL, (Size) maintenance_work_mem * 1024L);
+	InitGraph(&buildstate->graphData, NULL, maintenance_work_mem * (Size) 1024);
 	buildstate->graph = &buildstate->graphData;
 	buildstate->ml = HnswGetMl(buildstate->m);
 	buildstate->maxLevel = HnswGetMaxLevel(buildstate->m);
@@ -930,7 +930,7 @@ HnswBeginParallel(HnswBuildState * buildstate, bool isconcurrent, int request)
 	Size		estother;
 	HnswShared *hnswshared;
 	char	   *hnswarea;
-	HnswLeader *hnswleader = (HnswLeader *) palloc0(sizeof(HnswLeader));
+	HnswLeader *hnswleader = palloc0_object(HnswLeader);
 	bool		leaderparticipates = true;
 	int			querylen;
 
@@ -956,7 +956,7 @@ HnswBeginParallel(HnswBuildState * buildstate, bool isconcurrent, int request)
 	/* Leave space for other objects in shared memory */
 	/* Docker has a default limit of 64 MB for shm_size */
 	/* which happens to be the default value of maintenance_work_mem */
-	esthnswarea = maintenance_work_mem * 1024L;
+	esthnswarea = maintenance_work_mem * (Size) 1024;
 	estother = 3 * 1024 * 1024;
 	if (esthnswarea > estother)
 		esthnswarea -= estother;
@@ -1151,7 +1151,7 @@ hnswbuild(Relation heap, Relation index, IndexInfo *indexInfo)
 
 	BuildIndex(heap, index, indexInfo, &buildstate, MAIN_FORKNUM);
 
-	result = (IndexBuildResult *) palloc(sizeof(IndexBuildResult));
+	result = palloc_object(IndexBuildResult);
 	result->heap_tuples = buildstate.reltuples;
 	result->index_tuples = buildstate.indtuples;
 

src/hnswscan.c

@@ -136,7 +136,7 @@ hnswbeginscan(Relation index, int nkeys, int norderbys)
 
 	scan = RelationGetIndexScan(index, nkeys, norderbys);
 
-	so = (HnswScanOpaque) palloc(sizeof(HnswScanOpaqueData));
+	so = palloc_object(HnswScanOpaqueData);
 	so->typeInfo = HnswGetTypeInfo(index);
 
 	/* Set support functions */

src/hnswutils.c

@@ -282,7 +282,7 @@ HnswAddHeapTid(HnswElement element, ItemPointer heaptid)
 HnswElement
 HnswInitElementFromBlock(BlockNumber blkno, OffsetNumber offno)
 {
-	HnswElement element = palloc(sizeof(HnswElementData));
+	HnswElement element = palloc_object(HnswElementData);
 	char	   *base = NULL;
 
 	element->blkno = blkno;
@@ -596,7 +596,7 @@ GetElementDistance(char *base, HnswElement element, HnswQuery * q, HnswSupport *
 static HnswSearchCandidate *
 HnswInitSearchCandidate(char *base, HnswElement element, double distance)
 {
-	HnswSearchCandidate *sc = palloc(sizeof(HnswSearchCandidate));
+	HnswSearchCandidate *sc = palloc_object(HnswSearchCandidate);
 
 	HnswPtrStore(base, sc->element, element);
 	sc->distance = distance;
@@ -831,7 +831,7 @@ HnswSearchLayer(char *base, HnswQuery * q, List *ep, int ef, int lc, Relation in
 	HnswNeighborArray *localNeighborhood = NULL;
 	Size		neighborhoodSize = 0;
 	int			lm = HnswGetLayerM(m, lc);
-	HnswUnvisited *unvisited = palloc(lm * sizeof(HnswUnvisited));
+	HnswUnvisited *unvisited = palloc_array(HnswUnvisited, lm);
 	int			unvisitedLength;
 	bool		inMemory = index == NULL;
 
@@ -1074,7 +1074,7 @@ SelectNeighbors(char *base, List *c, int lm, HnswSupport * support, bool *closer
 	if (list_length(w) <= lm)
 		return w;
 
-	wd = palloc(sizeof(HnswCandidate *) * list_length(w));
+	wd = palloc_array(HnswCandidate *, list_length(w));
 
 	/* Ensure order of candidates is deterministic for closer caching */
 	if (sortCandidates)
@@ -1328,7 +1328,7 @@ HnswFindElementNeighbors(char *base, HnswElement element, HnswElement entryPoint
 		foreach(lc2, w)
 		{
 			HnswSearchCandidate *sc = lfirst(lc2);
-			HnswCandidate *hc = palloc(sizeof(HnswCandidate));
+			HnswCandidate *hc = palloc_object(HnswCandidate);
 
 			hc->element = sc->element;
 			hc->distance = sc->distance;

src/hnswvacuum.c

@@ -10,12 +10,6 @@
 #include "utils/memutils.h"
 #include "utils/rel.h"
 
-#if PG_VERSION_NUM >= 170000
-#include "access/tidstore.h"
-#include "miscadmin.h"
-#include "postmaster/autovacuum.h"
-#endif
-
 #if PG_VERSION_NUM >= 160000
 #include "varatt.h"
 #endif
@@ -25,16 +19,12 @@
 #endif
 
 /*
- * Check if deleted list contains an index TID
+ * Check if deletion list contains an element
  */
 static bool
-DeletedContains(HnswTidStore * deleted, ItemPointer indextid)
+DeletingElement(tidhash_hash * deleting, ItemPointer indextid)
 {
-#if PG_VERSION_NUM >= 170000
-	return TidStoreIsMember(deleted, indextid);
-#else
-	return tidhash_lookup(deleted, *indextid) != NULL;
-#endif
+	return tidhash_lookup(deleting, *indextid) != NULL;
 }
 
 /*
@@ -70,10 +60,6 @@ RemoveHeapTids(HnswVacuumState * vacuumstate)
 		OffsetNumber offno;
 		OffsetNumber maxoffno;
 		bool		updated = false;
-#if PG_VERSION_NUM >= 170000
-		OffsetNumber deletedoffs[MaxOffsetNumber];
-		int			ndeletedoffs = 0;
-#endif
 
 		vacuum_delay_point();
 
@@ -94,6 +80,14 @@ RemoveHeapTids(HnswVacuumState * vacuumstate)
 			if (!HnswIsElementTuple(etup))
 				continue;
 
+			/*
+			 * Skip deleted tuples. It is important they are not added to the
+			 * deletion list to avoid false positives in NeedsUpdated and
+			 * ConfirmRepaired.
+			 */
+			if (etup->deleted)
+				continue;
+
 			if (ItemPointerIsValid(&etup->heaptids[0]))
 			{
 				for (int i = 0; i < HNSW_HEAPTIDS; i++)
@@ -127,18 +121,14 @@ RemoveHeapTids(HnswVacuumState * vacuumstate)
 
 			if (!ItemPointerIsValid(&etup->heaptids[0]))
 			{
-#if PG_VERSION_NUM >= 170000
-				deletedoffs[ndeletedoffs++] = offno;
-#else
-				ItemPointerData ip;
+				ItemPointerData indextid;
 				bool		found;
 
-				/* Add to deleted list */
-				ItemPointerSet(&ip, blkno, offno);
+				/* Add to deletion list */
+				ItemPointerSet(&indextid, blkno, offno);
 
-				tidhash_insert(vacuumstate->deleted, ip, &found);
+				tidhash_insert(vacuumstate->deleting, indextid, &found);
 				Assert(!found);
-#endif
 			}
 			else if (etup->level > highestLevel)
 			{
@@ -167,10 +157,6 @@ RemoveHeapTids(HnswVacuumState * vacuumstate)
 			}
 		}
 
-#if PG_VERSION_NUM >= 170000
-		TidStoreSetBlockOffsets(vacuumstate->deleted, blkno, deletedoffs, ndeletedoffs);
-#endif
-
 		blkno = HnswPageGetOpaque(page)->nextblkno;
 
 		if (updated)
@@ -214,8 +200,8 @@ NeedsUpdated(HnswVacuumState * vacuumstate, HnswElement element)
 		if (!ItemPointerIsValid(indextid))
 			continue;
 
-		/* Check if in deleted list */
-		if (DeletedContains(vacuumstate->deleted, indextid))
+		/* Check if in deletion list */
+		if (DeletingElement(vacuumstate->deleting, indextid))
 		{
 			needsUpdated = true;
 			break;
@@ -224,13 +210,9 @@ NeedsUpdated(HnswVacuumState * vacuumstate, HnswElement element)
 
 	/* Also update if layer 0 is not full */
 	/* This could indicate too many candidates being deleted during insert */
-	if (!needsUpdated)
-	{
-		/* Keep clang-tidy happy */
-		Assert(ntup->count > 0);
-
+	/* There should always be more than zero indextids, but check for safety */
+	if (!needsUpdated && ntup->count > 0)
 		needsUpdated = !ItemPointerIsValid(&ntup->indextids[ntup->count - 1]);
-	}
 
 	UnlockReleaseBuffer(buf);
 
@@ -353,7 +335,7 @@ RepairGraphEntryPoint(HnswVacuumState * vacuumstate)
 
 		ItemPointerSet(&epData, entryPoint->blkno, entryPoint->offno);
 
-		if (DeletedContains(vacuumstate->deleted, &epData))
+		if (DeletingElement(vacuumstate->deleting, &epData))
 		{
 			/*
 			 * Replace the entry point with the highest point. If highest
@@ -439,6 +421,10 @@ RepairGraph(HnswVacuumState * vacuumstate)
 			if (!HnswIsElementTuple(etup))
 				continue;
 
+			/* Skip deleted tuples */
+			if (etup->deleted)
+				continue;
+
 			/* Skip updating neighbors if being deleted */
 			if (!ItemPointerIsValid(&etup->heaptids[0]))
 				continue;
@@ -504,7 +490,7 @@ RepairGraph(HnswVacuumState * vacuumstate)
 		MemoryContextReset(vacuumstate->tmpCtx);
 
 #ifdef HNSW_VACUUM_PROGRESS
-		if (!BlockNumberIsValid(blkno) || ((blkno - HNSW_HEAD_BLKNO) % 1000 == 0 && blkno != HNSW_HEAD_BLKNO))
+		if (!BlockNumberIsValid(blkno) || (blkno - HNSW_HEAD_BLKNO) % 1000 == 0)
 		{
 			BlockNumber totalBlocks = RelationGetNumberOfBlocks(index);
 			BlockNumber currentBlocks = BlockNumberIsValid(blkno) ? blkno : totalBlocks;
@@ -553,6 +539,10 @@ ConfirmRepaired(HnswVacuumState * vacuumstate)
 			if (!HnswIsElementTuple(etup))
 				continue;
 
+			/* Skip deleted tuples */
+			if (etup->deleted)
+				continue;
+
 			/* Skip if being deleted */
 			if (!ItemPointerIsValid(&etup->heaptids[0]))
 				continue;
@@ -583,8 +573,8 @@ ConfirmRepaired(HnswVacuumState * vacuumstate)
 				if (!ItemPointerIsValid(indextid))
 					continue;
 
-				/* Check if in deleted list */
-				if (DeletedContains(vacuumstate->deleted, indextid))
+				/* Check if in deletion list */
+				if (DeletingElement(vacuumstate->deleting, indextid))
 					elog(ERROR, "hnsw graph not repaired");
 			}
 
@@ -610,10 +600,15 @@ MarkDeleted(HnswVacuumState * vacuumstate)
 	BufferAccessStrategy bas = vacuumstate->bas;
 
 	/*
-	 * Wait for index scans to complete. Scans before this point may contain
-	 * tuples about to be deleted. Scans after this point will not, since the
-	 * graph has been repaired.
+	 * Wait for inserts and index scans to complete. Inserts and scans before
+	 * this point may visit tuples about to be deleted. Inserts and scans
+	 * after this point will not, since the graph has been repaired.
 	 */
+	LockPage(index, HNSW_UPDATE_LOCK, ExclusiveLock);
+	UnlockPage(index, HNSW_UPDATE_LOCK, ExclusiveLock);
+
+	ConfirmRepaired(vacuumstate);
+
 	LockPage(index, HNSW_SCAN_LOCK, ExclusiveLock);
 	UnlockPage(index, HNSW_SCAN_LOCK, ExclusiveLock);
 
@@ -742,7 +737,7 @@ InitVacuumState(HnswVacuumState * vacuumstate, IndexVacuumInfo *info, IndexBulkD
 	Relation	index = info->index;
 
 	if (stats == NULL)
-		stats = (IndexBulkDeleteResult *) palloc0(sizeof(IndexBulkDeleteResult));
+		stats = palloc0_object(IndexBulkDeleteResult);
 
 	vacuumstate->index = index;
 	vacuumstate->stats = stats;
@@ -761,11 +756,7 @@ InitVacuumState(HnswVacuumState * vacuumstate, IndexVacuumInfo *info, IndexBulkD
 	HnswGetMetaPageInfo(index, &vacuumstate->m, NULL);
 
 	/* Create hash table */
-#if PG_VERSION_NUM >= 170000
-	vacuumstate->deleted = TidStoreCreateLocal((AmAutoVacuumWorkerProcess() && autovacuum_work_mem != -1) ? autovacuum_work_mem : maintenance_work_mem, true);
-#else
-	vacuumstate->deleted = tidhash_create(CurrentMemoryContext, 256, NULL);
-#endif
+	vacuumstate->deleting = tidhash_create(CurrentMemoryContext, 256, NULL);
 }
 
 /*
@@ -774,11 +765,7 @@ InitVacuumState(HnswVacuumState * vacuumstate, IndexVacuumInfo *info, IndexBulkD
 static void
 FreeVacuumState(HnswVacuumState * vacuumstate)
 {
-#if PG_VERSION_NUM >= 170000
-	TidStoreDestroy(vacuumstate->deleted);
-#else
-	tidhash_destroy(vacuumstate->deleted);
-#endif
+	tidhash_destroy(vacuumstate->deleting);
 	FreeAccessStrategy(vacuumstate->bas);
 	pfree(vacuumstate->ntup);
 	MemoryContextDelete(vacuumstate->tmpCtx);
@@ -801,10 +788,7 @@ hnswbulkdelete(IndexVacuumInfo *info, IndexBulkDeleteResult *stats,
 	/* Pass 2: Repair graph */
 	HnswBench("RepairGraph", RepairGraph(&vacuumstate));
 
-	/* Pass 3: Confirm repaired */
-	HnswBench("ConfirmRepaired", ConfirmRepaired(&vacuumstate));
-
-	/* Pass 4: Mark as deleted */
+	/* Passes 3 and 4: Confirm repaired and mark as deleted */
 	HnswBench("MarkDeleted", MarkDeleted(&vacuumstate));
 
 	FreeVacuumState(&vacuumstate);

src/ivfbuild.c

@@ -152,18 +152,7 @@ SampleRows(IvfflatBuildState * buildstate)
 
 	/* Normalize if needed */
 	if (buildstate->kmeansnormprocinfo != NULL)
-	{
-		VectorArray samples = buildstate->samples;
-
-		for (int i = 0; i < samples->length; i++)
-		{
-			Datum		value = PointerGetDatum(VectorArrayGet(samples, i));
-			Datum		normValue = IvfflatNormValue(buildstate->typeInfo, buildstate->collation, value);
-
-			VectorArraySet(samples, i, DatumGetPointer(normValue));
-			pfree(DatumGetPointer(normValue));
-		}
-	}
+		IvfflatNormVectors(buildstate->typeInfo, buildstate->collation, buildstate->samples, buildstate->tmpCtx);
 }
 
 /*
@@ -399,9 +388,15 @@ InitBuildState(IvfflatBuildState * buildstate, Relation heap, Relation index, In
 
 	buildstate->slot = MakeSingleTupleTableSlot(buildstate->sortdesc, &TTSOpsVirtual);
 
-	/* TODO Ensure within maintenance_work_mem */
-	buildstate->centers = VectorArrayInit(buildstate->lists, buildstate->dimensions, buildstate->typeInfo->itemSize(buildstate->dimensions));
-	buildstate->listInfo = palloc(sizeof(ListInfo) * buildstate->lists);
+	buildstate->memoryUsed = 0;
+	buildstate->itemsize = buildstate->typeInfo->itemSize(buildstate->dimensions);
+
+	buildstate->memoryUsed += VECTOR_ARRAY_SIZE(buildstate->lists, buildstate->itemsize);
+	IvfflatCheckMemoryUsage(buildstate->memoryUsed);
+	buildstate->centers = VectorArrayInit(buildstate->lists, buildstate->dimensions, buildstate->itemsize);
+
+	/* TODO Move allocation to page creation */
+	buildstate->listInfo = palloc_array(ListInfo, buildstate->lists);
 
 	buildstate->tmpCtx = AllocSetContextCreate(CurrentMemoryContext,
 											   "Ivfflat build temporary context",
@@ -409,8 +404,8 @@ InitBuildState(IvfflatBuildState * buildstate, Relation heap, Relation index, In
 
 #ifdef IVFFLAT_KMEANS_DEBUG
 	buildstate->inertia = 0;
-	buildstate->listSums = palloc0(sizeof(double) * buildstate->lists);
-	buildstate->listCounts = palloc0(sizeof(int) * buildstate->lists);
+	buildstate->listSums = palloc0_array(double, buildstate->lists);
+	buildstate->listCounts = palloc0_array(int, buildstate->lists);
 #endif
 
 	buildstate->ivfleader = NULL;
@@ -443,19 +438,27 @@ ComputeCenters(IvfflatBuildState * buildstate)
 
 	pgstat_progress_update_param(PROGRESS_CREATEIDX_SUBPHASE, PROGRESS_IVFFLAT_PHASE_KMEANS);
 
+	/* Skip samples for unlogged table */
+	if (buildstate->heap == NULL)
+		numSamples = 1;
+	else
+	{
+		int64		maxTuples = (int64) RelationGetNumberOfBlocks(buildstate->heap) * MaxHeapTuplesPerPage;
+
 		/* Target 50 samples per list, with at least 10000 samples */
 		/* The number of samples has a large effect on index build time */
 		numSamples = buildstate->lists * 50;
 		if (numSamples < 10000)
 			numSamples = 10000;
 
-	/* Skip samples for unlogged table */
-	if (buildstate->heap == NULL)
-		numSamples = 1;
+		/* Save memory since will not have more than max tuples */
+		numSamples = Max(Min(numSamples, maxTuples), 1);
+	}
 
 	/* Sample rows */
-	/* TODO Ensure within maintenance_work_mem */
-	buildstate->samples = VectorArrayInit(numSamples, buildstate->dimensions, buildstate->centers->itemsize);
+	buildstate->memoryUsed += VECTOR_ARRAY_SIZE(numSamples, buildstate->itemsize);
+	IvfflatCheckMemoryUsage(buildstate->memoryUsed);
+	buildstate->samples = VectorArrayInit(numSamples, buildstate->dimensions, buildstate->itemsize);
 	if (buildstate->heap != NULL)
 	{
 		IvfflatBench("sample rows", SampleRows(buildstate));
@@ -470,7 +473,7 @@ ComputeCenters(IvfflatBuildState * buildstate)
 	}
 
 	/* Calculate centers */
-	IvfflatBench("k-means", IvfflatKmeans(buildstate->index, buildstate->samples, buildstate->centers, buildstate->typeInfo));
+	IvfflatBench("k-means", IvfflatKmeans(buildstate->index, buildstate->samples, buildstate->centers, buildstate->typeInfo, buildstate->memoryUsed));
 
 	/* Free samples before we allocate more memory */
 	VectorArrayFree(buildstate->samples);
@@ -659,7 +662,7 @@ IvfflatParallelScanAndSort(IvfflatSpool * ivfspool, IvfflatShared * ivfshared, S
 	IndexInfo  *indexInfo;
 
 	/* Initialize local tuplesort coordination state */
-	coordinate = palloc0(sizeof(SortCoordinateData));
+	coordinate = palloc0_object(SortCoordinateData);
 	coordinate->isWorker = true;
 	coordinate->nParticipants = -1;
 	coordinate->sharedsort = sharedsort;
@@ -754,7 +757,7 @@ IvfflatParallelBuildMain(dsm_segment *seg, shm_toc *toc)
 	indexRel = index_open(ivfshared->indexrelid, indexLockmode);
 
 	/* Initialize worker's own spool */
-	ivfspool = (IvfflatSpool *) palloc0(sizeof(IvfflatSpool));
+	ivfspool = palloc0_object(IvfflatSpool);
 	ivfspool->heap = heapRel;
 	ivfspool->index = indexRel;
 
@@ -809,7 +812,7 @@ IvfflatLeaderParticipateAsWorker(IvfflatBuildState * buildstate)
 	int			sortmem;
 
 	/* Allocate memory and initialize private spool */
-	leaderworker = (IvfflatSpool *) palloc0(sizeof(IvfflatSpool));
+	leaderworker = palloc0_object(IvfflatSpool);
 	leaderworker->heap = buildstate->heap;
 	leaderworker->index = buildstate->index;
 
@@ -835,7 +838,7 @@ IvfflatBeginParallel(IvfflatBuildState * buildstate, bool isconcurrent, int requ
 	IvfflatShared *ivfshared;
 	Sharedsort *sharedsort;
 	char	   *ivfcenters;
-	IvfflatLeader *ivfleader = (IvfflatLeader *) palloc0(sizeof(IvfflatLeader));
+	IvfflatLeader *ivfleader = palloc0_object(IvfflatLeader);
 	bool		leaderparticipates = true;
 	int			querylen;
 
@@ -984,7 +987,7 @@ AssignTuples(IvfflatBuildState * buildstate)
 	/* Set up coordination state if at least one worker launched */
 	if (buildstate->ivfleader)
 	{
-		coordinate = (SortCoordinate) palloc0(sizeof(SortCoordinateData));
+		coordinate = palloc0_object(SortCoordinateData);
 		coordinate->isWorker = false;
 		coordinate->nParticipants = buildstate->ivfleader->nparticipanttuplesorts;
 		coordinate->sharedsort = buildstate->ivfleader->sharedsort;
@@ -1069,7 +1072,7 @@ ivfflatbuild(Relation heap, Relation index, IndexInfo *indexInfo)
 
 	BuildIndex(heap, index, indexInfo, &buildstate, MAIN_FORKNUM);
 
-	result = (IndexBuildResult *) palloc(sizeof(IndexBuildResult));
+	result = palloc_object(IndexBuildResult);
 	result->heap_tuples = buildstate.reltuples;
 	result->index_tuples = buildstate.indtuples;
 

src/ivfflat.h

@@ -89,6 +89,13 @@ typedef Pointer Item;
 #define SeedRandom(seed) srandom(seed)
 #endif
 
+#if PG_VERSION_NUM < 140006
+#define palloc_object(type) ((type *) palloc(sizeof(type)))
+#define palloc0_object(type) ((type *) palloc0(sizeof(type)))
+#define palloc_array(type, count) ((type *) palloc(sizeof(type) * (count)))
+#define palloc0_array(type, count) ((type *) palloc0(sizeof(type) * (count)))
+#endif
+
 /* Variables */
 extern int	ivfflat_probes;
 extern int	ivfflat_iterative_scan;
@@ -204,6 +211,7 @@ typedef struct IvfflatBuildState
 	VectorArray samples;
 	VectorArray centers;
 	ListInfo   *listInfo;
+	Size		itemsize;
 
 #ifdef IVFFLAT_KMEANS_DEBUG
 	double		inertia;
@@ -223,6 +231,7 @@ typedef struct IvfflatBuildState
 	TupleTableSlot *slot;
 
 	/* Memory */
+	Size		memoryUsed;
 	MemoryContext tmpCtx;
 
 	/* Parallel builds */
@@ -303,22 +312,32 @@ typedef IvfflatScanOpaqueData * IvfflatScanOpaque;
 static inline Pointer
 VectorArrayGet(VectorArray arr, int offset)
 {
+	if (offset < 0 || offset >= arr->maxlen)
+		elog(ERROR, "safety check failed");
+
 	return ((char *) arr->items) + (offset * arr->itemsize);
 }
 
 static inline void
 VectorArraySet(VectorArray arr, int offset, Pointer val)
 {
-	memcpy(VectorArrayGet(arr, offset), val, VARSIZE_ANY(val));
+	Size		size = VARSIZE_ANY(val);
+
+	if (size > arr->itemsize)
+		elog(ERROR, "safety check failed");
+
+	memcpy(VectorArrayGet(arr, offset), val, size);
 }
 
 /* Methods */
 VectorArray VectorArrayInit(int maxlen, int dimensions, Size itemsize);
 void		VectorArrayFree(VectorArray arr);
-void		IvfflatKmeans(Relation index, VectorArray samples, VectorArray centers, const IvfflatTypeInfo * typeInfo);
+void		IvfflatKmeans(Relation index, VectorArray samples, VectorArray centers, const IvfflatTypeInfo * typeInfo, Size memoryUsed);
 FmgrInfo   *IvfflatOptionalProcInfo(Relation index, uint16 procnum);
 Datum		IvfflatNormValue(const IvfflatTypeInfo * typeInfo, Oid collation, Datum value);
 bool		IvfflatCheckNorm(FmgrInfo *procinfo, Oid collation, Datum value);
+void		IvfflatNormVectors(const IvfflatTypeInfo * typeInfo, Oid collation, VectorArray arr, MemoryContext tmpCtx);
+void		IvfflatCheckMemoryUsage(Size totalSize);
 int			IvfflatGetLists(Relation index);
 void		IvfflatGetMetaPageInfo(Relation index, int *lists, int *dimensions);
 void		IvfflatUpdateList(Relation index, ListInfo listInfo, BlockNumber insertPage, BlockNumber originalInsertPage, BlockNumber startPage, ForkNumber forkNum);

src/ivfkmeans.c

@@ -26,7 +26,7 @@ InitCenters(Relation index, VectorArray samples, VectorArray centers, float *low
 	FmgrInfo   *procinfo;
 	Oid			collation;
 	int64		j;
-	float	   *weight = palloc(samples->length * sizeof(float));
+	float	   *weight = palloc_array(float, samples->length);
 	int			numCenters = centers->maxlen;
 	int			numSamples = samples->length;
 
@@ -99,22 +99,8 @@ NormCenters(const IvfflatTypeInfo * typeInfo, Oid collation, VectorArray centers
 	MemoryContext normCtx = AllocSetContextCreate(CurrentMemoryContext,
 												  "Ivfflat norm temporary context",
 												  ALLOCSET_DEFAULT_SIZES);
-	MemoryContext oldCtx = MemoryContextSwitchTo(normCtx);
 
-	for (int j = 0; j < centers->length; j++)
-	{
-		Datum		center = PointerGetDatum(VectorArrayGet(centers, j));
-		Datum		newCenter = IvfflatNormValue(typeInfo, collation, center);
-		Size		size = VARSIZE_ANY(DatumGetPointer(newCenter));
-
-		if (size > centers->itemsize)
-			elog(ERROR, "safety check failed");
-
-		memcpy(DatumGetPointer(center), DatumGetPointer(newCenter), size);
-		MemoryContextReset(normCtx);
-	}
-
-	MemoryContextSwitchTo(oldCtx);
+	IvfflatNormVectors(typeInfo, collation, centers, normCtx);
 	MemoryContextDelete(normCtx);
 }
 
@@ -127,7 +113,7 @@ RandomCenters(Relation index, VectorArray centers, const IvfflatTypeInfo * typeI
 	int			dimensions = centers->dim;
 	FmgrInfo   *normprocinfo = IvfflatOptionalProcInfo(index, IVFFLAT_KMEANS_NORM_PROC);
 	Oid			collation = index->rd_indcollation[0];
-	float	   *x = (float *) palloc(sizeof(float) * dimensions);
+	float	   *x = palloc_array(float, dimensions);
 
 	/* Fill with random data */
 	while (centers->length < centers->maxlen)
@@ -258,7 +244,7 @@ ComputeNewCenters(VectorArray samples, float *agg, VectorArray newCenters, int *
  * https://www.aaai.org/Papers/ICML/2003/ICML03-022.pdf
  */
 static void
-ElkanKmeans(Relation index, VectorArray samples, VectorArray centers, const IvfflatTypeInfo * typeInfo)
+ElkanKmeans(Relation index, VectorArray samples, VectorArray centers, const IvfflatTypeInfo * typeInfo, Size memoryUsed)
 {
 	FmgrInfo   *procinfo;
 	FmgrInfo   *normprocinfo;
@@ -277,8 +263,6 @@ ElkanKmeans(Relation index, VectorArray samples, VectorArray centers, const Ivff
 	float	   *newcdist;
 
 	/* Calculate allocation sizes */
-	Size		samplesSize = VECTOR_ARRAY_SIZE(samples->maxlen, samples->itemsize);
-	Size		centersSize = VECTOR_ARRAY_SIZE(centers->maxlen, centers->itemsize);
 	Size		newCentersSize = VECTOR_ARRAY_SIZE(numCenters, centers->itemsize);
 	Size		aggSize = sizeof(float) * (int64) numCenters * dimensions;
 	Size		centerCountsSize = sizeof(int) * numCenters;
@@ -290,18 +274,13 @@ ElkanKmeans(Relation index, VectorArray samples, VectorArray centers, const Ivff
 	Size		newcdistSize = sizeof(float) * numCenters;
 
 	/* Calculate total size */
-	Size		totalSize = samplesSize + centersSize + newCentersSize + aggSize + centerCountsSize + closestCentersSize + lowerBoundSize + upperBoundSize + sSize + halfcdistSize + newcdistSize;
+	Size		totalSize = memoryUsed + newCentersSize + aggSize + centerCountsSize + closestCentersSize + lowerBoundSize + upperBoundSize + sSize + halfcdistSize + newcdistSize;
 
 	/* Check memory requirements */
-	/* Add one to error message to ceil */
-	if (totalSize > (Size) maintenance_work_mem * 1024L)
-		ereport(ERROR,
-				(errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
-				 errmsg("memory required is %zu MB, maintenance_work_mem is %d MB",
-						totalSize / (1024 * 1024) + 1, maintenance_work_mem / 1024)));
+	IvfflatCheckMemoryUsage(totalSize);
 
 	/* Ensure indexing does not overflow */
-	if (numCenters * numCenters > INT_MAX)
+	if (numCenters > INT_MAX / numCenters)
 		elog(ERROR, "Indexing overflow detected. Please report a bug.");
 
 	/* Set support functions */
@@ -501,7 +480,7 @@ ElkanKmeans(Relation index, VectorArray samples, VectorArray centers, const Ivff
 static void
 CheckElements(VectorArray centers, const IvfflatTypeInfo * typeInfo)
 {
-	float	   *scratch = palloc(sizeof(float) * centers->dim);
+	float	   *scratch = palloc_array(float, centers->dim);
 
 	for (int i = 0; i < centers->length; i++)
 	{
@@ -562,7 +541,7 @@ CheckCenters(Relation index, VectorArray centers, const IvfflatTypeInfo * typeIn
  * We use spherical k-means for inner product and cosine
  */
 void
-IvfflatKmeans(Relation index, VectorArray samples, VectorArray centers, const IvfflatTypeInfo * typeInfo)
+IvfflatKmeans(Relation index, VectorArray samples, VectorArray centers, const IvfflatTypeInfo * typeInfo, Size memoryUsed)
 {
 	MemoryContext kmeansCtx = AllocSetContextCreate(CurrentMemoryContext,
 													"Ivfflat kmeans temporary context",
@@ -572,7 +551,7 @@ IvfflatKmeans(Relation index, VectorArray samples, VectorArray centers, const Iv
 	if (samples->length == 0)
 		RandomCenters(index, centers, typeInfo);
 	else
-		ElkanKmeans(index, samples, centers, typeInfo);
+		ElkanKmeans(index, samples, centers, typeInfo, memoryUsed);
 
 	CheckCenters(index, centers, typeInfo);
 

src/ivfscan.c

@@ -276,12 +276,13 @@ ivfflatbeginscan(Relation index, int nkeys, int norderbys)
 	if (maxProbes > lists)
 		maxProbes = lists;
 
-	so = (IvfflatScanOpaque) palloc(sizeof(IvfflatScanOpaqueData));
+	so = palloc_object(IvfflatScanOpaqueData);
 	so->typeInfo = IvfflatGetTypeInfo(index);
 	so->first = true;
 	so->probes = probes;
 	so->maxProbes = maxProbes;
 	so->dimensions = dimensions;
+	so->value = PointerGetDatum(NULL);
 
 	/* Set support functions */
 	so->procinfo = index_getprocinfo(index, 1, IVFFLAT_DISTANCE_PROC);
@@ -317,9 +318,9 @@ ivfflatbeginscan(Relation index, int nkeys, int norderbys)
 	so->bas = GetAccessStrategy(BAS_BULKREAD);
 
 	so->listQueue = pairingheap_allocate(CompareLists, scan);
-	so->listPages = palloc(maxProbes * sizeof(BlockNumber));
+	so->listPages = palloc_array(BlockNumber, maxProbes);
 	so->listIndex = 0;
-	so->lists = palloc(maxProbes * sizeof(IvfflatScanList));
+	so->lists = palloc_array(IvfflatScanList, maxProbes);
 
 	MemoryContextSwitchTo(oldCtx);
 
@@ -340,6 +341,12 @@ ivfflatrescan(IndexScanDesc scan, ScanKey keys, int nkeys, ScanKey orderbys, int
 	pairingheap_reset(so->listQueue);
 	so->listIndex = 0;
 
+	if (so->normprocinfo != NULL && DatumGetPointer(so->value) != NULL)
+	{
+		pfree(DatumGetPointer(so->value));
+		so->value = PointerGetDatum(NULL);
+	}
+
 	if (keys && scan->numberOfKeys > 0)
 		memmove(scan->keyData, keys, scan->numberOfKeys * sizeof(ScanKeyData));
 

src/ivfutils.c

@@ -6,7 +6,9 @@
 #include "halfutils.h"
 #include "halfvec.h"
 #include "ivfflat.h"
+#include "miscadmin.h"
 #include "storage/bufmgr.h"
+#include "utils/memutils.h"
 #include "utils/relcache.h"
 #include "utils/varbit.h"
 #include "vector.h"
@@ -21,11 +23,15 @@
 VectorArray
 VectorArrayInit(int maxlen, int dimensions, Size itemsize)
 {
-	VectorArray res = palloc(sizeof(VectorArrayData));
+	VectorArray res;
+
+	if (maxlen < 1 || dimensions < 1 || itemsize == 0)
+		elog(ERROR, "cannot create vector array");
 
 	/* Ensure items are aligned to prevent UB */
 	itemsize = MAXALIGN(itemsize);
 
+	res = palloc_object(VectorArrayData);
 	res->length = 0;
 	res->maxlen = maxlen;
 	res->dim = dimensions;
@@ -88,6 +94,40 @@ IvfflatCheckNorm(FmgrInfo *procinfo, Oid collation, Datum value)
 	return DatumGetFloat8(FunctionCall1Coll(procinfo, collation, value)) > 0;
 }
 
+/*
+ * Normalize vectors
+ */
+void
+IvfflatNormVectors(const IvfflatTypeInfo * typeInfo, Oid collation, VectorArray arr, MemoryContext tmpCtx)
+{
+	MemoryContext oldCtx = MemoryContextSwitchTo(tmpCtx);
+
+	for (int i = 0; i < arr->length; i++)
+	{
+		Datum		value = PointerGetDatum(VectorArrayGet(arr, i));
+		Datum		newValue = IvfflatNormValue(typeInfo, collation, value);
+
+		VectorArraySet(arr, i, DatumGetPointer(newValue));
+		MemoryContextReset(tmpCtx);
+	}
+
+	MemoryContextSwitchTo(oldCtx);
+}
+
+/*
+ * Check memory usage
+ */
+void
+IvfflatCheckMemoryUsage(Size totalSize)
+{
+	/* Add one to error message to ceil */
+	if (totalSize > maintenance_work_mem * (Size) 1024)
+		ereport(ERROR,
+				(errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
+				 errmsg("memory required is %zu MB, maintenance_work_mem is %d MB",
+						totalSize / (1024 * 1024) + 1, maintenance_work_mem / 1024)));
+}
+
 /*
  * New buffer
  */

src/ivfvacuum.c

@@ -24,7 +24,7 @@ ivfflatbulkdelete(IndexVacuumInfo *info, IndexBulkDeleteResult *stats,
 	BufferAccessStrategy bas = GetAccessStrategy(BAS_BULKREAD);
 
 	if (stats == NULL)
-		stats = (IndexBulkDeleteResult *) palloc0(sizeof(IndexBulkDeleteResult));
+		stats = palloc0_object(IndexBulkDeleteResult);
 
 	/* Iterate over list pages */
 	while (BlockNumberIsValid(blkno))

src/sparsevec.c

@@ -26,6 +26,10 @@
 #include "parser/scansup.h"
 #endif
 
+#if PG_VERSION_NUM < 140006
+#define palloc_array(type, count) ((type *) palloc(sizeof(type) * (count)))
+#endif
+
 typedef struct SparseInputElement
 {
 	int32		index;
@@ -223,7 +227,7 @@ sparsevec_in(PG_FUNCTION_ARGS)
 				(errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
 				 errmsg("sparsevec cannot have more than %d non-zero elements", SPARSEVEC_MAX_NNZ)));
 
-	elements = palloc(maxNnz * sizeof(SparseInputElement));
+	elements = palloc_array(SparseInputElement, maxNnz);
 
 	pt = lit;
 
@@ -614,6 +618,7 @@ vector_to_sparsevec(PG_FUNCTION_ARGS)
 			nnz++;
 	}
 
+	CheckNnz(nnz, dim);
 	result = InitSparseVector(dim, nnz);
 	values = SPARSEVEC_VALUES(result);
 	for (int i = 0; i < dim; i++)
@@ -657,6 +662,7 @@ halfvec_to_sparsevec(PG_FUNCTION_ARGS)
 			nnz++;
 	}
 
+	CheckNnz(nnz, dim);
 	result = InitSparseVector(dim, nnz);
 	values = SPARSEVEC_VALUES(result);
 	for (int i = 0; i < dim; i++)
@@ -745,6 +751,7 @@ array_to_sparsevec(PG_FUNCTION_ARGS)
 				 errmsg("unsupported array type")));
 	}
 
+	CheckNnz(nnz, nelemsp);
 	result = InitSparseVector(nelemsp, nnz);
 	values = SPARSEVEC_VALUES(result);
 

src/vector.c

@@ -30,8 +30,12 @@
 #include "parser/scansup.h"
 #endif
 
+#if PG_VERSION_NUM < 140006
+#define palloc_array(type, count) ((type *) palloc(sizeof(type) * (count)))
+#endif
+
 #define STATE_DIMS(x) (ARR_DIMS(x)[0] - 1)
-#define CreateStateDatums(dim) palloc(sizeof(Datum) * (dim + 1))
+#define CreateStateDatums(dim) palloc_array(Datum, (dim) + 1)
 
 #if defined(USE_TARGET_CLONES) && !defined(__FMA__)
 #define VECTOR_TARGET_CLONES __attribute__((target_clones("default", "fma")))
@@ -40,7 +44,7 @@
 #endif
 
 #if PG_VERSION_NUM >= 180000
-PG_MODULE_MAGIC_EXT(.name = "vector", .version = "0.8.2");
+PG_MODULE_MAGIC_EXT(.name = "vector", .version = "0.8.5");
 #else
 PG_MODULE_MAGIC;
 #endif
@@ -516,7 +520,7 @@ vector_to_float4(PG_FUNCTION_ARGS)
 	Datum	   *datums;
 	ArrayType  *result;
 
-	datums = (Datum *) palloc(sizeof(Datum) * vec->dim);
+	datums = palloc_array(Datum, vec->dim);
 
 	for (int i = 0; i < vec->dim; i++)
 		datums[i] = Float4GetDatum(vec->x[i]);

test/expected/cast.out

@@ -268,6 +268,10 @@ SELECT array_agg(n)::vector FROM generate_series(1, 16001) n;
 ERROR:  vector cannot have more than 16000 dimensions
 SELECT array_to_vector(array_agg(n), 16001, false) FROM generate_series(1, 16001) n;
 ERROR:  vector cannot have more than 16000 dimensions
+SELECT array_agg(n)::halfvec FROM generate_series(1, 16001) n;
+ERROR:  halfvec cannot have more than 16000 dimensions
+SELECT array_agg(n)::sparsevec FROM generate_series(1, 16001) n;
+ERROR:  sparsevec cannot have more than 16000 non-zero elements
 -- ensure no error
 SELECT ARRAY[1,2,3] = ARRAY[1,2,3];
  ?column? 

test/expected/hnsw_bit.out

@@ -49,3 +49,11 @@ CREATE INDEX ON t USING hnsw ((val::bit(3)) bit_hamming_ops);
 CREATE INDEX ON t USING hnsw ((val::bit(64001)) bit_hamming_ops);
 ERROR:  column cannot have more than 64000 dimensions for hnsw index
 DROP TABLE t;
+-- dimensions
+CREATE TABLE t (val bit(64000));
+CREATE INDEX ON t USING hnsw (val bit_hamming_ops);
+DROP TABLE t;
+CREATE TABLE t (val bit(64001));
+CREATE INDEX ON t USING hnsw (val bit_hamming_ops);
+ERROR:  column cannot have more than 64000 dimensions for hnsw index
+DROP TABLE t;

test/expected/hnsw_halfvec.out

@@ -100,3 +100,11 @@ SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <+> (SELECT NULL::halfvec)) t
 (1 row)
 
 DROP TABLE t;
+-- dimensions
+CREATE TABLE t (val halfvec(4000));
+CREATE INDEX ON t USING hnsw (val halfvec_l2_ops);
+DROP TABLE t;
+CREATE TABLE t (val halfvec(4001));
+CREATE INDEX ON t USING hnsw (val halfvec_l2_ops);
+ERROR:  column cannot have more than 4000 dimensions for hnsw index
+DROP TABLE t;

test/expected/hnsw_vector.out

@@ -78,6 +78,14 @@ SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <=> (SELECT NULL::vector)) t2
      3
 (1 row)
 
+SELECT * FROM t CROSS JOIN LATERAL (SELECT * FROM t t2 ORDER BY val <=> t.val LIMIT 1) t2 WHERE t.val != '[0,0,0]' ORDER BY t.val;
+   val   |   val   
+---------+---------
+ [1,1,1] | [1,1,1]
+ [1,2,3] | [1,2,3]
+ [1,2,4] | [1,2,4]
+(3 rows)
+
 DROP TABLE t;
 -- L1
 CREATE TABLE t (val vector(3));
@@ -161,6 +169,7 @@ ERROR:  value 1001 out of bounds for option "ef_construction"
 DETAIL:  Valid values are between "4" and "1000".
 CREATE INDEX ON t USING hnsw (val vector_l2_ops) WITH (m = 16, ef_construction = 31);
 ERROR:  ef_construction must be greater than or equal to 2 * m
+DROP TABLE t;
 SHOW hnsw.ef_search;
  hnsw.ef_search 
 ----------------
@@ -198,4 +207,11 @@ 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)
+-- dimensions
+CREATE TABLE t (val vector(2000));
+CREATE INDEX ON t USING hnsw (val vector_l2_ops);
+DROP TABLE t;
+CREATE TABLE t (val vector(2001));
+CREATE INDEX ON t USING hnsw (val vector_l2_ops);
+ERROR:  column cannot have more than 2000 dimensions for hnsw index
 DROP TABLE t;

test/expected/ivfflat_bit.out

@@ -35,3 +35,32 @@ NOTICE:  ivfflat index created with little data
 DETAIL:  This will cause low recall.
 HINT:  Drop the index until the table has more data.
 DROP TABLE t;
+-- dimensions
+CREATE TABLE t (val bit(64000));
+CREATE INDEX ON t USING ivfflat (val bit_hamming_ops);
+NOTICE:  ivfflat index created with little data
+DETAIL:  This will cause low recall.
+HINT:  Drop the index until the table has more data.
+DROP TABLE t;
+CREATE TABLE t (val bit(64001));
+CREATE INDEX ON t USING ivfflat (val bit_hamming_ops);
+ERROR:  column cannot have more than 64000 dimensions for ivfflat index
+DROP TABLE t;
+-- memory
+SET maintenance_work_mem = '1MB';
+CREATE TABLE t (val bit(64000));
+CREATE INDEX ON t USING ivfflat (val bit_hamming_ops);
+NOTICE:  ivfflat index created with little data
+DETAIL:  This will cause low recall.
+HINT:  Drop the index until the table has more data.
+DROP TABLE t;
+RESET maintenance_work_mem;
+SET maintenance_work_mem = '29MB';
+CREATE TABLE t (val bit(64000));
+INSERT INTO t (val) VALUES (B'0'::bit(64000));
+CREATE INDEX ON t USING ivfflat (val bit_hamming_ops);
+NOTICE:  ivfflat index created with little data
+DETAIL:  This will cause low recall.
+HINT:  Drop the index until the table has more data.
+DROP TABLE t;
+RESET maintenance_work_mem;

test/expected/ivfflat_halfvec.out

@@ -82,3 +82,32 @@ SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <=> (SELECT NULL::halfvec)) t
 (1 row)
 
 DROP TABLE t;
+-- dimensions
+CREATE TABLE t (val halfvec(4000));
+CREATE INDEX ON t USING ivfflat (val halfvec_l2_ops);
+NOTICE:  ivfflat index created with little data
+DETAIL:  This will cause low recall.
+HINT:  Drop the index until the table has more data.
+DROP TABLE t;
+CREATE TABLE t (val halfvec(4001));
+CREATE INDEX ON t USING ivfflat (val halfvec_l2_ops);
+ERROR:  column cannot have more than 4000 dimensions for ivfflat index
+DROP TABLE t;
+-- memory
+SET maintenance_work_mem = '1MB';
+CREATE TABLE t (val halfvec(4000));
+CREATE INDEX ON t USING ivfflat (val halfvec_l2_ops);
+NOTICE:  ivfflat index created with little data
+DETAIL:  This will cause low recall.
+HINT:  Drop the index until the table has more data.
+DROP TABLE t;
+RESET maintenance_work_mem;
+SET maintenance_work_mem = '6MB';
+CREATE TABLE t (val halfvec(4000));
+INSERT INTO t (val) VALUES (array_fill(0, ARRAY[4000]));
+CREATE INDEX ON t USING ivfflat (val halfvec_l2_ops);
+NOTICE:  ivfflat index created with little data
+DETAIL:  This will cause low recall.
+HINT:  Drop the index until the table has more data.
+DROP TABLE t;
+RESET maintenance_work_mem;

test/expected/ivfflat_vector.out

@@ -81,6 +81,14 @@ SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <=> (SELECT NULL::vector)) t2
      3
 (1 row)
 
+SELECT * FROM t CROSS JOIN LATERAL (SELECT * FROM t t2 ORDER BY val <=> t.val LIMIT 1) t2 WHERE t.val != '[0,0,0]' ORDER BY t.val;
+   val   |   val   
+---------+---------
+ [1,1,1] | [1,1,1]
+ [1,2,3] | [1,2,3]
+ [1,2,4] | [1,2,4]
+(3 rows)
+
 DROP TABLE t;
 -- iterative
 CREATE TABLE t (val vector(3));
@@ -143,6 +151,7 @@ DETAIL:  Valid values are between "1" and "32768".
 CREATE INDEX ON t USING ivfflat (val vector_l2_ops) WITH (lists = 32769);
 ERROR:  value 32769 out of bounds for option "lists"
 DETAIL:  Valid values are between "1" and "32768".
+DROP TABLE t;
 SHOW ivfflat.probes;
  ivfflat.probes 
 ----------------
@@ -172,4 +181,32 @@ SET ivfflat.max_probes = 0;
 ERROR:  0 is outside the valid range for parameter "ivfflat.max_probes" (1 .. 32768)
 SET ivfflat.max_probes = 32769;
 ERROR:  32769 is outside the valid range for parameter "ivfflat.max_probes" (1 .. 32768)
+-- dimensions
+CREATE TABLE t (val vector(2000));
+CREATE INDEX ON t USING ivfflat (val vector_l2_ops);
+NOTICE:  ivfflat index created with little data
+DETAIL:  This will cause low recall.
+HINT:  Drop the index until the table has more data.
 DROP TABLE t;
+CREATE TABLE t (val vector(2001));
+CREATE INDEX ON t USING ivfflat (val vector_l2_ops);
+ERROR:  column cannot have more than 2000 dimensions for ivfflat index
+DROP TABLE t;
+-- memory
+SET maintenance_work_mem = '1MB';
+CREATE TABLE t (val vector(2000));
+CREATE INDEX ON t USING ivfflat (val vector_l2_ops);
+NOTICE:  ivfflat index created with little data
+DETAIL:  This will cause low recall.
+HINT:  Drop the index until the table has more data.
+DROP TABLE t;
+RESET maintenance_work_mem;
+SET maintenance_work_mem = '5MB';
+CREATE TABLE t (val vector(2000));
+INSERT INTO t (val) VALUES (array_fill(0, ARRAY[2000]));
+CREATE INDEX ON t USING ivfflat (val vector_l2_ops);
+NOTICE:  ivfflat index created with little data
+DETAIL:  This will cause low recall.
+HINT:  Drop the index until the table has more data.
+DROP TABLE t;
+RESET maintenance_work_mem;

test/sql/cast.sql

@@ -76,6 +76,8 @@ SELECT '{{1}}'::real[]::sparsevec;
 
 SELECT array_agg(n)::vector FROM generate_series(1, 16001) n;
 SELECT array_to_vector(array_agg(n), 16001, false) FROM generate_series(1, 16001) n;
+SELECT array_agg(n)::halfvec FROM generate_series(1, 16001) n;
+SELECT array_agg(n)::sparsevec FROM generate_series(1, 16001) n;
 
 -- ensure no error
 SELECT ARRAY[1,2,3] = ARRAY[1,2,3];

test/sql/hnsw_bit.sql

@@ -33,3 +33,13 @@ CREATE INDEX ON t USING hnsw (val bit_hamming_ops);
 CREATE INDEX ON t USING hnsw ((val::bit(3)) bit_hamming_ops);
 CREATE INDEX ON t USING hnsw ((val::bit(64001)) bit_hamming_ops);
 DROP TABLE t;
+
+-- dimensions
+
+CREATE TABLE t (val bit(64000));
+CREATE INDEX ON t USING hnsw (val bit_hamming_ops);
+DROP TABLE t;
+
+CREATE TABLE t (val bit(64001));
+CREATE INDEX ON t USING hnsw (val bit_hamming_ops);
+DROP TABLE t;

test/sql/hnsw_halfvec.sql

@@ -56,3 +56,13 @@ SELECT * FROM t ORDER BY val <+> '[3,3,3]';
 SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <+> (SELECT NULL::halfvec)) t2;
 
 DROP TABLE t;
+
+-- dimensions
+
+CREATE TABLE t (val halfvec(4000));
+CREATE INDEX ON t USING hnsw (val halfvec_l2_ops);
+DROP TABLE t;
+
+CREATE TABLE t (val halfvec(4001));
+CREATE INDEX ON t USING hnsw (val halfvec_l2_ops);
+DROP TABLE t;

test/sql/hnsw_vector.sql

@@ -41,6 +41,7 @@ INSERT INTO t (val) VALUES ('[1,2,4]');
 SELECT * FROM t ORDER BY val <=> '[3,3,3]';
 SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <=> '[0,0,0]') t2;
 SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <=> (SELECT NULL::vector)) t2;
+SELECT * FROM t CROSS JOIN LATERAL (SELECT * FROM t t2 ORDER BY val <=> t.val LIMIT 1) t2 WHERE t.val != '[0,0,0]' ORDER BY t.val;
 
 DROP TABLE t;
 
@@ -95,23 +96,28 @@ CREATE INDEX ON t USING hnsw (val vector_l2_ops) WITH (m = 101);
 CREATE INDEX ON t USING hnsw (val vector_l2_ops) WITH (ef_construction = 3);
 CREATE INDEX ON t USING hnsw (val vector_l2_ops) WITH (ef_construction = 1001);
 CREATE INDEX ON t USING hnsw (val vector_l2_ops) WITH (m = 16, ef_construction = 31);
+DROP TABLE t;
 
 SHOW hnsw.ef_search;
-
 SET hnsw.ef_search = 0;
 SET hnsw.ef_search = 1001;
 
 SHOW hnsw.iterative_scan;
-
 SET hnsw.iterative_scan = on;
 
 SHOW hnsw.max_scan_tuples;
-
 SET hnsw.max_scan_tuples = 0;
 
 SHOW hnsw.scan_mem_multiplier;
-
 SET hnsw.scan_mem_multiplier = 0;
 SET hnsw.scan_mem_multiplier = 1001;
 
+-- dimensions
+
+CREATE TABLE t (val vector(2000));
+CREATE INDEX ON t USING hnsw (val vector_l2_ops);
+DROP TABLE t;
+
+CREATE TABLE t (val vector(2001));
+CREATE INDEX ON t USING hnsw (val vector_l2_ops);
 DROP TABLE t;

test/sql/ivfflat_bit.sql

@@ -21,3 +21,28 @@ CREATE INDEX ON t USING ivfflat ((val::bit(3)) bit_hamming_ops) WITH (lists = 1)
 CREATE INDEX ON t USING ivfflat ((val::bit(64001)) bit_hamming_ops) WITH (lists = 1);
 CREATE INDEX ON t USING ivfflat ((val::bit(2)) bit_hamming_ops) WITH (lists = 5);
 DROP TABLE t;
+
+-- dimensions
+
+CREATE TABLE t (val bit(64000));
+CREATE INDEX ON t USING ivfflat (val bit_hamming_ops);
+DROP TABLE t;
+
+CREATE TABLE t (val bit(64001));
+CREATE INDEX ON t USING ivfflat (val bit_hamming_ops);
+DROP TABLE t;
+
+-- memory
+
+SET maintenance_work_mem = '1MB';
+CREATE TABLE t (val bit(64000));
+CREATE INDEX ON t USING ivfflat (val bit_hamming_ops);
+DROP TABLE t;
+RESET maintenance_work_mem;
+
+SET maintenance_work_mem = '29MB';
+CREATE TABLE t (val bit(64000));
+INSERT INTO t (val) VALUES (B'0'::bit(64000));
+CREATE INDEX ON t USING ivfflat (val bit_hamming_ops);
+DROP TABLE t;
+RESET maintenance_work_mem;

test/sql/ivfflat_halfvec.sql

@@ -43,3 +43,28 @@ SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <=> '[0,0,0]') t2;
 SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <=> (SELECT NULL::halfvec)) t2;
 
 DROP TABLE t;
+
+-- dimensions
+
+CREATE TABLE t (val halfvec(4000));
+CREATE INDEX ON t USING ivfflat (val halfvec_l2_ops);
+DROP TABLE t;
+
+CREATE TABLE t (val halfvec(4001));
+CREATE INDEX ON t USING ivfflat (val halfvec_l2_ops);
+DROP TABLE t;
+
+-- memory
+
+SET maintenance_work_mem = '1MB';
+CREATE TABLE t (val halfvec(4000));
+CREATE INDEX ON t USING ivfflat (val halfvec_l2_ops);
+DROP TABLE t;
+RESET maintenance_work_mem;
+
+SET maintenance_work_mem = '6MB';
+CREATE TABLE t (val halfvec(4000));
+INSERT INTO t (val) VALUES (array_fill(0, ARRAY[4000]));
+CREATE INDEX ON t USING ivfflat (val halfvec_l2_ops);
+DROP TABLE t;
+RESET maintenance_work_mem;

test/sql/ivfflat_vector.sql

@@ -41,6 +41,7 @@ INSERT INTO t (val) VALUES ('[1,2,4]');
 SELECT * FROM t ORDER BY val <=> '[3,3,3]';
 SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <=> '[0,0,0]') t2;
 SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <=> (SELECT NULL::vector)) t2;
+SELECT * FROM t CROSS JOIN LATERAL (SELECT * FROM t t2 ORDER BY val <=> t.val LIMIT 1) t2 WHERE t.val != '[0,0,0]' ORDER BY t.val;
 
 DROP TABLE t;
 
@@ -81,19 +82,40 @@ DROP TABLE t;
 CREATE TABLE t (val vector(3));
 CREATE INDEX ON t USING ivfflat (val vector_l2_ops) WITH (lists = 0);
 CREATE INDEX ON t USING ivfflat (val vector_l2_ops) WITH (lists = 32769);
+DROP TABLE t;
 
 SHOW ivfflat.probes;
-
 SET ivfflat.probes = 0;
 SET ivfflat.probes = 32769;
 
 SHOW ivfflat.iterative_scan;
-
 SET ivfflat.iterative_scan = on;
 
 SHOW ivfflat.max_probes;
-
 SET ivfflat.max_probes = 0;
 SET ivfflat.max_probes = 32769;
 
+-- dimensions
+
+CREATE TABLE t (val vector(2000));
+CREATE INDEX ON t USING ivfflat (val vector_l2_ops);
 DROP TABLE t;
+
+CREATE TABLE t (val vector(2001));
+CREATE INDEX ON t USING ivfflat (val vector_l2_ops);
+DROP TABLE t;
+
+-- memory
+
+SET maintenance_work_mem = '1MB';
+CREATE TABLE t (val vector(2000));
+CREATE INDEX ON t USING ivfflat (val vector_l2_ops);
+DROP TABLE t;
+RESET maintenance_work_mem;
+
+SET maintenance_work_mem = '5MB';
+CREATE TABLE t (val vector(2000));
+INSERT INTO t (val) VALUES (array_fill(0, ARRAY[2000]));
+CREATE INDEX ON t USING ivfflat (val vector_l2_ops);
+DROP TABLE t;
+RESET maintenance_work_mem;

test/t/046_hnsw_vacuum_scan.pl

@@ -0,0 +1,38 @@
+use strict;
+use warnings FATAL => 'all';
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
+use Test::More;
+
+my $dim = 3;
+my $array_sql = join(",", ('random()') x $dim);
+
+# Initialize node
+my $node = PostgreSQL::Test::Cluster->new('node');
+$node->init;
+$node->start;
+
+# Create table and index
+$node->safe_psql("postgres", "CREATE EXTENSION vector;");
+$node->safe_psql("postgres", "CREATE TABLE tst (i serial, v vector($dim));");
+$node->safe_psql("postgres", "ALTER TABLE tst SET (autovacuum_enabled = false);");
+$node->safe_psql("postgres",
+    "INSERT INTO tst (v) SELECT ARRAY[$array_sql] FROM generate_series(1, 1000) i;"
+);
+$node->safe_psql("postgres", "CREATE INDEX ON tst USING hnsw (v vector_l2_ops);");
+$node->safe_psql("postgres", "DELETE FROM tst");
+
+# Test HNSW_SCAN_LOCK at the beginning of MarkDeleted is effective
+$node->pgbench(
+    "--no-vacuum --client=5 --transactions=1000",
+    0,
+    [qr{actually processed}],
+    [qr{^$}],
+    "concurrent SELECTs and VACUUM",
+    {
+        "046_hnsw_vacuum_scan_select\@1000" => "SELECT i FROM tst ORDER BY v <-> '[0,0,0]' LIMIT 10;",
+        "046_hnsw_vacuum_scan_vacuum\@1" => "VACUUM tst;"
+    }
+);
+
+done_testing();

test/t/047_hnsw_vacuum_insert.pl

@@ -0,0 +1,39 @@
+use strict;
+use warnings FATAL => 'all';
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
+use Test::More;
+
+my $dim = 3;
+my $array_sql = join(",", ('random()') x $dim);
+
+# Initialize node
+my $node = PostgreSQL::Test::Cluster->new('node');
+$node->init;
+$node->start;
+
+# Create table and index
+$node->safe_psql("postgres", "CREATE EXTENSION vector;");
+$node->safe_psql("postgres", "CREATE TABLE tst (i serial, v vector($dim));");
+$node->safe_psql("postgres", "ALTER TABLE tst SET (autovacuum_enabled = false);");
+$node->safe_psql("postgres",
+    "INSERT INTO tst (v) SELECT ARRAY[$array_sql] FROM generate_series(1, 1000) i;"
+);
+$node->safe_psql("postgres", "CREATE INDEX ON tst USING hnsw (v vector_l2_ops);");
+
+# Test no "hnsw graph not repaired" errors
+$node->pgbench(
+    "--no-vacuum --client=5 --transactions=1000",
+    0,
+    [qr{actually processed}],
+    [qr{^$}],
+    "concurrent INSERTs, DELETEs, SELECTs, and VACUUM",
+    {
+        "047_hnsw_vacuum_insert_insert\@500" => "INSERT INTO tst (v) VALUES (ARRAY[$array_sql]);",
+        "047_hnsw_vacuum_insert_delete\@500" => "DELETE FROM tst WHERE i = (SELECT i FROM tst LIMIT 1);",
+        "047_hnsw_vacuum_insert_select\@20" => "SELECT i FROM tst ORDER BY v <-> (SELECT ARRAY[$array_sql]::vector) LIMIT 10;",
+        "047_hnsw_vacuum_insert_vacuum\@1" => "VACUUM tst;"
+    }
+);
+
+done_testing();

test/t/048_ivfflat_vacuum_insert.pl

@@ -0,0 +1,39 @@
+use strict;
+use warnings FATAL => 'all';
+use PostgreSQL::Test::Cluster;
+use PostgreSQL::Test::Utils;
+use Test::More;
+
+my $dim = 3;
+my $array_sql = join(",", ('random()') x $dim);
+
+# Initialize node
+my $node = PostgreSQL::Test::Cluster->new('node');
+$node->init;
+$node->start;
+
+# Create table and index
+$node->safe_psql("postgres", "CREATE EXTENSION vector;");
+$node->safe_psql("postgres", "CREATE TABLE tst (i serial, v vector($dim));");
+$node->safe_psql("postgres", "ALTER TABLE tst SET (autovacuum_enabled = false);");
+$node->safe_psql("postgres",
+    "INSERT INTO tst (v) SELECT ARRAY[$array_sql] FROM generate_series(1, 1000) i;"
+);
+$node->safe_psql("postgres", "CREATE INDEX ON tst USING ivfflat (v vector_l2_ops) WITH (lists = 10);");
+
+# Test no errors
+$node->pgbench(
+    "--no-vacuum --client=5 --transactions=1500",
+    0,
+    [qr{actually processed}],
+    [qr{^$}],
+    "concurrent INSERTs, DELETEs, SELECTs, and VACUUM",
+    {
+        "048_ivfflat_vacuum_insert_insert\@500" => "INSERT INTO tst (v) VALUES (ARRAY[$array_sql]);",
+        "048_ivfflat_vacuum_insert_delete\@500" => "DELETE FROM tst WHERE i = (SELECT i FROM tst LIMIT 1);",
+        "048_ivfflat_vacuum_insert_select\@500" => "SELECT i FROM tst ORDER BY v <-> (SELECT ARRAY[$array_sql]::vector) LIMIT 10;",
+        "048_ivfflat_vacuum_insert_vacuum\@1" => "VACUUM tst;"
+    }
+);
+
+done_testing();

vector.control

@@ -1,4 +1,4 @@
 comment = 'vector data type and ivfflat and hnsw access methods'
-default_version = '0.8.2'
+default_version = '0.8.5'
 module_pathname = '$libdir/vector'
 relocatable = true