Use variable for sequential ratio [skip ci]

CHANGELOG.md

@@ -1,9 +1,7 @@
 ## 0.8.0 (unreleased)
 
-- Added support for inline filtering with IVFFlat
 - Added casts for arrays to `sparsevec`
 - Improved cost estimation
-- Improved performance of HNSW inserts and on-disk index builds
 - Reduced memory usage for HNSW index scans
 - Dropped support for Postgres 12
 

README.md

@@ -439,12 +439,6 @@ Create an index on one [or more](https://www.postgresql.org/docs/current/indexes
 CREATE INDEX ON items (category_id);
 ```
 
-Or a composite IVFFlat index for approximate search (added in 0.8.0)
-
-```sql
-CREATE INDEX ON items USING ivfflat (embedding vector_l2_ops, category_id) WITH (lists = 100);
-```
-
 Or a [partial index](https://www.postgresql.org/docs/current/indexes-partial.html) on the vector column for approximate search
 
 ```sql

sql/vector--0.7.4--0.8.0.sql

@@ -24,5 +24,3 @@ CREATE CAST (double precision[] AS sparsevec)
 
 CREATE CAST (numeric[] AS sparsevec)
 	WITH FUNCTION array_to_sparsevec(numeric[], integer, boolean) AS ASSIGNMENT;
-
--- TODO add ivfflat attributes

sql/vector.sql

@@ -916,13 +916,3 @@ CREATE OPERATOR CLASS sparsevec_l1_ops
 	OPERATOR 1 <+> (sparsevec, sparsevec) FOR ORDER BY float_ops,
 	FUNCTION 1 l1_distance(sparsevec, sparsevec),
 	FUNCTION 3 hnsw_sparsevec_support(internal);
-
--- ivfflat attributes
-
-CREATE OPERATOR CLASS vector_integer_ops
-	DEFAULT FOR TYPE integer USING ivfflat AS
-	OPERATOR 2 < ,
-	OPERATOR 3 <= ,
-	OPERATOR 4 = ,
-	OPERATOR 5 >= ,
-	OPERATOR 6 > ;

src/hnsw.h

@@ -88,9 +88,6 @@
 /* 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)
 
-#define HnswGetSearchCandidate(membername, ptr) pairingheap_container(HnswSearchCandidate, membername, ptr)
-#define HnswGetSearchCandidateConst(membername, ptr) pairingheap_const_container(HnswSearchCandidate, membername, ptr)
-
 #define HnswGetValue(base, element) PointerGetDatum(HnswPtrAccess(base, (element)->value))
 
 #if PG_VERSION_NUM < 140005
@@ -163,7 +160,7 @@ typedef struct HnswSearchCandidate
 	pairingheap_node c_node;
 	pairingheap_node w_node;
 	HnswElementPtr element;
-	double		distance;
+	float		distance;
 }			HnswSearchCandidate;
 
 /* HNSW index options */
@@ -188,8 +185,8 @@ typedef struct HnswGraph
 
 	/* Allocations state */
 	LWLock		allocatorLock;
-	Size		memoryUsed;
-	Size		memoryTotal;
+	long		memoryUsed;
+	long		memoryTotal;
 
 	/* Flushed state */
 	LWLock		flushLock;
@@ -240,18 +237,6 @@ typedef struct HnswTypeInfo
 	void		(*checkValue) (Pointer v);
 }			HnswTypeInfo;
 
-typedef struct HnswSupport
-{
-	FmgrInfo   *procinfo;
-	FmgrInfo   *normprocinfo;
-	Oid			collation;
-}			HnswSupport;
-
-typedef struct HnswQuery
-{
-	Datum		value;
-}			HnswQuery;
-
 typedef struct HnswBuildState
 {
 	/* Info */
@@ -271,7 +256,9 @@ typedef struct HnswBuildState
 	double		reltuples;
 
 	/* Support functions */
-	HnswSupport support;
+	FmgrInfo   *procinfo;
+	FmgrInfo   *normprocinfo;
+	Oid			collation;
 
 	/* Variables */
 	HnswGraph	graphData;
@@ -338,19 +325,6 @@ typedef struct HnswNeighborTupleData
 
 typedef HnswNeighborTupleData * HnswNeighborTuple;
 
-typedef union
-{
-	struct pointerhash_hash *pointers;
-	struct offsethash_hash *offsets;
-	struct tidhash_hash *tids;
-}			visited_hash;
-
-typedef union
-{
-	HnswElement element;
-	ItemPointerData indextid;
-}			HnswUnvisited;
-
 typedef struct HnswScanOpaqueData
 {
 	const		HnswTypeInfo *typeInfo;
@@ -359,7 +333,9 @@ typedef struct HnswScanOpaqueData
 	MemoryContext tmpCtx;
 
 	/* Support functions */
-	HnswSupport support;
+	FmgrInfo   *procinfo;
+	FmgrInfo   *normprocinfo;
+	Oid			collation;
 }			HnswScanOpaqueData;
 
 typedef HnswScanOpaqueData * HnswScanOpaque;
@@ -377,7 +353,8 @@ typedef struct HnswVacuumState
 	int			efConstruction;
 
 	/* Support functions */
-	HnswSupport support;
+	FmgrInfo   *procinfo;
+	Oid			collation;
 
 	/* Variables */
 	struct tidhash_hash *deleted;
@@ -393,33 +370,30 @@ typedef struct HnswVacuumState
 int			HnswGetM(Relation index);
 int			HnswGetEfConstruction(Relation index);
 FmgrInfo   *HnswOptionalProcInfo(Relation index, uint16 procnum);
-void		HnswInitSupport(HnswSupport * support, Relation index);
 Datum		HnswNormValue(const HnswTypeInfo * typeInfo, Oid collation, Datum value);
-bool		HnswCheckNorm(HnswSupport * support, Datum value);
+bool		HnswCheckNorm(FmgrInfo *procinfo, Oid collation, Datum value);
 Buffer		HnswNewBuffer(Relation index, ForkNumber forkNum);
 void		HnswInitPage(Buffer buf, Page page);
 void		HnswInit(void);
-List	   *HnswSearchLayer(char *base, HnswQuery * q, List *ep, int ef, int lc, Relation index, HnswSupport * support, int m, bool inserting, HnswElement skipElement);
+List	   *HnswSearchLayer(char *base, 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);
 void	   *HnswAlloc(HnswAllocator * allocator, Size size);
 HnswElement HnswInitElement(char *base, ItemPointer tid, int m, double ml, int maxLevel, HnswAllocator * alloc);
 HnswElement HnswInitElementFromBlock(BlockNumber blkno, OffsetNumber offno);
-void		HnswFindElementNeighbors(char *base, HnswElement element, HnswElement entryPoint, Relation index, HnswSupport * support, int m, int efConstruction, bool existing);
-HnswSearchCandidate *HnswEntryCandidate(char *base, HnswElement em, HnswQuery * q, Relation rel, HnswSupport * support, bool loadVec);
+void		HnswFindElementNeighbors(char *base, HnswElement element, HnswElement entryPoint, Relation index, FmgrInfo *procinfo, Oid collation, int m, int efConstruction, bool existing);
+HnswSearchCandidate *HnswEntryCandidate(char *base, HnswElement em, Datum q, Relation rel, FmgrInfo *procinfo, Oid collation, bool loadVec);
 void		HnswUpdateMetaPage(Relation index, int updateEntry, HnswElement entryPoint, BlockNumber insertPage, ForkNumber forkNum, bool building);
 void		HnswSetNeighborTuple(char *base, HnswNeighborTuple ntup, HnswElement e, int m);
 void		HnswAddHeapTid(HnswElement element, ItemPointer heaptid);
-HnswNeighborArray *HnswInitNeighborArray(int lm, HnswAllocator * allocator);
 void		HnswInitNeighbors(char *base, HnswElement element, int m, HnswAllocator * alloc);
-bool		HnswInsertTupleOnDisk(Relation index, HnswSupport * support, Datum value, ItemPointer heaptid, bool building);
-void		HnswUpdateNeighborsOnDisk(Relation index, HnswSupport * support, HnswElement e, int m, bool checkExisting, bool building);
+bool		HnswInsertTupleOnDisk(Relation index, Datum value, Datum *values, bool *isnull, ItemPointer heap_tid, bool building);
+void		HnswUpdateNeighborsOnDisk(Relation index, FmgrInfo *procinfo, Oid collation, HnswElement e, int m, bool checkExisting, bool building);
 void		HnswLoadElementFromTuple(HnswElement element, HnswElementTuple etup, bool loadHeaptids, bool loadVec);
-void		HnswLoadElement(HnswElement element, double *distance, HnswQuery * q, Relation index, HnswSupport * support, bool loadVec, double *maxDistance);
-bool		HnswFormIndexValue(Datum *out, Datum *values, bool *isnull, const HnswTypeInfo * typeInfo, HnswSupport * support);
+void		HnswLoadElement(HnswElement element, float *distance, Datum *q, Relation index, FmgrInfo *procinfo, Oid collation, bool loadVec, float *maxDistance);
 void		HnswSetElementTuple(char *base, HnswElementTuple etup, HnswElement element);
-void		HnswUpdateConnection(char *base, HnswNeighborArray * neighbors, HnswElement newElement, float distance, int lm, int *updateIdx, Relation index, HnswSupport * support);
-bool		HnswLoadNeighborTids(HnswElement element, ItemPointerData *indextids, Relation index, int m, int lm, int lc);
+void		HnswUpdateConnection(char *base, HnswElement element, HnswCandidate * hc, int lm, int lc, int *updateIdx, Relation index, FmgrInfo *procinfo, Oid collation);
+void		HnswLoadNeighbors(HnswElement element, Relation index, int m);
 void		HnswInitLockTranche(void);
 const		HnswTypeInfo *HnswGetTypeInfo(Relation index);
 PGDLLEXPORT void HnswParallelBuildMain(dsm_segment *seg, shm_toc *toc);

src/hnswbuild.c

@@ -366,7 +366,7 @@ AddElementInMemory(char *base, HnswGraph * graph, HnswElement element)
  * Update neighbors
  */
 static void
-UpdateNeighborsInMemory(char *base, HnswSupport * support, HnswElement e, int m)
+UpdateNeighborsInMemory(char *base, FmgrInfo *procinfo, Oid collation, HnswElement e, int m)
 {
 	for (int lc = e->level; lc >= 0; lc--)
 	{
@@ -388,7 +388,7 @@ UpdateNeighborsInMemory(char *base, HnswSupport * support, HnswElement e, int m)
 			Assert(neighborElement);
 
 			LWLockAcquire(&neighborElement->lock, LW_EXCLUSIVE);
-			HnswUpdateConnection(base, HnswGetNeighbors(base, neighborElement, lc), e, hc->distance, lm, NULL, NULL, support);
+			HnswUpdateConnection(base, e, hc, lm, lc, NULL, NULL, procinfo, collation);
 			LWLockRelease(&neighborElement->lock);
 		}
 	}
@@ -398,7 +398,7 @@ UpdateNeighborsInMemory(char *base, HnswSupport * support, HnswElement e, int m)
  * Update graph in memory
  */
 static void
-UpdateGraphInMemory(HnswSupport * support, HnswElement element, int m, int efConstruction, HnswElement entryPoint, HnswBuildState * buildstate)
+UpdateGraphInMemory(FmgrInfo *procinfo, Oid collation, HnswElement element, int m, int efConstruction, HnswElement entryPoint, HnswBuildState * buildstate)
 {
 	HnswGraph  *graph = buildstate->graph;
 	char	   *base = buildstate->hnswarea;
@@ -411,7 +411,7 @@ UpdateGraphInMemory(HnswSupport * support, HnswElement element, int m, int efCon
 	AddElementInMemory(base, graph, element);
 
 	/* Update neighbors */
-	UpdateNeighborsInMemory(base, support, element, m);
+	UpdateNeighborsInMemory(base, procinfo, collation, element, m);
 
 	/* Update entry point if needed (already have lock) */
 	if (entryPoint == NULL || element->level > entryPoint->level)
@@ -424,8 +424,9 @@ UpdateGraphInMemory(HnswSupport * support, HnswElement element, int m, int efCon
 static void
 InsertTupleInMemory(HnswBuildState * buildstate, HnswElement element)
 {
+	FmgrInfo   *procinfo = buildstate->procinfo;
+	Oid			collation = buildstate->collation;
 	HnswGraph  *graph = buildstate->graph;
-	HnswSupport *support = &buildstate->support;
 	HnswElement entryPoint;
 	LWLock	   *entryLock = &graph->entryLock;
 	LWLock	   *entryWaitLock = &graph->entryWaitLock;
@@ -457,10 +458,10 @@ InsertTupleInMemory(HnswBuildState * buildstate, HnswElement element)
 	}
 
 	/* Find neighbors for element */
-	HnswFindElementNeighbors(base, element, entryPoint, NULL, support, m, efConstruction, false);
+	HnswFindElementNeighbors(base, element, entryPoint, NULL, procinfo, collation, m, efConstruction, false);
 
 	/* Update graph in memory */
-	UpdateGraphInMemory(support, element, m, efConstruction, entryPoint, buildstate);
+	UpdateGraphInMemory(procinfo, collation, element, m, efConstruction, entryPoint, buildstate);
 
 	/* Release entry lock */
 	LWLockRelease(entryLock);
@@ -472,19 +473,30 @@ InsertTupleInMemory(HnswBuildState * buildstate, HnswElement element)
 static bool
 InsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heaptid, HnswBuildState * buildstate)
 {
+	const		HnswTypeInfo *typeInfo = buildstate->typeInfo;
 	HnswGraph  *graph = buildstate->graph;
 	HnswElement element;
 	HnswAllocator *allocator = &buildstate->allocator;
-	HnswSupport *support = &buildstate->support;
 	Size		valueSize;
 	Pointer		valuePtr;
 	LWLock	   *flushLock = &graph->flushLock;
 	char	   *base = buildstate->hnswarea;
-	Datum		value;
 
-	/* Form index value */
-	if (!HnswFormIndexValue(&value, values, isnull, buildstate->typeInfo, support))
-		return false;
+	/* Detoast once for all calls */
+	Datum		value = PointerGetDatum(PG_DETOAST_DATUM(values[0]));
+
+	/* Check value */
+	if (typeInfo->checkValue != NULL)
+		typeInfo->checkValue(DatumGetPointer(value));
+
+	/* Normalize if needed */
+	if (buildstate->normprocinfo != NULL)
+	{
+		if (!HnswCheckNorm(buildstate->normprocinfo, buildstate->collation, value))
+			return false;
+
+		value = HnswNormValue(typeInfo, buildstate->collation, value);
+	}
 
 	/* Get datum size */
 	valueSize = VARSIZE_ANY(DatumGetPointer(value));
@@ -497,7 +509,7 @@ InsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heaptid, Hn
 	{
 		LWLockRelease(flushLock);
 
-		return HnswInsertTupleOnDisk(index, support, value, heaptid, true);
+		return HnswInsertTupleOnDisk(index, value, values, isnull, heaptid, true);
 	}
 
 	/*
@@ -529,7 +541,7 @@ InsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heaptid, Hn
 
 		LWLockRelease(flushLock);
 
-		return HnswInsertTupleOnDisk(index, support, value, heaptid, true);
+		return HnswInsertTupleOnDisk(index, value, values, isnull, heaptid, true);
 	}
 
 	/* Ok, we can proceed to allocate the element */
@@ -595,7 +607,7 @@ BuildCallback(Relation index, ItemPointer tid, Datum *values,
  * Initialize the graph
  */
 static void
-InitGraph(HnswGraph * graph, char *base, Size memoryTotal)
+InitGraph(HnswGraph * graph, char *base, long memoryTotal)
 {
 	/* Initialize the lock tranche if needed */
 	HnswInitLockTranche();
@@ -692,9 +704,11 @@ InitBuildState(HnswBuildState * buildstate, Relation heap, Relation index, Index
 	buildstate->indtuples = 0;
 
 	/* Get support functions */
-	HnswInitSupport(&buildstate->support, index);
+	buildstate->procinfo = index_getprocinfo(index, 1, HNSW_DISTANCE_PROC);
+	buildstate->normprocinfo = HnswOptionalProcInfo(index, HNSW_NORM_PROC);
+	buildstate->collation = index->rd_indcollation[0];
 
-	InitGraph(&buildstate->graphData, NULL, (Size) maintenance_work_mem * 1024L);
+	InitGraph(&buildstate->graphData, NULL, maintenance_work_mem * 1024L);
 	buildstate->graph = &buildstate->graphData;
 	buildstate->ml = HnswGetMl(buildstate->m);
 	buildstate->maxLevel = HnswGetMaxLevel(buildstate->m);

src/hnswinsert.c

@@ -334,107 +334,6 @@ AddElementOnDisk(Relation index, HnswElement e, int m, BlockNumber insertPage, B
 		*updatedInsertPage = newInsertPage;
 }
 
-/*
- * Load neighbors
- */
-static HnswNeighborArray *
-HnswLoadNeighbors(HnswElement element, Relation index, int m, int lm, int lc)
-{
-	char	   *base = NULL;
-	HnswNeighborArray *neighbors = HnswInitNeighborArray(lm, NULL);
-	ItemPointerData indextids[HNSW_MAX_M * 2];
-
-	if (!HnswLoadNeighborTids(element, indextids, index, m, lm, lc))
-		return neighbors;
-
-	for (int i = 0; i < lm; i++)
-	{
-		ItemPointer indextid = &indextids[i];
-		HnswElement e;
-		HnswCandidate *hc;
-
-		if (!ItemPointerIsValid(indextid))
-			break;
-
-		e = HnswInitElementFromBlock(ItemPointerGetBlockNumber(indextid), ItemPointerGetOffsetNumber(indextid));
-		hc = &neighbors->items[neighbors->length++];
-		HnswPtrStore(base, hc->element, e);
-	}
-
-	return neighbors;
-}
-
-/*
- * Load elements for insert
- */
-static void
-LoadElementsForInsert(HnswNeighborArray * neighbors, HnswQuery * q, int *idx, Relation index, HnswSupport * support)
-{
-	char	   *base = NULL;
-
-	for (int i = 0; i < neighbors->length; i++)
-	{
-		HnswCandidate *hc = &neighbors->items[i];
-		HnswElement element = HnswPtrAccess(base, hc->element);
-		double		distance;
-
-		HnswLoadElement(element, &distance, q, index, support, true, NULL);
-		hc->distance = distance;
-
-		/* Prune element if being deleted */
-		if (element->heaptidsLength == 0)
-		{
-			*idx = i;
-			break;
-		}
-	}
-}
-
-/*
- * Get update index
- */
-static int
-GetUpdateIndex(HnswElement element, HnswElement newElement, float distance, int m, int lm, int lc, Relation index, HnswSupport * support, MemoryContext updateCtx)
-{
-	char	   *base = NULL;
-	int			idx = -1;
-	HnswNeighborArray *neighbors;
-	MemoryContext oldCtx = MemoryContextSwitchTo(updateCtx);
-
-	/*
-	 * Get latest neighbors since they may have changed. Do not lock yet since
-	 * selecting neighbors can take time. Could use optimistic locking to
-	 * retry if another update occurs before getting exclusive lock.
-	 */
-	neighbors = HnswLoadNeighbors(element, index, m, lm, lc);
-
-	/*
-	 * 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.
-	 */
-
-	if (neighbors->length < lm)
-		idx = -2;
-	else
-	{
-		HnswQuery	q;
-
-		q.value = HnswGetValue(base, element);
-
-		LoadElementsForInsert(neighbors, &q, &idx, index, support);
-
-		if (idx == -1)
-			HnswUpdateConnection(base, neighbors, newElement, distance, lm, &idx, index, support);
-	}
-
-	MemoryContextSwitchTo(oldCtx);
-	MemoryContextReset(updateCtx);
-
-	return idx;
-}
-
 /*
  * Check if connection already exists
  */
@@ -455,94 +354,14 @@ ConnectionExists(HnswElement e, HnswNeighborTuple ntup, int startIdx, int lm)
 	return false;
 }
 
-/*
- * Update neighbor
- */
-static void
-UpdateNeighborOnDisk(HnswElement element, HnswElement newElement, int idx, int m, int lm, int lc, Relation index, bool checkExisting, bool building)
-{
-	Buffer		buf;
-	Page		page;
-	GenericXLogState *state;
-	HnswNeighborTuple ntup;
-	int			startIdx;
-	OffsetNumber offno = element->neighborOffno;
-
-	/* Register page */
-	buf = ReadBuffer(index, element->neighborPage);
-	LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
-	if (building)
-	{
-		state = NULL;
-		page = BufferGetPage(buf);
-	}
-	else
-	{
-		state = GenericXLogStart(index);
-		page = GenericXLogRegisterBuffer(state, buf, 0);
-	}
-
-	/* Get tuple */
-	ntup = (HnswNeighborTuple) PageGetItem(page, PageGetItemId(page, offno));
-
-	/* Calculate index for update */
-	startIdx = (element->level - lc) * m;
-
-	/* Check for existing connection */
-	if (checkExisting && ConnectionExists(newElement, 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 on the buffer */
-		ItemPointerSet(indextid, newElement->blkno, newElement->offno);
-
-		/* Commit */
-		if (building)
-			MarkBufferDirty(buf);
-		else
-			GenericXLogFinish(state);
-	}
-	else if (!building)
-		GenericXLogAbort(state);
-
-	UnlockReleaseBuffer(buf);
-}
-
 /*
  * Update neighbors
  */
 void
-HnswUpdateNeighborsOnDisk(Relation index, HnswSupport * support, HnswElement e, int m, bool checkExisting, bool building)
+HnswUpdateNeighborsOnDisk(Relation index, FmgrInfo *procinfo, Oid collation, HnswElement e, int m, bool checkExisting, bool building)
 {
 	char	   *base = NULL;
 
-	/* Use separate memory context to improve performance for larger vectors */
-	MemoryContext updateCtx = GenerationContextCreate(CurrentMemoryContext,
-													  "Hnsw insert update context",
-#if PG_VERSION_NUM >= 150000
-													  128 * 1024, 128 * 1024,
-#endif
-													  128 * 1024);
-
 	for (int lc = e->level; lc >= 0; lc--)
 	{
 		int			lm = HnswGetLayerM(m, lc);
@@ -551,20 +370,96 @@ HnswUpdateNeighborsOnDisk(Relation index, HnswSupport * support, HnswElement e,
 		for (int i = 0; i < neighbors->length; i++)
 		{
 			HnswCandidate *hc = &neighbors->items[i];
+			Buffer		buf;
+			Page		page;
+			GenericXLogState *state;
+			HnswNeighborTuple ntup;
+			int			idx = -1;
+			int			startIdx;
 			HnswElement neighborElement = HnswPtrAccess(base, hc->element);
-			int			idx;
+			OffsetNumber offno = neighborElement->neighborOffno;
 
-			idx = GetUpdateIndex(neighborElement, e, hc->distance, m, lm, lc, index, support, updateCtx);
+			/*
+			 * Get latest neighbors since they may have changed. Do not lock
+			 * yet since selecting neighbors can take time. Could use
+			 * optimistic locking to retry if another update occurs before
+			 * getting exclusive lock.
+			 */
+			HnswLoadNeighbors(neighborElement, index, m);
+
+			/*
+			 * 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.
+			 */
+
+			/* Select neighbors */
+			HnswUpdateConnection(NULL, e, hc, lm, lc, &idx, index, procinfo, collation);
 
 			/* New element was not selected as a neighbor */
 			if (idx == -1)
 				continue;
 
-			UpdateNeighborOnDisk(neighborElement, e, idx, m, lm, lc, index, checkExisting, building);
+			/* Register page */
+			buf = ReadBuffer(index, neighborElement->neighborPage);
+			LockBuffer(buf, BUFFER_LOCK_EXCLUSIVE);
+			if (building)
+			{
+				state = NULL;
+				page = BufferGetPage(buf);
+			}
+			else
+			{
+				state = GenericXLogStart(index);
+				page = GenericXLogRegisterBuffer(state, buf, 0);
+			}
+
+			/* Get tuple */
+			ntup = (HnswNeighborTuple) PageGetItem(page, PageGetItemId(page, offno));
+
+			/* Calculate index for update */
+			startIdx = (neighborElement->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 on the buffer */
+				ItemPointerSet(indextid, e->blkno, e->offno);
+
+				/* Commit */
+				if (building)
+					MarkBufferDirty(buf);
+				else
+					GenericXLogFinish(state);
+			}
+			else if (!building)
+				GenericXLogAbort(state);
+
+			UnlockReleaseBuffer(buf);
 		}
 	}
-
-	MemoryContextDelete(updateCtx);
 }
 
 /*
@@ -654,7 +549,7 @@ FindDuplicateOnDisk(Relation index, HnswElement element, bool building)
  * Update graph on disk
  */
 static void
-UpdateGraphOnDisk(Relation index, HnswSupport * support, HnswElement element, int m, int efConstruction, HnswElement entryPoint, bool building)
+UpdateGraphOnDisk(Relation index, FmgrInfo *procinfo, Oid collation, HnswElement element, int m, int efConstruction, HnswElement entryPoint, bool building)
 {
 	BlockNumber newInsertPage = InvalidBlockNumber;
 
@@ -670,7 +565,7 @@ UpdateGraphOnDisk(Relation index, HnswSupport * support, HnswElement element, in
 		HnswUpdateMetaPage(index, 0, NULL, newInsertPage, MAIN_FORKNUM, building);
 
 	/* Update neighbors */
-	HnswUpdateNeighborsOnDisk(index, support, element, m, false, building);
+	HnswUpdateNeighborsOnDisk(index, procinfo, collation, element, m, false, building);
 
 	/* Update entry point if needed */
 	if (entryPoint == NULL || element->level > entryPoint->level)
@@ -681,12 +576,14 @@ UpdateGraphOnDisk(Relation index, HnswSupport * support, HnswElement element, in
  * Insert a tuple into the index
  */
 bool
-HnswInsertTupleOnDisk(Relation index, HnswSupport * support, Datum value, ItemPointer heaptid, bool building)
+HnswInsertTupleOnDisk(Relation index, Datum value, Datum *values, bool *isnull, ItemPointer heap_tid, bool building)
 {
 	HnswElement entryPoint;
 	HnswElement element;
 	int			m;
 	int			efConstruction = HnswGetEfConstruction(index);
+	FmgrInfo   *procinfo = index_getprocinfo(index, 1, HNSW_DISTANCE_PROC);
+	Oid			collation = index->rd_indcollation[0];
 	LOCKMODE	lockmode = ShareLock;
 	char	   *base = NULL;
 
@@ -701,7 +598,7 @@ HnswInsertTupleOnDisk(Relation index, HnswSupport * support, Datum value, ItemPo
 	HnswGetMetaPageInfo(index, &m, &entryPoint);
 
 	/* Create an element */
-	element = HnswInitElement(base, heaptid, m, HnswGetMl(m), HnswGetMaxLevel(m), NULL);
+	element = HnswInitElement(base, heap_tid, m, HnswGetMl(m), HnswGetMaxLevel(m), NULL);
 	HnswPtrStore(base, element->value, DatumGetPointer(value));
 
 	/* Prevent concurrent inserts when likely updating entry point */
@@ -719,10 +616,10 @@ HnswInsertTupleOnDisk(Relation index, HnswSupport * support, Datum value, ItemPo
 	}
 
 	/* Find neighbors for element */
-	HnswFindElementNeighbors(base, element, entryPoint, index, support, m, efConstruction, false);
+	HnswFindElementNeighbors(base, element, entryPoint, index, procinfo, collation, m, efConstruction, false);
 
 	/* Update graph on disk */
-	UpdateGraphOnDisk(index, support, element, m, efConstruction, entryPoint, building);
+	UpdateGraphOnDisk(index, procinfo, collation, element, m, efConstruction, entryPoint, building);
 
 	/* Release lock */
 	UnlockPage(index, HNSW_UPDATE_LOCK, lockmode);
@@ -734,19 +631,31 @@ HnswInsertTupleOnDisk(Relation index, HnswSupport * support, Datum value, ItemPo
  * Insert a tuple into the index
  */
 static void
-HnswInsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heaptid)
+HnswInsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heap_tid)
 {
 	Datum		value;
 	const		HnswTypeInfo *typeInfo = HnswGetTypeInfo(index);
-	HnswSupport support;
+	FmgrInfo   *normprocinfo;
+	Oid			collation = index->rd_indcollation[0];
 
-	HnswInitSupport(&support, index);
+	/* Detoast once for all calls */
+	value = PointerGetDatum(PG_DETOAST_DATUM(values[0]));
 
-	/* Form index value */
-	if (!HnswFormIndexValue(&value, values, isnull, typeInfo, &support))
-		return;
+	/* Check value */
+	if (typeInfo->checkValue != NULL)
+		typeInfo->checkValue(DatumGetPointer(value));
 
-	HnswInsertTupleOnDisk(index, &support, value, heaptid, false);
+	/* Normalize if needed */
+	normprocinfo = HnswOptionalProcInfo(index, HNSW_NORM_PROC);
+	if (normprocinfo != NULL)
+	{
+		if (!HnswCheckNorm(normprocinfo, collation, value))
+			return;
+
+		value = HnswNormValue(typeInfo, collation, value);
+	}
+
+	HnswInsertTupleOnDisk(index, value, values, isnull, heap_tid, false);
 }
 
 /*

src/hnswscan.c

@@ -11,19 +11,17 @@
  * Algorithm 5 from paper
  */
 static List *
-GetScanItems(IndexScanDesc scan, Datum value)
+GetScanItems(IndexScanDesc scan, Datum q)
 {
 	HnswScanOpaque so = (HnswScanOpaque) scan->opaque;
 	Relation	index = scan->indexRelation;
-	HnswSupport *support = &so->support;
+	FmgrInfo   *procinfo = so->procinfo;
+	Oid			collation = so->collation;
 	List	   *ep;
 	List	   *w;
 	int			m;
 	HnswElement entryPoint;
 	char	   *base = NULL;
-	HnswQuery	q;
-
-	q.value = value;
 
 	/* Get m and entry point */
 	HnswGetMetaPageInfo(index, &m, &entryPoint);
@@ -31,15 +29,15 @@ GetScanItems(IndexScanDesc scan, Datum value)
 	if (entryPoint == NULL)
 		return NIL;
 
-	ep = list_make1(HnswEntryCandidate(base, entryPoint, &q, index, support, false));
+	ep = list_make1(HnswEntryCandidate(base, entryPoint, q, index, procinfo, collation, false));
 
 	for (int lc = entryPoint->level; lc >= 1; lc--)
 	{
-		w = HnswSearchLayer(base, &q, ep, 1, lc, index, support, m, false, NULL);
+		w = HnswSearchLayer(base, q, ep, 1, lc, index, procinfo, collation, m, false, NULL);
 		ep = w;
 	}
 
-	return HnswSearchLayer(base, &q, ep, hnsw_ef_search, 0, index, support, m, false, NULL);
+	return HnswSearchLayer(base, q, ep, hnsw_ef_search, 0, index, procinfo, collation, m, false, NULL);
 }
 
 /*
@@ -62,8 +60,8 @@ GetScanValue(IndexScanDesc scan)
 		Assert(!VARATT_IS_EXTENDED(DatumGetPointer(value)));
 
 		/* Normalize if needed */
-		if (so->support.normprocinfo != NULL)
-			value = HnswNormValue(so->typeInfo, so->support.collation, value);
+		if (so->normprocinfo != NULL)
+			value = HnswNormValue(so->typeInfo, so->collation, value);
 	}
 
 	return value;
@@ -88,7 +86,9 @@ hnswbeginscan(Relation index, int nkeys, int norderbys)
 									   ALLOCSET_DEFAULT_SIZES);
 
 	/* Set support functions */
-	HnswInitSupport(&so->support, index);
+	so->procinfo = index_getprocinfo(index, 1, HNSW_DISTANCE_PROC);
+	so->normprocinfo = HnswOptionalProcInfo(index, HNSW_NORM_PROC);
+	so->collation = index->rd_indcollation[0];
 
 	scan->opaque = so;
 
@@ -168,8 +168,8 @@ hnswgettuple(IndexScanDesc scan, ScanDirection dir)
 	while (list_length(so->w) > 0)
 	{
 		char	   *base = NULL;
-		HnswSearchCandidate *sc = llast(so->w);
-		HnswElement element = HnswPtrAccess(base, sc->element);
+		HnswSearchCandidate *hc = llast(so->w);
+		HnswElement element = HnswPtrAccess(base, hc->element);
 		ItemPointer heaptid;
 
 		/* Move to next element if no valid heap TIDs */

src/hnswutils.c

@@ -100,6 +100,19 @@ hash_offset(Size offset)
 #define SH_DEFINE
 #include "lib/simplehash.h"
 
+typedef union
+{
+	pointerhash_hash *pointers;
+	offsethash_hash *offsets;
+	tidhash_hash *tids;
+}			visited_hash;
+
+typedef union
+{
+	HnswElement element;
+	ItemPointerData indextid;
+}			HnswUnvisited;
+
 /*
  * Get the max number of connections in an upper layer for each element in the index
  */
@@ -140,17 +153,6 @@ HnswOptionalProcInfo(Relation index, uint16 procnum)
 	return index_getprocinfo(index, 1, procnum);
 }
 
-/*
- * Init support functions
- */
-void
-HnswInitSupport(HnswSupport * support, Relation index)
-{
-	support->procinfo = index_getprocinfo(index, 1, HNSW_DISTANCE_PROC);
-	support->collation = index->rd_indcollation[0];
-	support->normprocinfo = HnswOptionalProcInfo(index, HNSW_NORM_PROC);
-}
-
 /*
  * Normalize value
  */
@@ -164,9 +166,9 @@ HnswNormValue(const HnswTypeInfo * typeInfo, Oid collation, Datum value)
  * Check if non-zero norm
  */
 bool
-HnswCheckNorm(HnswSupport * support, Datum value)
+HnswCheckNorm(FmgrInfo *procinfo, Oid collation, Datum value)
 {
-	return DatumGetFloat8(FunctionCall1Coll(support->normprocinfo, support->collation, value)) > 0;
+	return DatumGetFloat8(FunctionCall1Coll(procinfo, collation, value)) > 0;
 }
 
 /*
@@ -195,7 +197,7 @@ HnswInitPage(Buffer buf, Page page)
 /*
  * Allocate a neighbor array
  */
-HnswNeighborArray *
+static HnswNeighborArray *
 HnswInitNeighborArray(int lm, HnswAllocator * allocator)
 {
 	HnswNeighborArray *a = HnswAlloc(allocator, HNSW_NEIGHBOR_ARRAY_SIZE(lm));
@@ -392,33 +394,6 @@ HnswUpdateMetaPage(Relation index, int updateEntry, HnswElement entryPoint, Bloc
 	UnlockReleaseBuffer(buf);
 }
 
-/*
- * Form index value
- */
-bool
-HnswFormIndexValue(Datum *out, Datum *values, bool *isnull, const HnswTypeInfo * typeInfo, HnswSupport * support)
-{
-	/* Detoast once for all calls */
-	Datum		value = PointerGetDatum(PG_DETOAST_DATUM(values[0]));
-
-	/* Check value */
-	if (typeInfo->checkValue != NULL)
-		typeInfo->checkValue(DatumGetPointer(value));
-
-	/* Normalize if needed */
-	if (support->normprocinfo != NULL)
-	{
-		if (!HnswCheckNorm(support, value))
-			return false;
-
-		value = HnswNormValue(typeInfo, support->collation, value);
-	}
-
-	*out = value;
-
-	return true;
-}
-
 /*
  * Set element tuple, except for neighbor info
  */
@@ -474,6 +449,69 @@ HnswSetNeighborTuple(char *base, HnswNeighborTuple ntup, HnswElement e, int m)
 	ntup->count = idx;
 }
 
+/*
+ * Load neighbors from page
+ */
+static void
+LoadNeighborsFromPage(HnswElement element, Relation index, Page page, int m)
+{
+	char	   *base = NULL;
+
+	HnswNeighborTuple ntup = (HnswNeighborTuple) PageGetItem(page, PageGetItemId(page, element->neighborOffno));
+	int			neighborCount = (element->level + 2) * m;
+
+	Assert(HnswIsNeighborTuple(ntup));
+
+	HnswInitNeighbors(base, element, m, NULL);
+
+	/* Ensure expected neighbors */
+	if (ntup->count != neighborCount)
+		return;
+
+	for (int i = 0; i < neighborCount; i++)
+	{
+		HnswElement e;
+		int			level;
+		HnswCandidate *hc;
+		ItemPointer indextid;
+		HnswNeighborArray *neighbors;
+
+		indextid = &ntup->indextids[i];
+
+		if (!ItemPointerIsValid(indextid))
+			continue;
+
+		e = HnswInitElementFromBlock(ItemPointerGetBlockNumber(indextid), ItemPointerGetOffsetNumber(indextid));
+
+		/* Calculate level based on offset */
+		level = element->level - i / m;
+		if (level < 0)
+			level = 0;
+
+		neighbors = HnswGetNeighbors(base, element, level);
+		hc = &neighbors->items[neighbors->length++];
+		HnswPtrStore(base, hc->element, e);
+	}
+}
+
+/*
+ * Load neighbors
+ */
+void
+HnswLoadNeighbors(HnswElement element, Relation index, int m)
+{
+	Buffer		buf;
+	Page		page;
+
+	buf = ReadBuffer(index, element->neighborPage);
+	LockBuffer(buf, BUFFER_LOCK_SHARE);
+	page = BufferGetPage(buf);
+
+	LoadNeighborsFromPage(element, index, page, m);
+
+	UnlockReleaseBuffer(buf);
+}
+
 /*
  * Load an element from a tuple
  */
@@ -507,20 +545,11 @@ HnswLoadElementFromTuple(HnswElement element, HnswElementTuple etup, bool loadHe
 	}
 }
 
-/*
- * Calculate the distance between values
- */
-static inline double
-HnswGetDistance(Datum a, Datum b, HnswSupport * support)
-{
-	return DatumGetFloat8(FunctionCall2Coll(support->procinfo, support->collation, a, b));
-}
-
 /*
  * Load an element and optionally get its distance from q
  */
 static void
-HnswLoadElementImpl(BlockNumber blkno, OffsetNumber offno, double *distance, HnswQuery * q, Relation index, HnswSupport * support, bool loadVec, double *maxDistance, HnswElement * element)
+HnswLoadElementImpl(BlockNumber blkno, OffsetNumber offno, float *distance, Datum *q, Relation index, FmgrInfo *procinfo, Oid collation, bool loadVec, float *maxDistance, HnswElement * element)
 {
 	Buffer		buf;
 	Page		page;
@@ -538,10 +567,10 @@ HnswLoadElementImpl(BlockNumber blkno, OffsetNumber offno, double *distance, Hns
 	/* Calculate distance */
 	if (distance != NULL)
 	{
-		if (DatumGetPointer(q->value) == NULL)
+		if (DatumGetPointer(*q) == NULL)
 			*distance = 0;
 		else
-			*distance = HnswGetDistance(q->value, PointerGetDatum(&etup->data), support);
+			*distance = (float) DatumGetFloat8(FunctionCall2Coll(procinfo, collation, *q, PointerGetDatum(&etup->data)));
 	}
 
 	/* Load element */
@@ -560,39 +589,41 @@ HnswLoadElementImpl(BlockNumber blkno, OffsetNumber offno, double *distance, Hns
  * Load an element and optionally get its distance from q
  */
 void
-HnswLoadElement(HnswElement element, double *distance, HnswQuery * q, Relation index, HnswSupport * support, bool loadVec, double *maxDistance)
+HnswLoadElement(HnswElement element, float *distance, Datum *q, Relation index, FmgrInfo *procinfo, Oid collation, bool loadVec, float *maxDistance)
 {
-	HnswLoadElementImpl(element->blkno, element->offno, distance, q, index, support, loadVec, maxDistance, &element);
+	HnswLoadElementImpl(element->blkno, element->offno, distance, q, index, procinfo, collation, loadVec, maxDistance, &element);
 }
 
 /*
  * Get the distance for an element
  */
-static double
-GetElementDistance(char *base, HnswElement element, HnswQuery * q, HnswSupport * support)
+static float
+GetElementDistance(char *base, HnswElement element, Datum q, FmgrInfo *procinfo, Oid collation)
 {
 	Datum		value = HnswGetValue(base, element);
 
-	return HnswGetDistance(q->value, value, support);
+	return DatumGetFloat8(FunctionCall2Coll(procinfo, collation, q, value));
 }
 
 /*
  * Create a candidate for the entry point
  */
 HnswSearchCandidate *
-HnswEntryCandidate(char *base, HnswElement entryPoint, HnswQuery * q, Relation index, HnswSupport * support, bool loadVec)
+HnswEntryCandidate(char *base, HnswElement entryPoint, Datum q, Relation index, FmgrInfo *procinfo, Oid collation, bool loadVec)
 {
-	HnswSearchCandidate *sc = palloc(sizeof(HnswSearchCandidate));
-	bool		inMemory = index == NULL;
+	HnswSearchCandidate *hc = palloc(sizeof(HnswSearchCandidate));
 
-	HnswPtrStore(base, sc->element, entryPoint);
-	if (inMemory)
-		sc->distance = GetElementDistance(base, entryPoint, q, support);
+	HnswPtrStore(base, hc->element, entryPoint);
+	if (index == NULL)
+		hc->distance = GetElementDistance(base, entryPoint, q, procinfo, collation);
 	else
-		HnswLoadElement(entryPoint, &sc->distance, q, index, support, loadVec, NULL);
-	return sc;
+		HnswLoadElement(entryPoint, &hc->distance, &q, index, procinfo, collation, loadVec, NULL);
+	return hc;
 }
 
+#define HnswGetSearchCandidate(membername, ptr) pairingheap_container(HnswSearchCandidate, membername, ptr)
+#define HnswGetSearchCandidateConst(membername, ptr) pairingheap_const_container(HnswSearchCandidate, membername, ptr)
+
 /*
  * Compare candidate distances
  */
@@ -627,9 +658,9 @@ CompareFurthestCandidates(const pairingheap_node *a, const pairingheap_node *b,
  * Init visited
  */
 static inline void
-InitVisited(char *base, visited_hash * v, bool inMemory, int ef, int m)
+InitVisited(char *base, visited_hash * v, Relation index, int ef, int m)
 {
-	if (!inMemory)
+	if (index != NULL)
 		v->tids = tidhash_create(CurrentMemoryContext, ef * m * 2, NULL);
 	else if (base != NULL)
 		v->offsets = offsethash_create(CurrentMemoryContext, ef * m * 2, NULL);
@@ -641,9 +672,9 @@ InitVisited(char *base, visited_hash * v, bool inMemory, int ef, int m)
  * Add to visited
  */
 static inline void
-AddToVisited(char *base, visited_hash * v, HnswElementPtr elementPtr, bool inMemory, bool *found)
+AddToVisited(char *base, visited_hash * v, HnswElementPtr elementPtr, Relation index, bool *found)
 {
-	if (!inMemory)
+	if (index != NULL)
 	{
 		HnswElement element = HnswPtrAccess(base, elementPtr);
 		ItemPointerData indextid;
@@ -704,7 +735,7 @@ HnswLoadUnvisitedFromMemory(char *base, HnswElement element, HnswUnvisited * unv
 		HnswCandidate *hc = &localNeighborhood->items[i];
 		bool		found;
 
-		AddToVisited(base, v, hc->element, true, &found);
+		AddToVisited(base, v, hc->element, NULL, &found);
 
 		if (!found)
 			unvisited[(*unvisitedLength)++].element = HnswPtrAccess(base, hc->element);
@@ -712,15 +743,16 @@ HnswLoadUnvisitedFromMemory(char *base, HnswElement element, HnswUnvisited * unv
 }
 
 /*
- * Load neighbor index TIDs
+ * Load unvisited neighbors from disk
  */
-bool
-HnswLoadNeighborTids(HnswElement element, ItemPointerData *indextids, Relation index, int m, int lm, int lc)
+static void
+HnswLoadUnvisitedFromDisk(HnswElement element, HnswUnvisited * unvisited, int *unvisitedLength, visited_hash * v, Relation index, int m, int lm, int lc)
 {
 	Buffer		buf;
 	Page		page;
 	HnswNeighborTuple ntup;
 	int			start;
+	ItemPointerData indextids[HNSW_MAX_M * 2];
 
 	buf = ReadBuffer(index, element->neighborPage);
 	LockBuffer(buf, BUFFER_LOCK_SHARE);
@@ -732,30 +764,17 @@ HnswLoadNeighborTids(HnswElement element, ItemPointerData *indextids, Relation i
 	if (ntup->count != (element->level + 2) * m)
 	{
 		UnlockReleaseBuffer(buf);
-		return false;
+		return;
 	}
 
 	/* Copy to minimize lock time */
 	start = (element->level - lc) * m;
-	memcpy(indextids, ntup->indextids + start, lm * sizeof(ItemPointerData));
+	memcpy(&indextids, ntup->indextids + start, lm * sizeof(ItemPointerData));
 
 	UnlockReleaseBuffer(buf);
-	return true;
-}
-
-/*
- * Load unvisited neighbors from disk
- */
-static void
-HnswLoadUnvisitedFromDisk(HnswElement element, HnswUnvisited * unvisited, int *unvisitedLength, visited_hash * v, Relation index, int m, int lm, int lc)
-{
-	ItemPointerData indextids[HNSW_MAX_M * 2];
 
 	*unvisitedLength = 0;
 
-	if (!HnswLoadNeighborTids(element, indextids, index, m, lm, lc))
-		return;
-
 	for (int i = 0; i < lm; i++)
 	{
 		ItemPointer indextid = &indextids[i];
@@ -775,7 +794,7 @@ HnswLoadUnvisitedFromDisk(HnswElement element, HnswUnvisited * unvisited, int *u
  * Algorithm 2 from paper
  */
 List *
-HnswSearchLayer(char *base, HnswQuery * q, List *ep, int ef, int lc, Relation index, HnswSupport * support, int m, bool inserting, HnswElement skipElement)
+HnswSearchLayer(char *base, Datum q, List *ep, int ef, int lc, Relation index, FmgrInfo *procinfo, Oid collation, int m, bool inserting, HnswElement skipElement)
 {
 	List	   *w = NIL;
 	pairingheap *C = pairingheap_allocate(CompareNearestCandidates, NULL);
@@ -788,12 +807,11 @@ HnswSearchLayer(char *base, HnswQuery * q, List *ep, int ef, int lc, Relation in
 	int			lm = HnswGetLayerM(m, lc);
 	HnswUnvisited *unvisited = palloc(lm * sizeof(HnswUnvisited));
 	int			unvisitedLength;
-	bool		inMemory = index == NULL;
 
-	InitVisited(base, &v, inMemory, ef, m);
+	InitVisited(base, &v, index, ef, m);
 
 	/* Create local memory for neighborhood if needed */
-	if (inMemory)
+	if (index == NULL)
 	{
 		neighborhoodSize = HNSW_NEIGHBOR_ARRAY_SIZE(lm);
 		localNeighborhood = palloc(neighborhoodSize);
@@ -802,20 +820,20 @@ HnswSearchLayer(char *base, HnswQuery * q, List *ep, int ef, int lc, Relation in
 	/* Add entry points to v, C, and W */
 	foreach(lc2, ep)
 	{
-		HnswSearchCandidate *sc = (HnswSearchCandidate *) lfirst(lc2);
+		HnswSearchCandidate *hc = (HnswSearchCandidate *) lfirst(lc2);
 		bool		found;
 
-		AddToVisited(base, &v, sc->element, inMemory, &found);
+		AddToVisited(base, &v, hc->element, index, &found);
 
-		pairingheap_add(C, &sc->c_node);
-		pairingheap_add(W, &sc->w_node);
+		pairingheap_add(C, &hc->c_node);
+		pairingheap_add(W, &hc->w_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 (CountElement(skipElement, HnswPtrAccess(base, sc->element)))
+		if (CountElement(skipElement, HnswPtrAccess(base, hc->element)))
 			wlen++;
 	}
 
@@ -830,7 +848,7 @@ HnswSearchLayer(char *base, HnswQuery * q, List *ep, int ef, int lc, Relation in
 
 		cElement = HnswPtrAccess(base, c->element);
 
-		if (inMemory)
+		if (index == NULL)
 			HnswLoadUnvisitedFromMemory(base, cElement, unvisited, &unvisitedLength, &v, lc, localNeighborhood, neighborhoodSize);
 		else
 			HnswLoadUnvisitedFromDisk(cElement, unvisited, &unvisitedLength, &v, index, m, lm, lc);
@@ -839,15 +857,15 @@ HnswSearchLayer(char *base, HnswQuery * q, List *ep, int ef, int lc, Relation in
 		{
 			HnswElement eElement;
 			HnswSearchCandidate *e;
-			double		eDistance;
+			float		eDistance;
 			bool		alwaysAdd = wlen < ef;
 
 			f = HnswGetSearchCandidate(w_node, pairingheap_first(W));
 
-			if (inMemory)
+			if (index == NULL)
 			{
 				eElement = unvisited[i].element;
-				eDistance = GetElementDistance(base, eElement, q, support);
+				eDistance = GetElementDistance(base, eElement, q, procinfo, collation);
 			}
 			else
 			{
@@ -857,7 +875,7 @@ HnswSearchLayer(char *base, HnswQuery * q, List *ep, int ef, int lc, Relation in
 
 				/* Avoid any allocations if not adding */
 				eElement = NULL;
-				HnswLoadElementImpl(blkno, offno, &eDistance, q, index, support, inserting, alwaysAdd ? NULL : &f->distance, &eElement);
+				HnswLoadElementImpl(blkno, offno, &eDistance, &q, index, procinfo, collation, inserting, alwaysAdd ? NULL : &f->distance, &eElement);
 
 				if (eElement == NULL)
 					continue;
@@ -898,9 +916,9 @@ HnswSearchLayer(char *base, HnswQuery * q, List *ep, int ef, int lc, Relation in
 	/* Add each element of W to w */
 	while (!pairingheap_is_empty(W))
 	{
-		HnswSearchCandidate *sc = HnswGetSearchCandidate(w_node, pairingheap_remove_first(W));
+		HnswSearchCandidate *hc = HnswGetSearchCandidate(w_node, pairingheap_remove_first(W));
 
-		w = lappend(w, sc);
+		w = lappend(w, hc);
 	}
 
 	return w;
@@ -954,22 +972,32 @@ CompareCandidateDistancesOffset(const ListCell *a, const ListCell *b)
 	return 0;
 }
 
+/*
+ * Calculate the distance between elements
+ */
+static float
+HnswGetDistance(char *base, HnswElement a, HnswElement b, FmgrInfo *procinfo, Oid collation)
+{
+	Datum		aValue = HnswGetValue(base, a);
+	Datum		bValue = HnswGetValue(base, b);
+
+	return DatumGetFloat8(FunctionCall2Coll(procinfo, collation, aValue, bValue));
+}
+
 /*
  * Check if an element is closer to q than any element from R
  */
 static bool
-CheckElementCloser(char *base, HnswCandidate * e, List *r, HnswSupport * support)
+CheckElementCloser(char *base, HnswCandidate * e, List *r, FmgrInfo *procinfo, Oid collation)
 {
 	HnswElement eElement = HnswPtrAccess(base, e->element);
-	Datum		eValue = HnswGetValue(base, eElement);
 	ListCell   *lc2;
 
 	foreach(lc2, r)
 	{
 		HnswCandidate *ri = lfirst(lc2);
 		HnswElement riElement = HnswPtrAccess(base, ri->element);
-		Datum		riValue = HnswGetValue(base, riElement);
-		float		distance = HnswGetDistance(eValue, riValue, support);
+		float		distance = HnswGetDistance(base, eElement, riElement, procinfo, collation);
 
 		if (distance <= e->distance)
 			return false;
@@ -982,14 +1010,15 @@ CheckElementCloser(char *base, HnswCandidate * e, List *r, HnswSupport * support
  * Algorithm 4 from paper
  */
 static List *
-SelectNeighbors(char *base, List *c, int lm, HnswSupport * support, bool *closerSet, HnswCandidate * newCandidate, HnswCandidate * *pruned, bool sortCandidates)
+SelectNeighbors(char *base, List *c, int lm, int lc, FmgrInfo *procinfo, Oid collation, HnswElement e2, HnswCandidate * newCandidate, HnswCandidate * *pruned, bool sortCandidates)
 {
 	List	   *r = NIL;
 	List	   *w = list_copy(c);
 	HnswCandidate **wd;
 	int			wdlen = 0;
 	int			wdoff = 0;
-	bool		mustCalculate = !(*closerSet);
+	HnswNeighborArray *neighbors = HnswGetNeighbors(base, e2, lc);
+	bool		mustCalculate = !neighbors->closerSet;
 	List	   *added = NIL;
 	bool		removedAny = false;
 
@@ -1016,7 +1045,7 @@ SelectNeighbors(char *base, List *c, int lm, HnswSupport * support, bool *closer
 
 		/* Use previous state of r and wd to skip work when possible */
 		if (mustCalculate)
-			e->closer = CheckElementCloser(base, e, r, support);
+			e->closer = CheckElementCloser(base, e, r, procinfo, collation);
 		else if (list_length(added) > 0)
 		{
 			/* Keep Valgrind happy for in-memory, parallel builds */
@@ -1029,7 +1058,7 @@ SelectNeighbors(char *base, List *c, int lm, HnswSupport * support, bool *closer
 			 */
 			if (e->closer)
 			{
-				e->closer = CheckElementCloser(base, e, added, support);
+				e->closer = CheckElementCloser(base, e, added, procinfo, collation);
 
 				if (!e->closer)
 					removedAny = true;
@@ -1042,7 +1071,7 @@ SelectNeighbors(char *base, List *c, int lm, HnswSupport * support, bool *closer
 				 */
 				if (removedAny)
 				{
-					e->closer = CheckElementCloser(base, e, r, support);
+					e->closer = CheckElementCloser(base, e, r, procinfo, collation);
 					if (e->closer)
 						added = lappend(added, e);
 				}
@@ -1050,7 +1079,7 @@ SelectNeighbors(char *base, List *c, int lm, HnswSupport * support, bool *closer
 		}
 		else if (e == newCandidate)
 		{
-			e->closer = CheckElementCloser(base, e, r, support);
+			e->closer = CheckElementCloser(base, e, r, procinfo, collation);
 			if (e->closer)
 				added = lappend(added, e);
 		}
@@ -1066,7 +1095,7 @@ SelectNeighbors(char *base, List *c, int lm, HnswSupport * support, bool *closer
 	}
 
 	/* Cached value can only be used in future if sorted deterministically */
-	*closerSet = sortCandidates;
+	neighbors->closerSet = sortCandidates;
 
 	/* Keep pruned connections */
 	while (wdoff < wdlen && list_length(r) < lm)
@@ -1101,16 +1130,18 @@ AddConnections(char *base, HnswElement element, List *neighbors, int lc)
  * Update connections
  */
 void
-HnswUpdateConnection(char *base, HnswNeighborArray * neighbors, HnswElement newElement, float distance, int lm, int *updateIdx, Relation index, HnswSupport * support)
+HnswUpdateConnection(char *base, HnswElement element, HnswCandidate * hc, int lm, int lc, int *updateIdx, Relation index, FmgrInfo *procinfo, Oid collation)
 {
-	HnswCandidate newHc;
+	HnswElement hce = HnswPtrAccess(base, hc->element);
+	HnswNeighborArray *currentNeighbors = HnswGetNeighbors(base, hce, lc);
+	HnswCandidate hc2;
 
-	HnswPtrStore(base, newHc.element, newElement);
-	newHc.distance = distance;
+	HnswPtrStore(base, hc2.element, element);
+	hc2.distance = hc->distance;
 
-	if (neighbors->length < lm)
+	if (currentNeighbors->length < lm)
 	{
-		neighbors->items[neighbors->length++] = newHc;
+		currentNeighbors->items[currentNeighbors->length++] = hc2;
 
 		/* Track update */
 		if (updateIdx != NULL)
@@ -1119,26 +1150,54 @@ HnswUpdateConnection(char *base, HnswNeighborArray * neighbors, HnswElement newE
 	else
 	{
 		/* Shrink connections */
-		List	   *c = NIL;
 		HnswCandidate *pruned = NULL;
 
-		/* Add candidates */
-		for (int i = 0; i < neighbors->length; i++)
-			c = lappend(c, &neighbors->items[i]);
-		c = lappend(c, &newHc);
+		/* Load elements on insert */
+		if (index != NULL)
+		{
+			Datum		q = HnswGetValue(base, hce);
 
-		SelectNeighbors(base, c, lm, support, &neighbors->closerSet, &newHc, &pruned, true);
+			for (int i = 0; i < currentNeighbors->length; i++)
+			{
+				HnswCandidate *hc3 = &currentNeighbors->items[i];
+				HnswElement hc3Element = HnswPtrAccess(base, hc3->element);
+
+				if (HnswPtrIsNull(base, hc3Element->value))
+					HnswLoadElement(hc3Element, &hc3->distance, &q, index, procinfo, collation, true, NULL);
+				else
+					hc3->distance = GetElementDistance(base, hc3Element, q, procinfo, collation);
+
+				/* Prune element if being deleted */
+				if (hc3Element->heaptidsLength == 0)
+				{
+					pruned = &currentNeighbors->items[i];
+					break;
+				}
+			}
+		}
 
-		/* Should not happen */
 		if (pruned == NULL)
-			return;
+		{
+			List	   *c = NIL;
+
+			/* Add candidates */
+			for (int i = 0; i < currentNeighbors->length; i++)
+				c = lappend(c, &currentNeighbors->items[i]);
+			c = lappend(c, &hc2);
+
+			SelectNeighbors(base, c, lm, lc, procinfo, collation, hce, &hc2, &pruned, true);
+
+			/* Should not happen */
+			if (pruned == NULL)
+				return;
+		}
 
 		/* Find and replace the pruned element */
-		for (int i = 0; i < neighbors->length; i++)
+		for (int i = 0; i < currentNeighbors->length; i++)
 		{
-			if (HnswPtrEqual(base, neighbors->items[i].element, pruned->element))
+			if (HnswPtrEqual(base, currentNeighbors->items[i].element, pruned->element))
 			{
-				neighbors->items[i] = newHc;
+				currentNeighbors->items[i] = hc2;
 
 				/* Track update */
 				if (updateIdx != NULL)
@@ -1198,20 +1257,17 @@ PrecomputeHash(char *base, HnswElement element)
  * Algorithm 1 from paper
  */
 void
-HnswFindElementNeighbors(char *base, HnswElement element, HnswElement entryPoint, Relation index, HnswSupport * support, int m, int efConstruction, bool existing)
+HnswFindElementNeighbors(char *base, HnswElement element, HnswElement entryPoint, Relation index, FmgrInfo *procinfo, Oid collation, int m, int efConstruction, bool existing)
 {
 	List	   *ep;
 	List	   *w;
 	int			level = element->level;
 	int			entryLevel;
-	HnswQuery	q;
+	Datum		q = HnswGetValue(base, element);
 	HnswElement skipElement = existing ? element : NULL;
-	bool		inMemory = index == NULL;
-
-	q.value = HnswGetValue(base, element);
 
 	/* Precompute hash */
-	if (inMemory)
+	if (index == NULL)
 		PrecomputeHash(base, element);
 
 	/* No neighbors if no entry point */
@@ -1219,13 +1275,13 @@ HnswFindElementNeighbors(char *base, HnswElement element, HnswElement entryPoint
 		return;
 
 	/* Get entry point and level */
-	ep = list_make1(HnswEntryCandidate(base, entryPoint, &q, index, support, true));
+	ep = list_make1(HnswEntryCandidate(base, entryPoint, q, index, procinfo, collation, true));
 	entryLevel = entryPoint->level;
 
 	/* 1st phase: greedy search to insert level */
 	for (int lc = entryLevel; lc >= level + 1; lc--)
 	{
-		w = HnswSearchLayer(base, &q, ep, 1, lc, index, support, m, true, skipElement);
+		w = HnswSearchLayer(base, q, ep, 1, lc, index, procinfo, collation, m, true, skipElement);
 		ep = w;
 	}
 
@@ -1244,7 +1300,7 @@ HnswFindElementNeighbors(char *base, HnswElement element, HnswElement entryPoint
 		List	   *lw = NIL;
 		ListCell   *lc2;
 
-		w = HnswSearchLayer(base, &q, ep, efConstruction, lc, index, support, m, true, skipElement);
+		w = HnswSearchLayer(base, q, ep, efConstruction, lc, index, procinfo, collation, m, true, skipElement);
 
 		/* Convert search candidates to candidates */
 		foreach(lc2, w)
@@ -1260,7 +1316,7 @@ HnswFindElementNeighbors(char *base, HnswElement element, HnswElement entryPoint
 
 		/* Elements being deleted or skipped can help with search */
 		/* but should be removed before selecting neighbors */
-		if (!inMemory)
+		if (index != NULL)
 			lw = RemoveElements(base, lw, skipElement);
 
 		/*
@@ -1268,7 +1324,7 @@ HnswFindElementNeighbors(char *base, HnswElement element, HnswElement entryPoint
 		 * sortCandidates to true for in-memory builds to enable closer
 		 * caching, but there does not seem to be a difference in performance.
 		 */
-		neighbors = SelectNeighbors(base, lw, lm, support, &HnswGetNeighbors(base, element, lc)->closerSet, NULL, NULL, false);
+		neighbors = SelectNeighbors(base, lw, lm, lc, procinfo, collation, element, NULL, NULL, false);
 
 		AddConnections(base, element, neighbors, lc);
 

src/hnswvacuum.c

@@ -184,12 +184,13 @@ static void
 RepairGraphElement(HnswVacuumState * vacuumstate, HnswElement element, HnswElement entryPoint)
 {
 	Relation	index = vacuumstate->index;
-	HnswSupport *support = &vacuumstate->support;
 	Buffer		buf;
 	Page		page;
 	GenericXLogState *state;
 	int			m = vacuumstate->m;
 	int			efConstruction = vacuumstate->efConstruction;
+	FmgrInfo   *procinfo = vacuumstate->procinfo;
+	Oid			collation = vacuumstate->collation;
 	BufferAccessStrategy bas = vacuumstate->bas;
 	HnswNeighborTuple ntup = vacuumstate->ntup;
 	Size		ntupSize = HNSW_NEIGHBOR_TUPLE_SIZE(element->level, m);
@@ -204,7 +205,7 @@ RepairGraphElement(HnswVacuumState * vacuumstate, HnswElement element, HnswEleme
 	element->heaptidsLength = 0;
 
 	/* Find neighbors for element, skipping itself */
-	HnswFindElementNeighbors(base, element, entryPoint, index, support, m, efConstruction, true);
+	HnswFindElementNeighbors(base, element, entryPoint, index, procinfo, collation, m, efConstruction, true);
 
 	/* Zero memory for each element */
 	MemSet(ntup, 0, HNSW_TUPLE_ALLOC_SIZE);
@@ -228,7 +229,7 @@ RepairGraphElement(HnswVacuumState * vacuumstate, HnswElement element, HnswEleme
 	UnlockReleaseBuffer(buf);
 
 	/* Update neighbors */
-	HnswUpdateNeighborsOnDisk(index, support, element, m, true, false);
+	HnswUpdateNeighborsOnDisk(index, procinfo, collation, element, m, true, false);
 }
 
 /*
@@ -238,7 +239,6 @@ static void
 RepairGraphEntryPoint(HnswVacuumState * vacuumstate)
 {
 	Relation	index = vacuumstate->index;
-	HnswSupport *support = &vacuumstate->support;
 	HnswElement highestPoint = &vacuumstate->highestPoint;
 	HnswElement entryPoint;
 	MemoryContext oldCtx = MemoryContextSwitchTo(vacuumstate->tmpCtx);
@@ -256,7 +256,7 @@ RepairGraphEntryPoint(HnswVacuumState * vacuumstate)
 		LockPage(index, HNSW_UPDATE_LOCK, ShareLock);
 
 		/* Load element */
-		HnswLoadElement(highestPoint, NULL, NULL, index, support, true, NULL);
+		HnswLoadElement(highestPoint, NULL, NULL, index, vacuumstate->procinfo, vacuumstate->collation, true, NULL);
 
 		/* Repair if needed */
 		if (NeedsUpdated(vacuumstate, highestPoint))
@@ -294,7 +294,7 @@ RepairGraphEntryPoint(HnswVacuumState * vacuumstate)
 			 * is outdated, this can remove connections at higher levels in
 			 * the graph until they are repaired, but this should be fine.
 			 */
-			HnswLoadElement(entryPoint, NULL, NULL, index, support, true, NULL);
+			HnswLoadElement(entryPoint, NULL, NULL, index, vacuumstate->procinfo, vacuumstate->collation, true, NULL);
 
 			if (NeedsUpdated(vacuumstate, entryPoint))
 			{
@@ -573,13 +573,13 @@ InitVacuumState(HnswVacuumState * vacuumstate, IndexVacuumInfo *info, IndexBulkD
 	vacuumstate->callback_state = callback_state;
 	vacuumstate->efConstruction = HnswGetEfConstruction(index);
 	vacuumstate->bas = GetAccessStrategy(BAS_BULKREAD);
+	vacuumstate->procinfo = index_getprocinfo(index, 1, HNSW_DISTANCE_PROC);
+	vacuumstate->collation = index->rd_indcollation[0];
 	vacuumstate->ntup = palloc0(HNSW_TUPLE_ALLOC_SIZE);
 	vacuumstate->tmpCtx = AllocSetContextCreate(CurrentMemoryContext,
 												"Hnsw vacuum temporary context",
 												ALLOCSET_DEFAULT_SIZES);
 
-	HnswInitSupport(&vacuumstate->support, index);
-
 	/* Get m from metapage */
 	HnswGetMetaPageInfo(index, &vacuumstate->m, NULL);
 

src/ivfbuild.c

@@ -138,7 +138,7 @@ SampleRows(IvfflatBuildState * buildstate)
  * Add tuple to sort
  */
 static void
-AddTupleToSort(Relation index, ItemPointer tid, Datum *values, bool *isnull, IvfflatBuildState * buildstate)
+AddTupleToSort(Relation index, ItemPointer tid, Datum *values, IvfflatBuildState * buildstate)
 {
 	double		distance;
 	double		minDistance = DBL_MAX;
@@ -184,11 +184,6 @@ AddTupleToSort(Relation index, ItemPointer tid, Datum *values, bool *isnull, Ivf
 	slot->tts_isnull[1] = false;
 	slot->tts_values[2] = value;
 	slot->tts_isnull[2] = false;
-	for (int i = 1; i < buildstate->tupdesc->natts; i++)
-	{
-		slot->tts_values[2 + i] = values[i];
-		slot->tts_isnull[2 + i] = isnull[i];
-	}
 	ExecStoreVirtualTuple(slot);
 
 	/*
@@ -220,7 +215,7 @@ BuildCallback(Relation index, ItemPointer tid, Datum *values,
 	oldCtx = MemoryContextSwitchTo(buildstate->tmpCtx);
 
 	/* Add tuple to sort */
-	AddTupleToSort(index, tid, values, isnull, buildstate);
+	AddTupleToSort(index, tid, values, buildstate);
 
 	/* Reset memory context */
 	MemoryContextSwitchTo(oldCtx);
@@ -231,20 +226,19 @@ BuildCallback(Relation index, ItemPointer tid, Datum *values,
  * Get index tuple from sort state
  */
 static inline void
-GetNextTuple(Tuplesortstate *sortstate, TupleDesc tupdesc, TupleTableSlot *slot, Datum *values, bool *isnull, IndexTuple *itup, int *list)
+GetNextTuple(Tuplesortstate *sortstate, TupleDesc tupdesc, TupleTableSlot *slot, IndexTuple *itup, int *list)
 {
+	Datum		value;
+	bool		isnull;
+
 	if (tuplesort_gettupleslot(sortstate, true, false, slot, NULL))
 	{
-		bool		unused;
-
-		*list = DatumGetInt32(slot_getattr(slot, 1, &unused));
-
-		for (int i = 0; i < tupdesc->natts; i++)
-			values[i] = slot_getattr(slot, 3 + i, &isnull[i]);
+		*list = DatumGetInt32(slot_getattr(slot, 1, &isnull));
+		value = slot_getattr(slot, 3, &isnull);
 
 		/* Form the index tuple */
-		*itup = index_form_tuple(tupdesc, values, isnull);
-		(*itup)->t_tid = *((ItemPointer) DatumGetPointer(slot_getattr(slot, 2, &unused)));
+		*itup = index_form_tuple(tupdesc, &value, &isnull);
+		(*itup)->t_tid = *((ItemPointer) DatumGetPointer(slot_getattr(slot, 2, &isnull)));
 	}
 	else
 		*list = -1;
@@ -260,16 +254,14 @@ InsertTuples(Relation index, IvfflatBuildState * buildstate, ForkNumber forkNum)
 	IndexTuple	itup = NULL;	/* silence compiler warning */
 	int64		inserted = 0;
 
-	TupleTableSlot *slot = MakeSingleTupleTableSlot(buildstate->sortdesc, &TTSOpsMinimalTuple);
-	TupleDesc	tupdesc = buildstate->tupdesc;
-	Datum	   *values = palloc(tupdesc->natts * sizeof(Datum));
-	bool	   *isnull = palloc(tupdesc->natts * sizeof(bool));
+	TupleTableSlot *slot = MakeSingleTupleTableSlot(buildstate->tupdesc, &TTSOpsMinimalTuple);
+	TupleDesc	tupdesc = RelationGetDescr(index);
 
 	pgstat_progress_update_param(PROGRESS_CREATEIDX_SUBPHASE, PROGRESS_IVFFLAT_PHASE_LOAD);
 
 	pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_TOTAL, buildstate->indtuples);
 
-	GetNextTuple(buildstate->sortstate, tupdesc, slot, values, isnull, &itup, &list);
+	GetNextTuple(buildstate->sortstate, tupdesc, slot, &itup, &list);
 
 	for (int i = 0; i < buildstate->centers->length; i++)
 	{
@@ -305,7 +297,7 @@ InsertTuples(Relation index, IvfflatBuildState * buildstate, ForkNumber forkNum)
 
 			pgstat_progress_update_param(PROGRESS_CREATEIDX_TUPLES_DONE, ++inserted);
 
-			GetNextTuple(buildstate->sortstate, tupdesc, slot, values, isnull, &itup, &list);
+			GetNextTuple(buildstate->sortstate, tupdesc, slot, &itup, &list);
 		}
 
 		insertPage = BufferGetBlockNumber(buf);
@@ -315,9 +307,6 @@ InsertTuples(Relation index, IvfflatBuildState * buildstate, ForkNumber forkNum)
 		/* Set the start and insert pages */
 		IvfflatUpdateList(index, buildstate->listInfo[i], insertPage, InvalidBlockNumber, startPage, forkNum);
 	}
-
-	pfree(values);
-	pfree(isnull);
 }
 
 /*
@@ -330,7 +319,6 @@ InitBuildState(IvfflatBuildState * buildstate, Relation heap, Relation index, In
 	buildstate->index = index;
 	buildstate->indexInfo = indexInfo;
 	buildstate->typeInfo = IvfflatGetTypeInfo(index);
-	buildstate->tupdesc = RelationGetDescr(index);
 
 	buildstate->lists = IvfflatGetLists(index);
 	buildstate->dimensions = TupleDescAttr(index->rd_att, 0)->atttypmod;
@@ -341,19 +329,6 @@ InitBuildState(IvfflatBuildState * buildstate, Relation heap, Relation index, In
 				(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
 				 errmsg("type not supported for ivfflat index")));
 
-	/* TODO See if needed */
-	if (IndexRelationGetNumberOfKeyAttributes(index) > 3)
-		elog(ERROR, "index cannot have more than three columns");
-
-	if (!OidIsValid(index_getprocid(index, 1, IVFFLAT_DISTANCE_PROC)))
-		elog(ERROR, "first column must be a vector");
-
-	for (int i = 1; i < IndexRelationGetNumberOfKeyAttributes(index); i++)
-	{
-		if (OidIsValid(index_getprocid(index, i + 1, IVFFLAT_DISTANCE_PROC)))
-			elog(ERROR, "column %d cannot be a vector", i + 1);
-	}
-
 	/* Require column to have dimensions to be indexed */
 	if (buildstate->dimensions < 0)
 		ereport(ERROR,
@@ -381,13 +356,12 @@ InitBuildState(IvfflatBuildState * buildstate, Relation heap, Relation index, In
 				 errmsg("dimensions must be greater than one for this opclass")));
 
 	/* Create tuple description for sorting */
-	buildstate->sortdesc = CreateTemplateTupleDesc(2 + buildstate->tupdesc->natts);
-	TupleDescInitEntry(buildstate->sortdesc, (AttrNumber) 1, "list", INT4OID, -1, 0);
-	TupleDescInitEntry(buildstate->sortdesc, (AttrNumber) 2, "tid", TIDOID, -1, 0);
-	for (int i = 0; i < buildstate->tupdesc->natts; i++)
-		TupleDescInitEntry(buildstate->sortdesc, (AttrNumber) (3 + i), NULL, buildstate->tupdesc->attrs[i].atttypid, -1, 0);
+	buildstate->tupdesc = CreateTemplateTupleDesc(3);
+	TupleDescInitEntry(buildstate->tupdesc, (AttrNumber) 1, "list", INT4OID, -1, 0);
+	TupleDescInitEntry(buildstate->tupdesc, (AttrNumber) 2, "tid", TIDOID, -1, 0);
+	TupleDescInitEntry(buildstate->tupdesc, (AttrNumber) 3, "vector", RelationGetDescr(index)->attrs[0].atttypid, -1, 0);
 
-	buildstate->slot = MakeSingleTupleTableSlot(buildstate->sortdesc, &TTSOpsVirtual);
+	buildstate->slot = MakeSingleTupleTableSlot(buildstate->tupdesc, &TTSOpsVirtual);
 
 	buildstate->centers = VectorArrayInit(buildstate->lists, buildstate->dimensions, buildstate->typeInfo->itemSize(buildstate->dimensions));
 	buildstate->listInfo = palloc(sizeof(ListInfo) * buildstate->lists);
@@ -659,7 +633,7 @@ IvfflatParallelScanAndSort(IvfflatSpool * ivfspool, IvfflatShared * ivfshared, S
 	InitBuildState(&buildstate, ivfspool->heap, ivfspool->index, indexInfo);
 	memcpy(buildstate.centers->items, ivfcenters, buildstate.centers->itemsize * buildstate.centers->maxlen);
 	buildstate.centers->length = buildstate.centers->maxlen;
-	ivfspool->sortstate = InitBuildSortState(buildstate.sortdesc, sortmem, coordinate);
+	ivfspool->sortstate = InitBuildSortState(buildstate.tupdesc, sortmem, coordinate);
 	buildstate.sortstate = ivfspool->sortstate;
 	scan = table_beginscan_parallel(ivfspool->heap,
 									ParallelTableScanFromIvfflatShared(ivfshared));
@@ -976,7 +950,7 @@ AssignTuples(IvfflatBuildState * buildstate)
 	}
 
 	/* Begin serial/leader tuplesort */
-	buildstate->sortstate = InitBuildSortState(buildstate->sortdesc, maintenance_work_mem, coordinate);
+	buildstate->sortstate = InitBuildSortState(buildstate->tupdesc, maintenance_work_mem, coordinate);
 
 	/* Add tuples to sort */
 	if (buildstate->heap != NULL)

src/ivfflat.c

@@ -167,7 +167,7 @@ ivfflathandler(PG_FUNCTION_ARGS)
 	amroutine->amcanorderbyop = true;
 	amroutine->amcanbackward = false;	/* can change direction mid-scan */
 	amroutine->amcanunique = false;
-	amroutine->amcanmulticol = true;
+	amroutine->amcanmulticol = false;
 	amroutine->amoptionalkey = true;
 	amroutine->amsearcharray = false;
 	amroutine->amsearchnulls = false;

src/ivfflat.h

@@ -165,7 +165,6 @@ typedef struct IvfflatBuildState
 	Relation	index;
 	IndexInfo  *indexInfo;
 	const		IvfflatTypeInfo *typeInfo;
-	TupleDesc	tupdesc;
 
 	/* Settings */
 	int			dimensions;
@@ -199,7 +198,7 @@ typedef struct IvfflatBuildState
 
 	/* Sorting */
 	Tuplesortstate *sortstate;
-	TupleDesc	sortdesc;
+	TupleDesc	tupdesc;
 	TupleTableSlot *slot;
 
 	/* Memory */

src/ivfinsert.c

@@ -78,8 +78,6 @@ InsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heap_tid, R
 	BlockNumber insertPage = InvalidBlockNumber;
 	ListInfo	listInfo;
 	BlockNumber originalInsertPage;
-	TupleDesc	tupdesc = RelationGetDescr(index);
-	Datum	   *newValues = palloc(tupdesc->natts * sizeof(Datum));
 
 	/* Detoast once for all calls */
 	value = PointerGetDatum(PG_DETOAST_DATUM(values[0]));
@@ -100,16 +98,12 @@ InsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heap_tid, R
 	IvfflatGetMetaPageInfo(index, NULL, NULL);
 
 	/* Find the insert page - sets the page and list info */
-	FindInsertPage(index, &value, &insertPage, &listInfo);
+	FindInsertPage(index, values, &insertPage, &listInfo);
 	Assert(BlockNumberIsValid(insertPage));
 	originalInsertPage = insertPage;
 
-	newValues[0] = value;
-	for (int i = 1; i < tupdesc->natts; i++)
-		newValues[i] = values[i];
-
 	/* Form tuple */
-	itup = index_form_tuple(tupdesc, newValues, isnull);
+	itup = index_form_tuple(RelationGetDescr(index), &value, isnull);
 	itup->t_tid = *heap_tid;
 
 	/* Get tuple size */

src/ivfscan.c

@@ -104,34 +104,6 @@ GetScanLists(IndexScanDesc scan, Datum value)
 	}
 }
 
-/*
- * Check if matches scan keys
- */
-static bool
-MatchesScanKeys(IndexScanDesc scan, IndexTuple itup, TupleDesc tupdesc)
-{
-	for (int i = 0; i < scan->numberOfKeys; i++)
-	{
-		ScanKey		key = &scan->keyData[i];
-		bool		attnull = key->sk_flags & SK_ISNULL;
-		bool		isnull;
-		Datum		value = index_getattr(itup, key->sk_attno, tupdesc, &isnull);
-
-		if (isnull || attnull)
-		{
-			if (isnull != attnull)
-				return false;
-		}
-		else
-		{
-			if (!DatumGetBool(FunctionCall2Coll(&key->sk_func, key->sk_collation, value, key->sk_argument)))
-				return false;
-		}
-	}
-
-	return true;
-}
-
 /*
  * Get items
  */
@@ -168,10 +140,6 @@ GetScanItems(IndexScanDesc scan, Datum value)
 				ItemId		itemid = PageGetItemId(page, offno);
 
 				itup = (IndexTuple) PageGetItem(page, itemid);
-
-				if (!MatchesScanKeys(scan, itup, tupdesc))
-					continue;
-
 				datum = index_getattr(itup, 1, tupdesc, &isnull);
 
 				/*

test/t/002_ivfflat_vacuum.pl

@@ -6,7 +6,13 @@ use Test::More;
 
 my $dim = 3;
 
-my $array_sql = join(",", ('random()') x $dim);
+my @r = ();
+for (1 .. $dim)
+{
+	my $v = int(rand(1000)) + 1;
+	push(@r, "i % $v");
+}
+my $array_sql = join(", ", @r);
 
 # Initialize node
 my $node = PostgreSQL::Test::Cluster->new('node');
@@ -17,20 +23,19 @@ $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, ARRAY[$array_sql] FROM generate_series(1, 100000) i;"
+	"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 vector_l2_ops);");
 
 # Get size
 my $size = $node->safe_psql("postgres", "SELECT pg_total_relation_size('tst_v_idx');");
 
-# Store values
-$node->safe_psql("postgres", "CREATE TABLE tmp AS SELECT * FROM tst;");
-
 # Delete all, vacuum, and insert same data
 $node->safe_psql("postgres", "DELETE FROM tst;");
 $node->safe_psql("postgres", "VACUUM tst;");
-$node->safe_psql("postgres", "INSERT INTO tst SELECT * FROM tmp;");
+$node->safe_psql("postgres",
+	"INSERT INTO tst SELECT i % 10, ARRAY[$array_sql] FROM generate_series(1, 100000) i;"
+);
 
 # Check size
 my $new_size = $node->safe_psql("postgres", "SELECT pg_total_relation_size('tst_v_idx');");

test/t/041_ivfflat_inline_filtering.pl

@@ -1,197 +0,0 @@
-use strict;
-use warnings FATAL => 'all';
-use PostgreSQL::Test::Cluster;
-use PostgreSQL::Test::Utils;
-use Test::More;
-
-my $node;
-my @queries = ();
-my @where = ();
-my @expected;
-my $limit = 20;
-my $dim = 3;
-my $array_sql = join(",", ('random()') x $dim);
-my $nc = 100;
-my $nc2 = 10;
-
-sub test_recall
-{
-	my ($probes, $min, $operator) = @_;
-	my $correct = 0;
-	my $total = 0;
-
-	for my $j (0 .. 2)
-	{
-		my $explain = $node->safe_psql("postgres", qq(
-			SET enable_seqscan = off;
-			SET ivfflat.probes = $probes;
-			EXPLAIN ANALYZE SELECT i FROM tst WHERE $where[$j] ORDER BY v $operator '$queries[$j]' LIMIT $limit;
-		));
-		like($explain, qr/Index Cond/);
-	}
-
-	for my $i (0 .. $#queries)
-	{
-		my $actual = $node->safe_psql("postgres", qq(
-			SET enable_seqscan = off;
-			SET ivfflat.probes = $probes;
-			SELECT i FROM tst WHERE $where[$i] ORDER BY v $operator '$queries[$i]' LIMIT $limit;
-		));
-		my @actual_ids = split("\n", $actual);
-		my %actual_set = map { $_ => 1 } @actual_ids;
-
-		is(scalar(@actual_ids), $limit);
-
-		my @expected_ids = split("\n", $expected[$i]);
-
-		foreach (@expected_ids)
-		{
-			if (exists($actual_set{$_}))
-			{
-				$correct++;
-			}
-			$total++;
-		}
-	}
-
-	cmp_ok($correct / $total, ">=", $min, $operator);
-}
-
-# Initialize node
-$node = PostgreSQL::Test::Cluster->new('node');
-$node->init;
-$node->start;
-
-# Create table
-$node->safe_psql("postgres", "CREATE EXTENSION vector;");
-$node->safe_psql("postgres", "CREATE TABLE tst (i int4, v vector($dim), c int4, c2 int4);");
-$node->safe_psql("postgres",
-	"INSERT INTO tst SELECT i, ARRAY[$array_sql], i % $nc, i % $nc2 FROM generate_series(1, 50000) i;"
-);
-
-# Generate queries
-for my $i (1 .. 100)
-{
-	my @r = ();
-	for (1 .. $dim)
-	{
-		push(@r, rand());
-	}
-	push(@queries, "[" . join(",", @r) . "]");
-
-	if ($i % 3 == 0)
-	{
-		my $c = int(rand() * $nc);
-		push(@where, "c = $c");
-	}
-	elsif ($i % 3 == 1)
-	{
-		my $c2 = int(rand() * $nc2);
-		push(@where, "c2 = $c2");
-	}
-	else
-	{
-		# use c2 to ensure results
-		my $c2 = int(rand() * $nc2);
-		push(@where, "c = $c2 AND c2 = $c2");
-	}
-}
-
-# Add index
-$node->safe_psql("postgres", qq(
-	CREATE INDEX ON tst USING ivfflat (v vector_l2_ops, c, c2) WITH (lists = 100);
-));
-
-# Insert more rows
-$node->safe_psql("postgres",
-	"INSERT INTO tst SELECT i, ARRAY[$array_sql], i % $nc, i % $nc2 FROM generate_series(1, 50000) i;"
-);
-
-# Get exact results
-@expected = ();
-for my $i (0 .. $#queries)
-{
-	my $res = $node->safe_psql("postgres", qq(
-		SET enable_indexscan = off;
-		SELECT i FROM tst WHERE $where[$i] ORDER BY v <-> '$queries[$i]' LIMIT $limit;
-	));
-	push(@expected, $res);
-}
-
-# Test recall
-test_recall(10, 0.99, '<->');
-
-# Test vacuum
-$node->safe_psql("postgres", "DELETE FROM tst WHERE c > 5;");
-$node->safe_psql("postgres", "VACUUM tst;");
-
-# Test less than
-my $explain = $node->safe_psql("postgres", qq(
-	SET enable_seqscan = off;
-	EXPLAIN ANALYZE SELECT i FROM tst WHERE c < 10 ORDER BY v <-> '$queries[0]' LIMIT $limit;
-));
-like($explain, qr/Index Cond: \(c < 10\)/);
-
-# Test less than or equal
-$explain = $node->safe_psql("postgres", qq(
-	SET enable_seqscan = off;
-	EXPLAIN ANALYZE SELECT i FROM tst WHERE c <= 10 ORDER BY v <-> '$queries[0]' LIMIT $limit;
-));
-like($explain, qr/Index Cond: \(c <= 10\)/);
-
-# Test greater than or equal
-$explain = $node->safe_psql("postgres", qq(
-	SET enable_seqscan = off;
-	EXPLAIN ANALYZE SELECT i FROM tst WHERE c >= 90 ORDER BY v <-> '$queries[0]' LIMIT $limit;
-));
-like($explain, qr/Index Cond: \(c >= 90\)/);
-
-# Test greater than
-$explain = $node->safe_psql("postgres", qq(
-	SET enable_seqscan = off;
-	EXPLAIN ANALYZE SELECT i FROM tst WHERE c > 90 ORDER BY v <-> '$queries[0]' LIMIT $limit;
-));
-like($explain, qr/Index Cond: \(c > 90\)/);
-
-# Test multiple attribute columns
-$explain = $node->safe_psql("postgres", qq(
-	SET enable_seqscan = off;
-	EXPLAIN ANALYZE SELECT i FROM tst WHERE c = 1 AND c2 = 1 ORDER BY v <-> '$queries[0]' LIMIT $limit;
-));
-like($explain, qr/Index Cond: \(\(c = 1\) AND \(c2 = 1\)\)/);
-
-# Test only last attribute column
-$explain = $node->safe_psql("postgres", qq(
-	SET enable_seqscan = off;
-	EXPLAIN ANALYZE SELECT i FROM tst WHERE c2 = 1 ORDER BY v <-> '$queries[0]' LIMIT $limit;
-));
-like($explain, qr/Index Cond: \(c2 = 1\)/);
-
-# Test only vector column
-$explain = $node->safe_psql("postgres", qq(
-	SET enable_seqscan = off;
-	EXPLAIN ANALYZE SELECT i FROM tst ORDER BY v <-> '$queries[0]' LIMIT $limit;
-));
-like($explain, qr/Index Scan/);
-
-# Test only attribute columns
-$explain = $node->safe_psql("postgres", qq(
-	SET enable_seqscan = off;
-	EXPLAIN ANALYZE SELECT i FROM tst WHERE c = 1;
-));
-like($explain, qr/Seq Scan/);
-
-# Test columns
-my ($ret, $stdout, $stderr) = $node->psql("postgres", "CREATE INDEX ON tst USING ivfflat (c);");
-like($stderr, qr/first column must be a vector/);
-
-($ret, $stdout, $stderr) = $node->psql("postgres", "CREATE INDEX ON tst USING ivfflat (c, v vector_cosine_ops);");
-like($stderr, qr/first column must be a vector/);
-
-($ret, $stdout, $stderr) = $node->psql("postgres", "CREATE INDEX ON tst USING ivfflat (v vector_cosine_ops, c, c, c);");
-like($stderr, qr/index cannot have more than three columns/);
-
-($ret, $stdout, $stderr) = $node->psql("postgres", "CREATE INDEX ON tst USING ivfflat (v vector_cosine_ops, v vector_cosine_ops);");
-like($stderr, qr/column 2 cannot be a vector/);
-
-done_testing();