Fixed locking for non-MVCC snapshots

This reverts commit dbef8d1ad1.

.github/workflows/build.yml

@@ -78,6 +78,7 @@ jobs:
           nmake /NOLOGO /F Makefile.win uninstall
         shell: cmd
   i386:
+    if: ${{ !startsWith(github.ref_name, 'mac') && !startsWith(github.ref_name, 'windows') }}
     runs-on: ubuntu-latest
     container:
       image: debian:11

CHANGELOG.md

@@ -1,11 +1,18 @@
-## 0.5.0 (unreleased)
+## 0.5.1 (unreleased)
+
+- Improved performance of index scans for IVFFlat after updates and deletes
+- Fixed locking for index scans for HNSW
+
+## 0.5.0 (2023-08-28)
 
 - Added HNSW index type
-- Added support for parallel index builds
+- Added support for parallel index builds for IVFFlat
 - Added `l1_distance` function
 - Added element-wise multiplication for vectors
 - Added `sum` aggregate
 - Improved performance of distance functions
+- Fixed out of range results for cosine distance
+- Fixed results for NULL and NaN distances for IVFFlat
 
 ## 0.4.4 (2023-06-12)
 

Dockerfile

@@ -5,6 +5,7 @@ ARG PG_MAJOR
 COPY . /tmp/pgvector
 
 RUN apt-get update && \
+		apt-mark hold locales && \
 		apt-get install -y --no-install-recommends build-essential postgresql-server-dev-$PG_MAJOR && \
 		cd /tmp/pgvector && \
 		make clean && \
@@ -15,4 +16,5 @@ RUN apt-get update && \
 		rm -r /tmp/pgvector && \
 		apt-get remove -y build-essential postgresql-server-dev-$PG_MAJOR && \
 		apt-get autoremove -y && \
+		apt-mark unhold locales && \
 		rm -rf /var/lib/apt/lists/*

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.4.4",
+	"version": "0.5.0",
 	"maintainer": [
 		"Andrew Kane <andrew@ankane.org>"
 	],
@@ -20,7 +20,7 @@
 		"vector": {
 			"file": "sql/vector.sql",
 			"docfile": "README.md",
-			"version": "0.4.4",
+			"version": "0.5.0",
 			"abstract": "Open-source vector similarity search for Postgres"
 		}
 	},

Makefile

@@ -1,13 +1,14 @@
 EXTENSION = vector
-EXTVERSION = 0.4.4
+EXTVERSION = 0.5.0
 
 MODULE_big = vector
 DATA = $(wildcard sql/*--*.sql)
 OBJS = src/hnsw.o src/hnswbuild.o src/hnswinsert.o src/hnswscan.o src/hnswutils.o src/hnswvacuum.o src/ivfbuild.o src/ivfflat.o src/ivfinsert.o src/ivfkmeans.o src/ivfscan.o src/ivfutils.o src/ivfvacuum.o src/vector.o
+HEADERS = src/vector.h
 
 TESTS = $(wildcard test/sql/*.sql)
 REGRESS = $(patsubst test/sql/%.sql,%,$(TESTS))
-REGRESS_OPTS = --inputdir=test --load-extension=vector
+REGRESS_OPTS = --inputdir=test --load-extension=$(EXTENSION)
 
 OPTFLAGS = -march=native
 

Makefile.win

@@ -1,10 +1,11 @@
 EXTENSION = vector
-EXTVERSION = 0.4.4
+EXTVERSION = 0.5.0
 
 OBJS = src\hnsw.obj src\hnswbuild.obj src\hnswinsert.obj src\hnswscan.obj src\hnswutils.obj src\hnswvacuum.obj src\ivfbuild.obj src\ivfflat.obj src\ivfinsert.obj src\ivfkmeans.obj src\ivfscan.obj src\ivfutils.obj src\ivfvacuum.obj src\vector.obj
+HEADERS = src\vector.h
 
 REGRESS = btree cast copy functions input ivfflat_cosine ivfflat_ip ivfflat_l2 ivfflat_options ivfflat_unlogged
-REGRESS_OPTS = --inputdir=test --load-extension=vector
+REGRESS_OPTS = --inputdir=test --load-extension=$(EXTENSION)
 
 # For /arch flags
 # https://learn.microsoft.com/en-us/cpp/build/reference/arch-minimum-cpu-architecture
@@ -54,6 +55,8 @@ install:
 	copy $(SHLIB) "$(PKGLIBDIR)"
 	copy $(EXTENSION).control "$(SHAREDIR)\extension"
 	copy sql\$(EXTENSION)--*.sql "$(SHAREDIR)\extension"
+	mkdir "$(INCLUDEDIR_SERVER)\extension\$(EXTENSION)"
+	copy $(HEADERS) "$(INCLUDEDIR_SERVER)\extension\$(EXTENSION)"
 
 installcheck:
 	"$(BINDIR)\pg_regress" --bindir="$(BINDIR)" $(REGRESS_OPTS) $(REGRESS)
@@ -61,7 +64,9 @@ installcheck:
 uninstall:
 	del /f "$(PKGLIBDIR)\$(SHLIB)"
 	del /f "$(SHAREDIR)\extension\$(EXTENSION).control"
-	del /f "$(SHAREDIR)\extension\vector--*.sql"
+	del /f "$(SHAREDIR)\extension\$(EXTENSION)--*.sql"
+	del /f "$(INCLUDEDIR_SERVER)\extension\$(EXTENSION)\*.h"
+	rmdir "$(INCLUDEDIR_SERVER)\extension\$(EXTENSION)"
 
 clean:
 	del /f $(SHLIB) $(EXTENSION).lib $(EXTENSION).exp

README.md

@@ -2,7 +2,7 @@
 
 Open-source vector similarity search for Postgres
 
-Store all of your application data in one place. Supports:
+Store your vectors with the rest of your data. Supports:
 
 - exact and approximate nearest neighbor search
 - L2 distance, inner product, and cosine distance
@@ -18,7 +18,7 @@ Compile and install the extension (supports Postgres 11+)
 
 ```sh
 cd /tmp
-git clone --branch v0.4.4 https://github.com/pgvector/pgvector.git
+git clone --branch v0.5.0 https://github.com/pgvector/pgvector.git
 cd pgvector
 make
 make install # may need sudo
@@ -157,16 +157,16 @@ SELECT category_id, AVG(embedding) FROM items GROUP BY category_id;
 
 By default, pgvector performs exact nearest neighbor search, which provides perfect recall.
 
-You can add an index to use approximate nearest neighbor search, which trades some recall for performance. Unlike typical indexes, you will see different results for queries after adding an approximate index.
+You can add an index to use approximate nearest neighbor search, which trades some recall for speed. Unlike typical indexes, you will see different results for queries after adding an approximate index.
 
 Supported index types are:
 
 - [IVFFlat](#ivfflat)
-- [HNSW](#hnsw) (*coming in 0.5.0*)
+- [HNSW](#hnsw) - added in 0.5.0
 
 ## IVFFlat
 
-An IVFFlat index clusters vectors into lists, and then searches a subset of those lists. It has faster build times and uses less memory than HNSW, but has lower query performance.
+An IVFFlat index divides vectors into lists, and then searches a subset of those lists that are closest to the query vector. It has faster build times and uses less memory than HNSW, but has lower query performance (in terms of speed-recall tradeoff).
 
 Three keys to achieving good recall are:
 
@@ -217,35 +217,41 @@ COMMIT;
 
 ## HNSW
 
-An HNSW index creates a multilayer graph between vectors. It has slower build times and uses more memory than IVFFlat, but has better query performance. There’s no training step like IVFFlat, so the index can be created without any data in the table.
-
-The options for HNSW are:
-
-- `m` - the max number of connections per layer (the bottom layer uses `2 * m`)
-- `ef_construction` - the size of the dynamic candidate list for constructing the graph
+An HNSW index creates a multilayer graph. It has slower build times and uses more memory than IVFFlat, but has better query performance (in terms of speed-recall tradeoff). There’s no training step like IVFFlat, so the index can be created without any data in the table.
 
 Add an index for each distance function you want to use.
 
 L2 distance
 
 ```sql
-CREATE INDEX ON items USING hnsw (embedding vector_l2_ops) WITH (m = 16, ef_construction = 40);
+CREATE INDEX ON items USING hnsw (embedding vector_l2_ops);
 ```
 
 Inner product
 
 ```sql
-CREATE INDEX ON items USING hnsw (embedding vector_ip_ops) WITH (m = 16, ef_construction = 40);
+CREATE INDEX ON items USING hnsw (embedding vector_ip_ops);
 ```
 
 Cosine distance
 
 ```sql
-CREATE INDEX ON items USING hnsw (embedding vector_cosine_ops) WITH (m = 16, ef_construction = 40);
+CREATE INDEX ON items USING hnsw (embedding vector_cosine_ops);
 ```
 
 Vectors with up to 2,000 dimensions can be indexed.
 
+### Index Options
+
+Specify HNSW parameters
+
+- `m` - the max number of connections per layer (16 by default)
+- `ef_construction` - the size of the dynamic candidate list for constructing the graph (64 by default)
+
+```sql
+CREATE INDEX ON items USING hnsw (embedding vector_l2_ops) WITH (m = 16, ef_construction = 64);
+```
+
 ### Query Options
 
 Specify the size of the dynamic candidate list for search (40 by default)
@@ -276,8 +282,8 @@ SELECT phase, tuples_done, tuples_total FROM pg_stat_progress_create_index;
 The phases are:
 
 1. `initializing`
-2. `performing k-means` (IVFFlat only)
-3. `sorting tuples` (IVFFlat only)
+2. `performing k-means` - IVFFlat only
+3. `assigning tuples` - IVFFlat only
 4. `loading tuples`
 
 Note: `tuples_done` and `tuples_total` are only populated during the `loading tuples` phase
@@ -357,6 +363,7 @@ Language | Libraries / Examples
 C++ | [pgvector-cpp](https://github.com/pgvector/pgvector-cpp)
 C# | [pgvector-dotnet](https://github.com/pgvector/pgvector-dotnet)
 Crystal | [pgvector-crystal](https://github.com/pgvector/pgvector-crystal)
+Dart | [pgvector-dart](https://github.com/pgvector/pgvector-dart)
 Elixir | [pgvector-elixir](https://github.com/pgvector/pgvector-elixir)
 Go | [pgvector-go](https://github.com/pgvector/pgvector-go)
 Haskell | [pgvector-haskell](https://github.com/pgvector/pgvector-haskell)
@@ -433,32 +440,32 @@ Each vector takes `4 * dimensions + 8` bytes of storage. Each element is a singl
 
 ### Vector Operators
 
-Operator | Description
---- | ---
-\+ | element-wise addition
-\- | element-wise subtraction
-\* | element-wise multiplication [unreleased]
-<-> | Euclidean distance
-<#> | negative inner product
-<=> | cosine distance
+Operator | Description | Added
+--- | --- | ---
+\+ | element-wise addition |
+\- | element-wise subtraction |
+\* | element-wise multiplication | 0.5.0
+<-> | Euclidean distance |
+<#> | negative inner product |
+<=> | cosine distance |
 
 ### Vector Functions
 
-Function | Description
---- | ---
-cosine_distance(vector, vector) → double precision | cosine distance
-inner_product(vector, vector) → double precision | inner product
-l2_distance(vector, vector) → double precision | Euclidean distance
-l1_distance(vector, vector) → double precision | taxicab distance [unreleased]
-vector_dims(vector) → integer | number of dimensions
-vector_norm(vector) → double precision | Euclidean norm
+Function | Description | Added
+--- | --- | ---
+cosine_distance(vector, vector) → double precision | cosine distance |
+inner_product(vector, vector) → double precision | inner product |
+l2_distance(vector, vector) → double precision | Euclidean distance |
+l1_distance(vector, vector) → double precision | taxicab distance | 0.5.0
+vector_dims(vector) → integer | number of dimensions |
+vector_norm(vector) → double precision | Euclidean norm |
 
 ### Aggregate Functions
 
-Function | Description
---- | ---
-avg(vector) → vector | arithmetic mean
-sum(vector) → vector | sum [unreleased]
+Function | Description | Added
+--- | --- | ---
+avg(vector) → vector | average |
+sum(vector) → vector | sum | 0.5.0
 
 ## Installation Notes
 
@@ -490,11 +497,19 @@ Note: Replace `15` with your Postgres server version
 
 ### Windows
 
-Support for Windows is currently experimental. Use `nmake` to build:
+Support for Windows is currently experimental. Ensure [C++ support in Visual Studio](https://learn.microsoft.com/en-us/cpp/build/building-on-the-command-line?view=msvc-170#download-and-install-the-tools) is installed, and run:
+
+```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\15"
-git clone --branch v0.4.4 https://github.com/pgvector/pgvector.git
+git clone --branch v0.5.0 https://github.com/pgvector/pgvector.git
 cd pgvector
 nmake /F Makefile.win
 nmake /F Makefile.win install
@@ -515,7 +530,7 @@ This adds pgvector to the [Postgres image](https://hub.docker.com/_/postgres) (r
 You can also build the image manually:
 
 ```sh
-git clone --branch v0.4.4 https://github.com/pgvector/pgvector.git
+git clone --branch v0.5.0 https://github.com/pgvector/pgvector.git
 cd pgvector
 docker build --build-arg PG_MAJOR=15 -t myuser/pgvector .
 ```
@@ -580,12 +595,18 @@ pgvector is available on [these providers](https://github.com/pgvector/pgvector/
 
 ## Upgrading
 
-Install the latest version and run:
+Install the latest version. Then in each database you want to upgrade, run:
 
 ```sql
 ALTER EXTENSION vector UPDATE;
 ```
 
+You can check the version in the current database with:
+
+```sql
+SELECT extversion FROM pg_extension WHERE extname = 'vector';
+```
+
 ## Upgrade Notes
 
 ### 0.4.0
@@ -618,7 +639,7 @@ Thanks to:
 
 - [PASE: PostgreSQL Ultra-High-Dimensional Approximate Nearest Neighbor Search Extension](https://dl.acm.org/doi/pdf/10.1145/3318464.3386131)
 - [Faiss: A Library for Efficient Similarity Search and Clustering of Dense Vectors](https://github.com/facebookresearch/faiss)
-- [Using the Triangle Inequality to Accelerate k-means](https://www.aaai.org/Papers/ICML/2003/ICML03-022.pdf)
+- [Using the Triangle Inequality to Accelerate k-means](https://cdn.aaai.org/ICML/2003/ICML03-022.pdf)
 - [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)

src/hnsw.c

@@ -37,7 +37,7 @@ HnswInit(void)
 		);
 
 	DefineCustomIntVariable("hnsw.ef_search", "Sets the size of the dynamic candidate list for search",
-							"Valid range is 10..1000.", &hnsw_ef_search,
+							"Valid range is 1..1000.", &hnsw_ef_search,
 							HNSW_DEFAULT_EF_SEARCH, HNSW_MIN_EF_SEARCH, HNSW_MAX_EF_SEARCH, PGC_USERSET, 0, NULL, NULL, NULL);
 }
 
@@ -91,7 +91,7 @@ hnswcostestimate(PlannerInfo *root, IndexPath *path, double loop_count,
 	MemSet(&costs, 0, sizeof(costs));
 
 	index = index_open(path->indexinfo->indexoid, NoLock);
-	m = HnswGetM(index);
+	HnswGetMetaPageInfo(index, &m, NULL);
 	index_close(index, NoLock);
 
 	/* Approximate entry level */
@@ -196,7 +196,7 @@ hnswhandler(PG_FUNCTION_ARGS)
 	amroutine->aminsert = hnswinsert;
 	amroutine->ambulkdelete = hnswbulkdelete;
 	amroutine->amvacuumcleanup = hnswvacuumcleanup;
-	amroutine->amcanreturn = NULL;	/* tuple not included in heapsort */
+	amroutine->amcanreturn = NULL;
 	amroutine->amcostestimate = hnswcostestimate;
 	amroutine->amoptions = hnswoptions;
 	amroutine->amproperty = NULL;	/* TODO AMPROP_DISTANCE_ORDERABLE */

src/hnsw.h

@@ -22,34 +22,43 @@
 
 #define HNSW_VERSION	1
 #define HNSW_MAGIC_NUMBER 0xA953A953
-#define HNSW_PAGE_ID	0xFF85
+#define HNSW_PAGE_ID	0xFF90
 
 /* Preserved page numbers */
 #define HNSW_METAPAGE_BLKNO	0
 #define HNSW_HEAD_BLKNO		1	/* first element page */
 
+/* Must correspond to page numbers since page lock is used */
+#define HNSW_UPDATE_LOCK 	0
+#define HNSW_SCAN_LOCK		1
+
+/* HNSW parameters */
 #define HNSW_DEFAULT_M	16
-#define HNSW_MIN_M	4
+#define HNSW_MIN_M	2
 #define HNSW_MAX_M		100
-#define HNSW_DEFAULT_EF_CONSTRUCTION	40
-#define HNSW_MIN_EF_CONSTRUCTION	10
+#define HNSW_DEFAULT_EF_CONSTRUCTION	64
+#define HNSW_MIN_EF_CONSTRUCTION	4
 #define HNSW_MAX_EF_CONSTRUCTION		1000
 #define HNSW_DEFAULT_EF_SEARCH	40
-#define HNSW_MIN_EF_SEARCH		10
+#define HNSW_MIN_EF_SEARCH		1
 #define HNSW_MAX_EF_SEARCH		1000
 
+/* Tuple types */
 #define HNSW_ELEMENT_TUPLE_TYPE  1
 #define HNSW_NEIGHBOR_TUPLE_TYPE 2
 
 /* Make graph robust against non-HOT updates */
 #define HNSW_HEAPTIDS 10
 
+#define HNSW_UPDATE_ENTRY_GREATER 1
+#define HNSW_UPDATE_ENTRY_ALWAYS 2
+
 /* Build phases */
 /* PROGRESS_CREATEIDX_SUBPHASE_INITIALIZE is 1 */
 #define PROGRESS_HNSW_PHASE_LOAD		2
 
 #define HNSW_ELEMENT_TUPLE_SIZE(_dim)	MAXALIGN(offsetof(HnswElementTupleData, vec) + VECTOR_SIZE(_dim))
-#define HNSW_NEIGHBOR_TUPLE_SIZE(level, m)	MAXALIGN(offsetof(HnswNeighborTupleData, neighbors) + ((level) + 2) * (m) * sizeof(HnswNeighborTupleItem))
+#define HNSW_NEIGHBOR_TUPLE_SIZE(level, m)	MAXALIGN(offsetof(HnswNeighborTupleData, indextids) + ((level) + 2) * (m) * sizeof(ItemPointerData))
 
 #define HnswPageGetOpaque(page)	((HnswPageOpaque) PageGetSpecialPointer(page))
 #define HnswPageGetMeta(page)	((HnswMetaPageData *) PageGetContents(page))
@@ -68,9 +77,15 @@
 #define HnswIsElementTuple(tup) ((tup)->type == HNSW_ELEMENT_TUPLE_TYPE)
 #define HnswIsNeighborTuple(tup) ((tup)->type == HNSW_NEIGHBOR_TUPLE_TYPE)
 
-#define HnswGetLayerM(m, layer) (layer == 0 ? m * 2 : m)
+/* 2 * M connections for ground layer */
+#define HnswGetLayerM(m, layer) (layer == 0 ? (m) * 2 : (m))
+
+/* Optimal ML from paper */
 #define HnswGetMl(m) (1 / log(m))
 
+/* Ensure fits on page and in uint8 */
+#define HnswGetMaxLevel(m) Min(((BLCKSZ - MAXALIGN(SizeOfPageHeaderData) - MAXALIGN(sizeof(HnswPageOpaqueData)) - offsetof(HnswNeighborTupleData, indextids) - sizeof(ItemIdData)) / (sizeof(ItemPointerData)) / m) - 2, 255)
+
 /* Variables */
 extern int	hnsw_ef_search;
 
@@ -103,13 +118,6 @@ typedef struct HnswNeighborArray
 	HnswCandidate *items;
 }			HnswNeighborArray;
 
-typedef struct HnswUpdate
-{
-	HnswCandidate hc;
-	int			level;
-	int			index;
-}			HnswUpdate;
-
 typedef struct HnswPairingHeapNode
 {
 	pairingheap_node ph_node;
@@ -197,19 +205,12 @@ typedef struct HnswElementTupleData
 
 typedef HnswElementTupleData * HnswElementTuple;
 
-typedef struct HnswNeighborTupleItem
-{
-	ItemPointerData indextid;
-	uint16		unused;
-	float		distance;		/* improves performance of inserts */
-}			HnswNeighborTupleItem;
-
 typedef struct HnswNeighborTupleData
 {
 	uint8		type;
 	uint8		unused;
 	uint16		count;
-	HnswNeighborTupleItem neighbors[FLEXIBLE_ARRAY_MEMBER];
+	ItemPointerData indextids[FLEXIBLE_ARRAY_MEMBER];
 }			HnswNeighborTupleData;
 
 typedef HnswNeighborTupleData * HnswNeighborTuple;
@@ -217,7 +218,6 @@ typedef HnswNeighborTupleData * HnswNeighborTuple;
 typedef struct HnswScanOpaqueData
 {
 	bool		first;
-	Buffer		buf;
 	List	   *w;
 	MemoryContext tmpCtx;
 
@@ -265,19 +265,26 @@ Buffer		HnswNewBuffer(Relation index, ForkNumber forkNum);
 void		HnswInitPage(Buffer buf, Page page);
 void		HnswInitRegisterPage(Relation index, Buffer *buf, Page *page, GenericXLogState **state);
 void		HnswInit(void);
-List	   *HnswSearchLayer(Datum q, List *ep, int ef, int lc, Relation index, FmgrInfo *procinfo, Oid collation, bool inserting, BlockNumber *skipPage, OffsetNumber *skipOffno);
+List	   *HnswSearchLayer(Datum q, List *ep, int ef, int lc, Relation index, FmgrInfo *procinfo, Oid collation, int m, bool inserting, HnswElement skipElement);
 HnswElement HnswGetEntryPoint(Relation index);
+void		HnswGetMetaPageInfo(Relation index, int *m, HnswElement * entryPoint);
 HnswElement HnswInitElement(ItemPointer tid, int m, double ml, int maxLevel);
 void		HnswFreeElement(HnswElement element);
-HnswElement HnswInsertElement(HnswElement element, HnswElement entryPoint, Relation index, FmgrInfo *procinfo, Oid collation, int m, int efConstruction, List **updates, bool vacuuming);
-HnswCandidate *HnswEntryCandidate(HnswElement em, Datum q, Relation rel, FmgrInfo *procinfo, Oid collation, bool loadvec);
-void		HnswUpdateMetaPage(Relation index, bool updateEntry, HnswElement entryPoint, BlockNumber insertPage, ForkNumber forkNum);
+HnswElement HnswInitElementFromBlock(BlockNumber blkno, OffsetNumber offno);
+void		HnswInsertElement(HnswElement element, HnswElement entryPoint, Relation index, FmgrInfo *procinfo, Oid collation, int m, int efConstruction, bool existing);
+HnswElement HnswFindDuplicate(HnswElement e);
+HnswCandidate *HnswEntryCandidate(HnswElement em, Datum q, Relation rel, FmgrInfo *procinfo, Oid collation, bool loadVec);
+void		HnswUpdateMetaPage(Relation index, int updateEntry, HnswElement entryPoint, BlockNumber insertPage, ForkNumber forkNum);
 void		HnswSetNeighborTuple(HnswNeighborTuple ntup, HnswElement e, int m);
 void		HnswAddHeapTid(HnswElement element, ItemPointer heaptid);
 void		HnswInitNeighbors(HnswElement element, int m);
 bool		HnswInsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heap_tid, Relation heapRel);
+void		HnswUpdateNeighborPages(Relation index, FmgrInfo *procinfo, Oid collation, HnswElement e, int m, bool checkExisting);
+void		HnswLoadElementFromTuple(HnswElement element, HnswElementTuple etup, bool loadHeaptids, bool loadVec);
 void		HnswLoadElement(HnswElement element, float *distance, Datum *q, Relation index, FmgrInfo *procinfo, Oid collation, bool loadVec);
 void		HnswSetElementTuple(HnswElementTuple etup, HnswElement element);
+void		HnswUpdateConnection(HnswElement element, HnswCandidate * hc, int m, int lc, int *updateIdx, Relation index, FmgrInfo *procinfo, Oid collation);
+void		HnswLoadNeighbors(HnswElement element, Relation index, int m);
 
 /* Index access methods */
 IndexBuildResult *hnswbuild(Relation heap, Relation index, IndexInfo *indexInfo);
@@ -295,7 +302,4 @@ void		hnswrescan(IndexScanDesc scan, ScanKey keys, int nkeys, ScanKey orderbys,
 bool		hnswgettuple(IndexScanDesc scan, ScanDirection dir);
 void		hnswendscan(IndexScanDesc scan);
 
-/* Ensure fits in uint8 */
-#define HnswGetMaxLevel(m) Min(((BLCKSZ - MAXALIGN(SizeOfPageHeaderData) - MAXALIGN(sizeof(HnswPageOpaqueData)) - offsetof(HnswNeighborTupleData, neighbors) - sizeof(ItemIdData)) / (sizeof(HnswNeighborTupleItem)) / m) - 2, 255)
-
 #endif

src/hnswbuild.c

@@ -60,6 +60,7 @@ CreateMetaPage(HnswBuildState * buildstate)
 	metap->efConstruction = buildstate->efConstruction;
 	metap->entryBlkno = InvalidBlockNumber;
 	metap->entryOffno = InvalidOffsetNumber;
+	metap->entryLevel = -1;
 	metap->insertPage = InvalidBlockNumber;
 	((PageHeader) page)->pd_lower =
 		((char *) metap + sizeof(HnswMetaPageData)) - (char *) page;
@@ -182,7 +183,7 @@ CreateElementPages(HnswBuildState * buildstate)
 	GenericXLogFinish(state);
 	UnlockReleaseBuffer(buf);
 
-	HnswUpdateMetaPage(index, true, buildstate->entryPoint, insertPage, forkNum);
+	HnswUpdateMetaPage(index, HNSW_UPDATE_ENTRY_ALWAYS, buildstate->entryPoint, insertPage, forkNum);
 
 	pfree(etup);
 	pfree(ntup);
@@ -288,7 +289,23 @@ InsertTuple(Relation index, Datum *values, HnswElement element, HnswBuildState *
 	memcpy(element->vec, DatumGetVector(value), VECTOR_SIZE(buildstate->dimensions));
 
 	/* Insert element in graph */
-	*dup = HnswInsertElement(element, entryPoint, NULL, procinfo, collation, m, efConstruction, NULL, false);
+	HnswInsertElement(element, entryPoint, NULL, procinfo, collation, m, efConstruction, false);
+
+	/* Look for duplicate */
+	*dup = HnswFindDuplicate(element);
+
+	/* Update neighbors if needed */
+	if (*dup == NULL)
+	{
+		for (int lc = element->level; lc >= 0; lc--)
+		{
+			int			lm = HnswGetLayerM(m, lc);
+			HnswNeighborArray *neighbors = &element->neighbors[lc];
+
+			for (int i = 0; i < neighbors->length; i++)
+				HnswUpdateConnection(element, &neighbors->items[i], lm, lc, NULL, NULL, procinfo, collation);
+		}
+	}
 
 	/* Update entry point if needed */
 	if (*dup == NULL && (entryPoint == NULL || element->level > entryPoint->level))
@@ -407,6 +424,9 @@ InitBuildState(HnswBuildState * buildstate, Relation heap, Relation index, Index
 	if (buildstate->dimensions > HNSW_MAX_DIM)
 		elog(ERROR, "column cannot have more than %d dimensions for hnsw index", HNSW_MAX_DIM);
 
+	if (buildstate->efConstruction < 2 * buildstate->m)
+		elog(ERROR, "ef_construction must be greater than or equal to 2 * m");
+
 	buildstate->reltuples = 0;
 	buildstate->indtuples = 0;
 

src/hnswinsert.c

@@ -34,7 +34,7 @@ GetInsertPage(Relation index)
  * Check for a free offset
  */
 static bool
-HnswFreeOffset(Relation index, Buffer buf, Page page, HnswElement element, Size ntupSize, Buffer *nbuf, Page *npage, OffsetNumber *freeOffno, OffsetNumber *freeNeighborOffno, BlockNumber *firstFreePage)
+HnswFreeOffset(Relation index, Buffer buf, Page page, HnswElement element, Size ntupSize, Buffer *nbuf, Page *npage, OffsetNumber *freeOffno, OffsetNumber *freeNeighborOffno, BlockNumber *newInsertPage)
 {
 	OffsetNumber offno;
 	OffsetNumber maxoffno = PageGetMaxOffsetNumber(page);
@@ -49,14 +49,15 @@ HnswFreeOffset(Relation index, Buffer buf, Page page, HnswElement element, Size
 
 		if (etup->deleted)
 		{
+			BlockNumber elementPage = BufferGetBlockNumber(buf);
 			BlockNumber neighborPage = ItemPointerGetBlockNumber(&etup->neighbortid);
 			OffsetNumber neighborOffno = ItemPointerGetOffsetNumber(&etup->neighbortid);
 			ItemId		itemid;
 
-			if (!BlockNumberIsValid(*firstFreePage))
-				*firstFreePage = neighborPage;
+			if (!BlockNumberIsValid(*newInsertPage))
+				*newInsertPage = elementPage;
 
-			if (neighborPage == BufferGetBlockNumber(buf))
+			if (neighborPage == elementPage)
 			{
 				*nbuf = buf;
 				*npage = page;
@@ -110,7 +111,7 @@ HnswInsertAppendPage(Relation index, Buffer *nbuf, Page *npage, GenericXLogState
  * Add to element and neighbor pages
  */
 static void
-WriteNewElementPages(Relation index, HnswElement e, int m)
+WriteNewElementPages(Relation index, HnswElement e, int m, BlockNumber insertPage, BlockNumber *updatedInsertPage)
 {
 	Buffer		buf;
 	Page		page;
@@ -118,21 +119,24 @@ WriteNewElementPages(Relation index, HnswElement e, int m)
 	Size		etupSize;
 	Size		ntupSize;
 	Size		combinedSize;
+	Size		maxSize;
+	Size		minCombinedSize;
 	HnswElementTuple etup;
-	BlockNumber insertPage = GetInsertPage(index);
-	BlockNumber originalInsertPage = insertPage;
+	BlockNumber currentPage = insertPage;
 	int			dimensions = e->vec->dim;
 	HnswNeighborTuple ntup;
 	Buffer		nbuf;
 	Page		npage;
 	OffsetNumber freeOffno = InvalidOffsetNumber;
 	OffsetNumber freeNeighborOffno = InvalidOffsetNumber;
-	BlockNumber firstFreePage = InvalidBlockNumber;
+	BlockNumber newInsertPage = InvalidBlockNumber;
 
 	/* Calculate sizes */
 	etupSize = HNSW_ELEMENT_TUPLE_SIZE(dimensions);
 	ntupSize = HNSW_NEIGHBOR_TUPLE_SIZE(e->level, m);
 	combinedSize = etupSize + ntupSize + sizeof(ItemIdData);
+	maxSize = BLCKSZ - MAXALIGN(SizeOfPageHeaderData) - MAXALIGN(sizeof(HnswPageOpaqueData));
+	minCombinedSize = etupSize + HNSW_NEIGHBOR_TUPLE_SIZE(0, m) + sizeof(ItemIdData);
 
 	/* Prepare element tuple */
 	etup = palloc0(etupSize);
@@ -142,16 +146,22 @@ WriteNewElementPages(Relation index, HnswElement e, int m)
 	ntup = palloc0(ntupSize);
 	HnswSetNeighborTuple(ntup, e, m);
 
-	/* Find a page to insert the item */
+	/* Find a page (or two if needed) to insert the tuples */
 	for (;;)
 	{
-		buf = ReadBuffer(index, insertPage);
+		buf = ReadBuffer(index, currentPage);
 		LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
 
 		state = GenericXLogStart(index);
 		page = GenericXLogRegisterBuffer(state, buf, 0);
 
-		/* Space for both */
+		/* Keep track of first page where element at level 0 can fit */
+		if (!BlockNumberIsValid(newInsertPage) && PageGetFreeSpace(page) >= minCombinedSize)
+			newInsertPage = currentPage;
+
+		/* First, try the fastest path */
+		/* Space for both tuples on the current page */
+		/* This can split existing tuples in rare cases */
 		if (PageGetFreeSpace(page) >= combinedSize)
 		{
 			nbuf = buf;
@@ -159,15 +169,8 @@ WriteNewElementPages(Relation index, HnswElement e, int m)
 			break;
 		}
 
-		/* Space for element but not neighbors and last page */
-		if (PageGetFreeSpace(page) >= etupSize && !BlockNumberIsValid(HnswPageGetOpaque(page)->nextblkno))
-		{
-			HnswInsertAppendPage(index, &nbuf, &npage, state, page);
-			break;
-		}
-
-		/* Space from deleted item */
-		if (HnswFreeOffset(index, buf, page, e, ntupSize, &nbuf, &npage, &freeOffno, &freeNeighborOffno, &firstFreePage))
+		/* Next, try space from a deleted element */
+		if (HnswFreeOffset(index, buf, page, e, ntupSize, &nbuf, &npage, &freeOffno, &freeNeighborOffno, &newInsertPage))
 		{
 			if (nbuf != buf)
 				npage = GenericXLogRegisterBuffer(state, nbuf, 0);
@@ -175,9 +178,17 @@ WriteNewElementPages(Relation index, HnswElement e, int m)
 			break;
 		}
 
-		insertPage = HnswPageGetOpaque(page)->nextblkno;
+		/* Finally, try space for element only if last page */
+		/* Skip if both tuples can fit on the same page */
+		if (combinedSize > maxSize && PageGetFreeSpace(page) >= etupSize && !BlockNumberIsValid(HnswPageGetOpaque(page)->nextblkno))
+		{
+			HnswInsertAppendPage(index, &nbuf, &npage, state, page);
+			break;
+		}
 
-		if (BlockNumberIsValid(insertPage))
+		currentPage = HnswPageGetOpaque(page)->nextblkno;
+
+		if (BlockNumberIsValid(currentPage))
 		{
 			/* Move to next page */
 			GenericXLogAbort(state);
@@ -219,7 +230,10 @@ WriteNewElementPages(Relation index, HnswElement e, int m)
 	e->blkno = BufferGetBlockNumber(buf);
 	e->neighborPage = BufferGetBlockNumber(nbuf);
 
-	insertPage = e->neighborPage;
+	/* Added tuple to new page if newInsertPage is not set */
+	/* So can set to neighbor page instead of element page */
+	if (!BlockNumberIsValid(newInsertPage))
+		newInsertPage = e->neighborPage;
 
 	if (OffsetNumberIsValid(freeOffno))
 	{
@@ -265,76 +279,126 @@ WriteNewElementPages(Relation index, HnswElement e, int m)
 		UnlockReleaseBuffer(nbuf);
 
 	/* Update the insert page */
-	if (insertPage != originalInsertPage && (!OffsetNumberIsValid(freeOffno) || firstFreePage == insertPage))
-		HnswUpdateMetaPage(index, false, NULL, insertPage, MAIN_FORKNUM);
+	if (BlockNumberIsValid(newInsertPage) && newInsertPage != insertPage)
+		*updatedInsertPage = newInsertPage;
 }
 
 /*
- * Calculate index for update
+ * Check if connection already exists
  */
-static int
-HnswGetIndex(HnswUpdate * update, int m)
+static bool
+ConnectionExists(HnswElement e, HnswNeighborTuple ntup, int startIdx, int lm)
 {
-	return (update->hc.element->level - update->level) * m + update->index;
+	for (int i = 0; i < lm; i++)
+	{
+		ItemPointer indextid = &ntup->indextids[startIdx + i];
+
+		if (!ItemPointerIsValid(indextid))
+			break;
+
+		if (ItemPointerGetBlockNumber(indextid) == e->blkno && ItemPointerGetOffsetNumber(indextid) == e->offno)
+			return true;
+	}
+
+	return false;
 }
 
 /*
  * Update neighbors
  */
-static void
-UpdateNeighborPages(Relation index, HnswElement e, int m, List *updates)
+void
+HnswUpdateNeighborPages(Relation index, FmgrInfo *procinfo, Oid collation, HnswElement e, int m, bool checkExisting)
 {
-	ListCell   *lc;
-
-	/* Could update multiple at once for same element */
-	/* but should only happen a low percent of time, so keep simple for now */
-	foreach(lc, updates)
+	for (int lc = e->level; lc >= 0; lc--)
 	{
-		Buffer		buf;
-		Page		page;
-		GenericXLogState *state;
-		HnswUpdate *update = lfirst(lc);
-		ItemId		itemid;
-		HnswNeighborTuple ntup;
-		Size		ntupSize;
-		int			idx;
-		OffsetNumber offno = update->hc.element->neighborOffno;
+		int			lm = HnswGetLayerM(m, lc);
+		HnswNeighborArray *neighbors = &e->neighbors[lc];
 
-		/* Register page */
-		buf = ReadBuffer(index, update->hc.element->neighborPage);
-		LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
-		state = GenericXLogStart(index);
-		page = GenericXLogRegisterBuffer(state, buf, 0);
-
-		/* Get tuple */
-		itemid = PageGetItemId(page, offno);
-		ntup = (HnswNeighborTuple) PageGetItem(page, itemid);
-		ntupSize = ItemIdGetLength(itemid);
-
-		/* Calculate index */
-		idx = HnswGetIndex(update, m);
-
-		/* Make robust to issues */
-		if (idx < ntup->count)
+		for (int i = 0; i < neighbors->length; i++)
 		{
-			HnswNeighborTupleItem *neighbor = &ntup->neighbors[idx];
+			HnswCandidate *hc = &neighbors->items[i];
+			Buffer		buf;
+			Page		page;
+			GenericXLogState *state;
+			ItemId		itemid;
+			HnswNeighborTuple ntup;
+			Size		ntupSize;
+			int			idx = -1;
+			int			startIdx;
+			OffsetNumber offno = hc->element->neighborOffno;
 
-			/* Update neighbor */
-			ItemPointerSet(&neighbor->indextid, e->blkno, e->offno);
-			neighbor->distance = update->hc.distance;
+			/* Get latest neighbors since they may have changed */
+			/* Do not lock yet since selecting neighbors can take time */
+			HnswLoadNeighbors(hc->element, index, m);
 
-			/* Overwrite tuple */
-			if (!PageIndexTupleOverwrite(page, offno, (Item) ntup, ntupSize))
-				elog(ERROR, "failed to add index item to \"%s\"", RelationGetRelationName(index));
+			/*
+			 * Could improve performance for vacuuming by checking neighbors
+			 * against list of elements being deleted to find index. It's
+			 * important to exclude already deleted elements for this since
+			 * they can be replaced at any time.
+			 */
 
-			/* Commit */
-			MarkBufferDirty(buf);
-			GenericXLogFinish(state);
+			/* Select neighbors */
+			HnswUpdateConnection(e, hc, lm, lc, &idx, index, procinfo, collation);
+
+			/* New element was not selected as a neighbor */
+			if (idx == -1)
+				continue;
+
+			/* Register page */
+			buf = ReadBuffer(index, hc->element->neighborPage);
+			LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
+			state = GenericXLogStart(index);
+			page = GenericXLogRegisterBuffer(state, buf, 0);
+
+			/* Get tuple */
+			itemid = PageGetItemId(page, offno);
+			ntup = (HnswNeighborTuple) PageGetItem(page, itemid);
+			ntupSize = ItemIdGetLength(itemid);
+
+			/* Calculate index for update */
+			startIdx = (hc->element->level - lc) * m;
+
+			/* Check for existing connection */
+			if (checkExisting && ConnectionExists(e, ntup, startIdx, lm))
+				idx = -1;
+			else if (idx == -2)
+			{
+				/* Find free offset if still exists */
+				/* TODO Retry updating connections if not */
+				for (int j = 0; j < lm; j++)
+				{
+					if (!ItemPointerIsValid(&ntup->indextids[startIdx + j]))
+					{
+						idx = startIdx + j;
+						break;
+					}
+				}
+			}
+			else
+				idx += startIdx;
+
+			/* Make robust to issues */
+			if (idx >= 0 && idx < ntup->count)
+			{
+				ItemPointer indextid = &ntup->indextids[idx];
+
+				/* Update neighbor */
+				ItemPointerSet(indextid, e->blkno, e->offno);
+
+				/* Overwrite tuple */
+				if (!PageIndexTupleOverwrite(page, offno, (Item) ntup, ntupSize))
+					elog(ERROR, "failed to add index item to \"%s\"", RelationGetRelationName(index));
+
+				/* Commit */
+				MarkBufferDirty(buf);
+				GenericXLogFinish(state);
+			}
+			else
+				GenericXLogAbort(state);
+
+			UnlockReleaseBuffer(buf);
 		}
-		else
-			GenericXLogAbort(state);
-
-		UnlockReleaseBuffer(buf);
 	}
 }
 
@@ -392,8 +456,10 @@ HnswAddDuplicate(Relation index, HnswElement element, HnswElement dup)
  * Write changes to disk
  */
 static void
-WriteElement(Relation index, HnswElement element, int m, List *updates, HnswElement dup, HnswElement entryPoint)
+WriteElement(Relation index, FmgrInfo *procinfo, Oid collation, HnswElement element, int m, int efConstruction, HnswElement dup, HnswElement entryPoint)
 {
+	BlockNumber newInsertPage = InvalidBlockNumber;
+
 	/* Try to add to existing page */
 	if (dup != NULL)
 	{
@@ -401,13 +467,19 @@ WriteElement(Relation index, HnswElement element, int m, List *updates, HnswElem
 			return;
 	}
 
-	/* If fails, take this path */
-	WriteNewElementPages(index, element, m);
-	UpdateNeighborPages(index, element, m, updates);
+	/* Write element and neighbor tuples */
+	WriteNewElementPages(index, element, m, GetInsertPage(index), &newInsertPage);
+
+	/* Update insert page if needed */
+	if (BlockNumberIsValid(newInsertPage))
+		HnswUpdateMetaPage(index, 0, NULL, newInsertPage, MAIN_FORKNUM);
+
+	/* Update neighbors */
+	HnswUpdateNeighborPages(index, procinfo, collation, element, m, false);
 
 	/* Update metapage if needed */
 	if (entryPoint == NULL || element->level > entryPoint->level)
-		HnswUpdateMetaPage(index, true, element, InvalidBlockNumber, MAIN_FORKNUM);
+		HnswUpdateMetaPage(index, HNSW_UPDATE_ENTRY_GREATER, element, InvalidBlockNumber, MAIN_FORKNUM);
 }
 
 /*
@@ -420,13 +492,12 @@ HnswInsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heap_ti
 	FmgrInfo   *normprocinfo;
 	HnswElement entryPoint;
 	HnswElement element;
-	int			m = HnswGetM(index);
+	int			m;
 	int			efConstruction = HnswGetEfConstruction(index);
-	double		ml = HnswGetMl(m);
 	FmgrInfo   *procinfo = index_getprocinfo(index, 1, HNSW_DISTANCE_PROC);
 	Oid			collation = index->rd_indcollation[0];
-	List	   *updates = NIL;
 	HnswElement dup;
+	LOCKMODE	lockmode = ShareLock;
 
 	/* Detoast once for all calls */
 	value = PointerGetDatum(PG_DETOAST_DATUM(values[0]));
@@ -439,18 +510,45 @@ HnswInsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heap_ti
 			return false;
 	}
 
+	/*
+	 * Get a shared lock. This allows vacuum to ensure no in-flight inserts
+	 * before repairing graph. Use a page lock so it does not interfere with
+	 * buffer lock (or reads when vacuuming).
+	 */
+	LockPage(index, HNSW_UPDATE_LOCK, lockmode);
+
+	/* Get m and entry point */
+	HnswGetMetaPageInfo(index, &m, &entryPoint);
+
 	/* Create an element */
-	element = HnswInitElement(heap_tid, m, ml, HnswGetMaxLevel(m));
+	element = HnswInitElement(heap_tid, m, HnswGetMl(m), HnswGetMaxLevel(m));
 	element->vec = DatumGetVector(value);
 
-	/* Get entry point */
-	entryPoint = HnswGetEntryPoint(index);
+	/* Prevent concurrent inserts when likely updating entry point */
+	if (entryPoint == NULL || element->level > entryPoint->level)
+	{
+		/* Release shared lock */
+		UnlockPage(index, HNSW_UPDATE_LOCK, lockmode);
+
+		/* Get exclusive lock */
+		lockmode = ExclusiveLock;
+		LockPage(index, HNSW_UPDATE_LOCK, lockmode);
+
+		/* Get latest entry point after lock is acquired */
+		entryPoint = HnswGetEntryPoint(index);
+	}
 
 	/* Insert element in graph */
-	dup = HnswInsertElement(element, entryPoint, index, procinfo, collation, m, efConstruction, &updates, false);
+	HnswInsertElement(element, entryPoint, index, procinfo, collation, m, efConstruction, false);
+
+	/* Look for duplicate */
+	dup = HnswFindDuplicate(element);
 
 	/* Write to disk */
-	WriteElement(index, element, m, updates, dup, entryPoint);
+	WriteElement(index, procinfo, collation, element, m, efConstruction, dup, entryPoint);
+
+	/* Release lock */
+	UnlockPage(index, HNSW_UPDATE_LOCK, lockmode);
 
 	return true;
 }

src/hnswscan.c

@@ -4,34 +4,39 @@
 #include "hnsw.h"
 #include "pgstat.h"
 #include "storage/bufmgr.h"
+#include "storage/lmgr.h"
 #include "utils/memutils.h"
 
 /*
  * Algorithm 5 from paper
  */
-static void
+static List *
 GetScanItems(IndexScanDesc scan, Datum q)
 {
 	HnswScanOpaque so = (HnswScanOpaque) scan->opaque;
 	Relation	index = scan->indexRelation;
 	FmgrInfo   *procinfo = so->procinfo;
 	Oid			collation = so->collation;
-	List	   *ep = NIL;
+	List	   *ep;
 	List	   *w;
-	HnswElement entryPoint = HnswGetEntryPoint(index);
+	int			m;
+	HnswElement entryPoint;
+
+	/* Get m and entry point */
+	HnswGetMetaPageInfo(index, &m, &entryPoint);
 
 	if (entryPoint == NULL)
-		return;
+		return NIL;
 
-	ep = lappend(ep, HnswEntryCandidate(entryPoint, q, index, procinfo, collation, false));
+	ep = list_make1(HnswEntryCandidate(entryPoint, q, index, procinfo, collation, false));
 
 	for (int lc = entryPoint->level; lc >= 1; lc--)
 	{
-		w = HnswSearchLayer(q, ep, 1, lc, index, procinfo, collation, false, NULL, NULL);
+		w = HnswSearchLayer(q, ep, 1, lc, index, procinfo, collation, m, false, NULL);
 		ep = w;
 	}
 
-	so->w = HnswSearchLayer(q, ep, hnsw_ef_search, 0, index, procinfo, collation, false, NULL, NULL);
+	return HnswSearchLayer(q, ep, hnsw_ef_search, 0, index, procinfo, collation, m, false, NULL);
 }
 
 /*
@@ -57,6 +62,33 @@ GetDimensions(Relation index)
 	return dimensions;
 }
 
+/*
+ * Get scan value
+ */
+static Datum
+GetScanValue(IndexScanDesc scan)
+{
+	HnswScanOpaque so = (HnswScanOpaque) scan->opaque;
+	Datum		value;
+
+	if (scan->orderByData->sk_flags & SK_ISNULL)
+		value = PointerGetDatum(InitVector(GetDimensions(scan->indexRelation)));
+	else
+	{
+		value = scan->orderByData->sk_argument;
+
+		/* Value should not be compressed or toasted */
+		Assert(!VARATT_IS_COMPRESSED(DatumGetPointer(value)));
+		Assert(!VARATT_IS_EXTENDED(DatumGetPointer(value)));
+
+		/* Fine if normalization fails */
+		if (so->normprocinfo != NULL)
+			HnswNormValue(so->normprocinfo, so->collation, &value, NULL);
+	}
+
+	return value;
+}
+
 /*
  * Prepare for an index scan
  */
@@ -69,7 +101,6 @@ hnswbeginscan(Relation index, int nkeys, int norderbys)
 	scan = RelationGetIndexScan(index, nkeys, norderbys);
 
 	so = (HnswScanOpaque) palloc(sizeof(HnswScanOpaqueData));
-	so->buf = InvalidBuffer;
 	so->first = true;
 	so->tmpCtx = AllocSetContextCreate(CurrentMemoryContext,
 									   "Hnsw scan temporary context",
@@ -82,6 +113,12 @@ hnswbeginscan(Relation index, int nkeys, int norderbys)
 
 	scan->opaque = so;
 
+	/*
+	 * Get a shared lock. This allows vacuum to ensure no in-flight scans
+	 * before marking tuples as deleted.
+	 */
+	LockPage(scan->indexRelation, HNSW_SCAN_LOCK, ShareLock);
+
 	return scan;
 }
 
@@ -129,61 +166,46 @@ hnswgettuple(IndexScanDesc scan, ScanDirection dir)
 		if (scan->orderByData == NULL)
 			elog(ERROR, "cannot scan hnsw index without order");
 
-		if (scan->orderByData->sk_flags & SK_ISNULL)
-			value = PointerGetDatum(InitVector(GetDimensions(scan->indexRelation)));
-		else
-		{
-			value = scan->orderByData->sk_argument;
+		/* Get scan value */
+		value = GetScanValue(scan);
 
-			/* Value should not be compressed or toasted */
-			Assert(!VARATT_IS_COMPRESSED(DatumGetPointer(value)));
-			Assert(!VARATT_IS_EXTENDED(DatumGetPointer(value)));
+		so->w = GetScanItems(scan, value);
 
-			/* Fine if normalization fails */
-			if (so->normprocinfo != NULL)
-				HnswNormValue(so->normprocinfo, so->collation, &value, NULL);
-		}
-
-		GetScanItems(scan, value);
 		so->first = false;
 	}
 
 	while (list_length(so->w) > 0)
 	{
 		HnswCandidate *hc = llast(so->w);
-		ItemPointer tid;
-		BlockNumber indexblkno;
+		ItemPointer heaptid;
 
-		/* Move to next element if no valid heap tids */
+		/* Move to next element if no valid heap TIDs */
 		if (list_length(hc->element->heaptids) == 0)
 		{
 			so->w = list_delete_last(so->w);
 			continue;
 		}
 
-		tid = llast(hc->element->heaptids);
-		indexblkno = hc->element->blkno;
+		heaptid = llast(hc->element->heaptids);
 
 		hc->element->heaptids = list_delete_last(hc->element->heaptids);
 
 		MemoryContextSwitchTo(oldCtx);
 
 #if PG_VERSION_NUM >= 120000
-		scan->xs_heaptid = *tid;
+		scan->xs_heaptid = *heaptid;
 #else
-		scan->xs_ctup.t_self = *tid;
+		scan->xs_ctup.t_self = *heaptid;
 #endif
 
-		if (BufferIsValid(so->buf))
-			ReleaseBuffer(so->buf);
-
 		/*
-		 * An index scan must maintain a pin on the index page holding the
-		 * item last returned by amgettuple
+		 * Typically, an index scan must maintain a pin on the index page
+		 * holding the item last returned by amgettuple. However, this is not
+		 * needed with the current vacuum strategy, which ensures scans do not
+		 * visit tuples in danger of being marked as deleted.
 		 *
 		 * https://www.postgresql.org/docs/current/index-locking.html
 		 */
-		so->buf = ReadBuffer(scan->indexRelation, indexblkno);
 
 		scan->xs_recheckorderby = false;
 		return true;
@@ -201,9 +223,8 @@ hnswendscan(IndexScanDesc scan)
 {
 	HnswScanOpaque so = (HnswScanOpaque) scan->opaque;
 
-	/* Release pin */
-	if (BufferIsValid(so->buf))
-		ReleaseBuffer(so->buf);
+	/* Release shared lock */
+	UnlockPage(scan->indexRelation, HNSW_SCAN_LOCK, ShareLock);
 
 	MemoryContextDelete(so->tmpCtx);
 

src/hnswutils.c

@@ -7,7 +7,7 @@
 #include "vector.h"
 
 /*
- * Get the number of connection in the index
+ * Get the max number of connections in an upper layer for each element in the index
  */
 int
 HnswGetM(Relation index)
@@ -197,8 +197,8 @@ HnswAddHeapTid(HnswElement element, ItemPointer heaptid)
 /*
  * Allocate an element from block and offset numbers
  */
-static HnswElement
-InitElementFromBlock(BlockNumber blkno, OffsetNumber offno)
+HnswElement
+HnswInitElementFromBlock(BlockNumber blkno, OffsetNumber offno)
 {
 	HnswElement element = palloc(sizeof(HnswElementData));
 
@@ -210,46 +210,54 @@ InitElementFromBlock(BlockNumber blkno, OffsetNumber offno)
 }
 
 /*
- * Get the entry point
+ * Get the metapage info
  */
-HnswElement
-HnswGetEntryPoint(Relation index)
+void
+HnswGetMetaPageInfo(Relation index, int *m, HnswElement * entryPoint)
 {
 	Buffer		buf;
 	Page		page;
 	HnswMetaPage metap;
-	HnswElement entryPoint = NULL;
 
 	buf = ReadBuffer(index, HNSW_METAPAGE_BLKNO);
 	LockBuffer(buf, BUFFER_LOCK_SHARE);
 	page = BufferGetPage(buf);
 	metap = HnswPageGetMeta(page);
 
-	if (BlockNumberIsValid(metap->entryBlkno))
-		entryPoint = InitElementFromBlock(metap->entryBlkno, metap->entryOffno);
+	if (m != NULL)
+		*m = metap->m;
+
+	if (entryPoint != NULL)
+	{
+		if (BlockNumberIsValid(metap->entryBlkno))
+			*entryPoint = HnswInitElementFromBlock(metap->entryBlkno, metap->entryOffno);
+		else
+			*entryPoint = NULL;
+	}
 
 	UnlockReleaseBuffer(buf);
+}
+
+/*
+ * Get the entry point
+ */
+HnswElement
+HnswGetEntryPoint(Relation index)
+{
+	HnswElement entryPoint;
+
+	HnswGetMetaPageInfo(index, NULL, &entryPoint);
 
 	return entryPoint;
 }
 
 /*
- * Update the metapage
+ * Update the metapage info
  */
-void
-HnswUpdateMetaPage(Relation index, bool updateEntry, HnswElement entryPoint, BlockNumber insertPage, ForkNumber forkNum)
+static void
+HnswUpdateMetaPageInfo(Page page, int updateEntry, HnswElement entryPoint, BlockNumber insertPage)
 {
-	Buffer		buf;
-	Page		page;
-	GenericXLogState *state;
-	HnswMetaPage metap;
-
-	buf = ReadBufferExtended(index, forkNum, HNSW_METAPAGE_BLKNO, RBM_NORMAL, NULL);
-	LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
-	state = GenericXLogStart(index);
-	page = GenericXLogRegisterBuffer(state, buf, 0);
-
-	metap = HnswPageGetMeta(page);
+	HnswMetaPage metap = HnswPageGetMeta(page);
 
 	if (updateEntry)
 	{
@@ -259,7 +267,7 @@ HnswUpdateMetaPage(Relation index, bool updateEntry, HnswElement entryPoint, Blo
 			metap->entryOffno = InvalidOffsetNumber;
 			metap->entryLevel = -1;
 		}
-		else
+		else if (entryPoint->level > metap->entryLevel || updateEntry == HNSW_UPDATE_ENTRY_ALWAYS)
 		{
 			metap->entryBlkno = entryPoint->blkno;
 			metap->entryOffno = entryPoint->offno;
@@ -269,6 +277,24 @@ HnswUpdateMetaPage(Relation index, bool updateEntry, HnswElement entryPoint, Blo
 
 	if (BlockNumberIsValid(insertPage))
 		metap->insertPage = insertPage;
+}
+
+/*
+ * Update the metapage
+ */
+void
+HnswUpdateMetaPage(Relation index, int updateEntry, HnswElement entryPoint, BlockNumber insertPage, ForkNumber forkNum)
+{
+	Buffer		buf;
+	Page		page;
+	GenericXLogState *state;
+
+	buf = ReadBufferExtended(index, forkNum, HNSW_METAPAGE_BLKNO, RBM_NORMAL, NULL);
+	LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
+	state = GenericXLogStart(index);
+	page = GenericXLogRegisterBuffer(state, buf, 0);
+
+	HnswUpdateMetaPageInfo(page, updateEntry, entryPoint, insertPage);
 
 	HnswCommitBuffer(buf, state);
 }
@@ -309,20 +335,16 @@ HnswSetNeighborTuple(HnswNeighborTuple ntup, HnswElement e, int m)
 
 		for (int i = 0; i < lm; i++)
 		{
-			HnswNeighborTupleItem *neighbor = &ntup->neighbors[idx++];
+			ItemPointer indextid = &ntup->indextids[idx++];
 
 			if (i < neighbors->length)
 			{
 				HnswCandidate *hc = &neighbors->items[i];
 
-				ItemPointerSet(&neighbor->indextid, hc->element->blkno, hc->element->offno);
-				neighbor->distance = hc->distance;
+				ItemPointerSet(indextid, hc->element->blkno, hc->element->offno);
 			}
 			else
-			{
-				ItemPointerSetInvalid(&neighbor->indextid);
-				neighbor->distance = NAN;
-			}
+				ItemPointerSetInvalid(indextid);
 		}
 	}
 
@@ -333,10 +355,9 @@ HnswSetNeighborTuple(HnswNeighborTuple ntup, HnswElement e, int m)
  * Load neighbors from page
  */
 static void
-LoadNeighborsFromPage(HnswElement element, Relation index, Page page)
+LoadNeighborsFromPage(HnswElement element, Relation index, Page page, int m)
 {
 	HnswNeighborTuple ntup = (HnswNeighborTuple) PageGetItem(page, PageGetItemId(page, element->neighborOffno));
-	int			m = HnswGetM(index);
 	int			neighborCount = (element->level + 2) * m;
 
 	Assert(HnswIsNeighborTuple(ntup));
@@ -352,15 +373,15 @@ LoadNeighborsFromPage(HnswElement element, Relation index, Page page)
 		HnswElement e;
 		int			level;
 		HnswCandidate *hc;
-		HnswNeighborTupleItem *neighbor;
+		ItemPointer indextid;
 		HnswNeighborArray *neighbors;
 
-		neighbor = &ntup->neighbors[i];
+		indextid = &ntup->indextids[i];
 
-		if (!ItemPointerIsValid(&neighbor->indextid))
+		if (!ItemPointerIsValid(indextid))
 			continue;
 
-		e = InitElementFromBlock(ItemPointerGetBlockNumber(&neighbor->indextid), ItemPointerGetOffsetNumber(&neighbor->indextid));
+		e = HnswInitElementFromBlock(ItemPointerGetBlockNumber(indextid), ItemPointerGetOffsetNumber(indextid));
 
 		/* Calculate level based on offset */
 		level = element->level - i / m;
@@ -370,15 +391,14 @@ LoadNeighborsFromPage(HnswElement element, Relation index, Page page)
 		neighbors = &element->neighbors[level];
 		hc = &neighbors->items[neighbors->length++];
 		hc->element = e;
-		hc->distance = neighbor->distance;
 	}
 }
 
 /*
  * Load neighbors
  */
-static void
-LoadNeighbors(HnswElement element, Relation index)
+void
+HnswLoadNeighbors(HnswElement element, Relation index, int m)
 {
 	Buffer		buf;
 	Page		page;
@@ -387,11 +407,42 @@ LoadNeighbors(HnswElement element, Relation index)
 	LockBuffer(buf, BUFFER_LOCK_SHARE);
 	page = BufferGetPage(buf);
 
-	LoadNeighborsFromPage(element, index, page);
+	LoadNeighborsFromPage(element, index, page, m);
 
 	UnlockReleaseBuffer(buf);
 }
 
+/*
+ * Load an element from a tuple
+ */
+void
+HnswLoadElementFromTuple(HnswElement element, HnswElementTuple etup, bool loadHeaptids, bool loadVec)
+{
+	element->level = etup->level;
+	element->deleted = etup->deleted;
+	element->neighborPage = ItemPointerGetBlockNumber(&etup->neighbortid);
+	element->neighborOffno = ItemPointerGetOffsetNumber(&etup->neighbortid);
+	element->heaptids = NIL;
+
+	if (loadHeaptids)
+	{
+		for (int i = 0; i < HNSW_HEAPTIDS; i++)
+		{
+			/* Can stop at first invalid */
+			if (!ItemPointerIsValid(&etup->heaptids[i]))
+				break;
+
+			HnswAddHeapTid(element, &etup->heaptids[i]);
+		}
+	}
+
+	if (loadVec)
+	{
+		element->vec = palloc(VECTOR_SIZE(etup->vec.dim));
+		memcpy(element->vec, &etup->vec, VECTOR_SIZE(etup->vec.dim));
+	}
+}
+
 /*
  * Load an element and optionally get its distance from q
  */
@@ -412,25 +463,7 @@ HnswLoadElement(HnswElement element, float *distance, Datum *q, Relation index,
 	Assert(HnswIsElementTuple(etup));
 
 	/* Load element */
-	element->heaptids = NIL;
-	for (int i = 0; i < HNSW_HEAPTIDS; i++)
-	{
-		/* Can stop at first invalid */
-		if (!ItemPointerIsValid(&etup->heaptids[i]))
-			break;
-
-		HnswAddHeapTid(element, &etup->heaptids[i]);
-	}
-	element->level = etup->level;
-	element->neighborPage = ItemPointerGetBlockNumber(&etup->neighbortid);
-	element->neighborOffno = ItemPointerGetOffsetNumber(&etup->neighbortid);
-	element->deleted = etup->deleted;
-
-	if (loadVec)
-	{
-		element->vec = palloc(VECTOR_SIZE(etup->vec.dim));
-		memcpy(element->vec, &etup->vec, VECTOR_SIZE(etup->vec.dim));
-	}
+	HnswLoadElementFromTuple(element, etup, true, loadVec);
 
 	/* Calculate distance */
 	if (distance != NULL)
@@ -452,7 +485,7 @@ GetCandidateDistance(HnswCandidate * hc, Datum q, FmgrInfo *procinfo, Oid collat
  * Create a candidate for the entry point
  */
 HnswCandidate *
-HnswEntryCandidate(HnswElement entryPoint, Datum q, Relation index, FmgrInfo *procinfo, Oid collation, bool loadvec)
+HnswEntryCandidate(HnswElement entryPoint, Datum q, Relation index, FmgrInfo *procinfo, Oid collation, bool loadVec)
 {
 	HnswCandidate *hc = palloc(sizeof(HnswCandidate));
 
@@ -460,7 +493,7 @@ HnswEntryCandidate(HnswElement entryPoint, Datum q, Relation index, FmgrInfo *pr
 	if (index == NULL)
 		hc->distance = GetCandidateDistance(hc, q, procinfo, collation);
 	else
-		HnswLoadElement(hc->element, &hc->distance, &q, index, procinfo, collation, loadvec);
+		HnswLoadElement(hc->element, &hc->distance, &q, index, procinfo, collation, loadVec);
 	return hc;
 }
 
@@ -527,7 +560,7 @@ AddToVisited(HTAB *v, HnswCandidate * hc, Relation index, bool *found)
  * Algorithm 2 from paper
  */
 List *
-HnswSearchLayer(Datum q, List *ep, int ef, int lc, Relation index, FmgrInfo *procinfo, Oid collation, bool inserting, BlockNumber *skipPage, OffsetNumber *skipOffno)
+HnswSearchLayer(Datum q, List *ep, int ef, int lc, Relation index, FmgrInfo *procinfo, Oid collation, int m, bool inserting, HnswElement skipElement)
 {
 	ListCell   *lc2;
 
@@ -563,7 +596,13 @@ HnswSearchLayer(Datum q, List *ep, int ef, int lc, Relation index, FmgrInfo *pro
 		pairingheap_add(C, &(CreatePairingHeapNode(hc)->ph_node));
 		pairingheap_add(W, &(CreatePairingHeapNode(hc)->ph_node));
 
-		wlen++;
+		/*
+		 * Do not count elements being deleted towards ef when vacuuming. It
+		 * would be ideal to do this for inserts as well, but this could
+		 * affect insert performance.
+		 */
+		if (skipElement == NULL || list_length(hc->element->heaptids) != 0)
+			wlen++;
 	}
 
 	while (!pairingheap_is_empty(C))
@@ -576,7 +615,7 @@ HnswSearchLayer(Datum q, List *ep, int ef, int lc, Relation index, FmgrInfo *pro
 			break;
 
 		if (c->element->neighbors == NULL)
-			LoadNeighbors(c->element, index);
+			HnswLoadNeighbors(c->element, index, m);
 
 		/* Get the neighborhood at layer lc */
 		neighborhood = &c->element->neighbors[lc];
@@ -599,17 +638,7 @@ HnswSearchLayer(Datum q, List *ep, int ef, int lc, Relation index, FmgrInfo *pro
 				else
 					HnswLoadElement(e->element, &eDistance, &q, index, procinfo, collation, inserting);
 
-				/* Skip if fully deleted */
-				if (e->element->deleted)
-					continue;
-
-				/* Skip for inserts if deleting */
-				if (inserting && list_length(e->element->heaptids) == 0)
-					continue;
-
-				/* Skip self for vacuuming update */
-				if (skipPage != NULL && e->element->neighborPage == *skipPage && e->element->neighborOffno == *skipOffno)
-					continue;
+				Assert(!e->element->deleted);
 
 				/* Make robust to issues */
 				if (e->element->level < lc)
@@ -625,11 +654,20 @@ HnswSearchLayer(Datum q, List *ep, int ef, int lc, Relation index, FmgrInfo *pro
 
 					pairingheap_add(C, &(CreatePairingHeapNode(ec)->ph_node));
 					pairingheap_add(W, &(CreatePairingHeapNode(ec)->ph_node));
-					wlen++;
 
-					/* No need to decrement wlen */
-					if (wlen > ef)
-						pairingheap_remove_first(W);
+					/*
+					 * Do not count elements being deleted towards ef when
+					 * vacuuming. It would be ideal to do this for inserts as
+					 * well, but this could affect insert performance.
+					 */
+					if (skipElement == NULL || list_length(e->element->heaptids) != 0)
+					{
+						wlen++;
+
+						/* No need to decrement wlen */
+						if (wlen > ef)
+							pairingheap_remove_first(W);
+					}
 				}
 			}
 		}
@@ -708,7 +746,7 @@ SelectNeighbors(List *c, int m, int lc, FmgrInfo *procinfo, Oid collation, HnswC
 	List	   *w = list_copy(c);
 	pairingheap *wd;
 
-	if (list_length(w) < m)
+	if (list_length(w) <= m)
 		return w;
 
 	wd = pairingheap_allocate(CompareNearestCandidates, NULL);
@@ -748,14 +786,14 @@ SelectNeighbors(List *c, int m, int lc, FmgrInfo *procinfo, Oid collation, HnswC
 /*
  * Find duplicate element
  */
-static HnswElement
-HnswFindDuplicate(HnswElement e, List *neighbors)
+HnswElement
+HnswFindDuplicate(HnswElement e)
 {
-	ListCell   *lc;
+	HnswNeighborArray *neighbors = &e->neighbors[0];
 
-	foreach(lc, neighbors)
+	for (int i = 0; i < neighbors->length; i++)
 	{
-		HnswCandidate *neighbor = lfirst(lc);
+		HnswCandidate *neighbor = &neighbors->items[i];
 
 		/* Exit early since ordered by distance */
 		if (vector_cmp_internal(e->vec, neighbor->element->vec) != 0)
@@ -804,50 +842,57 @@ CompareCandidateDistances(const void *a, const void *b)
 	return 0;
 }
 
-/*
- * Create update
- */
-static HnswUpdate *
-CreateUpdate(HnswCandidate * hc, int level, int index)
-{
-	HnswUpdate *update = palloc(sizeof(HnswUpdate));
-
-	update->hc = *hc;
-	update->level = level;
-	update->index = index;
-	return update;
-}
-
 /*
  * Update connections
  */
-static void
-UpdateConnections(HnswElement element, List *neighbors, int m, int lc, List **updates, Relation index, FmgrInfo *procinfo, Oid collation)
+void
+HnswUpdateConnection(HnswElement element, HnswCandidate * hc, int m, int lc, int *updateIdx, Relation index, FmgrInfo *procinfo, Oid collation)
 {
-	ListCell   *lc2;
+	HnswNeighborArray *currentNeighbors = &hc->element->neighbors[lc];
 
-	foreach(lc2, neighbors)
+	HnswCandidate hc2;
+
+	hc2.element = element;
+	hc2.distance = hc->distance;
+
+	if (currentNeighbors->length < m)
 	{
-		HnswCandidate *hc = (HnswCandidate *) lfirst(lc2);
-		HnswNeighborArray *currentNeighbors = &hc->element->neighbors[lc];
+		currentNeighbors->items[currentNeighbors->length++] = hc2;
 
-		HnswCandidate hc2;
+		/* Track update */
+		if (updateIdx != NULL)
+			*updateIdx = -2;
+	}
+	else
+	{
+		/* Shrink connections */
+		HnswCandidate *pruned = NULL;
 
-		hc2.element = element;
-		hc2.distance = hc->distance;
-
-		if (currentNeighbors->length < m)
+		/* Load elements on insert */
+		if (index != NULL)
 		{
-			currentNeighbors->items[currentNeighbors->length++] = hc2;
+			Datum		q = PointerGetDatum(hc->element->vec);
 
-			/* Track updates */
-			if (updates != NULL)
-				*updates = lappend(*updates, CreateUpdate(hc, lc, currentNeighbors->length - 1));
+			for (int i = 0; i < currentNeighbors->length; i++)
+			{
+				HnswCandidate *hc3 = &currentNeighbors->items[i];
+
+				if (hc3->element->vec == NULL)
+					HnswLoadElement(hc3->element, &hc3->distance, &q, index, procinfo, collation, true);
+				else
+					hc3->distance = GetCandidateDistance(hc3, q, procinfo, collation);
+
+				/* Prune element if being deleted */
+				if (list_length(hc3->element->heaptids) == 0)
+				{
+					pruned = &currentNeighbors->items[i];
+					break;
+				}
+			}
 		}
-		else
+
+		if (pruned == NULL)
 		{
-			/* Shrink connections */
-			HnswCandidate *pruned = NULL;
 			List	   *c = NIL;
 
 			/* Add and sort candidates */
@@ -856,127 +901,109 @@ UpdateConnections(HnswElement element, List *neighbors, int m, int lc, List **up
 			c = lappend(c, &hc2);
 			list_sort(c, CompareCandidateDistances);
 
-			/* Load elements on insert */
-			if (index != NULL)
-			{
-				for (int i = 0; i < currentNeighbors->length; i++)
-				{
-					if (currentNeighbors->items[i].element->vec == NULL)
-					{
-						HnswLoadElement(currentNeighbors->items[i].element, NULL, NULL, index, procinfo, collation, true);
-
-						/* Prune deleted element */
-						if (currentNeighbors->items[i].element->deleted)
-						{
-							pruned = &currentNeighbors->items[i];
-							break;
-						}
-					}
-				}
-			}
+			SelectNeighbors(c, m, lc, procinfo, collation, &pruned);
 
+			/* Should not happen */
 			if (pruned == NULL)
+				return;
+		}
+
+		/* Find and replace the pruned element */
+		for (int i = 0; i < currentNeighbors->length; i++)
+		{
+			if (currentNeighbors->items[i].element == pruned->element)
 			{
-				SelectNeighbors(c, m, lc, procinfo, collation, &pruned);
+				currentNeighbors->items[i] = hc2;
 
-				/* Should not happen */
-				if (pruned == NULL)
-					continue;
-			}
+				/* Track update */
+				if (updateIdx != NULL)
+					*updateIdx = i;
 
-			/* Find and replace the pruned element */
-			for (int i = 0; i < currentNeighbors->length; i++)
-			{
-				if (currentNeighbors->items[i].element == pruned->element)
-				{
-					currentNeighbors->items[i] = hc2;
-
-					/* Track updates */
-					if (updates != NULL)
-						*updates = lappend(*updates, CreateUpdate(hc, lc, i));
-
-					break;
-				}
+				break;
 			}
 		}
 	}
 }
 
+/*
+ * Remove elements being deleted or skipped
+ */
+static List *
+RemoveElements(List *w, HnswElement skipElement)
+{
+	ListCell   *lc2;
+	List	   *w2 = NIL;
+
+	foreach(lc2, w)
+	{
+		HnswCandidate *hc = (HnswCandidate *) lfirst(lc2);
+
+		/* Skip self for vacuuming update */
+		if (skipElement != NULL && hc->element->blkno == skipElement->blkno && hc->element->offno == skipElement->offno)
+			continue;
+
+		if (list_length(hc->element->heaptids) != 0)
+			w2 = lappend(w2, hc);
+	}
+
+	return w2;
+}
+
 /*
  * Algorithm 1 from paper
  */
-HnswElement
-HnswInsertElement(HnswElement element, HnswElement entryPoint, Relation index, FmgrInfo *procinfo, Oid collation, int m, int efConstruction, List **updates, bool vacuuming)
+void
+HnswInsertElement(HnswElement element, HnswElement entryPoint, Relation index, FmgrInfo *procinfo, Oid collation, int m, int efConstruction, bool existing)
 {
-	List	   *ep = NIL;
+	List	   *ep;
 	List	   *w;
 	int			level = element->level;
 	int			entryLevel;
-	List	  **newNeighbors = palloc(sizeof(List *) * (level + 1));
 	Datum		q = PointerGetDatum(element->vec);
-	HnswElement dup;
-	BlockNumber *skipPage = vacuuming ? &element->neighborPage : NULL;
-	OffsetNumber *skipOffno = vacuuming ? &element->neighborOffno : NULL;
-	bool		removeEntryPoint;
-	HnswCandidate *entryCandidate;
+	HnswElement skipElement = existing ? element : NULL;
+
+	/* No neighbors if no entry point */
+	if (entryPoint == NULL)
+		return;
 
 	/* Get entry point and level */
-	if (entryPoint != NULL)
-	{
-		entryCandidate = HnswEntryCandidate(entryPoint, q, index, procinfo, collation, true);
-		ep = lappend(ep, entryCandidate);
-		entryLevel = entryPoint->level;
-		removeEntryPoint = vacuuming && list_length(entryPoint->heaptids) == 0;
-	}
-	else
-	{
-		entryLevel = -1;
-		removeEntryPoint = false;
-	}
+	ep = list_make1(HnswEntryCandidate(entryPoint, q, index, procinfo, collation, true));
+	entryLevel = entryPoint->level;
 
 	/* 1st phase: greedy search to insert level */
 	for (int lc = entryLevel; lc >= level + 1; lc--)
 	{
-		w = HnswSearchLayer(q, ep, 1, lc, index, procinfo, collation, true, skipPage, skipOffno);
+		w = HnswSearchLayer(q, ep, 1, lc, index, procinfo, collation, m, true, skipElement);
 		ep = w;
 	}
 
 	if (level > entryLevel)
 		level = entryLevel;
 
+	/* Add one for existing element */
+	if (existing)
+		efConstruction++;
+
 	/* 2nd phase */
 	for (int lc = level; lc >= 0; lc--)
 	{
 		int			lm = HnswGetLayerM(m, lc);
+		List	   *neighbors;
+		List	   *lw;
 
-		w = HnswSearchLayer(q, ep, efConstruction, lc, index, procinfo, collation, true, skipPage, skipOffno);
+		w = HnswSearchLayer(q, ep, efConstruction, lc, index, procinfo, collation, m, true, skipElement);
 
-		/* Remove entry point if it's being deleted */
-		if (removeEntryPoint)
-			w = list_delete_ptr(w, entryCandidate);
+		/* Elements being deleted or skipped can help with search */
+		/* but should be removed before selecting neighbors */
+		if (index != NULL)
+			lw = RemoveElements(w, skipElement);
+		else
+			lw = w;
+
+		neighbors = SelectNeighbors(lw, lm, lc, procinfo, collation, NULL);
+
+		AddConnections(element, neighbors, lm, lc);
 
-		newNeighbors[lc] = SelectNeighbors(w, lm, lc, procinfo, collation, NULL);
 		ep = w;
 	}
-
-	/* Look for duplicate */
-	if (level >= 0 && !vacuuming)
-	{
-		dup = HnswFindDuplicate(element, newNeighbors[0]);
-		if (dup != NULL)
-			return dup;
-	}
-
-	/* Update connections */
-	for (int lc = level; lc >= 0; lc--)
-	{
-		int			lm = HnswGetLayerM(m, lc);
-
-		AddConnections(element, newNeighbors[lc], lm, lc);
-
-		if (!vacuuming)
-			UpdateConnections(element, newNeighbors[lc], lm, lc, updates, index, procinfo, collation);
-	}
-
-	return NULL;
 }

src/hnswvacuum.c

@@ -5,10 +5,11 @@
 #include "commands/vacuum.h"
 #include "hnsw.h"
 #include "storage/bufmgr.h"
+#include "storage/lmgr.h"
 #include "utils/memutils.h"
 
 /*
- * Check if deleted list contains an index tid
+ * Check if deleted list contains an index TID
  */
 static bool
 DeletedContains(HTAB *deleted, ItemPointer indextid)
@@ -32,6 +33,7 @@ RemoveHeapTids(HnswVacuumState * vacuumstate)
 	Relation	index = vacuumstate->index;
 	BufferAccessStrategy bas = vacuumstate->bas;
 	HnswElement entryPoint = HnswGetEntryPoint(vacuumstate->index);
+	IndexBulkDeleteResult *stats = vacuumstate->stats;
 
 	/* Store separately since highestPoint.level is uint8 */
 	int			highestLevel = -1;
@@ -77,11 +79,15 @@ RemoveHeapTids(HnswVacuumState * vacuumstate)
 						break;
 
 					if (vacuumstate->callback(&etup->heaptids[i], vacuumstate->callback_state))
+					{
 						itemUpdated = true;
+						stats->tuples_removed++;
+					}
 					else
 					{
 						/* Move to front of list */
 						etup->heaptids[idx++] = etup->heaptids[i];
+						stats->num_index_tuples++;
 					}
 				}
 
@@ -109,7 +115,7 @@ RemoveHeapTids(HnswVacuumState * vacuumstate)
 
 				(void) hash_search(vacuumstate->deleted, &ip, HASH_ENTER, NULL);
 			}
-			else if (etup->level > highestLevel && !(blkno == entryPoint->blkno && offno == entryPoint->offno))
+			else if (etup->level > highestLevel && !(entryPoint != NULL && blkno == entryPoint->blkno && offno == entryPoint->offno))
 			{
 				/* Keep track of highest non-entry point */
 				highestPoint->blkno = blkno;
@@ -156,19 +162,24 @@ NeedsUpdated(HnswVacuumState * vacuumstate, HnswElement element)
 	/* Check neighbors */
 	for (int i = 0; i < ntup->count; i++)
 	{
-		HnswNeighborTupleItem *neighbor = &ntup->neighbors[i];
+		ItemPointer indextid = &ntup->indextids[i];
 
-		if (!ItemPointerIsValid(&neighbor->indextid))
+		if (!ItemPointerIsValid(indextid))
 			continue;
 
 		/* Check if in deleted list */
-		if (DeletedContains(vacuumstate->deleted, &neighbor->indextid))
+		if (DeletedContains(vacuumstate->deleted, indextid))
 		{
 			needsUpdated = true;
 			break;
 		}
 	}
 
+	/* Also update if layer 0 is not full */
+	/* This could indicate too many candidates being deleted during insert */
+	if (!needsUpdated)
+		needsUpdated = !ItemPointerIsValid(&ntup->indextids[ntup->count - 1]);
+
 	UnlockReleaseBuffer(buf);
 
 	return needsUpdated;
@@ -178,7 +189,7 @@ NeedsUpdated(HnswVacuumState * vacuumstate, HnswElement element)
  * Repair graph for a single element
  */
 static void
-RepairGraphElement(HnswVacuumState * vacuumstate, HnswElement element)
+RepairGraphElement(HnswVacuumState * vacuumstate, HnswElement element, HnswElement entryPoint)
 {
 	Relation	index = vacuumstate->index;
 	Buffer		buf;
@@ -188,42 +199,20 @@ RepairGraphElement(HnswVacuumState * vacuumstate, HnswElement element)
 	int			efConstruction = vacuumstate->efConstruction;
 	FmgrInfo   *procinfo = vacuumstate->procinfo;
 	Oid			collation = vacuumstate->collation;
-	HnswElement entryPoint;
 	BufferAccessStrategy bas = vacuumstate->bas;
 	HnswNeighborTuple ntup = vacuumstate->ntup;
 	Size		ntupSize = HNSW_NEIGHBOR_TUPLE_SIZE(element->level, m);
 
-	/* Check if any neighbors point to deleted values */
-	if (!NeedsUpdated(vacuumstate, element))
+	/* Skip if element is entry point */
+	if (entryPoint != NULL && element->blkno == entryPoint->blkno && element->offno == entryPoint->offno)
 		return;
 
-	/* Refresh entry point for each element */
-	entryPoint = HnswGetEntryPoint(index);
-
-	/* Special case for entry point */
-	if (element->blkno == entryPoint->blkno && element->offno == entryPoint->offno)
-	{
-		if (BlockNumberIsValid(vacuumstate->highestPoint.blkno))
-		{
-			/* Already updated */
-			if (vacuumstate->highestPoint.blkno == element->blkno && vacuumstate->highestPoint.offno == element->offno)
-				return;
-
-			entryPoint = &vacuumstate->highestPoint;
-
-			/* Reset neighbors from previous update */
-			entryPoint->neighbors = NULL;
-		}
-		else
-			entryPoint = NULL;
-	}
-
 	/* Init fields */
 	HnswInitNeighbors(element, m);
 	element->heaptids = NIL;
 
 	/* Add element to graph, skipping itself */
-	HnswInsertElement(element, entryPoint, index, procinfo, collation, m, efConstruction, NULL, true);
+	HnswInsertElement(element, entryPoint, index, procinfo, collation, m, efConstruction, true);
 
 	/* Update neighbor tuple */
 	/* Do this before getting page to minimize locking */
@@ -243,6 +232,9 @@ RepairGraphElement(HnswVacuumState * vacuumstate, HnswElement element)
 	MarkBufferDirty(buf);
 	GenericXLogFinish(state);
 	UnlockReleaseBuffer(buf);
+
+	/* Update neighbors */
+	HnswUpdateNeighborPages(index, procinfo, collation, element, m, true);
 }
 
 /*
@@ -256,16 +248,35 @@ RepairGraphEntryPoint(HnswVacuumState * vacuumstate)
 	HnswElement entryPoint;
 	MemoryContext oldCtx = MemoryContextSwitchTo(vacuumstate->tmpCtx);
 
-	/* Repair graph for highest non-entry point */
-	/* This may not be the highest with new inserts, but should be fine */
-	if (BlockNumberIsValid(highestPoint->blkno))
+	if (!BlockNumberIsValid(highestPoint->blkno))
+		highestPoint = NULL;
+
+	/*
+	 * Repair graph for highest non-entry point. Highest point may be outdated
+	 * due to inserts that happen during and after RemoveHeapTids.
+	 */
+	if (highestPoint != NULL)
 	{
+		/* Get a shared lock */
+		LockPage(index, HNSW_UPDATE_LOCK, ShareLock);
+
+		/* Load element */
 		HnswLoadElement(highestPoint, NULL, NULL, index, vacuumstate->procinfo, vacuumstate->collation, true);
-		RepairGraphElement(vacuumstate, highestPoint);
+
+		/* Repair if needed */
+		if (NeedsUpdated(vacuumstate, highestPoint))
+			RepairGraphElement(vacuumstate, highestPoint, HnswGetEntryPoint(index));
+
+		/* Release lock */
+		UnlockPage(index, HNSW_UPDATE_LOCK, ShareLock);
 	}
 
-	/* See if entry point needs updated */
+	/* Prevent concurrent inserts when possibly updating entry point */
+	LockPage(index, HNSW_UPDATE_LOCK, ExclusiveLock);
+
+	/* Get latest entry point */
 	entryPoint = HnswGetEntryPoint(index);
+
 	if (entryPoint != NULL)
 	{
 		ItemPointerData epData;
@@ -273,15 +284,37 @@ RepairGraphEntryPoint(HnswVacuumState * vacuumstate)
 		ItemPointerSet(&epData, entryPoint->blkno, entryPoint->offno);
 
 		if (DeletedContains(vacuumstate->deleted, &epData))
-			HnswUpdateMetaPage(index, true, highestPoint, InvalidBlockNumber, MAIN_FORKNUM);
+		{
+			/*
+			 * Replace the entry point with the highest point. If highest
+			 * point is outdated and empty, the entry point will be empty
+			 * until an element is repaired.
+			 */
+			HnswUpdateMetaPage(index, HNSW_UPDATE_ENTRY_ALWAYS, highestPoint, InvalidBlockNumber, MAIN_FORKNUM);
+		}
 		else
 		{
-			/* Highest point will be used to repair */
+			/*
+			 * Repair the entry point with the highest point. If highest point
+			 * 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, vacuumstate->procinfo, vacuumstate->collation, true);
-			RepairGraphElement(vacuumstate, entryPoint);
+
+			if (NeedsUpdated(vacuumstate, entryPoint))
+			{
+				/* Reset neighbors from previous update */
+				if (highestPoint != NULL)
+					highestPoint->neighbors = NULL;
+
+				RepairGraphElement(vacuumstate, entryPoint, highestPoint);
+			}
 		}
 	}
 
+	/* Release lock */
+	UnlockPage(index, HNSW_UPDATE_LOCK, ExclusiveLock);
+
 	/* Reset memory context */
 	MemoryContextSwitchTo(oldCtx);
 	MemoryContextReset(vacuumstate->tmpCtx);
@@ -297,6 +330,14 @@ RepairGraph(HnswVacuumState * vacuumstate)
 	BufferAccessStrategy bas = vacuumstate->bas;
 	BlockNumber blkno = HNSW_HEAD_BLKNO;
 
+	/*
+	 * Wait for inserts to complete. Inserts before this point may have
+	 * neighbors about to be deleted. Inserts after this point will not.
+	 */
+	LockPage(index, HNSW_UPDATE_LOCK, ExclusiveLock);
+	UnlockPage(index, HNSW_UPDATE_LOCK, ExclusiveLock);
+
+	/* Repair entry point first */
 	RepairGraphEntryPoint(vacuumstate);
 
 	while (BlockNumberIsValid(blkno))
@@ -333,14 +374,8 @@ RepairGraph(HnswVacuumState * vacuumstate)
 				continue;
 
 			/* Create an element */
-			element = palloc(sizeof(HnswElementData));
-			element->neighborPage = ItemPointerGetBlockNumber(&etup->neighbortid);
-			element->neighborOffno = ItemPointerGetOffsetNumber(&etup->neighbortid);
-			element->level = etup->level;
-			element->blkno = blkno;
-			element->offno = offno;
-			element->vec = palloc(VECTOR_SIZE(etup->vec.dim));
-			memcpy(element->vec, &etup->vec, VECTOR_SIZE(etup->vec.dim));
+			element = HnswInitElementFromBlock(blkno, offno);
+			HnswLoadElementFromTuple(element, etup, false, true);
 
 			elements = lappend(elements, element);
 		}
@@ -351,7 +386,48 @@ RepairGraph(HnswVacuumState * vacuumstate)
 
 		/* Update neighbor pages */
 		foreach(lc2, elements)
-			RepairGraphElement(vacuumstate, (HnswElement) lfirst(lc2));
+		{
+			HnswElement element = (HnswElement) lfirst(lc2);
+			HnswElement entryPoint;
+			LOCKMODE	lockmode = ShareLock;
+
+			/* Check if any neighbors point to deleted values */
+			if (!NeedsUpdated(vacuumstate, element))
+				continue;
+
+			/* Get a shared lock */
+			LockPage(index, HNSW_UPDATE_LOCK, lockmode);
+
+			/* Refresh entry point for each element */
+			entryPoint = HnswGetEntryPoint(index);
+
+			/* Prevent concurrent inserts when likely updating entry point */
+			if (entryPoint == NULL || element->level > entryPoint->level)
+			{
+				/* Release shared lock */
+				UnlockPage(index, HNSW_UPDATE_LOCK, lockmode);
+
+				/* Get exclusive lock */
+				lockmode = ExclusiveLock;
+				LockPage(index, HNSW_UPDATE_LOCK, lockmode);
+
+				/* Get latest entry point after lock is acquired */
+				entryPoint = HnswGetEntryPoint(index);
+			}
+
+			/* Repair connections */
+			RepairGraphElement(vacuumstate, element, entryPoint);
+
+			/*
+			 * Update metapage if needed. Should only happen if entry point
+			 * was replaced and highest point was outdated.
+			 */
+			if (entryPoint == NULL || element->level > entryPoint->level)
+				HnswUpdateMetaPage(index, HNSW_UPDATE_ENTRY_GREATER, element, InvalidBlockNumber, MAIN_FORKNUM);
+
+			/* Release lock */
+			UnlockPage(index, HNSW_UPDATE_LOCK, lockmode);
+		}
 
 		/* Reset memory context */
 		MemoryContextSwitchTo(oldCtx);
@@ -369,7 +445,14 @@ MarkDeleted(HnswVacuumState * vacuumstate)
 	BlockNumber insertPage = InvalidBlockNumber;
 	Relation	index = vacuumstate->index;
 	BufferAccessStrategy bas = vacuumstate->bas;
-	IndexBulkDeleteResult *stats = vacuumstate->stats;
+
+	/*
+	 * 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.
+	 */
+	LockPage(index, HNSW_SCAN_LOCK, ExclusiveLock);
+	UnlockPage(index, HNSW_SCAN_LOCK, ExclusiveLock);
 
 	while (BlockNumberIsValid(blkno))
 	{
@@ -413,17 +496,17 @@ MarkDeleted(HnswVacuumState * vacuumstate)
 
 			/* Skip deleted tuples */
 			if (etup->deleted)
-				continue;
-
-			/* Skip live tuples */
-			if (ItemPointerIsValid(&etup->heaptids[0]))
 			{
-				stats->num_index_tuples++;
+				/* Set to first free page */
+				if (!BlockNumberIsValid(insertPage))
+					insertPage = blkno;
+
 				continue;
 			}
 
-			/* Update stats */
-			stats->tuples_removed++;
+			/* Skip live tuples */
+			if (ItemPointerIsValid(&etup->heaptids[0]))
+				continue;
 
 			/* Calculate sizes */
 			etupSize = HNSW_ELEMENT_TUPLE_SIZE(etup->vec.dim);
@@ -453,10 +536,7 @@ MarkDeleted(HnswVacuumState * vacuumstate)
 
 			/* Overwrite neighbors */
 			for (int i = 0; i < ntup->count; i++)
-			{
-				ItemPointerSetInvalid(&ntup->neighbors[i].indextid);
-				ntup->neighbors[i].distance = NAN;
-			}
+				ItemPointerSetInvalid(&ntup->indextids[i]);
 
 			/* Overwrite element tuple */
 			if (!PageIndexTupleOverwrite(page, offno, (Item) etup, etupSize))
@@ -489,7 +569,8 @@ MarkDeleted(HnswVacuumState * vacuumstate)
 		UnlockReleaseBuffer(buf);
 	}
 
-	HnswUpdateMetaPage(index, false, NULL, insertPage, MAIN_FORKNUM);
+	/* Update insert page last, after everything has been marked as deleted */
+	HnswUpdateMetaPage(index, 0, NULL, insertPage, MAIN_FORKNUM);
 }
 
 /*
@@ -508,7 +589,6 @@ InitVacuumState(HnswVacuumState * vacuumstate, IndexVacuumInfo *info, IndexBulkD
 	vacuumstate->stats = stats;
 	vacuumstate->callback = callback;
 	vacuumstate->callback_state = callback_state;
-	vacuumstate->m = HnswGetM(index);
 	vacuumstate->efConstruction = HnswGetEfConstruction(index);
 	vacuumstate->bas = GetAccessStrategy(BAS_BULKREAD);
 	vacuumstate->procinfo = index_getprocinfo(index, 1, HNSW_DISTANCE_PROC);
@@ -518,6 +598,9 @@ InitVacuumState(HnswVacuumState * vacuumstate, IndexVacuumInfo *info, IndexBulkD
 												"Hnsw vacuum temporary context",
 												ALLOCSET_DEFAULT_SIZES);
 
+	/* Get m from metapage */
+	HnswGetMetaPageInfo(index, &vacuumstate->m, NULL);
+
 	/* Create hash table */
 	hash_ctl.keysize = sizeof(ItemPointerData);
 	hash_ctl.entrysize = sizeof(ItemPointerData);

src/ivfbuild.c

@@ -10,8 +10,8 @@
 #include "ivfflat.h"
 #include "miscadmin.h"
 #include "storage/bufmgr.h"
-#include "utils/memutils.h"
 #include "tcop/tcopprot.h"
+#include "utils/memutils.h"
 
 #if PG_VERSION_NUM >= 140000
 #include "utils/backend_progress.h"

src/ivfflat.c

@@ -24,7 +24,7 @@ IvfflatInit(void)
 {
 	ivfflat_relopt_kind = add_reloption_kind();
 	add_int_reloption(ivfflat_relopt_kind, "lists", "Number of inverted lists",
-					  IVFFLAT_DEFAULT_LISTS, 1, IVFFLAT_MAX_LISTS
+					  IVFFLAT_DEFAULT_LISTS, IVFFLAT_MIN_LISTS, IVFFLAT_MAX_LISTS
 #if PG_VERSION_NUM >= 130000
 					  ,AccessExclusiveLock
 #endif
@@ -32,7 +32,7 @@ IvfflatInit(void)
 
 	DefineCustomIntVariable("ivfflat.probes", "Sets the number of probes",
 							"Valid range is 1..lists.", &ivfflat_probes,
-							1, 1, IVFFLAT_MAX_LISTS, PGC_USERSET, 0, NULL, NULL, NULL);
+							IVFFLAT_DEFAULT_PROBES, IVFFLAT_MIN_LISTS, IVFFLAT_MAX_LISTS, PGC_USERSET, 0, NULL, NULL, NULL);
 }
 
 /*
@@ -71,7 +71,7 @@ ivfflatcostestimate(PlannerInfo *root, IndexPath *path, double loop_count,
 	int			lists;
 	double		ratio;
 	double		spc_seq_page_cost;
-	Relation	indexRel;
+	Relation	index;
 #if PG_VERSION_NUM < 120000
 	List	   *qinfos;
 #endif
@@ -89,9 +89,9 @@ ivfflatcostestimate(PlannerInfo *root, IndexPath *path, double loop_count,
 
 	MemSet(&costs, 0, sizeof(costs));
 
-	indexRel = index_open(path->indexinfo->indexoid, NoLock);
-	lists = IvfflatGetLists(indexRel);
-	index_close(indexRel, NoLock);
+	index = index_open(path->indexinfo->indexoid, NoLock);
+	IvfflatGetMetaPageInfo(index, &lists, NULL);
+	index_close(index, NoLock);
 
 	/* Get the ratio of lists that we need to visit */
 	ratio = ((double) ivfflat_probes) / lists;

src/ivfflat.h

@@ -40,8 +40,14 @@
 #define IVFFLAT_METAPAGE_BLKNO	0
 #define IVFFLAT_HEAD_BLKNO		1	/* first list page */
 
+/* Must correspond to page numbers since page lock is used */
+#define IVFFLAT_SCAN_LOCK		0
+
+/* IVFFlat parameters */
 #define IVFFLAT_DEFAULT_LISTS	100
+#define IVFFLAT_MIN_LISTS		1
 #define IVFFLAT_MAX_LISTS		32768
+#define IVFFLAT_DEFAULT_PROBES	1
 
 /* Build phases */
 /* PROGRESS_CREATEIDX_SUBPHASE_INITIALIZE is 1 */
@@ -241,8 +247,11 @@ typedef struct IvfflatScanList
 typedef struct IvfflatScanOpaqueData
 {
 	int			probes;
+	int			dimensions;
 	bool		first;
+	bool		hasLock;
 	Buffer		buf;
+	ItemPointerData heaptid;
 
 	/* Sorting */
 	Tuplesortstate *sortstate;
@@ -275,6 +284,7 @@ void		IvfflatKmeans(Relation index, VectorArray samples, VectorArray centers);
 FmgrInfo   *IvfflatOptionalProcInfo(Relation rel, uint16 procnum);
 bool		IvfflatNormValue(FmgrInfo *procinfo, Oid collation, Datum *value, Vector * result);
 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);
 void		IvfflatCommitBuffer(Buffer buf, GenericXLogState *state);
 void		IvfflatAppendPage(Relation index, Buffer *buf, Page *page, GenericXLogState **state, ForkNumber forkNum);

src/ivfscan.c

@@ -9,6 +9,7 @@
 #include "miscadmin.h"
 #include "pgstat.h"
 #include "storage/bufmgr.h"
+#include "storage/lmgr.h"
 
 /*
  * Compare list distances
@@ -31,36 +32,36 @@ CompareLists(const pairingheap_node *a, const pairingheap_node *b, void *arg)
 static void
 GetScanLists(IndexScanDesc scan, Datum value)
 {
-	Buffer		cbuf;
-	Page		cpage;
-	IvfflatList list;
-	OffsetNumber offno;
-	OffsetNumber maxoffno;
+	IvfflatScanOpaque so = (IvfflatScanOpaque) scan->opaque;
 	BlockNumber nextblkno = IVFFLAT_HEAD_BLKNO;
 	int			listCount = 0;
-	IvfflatScanOpaque so = (IvfflatScanOpaque) scan->opaque;
-	double		distance;
-	IvfflatScanList *scanlist;
 	double		maxDistance = DBL_MAX;
 
 	/* Search all list pages */
 	while (BlockNumberIsValid(nextblkno))
 	{
+		Buffer		cbuf;
+		Page		cpage;
+		OffsetNumber maxoffno;
+
 		cbuf = ReadBuffer(scan->indexRelation, nextblkno);
 		LockBuffer(cbuf, BUFFER_LOCK_SHARE);
 		cpage = BufferGetPage(cbuf);
 
 		maxoffno = PageGetMaxOffsetNumber(cpage);
 
-		for (offno = FirstOffsetNumber; offno <= maxoffno; offno = OffsetNumberNext(offno))
+		for (OffsetNumber offno = FirstOffsetNumber; offno <= maxoffno; offno = OffsetNumberNext(offno))
 		{
-			list = (IvfflatList) PageGetItem(cpage, PageGetItemId(cpage, offno));
+			IvfflatList list = (IvfflatList) PageGetItem(cpage, PageGetItemId(cpage, offno));
+			double		distance;
 
 			/* Use procinfo from the index instead of scan key for performance */
 			distance = DatumGetFloat8(FunctionCall2Coll(so->procinfo, so->collation, PointerGetDatum(&list->center), value));
 
 			if (listCount < so->probes)
 			{
+				IvfflatScanList *scanlist;
+
 				scanlist = &so->lists[listCount];
 				scanlist->startPage = list->startPage;
 				scanlist->distance = distance;
@@ -75,6 +76,8 @@ GetScanLists(IndexScanDesc scan, Datum value)
 			}
 			else if (distance < maxDistance)
 			{
+				IvfflatScanList *scanlist;
+
 				/* Remove */
 				scanlist = (IvfflatScanList *) pairingheap_remove_first(so->listQueue);
 
@@ -101,14 +104,6 @@ static void
 GetScanItems(IndexScanDesc scan, Datum value)
 {
 	IvfflatScanOpaque so = (IvfflatScanOpaque) scan->opaque;
-	Buffer		buf;
-	Page		page;
-	IndexTuple	itup;
-	BlockNumber searchPage;
-	OffsetNumber offno;
-	OffsetNumber maxoffno;
-	Datum		datum;
-	bool		isnull;
 	TupleDesc	tupdesc = RelationGetDescr(scan->indexRelation);
 	double		tuples = 0;
 
@@ -128,19 +123,32 @@ GetScanItems(IndexScanDesc scan, Datum value)
 	/* Search closest probes lists */
 	while (!pairingheap_is_empty(so->listQueue))
 	{
-		searchPage = ((IvfflatScanList *) pairingheap_remove_first(so->listQueue))->startPage;
+		BlockNumber searchPage = ((IvfflatScanList *) pairingheap_remove_first(so->listQueue))->startPage;
 
 		/* Search all entry pages for list */
 		while (BlockNumberIsValid(searchPage))
 		{
+			Buffer		buf;
+			Page		page;
+			OffsetNumber maxoffno;
+
 			buf = ReadBufferExtended(scan->indexRelation, MAIN_FORKNUM, searchPage, RBM_NORMAL, bas);
 			LockBuffer(buf, BUFFER_LOCK_SHARE);
 			page = BufferGetPage(buf);
 			maxoffno = PageGetMaxOffsetNumber(page);
 
-			for (offno = FirstOffsetNumber; offno <= maxoffno; offno = OffsetNumberNext(offno))
+			for (OffsetNumber offno = FirstOffsetNumber; offno <= maxoffno; offno = OffsetNumberNext(offno))
 			{
-				itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, offno));
+				IndexTuple	itup;
+				Datum		datum;
+				bool		isnull;
+				ItemId		itemid = PageGetItemId(page, offno);
+
+				/* Skip dead tuples */
+				if (scan->ignore_killed_tuples && ItemIdIsDead(itemid))
+					continue;
+
+				itup = (IndexTuple) PageGetItem(page, itemid);
 				datum = index_getattr(itup, 1, tupdesc, &isnull);
 
 				/*
@@ -180,6 +188,55 @@ GetScanItems(IndexScanDesc scan, Datum value)
 	tuplesort_performsort(so->sortstate);
 }
 
+/*
+ * Mark prior tuple as dead
+ */
+static void
+MarkPriorTupleDead(IndexScanDesc scan)
+{
+	IvfflatScanOpaque so = (IvfflatScanOpaque) scan->opaque;
+	Buffer		buf = so->buf;
+	Page		page;
+	OffsetNumber maxoffno;
+
+	/* Safety check */
+	if (!BufferIsValid(so->buf) || !ItemPointerIsValid(&so->heaptid))
+		return;
+
+	/* Only a shared locked is needed for ItemIdMarkDead */
+	LockBuffer(buf, BUFFER_LOCK_SHARE);
+	page = BufferGetPage(buf);
+	maxoffno = PageGetMaxOffsetNumber(page);
+
+	for (OffsetNumber offno = FirstOffsetNumber; offno <= maxoffno; offno = OffsetNumberNext(offno))
+	{
+		ItemId		itemid = PageGetItemId(page, offno);
+		IndexTuple	itup = (IndexTuple) PageGetItem(page, itemid);
+
+		/*
+		 * Find tuple. Since buffer has been pinned, tuple cannot have been
+		 * vacuumed (and heap TID reused).
+		 */
+		if (ItemPointerEquals(&itup->t_tid, &so->heaptid))
+		{
+			/*
+			 * Make sure tuple has not already been marked dead to avoid extra
+			 * WAL if wal_log_hints or data checksums enabled
+			 */
+			if (!ItemIdIsDead(itemid))
+			{
+				ItemIdMarkDead(itemid);
+				MarkBufferDirtyHint(buf, true);
+			}
+
+			break;
+		}
+	}
+
+	/* Unlock buffer */
+	LockBuffer(buf, BUFFER_LOCK_UNLOCK);
+}
+
 /*
  * Prepare for an index scan
  */
@@ -189,6 +246,7 @@ ivfflatbeginscan(Relation index, int nkeys, int norderbys)
 	IndexScanDesc scan;
 	IvfflatScanOpaque so;
 	int			lists;
+	int			dimensions;
 	AttrNumber	attNums[] = {1};
 	Oid			sortOperators[] = {Float8LessOperator};
 	Oid			sortCollations[] = {InvalidOid};
@@ -196,7 +254,9 @@ ivfflatbeginscan(Relation index, int nkeys, int norderbys)
 	int			probes = ivfflat_probes;
 
 	scan = RelationGetIndexScan(index, nkeys, norderbys);
-	lists = IvfflatGetLists(scan->indexRelation);
+
+	/* Get lists and dimensions from metapage */
+	IvfflatGetMetaPageInfo(index, &lists, &dimensions);
 
 	if (probes > lists)
 		probes = lists;
@@ -204,7 +264,10 @@ ivfflatbeginscan(Relation index, int nkeys, int norderbys)
 	so = (IvfflatScanOpaque) palloc(offsetof(IvfflatScanOpaqueData, lists) + probes * sizeof(IvfflatScanList));
 	so->buf = InvalidBuffer;
 	so->first = true;
+	so->hasLock = false;
+	ItemPointerSetInvalid(&so->heaptid);
 	so->probes = probes;
+	so->dimensions = dimensions;
 
 	/* Set support functions */
 	so->procinfo = index_getprocinfo(index, 1, IVFFLAT_DISTANCE_PROC);
@@ -218,7 +281,7 @@ ivfflatbeginscan(Relation index, int nkeys, int norderbys)
 	so->tupdesc = CreateTemplateTupleDesc(3, false);
 #endif
 	TupleDescInitEntry(so->tupdesc, (AttrNumber) 1, "distance", FLOAT8OID, -1, 0);
-	TupleDescInitEntry(so->tupdesc, (AttrNumber) 2, "tid", TIDOID, -1, 0);
+	TupleDescInitEntry(so->tupdesc, (AttrNumber) 2, "heaptid", TIDOID, -1, 0);
 	TupleDescInitEntry(so->tupdesc, (AttrNumber) 3, "indexblkno", INT4OID, -1, 0);
 
 	/* Prep sort */
@@ -251,6 +314,7 @@ ivfflatrescan(IndexScanDesc scan, ScanKey keys, int nkeys, ScanKey orderbys, int
 #endif
 
 	so->first = true;
+	ItemPointerSetInvalid(&so->heaptid);
 	pairingheap_reset(so->listQueue);
 
 	if (keys && scan->numberOfKeys > 0)
@@ -285,21 +349,26 @@ ivfflatgettuple(IndexScanDesc scan, ScanDirection dir)
 		if (scan->orderByData == NULL)
 			elog(ERROR, "cannot scan ivfflat index without order");
 
-		/* No items will match if null */
-		if (scan->orderByData->sk_flags & SK_ISNULL)
-			return false;
-
-		value = scan->orderByData->sk_argument;
-
-		/* Value should not be compressed or toasted */
-		Assert(!VARATT_IS_COMPRESSED(DatumGetPointer(value)));
-		Assert(!VARATT_IS_EXTENDED(DatumGetPointer(value)));
-
-		if (so->normprocinfo != NULL)
+		/* Get a shared lock for non-MVCC snapshots */
+		if (!so->hasLock && !IsMVCCSnapshot(scan->xs_snapshot))
 		{
-			/* No items will match if normalization fails */
-			if (!IvfflatNormValue(so->normprocinfo, so->collation, &value, NULL))
-				return false;
+			so->hasLock = true;
+			LockPage(scan->indexRelation, IVFFLAT_SCAN_LOCK, ShareLock);
+		}
+
+		if (scan->orderByData->sk_flags & SK_ISNULL)
+			value = PointerGetDatum(InitVector(so->dimensions));
+		else
+		{
+			value = scan->orderByData->sk_argument;
+
+			/* Value should not be compressed or toasted */
+			Assert(!VARATT_IS_COMPRESSED(DatumGetPointer(value)));
+			Assert(!VARATT_IS_EXTENDED(DatumGetPointer(value)));
+
+			/* Fine if normalization fails */
+			if (so->normprocinfo != NULL)
+				IvfflatNormValue(so->normprocinfo, so->collation, &value, NULL);
 		}
 
 		IvfflatBench("GetScanLists", GetScanLists(scan, value));
@@ -310,18 +379,28 @@ ivfflatgettuple(IndexScanDesc scan, ScanDirection dir)
 		if (value != scan->orderByData->sk_argument)
 			pfree(DatumGetPointer(value));
 	}
+	else
+	{
+		/* Mark prior tuple as dead */
+		if (scan->kill_prior_tuple)
+			MarkPriorTupleDead(scan);
+	}
 
 	if (tuplesort_gettupleslot(so->sortstate, true, false, so->slot, NULL))
 	{
-		ItemPointer tid = (ItemPointer) DatumGetPointer(slot_getattr(so->slot, 2, &so->isnull));
+		ItemPointer heaptid = (ItemPointer) DatumGetPointer(slot_getattr(so->slot, 2, &so->isnull));
 		BlockNumber indexblkno = DatumGetInt32(slot_getattr(so->slot, 3, &so->isnull));
 
 #if PG_VERSION_NUM >= 120000
-		scan->xs_heaptid = *tid;
+		scan->xs_heaptid = *heaptid;
 #else
-		scan->xs_ctup.t_self = *tid;
+		scan->xs_ctup.t_self = *heaptid;
 #endif
 
+		/* Keep track of info needed to mark tuple as dead */
+		so->heaptid = *heaptid;
+
+		/* Unpin buffer */
 		if (BufferIsValid(so->buf))
 			ReleaseBuffer(so->buf);
 
@@ -352,6 +431,10 @@ ivfflatendscan(IndexScanDesc scan)
 	if (BufferIsValid(so->buf))
 		ReleaseBuffer(so->buf);
 
+	/* Release lock */
+	if (so->hasLock)
+		UnlockPage(scan->indexRelation, IVFFLAT_SCAN_LOCK, ShareLock);
+
 	pairingheap_free(so->listQueue);
 	tuplesort_end(so->sortstate);
 

src/ivfutils.c

@@ -172,6 +172,29 @@ IvfflatAppendPage(Relation index, Buffer *buf, Page *page, GenericXLogState **st
 	*buf = newbuf;
 }
 
+/*
+ * Get the metapage info
+ */
+void
+IvfflatGetMetaPageInfo(Relation index, int *lists, int *dimensions)
+{
+	Buffer		buf;
+	Page		page;
+	IvfflatMetaPage metap;
+
+	buf = ReadBuffer(index, IVFFLAT_METAPAGE_BLKNO);
+	LockBuffer(buf, BUFFER_LOCK_SHARE);
+	page = BufferGetPage(buf);
+	metap = IvfflatPageGetMeta(page);
+
+	*lists = metap->lists;
+
+	if (dimensions != NULL)
+		*dimensions = metap->dimensions;
+
+	UnlockReleaseBuffer(buf);
+}
+
 /*
  * Update the start or insert page of a list
  */

src/ivfvacuum.c

@@ -3,6 +3,7 @@
 #include "commands/vacuum.h"
 #include "ivfflat.h"
 #include "storage/bufmgr.h"
+#include "storage/lmgr.h"
 
 /*
  * Bulk delete tuples from the index
@@ -65,14 +66,10 @@ ivfflatbulkdelete(IndexVacuumInfo *info, IndexBulkDeleteResult *stats,
 
 				vacuum_delay_point();
 
-				buf = ReadBufferExtended(index, MAIN_FORKNUM, searchPage, RBM_NORMAL, bas);
+				/* Ensure no in-flight index scans for non-MVCC snapshots */
+				LockPage(index, IVFFLAT_SCAN_LOCK, ExclusiveLock);
 
-				/*
-				 * ambulkdelete cannot delete entries from pages that are
-				 * pinned by other backends
-				 *
-				 * https://www.postgresql.org/docs/current/index-locking.html
-				 */
+				buf = ReadBufferExtended(index, MAIN_FORKNUM, searchPage, RBM_NORMAL, bas);
 				LockBufferForCleanup(buf);
 
 				state = GenericXLogStart(index);
@@ -114,6 +111,8 @@ ivfflatbulkdelete(IndexVacuumInfo *info, IndexBulkDeleteResult *stats,
 					GenericXLogAbort(state);
 
 				UnlockReleaseBuffer(buf);
+
+				UnlockPage(index, IVFFLAT_SCAN_LOCK, ExclusiveLock);
 			}
 
 			/*

src/vector.c

@@ -15,6 +15,10 @@
 #include "utils/numeric.h"
 #include "vector.h"
 
+#if PG_VERSION_NUM >= 160000
+#include "varatt.h"
+#endif
+
 #if PG_VERSION_NUM >= 120000
 #include "common/shortest_dec.h"
 #include "utils/float.h"
@@ -35,6 +39,7 @@ PG_MODULE_MAGIC;
 /*
  * Initialize index options and variables
  */
+PGDLLEXPORT void _PG_init(void);
 void
 _PG_init(void)
 {
@@ -100,6 +105,23 @@ CheckElement(float value)
 				 errmsg("infinite value not allowed in vector")));
 }
 
+/*
+ * Allocate and initialize a new vector
+ */
+Vector *
+InitVector(int dim)
+{
+	Vector	   *result;
+	int			size;
+
+	size = VECTOR_SIZE(dim);
+	result = (Vector *) palloc0(size);
+	SET_VARSIZE(result, size);
+	result->dim = dim;
+
+	return result;
+}
+
 /*
  * Check for whitespace, since array_isspace() is static
  */
@@ -632,6 +654,7 @@ cosine_distance(PG_FUNCTION_ARGS)
 	float		distance = 0.0;
 	float		norma = 0.0;
 	float		normb = 0.0;
+	double		similarity;
 
 	CheckDims(a, b);
 
@@ -644,7 +667,21 @@ cosine_distance(PG_FUNCTION_ARGS)
 	}
 
 	/* Use sqrt(a * b) over sqrt(a) * sqrt(b) */
-	PG_RETURN_FLOAT8(1.0 - ((double) distance / sqrt((double) norma * (double) normb)));
+	similarity = (double) distance / sqrt((double) norma * (double) normb);
+
+#ifdef _MSC_VER
+	/* /fp:fast may not propagate NaN */
+	if (isnan(similarity))
+		PG_RETURN_FLOAT8(NAN);
+#endif
+
+	/* Keep in range */
+	if (similarity > 1)
+		similarity = 1.0;
+	else if (similarity < -1)
+		similarity = -1.0;
+
+	PG_RETURN_FLOAT8(1.0 - similarity);
 }
 
 /*
@@ -658,6 +695,8 @@ vector_spherical_distance(PG_FUNCTION_ARGS)
 {
 	Vector	   *a = PG_GETARG_VECTOR_P(0);
 	Vector	   *b = PG_GETARG_VECTOR_P(1);
+	float	   *ax = a->x;
+	float	   *bx = b->x;
 	float		dp = 0.0;
 	double		distance;
 
@@ -665,9 +704,10 @@ vector_spherical_distance(PG_FUNCTION_ARGS)
 
 	/* Auto-vectorized */
 	for (int i = 0; i < a->dim; i++)
-		dp += a->x[i] * b->x[i];
+		dp += ax[i] * bx[i];
 
 	distance = (double) dp;
+
 	/* Prevent NaN with acos with loss of precision */
 	if (distance > 1)
 		distance = 1;
@@ -720,13 +760,13 @@ vector_norm(PG_FUNCTION_ARGS)
 {
 	Vector	   *a = PG_GETARG_VECTOR_P(0);
 	float	   *ax = a->x;
-	float		norm = 0.0;
+	double		norm = 0.0;
 
 	/* Auto-vectorized */
 	for (int i = 0; i < a->dim; i++)
-		norm += ax[i] * ax[i];
+		norm += (double) ax[i] * (double) ax[i];
 
-	PG_RETURN_FLOAT8(sqrt((double) norm));
+	PG_RETURN_FLOAT8(sqrt(norm));
 }
 
 /*

src/vector.h

@@ -1,12 +1,6 @@
 #ifndef VECTOR_H
 #define VECTOR_H
 
-#include "postgres.h"
-
-#if PG_VERSION_NUM >= 160000
-#include "varatt.h"
-#endif
-
 #define VECTOR_MAX_DIM 16000
 
 #define VECTOR_SIZE(_dim)		(offsetof(Vector, x) + sizeof(float)*(_dim))
@@ -14,9 +8,6 @@
 #define PG_GETARG_VECTOR_P(x)	DatumGetVector(PG_GETARG_DATUM(x))
 #define PG_RETURN_VECTOR_P(x)	PG_RETURN_POINTER(x)
 
-/* Exported functions */
-PGDLLEXPORT void _PG_init(void);
-
 typedef struct Vector
 {
 	int32		vl_len_;		/* varlena header (do not touch directly!) */
@@ -25,24 +16,8 @@ typedef struct Vector
 	float		x[FLEXIBLE_ARRAY_MEMBER];
 }			Vector;
 
+Vector	   *InitVector(int dim);
 void		PrintVector(char *msg, Vector * vector);
 int			vector_cmp_internal(Vector * a, Vector * b);
 
-/*
- * Allocate and initialize a new vector
- */
-static inline Vector *
-InitVector(int dim)
-{
-	Vector	   *result;
-	int			size;
-
-	size = VECTOR_SIZE(dim);
-	result = (Vector *) palloc0(size);
-	SET_VARSIZE(result, size);
-	result->dim = dim;
-
-	return result;
-}
-
 #endif

test/expected/functions.out

@@ -48,6 +48,12 @@ SELECT vector_norm('[0,1]');
            1
 (1 row)
 
+SELECT vector_norm('[3e37,4e37]')::real;
+ vector_norm 
+-------------
+       5e+37
+(1 row)
+
 SELECT l2_distance('[0,0]', '[3,4]');
  l2_distance 
 -------------
@@ -62,6 +68,12 @@ SELECT l2_distance('[0,0]', '[0,1]');
 
 SELECT l2_distance('[1,2]', '[3]');
 ERROR:  different vector dimensions 2 and 1
+SELECT l2_distance('[3e38]', '[-3e38]');
+ l2_distance 
+-------------
+    Infinity
+(1 row)
+
 SELECT inner_product('[1,2]', '[3,4]');
  inner_product 
 ---------------
@@ -70,6 +82,12 @@ SELECT inner_product('[1,2]', '[3,4]');
 
 SELECT inner_product('[1,2]', '[3]');
 ERROR:  different vector dimensions 2 and 1
+SELECT inner_product('[3e38]', '[3e38]');
+ inner_product 
+---------------
+      Infinity
+(1 row)
+
 SELECT cosine_distance('[1,2]', '[2,4]');
  cosine_distance 
 -----------------
@@ -88,6 +106,12 @@ SELECT cosine_distance('[1,1]', '[1,1]');
                0
 (1 row)
 
+SELECT cosine_distance('[1,0]', '[0,2]');
+ cosine_distance 
+-----------------
+               1
+(1 row)
+
 SELECT cosine_distance('[1,1]', '[-1,-1]');
  cosine_distance 
 -----------------
@@ -96,6 +120,24 @@ SELECT cosine_distance('[1,1]', '[-1,-1]');
 
 SELECT cosine_distance('[1,2]', '[3]');
 ERROR:  different vector dimensions 2 and 1
+SELECT cosine_distance('[1,1]', '[1.1,1.1]');
+ cosine_distance 
+-----------------
+               0
+(1 row)
+
+SELECT cosine_distance('[1,1]', '[-1.1,-1.1]');
+ cosine_distance 
+-----------------
+               2
+(1 row)
+
+SELECT cosine_distance('[3e38]', '[3e38]');
+ cosine_distance 
+-----------------
+             NaN
+(1 row)
+
 SELECT l1_distance('[0,0]', '[3,4]');
  l1_distance 
 -------------
@@ -110,6 +152,12 @@ SELECT l1_distance('[0,0]', '[0,1]');
 
 SELECT l1_distance('[1,2]', '[3]');
 ERROR:  different vector dimensions 2 and 1
+SELECT l1_distance('[3e38]', '[-3e38]');
+ l1_distance 
+-------------
+    Infinity
+(1 row)
+
 SELECT avg(v) FROM unnest(ARRAY['[1,2,3]'::vector, '[3,5,7]']) v;
     avg    
 -----------

test/expected/hnsw_l2.out

@@ -27,4 +27,10 @@ SELECT COUNT(*) FROM t;
      5
 (1 row)
 
+TRUNCATE t;
+SELECT * FROM t ORDER BY val <-> '[3,3,3]';
+ val 
+-----
+(0 rows)
+
 DROP TABLE t;

test/expected/hnsw_options.out

@@ -1,25 +1,26 @@
-SET enable_seqscan = off;
 CREATE TABLE t (val vector(3));
-CREATE INDEX ON t USING hnsw (val vector_l2_ops) WITH (m = 3);
-ERROR:  value 3 out of bounds for option "m"
-DETAIL:  Valid values are between "4" and "100".
+CREATE INDEX ON t USING hnsw (val vector_l2_ops) WITH (m = 1);
+ERROR:  value 1 out of bounds for option "m"
+DETAIL:  Valid values are between "2" and "100".
 CREATE INDEX ON t USING hnsw (val vector_l2_ops) WITH (m = 101);
 ERROR:  value 101 out of bounds for option "m"
-DETAIL:  Valid values are between "4" and "100".
-CREATE INDEX ON t USING hnsw (val vector_l2_ops) WITH (ef_construction = 9);
-ERROR:  value 9 out of bounds for option "ef_construction"
-DETAIL:  Valid values are between "10" and "1000".
+DETAIL:  Valid values are between "2" and "100".
+CREATE INDEX ON t USING hnsw (val vector_l2_ops) WITH (ef_construction = 3);
+ERROR:  value 3 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 (ef_construction = 1001);
 ERROR:  value 1001 out of bounds for option "ef_construction"
-DETAIL:  Valid values are between "10" and "1000".
+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
 SHOW hnsw.ef_search;
  hnsw.ef_search 
 ----------------
  40
 (1 row)
 
-SET hnsw.ef_search = 9;
-ERROR:  9 is outside the valid range for parameter "hnsw.ef_search" (10 .. 1000)
+SET hnsw.ef_search = 0;
+ERROR:  0 is outside the valid range for parameter "hnsw.ef_search" (1 .. 1000)
 SET hnsw.ef_search = 1001;
-ERROR:  1001 is outside the valid range for parameter "hnsw.ef_search" (10 .. 1000)
+ERROR:  1001 is outside the valid range for parameter "hnsw.ef_search" (1 .. 1000)
 DROP TABLE t;

test/expected/ivfflat_cosine.out

@@ -11,9 +11,16 @@ SELECT * FROM t ORDER BY val <=> '[3,3,3]';
  [1,2,4]
 (3 rows)
 
-SELECT * FROM t ORDER BY val <=> (SELECT NULL::vector);
- val 
------
-(0 rows)
+SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <=> '[0,0,0]') t2;
+ count 
+-------
+     3
+(1 row)
+
+SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <=> (SELECT NULL::vector)) t2;
+ count 
+-------
+     3
+(1 row)
 
 DROP TABLE t;

test/expected/ivfflat_ip.out

@@ -12,9 +12,10 @@ SELECT * FROM t ORDER BY val <#> '[3,3,3]';
  [0,0,0]
 (4 rows)
 
-SELECT * FROM t ORDER BY val <#> (SELECT NULL::vector);
- val 
------
-(0 rows)
+SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <#> (SELECT NULL::vector)) t2;
+ count 
+-------
+     4
+(1 row)
 
 DROP TABLE t;

test/expected/ivfflat_l2.out

@@ -1,7 +1,7 @@
 SET enable_seqscan = off;
 CREATE TABLE t (val vector(3));
 INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
-CREATE INDEX ON t USING ivfflat (val) WITH (lists = 1);
+CREATE INDEX ON t USING ivfflat (val vector_l2_ops) WITH (lists = 1);
 INSERT INTO t (val) VALUES ('[1,2,4]');
 SELECT * FROM t ORDER BY val <-> '[3,3,3]';
    val   
@@ -13,9 +13,13 @@ SELECT * FROM t ORDER BY val <-> '[3,3,3]';
 (4 rows)
 
 SELECT * FROM t ORDER BY val <-> (SELECT NULL::vector);
- val 
------
-(0 rows)
+   val   
+---------
+ [0,0,0]
+ [1,1,1]
+ [1,2,3]
+ [1,2,4]
+(4 rows)
 
 SELECT COUNT(*) FROM t;
  count 
@@ -23,4 +27,13 @@ SELECT COUNT(*) FROM t;
      5
 (1 row)
 
+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)
+
 DROP TABLE t;

test/expected/ivfflat_options.out

@@ -1,9 +1,8 @@
-SET enable_seqscan = off;
 CREATE TABLE t (val vector(3));
-CREATE INDEX ON t USING ivfflat (val) WITH (lists = 0);
+CREATE INDEX ON t USING ivfflat (val vector_l2_ops) WITH (lists = 0);
 ERROR:  value 0 out of bounds for option "lists"
 DETAIL:  Valid values are between "1" and "32768".
-CREATE INDEX ON t USING ivfflat (val) WITH (lists = 32769);
+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".
 SHOW ivfflat.probes;

test/expected/ivfflat_unlogged.out

@@ -1,7 +1,7 @@
 SET enable_seqscan = off;
 CREATE UNLOGGED TABLE t (val vector(3));
 INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
-CREATE INDEX ON t USING ivfflat (val) WITH (lists = 1);
+CREATE INDEX ON t USING ivfflat (val vector_l2_ops) WITH (lists = 1);
 SELECT * FROM t ORDER BY val <-> '[3,3,3]';
    val   
 ---------

test/sql/functions.sql

@@ -11,23 +11,31 @@ SELECT vector_dims('[1,2,3]');
 SELECT round(vector_norm('[1,1]')::numeric, 5);
 SELECT vector_norm('[3,4]');
 SELECT vector_norm('[0,1]');
+SELECT vector_norm('[3e37,4e37]')::real;
 
 SELECT l2_distance('[0,0]', '[3,4]');
 SELECT l2_distance('[0,0]', '[0,1]');
 SELECT l2_distance('[1,2]', '[3]');
+SELECT l2_distance('[3e38]', '[-3e38]');
 
 SELECT inner_product('[1,2]', '[3,4]');
 SELECT inner_product('[1,2]', '[3]');
+SELECT inner_product('[3e38]', '[3e38]');
 
 SELECT cosine_distance('[1,2]', '[2,4]');
 SELECT cosine_distance('[1,2]', '[0,0]');
 SELECT cosine_distance('[1,1]', '[1,1]');
+SELECT cosine_distance('[1,0]', '[0,2]');
 SELECT cosine_distance('[1,1]', '[-1,-1]');
 SELECT cosine_distance('[1,2]', '[3]');
+SELECT cosine_distance('[1,1]', '[1.1,1.1]');
+SELECT cosine_distance('[1,1]', '[-1.1,-1.1]');
+SELECT cosine_distance('[3e38]', '[3e38]');
 
 SELECT l1_distance('[0,0]', '[3,4]');
 SELECT l1_distance('[0,0]', '[0,1]');
 SELECT l1_distance('[1,2]', '[3]');
+SELECT l1_distance('[3e38]', '[-3e38]');
 
 SELECT avg(v) FROM unnest(ARRAY['[1,2,3]'::vector, '[3,5,7]']) v;
 SELECT avg(v) FROM unnest(ARRAY['[1,2,3]'::vector, '[3,5,7]', NULL]) v;

test/sql/hnsw_l2.sql

@@ -10,4 +10,7 @@ SELECT * FROM t ORDER BY val <-> '[3,3,3]';
 SELECT * FROM t ORDER BY val <-> (SELECT NULL::vector);
 SELECT COUNT(*) FROM t;
 
+TRUNCATE t;
+SELECT * FROM t ORDER BY val <-> '[3,3,3]';
+
 DROP TABLE t;

test/sql/hnsw_options.sql

@@ -1,14 +1,13 @@
-SET enable_seqscan = off;
-
 CREATE TABLE t (val vector(3));
-CREATE INDEX ON t USING hnsw (val vector_l2_ops) WITH (m = 3);
+CREATE INDEX ON t USING hnsw (val vector_l2_ops) WITH (m = 1);
 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 = 9);
+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);
 
 SHOW hnsw.ef_search;
 
-SET hnsw.ef_search = 9;
+SET hnsw.ef_search = 0;
 SET hnsw.ef_search = 1001;
 
 DROP TABLE t;

test/sql/ivfflat_cosine.sql

@@ -7,6 +7,7 @@ CREATE INDEX ON t USING ivfflat (val vector_cosine_ops) WITH (lists = 1);
 INSERT INTO t (val) VALUES ('[1,2,4]');
 
 SELECT * FROM t ORDER BY val <=> '[3,3,3]';
-SELECT * FROM t ORDER BY val <=> (SELECT NULL::vector);
+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;
 
 DROP TABLE t;

test/sql/ivfflat_ip.sql

@@ -7,6 +7,6 @@ CREATE INDEX ON t USING ivfflat (val vector_ip_ops) WITH (lists = 1);
 INSERT INTO t (val) VALUES ('[1,2,4]');
 
 SELECT * FROM t ORDER BY val <#> '[3,3,3]';
-SELECT * FROM t ORDER BY val <#> (SELECT NULL::vector);
+SELECT COUNT(*) FROM (SELECT * FROM t ORDER BY val <#> (SELECT NULL::vector)) t2;
 
 DROP TABLE t;

test/sql/ivfflat_l2.sql

@@ -2,7 +2,7 @@ SET enable_seqscan = off;
 
 CREATE TABLE t (val vector(3));
 INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
-CREATE INDEX ON t USING ivfflat (val) WITH (lists = 1);
+CREATE INDEX ON t USING ivfflat (val vector_l2_ops) WITH (lists = 1);
 
 INSERT INTO t (val) VALUES ('[1,2,4]');
 
@@ -10,4 +10,7 @@ SELECT * FROM t ORDER BY val <-> '[3,3,3]';
 SELECT * FROM t ORDER BY val <-> (SELECT NULL::vector);
 SELECT COUNT(*) FROM t;
 
+TRUNCATE t;
+SELECT * FROM t ORDER BY val <-> '[3,3,3]';
+
 DROP TABLE t;

test/sql/ivfflat_options.sql

@@ -1,8 +1,6 @@
-SET enable_seqscan = off;
-
 CREATE TABLE t (val vector(3));
-CREATE INDEX ON t USING ivfflat (val) WITH (lists = 0);
-CREATE INDEX ON t USING ivfflat (val) WITH (lists = 32769);
+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);
 
 SHOW ivfflat.probes;
 

test/sql/ivfflat_unlogged.sql

@@ -2,7 +2,7 @@ SET enable_seqscan = off;
 
 CREATE UNLOGGED TABLE t (val vector(3));
 INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
-CREATE INDEX ON t USING ivfflat (val) WITH (lists = 1);
+CREATE INDEX ON t USING ivfflat (val vector_l2_ops) WITH (lists = 1);
 
 SELECT * FROM t ORDER BY val <-> '[3,3,3]';
 

test/t/001_ivfflat_wal.pl

@@ -19,14 +19,13 @@ sub test_index_replay
 
 	# Wait for replica to catch up
 	my $applname = $node_replica->name;
-
-	my $server_version_num = $node_primary->safe_psql("postgres", "SHOW server_version_num");
 	my $caughtup_query = "SELECT pg_current_wal_lsn() <= replay_lsn FROM pg_stat_replication WHERE application_name = '$applname';";
 	$node_primary->poll_query_until('postgres', $caughtup_query)
 	  or die "Timed out while waiting for replica 1 to catch up";
 
 	my @r = ();
-	for (1 .. $dim) {
+	for (1 .. $dim)
+	{
 		push(@r, rand());
 	}
 	my $sql = join(",", @r);
@@ -52,11 +51,13 @@ my $array_sql = join(",", ('random()') x $dim);
 # Initialize primary node
 $node_primary = get_new_node('primary');
 $node_primary->init(allows_streaming => 1);
-if ($dim > 32) {
+if ($dim > 32)
+{
 	# TODO use wal_keep_segments for Postgres < 13
 	$node_primary->append_conf('postgresql.conf', qq(wal_keep_size = 1GB));
 }
-if ($dim > 1500) {
+if ($dim > 1500)
+{
 	$node_primary->append_conf('postgresql.conf', qq(maintenance_work_mem = 128MB));
 }
 $node_primary->start;
@@ -67,8 +68,7 @@ $node_primary->backup($backup_name);
 
 # Create streaming replica linking to primary
 $node_replica = get_new_node('replica');
-$node_replica->init_from_backup($node_primary, $backup_name,
-	has_streaming => 1);
+$node_replica->init_from_backup($node_primary, $backup_name, has_streaming => 1);
 $node_replica->start;
 
 # Create ivfflat index on primary
@@ -77,7 +77,7 @@ $node_primary->safe_psql("postgres", "CREATE TABLE tst (i int4, v vector($dim));
 $node_primary->safe_psql("postgres",
 	"INSERT INTO tst SELECT i % 10, ARRAY[$array_sql] FROM generate_series(1, 100000) i;"
 );
-$node_primary->safe_psql("postgres", "CREATE INDEX ON tst USING ivfflat (v);");
+$node_primary->safe_psql("postgres", "CREATE INDEX ON tst USING ivfflat (v vector_l2_ops);");
 
 # Test that queries give same result
 test_index_replay('initial');

test/t/002_ivfflat_vacuum.pl

@@ -7,7 +7,8 @@ use Test::More;
 my $dim = 3;
 
 my @r = ();
-for (1 .. $dim) {
+for (1 .. $dim)
+{
 	my $v = int(rand(1000)) + 1;
 	push(@r, "i % $v");
 }
@@ -24,7 +25,7 @@ $node->safe_psql("postgres", "CREATE TABLE tst (i int4, v vector($dim));");
 $node->safe_psql("postgres",
 	"INSERT INTO tst SELECT i % 10, ARRAY[$array_sql] FROM generate_series(1, 100000) i;"
 );
-$node->safe_psql("postgres", "CREATE INDEX ON tst USING ivfflat (v);");
+$node->safe_psql("postgres", "CREATE INDEX ON tst USING ivfflat (v vector_l2_ops);");
 
 # Get size
 my $size = $node->safe_psql("postgres", "SELECT pg_total_relation_size('tst_v_idx');");

test/t/003_ivfflat_build_recall.pl

@@ -22,7 +22,8 @@ sub test_recall
 	));
 	like($explain, qr/Index Scan using idx on tst/);
 
-	for my $i (0 .. $#queries) {
+	for my $i (0 .. $#queries)
+	{
 		my $actual = $node->safe_psql("postgres", qq(
 			SET enable_seqscan = off;
 			SET ivfflat.probes = $probes;
@@ -33,8 +34,10 @@ sub test_recall
 
 		my @expected_ids = split("\n", $expected[$i]);
 
-		foreach (@expected_ids) {
-			if (exists($actual_set{$_})) {
+		foreach (@expected_ids)
+		{
+			if (exists($actual_set{$_}))
+			{
 				$correct++;
 			}
 			$total++;
@@ -57,7 +60,8 @@ $node->safe_psql("postgres",
 );
 
 # Generate queries
-for (1..20) {
+for (1 .. 20)
+{
 	my $r1 = rand();
 	my $r2 = rand();
 	my $r3 = rand();
@@ -66,26 +70,21 @@ for (1..20) {
 
 # Check each index type
 my @operators = ("<->", "<#>", "<=>");
+my @opclasses = ("vector_l2_ops", "vector_ip_ops", "vector_cosine_ops");
 
-foreach (@operators) {
-	my $operator = $_;
+for my $i (0 .. $#operators)
+{
+	my $operator = $operators[$i];
+	my $opclass = $opclasses[$i];
 
 	# Get exact results
 	@expected = ();
-	foreach (@queries) {
+	foreach (@queries)
+	{
 		my $res = $node->safe_psql("postgres", "SELECT i FROM tst ORDER BY v $operator '$_' LIMIT $limit;");
 		push(@expected, $res);
 	}
 
-	my $opclass;
-	if ($operator eq "<->") {
-		$opclass = "vector_l2_ops";
-	} elsif ($operator eq "<#>") {
-		$opclass = "vector_ip_ops";
-	} else {
-		$opclass = "vector_cosine_ops";
-	}
-
 	# Build index serially
 	$node->safe_psql("postgres", qq(
 		SET max_parallel_maintenance_workers = 0;
@@ -93,13 +92,14 @@ foreach (@operators) {
 	));
 
 	# Test approximate results
-	if ($operator ne "<#>") {
-		# TODO fix test
-		test_recall(1, 0.75, $operator);
+	if ($operator ne "<#>")
+	{
+		# TODO Fix test (uniform random vectors all have similar inner product)
+		test_recall(1, 0.71, $operator);
 		test_recall(10, 0.95, $operator);
 	}
 	# Account for equal distances
-	test_recall(100, 0.995, $operator);
+	test_recall(100, 0.9925, $operator);
 
 	$node->safe_psql("postgres", "DROP INDEX idx;");
 
@@ -113,13 +113,14 @@ foreach (@operators) {
 	like($stderr, qr/using \d+ parallel workers/);
 
 	# Test approximate results
-	if ($operator ne "<#>") {
-		# TODO fix test
-		test_recall(1, 0.75, $operator);
+	if ($operator ne "<#>")
+	{
+		# TODO Fix test (uniform random vectors all have similar inner product)
+		test_recall(1, 0.71, $operator);
 		test_recall(10, 0.95, $operator);
 	}
 	# Account for equal distances
-	test_recall(100, 0.995, $operator);
+	test_recall(100, 0.9925, $operator);
 
 	$node->safe_psql("postgres", "DROP INDEX idx;");
 }

test/t/004_ivfflat_centers.pl

@@ -20,7 +20,7 @@ sub test_centers
 {
 	my ($lists, $min) = @_;
 
-	my ($ret, $stdout, $stderr) = $node->psql("postgres", "CREATE INDEX ON tst USING ivfflat (v) WITH (lists = $lists);");
+	my ($ret, $stdout, $stderr) = $node->psql("postgres", "CREATE INDEX ON tst USING ivfflat (v vector_l2_ops) WITH (lists = $lists);");
 	is($ret, 0, $stderr);
 }
 

test/t/005_ivfflat_query_recall.pl

@@ -18,24 +18,21 @@ $node->safe_psql("postgres",
 
 # Check each index type
 my @operators = ("<->", "<#>", "<=>");
-foreach (@operators) {
-	my $operator = $_;
+my @opclasses = ("vector_l2_ops", "vector_ip_ops", "vector_cosine_ops");
+
+for my $i (0 .. $#operators)
+{
+	my $operator = $operators[$i];
+	my $opclass = $opclasses[$i];
 
 	# Add index
-	my $opclass;
-	if ($operator eq "<->") {
-		$opclass = "vector_l2_ops";
-	} elsif ($operator eq "<#>") {
-		$opclass = "vector_ip_ops";
-	} else {
-		$opclass = "vector_cosine_ops";
-	}
 	$node->safe_psql("postgres", "CREATE INDEX ON tst USING ivfflat (v $opclass);");
 
 	# Test 100% recall
-	for (1..20) {
-		my $i = int(rand() * 100000);
-		my $query = $node->safe_psql("postgres", "SELECT v FROM tst WHERE i = $i;");
+	for (1 .. 20)
+	{
+		my $id = int(rand() * 100000);
+		my $query = $node->safe_psql("postgres", "SELECT v FROM tst WHERE i = $id;");
 		my $res = $node->safe_psql("postgres", qq(
 			SET enable_seqscan = off;
 			SELECT v FROM tst ORDER BY v <-> '$query' LIMIT 1;

test/t/006_ivfflat_lists.pl

@@ -16,8 +16,8 @@ $node->safe_psql("postgres",
 	"INSERT INTO tst SELECT ARRAY[random(), random(), random()] FROM generate_series(1, 100000) i;"
 );
 
-$node->safe_psql("postgres", "CREATE INDEX lists50 ON tst USING ivfflat (v) WITH (lists = 50);");
-$node->safe_psql("postgres", "CREATE INDEX lists100 ON tst USING ivfflat (v) WITH (lists = 100);");
+$node->safe_psql("postgres", "CREATE INDEX lists50 ON tst USING ivfflat (v vector_l2_ops) WITH (lists = 50);");
+$node->safe_psql("postgres", "CREATE INDEX lists100 ON tst USING ivfflat (v vector_l2_ops) WITH (lists = 100);");
 
 # Test prefers more lists
 my $res = $node->safe_psql("postgres", "EXPLAIN SELECT v FROM tst ORDER BY v <-> '[0.5,0.5,0.5]' LIMIT 10;");
@@ -26,7 +26,7 @@ unlike($res, qr/lists50/);
 
 # Test errors with too much memory
 my ($ret, $stdout, $stderr) = $node->psql("postgres",
-	"CREATE INDEX lists10000 ON tst USING ivfflat (v) WITH (lists = 10000);"
+	"CREATE INDEX lists10000 ON tst USING ivfflat (v vector_l2_ops) WITH (lists = 10000);"
 );
 like($stderr, qr/memory required is/);
 

test/t/007_ivfflat_inserts.pl

@@ -19,7 +19,7 @@ $node->safe_psql("postgres", "CREATE TABLE tst (v vector($dim));");
 $node->safe_psql("postgres",
 	"INSERT INTO tst SELECT ARRAY[$array_sql] FROM generate_series(1, 10000) i;"
 );
-$node->safe_psql("postgres", "CREATE INDEX ON tst USING ivfflat (v);");
+$node->safe_psql("postgres", "CREATE INDEX ON tst USING ivfflat (v vector_l2_ops);");
 
 $node->pgbench(
 	"--no-vacuum --client=5 --transactions=100",
@@ -28,7 +28,7 @@ $node->pgbench(
 	[qr{^$}],
 	"concurrent INSERTs",
 	{
-		"007_inserts" => "INSERT INTO tst SELECT ARRAY[$array_sql] FROM generate_series(1, 10) i;"
+		"007_ivfflat_inserts" => "INSERT INTO tst SELECT ARRAY[$array_sql] FROM generate_series(1, 10) i;"
 	}
 );
 

test/t/008_aggregates.pl

@@ -30,7 +30,8 @@ sub test_aggregate
 
 	# Test matches real for avg
 	# Cannot test sum since sum(real) varies between calls
-	if ($agg eq 'avg') {
+	if ($agg eq 'avg')
+	{
 		my $r1 = $node->safe_psql("postgres", "SELECT $agg(r1)::float4 FROM tst;");
 		my $r2 = $node->safe_psql("postgres", "SELECT $agg(r2)::float4 FROM tst;");
 		my $r3 = $node->safe_psql("postgres", "SELECT $agg(r3)::float4 FROM tst;");

test/t/010_hnsw_wal.pl

@@ -19,14 +19,13 @@ sub test_index_replay
 
 	# Wait for replica to catch up
 	my $applname = $node_replica->name;
-
-	my $server_version_num = $node_primary->safe_psql("postgres", "SHOW server_version_num");
 	my $caughtup_query = "SELECT pg_current_wal_lsn() <= replay_lsn FROM pg_stat_replication WHERE application_name = '$applname';";
 	$node_primary->poll_query_until('postgres', $caughtup_query)
 	  or die "Timed out while waiting for replica 1 to catch up";
 
 	my @r = ();
-	for (1 .. $dim) {
+	for (1 .. $dim)
+	{
 		push(@r, rand());
 	}
 	my $sql = join(",", @r);
@@ -52,11 +51,13 @@ my $array_sql = join(",", ('random()') x $dim);
 # Initialize primary node
 $node_primary = get_new_node('primary');
 $node_primary->init(allows_streaming => 1);
-if ($dim > 32) {
+if ($dim > 32)
+{
 	# TODO use wal_keep_segments for Postgres < 13
 	$node_primary->append_conf('postgresql.conf', qq(wal_keep_size = 1GB));
 }
-if ($dim > 1500) {
+if ($dim > 1500)
+{
 	$node_primary->append_conf('postgresql.conf', qq(maintenance_work_mem = 128MB));
 }
 $node_primary->start;
@@ -67,8 +68,7 @@ $node_primary->backup($backup_name);
 
 # Create streaming replica linking to primary
 $node_replica = get_new_node('replica');
-$node_replica->init_from_backup($node_primary, $backup_name,
-	has_streaming => 1);
+$node_replica->init_from_backup($node_primary, $backup_name, has_streaming => 1);
 $node_replica->start;
 
 # Create hnsw index on primary

test/t/011_hnsw_vacuum.pl

@@ -7,7 +7,8 @@ use Test::More;
 my $dim = 3;
 
 my @r = ();
-for (1 .. $dim) {
+for (1 .. $dim)
+{
 	my $v = int(rand(1000)) + 1;
 	push(@r, "i % $v");
 }
@@ -22,7 +23,7 @@ $node->start;
 $node->safe_psql("postgres", "CREATE EXTENSION vector;");
 $node->safe_psql("postgres", "CREATE TABLE tst (i int4, v vector($dim));");
 $node->safe_psql("postgres",
-	"INSERT INTO tst SELECT i % 10, ARRAY[$array_sql] FROM generate_series(1, 10000) i;"
+	"INSERT INTO tst SELECT i, ARRAY[$array_sql] FROM generate_series(1, 10000) i;"
 );
 $node->safe_psql("postgres", "CREATE INDEX ON tst USING hnsw (v vector_l2_ops);");
 
@@ -33,11 +34,21 @@ my $size = $node->safe_psql("postgres", "SELECT pg_total_relation_size('tst_v_id
 $node->safe_psql("postgres", "DELETE FROM tst;");
 $node->safe_psql("postgres", "VACUUM tst;");
 $node->safe_psql("postgres",
-	"INSERT INTO tst SELECT i % 10, ARRAY[$array_sql] FROM generate_series(1, 10000) i;"
+	"INSERT INTO tst SELECT i, ARRAY[$array_sql] FROM generate_series(1, 10000) i;"
 );
 
 # Check size
+# May increase some due to different levels
 my $new_size = $node->safe_psql("postgres", "SELECT pg_total_relation_size('tst_v_idx');");
-cmp_ok($new_size, "<=", $size * 1.01, "size does not increase too much");
+cmp_ok($new_size, "<=", $size * 1.02, "size does not increase too much");
+
+# Delete all but one
+$node->safe_psql("postgres", "DELETE FROM tst WHERE i != 123;");
+$node->safe_psql("postgres", "VACUUM tst;");
+my $res = $node->safe_psql("postgres", qq(
+	SET enable_seqscan = off;
+	SELECT i FROM tst ORDER BY v <-> '[0,0,0]' LIMIT 10;
+));
+is($res, 123);
 
 done_testing();

test/t/012_hnsw_build_recall.pl

@@ -21,7 +21,8 @@ sub test_recall
 	));
 	like($explain, qr/Index Scan/);
 
-	for my $i (0 .. $#queries) {
+	for my $i (0 .. $#queries)
+	{
 		my $actual = $node->safe_psql("postgres", qq(
 			SET enable_seqscan = off;
 			SELECT i FROM tst ORDER BY v $operator '$queries[$i]' LIMIT $limit;
@@ -31,8 +32,10 @@ sub test_recall
 
 		my @expected_ids = split("\n", $expected[$i]);
 
-		foreach (@expected_ids) {
-			if (exists($actual_set{$_})) {
+		foreach (@expected_ids)
+		{
+			if (exists($actual_set{$_}))
+			{
 				$correct++;
 			}
 			$total++;
@@ -55,7 +58,8 @@ $node->safe_psql("postgres",
 );
 
 # Generate queries
-for (1..20) {
+for (1 .. 20)
+{
 	my $r1 = rand();
 	my $r2 = rand();
 	my $r3 = rand();
@@ -64,33 +68,26 @@ for (1..20) {
 
 # Check each index type
 my @operators = ("<->", "<#>", "<=>");
+my @opclasses = ("vector_l2_ops", "vector_ip_ops", "vector_cosine_ops");
 
-foreach (@operators) {
-	my $operator = $_;
+for my $i (0 .. $#operators)
+{
+	my $operator = $operators[$i];
+	my $opclass = $opclasses[$i];
 
 	# Get exact results
 	@expected = ();
-	foreach (@queries) {
+	foreach (@queries)
+	{
 		my $res = $node->safe_psql("postgres", "SELECT i FROM tst ORDER BY v $operator '$_' LIMIT $limit;");
 		push(@expected, $res);
 	}
 
 	# Add index
-	my $opclass;
-	if ($operator eq "<->") {
-		$opclass = "vector_l2_ops";
-	} elsif ($operator eq "<#>") {
-		$opclass = "vector_ip_ops";
-	} else {
-		$opclass = "vector_cosine_ops";
-	}
 	$node->safe_psql("postgres", "CREATE INDEX ON tst USING hnsw (v $opclass);");
 
-	if ($operator eq "<#>") {
-		test_recall(0.80, $operator);
-	} else {
-		test_recall(0.99, $operator);
-	}
+	my $min = $operator eq "<#>" ? 0.80 : 0.99;
+	test_recall($min, $operator);
 }
 
 done_testing();

test/t/013_hnsw_insert_recall.pl

@@ -21,7 +21,8 @@ sub test_recall
 	));
 	like($explain, qr/Index Scan/);
 
-	for my $i (0 .. $#queries) {
+	for my $i (0 .. $#queries)
+	{
 		my $actual = $node->safe_psql("postgres", qq(
 			SET enable_seqscan = off;
 			SELECT i FROM tst ORDER BY v $operator '$queries[$i]' LIMIT $limit;
@@ -31,8 +32,10 @@ sub test_recall
 
 		my @expected_ids = split("\n", $expected[$i]);
 
-		foreach (@expected_ids) {
-			if (exists($actual_set{$_})) {
+		foreach (@expected_ids)
+		{
+			if (exists($actual_set{$_}))
+			{
 				$correct++;
 			}
 			$total++;
@@ -49,10 +52,11 @@ $node->start;
 
 # Create table
 $node->safe_psql("postgres", "CREATE EXTENSION vector;");
-$node->safe_psql("postgres", "CREATE TABLE tst (i int4, v vector(3));");
+$node->safe_psql("postgres", "CREATE TABLE tst (i serial, v vector(3));");
 
 # Generate queries
-for (1..20) {
+for (1 .. 20)
+{
 	my $r1 = rand();
 	my $r2 = rand();
 	my $r3 = rand();
@@ -61,28 +65,32 @@ for (1..20) {
 
 # Check each index type
 my @operators = ("<->", "<#>", "<=>");
+my @opclasses = ("vector_l2_ops", "vector_ip_ops", "vector_cosine_ops");
 
-foreach (@operators) {
-	my $operator = $_;
+for my $i (0 .. $#operators)
+{
+	my $operator = $operators[$i];
+	my $opclass = $opclasses[$i];
 
 	# Add index
-	my $opclass;
-	if ($operator eq "<->") {
-		$opclass = "vector_l2_ops";
-	} elsif ($operator eq "<#>") {
-		$opclass = "vector_ip_ops";
-	} else {
-		$opclass = "vector_cosine_ops";
-	}
 	$node->safe_psql("postgres", "CREATE INDEX idx ON tst USING hnsw (v $opclass);");
 
-	$node->safe_psql("postgres",
-		"INSERT INTO tst SELECT i, ARRAY[random(), random(), random()] FROM generate_series(1, 10000) i;"
+	# Use concurrent inserts
+	$node->pgbench(
+		"--no-vacuum --client=10 --transactions=1000",
+		0,
+		[qr{actually processed}],
+		[qr{^$}],
+		"concurrent INSERTs",
+		{
+			"013_hnsw_insert_recall_$opclass" => "INSERT INTO tst (v) VALUES (ARRAY[random(), random(), random()]);"
+		}
 	);
 
 	# Get exact results
 	@expected = ();
-	foreach (@queries) {
+	foreach (@queries)
+	{
 		my $res = $node->safe_psql("postgres", qq(
 			SET enable_indexscan = off;
 			SELECT i FROM tst ORDER BY v $operator '$_' LIMIT $limit;
@@ -90,11 +98,8 @@ foreach (@operators) {
 		push(@expected, $res);
 	}
 
-	if ($operator eq "<#>") {
-		test_recall(0.80, $operator);
-	} else {
-		test_recall(0.99, $operator);
-	}
+	my $min = $operator eq "<#>" ? 0.80 : 0.99;
+	test_recall($min, $operator);
 
 	$node->safe_psql("postgres", "DROP INDEX idx;");
 	$node->safe_psql("postgres", "TRUNCATE tst;");

test/t/014_hnsw_inserts.pl

@@ -17,22 +17,8 @@ $node->start;
 # Create table and index
 $node->safe_psql("postgres", "CREATE EXTENSION vector;");
 $node->safe_psql("postgres", "CREATE TABLE tst (v vector($dim));");
-$node->safe_psql("postgres",
-	"INSERT INTO tst SELECT ARRAY[$array_sql] FROM generate_series(1, 100) i;"
-);
 $node->safe_psql("postgres", "CREATE INDEX ON tst USING hnsw (v vector_l2_ops);");
 
-$node->pgbench(
-	"--no-vacuum --client=5 --transactions=100",
-	0,
-	[qr{actually processed}],
-	[qr{^$}],
-	"concurrent INSERTs",
-	{
-		"007_inserts" => "INSERT INTO tst SELECT ARRAY[$array_sql] FROM generate_series(1, 10) i;"
-	}
-);
-
 sub idx_scan
 {
 	# Stats do not update instantaneously
@@ -41,18 +27,48 @@ sub idx_scan
 	$node->safe_psql("postgres", "SELECT idx_scan FROM pg_stat_user_indexes WHERE indexrelid = 'tst_v_idx'::regclass;");
 }
 
-my $expected = 100 + 5 * 100 * 10;
+for my $i (1 .. 20)
+{
+	$node->pgbench(
+		"--no-vacuum --client=10 --transactions=1",
+		0,
+		[qr{actually processed}],
+		[qr{^$}],
+		"concurrent INSERTs",
+		{
+			"014_hnsw_inserts_$i" => "INSERT INTO tst VALUES (ARRAY[$array_sql]);"
+		}
+	);
 
-my $count = $node->safe_psql("postgres", "SELECT COUNT(*) FROM tst;");
-is($count, $expected);
-is(idx_scan(), 0);
+	my $count = $node->safe_psql("postgres", qq(
+		SET enable_seqscan = off;
+		SELECT COUNT(*) FROM (SELECT v FROM tst ORDER BY v <-> (SELECT v FROM tst LIMIT 1)) t;
+	));
+	is($count, 10);
 
-$count = $node->safe_psql("postgres", qq(
+	$node->safe_psql("postgres", "TRUNCATE tst;");
+}
+
+$node->pgbench(
+	"--no-vacuum --client=20 --transactions=5",
+	0,
+	[qr{actually processed}],
+	[qr{^$}],
+	"concurrent INSERTs",
+	{
+		"014_hnsw_inserts" => "INSERT INTO tst SELECT ARRAY[$array_sql] FROM generate_series(1, 10) i;"
+	}
+);
+
+my $count = $node->safe_psql("postgres", qq(
 	SET enable_seqscan = off;
-	SET hnsw.ef_search = 400;
+	SET hnsw.ef_search = 1000;
 	SELECT COUNT(*) FROM (SELECT v FROM tst ORDER BY v <-> (SELECT v FROM tst LIMIT 1)) t;
 ));
-is($count, 400);
-is(idx_scan(), 1);
+# Elements may lose all incoming connections with the HNSW algorithm
+# Vacuuming can fix this if one of the elements neighbors is deleted
+cmp_ok($count, ">=", 997);
+
+is(idx_scan(), 21);
 
 done_testing();

test/t/015_hnsw_duplicates.pl

@@ -0,0 +1,58 @@
+use strict;
+use warnings;
+use PostgresNode;
+use TestLib;
+use Test::More;
+
+# Initialize node
+my $node = get_new_node('node');
+$node->init;
+$node->start;
+
+# Create table
+$node->safe_psql("postgres", "CREATE EXTENSION vector;");
+$node->safe_psql("postgres", "CREATE TABLE tst (v vector(3));");
+
+sub insert_vectors
+{
+	for my $i (1 .. 20)
+	{
+		$node->safe_psql("postgres", "INSERT INTO tst VALUES ('[1,1,1]');");
+	}
+}
+
+sub test_duplicates
+{
+	my $res = $node->safe_psql("postgres", qq(
+		SET enable_seqscan = off;
+		SET hnsw.ef_search = 1;
+		SELECT COUNT(*) FROM (SELECT * FROM tst ORDER BY v <-> '[1,1,1]') t;
+	));
+	is($res, 10);
+}
+
+# Test duplicates with build
+insert_vectors();
+$node->safe_psql("postgres", "CREATE INDEX idx ON tst USING hnsw (v vector_l2_ops);");
+test_duplicates();
+
+# Reset
+$node->safe_psql("postgres", "TRUNCATE tst;");
+
+# Test duplicates with inserts
+insert_vectors();
+test_duplicates();
+
+# Test fallback path for inserts
+$node->pgbench(
+	"--no-vacuum --client=5 --transactions=100",
+	0,
+	[qr{actually processed}],
+	[qr{^$}],
+	"concurrent INSERTs",
+	{
+		"015_hnsw_duplicates" => "INSERT INTO tst VALUES ('[1,1,1]');"
+	}
+);
+
+done_testing();

test/t/016_hnsw_vacuum_recall.pl

@@ -0,0 +1,97 @@
+use strict;
+use warnings;
+use PostgresNode;
+use TestLib;
+use Test::More;
+
+my $node;
+my @queries = ();
+my @expected;
+my $limit = 20;
+
+sub test_recall
+{
+	my ($min, $ef_search, $test_name) = @_;
+	my $correct = 0;
+	my $total = 0;
+
+	my $explain = $node->safe_psql("postgres", qq(
+		SET enable_seqscan = off;
+		SET hnsw.ef_search = $ef_search;
+		EXPLAIN ANALYZE SELECT i FROM tst ORDER BY v <-> '$queries[0]' LIMIT $limit;
+	));
+	like($explain, qr/Index Scan/);
+
+	for my $i (0 .. $#queries)
+	{
+		my $actual = $node->safe_psql("postgres", qq(
+			SET enable_seqscan = off;
+			SET hnsw.ef_search = $ef_search;
+			SELECT i FROM tst ORDER BY v <-> '$queries[$i]' LIMIT $limit;
+		));
+		my @actual_ids = split("\n", $actual);
+		my %actual_set = map { $_ => 1 } @actual_ids;
+
+		my @expected_ids = split("\n", $expected[$i]);
+
+		foreach (@expected_ids)
+		{
+			if (exists($actual_set{$_}))
+			{
+				$correct++;
+			}
+			$total++;
+		}
+	}
+
+	cmp_ok($correct / $total, ">=", $min, $test_name);
+}
+
+# Initialize node
+$node = get_new_node('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(3));");
+$node->safe_psql("postgres", "ALTER TABLE tst SET (autovacuum_enabled = false);");
+$node->safe_psql("postgres",
+	"INSERT INTO tst SELECT i, ARRAY[random(), random(), random()] FROM generate_series(1, 10000) i;"
+);
+
+# Add index
+$node->safe_psql("postgres", "CREATE INDEX ON tst USING hnsw (v vector_l2_ops) WITH (m = 4, ef_construction = 8);");
+
+# Delete data
+$node->safe_psql("postgres", "DELETE FROM tst WHERE i > 2500;");
+
+# Generate queries
+for (1 .. 20)
+{
+	my $r1 = rand();
+	my $r2 = rand();
+	my $r3 = rand();
+	push(@queries, "[$r1,$r2,$r3]");
+}
+
+# Get exact results
+@expected = ();
+foreach (@queries)
+{
+	my $res = $node->safe_psql("postgres", qq(
+		SET enable_indexscan = off;
+		SELECT i FROM tst ORDER BY v <-> '$_' LIMIT $limit;
+	));
+	push(@expected, $res);
+}
+
+test_recall(0.20, $limit, "before vacuum");
+test_recall(0.95, 100, "before vacuum");
+
+# TODO Test concurrent inserts with vacuum
+$node->safe_psql("postgres", "VACUUM tst;");
+
+test_recall(0.95, $limit, "after vacuum");
+
+done_testing();

test/t/017_ivfflat_insert_recall.pl

@@ -0,0 +1,117 @@
+use strict;
+use warnings;
+use PostgresNode;
+use TestLib;
+use Test::More;
+
+my $node;
+my @queries = ();
+my @expected;
+my $limit = 20;
+
+sub test_recall
+{
+	my ($probes, $min, $operator) = @_;
+	my $correct = 0;
+	my $total = 0;
+
+	my $explain = $node->safe_psql("postgres", qq(
+		SET enable_seqscan = off;
+		SET ivfflat.probes = $probes;
+		EXPLAIN ANALYZE SELECT i FROM tst ORDER BY v $operator '$queries[0]' LIMIT $limit;
+	));
+	like($explain, qr/Index Scan using idx on tst/);
+
+	for my $i (0 .. $#queries)
+	{
+		my $actual = $node->safe_psql("postgres", qq(
+			SET enable_seqscan = off;
+			SET ivfflat.probes = $probes;
+			SELECT i FROM tst ORDER BY v $operator '$queries[$i]' LIMIT $limit;
+		));
+		my @actual_ids = split("\n", $actual);
+		my %actual_set = map { $_ => 1 } @actual_ids;
+
+		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 = get_new_node('node');
+$node->init;
+$node->start;
+
+# Create table
+$node->safe_psql("postgres", "CREATE EXTENSION vector;");
+$node->safe_psql("postgres", "CREATE TABLE tst (i serial, v vector(3));");
+
+# Generate queries
+for (1 .. 20)
+{
+	my $r1 = rand();
+	my $r2 = rand();
+	my $r3 = rand();
+	push(@queries, "[$r1,$r2,$r3]");
+}
+
+# Check each index type
+my @operators = ("<->", "<#>", "<=>");
+my @opclasses = ("vector_l2_ops", "vector_ip_ops", "vector_cosine_ops");
+
+for my $i (0 .. $#operators)
+{
+	my $operator = $operators[$i];
+	my $opclass = $opclasses[$i];
+
+	# Add index
+	$node->safe_psql("postgres", "CREATE INDEX idx ON tst USING ivfflat (v $opclass);");
+
+	# Use concurrent inserts
+	$node->pgbench(
+		"--no-vacuum --client=10 --transactions=1000",
+		0,
+		[qr{actually processed}],
+		[qr{^$}],
+		"concurrent INSERTs",
+		{
+			"017_ivfflat_insert_recall_$opclass" => "INSERT INTO tst (v) SELECT ARRAY[random(), random(), random()] FROM generate_series(1, 10) i;"
+		}
+	);
+
+	# Get exact results
+	@expected = ();
+	foreach (@queries)
+	{
+		my $res = $node->safe_psql("postgres", qq(
+			SET enable_indexscan = off;
+			SELECT i FROM tst ORDER BY v $operator '$_' LIMIT $limit;
+		));
+		push(@expected, $res);
+	}
+
+	# Test approximate results
+	if ($operator ne "<#>")
+	{
+		# TODO Fix test (uniform random vectors all have similar inner product)
+		test_recall(1, 0.71, $operator);
+		test_recall(10, 0.95, $operator);
+	}
+	# Account for equal distances
+	test_recall(100, 0.9925, $operator);
+
+	$node->safe_psql("postgres", "DROP INDEX idx;");
+	$node->safe_psql("postgres", "TRUNCATE tst;");
+}
+
+done_testing();

test/t/018_ivfflat_deletes.pl

@@ -0,0 +1,43 @@
+use strict;
+use warnings;
+use PostgresNode;
+use TestLib;
+use Test::More;
+
+my $dim = 3;
+
+my $array_sql = join(",", ('random()') x $dim);
+
+# Initialize node
+my $node = get_new_node('node');
+$node->init;
+$node->start;
+
+# Create table and index
+$node->safe_psql("postgres", "CREATE EXTENSION vector;");
+$node->safe_psql("postgres", "CREATE TABLE tst (i serial, v vector($dim));");
+$node->safe_psql("postgres",
+	"INSERT INTO tst (v) SELECT ARRAY[$array_sql] FROM generate_series(1, 10000) i;"
+);
+$node->safe_psql("postgres", "CREATE INDEX ON tst USING ivfflat (v vector_l2_ops);");
+
+# Delete data
+$node->safe_psql("postgres", "DELETE FROM tst WHERE i % 100 != 0;");
+
+my $exp = $node->safe_psql("postgres", qq(
+	SET enable_indexscan = off;
+	SELECT i FROM tst ORDER BY v <-> '[0,0,0]';
+));
+
+# Run twice to make sure correct tuples marked as dead
+for (1 .. 2)
+{
+	my $res = $node->safe_psql("postgres", qq(
+		SET enable_seqscan = off;
+		SET ivfflat.probes = 100;
+		SELECT i FROM tst ORDER BY v <-> '[0,0,0]';
+	));
+	is($res, $exp);
+}
+
+done_testing();

vector.control

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