Try double

Co-authored-by: Xiaoran Wang <wxiaoran@vmware.com>

.github/workflows/build.yml

@@ -77,23 +77,5 @@ jobs:
           nmake /NOLOGO /F Makefile.win clean && ^
           nmake /NOLOGO /F Makefile.win uninstall
         shell: cmd
-  i386:
-    runs-on: ubuntu-latest
-    container:
-      image: debian:11
-      options: --platform linux/386
-    steps:
-      - run: apt-get update && apt-get install -y build-essential git libipc-run-perl postgresql-13 postgresql-server-dev-13 sudo
-      - run: service postgresql start
-      - run: |
-          git clone https://github.com/${{ github.repository }}.git pgvector
-          cd pgvector
-          git fetch origin ${{ github.ref }}
-          git reset --hard FETCH_HEAD
-          make
-          make install
-          chown -R postgres .
-          sudo -u postgres make installcheck
-          sudo -u postgres make prove_installcheck
-        env:
-          PG_CFLAGS: -Wall -Wextra -Werror -Wno-unused-parameter -Wno-sign-compare
+      - if: ${{ failure() }}
+        run: cat regression.diffs

CHANGELOG.md

@@ -3,9 +3,12 @@
 - Added HNSW index type
 - Added support for parallel index builds
 - Added `l1_distance` function
+- Added `normalize_l2` function
 - Added element-wise multiplication for vectors
 - Added `sum` aggregate
 - Improved performance of distance functions
+- Fixed out of range results for cosine distance
+- Fixed results for NULL and NaN distances
 
 ## 0.4.4 (2023-06-12)
 

Dockerfile

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

README.md

@@ -159,15 +159,6 @@ By default, pgvector performs exact nearest neighbor search, which provides perf
 
 You can add an index to use approximate nearest neighbor search, which trades some recall for performance. Unlike typical indexes, you will see different results for queries after adding an approximate index.
 
-Supported index types are:
-
-- [IVFFlat](#ivfflat)
-- [HNSW](#hnsw) (*coming in 0.5.0*)
-
-## IVFFlat
-
-An IVFFlat index clusters vectors into lists, and then searches a subset of those lists. It has faster build times and uses less memory than HNSW, but has lower query performance.
-
 Three keys to achieving good recall are:
 
 1. Create the index *after* the table has some data
@@ -215,57 +206,7 @@ SELECT ...
 COMMIT;
 ```
 
-## HNSW
-
-An HNSW index creates a multilayer graph between vectors. It has slower build times and uses more memory than IVFFlat, but has better query performance. There’s no training step like IVFFlat, so the index can be created without any data in the table.
-
-The options for HNSW are:
-
-- `m` - the max number of connections per layer (the bottom layer uses `2 * m`)
-- `ef_construction` - the size of the dynamic candidate list for constructing the graph
-
-Add an index for each distance function you want to use.
-
-L2 distance
-
-```sql
-CREATE INDEX ON items USING hnsw (embedding vector_l2_ops) WITH (m = 16, ef_construction = 40);
-```
-
-Inner product
-
-```sql
-CREATE INDEX ON items USING hnsw (embedding vector_ip_ops) WITH (m = 16, ef_construction = 40);
-```
-
-Cosine distance
-
-```sql
-CREATE INDEX ON items USING hnsw (embedding vector_cosine_ops) WITH (m = 16, ef_construction = 40);
-```
-
-Vectors with up to 2,000 dimensions can be indexed.
-
-### Query Options
-
-Specify the size of the dynamic candidate list for search (40 by default)
-
-```sql
-SET hnsw.ef_search = 100;
-```
-
-A higher value provides better recall at the cost of speed.
-
-Use `SET LOCAL` inside a transaction to set it for a single query
-
-```sql
-BEGIN;
-SET LOCAL hnsw.ef_search = 100;
-SELECT ...
-COMMIT;
-```
-
-## Indexing Progress
+### Indexing Progress
 
 Check [indexing progress](https://www.postgresql.org/docs/current/progress-reporting.html#CREATE-INDEX-PROGRESS-REPORTING) with Postgres 12+
 
@@ -276,8 +217,8 @@ SELECT phase, tuples_done, tuples_total FROM pg_stat_progress_create_index;
 The phases are:
 
 1. `initializing`
-2. `performing k-means` (IVFFlat only)
-3. `sorting tuples` (IVFFlat only)
+2. `performing k-means`
+3. `sorting tuples`
 4. `loading tuples`
 
 Note: `tuples_done` and `tuples_total` are only populated during the `loading tuples` phase
@@ -342,7 +283,7 @@ SELECT * FROM items ORDER BY embedding <#> '[3,1,2]' LIMIT 5;
 
 ### Approximate Search
 
-To speed up queries with an IVFFlat index, increase the number of inverted lists (at the expense of recall).
+To speed up queries with an index, increase the number of inverted lists (at the expense of recall).
 
 ```sql
 CREATE INDEX ON items USING ivfflat (embedding vector_l2_ops) WITH (lists = 1000);
@@ -357,6 +298,7 @@ Language | Libraries / Examples
 C++ | [pgvector-cpp](https://github.com/pgvector/pgvector-cpp)
 C# | [pgvector-dotnet](https://github.com/pgvector/pgvector-dotnet)
 Crystal | [pgvector-crystal](https://github.com/pgvector/pgvector-crystal)
+Dart | [pgvector-dart](https://github.com/pgvector/pgvector-dart)
 Elixir | [pgvector-elixir](https://github.com/pgvector/pgvector-elixir)
 Go | [pgvector-go](https://github.com/pgvector/pgvector-go)
 Haskell | [pgvector-haskell](https://github.com/pgvector/pgvector-haskell)
@@ -417,7 +359,7 @@ or choose to store vectors inline:
 ALTER TABLE items ALTER COLUMN embedding SET STORAGE PLAIN;
 ```
 
-#### Why are there less results for a query after adding an IVFFlat index?
+#### Why are there less results for a query after adding an index?
 
 The index was likely created with too little data for the number of lists. Drop the index until the table has more data.
 
@@ -450,6 +392,7 @@ cosine_distance(vector, vector) → double precision | cosine distance
 inner_product(vector, vector) → double precision | inner product
 l2_distance(vector, vector) → double precision | Euclidean distance
 l1_distance(vector, vector) → double precision | taxicab distance [unreleased]
+normalize_l2(vector) → vector | normalize with Euclidean norm [unreleased]
 vector_dims(vector) → integer | number of dimensions
 vector_norm(vector) → double precision | Euclidean norm
 
@@ -490,7 +433,15 @@ Note: Replace `15` with your Postgres server version
 
 ### Windows
 
-Support for Windows is currently experimental. Use `nmake` to build:
+Support for Windows is currently experimental. Ensure [C++ support in Visual Studio](https://learn.microsoft.com/en-us/cpp/build/building-on-the-command-line?view=msvc-170#download-and-install-the-tools) is installed, and run:
+
+```cmd
+call "C:\Program Files\Microsoft Visual Studio\2022\Community\VC\Auxiliary\Build\vcvars64.bat"
+```
+
+Note: The exact path will vary depending on your Visual Studio version and edition
+
+Then use `nmake` to build:
 
 ```cmd
 set "PGROOT=C:\Program Files\PostgreSQL\15"
@@ -517,6 +468,7 @@ You can also build the image manually:
 ```sh
 git clone --branch v0.4.4 https://github.com/pgvector/pgvector.git
 cd pgvector
+git cherry-pick 237a6df
 docker build --build-arg PG_MAJOR=15 -t myuser/pgvector .
 ```
 
@@ -618,7 +570,7 @@ Thanks to:
 
 - [PASE: PostgreSQL Ultra-High-Dimensional Approximate Nearest Neighbor Search Extension](https://dl.acm.org/doi/pdf/10.1145/3318464.3386131)
 - [Faiss: A Library for Efficient Similarity Search and Clustering of Dense Vectors](https://github.com/facebookresearch/faiss)
-- [Using the Triangle Inequality to Accelerate k-means](https://www.aaai.org/Papers/ICML/2003/ICML03-022.pdf)
+- [Using the Triangle Inequality to Accelerate k-means](https://cdn.aaai.org/ICML/2003/ICML03-022.pdf)
 - [k-means++: The Advantage of Careful Seeding](https://theory.stanford.edu/~sergei/papers/kMeansPP-soda.pdf)
 - [Concept Decompositions for Large Sparse Text Data using Clustering](https://www.cs.utexas.edu/users/inderjit/public_papers/concept_mlj.pdf)
 - [Efficient and Robust Approximate Nearest Neighbor Search using Hierarchical Navigable Small World Graphs](https://arxiv.org/ftp/arxiv/papers/1603/1603.09320.pdf)

sql/vector--0.4.4--0.5.0.sql

@@ -4,6 +4,9 @@
 CREATE FUNCTION l1_distance(vector, vector) RETURNS float8
 	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
 
+CREATE FUNCTION normalize_l2(vector) RETURNS vector
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
 CREATE FUNCTION vector_mul(vector, vector) RETURNS vector
 	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
 

sql/vector.sql

@@ -49,6 +49,9 @@ CREATE FUNCTION vector_dims(vector) RETURNS integer
 CREATE FUNCTION vector_norm(vector) RETURNS float8
 	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
 
+CREATE FUNCTION normalize_l2(vector) RETURNS vector
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
 CREATE FUNCTION vector_add(vector, vector) RETURNS vector
 	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
 

src/hnsw.h

@@ -49,7 +49,7 @@
 #define PROGRESS_HNSW_PHASE_LOAD		2
 
 #define HNSW_ELEMENT_TUPLE_SIZE(_dim)	MAXALIGN(offsetof(HnswElementTupleData, vec) + VECTOR_SIZE(_dim))
-#define HNSW_NEIGHBOR_TUPLE_SIZE(level, m)	MAXALIGN(offsetof(HnswNeighborTupleData, neighbors) + ((level) + 2) * (m) * sizeof(HnswNeighborTupleItem))
+#define HNSW_NEIGHBOR_TUPLE_SIZE(level, m)	MAXALIGN(offsetof(HnswNeighborTupleData, indextids) + ((level) + 2) * (m) * sizeof(ItemPointerData))
 
 #define HnswPageGetOpaque(page)	((HnswPageOpaque) PageGetSpecialPointer(page))
 #define HnswPageGetMeta(page)	((HnswMetaPageData *) PageGetContents(page))
@@ -71,6 +71,9 @@
 #define HnswGetLayerM(m, layer) (layer == 0 ? m * 2 : m)
 #define HnswGetMl(m) (1 / log(m))
 
+/* Ensure fits in uint8 */
+#define HnswGetMaxLevel(m) Min(((BLCKSZ - MAXALIGN(SizeOfPageHeaderData) - MAXALIGN(sizeof(HnswPageOpaqueData)) - offsetof(HnswNeighborTupleData, indextids) - sizeof(ItemIdData)) / (sizeof(ItemPointerData)) / m) - 2, 255)
+
 /* Variables */
 extern int	hnsw_ef_search;
 
@@ -197,19 +200,12 @@ typedef struct HnswElementTupleData
 
 typedef HnswElementTupleData * HnswElementTuple;
 
-typedef struct HnswNeighborTupleItem
-{
-	ItemPointerData indextid;
-	uint16		unused;
-	float		distance;		/* improves performance of inserts */
-}			HnswNeighborTupleItem;
-
 typedef struct HnswNeighborTupleData
 {
 	uint8		type;
 	uint8		unused;
 	uint16		count;
-	HnswNeighborTupleItem neighbors[FLEXIBLE_ARRAY_MEMBER];
+	ItemPointerData indextids[FLEXIBLE_ARRAY_MEMBER];
 }			HnswNeighborTupleData;
 
 typedef HnswNeighborTupleData * HnswNeighborTuple;
@@ -295,7 +291,4 @@ void		hnswrescan(IndexScanDesc scan, ScanKey keys, int nkeys, ScanKey orderbys,
 bool		hnswgettuple(IndexScanDesc scan, ScanDirection dir);
 void		hnswendscan(IndexScanDesc scan);
 
-/* Ensure fits in uint8 */
-#define HnswGetMaxLevel(m) Min(((BLCKSZ - MAXALIGN(SizeOfPageHeaderData) - MAXALIGN(sizeof(HnswPageOpaqueData)) - offsetof(HnswNeighborTupleData, neighbors) - sizeof(ItemIdData)) / (sizeof(HnswNeighborTupleItem)) / m) - 2, 255)
-
 #endif

src/hnswinsert.c

@@ -317,11 +317,10 @@ UpdateNeighborPages(Relation index, HnswElement e, int m, List *updates)
 		/* Make robust to issues */
 		if (idx < ntup->count)
 		{
-			HnswNeighborTupleItem *neighbor = &ntup->neighbors[idx];
+			ItemPointer indextid = &ntup->indextids[idx];
 
 			/* Update neighbor */
-			ItemPointerSet(&neighbor->indextid, e->blkno, e->offno);
-			neighbor->distance = update->hc.distance;
+			ItemPointerSet(indextid, e->blkno, e->offno);
 
 			/* Overwrite tuple */
 			if (!PageIndexTupleOverwrite(page, offno, (Item) ntup, ntupSize))

src/hnswutils.c

@@ -309,20 +309,16 @@ HnswSetNeighborTuple(HnswNeighborTuple ntup, HnswElement e, int m)
 
 		for (int i = 0; i < lm; i++)
 		{
-			HnswNeighborTupleItem *neighbor = &ntup->neighbors[idx++];
+			ItemPointer indextid = &ntup->indextids[idx++];
 
 			if (i < neighbors->length)
 			{
 				HnswCandidate *hc = &neighbors->items[i];
 
-				ItemPointerSet(&neighbor->indextid, hc->element->blkno, hc->element->offno);
-				neighbor->distance = hc->distance;
+				ItemPointerSet(indextid, hc->element->blkno, hc->element->offno);
 			}
 			else
-			{
-				ItemPointerSetInvalid(&neighbor->indextid);
-				neighbor->distance = NAN;
-			}
+				ItemPointerSetInvalid(indextid);
 		}
 	}
 
@@ -352,15 +348,15 @@ LoadNeighborsFromPage(HnswElement element, Relation index, Page page)
 		HnswElement e;
 		int			level;
 		HnswCandidate *hc;
-		HnswNeighborTupleItem *neighbor;
+		ItemPointer indextid;
 		HnswNeighborArray *neighbors;
 
-		neighbor = &ntup->neighbors[i];
+		indextid = &ntup->indextids[i];
 
-		if (!ItemPointerIsValid(&neighbor->indextid))
+		if (!ItemPointerIsValid(indextid))
 			continue;
 
-		e = InitElementFromBlock(ItemPointerGetBlockNumber(&neighbor->indextid), ItemPointerGetOffsetNumber(&neighbor->indextid));
+		e = InitElementFromBlock(ItemPointerGetBlockNumber(indextid), ItemPointerGetOffsetNumber(indextid));
 
 		/* Calculate level based on offset */
 		level = element->level - i / m;
@@ -370,7 +366,6 @@ LoadNeighborsFromPage(HnswElement element, Relation index, Page page)
 		neighbors = &element->neighbors[level];
 		hc = &neighbors->items[neighbors->length++];
 		hc->element = e;
-		hc->distance = neighbor->distance;
 	}
 }
 
@@ -850,33 +845,37 @@ UpdateConnections(HnswElement element, List *neighbors, int m, int lc, List **up
 			HnswCandidate *pruned = NULL;
 			List	   *c = NIL;
 
-			/* Add and sort candidates */
-			for (int i = 0; i < currentNeighbors->length; i++)
-				c = lappend(c, &currentNeighbors->items[i]);
-			c = lappend(c, &hc2);
-			list_sort(c, CompareCandidateDistances);
-
 			/* Load elements on insert */
 			if (index != NULL)
 			{
+				Datum		q = PointerGetDatum(hc->element->vec);
+
 				for (int i = 0; i < currentNeighbors->length; i++)
 				{
-					if (currentNeighbors->items[i].element->vec == NULL)
-					{
-						HnswLoadElement(currentNeighbors->items[i].element, NULL, NULL, index, procinfo, collation, true);
+					HnswCandidate *hc3 = &currentNeighbors->items[i];
 
-						/* Prune deleted element */
-						if (currentNeighbors->items[i].element->deleted)
-						{
-							pruned = &currentNeighbors->items[i];
-							break;
-						}
+					if (hc3->element->vec == NULL)
+						HnswLoadElement(hc3->element, &hc3->distance, &q, index, procinfo, collation, true);
+					else
+						hc3->distance = GetCandidateDistance(hc3, q, procinfo, collation);
+
+					/* Prune element if being deleted */
+					if (list_length(hc3->element->heaptids) == 0)
+					{
+						pruned = &currentNeighbors->items[i];
+						break;
 					}
 				}
 			}
 
 			if (pruned == NULL)
 			{
+				/* Add and sort candidates */
+				for (int i = 0; i < currentNeighbors->length; i++)
+					c = lappend(c, &currentNeighbors->items[i]);
+				c = lappend(c, &hc2);
+				list_sort(c, CompareCandidateDistances);
+
 				SelectNeighbors(c, m, lc, procinfo, collation, &pruned);
 
 				/* Should not happen */

src/hnswvacuum.c

@@ -156,13 +156,13 @@ NeedsUpdated(HnswVacuumState * vacuumstate, HnswElement element)
 	/* Check neighbors */
 	for (int i = 0; i < ntup->count; i++)
 	{
-		HnswNeighborTupleItem *neighbor = &ntup->neighbors[i];
+		ItemPointer indextid = &ntup->indextids[i];
 
-		if (!ItemPointerIsValid(&neighbor->indextid))
+		if (!ItemPointerIsValid(indextid))
 			continue;
 
 		/* Check if in deleted list */
-		if (DeletedContains(vacuumstate->deleted, &neighbor->indextid))
+		if (DeletedContains(vacuumstate->deleted, indextid))
 		{
 			needsUpdated = true;
 			break;
@@ -453,10 +453,7 @@ MarkDeleted(HnswVacuumState * vacuumstate)
 
 			/* Overwrite neighbors */
 			for (int i = 0; i < ntup->count; i++)
-			{
-				ItemPointerSetInvalid(&ntup->neighbors[i].indextid);
-				ntup->neighbors[i].distance = NAN;
-			}
+				ItemPointerSetInvalid(&ntup->indextids[i]);
 
 			/* Overwrite element tuple */
 			if (!PageIndexTupleOverwrite(page, offno, (Item) etup, etupSize))

src/ivfscan.c

@@ -180,6 +180,29 @@ GetScanItems(IndexScanDesc scan, Datum value)
 	tuplesort_performsort(so->sortstate);
 }
 
+/*
+ * Get dimensions from metapage
+ */
+static int
+GetDimensions(Relation index)
+{
+	Buffer		buf;
+	Page		page;
+	IvfflatMetaPage metap;
+	int			dimensions;
+
+	buf = ReadBuffer(index, IVFFLAT_METAPAGE_BLKNO);
+	LockBuffer(buf, BUFFER_LOCK_SHARE);
+	page = BufferGetPage(buf);
+	metap = IvfflatPageGetMeta(page);
+
+	dimensions = metap->dimensions;
+
+	UnlockReleaseBuffer(buf);
+
+	return dimensions;
+}
+
 /*
  * Prepare for an index scan
  */
@@ -285,21 +308,19 @@ ivfflatgettuple(IndexScanDesc scan, ScanDirection dir)
 		if (scan->orderByData == NULL)
 			elog(ERROR, "cannot scan ivfflat index without order");
 
-		/* No items will match if null */
 		if (scan->orderByData->sk_flags & SK_ISNULL)
-			return false;
-
-		value = scan->orderByData->sk_argument;
-
-		/* Value should not be compressed or toasted */
-		Assert(!VARATT_IS_COMPRESSED(DatumGetPointer(value)));
-		Assert(!VARATT_IS_EXTENDED(DatumGetPointer(value)));
-
-		if (so->normprocinfo != NULL)
+			value = PointerGetDatum(InitVector(GetDimensions(scan->indexRelation)));
+		else
 		{
-			/* No items will match if normalization fails */
-			if (!IvfflatNormValue(so->normprocinfo, so->collation, &value, NULL))
-				return false;
+			value = scan->orderByData->sk_argument;
+
+			/* Value should not be compressed or toasted */
+			Assert(!VARATT_IS_COMPRESSED(DatumGetPointer(value)));
+			Assert(!VARATT_IS_EXTENDED(DatumGetPointer(value)));
+
+			/* Fine if normalization fails */
+			if (so->normprocinfo != NULL)
+				IvfflatNormValue(so->normprocinfo, so->collation, &value, NULL);
 		}
 
 		IvfflatBench("GetScanLists", GetScanLists(scan, value));

src/vector.c

@@ -632,6 +632,7 @@ cosine_distance(PG_FUNCTION_ARGS)
 	float		distance = 0.0;
 	float		norma = 0.0;
 	float		normb = 0.0;
+	double		similarity;
 
 	CheckDims(a, b);
 
@@ -644,7 +645,21 @@ cosine_distance(PG_FUNCTION_ARGS)
 	}
 
 	/* Use sqrt(a * b) over sqrt(a) * sqrt(b) */
-	PG_RETURN_FLOAT8(1.0 - ((double) distance / sqrt((double) norma * (double) normb)));
+	similarity = (double) distance / sqrt((double) norma * (double) normb);
+
+#ifdef _MSC_VER
+	/* /fp:fast may not propagate NaN */
+	if (isnan(similarity))
+		PG_RETURN_FLOAT8(NAN);
+#endif
+
+	/* Keep in range */
+	if (similarity > 1)
+		similarity = 1.0;
+	else if (similarity < -1)
+		similarity = -1.0;
+
+	PG_RETURN_FLOAT8(1.0 - similarity);
 }
 
 /*
@@ -668,6 +683,7 @@ vector_spherical_distance(PG_FUNCTION_ARGS)
 		dp += a->x[i] * b->x[i];
 
 	distance = (double) dp;
+
 	/* Prevent NaN with acos with loss of precision */
 	if (distance > 1)
 		distance = 1;
@@ -729,6 +745,45 @@ vector_norm(PG_FUNCTION_ARGS)
 	PG_RETURN_FLOAT8(sqrt((double) norm));
 }
 
+/*
+ * Normalize a vector with the L2 norm
+ */
+PGDLLEXPORT PG_FUNCTION_INFO_V1(normalize_l2);
+Datum
+normalize_l2(PG_FUNCTION_ARGS)
+{
+	Vector	   *a = PG_GETARG_VECTOR_P(0);
+	float	   *ax = a->x;
+	double		norm = 0.0;
+	Vector	   *result;
+	float	   *rx;
+
+	result = InitVector(a->dim);
+	rx = result->x;
+
+	/* Auto-vectorized */
+	for (int i = 0; i < a->dim; i++)
+		norm += (double) ax[i] * (double) ax[i];
+
+	norm = sqrt(norm);
+
+	if (norm > 0)
+	{
+		/* Auto-vectorized */
+		for (int i = 0, imax = a->dim; i < imax; i++)
+			rx[i] = ax[i] / norm;
+
+		/* Check for overflow */
+		for (int i = 0, imax = a->dim; i < imax; i++)
+		{
+			if (isinf(rx[i]))
+				float_overflow_error();
+		}
+	}
+
+	PG_RETURN_POINTER(result);
+}
+
 /*
  * Add vectors
  */

test/expected/functions.out

@@ -48,6 +48,36 @@ SELECT vector_norm('[0,1]');
            1
 (1 row)
 
+SELECT normalize_l2('[3,4]');
+ normalize_l2 
+--------------
+ [0.6,0.8]
+(1 row)
+
+SELECT normalize_l2('[3,0]');
+ normalize_l2 
+--------------
+ [1,0]
+(1 row)
+
+SELECT normalize_l2('[0,0.1]');
+ normalize_l2 
+--------------
+ [0,1]
+(1 row)
+
+SELECT normalize_l2('[0,0]');
+ normalize_l2 
+--------------
+ [0,0]
+(1 row)
+
+SELECT normalize_l2('[3e38]');
+ normalize_l2 
+--------------
+ [1]
+(1 row)
+
 SELECT l2_distance('[0,0]', '[3,4]');
  l2_distance 
 -------------
@@ -62,6 +92,12 @@ SELECT l2_distance('[0,0]', '[0,1]');
 
 SELECT l2_distance('[1,2]', '[3]');
 ERROR:  different vector dimensions 2 and 1
+SELECT l2_distance('[3e38]', '[-3e38]');
+ l2_distance 
+-------------
+    Infinity
+(1 row)
+
 SELECT inner_product('[1,2]', '[3,4]');
  inner_product 
 ---------------
@@ -70,6 +106,12 @@ SELECT inner_product('[1,2]', '[3,4]');
 
 SELECT inner_product('[1,2]', '[3]');
 ERROR:  different vector dimensions 2 and 1
+SELECT inner_product('[3e38]', '[3e38]');
+ inner_product 
+---------------
+      Infinity
+(1 row)
+
 SELECT cosine_distance('[1,2]', '[2,4]');
  cosine_distance 
 -----------------
@@ -96,6 +138,24 @@ SELECT cosine_distance('[1,1]', '[-1,-1]');
 
 SELECT cosine_distance('[1,2]', '[3]');
 ERROR:  different vector dimensions 2 and 1
+SELECT cosine_distance('[1,1]', '[1.1,1.1]');
+ cosine_distance 
+-----------------
+               0
+(1 row)
+
+SELECT cosine_distance('[1,1]', '[-1.1,-1.1]');
+ cosine_distance 
+-----------------
+               2
+(1 row)
+
+SELECT cosine_distance('[3e38]', '[3e38]');
+ cosine_distance 
+-----------------
+             NaN
+(1 row)
+
 SELECT l1_distance('[0,0]', '[3,4]');
  l1_distance 
 -------------
@@ -110,6 +170,12 @@ SELECT l1_distance('[0,0]', '[0,1]');
 
 SELECT l1_distance('[1,2]', '[3]');
 ERROR:  different vector dimensions 2 and 1
+SELECT l1_distance('[3e38]', '[-3e38]');
+ l1_distance 
+-------------
+    Infinity
+(1 row)
+
 SELECT avg(v) FROM unnest(ARRAY['[1,2,3]'::vector, '[3,5,7]']) v;
     avg    
 -----------

test/expected/ivfflat_cosine.out

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

test/expected/ivfflat_ip.out

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

test/expected/ivfflat_l2.out

@@ -13,9 +13,13 @@ SELECT * FROM t ORDER BY val <-> '[3,3,3]';
 (4 rows)
 
 SELECT * FROM t ORDER BY val <-> (SELECT NULL::vector);
- val 
------
-(0 rows)
+   val   
+---------
+ [0,0,0]
+ [1,1,1]
+ [1,2,3]
+ [1,2,4]
+(4 rows)
 
 SELECT COUNT(*) FROM t;
  count 

test/sql/functions.sql

@@ -12,22 +12,34 @@ SELECT round(vector_norm('[1,1]')::numeric, 5);
 SELECT vector_norm('[3,4]');
 SELECT vector_norm('[0,1]');
 
+SELECT normalize_l2('[3,4]');
+SELECT normalize_l2('[3,0]');
+SELECT normalize_l2('[0,0.1]');
+SELECT normalize_l2('[0,0]');
+SELECT normalize_l2('[3e38]');
+
 SELECT l2_distance('[0,0]', '[3,4]');
 SELECT l2_distance('[0,0]', '[0,1]');
 SELECT l2_distance('[1,2]', '[3]');
+SELECT l2_distance('[3e38]', '[-3e38]');
 
 SELECT inner_product('[1,2]', '[3,4]');
 SELECT inner_product('[1,2]', '[3]');
+SELECT inner_product('[3e38]', '[3e38]');
 
 SELECT cosine_distance('[1,2]', '[2,4]');
 SELECT cosine_distance('[1,2]', '[0,0]');
 SELECT cosine_distance('[1,1]', '[1,1]');
 SELECT cosine_distance('[1,1]', '[-1,-1]');
 SELECT cosine_distance('[1,2]', '[3]');
+SELECT cosine_distance('[1,1]', '[1.1,1.1]');
+SELECT cosine_distance('[1,1]', '[-1.1,-1.1]');
+SELECT cosine_distance('[3e38]', '[3e38]');
 
 SELECT l1_distance('[0,0]', '[3,4]');
 SELECT l1_distance('[0,0]', '[0,1]');
 SELECT l1_distance('[1,2]', '[3]');
+SELECT l1_distance('[3e38]', '[-3e38]');
 
 SELECT avg(v) FROM unnest(ARRAY['[1,2,3]'::vector, '[3,5,7]']) v;
 SELECT avg(v) FROM unnest(ARRAY['[1,2,3]'::vector, '[3,5,7]', NULL]) v;

test/sql/ivfflat_cosine.sql

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

test/sql/ivfflat_ip.sql

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