Added PrintGraph function for HNSW [skip ci]

CHANGELOG.md

@@ -1,17 +1,13 @@
-## 0.5.1 (unreleased)
-
-- Fixed locking for index scans for HNSW
-
-## 0.5.0 (2023-08-28)
+## 0.5.0 (unreleased)
 
 - Added HNSW index type
-- Added support for parallel index builds for IVFFlat
+- Added support for parallel index builds
 - 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
+- Fixed results for NULL and NaN distances
 
 ## 0.4.4 (2023-06-12)
 

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

Makefile

@@ -1,5 +1,5 @@
 EXTENSION = vector
-EXTVERSION = 0.5.0
+EXTVERSION = 0.4.4
 
 MODULE_big = vector
 DATA = $(wildcard sql/*--*.sql)
@@ -8,7 +8,7 @@ HEADERS = src/vector.h
 
 TESTS = $(wildcard test/sql/*.sql)
 REGRESS = $(patsubst test/sql/%.sql,%,$(TESTS))
-REGRESS_OPTS = --inputdir=test --load-extension=$(EXTENSION)
+REGRESS_OPTS = --inputdir=test --load-extension=vector
 
 OPTFLAGS = -march=native
 

Makefile.win

@@ -1,11 +1,11 @@
 EXTENSION = vector
-EXTVERSION = 0.5.0
+EXTVERSION = 0.4.4
 
 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=$(EXTENSION)
+REGRESS_OPTS = --inputdir=test --load-extension=vector
 
 # For /arch flags
 # https://learn.microsoft.com/en-us/cpp/build/reference/arch-minimum-cpu-architecture

README.md

@@ -18,7 +18,7 @@ Compile and install the extension (supports Postgres 11+)
 
 ```sh
 cd /tmp
-git clone --branch v0.5.0 https://github.com/pgvector/pgvector.git
+git clone --branch v0.4.4 https://github.com/pgvector/pgvector.git
 cd pgvector
 make
 make install # may need sudo
@@ -157,16 +157,7 @@ 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 speed. Unlike typical indexes, you will see different results for queries after adding an approximate index.
-
-Supported index types are:
-
-- [IVFFlat](#ivfflat)
-- [HNSW](#hnsw) - added in 0.5.0
-
-## IVFFlat
-
-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).
+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.
 
 Three keys to achieving good recall are:
 
@@ -215,63 +206,7 @@ SELECT ...
 COMMIT;
 ```
 
-## HNSW
-
-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);
-```
-
-Inner product
-
-```sql
-CREATE INDEX ON items USING hnsw (embedding vector_ip_ops);
-```
-
-Cosine distance
-
-```sql
-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)
-
-```sql
-SET hnsw.ef_search = 100;
-```
-
-A higher value provides better recall at the cost of speed.
-
-Use `SET LOCAL` inside a transaction to set it for a single query
-
-```sql
-BEGIN;
-SET LOCAL hnsw.ef_search = 100;
-SELECT ...
-COMMIT;
-```
-
-## Indexing Progress
+### Indexing Progress
 
 Check [indexing progress](https://www.postgresql.org/docs/current/progress-reporting.html#CREATE-INDEX-PROGRESS-REPORTING) with Postgres 12+
 
@@ -282,8 +217,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. `assigning tuples` - IVFFlat only
+2. `performing k-means`
+3. `sorting tuples`
 4. `loading tuples`
 
 Note: `tuples_done` and `tuples_total` are only populated during the `loading tuples` phase
@@ -348,7 +283,7 @@ SELECT * FROM items ORDER BY embedding <#> '[3,1,2]' LIMIT 5;
 
 ### Approximate Search
 
-To speed up queries with an IVFFlat index, increase the number of inverted lists (at the expense of recall).
+To speed up queries with an index, increase the number of inverted lists (at the expense of recall).
 
 ```sql
 CREATE INDEX ON items USING ivfflat (embedding vector_l2_ops) WITH (lists = 1000);
@@ -424,7 +359,7 @@ or choose to store vectors inline:
 ALTER TABLE items ALTER COLUMN embedding SET STORAGE PLAIN;
 ```
 
-#### Why are there less results for a query after adding an IVFFlat index?
+#### Why are there less results for a query after adding an index?
 
 The index was likely created with too little data for the number of lists. Drop the index until the table has more data.
 
@@ -440,32 +375,32 @@ Each vector takes `4 * dimensions + 8` bytes of storage. Each element is a singl
 
 ### Vector Operators
 
-Operator | Description | Added
---- | --- | ---
-\+ | element-wise addition |
-\- | element-wise subtraction |
-\* | element-wise multiplication | 0.5.0
-<-> | Euclidean distance |
-<#> | negative inner product |
-<=> | cosine distance |
+Operator | Description
+--- | ---
+\+ | element-wise addition
+\- | element-wise subtraction
+\* | element-wise multiplication [unreleased]
+<-> | Euclidean distance
+<#> | negative inner product
+<=> | cosine distance
 
 ### Vector Functions
 
-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 |
+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
 
 ### Aggregate Functions
 
-Function | Description | Added
---- | --- | ---
-avg(vector) → vector | average |
-sum(vector) → vector | sum | 0.5.0
+Function | Description
+--- | ---
+avg(vector) → vector | arithmetic mean
+sum(vector) → vector | sum [unreleased]
 
 ## Installation Notes
 
@@ -509,7 +444,7 @@ Then use `nmake` to build:
 
 ```cmd
 set "PGROOT=C:\Program Files\PostgreSQL\15"
-git clone --branch v0.5.0 https://github.com/pgvector/pgvector.git
+git clone --branch v0.4.4 https://github.com/pgvector/pgvector.git
 cd pgvector
 nmake /F Makefile.win
 nmake /F Makefile.win install
@@ -530,8 +465,9 @@ 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.5.0 https://github.com/pgvector/pgvector.git
+git clone --branch v0.4.4 https://github.com/pgvector/pgvector.git
 cd pgvector
+git cherry-pick 237a6df
 docker build --build-arg PG_MAJOR=15 -t myuser/pgvector .
 ```
 
@@ -595,18 +531,12 @@ pgvector is available on [these providers](https://github.com/pgvector/pgvector/
 
 ## Upgrading
 
-Install the latest version. Then in each database you want to upgrade, run:
+Install the latest version and 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

src/hnsw.c

@@ -91,7 +91,7 @@ hnswcostestimate(PlannerInfo *root, IndexPath *path, double loop_count,
 	MemSet(&costs, 0, sizeof(costs));
 
 	index = index_open(path->indexinfo->indexoid, NoLock);
-	HnswGetMetaPageInfo(index, &m, NULL);
+	m = HnswGetM(index);
 	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;
+	amroutine->amcanreturn = NULL;	/* tuple not included in heapsort */
 	amroutine->amcostestimate = hnswcostestimate;
 	amroutine->amoptions = hnswoptions;
 	amroutine->amproperty = NULL;	/* TODO AMPROP_DISTANCE_ORDERABLE */

src/hnsw.h

@@ -36,7 +36,7 @@
 #define HNSW_DEFAULT_M	16
 #define HNSW_MIN_M	2
 #define HNSW_MAX_M		100
-#define HNSW_DEFAULT_EF_CONSTRUCTION	64
+#define HNSW_DEFAULT_EF_CONSTRUCTION	40
 #define HNSW_MIN_EF_CONSTRUCTION	4
 #define HNSW_MAX_EF_CONSTRUCTION		1000
 #define HNSW_DEFAULT_EF_SEARCH	40
@@ -266,9 +266,8 @@ 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, int m, bool inserting, HnswElement skipElement);
+List	   *HnswSearchLayer(Datum q, List *ep, int ef, int lc, Relation index, FmgrInfo *procinfo, Oid collation, 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 HnswInitElementFromBlock(BlockNumber blkno, OffsetNumber offno);
@@ -285,7 +284,7 @@ void		HnswLoadElementFromTuple(HnswElement element, HnswElementTuple etup, bool
 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);
+void		HnswLoadNeighbors(HnswElement element, Relation index);
 
 /* Index access methods */
 IndexBuildResult *hnswbuild(Relation heap, Relation index, IndexInfo *indexInfo);

src/hnswinsert.c

@@ -329,7 +329,7 @@ HnswUpdateNeighborPages(Relation index, FmgrInfo *procinfo, Oid collation, HnswE
 
 			/* Get latest neighbors since they may have changed */
 			/* Do not lock yet since selecting neighbors can take time */
-			HnswLoadNeighbors(hc->element, index, m);
+			HnswLoadNeighbors(hc->element, index);
 
 			/*
 			 * Could improve performance for vacuuming by checking neighbors
@@ -492,8 +492,9 @@ HnswInsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heap_ti
 	FmgrInfo   *normprocinfo;
 	HnswElement entryPoint;
 	HnswElement element;
-	int			m;
+	int			m = HnswGetM(index);
 	int			efConstruction = HnswGetEfConstruction(index);
+	double		ml = HnswGetMl(m);
 	FmgrInfo   *procinfo = index_getprocinfo(index, 1, HNSW_DISTANCE_PROC);
 	Oid			collation = index->rd_indcollation[0];
 	HnswElement dup;
@@ -510,6 +511,10 @@ HnswInsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heap_ti
 			return false;
 	}
 
+	/* Create an element */
+	element = HnswInitElement(heap_tid, m, ml, HnswGetMaxLevel(m));
+	element->vec = DatumGetVector(value);
+
 	/*
 	 * 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
@@ -517,12 +522,8 @@ HnswInsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heap_ti
 	 */
 	LockPage(index, HNSW_UPDATE_LOCK, lockmode);
 
-	/* Get m and entry point */
-	HnswGetMetaPageInfo(index, &m, &entryPoint);
-
-	/* Create an element */
-	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)

src/hnswscan.c

@@ -19,11 +19,7 @@ GetScanItems(IndexScanDesc scan, Datum q)
 	Oid			collation = so->collation;
 	List	   *ep;
 	List	   *w;
-	int			m;
-	HnswElement entryPoint;
-
-	/* Get m and entry point */
-	HnswGetMetaPageInfo(index, &m, &entryPoint);
+	HnswElement entryPoint = HnswGetEntryPoint(index);
 
 	if (entryPoint == NULL)
 		return NIL;
@@ -32,11 +28,11 @@ GetScanItems(IndexScanDesc scan, Datum q)
 
 	for (int lc = entryPoint->level; lc >= 1; lc--)
 	{
-		w = HnswSearchLayer(q, ep, 1, lc, index, procinfo, collation, m, false, NULL);
+		w = HnswSearchLayer(q, ep, 1, lc, index, procinfo, collation, false, NULL);
 		ep = w;
 	}
 
-	return HnswSearchLayer(q, ep, hnsw_ef_search, 0, index, procinfo, collation, m, false, NULL);
+	return HnswSearchLayer(q, ep, hnsw_ef_search, 0, index, procinfo, collation, false, NULL);
 }
 
 /*
@@ -62,33 +58,6 @@ 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
  */
@@ -114,12 +83,6 @@ 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;
 }
 
@@ -167,28 +130,49 @@ hnswgettuple(IndexScanDesc scan, ScanDirection dir)
 		if (scan->orderByData == NULL)
 			elog(ERROR, "cannot scan hnsw index without order");
 
-		/* Get scan value */
-		value = GetScanValue(scan);
+		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);
+		}
+
+		/*
+		 * 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);
 
 		so->w = GetScanItems(scan, value);
 
+		/* Release shared lock */
+		UnlockPage(scan->indexRelation, HNSW_SCAN_LOCK, ShareLock);
+
 		so->first = false;
 	}
 
 	while (list_length(so->w) > 0)
 	{
 		HnswCandidate *hc = llast(so->w);
-		ItemPointer heaptid;
+		ItemPointer tid;
 		BlockNumber indexblkno;
 
-		/* 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;
 		}
 
-		heaptid = llast(hc->element->heaptids);
+		tid = llast(hc->element->heaptids);
 		indexblkno = hc->element->blkno;
 
 		hc->element->heaptids = list_delete_last(hc->element->heaptids);
@@ -196,12 +180,11 @@ hnswgettuple(IndexScanDesc scan, ScanDirection dir)
 		MemoryContextSwitchTo(oldCtx);
 
 #if PG_VERSION_NUM >= 120000
-		scan->xs_heaptid = *heaptid;
+		scan->xs_heaptid = *tid;
 #else
-		scan->xs_ctup.t_self = *heaptid;
+		scan->xs_ctup.t_self = *tid;
 #endif
 
-		/* Unpin buffer */
 		if (BufferIsValid(so->buf))
 			ReleaseBuffer(so->buf);
 
@@ -233,9 +216,6 @@ hnswendscan(IndexScanDesc scan)
 	if (BufferIsValid(so->buf))
 		ReleaseBuffer(so->buf);
 
-	/* Release shared lock */
-	UnlockPage(scan->indexRelation, HNSW_SCAN_LOCK, ShareLock);
-
 	MemoryContextDelete(so->tmpCtx);
 
 	pfree(so);

src/hnswutils.c

@@ -210,43 +210,25 @@ HnswInitElementFromBlock(BlockNumber blkno, OffsetNumber offno)
 }
 
 /*
- * Get the metapage info
+ * Get the entry point
  */
-void
-HnswGetMetaPageInfo(Relation index, int *m, HnswElement * entryPoint)
+HnswElement
+HnswGetEntryPoint(Relation index)
 {
 	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 (m != NULL)
-		*m = metap->m;
-
-	if (entryPoint != NULL)
-	{
-		if (BlockNumberIsValid(metap->entryBlkno))
-			*entryPoint = HnswInitElementFromBlock(metap->entryBlkno, metap->entryOffno);
-		else
-			*entryPoint = NULL;
-	}
+	if (BlockNumberIsValid(metap->entryBlkno))
+		entryPoint = HnswInitElementFromBlock(metap->entryBlkno, metap->entryOffno);
 
 	UnlockReleaseBuffer(buf);
-}
-
-/*
- * Get the entry point
- */
-HnswElement
-HnswGetEntryPoint(Relation index)
-{
-	HnswElement entryPoint;
-
-	HnswGetMetaPageInfo(index, NULL, &entryPoint);
 
 	return entryPoint;
 }
@@ -355,9 +337,10 @@ HnswSetNeighborTuple(HnswNeighborTuple ntup, HnswElement e, int m)
  * Load neighbors from page
  */
 static void
-LoadNeighborsFromPage(HnswElement element, Relation index, Page page, int m)
+LoadNeighborsFromPage(HnswElement element, Relation index, Page page)
 {
 	HnswNeighborTuple ntup = (HnswNeighborTuple) PageGetItem(page, PageGetItemId(page, element->neighborOffno));
+	int			m = HnswGetM(index);
 	int			neighborCount = (element->level + 2) * m;
 
 	Assert(HnswIsNeighborTuple(ntup));
@@ -398,7 +381,7 @@ LoadNeighborsFromPage(HnswElement element, Relation index, Page page, int m)
  * Load neighbors
  */
 void
-HnswLoadNeighbors(HnswElement element, Relation index, int m)
+HnswLoadNeighbors(HnswElement element, Relation index)
 {
 	Buffer		buf;
 	Page		page;
@@ -407,7 +390,7 @@ HnswLoadNeighbors(HnswElement element, Relation index, int m)
 	LockBuffer(buf, BUFFER_LOCK_SHARE);
 	page = BufferGetPage(buf);
 
-	LoadNeighborsFromPage(element, index, page, m);
+	LoadNeighborsFromPage(element, index, page);
 
 	UnlockReleaseBuffer(buf);
 }
@@ -560,7 +543,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, int m, bool inserting, HnswElement skipElement)
+HnswSearchLayer(Datum q, List *ep, int ef, int lc, Relation index, FmgrInfo *procinfo, Oid collation, bool inserting, HnswElement skipElement)
 {
 	ListCell   *lc2;
 
@@ -615,7 +598,7 @@ HnswSearchLayer(Datum q, List *ep, int ef, int lc, Relation index, FmgrInfo *pro
 			break;
 
 		if (c->element->neighbors == NULL)
-			HnswLoadNeighbors(c->element, index, m);
+			HnswLoadNeighbors(c->element, index);
 
 		/* Get the neighborhood at layer lc */
 		neighborhood = &c->element->neighbors[lc];
@@ -640,6 +623,10 @@ HnswSearchLayer(Datum q, List *ep, int ef, int lc, Relation index, FmgrInfo *pro
 
 				Assert(!e->element->deleted);
 
+				/* Skip self for vacuuming update */
+				if (skipElement != NULL && e->element->blkno == skipElement->blkno && e->element->offno == skipElement->offno)
+					continue;
+
 				/* Make robust to issues */
 				if (e->element->level < lc)
 					continue;
@@ -926,10 +913,10 @@ HnswUpdateConnection(HnswElement element, HnswCandidate * hc, int m, int lc, int
 }
 
 /*
- * Remove elements being deleted or skipped
+ * Remove elements being deleted
  */
 static List *
-RemoveElements(List *w, HnswElement skipElement)
+RemoveElementsBeingDeleted(List *w)
 {
 	ListCell   *lc2;
 	List	   *w2 = NIL;
@@ -938,10 +925,6 @@ RemoveElements(List *w, HnswElement skipElement)
 	{
 		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);
 	}
@@ -973,34 +956,27 @@ HnswInsertElement(HnswElement element, HnswElement entryPoint, Relation index, F
 	/* 1st phase: greedy search to insert level */
 	for (int lc = entryLevel; lc >= level + 1; lc--)
 	{
-		w = HnswSearchLayer(q, ep, 1, lc, index, procinfo, collation, m, true, skipElement);
+		w = HnswSearchLayer(q, ep, 1, lc, index, procinfo, collation, 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, m, true, skipElement);
+		w = HnswSearchLayer(q, ep, efConstruction, lc, index, procinfo, collation, true, skipElement);
 
-		/* Elements being deleted or skipped can help with search */
+		/* Elements being deleted can help with search */
 		/* but should be removed before selecting neighbors */
 		if (index != NULL)
-			lw = RemoveElements(w, skipElement);
-		else
-			lw = w;
+			w = RemoveElementsBeingDeleted(w);
 
-		neighbors = SelectNeighbors(lw, lm, lc, procinfo, collation, NULL);
+		neighbors = SelectNeighbors(w, lm, lc, procinfo, collation, NULL);
 
 		AddConnections(element, neighbors, lm, lc);
 

src/hnswvacuum.c

@@ -330,10 +330,7 @@ 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.
-	 */
+	/* Wait for inserts to complete */
 	LockPage(index, HNSW_UPDATE_LOCK, ExclusiveLock);
 	UnlockPage(index, HNSW_UPDATE_LOCK, ExclusiveLock);
 
@@ -446,11 +443,7 @@ MarkDeleted(HnswVacuumState * vacuumstate)
 	Relation	index = vacuumstate->index;
 	BufferAccessStrategy bas = vacuumstate->bas;
 
-	/*
-	 * Wait for index scans to complete. Scans before this point may contain
-	 * tuples about to be deleted. Scans after this point will not, since the
-	 * graph has been repaired.
-	 */
+	/* Wait for selects to complete */
 	LockPage(index, HNSW_SCAN_LOCK, ExclusiveLock);
 	UnlockPage(index, HNSW_SCAN_LOCK, ExclusiveLock);
 
@@ -589,6 +582,7 @@ 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);
@@ -598,9 +592,6 @@ 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);
@@ -620,6 +611,67 @@ FreeVacuumState(HnswVacuumState * vacuumstate)
 	MemoryContextDelete(vacuumstate->tmpCtx);
 }
 
+/*
+ * Print graph
+ */
+#ifdef HNSW_DEBUG
+static void
+PrintGraph(HnswVacuumState * vacuumstate)
+{
+	BlockNumber blkno = HNSW_HEAD_BLKNO;
+	Relation	index = vacuumstate->index;
+
+	while (BlockNumberIsValid(blkno))
+	{
+		Buffer		buf;
+		Page		page;
+		OffsetNumber offno;
+		OffsetNumber maxoffno;
+
+		buf = ReadBuffer(index, blkno);
+		LockBuffer(buf, BUFFER_LOCK_SHARE);
+		page = BufferGetPage(buf);
+		maxoffno = PageGetMaxOffsetNumber(page);
+
+		for (offno = FirstOffsetNumber; offno <= maxoffno; offno = OffsetNumberNext(offno))
+		{
+			HnswElementTuple etup = (HnswElementTuple) PageGetItem(page, PageGetItemId(page, offno));
+			HnswElement element;
+
+			/* Skip neighbor tuples */
+			if (!HnswIsElementTuple(etup))
+				continue;
+
+			/* Skip deleted tuples */
+			if (etup->deleted)
+				continue;
+
+			element = HnswInitElementFromBlock(blkno, offno);
+			HnswLoadElementFromTuple(element, etup, false, true);
+			HnswLoadNeighbors(element, index);
+
+			elog(INFO, "element (%d,%d)", element->blkno, element->offno);
+
+			for (int lc = element->level; lc >= 0; lc--)
+			{
+				HnswNeighborArray *neighbors = &element->neighbors[lc];
+
+				for (int i = 0; i < neighbors->length; i++)
+				{
+					HnswElement e = neighbors->items[i].element;
+
+					elog(INFO, "%d: (%d,%d)", lc, e->blkno, e->offno);
+				}
+			}
+		}
+
+		blkno = HnswPageGetOpaque(page)->nextblkno;
+
+		UnlockReleaseBuffer(buf);
+	}
+}
+#endif
+
 /*
  * Bulk delete tuples from the index
  */
@@ -640,6 +692,10 @@ hnswbulkdelete(IndexVacuumInfo *info, IndexBulkDeleteResult *stats,
 	/* Pass 3: Mark as deleted */
 	MarkDeleted(&vacuumstate);
 
+#ifdef HNSW_DEBUG
+	PrintGraph(&vacuumstate);
+#endif
+
 	FreeVacuumState(&vacuumstate);
 
 	return vacuumstate.stats;

src/ivfbuild.c

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

src/ivfflat.c

@@ -71,7 +71,7 @@ ivfflatcostestimate(PlannerInfo *root, IndexPath *path, double loop_count,
 	int			lists;
 	double		ratio;
 	double		spc_seq_page_cost;
-	Relation	index;
+	Relation	indexRel;
 #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));
 
-	index = index_open(path->indexinfo->indexoid, NoLock);
-	IvfflatGetMetaPageInfo(index, &lists, NULL);
-	index_close(index, NoLock);
+	indexRel = index_open(path->indexinfo->indexoid, NoLock);
+	lists = IvfflatGetLists(indexRel);
+	index_close(indexRel, NoLock);
 
 	/* Get the ratio of lists that we need to visit */
 	ratio = ((double) ivfflat_probes) / lists;

src/ivfflat.h

@@ -244,8 +244,8 @@ typedef struct IvfflatScanList
 typedef struct IvfflatScanOpaqueData
 {
 	int			probes;
-	int			dimensions;
 	bool		first;
+	Buffer		buf;
 
 	/* Sorting */
 	Tuplesortstate *sortstate;
@@ -278,7 +278,6 @@ 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

@@ -31,36 +31,36 @@ CompareLists(const pairingheap_node *a, const pairingheap_node *b, void *arg)
 static void
 GetScanLists(IndexScanDesc scan, Datum value)
 {
-	IvfflatScanOpaque so = (IvfflatScanOpaque) scan->opaque;
+	Buffer		cbuf;
+	Page		cpage;
+	IvfflatList list;
+	OffsetNumber offno;
+	OffsetNumber maxoffno;
 	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 (OffsetNumber offno = FirstOffsetNumber; offno <= maxoffno; offno = OffsetNumberNext(offno))
+		for (offno = FirstOffsetNumber; offno <= maxoffno; offno = OffsetNumberNext(offno))
 		{
-			IvfflatList list = (IvfflatList) PageGetItem(cpage, PageGetItemId(cpage, offno));
-			double		distance;
+			list = (IvfflatList) PageGetItem(cpage, PageGetItemId(cpage, offno));
 
 			/* 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,8 +75,6 @@ GetScanLists(IndexScanDesc scan, Datum value)
 			}
 			else if (distance < maxDistance)
 			{
-				IvfflatScanList *scanlist;
-
 				/* Remove */
 				scanlist = (IvfflatScanList *) pairingheap_remove_first(so->listQueue);
 
@@ -103,6 +101,14 @@ 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;
 
@@ -122,28 +128,19 @@ GetScanItems(IndexScanDesc scan, Datum value)
 	/* Search closest probes lists */
 	while (!pairingheap_is_empty(so->listQueue))
 	{
-		BlockNumber searchPage = ((IvfflatScanList *) pairingheap_remove_first(so->listQueue))->startPage;
+		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 (OffsetNumber offno = FirstOffsetNumber; offno <= maxoffno; offno = OffsetNumberNext(offno))
+			for (offno = FirstOffsetNumber; offno <= maxoffno; offno = OffsetNumberNext(offno))
 			{
-				IndexTuple	itup;
-				Datum		datum;
-				bool		isnull;
-				ItemId		itemid = PageGetItemId(page, offno);
-
-				itup = (IndexTuple) PageGetItem(page, itemid);
+				itup = (IndexTuple) PageGetItem(page, PageGetItemId(page, offno));
 				datum = index_getattr(itup, 1, tupdesc, &isnull);
 
 				/*
@@ -157,6 +154,8 @@ GetScanItems(IndexScanDesc scan, Datum value)
 				slot->tts_isnull[0] = false;
 				slot->tts_values[1] = PointerGetDatum(&itup->t_tid);
 				slot->tts_isnull[1] = false;
+				slot->tts_values[2] = Int32GetDatum((int) searchPage);
+				slot->tts_isnull[2] = false;
 				ExecStoreVirtualTuple(slot);
 
 				tuplesort_puttupleslot(so->sortstate, slot);
@@ -181,6 +180,29 @@ GetScanItems(IndexScanDesc scan, Datum value)
 	tuplesort_performsort(so->sortstate);
 }
 
+/*
+ * Get dimensions from metapage
+ */
+static int
+GetDimensions(Relation index)
+{
+	Buffer		buf;
+	Page		page;
+	IvfflatMetaPage metap;
+	int			dimensions;
+
+	buf = ReadBuffer(index, IVFFLAT_METAPAGE_BLKNO);
+	LockBuffer(buf, BUFFER_LOCK_SHARE);
+	page = BufferGetPage(buf);
+	metap = IvfflatPageGetMeta(page);
+
+	dimensions = metap->dimensions;
+
+	UnlockReleaseBuffer(buf);
+
+	return dimensions;
+}
+
 /*
  * Prepare for an index scan
  */
@@ -190,7 +212,6 @@ ivfflatbeginscan(Relation index, int nkeys, int norderbys)
 	IndexScanDesc scan;
 	IvfflatScanOpaque so;
 	int			lists;
-	int			dimensions;
 	AttrNumber	attNums[] = {1};
 	Oid			sortOperators[] = {Float8LessOperator};
 	Oid			sortCollations[] = {InvalidOid};
@@ -198,17 +219,15 @@ ivfflatbeginscan(Relation index, int nkeys, int norderbys)
 	int			probes = ivfflat_probes;
 
 	scan = RelationGetIndexScan(index, nkeys, norderbys);
-
-	/* Get lists and dimensions from metapage */
-	IvfflatGetMetaPageInfo(index, &lists, &dimensions);
+	lists = IvfflatGetLists(scan->indexRelation);
 
 	if (probes > lists)
 		probes = lists;
 
 	so = (IvfflatScanOpaque) palloc(offsetof(IvfflatScanOpaqueData, lists) + probes * sizeof(IvfflatScanList));
+	so->buf = InvalidBuffer;
 	so->first = true;
 	so->probes = probes;
-	so->dimensions = dimensions;
 
 	/* Set support functions */
 	so->procinfo = index_getprocinfo(index, 1, IVFFLAT_DISTANCE_PROC);
@@ -217,12 +236,13 @@ ivfflatbeginscan(Relation index, int nkeys, int norderbys)
 
 	/* Create tuple description for sorting */
 #if PG_VERSION_NUM >= 120000
-	so->tupdesc = CreateTemplateTupleDesc(2);
+	so->tupdesc = CreateTemplateTupleDesc(3);
 #else
-	so->tupdesc = CreateTemplateTupleDesc(2, false);
+	so->tupdesc = CreateTemplateTupleDesc(3, false);
 #endif
 	TupleDescInitEntry(so->tupdesc, (AttrNumber) 1, "distance", FLOAT8OID, -1, 0);
-	TupleDescInitEntry(so->tupdesc, (AttrNumber) 2, "heaptid", TIDOID, -1, 0);
+	TupleDescInitEntry(so->tupdesc, (AttrNumber) 2, "tid", TIDOID, -1, 0);
+	TupleDescInitEntry(so->tupdesc, (AttrNumber) 3, "indexblkno", INT4OID, -1, 0);
 
 	/* Prep sort */
 	so->sortstate = tuplesort_begin_heap(so->tupdesc, 1, attNums, sortOperators, sortCollations, nullsFirstFlags, work_mem, NULL, false);
@@ -288,12 +308,8 @@ ivfflatgettuple(IndexScanDesc scan, ScanDirection dir)
 		if (scan->orderByData == NULL)
 			elog(ERROR, "cannot scan ivfflat index without order");
 
-		/* Safety check */
-		if (!IsMVCCSnapshot(scan->xs_snapshot))
-			elog(ERROR, "non-MVCC snapshots are not supported with ivfflat");
-
 		if (scan->orderByData->sk_flags & SK_ISNULL)
-			value = PointerGetDatum(InitVector(so->dimensions));
+			value = PointerGetDatum(InitVector(GetDimensions(scan->indexRelation)));
 		else
 		{
 			value = scan->orderByData->sk_argument;
@@ -318,19 +334,25 @@ ivfflatgettuple(IndexScanDesc scan, ScanDirection dir)
 
 	if (tuplesort_gettupleslot(so->sortstate, true, false, so->slot, NULL))
 	{
-		ItemPointer heaptid = (ItemPointer) DatumGetPointer(slot_getattr(so->slot, 2, &so->isnull));
+		ItemPointer tid = (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 = *heaptid;
+		scan->xs_heaptid = *tid;
 #else
-		scan->xs_ctup.t_self = *heaptid;
+		scan->xs_ctup.t_self = *tid;
 #endif
 
+		if (BufferIsValid(so->buf))
+			ReleaseBuffer(so->buf);
+
 		/*
-		 * Since no pinning during sorting, requires MVCC-compliant snapshot.
-		 * Also, cannot kill prior tuples, since heap TID may be recycled.
+		 * An index scan must maintain a pin on the index page holding the
+		 * item last returned by amgettuple
+		 *
 		 * https://www.postgresql.org/docs/current/index-locking.html
 		 */
+		so->buf = ReadBuffer(scan->indexRelation, indexblkno);
 
 		scan->xs_recheckorderby = false;
 		return true;
@@ -347,6 +369,10 @@ ivfflatendscan(IndexScanDesc scan)
 {
 	IvfflatScanOpaque so = (IvfflatScanOpaque) scan->opaque;
 
+	/* Release pin */
+	if (BufferIsValid(so->buf))
+		ReleaseBuffer(so->buf);
+
 	pairingheap_free(so->listQueue);
 	tuplesort_end(so->sortstate);
 

src/ivfutils.c

@@ -172,29 +172,6 @@ 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/vector.c

@@ -695,8 +695,6 @@ 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;
 
@@ -704,7 +702,7 @@ vector_spherical_distance(PG_FUNCTION_ARGS)
 
 	/* Auto-vectorized */
 	for (int i = 0; i < a->dim; i++)
-		dp += ax[i] * bx[i];
+		dp += a->x[i] * b->x[i];
 
 	distance = (double) dp;
 

test/expected/functions.out

@@ -106,12 +106,6 @@ 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 
 -----------------

test/sql/functions.sql

@@ -25,7 +25,6 @@ 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]');

test/t/001_ivfflat_wal.pl

@@ -19,6 +19,8 @@ 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";

test/t/003_ivfflat_recall.pl

@@ -94,7 +94,7 @@ for my $i (0 .. $#operators)
 	# Test approximate results
 	if ($operator ne "<#>")
 	{
-		# TODO Fix test (uniform random vectors all have similar inner product)
+		# TODO fix test
 		test_recall(1, 0.71, $operator);
 		test_recall(10, 0.95, $operator);
 	}
@@ -115,7 +115,7 @@ for my $i (0 .. $#operators)
 	# Test approximate results
 	if ($operator ne "<#>")
 	{
-		# TODO Fix test (uniform random vectors all have similar inner product)
+		# TODO fix test
 		test_recall(1, 0.71, $operator);
 		test_recall(10, 0.95, $operator);
 	}

test/t/010_hnsw_wal.pl

@@ -19,6 +19,8 @@ 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";

test/t/016_hnsw_vacuum_recall.pl

@@ -89,7 +89,7 @@ foreach (@queries)
 test_recall(0.20, $limit, "before vacuum");
 test_recall(0.95, 100, "before vacuum");
 
-# TODO Test concurrent inserts with vacuum
+# TODO test concurrent inserts with vacuum
 $node->safe_psql("postgres", "VACUUM tst;");
 
 test_recall(0.95, $limit, "after vacuum");

test/t/017_ivfflat_insert_recall.pl

@@ -1,117 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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 and hnsw access methods'
-default_version = '0.5.0'
+comment = 'vector data type and ivfflat access method'
+default_version = '0.4.4'
 module_pathname = '$libdir/vector'
 relocatable = true