Added random_vector function

.github/workflows/build.yml

@@ -17,7 +17,7 @@ jobs:
           - postgres: 12
             os: ubuntu-20.04
           - postgres: 11
-            os: ubuntu-20.04
+            os: ubuntu-18.04
     steps:
       - uses: actions/checkout@v3
       - uses: ankane/setup-postgres@v1

.gitignore

@@ -1,5 +1,4 @@
 /dist/
-/log/
 /results/
 /tmp_check/
 /sql/vector--?.?.?.sql
@@ -8,7 +7,6 @@ regression.*
 *.so
 *.bc
 *.dll
-*.dylib
 *.obj
 *.lib
 *.exp

CHANGELOG.md

@@ -1,12 +1,6 @@
-## 0.4.2 (unreleased)
+## 0.4.1 (unreleased)
 
-- Added notice when index created with little data
-- Fixed installation error with Postgres 12.0-12.2
-
-## 0.4.1 (2023-03-21)
-
-- Improved performance of cosine distance
-- Fixed index scan count
+- Added `random_vector` function
 
 ## 0.4.0 (2023-01-11)
 

Dockerfile

@@ -1,11 +1,9 @@
-ARG PG_MAJOR=15
-FROM postgres:$PG_MAJOR
-ARG PG_MAJOR
+FROM postgres:15
 
 COPY . /tmp/pgvector
 
 RUN apt-get update && \
-		apt-get install -y --no-install-recommends build-essential postgresql-server-dev-$PG_MAJOR && \
+		apt-get install -y --no-install-recommends build-essential postgresql-server-dev-15 && \
 		cd /tmp/pgvector && \
 		make clean && \
 		make OPTFLAGS="" && \
@@ -13,6 +11,6 @@ RUN apt-get update && \
 		mkdir /usr/share/doc/pgvector && \
 		cp LICENSE README.md /usr/share/doc/pgvector && \
 		rm -r /tmp/pgvector && \
-		apt-get remove -y build-essential postgresql-server-dev-$PG_MAJOR && \
+		apt-get remove -y build-essential postgresql-server-dev-15 && \
 		apt-get autoremove -y && \
 		rm -rf /var/lib/apt/lists/*

META.json

@@ -2,7 +2,7 @@
 	"name": "vector",
 	"abstract": "Open-source vector similarity search for Postgres",
 	"description": "Supports L2 distance, inner product, and cosine distance",
-	"version": "0.4.1",
+	"version": "0.4.0",
 	"maintainer": [
 		"Andrew Kane <andrew@ankane.org>"
 	],
@@ -20,7 +20,7 @@
 		"vector": {
 			"file": "sql/vector.sql",
 			"docfile": "README.md",
-			"version": "0.4.1",
+			"version": "0.4.0",
 			"abstract": "Open-source vector similarity search for Postgres"
 		}
 	},

Makefile

@@ -1,5 +1,5 @@
 EXTENSION = vector
-EXTVERSION = 0.4.1
+EXTVERSION = 0.4.0
 
 MODULE_big = vector
 DATA = $(wildcard sql/*--*.sql)
@@ -14,7 +14,6 @@ OPTFLAGS = -march=native
 # Mac ARM doesn't support -march=native
 ifeq ($(shell uname -s), Darwin)
 	ifeq ($(shell uname -p), arm)
-		# no difference with -march=armv8.5-a
 		OPTFLAGS =
 	endif
 endif
@@ -62,4 +61,4 @@ dist:
 .PHONY: docker
 
 docker:
-	docker build --pull --no-cache --platform linux/amd64 -t ankane/pgvector:latest .
+	docker build --pull --no-cache -t ankane/pgvector:latest .

Makefile.win

@@ -1,5 +1,5 @@
 EXTENSION = vector
-EXTVERSION = 0.4.1
+EXTVERSION = 0.4.0
 
 OBJS = src\ivfbuild.obj src\ivfflat.obj src\ivfinsert.obj src\ivfkmeans.obj src\ivfscan.obj src\ivfutils.obj src\ivfvacuum.obj src\vector.obj
 

README.md

@@ -2,11 +2,13 @@
 
 Open-source vector similarity search for Postgres
 
-Supports
+```sql
+CREATE TABLE items (embedding vector(3));
+CREATE INDEX ON items USING ivfflat (embedding vector_l2_ops);
+SELECT * FROM items ORDER BY embedding <-> '[1,2,3]' LIMIT 5;
+```
 
-- exact and approximate nearest neighbor search
-- L2 distance, inner product, and cosine distance
-- any [language](#languages) with a Postgres client
+Supports L2 distance, inner product, and cosine distance
 
 [![Build Status](https://github.com/pgvector/pgvector/workflows/build/badge.svg?branch=master)](https://github.com/pgvector/pgvector/actions)
 
@@ -15,8 +17,7 @@ Supports
 Compile and install the extension (supports Postgres 11+)
 
 ```sh
-cd /tmp
-git clone --branch v0.4.1 https://github.com/pgvector/pgvector.git
+git clone --branch v0.4.0 https://github.com/pgvector/pgvector.git
 cd pgvector
 make
 make install # may need sudo
@@ -28,178 +29,81 @@ Then load it in databases where you want to use it
 CREATE EXTENSION vector;
 ```
 
-See the [installation notes](#installation-notes) if you run into issues
-
-You can also install it with [Docker](#docker), [Homebrew](#homebrew), [PGXN](#pgxn), [Yum](#yum), or [conda-forge](#conda-forge)
+You can also install it with [Docker](#docker), [Homebrew](#homebrew), [PGXN](#pgxn), or [conda-forge](#conda-forge)
 
 ## Getting Started
 
 Create a vector column with 3 dimensions
 
 ```sql
-CREATE TABLE items (id bigserial PRIMARY KEY, embedding vector(3));
+CREATE TABLE items (embedding vector(3));
 ```
 
-Insert vectors
+Insert values
 
 ```sql
-INSERT INTO items (embedding) VALUES ('[1,2,3]'), ('[4,5,6]');
+INSERT INTO items VALUES ('[1,2,3]'), ('[4,5,6]');
 ```
 
-Get the nearest neighbors by L2 distance
+Get the nearest neighbor by L2 distance
 
 ```sql
-SELECT * FROM items ORDER BY embedding <-> '[3,1,2]' LIMIT 5;
+SELECT * FROM items ORDER BY embedding <-> '[3,1,2]' LIMIT 1;
 ```
 
 Also supports inner product (`<#>`) and cosine distance (`<=>`)
 
 Note: `<#>` returns the negative inner product since Postgres only supports `ASC` order index scans on operators
 
-## Storing
-
-Create a new table with a vector column
-
-```sql
-CREATE TABLE items (id bigserial PRIMARY KEY, embedding vector(3));
-```
-
-Or add a vector column to an existing table
-
-```sql
-ALTER TABLE items ADD COLUMN embedding vector(3);
-```
-
-Insert vectors
-
-```sql
-INSERT INTO items (embedding) VALUES ('[1,2,3]'), ('[4,5,6]');
-```
-
-Upsert vectors
-
-```sql
-INSERT INTO items (id, embedding) VALUES (1, '[1,2,3]'), (2, '[4,5,6]')
-    ON CONFLICT (id) DO UPDATE SET embedding = EXCLUDED.embedding;
-```
-
-Update vectors
-
-```sql
-UPDATE items SET embedding = '[1,2,3]' WHERE id = 1;
-```
-
-Delete vectors
-
-```sql
-DELETE FROM items WHERE id = 1;
-```
-
-## Querying
-
-Get the nearest neighbors to a vector
-
-```sql
-SELECT * FROM items ORDER BY embedding <-> '[3,1,2]' LIMIT 5;
-```
-
-Get the nearest neighbors to a row
-
-```sql
-SELECT * FROM items WHERE id != 1 ORDER BY embedding <-> (SELECT embedding FROM items WHERE id = 1) LIMIT 5;
-```
-
-Get rows within a certain distance
-
-```sql
-SELECT * FROM items WHERE embedding <-> '[3,1,2]' < 5;
-```
-
-Note: Combine with `ORDER BY` and `LIMIT` to use an index
-
-#### Distances
-
-Get the distance
-
-```sql
-SELECT embedding <-> '[3,1,2]' AS distance FROM items;
-```
-
-For inner product, multiply by -1 (since `<#>` returns the negative inner product)
-
-```sql
-SELECT (embedding <#> '[3,1,2]') * -1 AS inner_product FROM items;
-```
-
-For cosine similarity, use 1 - cosine distance
-
-```sql
-SELECT 1 - (embedding <=> '[3,1,2]') AS cosine_similarity FROM items;
-```
-
-#### Aggregates
-
-Average vectors
-
-```sql
-SELECT AVG(embedding) FROM items;
-```
-
-Average groups of vectors
-
-```sql
-SELECT category_id, AVG(embedding) FROM items GROUP BY category_id;
-```
-
 ## Indexing
 
-By default, pgvector performs exact nearest neighbor search, which provides perfect recall.
-
-You can add an index to use approximate nearest neighbor search, which trades some recall for performance. Unlike typical indexes, you will see different results for queries after adding an approximate index.
-
-Three keys to achieving good recall are:
-
-1. Create the index *after* the table has some data
-2. Choose an appropriate number of lists - a good place to start is `rows / 1000` for up to 1M rows and `sqrt(rows)` for over 1M rows
-3. When querying, specify an appropriate number of [probes](#query-options) (higher is better for recall, lower is better for speed) - a good place to start is `lists / 10` for up to 1M rows and `sqrt(lists)` for over 1M rows
-
-Add an index for each distance function you want to use.
+Speed up queries with an approximate index. Add an index for each distance function you want to use.
 
 L2 distance
 
 ```sql
-CREATE INDEX ON items USING ivfflat (embedding vector_l2_ops) WITH (lists = 100);
+CREATE INDEX ON items USING ivfflat (embedding vector_l2_ops);
 ```
 
 Inner product
 
 ```sql
-CREATE INDEX ON items USING ivfflat (embedding vector_ip_ops) WITH (lists = 100);
+CREATE INDEX ON items USING ivfflat (embedding vector_ip_ops);
 ```
 
 Cosine distance
 
 ```sql
-CREATE INDEX ON items USING ivfflat (embedding vector_cosine_ops) WITH (lists = 100);
+CREATE INDEX ON items USING ivfflat (embedding vector_cosine_ops);
 ```
 
-Vectors with up to 2,000 dimensions can be indexed.
+Indexes should be created after the table has some data for optimal clustering. Also, unlike typical indexes which only affect performance, you may see different results for queries after adding an approximate index. Vectors with up to 2,000 dimensions can be indexed.
+
+### Index Options
+
+Specify the number of inverted lists (100 by default)
+
+```sql
+CREATE INDEX ON items USING ivfflat (embedding vector_l2_ops) WITH (lists = 100);
+```
+
+A [good place to start](https://github.com/facebookresearch/faiss/issues/112) is `4 * sqrt(rows)`
 
 ### Query Options
 
 Specify the number of probes (1 by default)
 
 ```sql
-SET ivfflat.probes = 10;
+SET ivfflat.probes = 1;
 ```
 
-A higher value provides better recall at the cost of speed, and it can be set to the number of lists for exact nearest neighbor search (at which point the planner won’t use the index)
+A higher value improves recall at the cost of speed.
 
 Use `SET LOCAL` inside a transaction to set it for a single query
 
 ```sql
 BEGIN;
-SET LOCAL ivfflat.probes = 10;
+SET LOCAL ivfflat.probes = 1;
 SELECT ...
 COMMIT;
 ```
@@ -232,7 +136,7 @@ SELECT * FROM items WHERE category_id = 123 ORDER BY embedding <-> '[3,1,2]' LIM
 can be indexed with:
 
 ```sql
-CREATE INDEX ON items USING ivfflat (embedding vector_l2_ops) WITH (lists = 100) WHERE (category_id = 123);
+CREATE INDEX ON items USING ivfflat (embedding vector_l2_ops) WHERE (category_id = 123);
 ```
 
 To index many different values of `category_id`, consider [partitioning](https://www.postgresql.org/docs/current/ddl-partitioning.html) on `category_id`.
@@ -243,75 +147,18 @@ CREATE TABLE items (embedding vector(3), category_id int) PARTITION BY LIST(cate
 
 ## Performance
 
-Use `EXPLAIN ANALYZE` to debug performance.
-
-```sql
-EXPLAIN ANALYZE SELECT * FROM items ORDER BY embedding <-> '[3,1,2]' LIMIT 5;
-```
-
-### Exact Search
-
 To speed up queries without an index, increase `max_parallel_workers_per_gather`.
 
 ```sql
 SET max_parallel_workers_per_gather = 4;
 ```
 
-If vectors are normalized to length 1 (like [OpenAI embeddings](https://platform.openai.com/docs/guides/embeddings/which-distance-function-should-i-use)), use inner product for best performance.
-
-```sql
-SELECT * FROM items ORDER BY embedding <#> '[3,1,2]' LIMIT 5;
-```
-
-### Approximate Search
-
 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);
 ```
 
-## Languages
-
-Use pgvector from any language with a Postgres client. You can even generate and store vectors in one language and query them in another.
-
-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)
-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)
-Java, Scala | [pgvector-java](https://github.com/pgvector/pgvector-java)
-Julia | [pgvector-julia](https://github.com/pgvector/pgvector-julia)
-Lua | [pgvector-lua](https://github.com/pgvector/pgvector-lua)
-Node.js | [pgvector-node](https://github.com/pgvector/pgvector-node)
-Perl | [pgvector-perl](https://github.com/pgvector/pgvector-perl)
-PHP | [pgvector-php](https://github.com/pgvector/pgvector-php)
-Python | [pgvector-python](https://github.com/pgvector/pgvector-python)
-R | [pgvector-r](https://github.com/pgvector/pgvector-r)
-Ruby | [pgvector-ruby](https://github.com/pgvector/pgvector-ruby), [Neighbor](https://github.com/ankane/neighbor)
-Rust | [pgvector-rust](https://github.com/pgvector/pgvector-rust)
-Swift | [pgvector-swift](https://github.com/pgvector/pgvector-swift)
-
-## Frequently Asked Questions
-
-#### How many vectors can be stored in a single table?
-
-A non-partitioned table has a limit of 32 TB by default in Postgres. A partitioned table can have thousands of partitions of that size.
-
-#### Is replication supported?
-
-Yes, pgvector uses the write-ahead log (WAL), which allows for replication and point-in-time recovery.
-
-#### What if I want to index vectors with more than 2,000 dimensions?
-
-Two things you can try are:
-
-1. use dimensionality reduction
-2. compile Postgres with a larger block size (`./configure --with-blocksize=32`) and edit the limit in `src/ivfflat.h`
-
 ## Reference
 
 ### Vector Type
@@ -337,6 +184,7 @@ inner_product(vector, vector) → double precision | inner product
 l2_distance(vector, vector) → double precision | Euclidean distance
 vector_dims(vector) → integer | number of dimensions
 vector_norm(vector) → double precision | Euclidean norm
+random_vector(integer) → vector | random vector [unreleased]
 
 ### Aggregate Functions
 
@@ -344,41 +192,35 @@ Function | Description
 --- | ---
 avg(vector) → vector | arithmetic mean
 
-## Installation Notes
+## Libraries
 
-### Postgres Location
+Language | Libraries
+--- | ---
+Python | [pgvector-python](https://github.com/pgvector/pgvector-python)
+Ruby | [Neighbor](https://github.com/ankane/neighbor), [pgvector-ruby](https://github.com/pgvector/pgvector-ruby)
+Node | [pgvector-node](https://github.com/pgvector/pgvector-node)
+Go | [pgvector-go](https://github.com/pgvector/pgvector-go)
+PHP | [pgvector-php](https://github.com/pgvector/pgvector-php)
+Rust | [pgvector-rust](https://github.com/pgvector/pgvector-rust)
+C++ | [pgvector-cpp](https://github.com/pgvector/pgvector-cpp)
+Elixir | [pgvector-elixir](https://github.com/pgvector/pgvector-elixir)
 
-If your machine has multiple Postgres installations, specify the path to [pg_config](https://www.postgresql.org/docs/current/app-pgconfig.html) with:
+## Frequently Asked Questions
 
-```sh
-export PG_CONFIG=/Applications/Postgres.app/Contents/Versions/latest/bin/pg_config
-```
+#### How many vectors can be stored in a single table?
 
-Then re-run the installation instructions (run `make clean` before `make` if needed)
+A non-partitioned table has a limit of 32 TB by default in Postgres. A partitioned table can have thousands of partitions of that size.
 
-### Missing Header
+#### Is replication supported?
 
-If compilation fails with `fatal error: postgres.h: No such file or directory`, make sure Postgres development files are installed on the server.
+Yes, pgvector uses the write-ahead log (WAL), which allows for replication and point-in-time recovery.
 
-For Ubuntu and Debian, use:
+#### What if I want to index vectors with more than 2,000 dimensions?
 
-```sh
-sudo apt-get install postgresql-server-dev-15
-```
+Two things you can try are:
 
-Note: Replace `15` with your Postgres server version
-
-### Windows
-
-Support for Windows is currently experimental. Use `nmake` to build:
-
-```cmd
-set "PGROOT=C:\Program Files\PostgreSQL\15"
-git clone --branch v0.4.1 https://github.com/pgvector/pgvector.git
-cd pgvector
-nmake /F Makefile.win
-nmake /F Makefile.win install
-```
+1. use dimensionality reduction
+2. compile Postgres with a larger block size (`./configure --with-blocksize=32`) and edit the limit in `src/ivfflat.h`
 
 ## Additional Installation Methods
 
@@ -390,12 +232,12 @@ Get the [Docker image](https://hub.docker.com/r/ankane/pgvector) with:
 docker pull ankane/pgvector
 ```
 
-This adds pgvector to the [Postgres image](https://hub.docker.com/_/postgres) (run it the same way).
+This adds pgvector to the [Postgres image](https://hub.docker.com/_/postgres).
 
-You can also build the image manually:
+You can also build the image manually
 
 ```sh
-git clone --branch v0.4.1 https://github.com/pgvector/pgvector.git
+git clone --branch v0.4.0 https://github.com/pgvector/pgvector.git
 cd pgvector
 docker build -t pgvector .
 ```
@@ -405,7 +247,7 @@ docker build -t pgvector .
 With Homebrew Postgres, you can use:
 
 ```sh
-brew install pgvector
+brew install pgvector/brew/pgvector
 ```
 
 ### PGXN
@@ -416,21 +258,9 @@ Install from the [PostgreSQL Extension Network](https://pgxn.org/dist/vector) wi
 pgxn install vector
 ```
 
-### Yum
-
-RPM packages are available from the [PostgreSQL Yum Repository](https://yum.postgresql.org/). Follow the [setup instructions](https://www.postgresql.org/download/linux/redhat/) for your distribution and run:
-
-```sh
-sudo yum install pgvector_15
-# or
-sudo dnf install pgvector_15
-```
-
-Note: Replace `15` with your Postgres server version
-
 ### conda-forge
 
-With Conda Postgres, install from [conda-forge](https://anaconda.org/conda-forge/pgvector) with:
+Install from [conda-forge](https://anaconda.org/conda-forge/pgvector) with:
 
 ```sh
 conda install -c conda-forge pgvector
@@ -440,15 +270,12 @@ This method is [community-maintained](https://github.com/conda-forge/pgvector-fe
 
 ## Hosted Postgres
 
-pgvector is available on [these providers](https://github.com/pgvector/pgvector/issues/54).
-
-To request a new extension on other providers:
+Some Postgres providers only support specific extensions. To request a new extension:
 
 - Amazon RDS - follow the instructions on [this page](https://aws.amazon.com/rds/postgresql/faqs/)
 - Google Cloud SQL - vote or comment on [this page](https://issuetracker.google.com/issues/265172065)
-- Azure Database - vote or comment on [this page](https://feedback.azure.com/d365community/idea/7b423322-6189-ed11-a81b-000d3ae49307)
 - DigitalOcean Managed Databases - vote or comment on [this page](https://ideas.digitalocean.com/app-framework-services/p/pgvector-extension-for-postgresql)
-- Heroku Postgres - vote or comment on [this page](https://github.com/heroku/roadmap/issues/156)
+- Azure Database for PostgreSQL - vote or comment on [this page](https://feedback.azure.com/d365community/idea/7b423322-6189-ed11-a81b-000d3ae49307)
 
 ## Upgrading
 

sql/vector--0.4.0--0.4.1.sql

@@ -1,2 +1,5 @@
 -- complain if script is sourced in psql, rather than via CREATE EXTENSION
 \echo Use "ALTER EXTENSION vector UPDATE TO '0.4.1'" to load this file. \quit
+
+CREATE FUNCTION random_vector(integer) RETURNS vector
+	AS 'MODULE_PATHNAME' LANGUAGE C VOLATILE STRICT PARALLEL SAFE;

sql/vector.sql

@@ -52,6 +52,9 @@ CREATE FUNCTION vector_add(vector, vector) RETURNS vector
 CREATE FUNCTION vector_sub(vector, vector) RETURNS vector
 	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
 
+CREATE FUNCTION random_vector(integer) RETURNS vector
+	AS 'MODULE_PATHNAME' LANGUAGE C VOLATILE STRICT PARALLEL SAFE;
+
 -- private functions
 
 CREATE FUNCTION vector_lt(vector, vector) RETURNS bool

src/ivfbuild.c

@@ -431,18 +431,8 @@ ComputeCenters(IvfflatBuildState * buildstate)
 	/* TODO Ensure within maintenance_work_mem */
 	buildstate->samples = VectorArrayInit(numSamples, buildstate->dimensions);
 	if (buildstate->heap != NULL)
-	{
 		SampleRows(buildstate);
 
-		if (buildstate->samples->length < buildstate->lists)
-		{
-			ereport(NOTICE,
-					(errmsg("ivfflat index created with little data"),
-					 errdetail("this will cause poor recall"),
-					 errhint("drop the index until the table has more data")));
-		}
-	}
-
 	/* Calculate centers */
 	IvfflatBench("k-means", IvfflatKmeans(buildstate->index, buildstate->samples, buildstate->centers));
 

src/ivfflat.h

@@ -10,15 +10,10 @@
 #include "access/generic_xlog.h"
 #include "access/reloptions.h"
 #include "nodes/execnodes.h"
-#include "port.h"				/* for strtof() and random() */
 #include "utils/sampling.h"
 #include "utils/tuplesort.h"
 #include "vector.h"
 
-#if PG_VERSION_NUM >= 150000
-#include "common/pg_prng.h"
-#endif
-
 #ifdef IVFFLAT_BENCH
 #include "portability/instr_time.h"
 #endif
@@ -68,14 +63,6 @@
 #define IvfflatBench(name, code) (code)
 #endif
 
-#if PG_VERSION_NUM >= 150000
-#define RandomDouble() pg_prng_double(&pg_global_prng_state)
-#define RandomInt() pg_prng_uint32(&pg_global_prng_state)
-#else
-#define RandomDouble() (((double) random()) / MAX_RANDOM_VALUE)
-#define RandomInt() random()
-#endif
-
 /* Variables */
 extern int	ivfflat_probes;
 

src/ivfscan.c

@@ -5,7 +5,6 @@
 #include "access/relscan.h"
 #include "ivfflat.h"
 #include "miscadmin.h"
-#include "pgstat.h"
 #include "storage/bufmgr.h"
 
 #include "catalog/pg_operator_d.h"
@@ -111,7 +110,6 @@ GetScanItems(IndexScanDesc scan, Datum value)
 	Datum		datum;
 	bool		isnull;
 	TupleDesc	tupdesc = RelationGetDescr(scan->indexRelation);
-	double		tuples = 0;
 
 #if PG_VERSION_NUM >= 120000
 	TupleTableSlot *slot = MakeSingleTupleTableSlot(so->tupdesc, &TTSOpsVirtual);
@@ -160,8 +158,6 @@ GetScanItems(IndexScanDesc scan, Datum value)
 				ExecStoreVirtualTuple(slot);
 
 				tuplesort_puttupleslot(so->sortstate, slot);
-
-				tuples++;
 			}
 
 			searchPage = IvfflatPageGetOpaque(page)->nextblkno;
@@ -170,13 +166,6 @@ GetScanItems(IndexScanDesc scan, Datum value)
 		}
 	}
 
-	/* TODO Scan more lists */
-	if (tuples < 100)
-		ereport(DEBUG1,
-				(errmsg("index scan found few tuples"),
-				 errdetail("index may have been created without data or lists is too high"),
-				 errhint("recreate the index and possibly decrease lists")));
-
 	tuplesort_performsort(so->sortstate);
 }
 
@@ -278,9 +267,6 @@ ivfflatgettuple(IndexScanDesc scan, ScanDirection dir)
 	{
 		Datum		value;
 
-		/* Count index scan for stats */
-		pgstat_count_index_scan(scan->indexRelation);
-
 		/* Safety check */
 		if (scan->orderByData == NULL)
 			elog(ERROR, "cannot scan ivfflat index without order");

src/ivfvacuum.c

@@ -143,11 +143,6 @@ ivfflatvacuumcleanup(IndexVacuumInfo *info, IndexBulkDeleteResult *stats)
 {
 	Relation	rel = info->index;
 
-	if (info->analyze_only)
-		return stats;
-
-	/* stats is NULL if ambulkdelete not called */
-	/* OK to return NULL if index not changed */
 	if (stats == NULL)
 		return NULL;
 

src/vector.c

@@ -100,7 +100,7 @@ CheckStateArray(ArrayType *statearray, const char *caller)
 	return (float8 *) ARR_DATA_PTR(statearray);
 }
 
-#if PG_VERSION_NUM < 120003
+#if PG_VERSION_NUM < 120000
 static pg_noinline void
 float_overflow_error(void)
 {
@@ -416,7 +416,7 @@ array_to_vector(PG_FUNCTION_ARGS)
 		else if (ARR_ELEMTYPE(array) == FLOAT4OID)
 			result->x[i] = DatumGetFloat4(elemsp[i]);
 		else if (ARR_ELEMTYPE(array) == NUMERICOID)
-			result->x[i] = DatumGetFloat4(DirectFunctionCall1(numeric_float4, elemsp[i]));
+			result->x[i] = DatumGetFloat4(DirectFunctionCall1(numeric_float4, NumericGetDatum(elemsp[i])));
 		else
 			ereport(ERROR,
 					(errcode(ERRCODE_DATA_EXCEPTION),
@@ -467,7 +467,6 @@ l2_distance(PG_FUNCTION_ARGS)
 
 	CheckDims(a, b);
 
-	/* Auto-vectorized */
 	for (int i = 0; i < a->dim; i++)
 	{
 		diff = ax[i] - bx[i];
@@ -492,7 +491,8 @@ vector_l2_squared_distance(PG_FUNCTION_ARGS)
 	double		distance = 0.0;
 	double		diff;
 
-	/* Auto-vectorized */
+	CheckDims(a, b);
+
 	for (int i = 0; i < a->dim; i++)
 	{
 		diff = ax[i] - bx[i];
@@ -517,7 +517,6 @@ inner_product(PG_FUNCTION_ARGS)
 
 	CheckDims(a, b);
 
-	/* Auto-vectorized */
 	for (int i = 0; i < a->dim; i++)
 		distance += ax[i] * bx[i];
 
@@ -539,7 +538,6 @@ vector_negative_inner_product(PG_FUNCTION_ARGS)
 
 	CheckDims(a, b);
 
-	/* Auto-vectorized */
 	for (int i = 0; i < a->dim; i++)
 		distance += ax[i] * bx[i];
 
@@ -563,7 +561,6 @@ cosine_distance(PG_FUNCTION_ARGS)
 
 	CheckDims(a, b);
 
-	/* Auto-vectorized */
 	for (int i = 0; i < a->dim; i++)
 	{
 		distance += ax[i] * bx[i];
@@ -571,8 +568,7 @@ cosine_distance(PG_FUNCTION_ARGS)
 		normb += bx[i] * bx[i];
 	}
 
-	/* Use sqrt(a * b) over sqrt(a) * sqrt(b) */
-	PG_RETURN_FLOAT8(1 - (distance / sqrt(norma * normb)));
+	PG_RETURN_FLOAT8(1 - (distance / (sqrt(norma) * sqrt(normb))));
 }
 
 /*
@@ -590,7 +586,6 @@ vector_spherical_distance(PG_FUNCTION_ARGS)
 
 	CheckDims(a, b);
 
-	/* Auto-vectorized */
 	for (int i = 0; i < a->dim; i++)
 		distance += a->x[i] * b->x[i];
 
@@ -626,7 +621,6 @@ vector_norm(PG_FUNCTION_ARGS)
 	float	   *ax = a->x;
 	double		norm = 0.0;
 
-	/* Auto-vectorized */
 	for (int i = 0; i < a->dim; i++)
 		norm += ax[i] * ax[i];
 
@@ -651,8 +645,6 @@ vector_add(PG_FUNCTION_ARGS)
 
 	result = InitVector(a->dim);
 	rx = result->x;
-
-	/* Auto-vectorized */
 	for (int i = 0, imax = a->dim; i < imax; i++)
 		rx[i] = ax[i] + bx[i];
 
@@ -677,8 +669,6 @@ vector_sub(PG_FUNCTION_ARGS)
 
 	result = InitVector(a->dim);
 	rx = result->x;
-
-	/* Auto-vectorized */
 	for (int i = 0, imax = a->dim; i < imax; i++)
 		rx[i] = ax[i] - bx[i];
 
@@ -832,7 +822,7 @@ vector_accum(PG_FUNCTION_ARGS)
 	if (newarr)
 	{
 		for (int i = 0; i < dim; i++)
-			statedatums[i + 1] = Float8GetDatumFast((double) x[i]);
+			statedatums[i + 1] = Float8GetDatumFast(x[i]);
 	}
 	else
 	{
@@ -960,3 +950,22 @@ vector_avg(PG_FUNCTION_ARGS)
 
 	PG_RETURN_POINTER(result);
 }
+
+/*
+ * Generate a random vector
+ */
+PGDLLEXPORT PG_FUNCTION_INFO_V1(random_vector);
+Datum
+random_vector(PG_FUNCTION_ARGS)
+{
+	int32		dim = PG_GETARG_INT32(0);
+	Vector	   *result;
+
+	CheckDim(dim);
+
+	result = InitVector(dim);
+	for (int i = 0; i < dim; i++)
+		result->x[i] = RandomDouble();
+
+	PG_RETURN_POINTER(result);
+}

src/vector.h

@@ -3,8 +3,10 @@
 
 #include "postgres.h"
 
-#if PG_VERSION_NUM >= 160000
-#include "varatt.h"
+#include "port.h"				/* for strtof() and random() */
+
+#if PG_VERSION_NUM >= 150000
+#include "common/pg_prng.h"
 #endif
 
 #define VECTOR_MAX_DIM 16000
@@ -14,6 +16,14 @@
 #define PG_GETARG_VECTOR_P(x)	DatumGetVector(PG_GETARG_DATUM(x))
 #define PG_RETURN_VECTOR_P(x)	PG_RETURN_POINTER(x)
 
+#if PG_VERSION_NUM >= 150000
+#define RandomDouble() pg_prng_double(&pg_global_prng_state)
+#define RandomInt() pg_prng_uint32(&pg_global_prng_state)
+#else
+#define RandomDouble() (((double) random()) / MAX_RANDOM_VALUE)
+#define RandomInt() random()
+#endif
+
 typedef struct Vector
 {
 	int32		vl_len_;		/* varlena header (do not touch directly!) */

test/expected/cast.out

@@ -22,12 +22,6 @@ SELECT ARRAY[1,2,3]::float8[]::vector;
  [1,2,3]
 (1 row)
 
-SELECT ARRAY[1,2,3]::numeric[]::vector;
-  array  
----------
- [1,2,3]
-(1 row)
-
 SELECT '{NULL}'::real[]::vector;
 ERROR:  array must not containing NULLs
 SELECT '{NaN}'::real[]::vector;

test/expected/functions.out

@@ -22,28 +22,10 @@ SELECT round(vector_norm('[1,1]')::numeric, 5);
  1.41421
 (1 row)
 
-SELECT vector_norm('[3,4]');
- vector_norm 
--------------
-           5
-(1 row)
-
-SELECT vector_norm('[0,1]');
- vector_norm 
--------------
-           1
-(1 row)
-
-SELECT l2_distance('[0,0]', '[3,4]');
- l2_distance 
--------------
-           5
-(1 row)
-
-SELECT l2_distance('[0,0]', '[0,1]');
- l2_distance 
--------------
-           1
+SELECT round(l2_distance('[1,2]', '[0,0]')::numeric, 5);
+  round  
+---------
+ 2.23607
 (1 row)
 
 SELECT l2_distance('[1,2]', '[3]');
@@ -56,10 +38,10 @@ SELECT inner_product('[1,2]', '[3,4]');
 
 SELECT inner_product('[1,2]', '[3]');
 ERROR:  different vector dimensions 2 and 1
-SELECT cosine_distance('[1,2]', '[2,4]');
- cosine_distance 
------------------
-               0
+SELECT round(cosine_distance('[1,2]', '[2,4]')::numeric, 5);
+  round  
+---------
+ 0.00000
 (1 row)
 
 SELECT cosine_distance('[1,2]', '[0,0]');
@@ -68,18 +50,6 @@ SELECT cosine_distance('[1,2]', '[0,0]');
              NaN
 (1 row)
 
-SELECT cosine_distance('[1,1]', '[1,1]');
- cosine_distance 
------------------
-               0
-(1 row)
-
-SELECT cosine_distance('[1,1]', '[-1,-1]');
- cosine_distance 
------------------
-               2
-(1 row)
-
 SELECT cosine_distance('[1,2]', '[3]');
 ERROR:  different vector dimensions 2 and 1
 SELECT avg(v) FROM unnest(ARRAY['[1,2,3]'::vector, '[3,5,7]']) v;

test/sql/cast.sql

@@ -2,7 +2,6 @@ SELECT ARRAY[1,2,3]::vector;
 SELECT ARRAY[1.0,2.0,3.0]::vector;
 SELECT ARRAY[1,2,3]::float4[]::vector;
 SELECT ARRAY[1,2,3]::float8[]::vector;
-SELECT ARRAY[1,2,3]::numeric[]::vector;
 SELECT '{NULL}'::real[]::vector;
 SELECT '{NaN}'::real[]::vector;
 SELECT '{Infinity}'::real[]::vector;

test/sql/functions.sql

@@ -2,22 +2,16 @@ SELECT '[1,2,3]'::vector + '[4,5,6]';
 SELECT '[1,2,3]'::vector - '[4,5,6]';
 
 SELECT vector_dims('[1,2,3]');
-
 SELECT round(vector_norm('[1,1]')::numeric, 5);
-SELECT vector_norm('[3,4]');
-SELECT vector_norm('[0,1]');
 
-SELECT l2_distance('[0,0]', '[3,4]');
-SELECT l2_distance('[0,0]', '[0,1]');
+SELECT round(l2_distance('[1,2]', '[0,0]')::numeric, 5);
 SELECT l2_distance('[1,2]', '[3]');
 
 SELECT inner_product('[1,2]', '[3,4]');
 SELECT inner_product('[1,2]', '[3]');
 
-SELECT cosine_distance('[1,2]', '[2,4]');
+SELECT round(cosine_distance('[1,2]', '[2,4]')::numeric, 5);
 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 avg(v) FROM unnest(ARRAY['[1,2,3]'::vector, '[3,5,7]']) v;

test/t/001_wal.pl

@@ -44,11 +44,6 @@ sub test_index_replay
 	return;
 }
 
-# Use ARRAY[random(), random(), random(), ...] over
-# SELECT array_agg(random()) FROM generate_series(1, $dim)
-# to generate different values for each row
-my $array_sql = join(",", ('random()') x $dim);
-
 # Initialize primary node
 $node_primary = get_new_node('primary');
 $node_primary->init(allows_streaming => 1);
@@ -75,7 +70,7 @@ $node_replica->start;
 $node_primary->safe_psql("postgres", "CREATE EXTENSION vector;");
 $node_primary->safe_psql("postgres", "CREATE TABLE tst (i int4, v vector($dim));");
 $node_primary->safe_psql("postgres",
-	"INSERT INTO tst SELECT i % 10, ARRAY[$array_sql] FROM generate_series(1, 100000) i;"
+	"INSERT INTO tst SELECT i % 10, random_vector($dim) FROM generate_series(1, 100000) i;"
 );
 $node_primary->safe_psql("postgres", "CREATE INDEX ON tst USING ivfflat (v);");
 
@@ -91,7 +86,7 @@ for my $i (1 .. 10)
 	test_index_replay("vacuum $i");
 	my ($start, $end) = (100001 + ($i - 1) * 10000, 100000 + $i * 10000);
 	$node_primary->safe_psql("postgres",
-		"INSERT INTO tst SELECT i % 10, ARRAY[$array_sql] FROM generate_series($start, $end) i;"
+		"INSERT INTO tst SELECT i % 10, random_vector($dim) FROM generate_series($start, $end) i;"
 	);
 	test_index_replay("insert $i");
 }

test/t/003_recall.pl

@@ -46,7 +46,7 @@ $node->start;
 $node->safe_psql("postgres", "CREATE EXTENSION vector;");
 $node->safe_psql("postgres", "CREATE TABLE tst (i int4, v vector(3));");
 $node->safe_psql("postgres",
-	"INSERT INTO tst SELECT i, ARRAY[random(), random(), random()] FROM generate_series(1, 100000) i;"
+	"INSERT INTO tst SELECT i, random_vector(3) FROM generate_series(1, 100000) i;"
 );
 
 # Generate queries

test/t/005_query_recall.pl

@@ -13,7 +13,7 @@ $node->start;
 $node->safe_psql("postgres", "CREATE EXTENSION vector;");
 $node->safe_psql("postgres", "CREATE TABLE tst (i int4 primary key, v vector(3));");
 $node->safe_psql("postgres",
-	"INSERT INTO tst SELECT i, ARRAY[random(), random(), random()] FROM generate_series(1, 100000) i;"
+	"INSERT INTO tst SELECT i, random_vector(3) FROM generate_series(1, 100000) i;"
 );
 
 # Check each index type

test/t/006_lists.pl

@@ -13,7 +13,7 @@ $node->start;
 $node->safe_psql("postgres", "CREATE EXTENSION vector;");
 $node->safe_psql("postgres", "CREATE TABLE tst (v vector(3));");
 $node->safe_psql("postgres",
-	"INSERT INTO tst SELECT ARRAY[random(), random(), random()] FROM generate_series(1, 100000) i;"
+	"INSERT INTO tst SELECT random_vector(3) FROM generate_series(1, 100000) i;"
 );
 
 $node->safe_psql("postgres", "CREATE INDEX lists50 ON tst USING ivfflat (v) WITH (lists = 50);");

test/t/007_inserts.pl

@@ -2,12 +2,10 @@ use strict;
 use warnings;
 use PostgresNode;
 use TestLib;
-use Test::More tests => 7;
+use Test::More tests => 5;
 
 my $dim = 768;
 
-my $array_sql = join(",", ('random()') x $dim);
-
 # Initialize node
 my $node = get_new_node('node');
 $node->init;
@@ -17,7 +15,7 @@ $node->start;
 $node->safe_psql("postgres", "CREATE EXTENSION vector;");
 $node->safe_psql("postgres", "CREATE TABLE tst (v vector($dim));");
 $node->safe_psql("postgres",
-	"INSERT INTO tst SELECT ARRAY[$array_sql] FROM generate_series(1, 10000) i;"
+	"INSERT INTO tst SELECT random_vector($dim) FROM generate_series(1, 10000) i;"
 );
 $node->safe_psql("postgres", "CREATE INDEX ON tst USING ivfflat (v);");
 
@@ -28,23 +26,14 @@ $node->pgbench(
 	[qr{^$}],
 	"concurrent INSERTs",
 	{
-		"007_inserts" => "INSERT INTO tst SELECT ARRAY[$array_sql] FROM generate_series(1, 10) i;"
+		"007_inserts" => "INSERT INTO tst SELECT random_vector($dim) FROM generate_series(1, 10) i;"
 	}
 );
 
-sub idx_scan
-{
-	# Stats do not update instantaneously
-	# https://www.postgresql.org/docs/current/monitoring-stats.html#MONITORING-STATS-VIEWS
-	sleep(1);
-	$node->safe_psql("postgres", "SELECT idx_scan FROM pg_stat_user_indexes WHERE indexrelid = 'tst_v_idx'::regclass;");
-}
-
 my $expected = 10000 + 5 * 100 * 10;
 
 my $count = $node->safe_psql("postgres", "SELECT COUNT(*) FROM tst;");
 is($count, $expected);
-is(idx_scan(), 0);
 
 $count = $node->safe_psql("postgres", qq(
 	SET enable_seqscan = off;
@@ -52,4 +41,3 @@ $count = $node->safe_psql("postgres", qq(
 	SELECT COUNT(*) FROM (SELECT v FROM tst ORDER BY v <-> (SELECT v FROM tst LIMIT 1)) t;
 ));
 is($count, $expected);
-is(idx_scan(), 1);

test/t/009_storage.pl

@@ -17,7 +17,7 @@ $node->safe_psql("postgres", "CREATE TABLE tst (v1 vector(1024), v2 vector(1024)
 
 # Test insert succeeds
 $node->safe_psql("postgres",
-	"INSERT INTO tst SELECT array_agg(n), array_agg(n), array_agg(n) FROM generate_series(1, $dim) n"
+	"INSERT INTO tst SELECT random_vector($dim), random_vector($dim), random_vector($dim)"
 );
 
 # Change storage to PLAIN
@@ -27,6 +27,6 @@ $node->safe_psql("postgres", "ALTER TABLE tst ALTER COLUMN v3 SET STORAGE PLAIN"
 
 # Test insert fails
 my ($ret, $stdout, $stderr) = $node->psql("postgres",
-	"INSERT INTO tst SELECT array_agg(n), array_agg(n), array_agg(n) FROM generate_series(1, $dim) n"
+	"INSERT INTO tst SELECT random_vector($dim), random_vector($dim), random_vector($dim)"
 );
 like($stderr, qr/row is too big/);

vector.control

@@ -1,4 +1,4 @@
 comment = 'vector data type and ivfflat access method'
-default_version = '0.4.1'
+default_version = '0.4.0'
 module_pathname = '$libdir/vector'
 relocatable = true