Updated function name

Makefile

@@ -3,7 +3,7 @@ EXTVERSION = 0.5.0
 
 MODULE_big = vector
 DATA = $(wildcard sql/*--*.sql)
-OBJS = src/hnsw.o src/hnswbuild.o src/hnswinsert.o src/hnswscan.o src/hnswutils.o src/hnswvacuum.o src/ivfbuild.o src/ivfflat.o src/ivfinsert.o src/ivfkmeans.o src/ivfscan.o src/ivfutils.o src/ivfvacuum.o src/vector.o
+OBJS = src/float4.o src/hnsw.o src/hnswbuild.o src/hnswinsert.o src/hnswscan.o src/hnswutils.o src/hnswvacuum.o src/ivfbuild.o src/ivfflat.o src/ivfinsert.o src/ivfkmeans.o src/ivfscan.o src/ivfutils.o src/ivfvacuum.o src/vector.o
 HEADERS = src/vector.h
 
 TESTS = $(wildcard test/sql/*.sql)

Makefile.win

@@ -1,7 +1,7 @@
 EXTENSION = vector
 EXTVERSION = 0.5.0
 
-OBJS = src\hnsw.obj src\hnswbuild.obj src\hnswinsert.obj src\hnswscan.obj src\hnswutils.obj src\hnswvacuum.obj src\ivfbuild.obj src\ivfflat.obj src\ivfinsert.obj src\ivfkmeans.obj src\ivfscan.obj src\ivfutils.obj src\ivfvacuum.obj src\vector.obj
+OBJS = src\float4.obj src\hnsw.obj src\hnswbuild.obj src\hnswinsert.obj src\hnswscan.obj src\hnswutils.obj src\hnswvacuum.obj src\ivfbuild.obj src\ivfflat.obj src\ivfinsert.obj src\ivfkmeans.obj src\ivfscan.obj src\ivfutils.obj src\ivfvacuum.obj src\vector.obj
 HEADERS = src\vector.h
 
 REGRESS = btree cast copy functions input ivfflat_cosine ivfflat_ip ivfflat_l2 ivfflat_options ivfflat_unlogged

sql/vector.sql

@@ -34,6 +34,9 @@ CREATE TYPE vector (
 CREATE FUNCTION l2_distance(vector, vector) RETURNS float8
 	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
 
+CREATE FUNCTION l2_distance(float4[], float4[]) RETURNS float8
+	AS 'MODULE_PATHNAME', 'float4_l2_distance' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
 CREATE FUNCTION inner_product(vector, vector) RETURNS float8
 	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
 
@@ -84,6 +87,9 @@ CREATE FUNCTION vector_cmp(vector, vector) RETURNS int4
 CREATE FUNCTION vector_l2_squared_distance(vector, vector) RETURNS float8
 	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
 
+CREATE FUNCTION float4_l2_squared_distance(float4[], float4[]) RETURNS float8
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
 CREATE FUNCTION vector_negative_inner_product(vector, vector) RETURNS float8
 	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
 
@@ -164,6 +170,11 @@ CREATE OPERATOR <-> (
 	COMMUTATOR = '<->'
 );
 
+CREATE OPERATOR <-> (
+	LEFTARG = float4[], RIGHTARG = float4[], PROCEDURE = l2_distance,
+	COMMUTATOR = '<->'
+);
+
 CREATE OPERATOR <#> (
 	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = vector_negative_inner_product,
 	COMMUTATOR = '<#>'
@@ -280,6 +291,11 @@ CREATE OPERATOR CLASS vector_l2_ops
 	OPERATOR 1 <-> (vector, vector) FOR ORDER BY float_ops,
 	FUNCTION 1 vector_l2_squared_distance(vector, vector);
 
+CREATE OPERATOR CLASS float4_l2_ops
+	FOR TYPE float4[] USING hnsw AS
+	OPERATOR 1 <-> (float4[], float4[]) FOR ORDER BY float_ops,
+	FUNCTION 1 float4_l2_squared_distance(float4[], float4[]);
+
 CREATE OPERATOR CLASS vector_ip_ops
 	FOR TYPE vector USING hnsw AS
 	OPERATOR 1 <#> (vector, vector) FOR ORDER BY float_ops,

src/float4.c

@@ -0,0 +1,60 @@
+#include "postgres.h"
+
+#include <math.h>
+
+#include "utils/array.h"
+
+/*
+ * Get the L2 distance between vectors
+ */
+PGDLLEXPORT PG_FUNCTION_INFO_V1(float4_l2_distance);
+Datum
+float4_l2_distance(PG_FUNCTION_ARGS)
+{
+	ArrayType  *a = PG_GETARG_ARRAYTYPE_P(0);
+	ArrayType  *b = PG_GETARG_ARRAYTYPE_P(1);
+	float	   *ax = (float *) ARR_DATA_PTR(a);
+	float	   *bx = (float *) ARR_DATA_PTR(b);
+	float		distance = 0.0;
+	float		diff;
+
+	/* TODO Check rank, dimensions, and nulls */
+	int			dim = ARR_DIMS(a)[0];
+
+	/* Auto-vectorized */
+	for (int i = 0; i < dim; i++)
+	{
+		diff = ax[i] - bx[i];
+		distance += diff * diff;
+	}
+
+	PG_RETURN_FLOAT8(sqrt((double) distance));
+}
+
+/*
+ * Get the L2 squared distance between vectors
+ * This saves a sqrt calculation
+ */
+PGDLLEXPORT PG_FUNCTION_INFO_V1(float4_l2_squared_distance);
+Datum
+float4_l2_squared_distance(PG_FUNCTION_ARGS)
+{
+	ArrayType  *a = PG_GETARG_ARRAYTYPE_P(0);
+	ArrayType  *b = PG_GETARG_ARRAYTYPE_P(1);
+	float	   *ax = (float *) ARR_DATA_PTR(a);
+	float	   *bx = (float *) ARR_DATA_PTR(b);
+	float		distance = 0.0;
+	float		diff;
+
+	/* TODO Check rank, dimensions, and nulls */
+	int			dim = ARR_DIMS(a)[0];
+
+	/* Auto-vectorized */
+	for (int i = 0; i < dim; i++)
+	{
+		diff = ax[i] - bx[i];
+		distance += diff * diff;
+	}
+
+	PG_RETURN_FLOAT8((double) distance);
+}

src/hnsw.c

@@ -33,6 +33,12 @@ HnswInit(void)
 					  HNSW_DEFAULT_EF_CONSTRUCTION, HNSW_MIN_EF_CONSTRUCTION, HNSW_MAX_EF_CONSTRUCTION
 #if PG_VERSION_NUM >= 130000
 					  ,AccessExclusiveLock
+#endif
+		);
+	add_int_reloption(hnsw_relopt_kind, "dimensions", "Number of dimensions",
+					  HNSW_DEFAULT_DIMENSIONS, HNSW_MIN_DIMENSIONS, HNSW_MAX_DIMENSIONS
+#if PG_VERSION_NUM >= 130000
+					  ,AccessExclusiveLock
 #endif
 		);
 
@@ -125,6 +131,7 @@ hnswoptions(Datum reloptions, bool validate)
 	static const relopt_parse_elt tab[] = {
 		{"m", RELOPT_TYPE_INT, offsetof(HnswOptions, m)},
 		{"ef_construction", RELOPT_TYPE_INT, offsetof(HnswOptions, efConstruction)},
+		{"dimensions", RELOPT_TYPE_INT, offsetof(HnswOptions, dimensions)},
 	};
 
 #if PG_VERSION_NUM >= 130000

src/hnsw.h

@@ -42,6 +42,9 @@
 #define HNSW_DEFAULT_EF_SEARCH	40
 #define HNSW_MIN_EF_SEARCH		1
 #define HNSW_MAX_EF_SEARCH		1000
+#define HNSW_DEFAULT_DIMENSIONS	-1
+#define HNSW_MIN_DIMENSIONS		1
+#define HNSW_MAX_DIMENSIONS		HNSW_MAX_DIM
 
 /* Tuple types */
 #define HNSW_ELEMENT_TUPLE_TYPE  1
@@ -57,7 +60,7 @@
 /* PROGRESS_CREATEIDX_SUBPHASE_INITIALIZE is 1 */
 #define PROGRESS_HNSW_PHASE_LOAD		2
 
-#define HNSW_ELEMENT_TUPLE_SIZE(_dim)	MAXALIGN(offsetof(HnswElementTupleData, vec) + VECTOR_SIZE(_dim))
+#define HNSW_ELEMENT_TUPLE_SIZE(_datum)	MAXALIGN(offsetof(HnswElementTupleData, value) + VARSIZE_ANY(_datum))
 #define HNSW_NEIGHBOR_TUPLE_SIZE(level, m)	MAXALIGN(offsetof(HnswNeighborTupleData, indextids) + ((level) + 2) * (m) * sizeof(ItemPointerData))
 
 #define HnswPageGetOpaque(page)	((HnswPageOpaque) PageGetSpecialPointer(page))
@@ -96,12 +99,13 @@ typedef struct HnswElementData
 	List	   *heaptids;
 	uint8		level;
 	uint8		deleted;
+	bool		loaded;
 	HnswNeighborArray *neighbors;
 	BlockNumber blkno;
 	OffsetNumber offno;
 	OffsetNumber neighborOffno;
 	BlockNumber neighborPage;
-	Vector	   *vec;
+	Datum		value;
 }			HnswElementData;
 
 typedef HnswElementData * HnswElement;
@@ -130,6 +134,7 @@ typedef struct HnswOptions
 	int32		vl_len_;		/* varlena header (do not touch directly!) */
 	int			m;				/* number of connections */
 	int			efConstruction; /* size of dynamic candidate list */
+	int			dimensions;
 }			HnswOptions;
 
 typedef struct HnswBuildState
@@ -200,7 +205,7 @@ typedef struct HnswElementTupleData
 	ItemPointerData heaptids[HNSW_HEAPTIDS];
 	ItemPointerData neighbortid;
 	uint16		unused2;
-	Vector		vec;
+	char		value[FLEXIBLE_ARRAY_MEMBER];
 }			HnswElementTupleData;
 
 typedef HnswElementTupleData * HnswElementTuple;
@@ -258,6 +263,7 @@ typedef struct HnswVacuumState
 /* Methods */
 int			HnswGetM(Relation index);
 int			HnswGetEfConstruction(Relation index);
+int			HnswGetDimensions(Relation index);
 FmgrInfo   *HnswOptionalProcInfo(Relation index, uint16 procnum);
 bool		HnswNormValue(FmgrInfo *procinfo, Oid collation, Datum *value, Vector * result);
 void		HnswCommitBuffer(Buffer buf, GenericXLogState *state);

src/hnswbuild.c

@@ -8,6 +8,7 @@
 #include "lib/pairingheap.h"
 #include "nodes/pg_list.h"
 #include "storage/bufmgr.h"
+#include "utils/datum.h"
 #include "utils/memutils.h"
 
 #if PG_VERSION_NUM >= 140000
@@ -106,8 +107,6 @@ CreateElementPages(HnswBuildState * buildstate)
 {
 	Relation	index = buildstate->index;
 	ForkNumber	forkNum = buildstate->forkNum;
-	int			dimensions = buildstate->dimensions;
-	Size		etupSize;
 	Size		maxSize;
 	HnswElementTuple etup;
 	HnswNeighborTuple ntup;
@@ -119,10 +118,9 @@ CreateElementPages(HnswBuildState * buildstate)
 
 	/* Calculate sizes */
 	maxSize = BLCKSZ - MAXALIGN(SizeOfPageHeaderData) - MAXALIGN(sizeof(HnswPageOpaqueData));
-	etupSize = HNSW_ELEMENT_TUPLE_SIZE(dimensions);
 
 	/* Allocate once */
-	etup = palloc0(etupSize);
+	etup = palloc0(maxSize);
 	ntup = palloc0(maxSize);
 
 	/* Prepare first page */
@@ -134,12 +132,14 @@ CreateElementPages(HnswBuildState * buildstate)
 	foreach(lc, buildstate->elements)
 	{
 		HnswElement element = lfirst(lc);
+		Size		etupSize;
 		Size		ntupSize;
 		Size		combinedSize;
 
 		HnswSetElementTuple(etup, element);
 
 		/* Calculate sizes */
+		etupSize = HNSW_ELEMENT_TUPLE_SIZE(element->value);
 		ntupSize = HNSW_NEIGHBOR_TUPLE_SIZE(element->level, buildstate->m);
 		combinedSize = etupSize + ntupSize + sizeof(ItemIdData);
 
@@ -276,18 +276,15 @@ InsertTuple(Relation index, Datum *values, HnswElement element, HnswBuildState *
 	int			m = buildstate->m;
 
 	/* Detoast once for all calls */
-	Datum		value = PointerGetDatum(PG_DETOAST_DATUM(values[0]));
+	element->value = PointerGetDatum(PG_DETOAST_DATUM(values[0]));
 
 	/* Normalize if needed */
 	if (buildstate->normprocinfo != NULL)
 	{
-		if (!HnswNormValue(buildstate->normprocinfo, collation, &value, buildstate->normvec))
+		if (!HnswNormValue(buildstate->normprocinfo, collation, &element->value, buildstate->normvec))
 			return false;
 	}
 
-	/* Copy value to element so accessible outside of memory context */
-	memcpy(element->vec, DatumGetVector(value), VECTOR_SIZE(buildstate->dimensions));
-
 	/* Insert element in graph */
 	HnswInsertElement(element, entryPoint, NULL, procinfo, collation, m, efConstruction, false);
 
@@ -363,7 +360,6 @@ BuildCallback(Relation index, CALLBACK_ITEM_POINTER, Datum *values,
 
 	/* Allocate necessary memory outside of memory context */
 	element = HnswInitElement(tid, buildstate->m, buildstate->ml, buildstate->maxLevel);
-	element->vec = palloc(VECTOR_SIZE(buildstate->dimensions));
 
 	/* Use memory context since detoast can allocate */
 	oldCtx = MemoryContextSwitchTo(buildstate->tmpCtx);
@@ -371,9 +367,8 @@ BuildCallback(Relation index, CALLBACK_ITEM_POINTER, Datum *values,
 	/* Insert tuple */
 	inserted = InsertTuple(index, values, element, buildstate, &dup);
 
-	/* Reset memory context */
+	/* Switch memory context */
 	MemoryContextSwitchTo(oldCtx);
-	MemoryContextReset(buildstate->tmpCtx);
 
 	/* Add outside memory context */
 	if (dup != NULL)
@@ -381,9 +376,16 @@ BuildCallback(Relation index, CALLBACK_ITEM_POINTER, Datum *values,
 
 	/* Add to buildstate or free */
 	if (inserted)
+	{
+		element->value = datumCopy(element->value, false, -1);
+		element->loaded = true;
 		buildstate->elements = lappend(buildstate->elements, element);
+	}
 	else
 		HnswFreeElement(element);
+
+	/* Reset memory context */
+	MemoryContextReset(buildstate->tmpCtx);
 }
 
 /*
@@ -398,6 +400,7 @@ HnswGetMaxInMemoryElements(int m, double ml, int dimensions)
 	elementSize += sizeof(HnswNeighborArray) * (avgLevel + 1);
 	elementSize += sizeof(HnswCandidate) * (m * (avgLevel + 2));
 	elementSize += sizeof(ItemPointerData);
+	/* TODO Handle non-vector types */
 	elementSize += VECTOR_SIZE(dimensions);
 	return (maintenance_work_mem * 1024L) / elementSize;
 }
@@ -415,7 +418,10 @@ InitBuildState(HnswBuildState * buildstate, Relation heap, Relation index, Index
 
 	buildstate->m = HnswGetM(index);
 	buildstate->efConstruction = HnswGetEfConstruction(index);
-	buildstate->dimensions = TupleDescAttr(index->rd_att, 0)->atttypmod;
+	buildstate->dimensions = HnswGetDimensions(index);
+
+	if (buildstate->dimensions < 0)
+		buildstate->dimensions = TupleDescAttr(index->rd_att, 0)->atttypmod;
 
 	/* Require column to have dimensions to be indexed */
 	if (buildstate->dimensions < 0)

src/hnswinsert.c

@@ -123,7 +123,6 @@ WriteNewElementPages(Relation index, HnswElement e, int m, BlockNumber insertPag
 	Size		minCombinedSize;
 	HnswElementTuple etup;
 	BlockNumber currentPage = insertPage;
-	int			dimensions = e->vec->dim;
 	HnswNeighborTuple ntup;
 	Buffer		nbuf;
 	Page		npage;
@@ -132,7 +131,7 @@ WriteNewElementPages(Relation index, HnswElement e, int m, BlockNumber insertPag
 	BlockNumber newInsertPage = InvalidBlockNumber;
 
 	/* Calculate sizes */
-	etupSize = HNSW_ELEMENT_TUPLE_SIZE(dimensions);
+	etupSize = HNSW_ELEMENT_TUPLE_SIZE(e->value);
 	ntupSize = HNSW_NEIGHBOR_TUPLE_SIZE(e->level, m);
 	combinedSize = etupSize + ntupSize + sizeof(ItemIdData);
 	maxSize = BLCKSZ - MAXALIGN(SizeOfPageHeaderData) - MAXALIGN(sizeof(HnswPageOpaqueData));
@@ -411,7 +410,7 @@ HnswAddDuplicate(Relation index, HnswElement element, HnswElement dup)
 	Buffer		buf;
 	Page		page;
 	GenericXLogState *state;
-	Size		etupSize = HNSW_ELEMENT_TUPLE_SIZE(dup->vec->dim);
+	Size		etupSize = HNSW_ELEMENT_TUPLE_SIZE(dup->value);
 	HnswElementTuple etup;
 	int			i;
 
@@ -522,7 +521,7 @@ HnswInsertTuple(Relation index, Datum *values, bool *isnull, ItemPointer heap_ti
 
 	/* Create an element */
 	element = HnswInitElement(heap_tid, m, HnswGetMl(m), HnswGetMaxLevel(m));
-	element->vec = DatumGetVector(value);
+	element->value = value;
 
 	/* Prevent concurrent inserts when likely updating entry point */
 	if (entryPoint == NULL || element->level > entryPoint->level)

src/hnswutils.c

@@ -4,6 +4,7 @@
 
 #include "hnsw.h"
 #include "storage/bufmgr.h"
+#include "utils/datum.h"
 #include "vector.h"
 
 /*
@@ -34,6 +35,20 @@ HnswGetEfConstruction(Relation index)
 	return HNSW_DEFAULT_EF_CONSTRUCTION;
 }
 
+/*
+ * Get the number of dimensions in the index
+ */
+int
+HnswGetDimensions(Relation index)
+{
+	HnswOptions *opts = (HnswOptions *) index->rd_options;
+
+	if (opts)
+		return opts->dimensions;
+
+	return HNSW_DEFAULT_DIMENSIONS;
+}
+
 /*
  * Get proc
  */
@@ -187,7 +202,8 @@ HnswFreeElement(HnswElement element)
 {
 	HnswFreeNeighbors(element);
 	list_free_deep(element->heaptids);
-	pfree(element->vec);
+	if (element->loaded)
+		pfree(DatumGetPointer(element->value));
 	pfree(element);
 }
 
@@ -214,7 +230,7 @@ HnswInitElementFromBlock(BlockNumber blkno, OffsetNumber offno)
 	element->blkno = blkno;
 	element->offno = offno;
 	element->neighbors = NULL;
-	element->vec = NULL;
+	element->loaded = false;
 	return element;
 }
 
@@ -324,7 +340,7 @@ HnswSetElementTuple(HnswElementTuple etup, HnswElement element)
 		else
 			ItemPointerSetInvalid(&etup->heaptids[i]);
 	}
-	memcpy(&etup->vec, element->vec, VECTOR_SIZE(element->vec->dim));
+	memcpy(&etup->value, DatumGetPointer(element->value), VARSIZE_ANY(element->value));
 }
 
 /*
@@ -447,8 +463,10 @@ HnswLoadElementFromTuple(HnswElement element, HnswElementTuple etup, bool loadHe
 
 	if (loadVec)
 	{
-		element->vec = palloc(VECTOR_SIZE(etup->vec.dim));
-		memcpy(element->vec, &etup->vec, VECTOR_SIZE(etup->vec.dim));
+		Datum		value = PointerGetDatum(&etup->value);
+
+		element->value = datumCopy(value, false, -1);
+		element->loaded = true;
 	}
 }
 
@@ -476,7 +494,7 @@ HnswLoadElement(HnswElement element, float *distance, Datum *q, Relation index,
 
 	/* Calculate distance */
 	if (distance != NULL)
-		*distance = (float) DatumGetFloat8(FunctionCall2Coll(procinfo, collation, *q, PointerGetDatum(&etup->vec)));
+		*distance = (float) DatumGetFloat8(FunctionCall2Coll(procinfo, collation, *q, PointerGetDatum(&etup->value)));
 
 	UnlockReleaseBuffer(buf);
 }
@@ -487,7 +505,7 @@ HnswLoadElement(HnswElement element, float *distance, Datum *q, Relation index,
 static float
 GetCandidateDistance(HnswCandidate * hc, Datum q, FmgrInfo *procinfo, Oid collation)
 {
-	return DatumGetFloat8(FunctionCall2Coll(procinfo, collation, q, PointerGetDatum(hc->element->vec)));
+	return DatumGetFloat8(FunctionCall2Coll(procinfo, collation, q, hc->element->value));
 }
 
 /*
@@ -722,7 +740,7 @@ HnswGetDistance(HnswElement a, HnswElement b, int lc, FmgrInfo *procinfo, Oid co
 		}
 	}
 
-	return DatumGetFloat8(FunctionCall2Coll(procinfo, collation, PointerGetDatum(a->vec), PointerGetDatum(b->vec)));
+	return DatumGetFloat8(FunctionCall2Coll(procinfo, collation, a->value, b->value));
 }
 
 /*
@@ -805,7 +823,7 @@ HnswFindDuplicate(HnswElement e)
 		HnswCandidate *neighbor = &neighbors->items[i];
 
 		/* Exit early since ordered by distance */
-		if (vector_cmp_internal(e->vec, neighbor->element->vec) != 0)
+		if (!datumIsEqual(e->value, neighbor->element->value, false, -1))
 			break;
 
 		/* Check for space */
@@ -880,13 +898,13 @@ HnswUpdateConnection(HnswElement element, HnswCandidate * hc, int m, int lc, int
 		/* Load elements on insert */
 		if (index != NULL)
 		{
-			Datum		q = PointerGetDatum(hc->element->vec);
+			Datum		q = hc->element->value;
 
 			for (int i = 0; i < currentNeighbors->length; i++)
 			{
 				HnswCandidate *hc3 = &currentNeighbors->items[i];
 
-				if (hc3->element->vec == NULL)
+				if (!hc3->element->loaded)
 					HnswLoadElement(hc3->element, &hc3->distance, &q, index, procinfo, collation, true);
 				else
 					hc3->distance = GetCandidateDistance(hc3, q, procinfo, collation);
@@ -968,7 +986,7 @@ HnswInsertElement(HnswElement element, HnswElement entryPoint, Relation index, F
 	List	   *w;
 	int			level = element->level;
 	int			entryLevel;
-	Datum		q = PointerGetDatum(element->vec);
+	Datum		q = element->value;
 	HnswElement skipElement = existing ? element : NULL;
 
 	/* No neighbors if no entry point */

src/hnswvacuum.c

@@ -93,7 +93,7 @@ RemoveHeapTids(HnswVacuumState * vacuumstate)
 
 				if (itemUpdated)
 				{
-					Size		etupSize = HNSW_ELEMENT_TUPLE_SIZE(etup->vec.dim);
+					Size		etupSize = HNSW_ELEMENT_TUPLE_SIZE(PointerGetDatum(&etup->value));
 
 					/* Mark rest as invalid */
 					for (int i = idx; i < HNSW_HEAPTIDS; i++)
@@ -485,6 +485,7 @@ MarkDeleted(HnswVacuumState * vacuumstate)
 			HnswNeighborTuple ntup;
 			Size		etupSize;
 			Size		ntupSize;
+			Datum		value;
 			Buffer		nbuf;
 			Page		npage;
 			BlockNumber neighborPage;
@@ -508,8 +509,11 @@ MarkDeleted(HnswVacuumState * vacuumstate)
 			if (ItemPointerIsValid(&etup->heaptids[0]))
 				continue;
 
+			/* Get datum */
+			value = PointerGetDatum(&etup->value);
+
 			/* Calculate sizes */
-			etupSize = HNSW_ELEMENT_TUPLE_SIZE(etup->vec.dim);
+			etupSize = HNSW_ELEMENT_TUPLE_SIZE(value);
 			ntupSize = HNSW_NEIGHBOR_TUPLE_SIZE(etup->level, vacuumstate->m);
 
 			/* Get neighbor page */
@@ -532,7 +536,7 @@ MarkDeleted(HnswVacuumState * vacuumstate)
 
 			/* Overwrite element */
 			etup->deleted = 1;
-			MemSet(&etup->vec.x, 0, etup->vec.dim * sizeof(float));
+			MemSet(&etup->value, 0, VARSIZE_ANY(value));
 
 			/* Overwrite neighbors */
 			for (int i = 0; i < ntup->count; i++)

src/ivfbuild.c

@@ -506,11 +506,9 @@ CreateListPages(Relation index, VectorArray centers, int dimensions,
 	Buffer		buf;
 	Page		page;
 	GenericXLogState *state;
-	Size		listSize;
 	IvfflatList list;
 
-	listSize = MAXALIGN(IVFFLAT_LIST_SIZE(dimensions));
-	list = palloc(listSize);
+	list = palloc0(BLCKSZ);
 
 	buf = IvfflatNewBuffer(index, forkNum);
 	IvfflatInitRegisterPage(index, &buf, &page, &state);
@@ -518,11 +516,13 @@ CreateListPages(Relation index, VectorArray centers, int dimensions,
 	for (int i = 0; i < lists; i++)
 	{
 		OffsetNumber offno;
+		Datum		center = PointerGetDatum(VectorArrayGet(centers, i));
+		Size		listSize = MAXALIGN(IVFFLAT_LIST_SIZE(center));
 
 		/* Load list */
 		list->startPage = InvalidBlockNumber;
 		list->insertPage = InvalidBlockNumber;
-		memcpy(&list->center, VectorArrayGet(centers, i), VECTOR_SIZE(dimensions));
+		memcpy(&list->center, DatumGetPointer(center), VARSIZE_ANY(center));
 
 		/* Ensure free space */
 		if (PageGetFreeSpace(page) < listSize)

src/ivfflat.h

@@ -52,7 +52,7 @@
 #define PROGRESS_IVFFLAT_PHASE_ASSIGN	3
 #define PROGRESS_IVFFLAT_PHASE_LOAD		4
 
-#define IVFFLAT_LIST_SIZE(_dim)	(offsetof(IvfflatListData, center) + VECTOR_SIZE(_dim))
+#define IVFFLAT_LIST_SIZE(_datum)	(offsetof(IvfflatListData, center) + VARSIZE_ANY(_datum))
 
 #define IvfflatPageGetOpaque(page)	((IvfflatPageOpaque) PageGetSpecialPointer(page))
 #define IvfflatPageGetMeta(page)	((IvfflatMetaPageData *) PageGetContents(page))
@@ -229,7 +229,7 @@ typedef struct IvfflatListData
 {
 	BlockNumber startPage;
 	BlockNumber insertPage;
-	Vector		center;
+	char		center[FLEXIBLE_ARRAY_MEMBER];
 }			IvfflatListData;
 
 typedef IvfflatListData * IvfflatList;

test/expected/functions.out

@@ -54,21 +54,21 @@ SELECT vector_norm('[3e37,4e37]')::real;
        5e+37
 (1 row)
 
-SELECT l2_distance('[0,0]', '[3,4]');
+SELECT l2_distance('[0,0]'::vector, '[3,4]');
  l2_distance 
 -------------
            5
 (1 row)
 
-SELECT l2_distance('[0,0]', '[0,1]');
+SELECT l2_distance('[0,0]'::vector, '[0,1]');
  l2_distance 
 -------------
            1
 (1 row)
 
-SELECT l2_distance('[1,2]', '[3]');
+SELECT l2_distance('[1,2]'::vector, '[3]');
 ERROR:  different vector dimensions 2 and 1
-SELECT l2_distance('[3e38]', '[-3e38]');
+SELECT l2_distance('[3e38]'::vector, '[-3e38]');
  l2_distance 
 -------------
     Infinity

test/sql/functions.sql

@@ -13,10 +13,10 @@ SELECT vector_norm('[3,4]');
 SELECT vector_norm('[0,1]');
 SELECT vector_norm('[3e37,4e37]')::real;
 
-SELECT l2_distance('[0,0]', '[3,4]');
-SELECT l2_distance('[0,0]', '[0,1]');
-SELECT l2_distance('[1,2]', '[3]');
-SELECT l2_distance('[3e38]', '[-3e38]');
+SELECT l2_distance('[0,0]'::vector, '[3,4]');
+SELECT l2_distance('[0,0]'::vector, '[0,1]');
+SELECT l2_distance('[1,2]'::vector, '[3]');
+SELECT l2_distance('[3e38]'::vector, '[-3e38]');
 
 SELECT inner_product('[1,2]', '[3,4]');
 SELECT inner_product('[1,2]', '[3]');

test/t/019_hnsw_array.pl

@@ -0,0 +1,93 @@
+use strict;
+use warnings;
+use PostgresNode;
+use TestLib;
+use Test::More;
+
+my $node;
+my @queries = ();
+my @expected;
+my $limit = 20;
+
+sub test_recall
+{
+	my ($min, $operator) = @_;
+	my $correct = 0;
+	my $total = 0;
+
+	my $explain = $node->safe_psql("postgres", qq(
+		SET enable_seqscan = off;
+		EXPLAIN ANALYZE SELECT i FROM tst ORDER BY v $operator '$queries[0]' LIMIT $limit;
+	));
+	like($explain, qr/Index Scan/);
+
+	for my $i (0 .. $#queries)
+	{
+		my $actual = $node->safe_psql("postgres", qq(
+			SET enable_seqscan = off;
+			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 int4, v float4[3]);");
+$node->safe_psql("postgres",
+	"INSERT INTO tst SELECT i, ARRAY[random(), random(), random()] FROM generate_series(1, 10000) i;"
+);
+
+# 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 = ("float4_l2_ops");
+
+for my $i (0 .. $#operators)
+{
+	my $operator = $operators[$i];
+	my $opclass = $opclasses[$i];
+
+	# Get exact results
+	@expected = ();
+	foreach (@queries)
+	{
+		my $res = $node->safe_psql("postgres", "SELECT i FROM tst ORDER BY v $operator '$_' LIMIT $limit;");
+		push(@expected, $res);
+	}
+
+	# Add index
+	$node->safe_psql("postgres", "CREATE INDEX ON tst USING hnsw (v $opclass) WITH (dimensions = 3);");
+
+	my $min = $operator eq "<#>" ? 0.80 : 0.99;
+	test_recall($min, $operator);
+}
+
+done_testing();