Added comment [skip ci]

src/hnsw.c

@@ -155,15 +155,6 @@ hnswvalidate(Oid opclassoid)
 	return true;
 }
 
-/*
- * Checks if index-only scan is supported
- */
-static bool
-hnswcanreturn(Relation indexRelation, int attno)
-{
-	return attno == 1 && !OidIsValid(index_getprocid(indexRelation, 1, HNSW_NORM_PROC));
-}
-
 /*
  * Define index handler
  *
@@ -205,7 +196,7 @@ hnswhandler(PG_FUNCTION_ARGS)
 	amroutine->aminsert = hnswinsert;
 	amroutine->ambulkdelete = hnswbulkdelete;
 	amroutine->amvacuumcleanup = hnswvacuumcleanup;
-	amroutine->amcanreturn = hnswcanreturn;
+	amroutine->amcanreturn = NULL;	/* tuple not included in heapsort */
 	amroutine->amcostestimate = hnswcostestimate;
 	amroutine->amoptions = hnswoptions;
 	amroutine->amproperty = NULL;	/* TODO AMPROP_DISTANCE_ORDERABLE */

src/hnsw.h

@@ -219,6 +219,9 @@ typedef struct HnswScanOpaqueData
 {
 	bool		first;
 	Buffer		buf;
+	ItemPointerData heaptid;
+	OffsetNumber offno;
+	int			removedCount;
 	List	   *w;
 	MemoryContext tmpCtx;
 
@@ -266,7 +269,7 @@ 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 loadVec, 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);
 HnswElement HnswInitElement(ItemPointer tid, int m, double ml, int maxLevel);
 void		HnswFreeElement(HnswElement element);

src/hnswscan.c

@@ -17,7 +17,6 @@ GetScanItems(IndexScanDesc scan, Datum q)
 	Relation	index = scan->indexRelation;
 	FmgrInfo   *procinfo = so->procinfo;
 	Oid			collation = so->collation;
-	bool		loadVec = scan->xs_want_itup;
 	List	   *ep;
 	List	   *w;
 	HnswElement entryPoint = HnswGetEntryPoint(index);
@@ -25,15 +24,15 @@ GetScanItems(IndexScanDesc scan, Datum q)
 	if (entryPoint == NULL)
 		return NIL;
 
-	ep = list_make1(HnswEntryCandidate(entryPoint, q, index, procinfo, collation, loadVec));
+	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, loadVec, 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, loadVec, NULL);
+	return HnswSearchLayer(q, ep, hnsw_ef_search, 0, index, procinfo, collation, false, NULL);
 }
 
 /*
@@ -59,6 +58,75 @@ GetDimensions(Relation index)
 	return dimensions;
 }
 
+/*
+ * Remove deleted heap TID
+ */
+static void
+RemoveHeapTid(IndexScanDesc scan)
+{
+	HnswScanOpaque so = (HnswScanOpaque) scan->opaque;
+	Relation	index = scan->indexRelation;
+	Buffer		buf = so->buf;
+	Page		page;
+	GenericXLogState *state;
+	ItemId		itemid;
+	HnswElementTuple etup;
+	Size		etupSize;
+	int			idx = -1;
+
+	/* Safety check */
+	if (!BufferIsValid(buf) || !OffsetNumberIsValid(so->offno) || !ItemPointerIsValid(&so->heaptid))
+		return;
+
+	/* Use WAL rather than hint */
+	LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
+	state = GenericXLogStart(index);
+	page = GenericXLogRegisterBuffer(state, buf, 0);
+	itemid = PageGetItemId(page, so->offno);
+	etup = (HnswElementTuple) PageGetItem(page, itemid);
+	etupSize = ItemIdGetLength(itemid);
+
+	Assert(HnswIsElementTuple(etup));
+
+	/* Find index */
+	for (int i = 0; i < HNSW_HEAPTIDS; i++)
+	{
+		if (!ItemPointerIsValid(&etup->heaptids[i]))
+			break;
+
+		if (ItemPointerEquals(&etup->heaptids[i], &so->heaptid))
+		{
+			idx = i;
+			break;
+		}
+	}
+
+	if (idx == -1)
+		GenericXLogAbort(state);
+	else
+	{
+		/* Move pointers forward */
+		for (int i = idx; i < HNSW_HEAPTIDS; i++)
+		{
+			if (i + 1 == HNSW_HEAPTIDS || !ItemPointerIsValid(&etup->heaptids[i + 1]))
+				ItemPointerSetInvalid(&etup->heaptids[i]);
+			else
+				ItemPointerCopy(&etup->heaptids[i + 1], &etup->heaptids[i]);
+		}
+
+		/* Overwrite tuple */
+		if (!PageIndexTupleOverwrite(page, so->offno, (Item) etup, etupSize))
+			elog(ERROR, "failed to add index item to \"%s\"", RelationGetRelationName(index));
+
+		/* Commit */
+		MarkBufferDirty(buf);
+		GenericXLogFinish(state);
+	}
+
+	/* Unlock buffer */
+	LockBuffer(buf, BUFFER_LOCK_UNLOCK);
+}
+
 /*
  * Prepare for an index scan
  */
@@ -72,6 +140,9 @@ hnswbeginscan(Relation index, int nkeys, int norderbys)
 
 	so = (HnswScanOpaque) palloc(sizeof(HnswScanOpaqueData));
 	so->buf = InvalidBuffer;
+	ItemPointerSetInvalid(&so->heaptid);
+	so->offno = InvalidOffsetNumber;
+	so->removedCount = 0;
 	so->first = true;
 	so->tmpCtx = AllocSetContextCreate(CurrentMemoryContext,
 									   "Hnsw scan temporary context",
@@ -84,9 +155,6 @@ hnswbeginscan(Relation index, int nkeys, int norderbys)
 
 	scan->opaque = so;
 
-	/* OK to always set since cheap */
-	scan->xs_itupdesc = RelationGetDescr(index);
-
 	return scan;
 }
 
@@ -99,6 +167,7 @@ hnswrescan(IndexScanDesc scan, ScanKey keys, int nkeys, ScanKey orderbys, int no
 	HnswScanOpaque so = (HnswScanOpaque) scan->opaque;
 
 	so->first = true;
+	ItemPointerSetInvalid(&so->heaptid);
 	MemoryContextReset(so->tmpCtx);
 
 	if (keys && scan->numberOfKeys > 0)
@@ -162,14 +231,27 @@ hnswgettuple(IndexScanDesc scan, ScanDirection dir)
 
 		so->first = false;
 	}
+	else
+	{
+		/*
+		 * Remove dead tuples. kill_prior_tuple will only be true if not in
+		 * recovery. Limit the number removed per scan for performance.
+		 */
+		if (scan->kill_prior_tuple && so->removedCount < 3)
+		{
+			RemoveHeapTid(scan);
+			so->removedCount++;
+		}
+	}
 
 	while (list_length(so->w) > 0)
 	{
 		HnswCandidate *hc = llast(so->w);
 		ItemPointer tid;
 		BlockNumber indexblkno;
+		OffsetNumber indexoffno;
 
-		/* 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);
@@ -178,18 +260,10 @@ hnswgettuple(IndexScanDesc scan, ScanDirection dir)
 
 		tid = llast(hc->element->heaptids);
 		indexblkno = hc->element->blkno;
+		indexoffno = hc->element->offno;
 
 		hc->element->heaptids = list_delete_last(hc->element->heaptids);
 
-		if (scan->xs_want_itup)
-		{
-			Datum		value = PointerGetDatum(hc->element->vec);
-			bool		isnull = false;
-
-			scan->xs_itup = index_form_tuple(scan->xs_itupdesc, &value, &isnull);
-			scan->xs_itup->t_tid = *tid;
-		}
-
 		MemoryContextSwitchTo(oldCtx);
 
 #if PG_VERSION_NUM >= 120000
@@ -198,6 +272,10 @@ hnswgettuple(IndexScanDesc scan, ScanDirection dir)
 		scan->xs_ctup.t_self = *tid;
 #endif
 
+		/* Keep track of info needed to remove dead tuples */
+		so->heaptid = *tid;
+		so->offno = indexoffno;
+
 		/* Unpin buffer */
 		if (BufferIsValid(so->buf))
 			ReleaseBuffer(so->buf);

src/hnswutils.c

@@ -543,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, bool loadVec, HnswElement skipElement)
+HnswSearchLayer(Datum q, List *ep, int ef, int lc, Relation index, FmgrInfo *procinfo, Oid collation, bool inserting, HnswElement skipElement)
 {
 	ListCell   *lc2;
 
@@ -551,6 +551,8 @@ HnswSearchLayer(Datum q, List *ep, int ef, int lc, Relation index, FmgrInfo *pro
 	pairingheap *C = pairingheap_allocate(CompareNearestCandidates, NULL);
 	pairingheap *W = pairingheap_allocate(CompareFurthestCandidates, NULL);
 	int			wlen = 0;
+	uint64		dead = 0;
+	uint64		maxAdditional = skipElement == NULL ? ef : PG_UINT64_MAX;
 	HASHCTL		hash_ctl;
 	HTAB	   *v;
 
@@ -579,13 +581,14 @@ 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));
 
-		/*
-		 * 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++;
+		/* Do not count certain number of dead elements towards ef */
+		if (list_length(hc->element->heaptids) == 0)
+		{
+			if ((++dead) <= maxAdditional)
+				continue;
+		}
+
+		wlen++;
 	}
 
 	while (!pairingheap_is_empty(C))
@@ -619,7 +622,7 @@ HnswSearchLayer(Datum q, List *ep, int ef, int lc, Relation index, FmgrInfo *pro
 				if (index == NULL)
 					eDistance = GetCandidateDistance(e, q, procinfo, collation);
 				else
-					HnswLoadElement(e->element, &eDistance, &q, index, procinfo, collation, loadVec);
+					HnswLoadElement(e->element, &eDistance, &q, index, procinfo, collation, inserting);
 
 				Assert(!e->element->deleted);
 
@@ -638,19 +641,18 @@ 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));
 
-					/*
-					 * 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)
+					/* Do not count certain number of dead elements towards ef */
+					if (list_length(e->element->heaptids) == 0)
 					{
-						wlen++;
-
-						/* No need to decrement wlen */
-						if (wlen > ef)
-							pairingheap_remove_first(W);
+						if ((++dead) <= maxAdditional)
+							continue;
 					}
+
+					wlen++;
+
+					/* No need to decrement wlen */
+					if (wlen > ef)
+						pairingheap_remove_first(W);
 				}
 			}
 		}

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/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";
@@ -36,8 +38,9 @@ sub test_index_replay
 	);
 
 	# Run test queries and compare their result
-	my $primary_result = $node_primary->safe_psql("postgres", $queries);
+	# Query replica first since index scan on primary can generate WAL removing tuples
 	my $replica_result = $node_replica->safe_psql("postgres", $queries);
+	my $primary_result = $node_primary->safe_psql("postgres", $queries);
 
 	is($primary_result, $replica_result, "$test_name: query result matches");
 	return;

test/t/015_hnsw_duplicates.pl

@@ -23,25 +23,27 @@ sub insert_vectors
 
 sub test_duplicates
 {
+	my ($exp) = @_;
+
 	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);
+	is($res, $exp);
 }
 
 # Test duplicates with build
 insert_vectors();
 $node->safe_psql("postgres", "CREATE INDEX idx ON tst USING hnsw (v vector_l2_ops);");
-test_duplicates();
+test_duplicates(10);
 
 # Reset
 $node->safe_psql("postgres", "TRUNCATE tst;");
 
 # Test duplicates with inserts
 insert_vectors();
-test_duplicates();
+test_duplicates(10);
 
 # Test fallback path for inserts
 $node->pgbench(
@@ -55,4 +57,15 @@ $node->pgbench(
 	}
 );
 
+# Reset
+$node->safe_psql("postgres", "TRUNCATE tst;");
+
+# Test deletes with index scan
+$node->safe_psql("postgres", "INSERT INTO tst SELECT '[1,1,1]' FROM generate_series(1, 10) i;");
+$node->safe_psql("postgres", "DELETE FROM tst WHERE ctid IN (SELECT ctid FROM tst ORDER BY random() LIMIT 5);");
+for (1 .. 3)
+{
+	test_duplicates(5);
+}
+
 done_testing();