Version bump to 0.1.8 [skip ci]

.dockerignore

@@ -0,0 +1,8 @@
+/.git/
+/dist/
+/results/
+/tmp_check/
+/sql/vector--?.?.?.sql
+regression.*
+*.o
+*.so

.gitignore

@@ -1,5 +1,7 @@
-results
-tmp_check
+/dist/
+/results/
+/tmp_check/
+/sql/vector--?.?.?.sql
 regression.*
 *.o
 *.so

CHANGELOG.md

@@ -1,3 +1,29 @@
+## 0.1.8 (2021-09-07)
+
+- Added cast for `vector` to `real[]`
+
+## 0.1.7 (2021-06-13)
+
+- Added cast for `numeric[]` to `vector`
+
+## 0.1.6 (2021-06-09)
+
+- Fixed segmentation fault with `COUNT`
+
+## 0.1.5 (2021-05-25)
+
+- Reduced memory usage during index creation
+
+## 0.1.4 (2021-05-09)
+
+- Fixed kmeans for inner product
+- Fixed multiple definition error with GCC 10
+
+## 0.1.3 (2021-05-06)
+
+- Added Dockerfile
+- Fixed version
+
 ## 0.1.2 (2021-04-26)
 
 - Vectorized distance calculations

Dockerfile

@@ -0,0 +1,16 @@
+FROM postgres
+
+COPY . /tmp/pgvector
+
+RUN apt-get update && \
+		apt-get install -y --no-install-recommends build-essential postgresql-server-dev-13 && \
+		cd /tmp/pgvector && \
+		make clean && \
+		make OPTFLAGS="" && \
+		make install && \
+		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-13 && \
+		apt-get autoremove -y && \
+		rm -rf /var/lib/apt/lists/*

META.json

@@ -0,0 +1,49 @@
+{
+	"name": "vector",
+	"abstract": "Open-source vector similarity search for Postgres",
+	"description": "Supports L2 distance, inner product, and cosine distance",
+	"version": "0.1.8",
+	"maintainer": [
+		"Andrew Kane <andrew@ankane.org>"
+	],
+	"license": {
+		"PostgreSQL": "http://www.postgresql.org/about/licence"
+	},
+	"prereqs": {
+		"runtime": {
+			"requires": {
+				"PostgreSQL": "9.6.0"
+			}
+		}
+	},
+	"provides": {
+		"vector": {
+			"file": "sql/vector.sql",
+			"docfile": "README.md",
+			"version": "0.1.8",
+			"abstract": "Open-source vector similarity search for Postgres"
+		}
+	},
+	"resources": {
+		"homepage": "https://github.com/ankane/pgvector",
+		"bugtracker": {
+			"web": "https://github.com/ankane/pgvector/issues"
+		},
+		"repository": {
+			"url":  "https://github.com/ankane/pgvector.git",
+			"web":  "https://github.com/ankane/pgvector",
+			"type": "git"
+		}
+	},
+	"generated_by": "Andrew Kane",
+	"meta-spec": {
+		"version": "1.0.0",
+		"url": "http://pgxn.org/meta/spec.txt"
+	},
+	"tags": [
+		"vectors",
+		"datatype",
+		"nearest neighbor search",
+		"approximate nearest neighbors"
+	]
+}

Makefile

@@ -1,16 +1,20 @@
 EXTENSION = vector
-DATA = vector--0.1.1.sql vector--0.1.0--0.1.1.sql
+EXTVERSION = 0.1.8
+
 MODULE_big = vector
+DATA = $(wildcard sql/*--*.sql)
 OBJS = src/ivfbuild.o src/ivfflat.o src/ivfinsert.o src/ivfkmeans.o src/ivfscan.o src/ivfutils.o src/ivfvacuum.o src/vector.o
 
-TESTS = $(wildcard sql/*.sql)
+TESTS = $(wildcard test/sql/*.sql)
+REGRESS = $(patsubst test/sql/%.sql,%,$(TESTS))
+REGRESS_OPTS = --inputdir=test
 
-REGRESS = btree cast copy functions ivfflat_cosine ivfflat_ip ivfflat_l2 ivfflat_unlogged vector
+OPTFLAGS = -march=native
 
 # For auto-vectorization:
 # - GCC (needs -ftree-vectorize OR -O3) - https://gcc.gnu.org/projects/tree-ssa/vectorization.html
 # - Clang (could use pragma instead) - https://llvm.org/docs/Vectorizers.html
-PG_CFLAGS = -march=native -ftree-vectorize -fassociative-math -fno-signed-zeros -fno-trapping-math
+PG_CFLAGS = $(OPTFLAGS) -ftree-vectorize -fassociative-math -fno-signed-zeros -fno-trapping-math
 
 # Debug GCC auto-vectorization
 # PG_CFLAGS += -fopt-info-vec
@@ -18,10 +22,23 @@ PG_CFLAGS = -march=native -ftree-vectorize -fassociative-math -fno-signed-zeros
 # Debug Clang auto-vectorization
 # PG_CFLAGS += -Rpass=loop-vectorize -Rpass-analysis=loop-vectorize
 
+all: sql/$(EXTENSION)--$(EXTVERSION).sql
+
+sql/$(EXTENSION)--$(EXTVERSION).sql: sql/$(EXTENSION).sql
+	cp $< $@
+
+EXTRA_CLEAN = sql/$(EXTENSION)--$(EXTVERSION).sql
+
 PG_CONFIG ?= pg_config
 PGXS := $(shell $(PG_CONFIG) --pgxs)
 include $(PGXS)
 
 prove_installcheck:
 	rm -rf $(CURDIR)/tmp_check
-	cd $(srcdir) && TESTDIR='$(CURDIR)' PATH="$(bindir):$$PATH" PGPORT='6$(DEF_PGPORT)' PG_REGRESS='$(top_builddir)/src/test/regress/pg_regress' $(PROVE) $(PG_PROVE_FLAGS) $(PROVE_FLAGS) $(if $(PROVE_TESTS),$(PROVE_TESTS),t/*.pl)
+	cd $(srcdir) && TESTDIR='$(CURDIR)' PATH="$(bindir):$$PATH" PGPORT='6$(DEF_PGPORT)' PG_REGRESS='$(top_builddir)/src/test/regress/pg_regress' $(PROVE) $(PG_PROVE_FLAGS) $(PROVE_FLAGS) $(if $(PROVE_TESTS),$(PROVE_TESTS),test/t/*.pl)
+
+.PHONY: dist
+
+dist:
+	mkdir -p dist
+	git archive --format zip --prefix=$(EXTENSION)-$(EXTVERSION)/ --output dist/$(EXTENSION)-$(EXTVERSION).zip master

README.md

@@ -17,7 +17,7 @@ Supports L2 distance, inner product, and cosine distance
 Compile and install the extension (supports Postgres 9.6+)
 
 ```sh
-git clone --branch v0.1.2 https://github.com/ankane/pgvector.git
+git clone --branch v0.1.8 https://github.com/ankane/pgvector.git
 cd pgvector
 make
 make install # may need sudo
@@ -29,6 +29,8 @@ Then load it in databases where you want to use it
 CREATE EXTENSION vector;
 ```
 
+You can also install it with [Docker](#docker), [Homebrew](#homebrew), or [PGXN](#pgxn)
+
 ## Getting Started
 
 Create a vector column with 3 dimensions (replace `table` and `column` with non-reserved names)
@@ -104,6 +106,16 @@ SELECT ...
 COMMIT;
 ```
 
+### Partial Indexes
+
+Consider [partial indexes](https://www.postgresql.org/docs/current/indexes-partial.html) for queries with a `WHERE` clause
+
+```sql
+CREATE INDEX ON table USING ivfflat (column) WHERE (other_column = 123);
+```
+
+To index many different values of `other_column`, consider [partitioning](https://www.postgresql.org/docs/current/ddl-partitioning.html) on `other_column`.
+
 ## Reference
 
 ### Vector Type
@@ -134,16 +146,63 @@ vector_norm(vector) | Euclidean norm
 
 Libraries that use pgvector:
 
+- [pgvector-python](https://github.com/ankane/pgvector-python) (Python)
 - [Neighbor](https://github.com/ankane/neighbor) (Ruby)
+- [pgvector-node](https://github.com/ankane/pgvector-node) (Node.js)
+- [pgvector-go](https://github.com/ankane/pgvector-go) (Go)
+- [pgvector-rust](https://github.com/ankane/pgvector-rust) (Rust)
+
+## Additional Installation Methods
+
+### Docker
+
+Get the [Docker image](https://hub.docker.com/repository/docker/ankane/pgvector) with:
+
+```sh
+docker pull ankane/pgvector
+```
+
+This adds pgvector to the [Postgres image](https://hub.docker.com/_/postgres).
+
+You can also build the image manually
+
+```sh
+git clone --branch v0.1.8 https://github.com/ankane/pgvector.git
+cd pgvector
+docker build -t pgvector .
+```
+
+### Homebrew
+
+On Mac with Homebrew Postgres, you can use:
+
+```sh
+brew install ankane/brew/pgvector
+```
+
+### PGXN
+
+Install from the [PostgreSQL Extension Network](https://pgxn.org/dist/vector) with:
+
+```sh
+pgxn install vector
+```
+
+## Hosted Postgres
+
+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 - follow the instructions on [this page](https://cloud.google.com/sql/docs/postgres/extensions#requesting-support-for-a-new-extension)
+- DigitalOcean Managed Databases - follow the instructions on [this page](https://docs.digitalocean.com/products/databases/postgresql/resources/supported-extensions/#supported-extensions)
+- Azure Database for PostgreSQL - follow the instructions on [this page](https://docs.microsoft.com/en-us/azure/postgresql/concepts-extensions#next-steps)
 
 ## Upgrading
 
-### 0.1.1
-
-Compile and install the latest version and run:
+Install the latest version and run:
 
 ```sql
-ALTER EXTENSION vector UPDATE TO '0.1.1';
+ALTER EXTENSION vector UPDATE;
 ```
 
 ## Thanks
@@ -188,16 +247,10 @@ make prove_installcheck  # TAP tests
 To run single tests:
 
 ```sh
-make installcheck REGRESS=vector                  # regression test
-make prove_installcheck PROVE_TESTS=t/001_wal.pl  # TAP test
+make installcheck REGRESS=functions                    # regression test
+make prove_installcheck PROVE_TESTS=test/t/001_wal.pl  # TAP test
 ```
 
-Directories
-
-- `expected` - expected output for regression tests
-- `sql` - regression tests
-- `t` - TAP tests
-
 Resources for contributors
 
 - [Extension Building Infrastructure](https://www.postgresql.org/docs/current/extend-pgxs.html)

sql/vector--0.1.1--0.1.3.sql

@@ -0,0 +1,2 @@
+-- complain if script is sourced in psql, rather than via CREATE EXTENSION
+\echo Use "ALTER EXTENSION vector UPDATE TO '0.1.3'" to load this file. \quit

sql/vector--0.1.3--0.1.4.sql

@@ -0,0 +1,2 @@
+-- complain if script is sourced in psql, rather than via CREATE EXTENSION
+\echo Use "ALTER EXTENSION vector UPDATE TO '0.1.4'" to load this file. \quit

sql/vector--0.1.4--0.1.5.sql

@@ -0,0 +1,2 @@
+-- complain if script is sourced in psql, rather than via CREATE EXTENSION
+\echo Use "ALTER EXTENSION vector UPDATE TO '0.1.5'" to load this file. \quit

sql/vector--0.1.5--0.1.6.sql

@@ -0,0 +1,2 @@
+-- complain if script is sourced in psql, rather than via CREATE EXTENSION
+\echo Use "ALTER EXTENSION vector UPDATE TO '0.1.6'" to load this file. \quit

sql/vector--0.1.6--0.1.7.sql

@@ -0,0 +1,8 @@
+-- complain if script is sourced in psql, rather than via CREATE EXTENSION
+\echo Use "ALTER EXTENSION vector UPDATE TO '0.1.7'" to load this file. \quit
+
+CREATE FUNCTION array_to_vector(numeric[], integer, boolean) RETURNS vector
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE CAST (numeric[] AS vector)
+	WITH FUNCTION array_to_vector(numeric[], integer, boolean) AS IMPLICIT;

sql/vector--0.1.7--0.1.8.sql

@@ -0,0 +1,8 @@
+-- complain if script is sourced in psql, rather than via CREATE EXTENSION
+\echo Use "ALTER EXTENSION vector UPDATE TO '0.1.8'" to load this file. \quit
+
+CREATE FUNCTION vector_to_float4(vector, integer, boolean) RETURNS real[]
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE CAST (vector AS real[])
+	WITH FUNCTION vector_to_float4(vector, integer, boolean) AS IMPLICIT;

sql/vector.sql

@@ -1,15 +1,230 @@
-SET client_min_messages = warning;
-CREATE EXTENSION IF NOT EXISTS vector;
+-- complain if script is sourced in psql, rather than via CREATE EXTENSION
+\echo Use "CREATE EXTENSION vector" to load this file. \quit
 
-SELECT '[1,2,3]'::vector;
-SELECT '[-1,2,3]'::vector;
-SELECT '[hello,1]'::vector;
-SELECT '[NaN,1]'::vector;
-SELECT '[Infinity,1]'::vector;
-SELECT '[-Infinity,1]'::vector;
-SELECT '[1,2,3'::vector;
-SELECT '[1,2,3]9'::vector;
-SELECT '1,2,3'::vector;
-SELECT '[]'::vector;
-SELECT '[1,]'::vector;
-SELECT '[1,2,3]'::vector(2);
+-- type
+
+CREATE TYPE vector;
+
+CREATE FUNCTION vector_in(cstring, oid, integer) RETURNS vector
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION vector_out(vector) RETURNS cstring
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION vector_typmod_in(cstring[]) RETURNS integer
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION vector_recv(internal, oid, integer) RETURNS vector
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION vector_send(vector) RETURNS bytea
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE TYPE vector (
+	INPUT     = vector_in,
+	OUTPUT    = vector_out,
+	TYPMOD_IN = vector_typmod_in,
+	RECEIVE   = vector_recv,
+	SEND      = vector_send
+);
+
+-- functions
+
+CREATE FUNCTION l2_distance(vector, vector) RETURNS float8
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION inner_product(vector, vector) RETURNS float8
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION cosine_distance(vector, vector) RETURNS float8
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION vector_dims(vector) RETURNS integer
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION vector_norm(vector) RETURNS float8
+	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;
+
+CREATE FUNCTION vector_sub(vector, vector) RETURNS vector
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+-- private functions
+
+CREATE FUNCTION vector_lt(vector, vector) RETURNS bool
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION vector_le(vector, vector) RETURNS bool
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION vector_eq(vector, vector) RETURNS bool
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION vector_ne(vector, vector) RETURNS bool
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION vector_ge(vector, vector) RETURNS bool
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION vector_gt(vector, vector) RETURNS bool
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION vector_cmp(vector, vector) RETURNS int4
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION vector_l2_squared_distance(vector, vector) 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;
+
+CREATE FUNCTION vector_spherical_distance(vector, vector) RETURNS float8
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+-- cast functions
+
+CREATE FUNCTION vector(vector, integer, boolean) RETURNS vector
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION array_to_vector(integer[], integer, boolean) RETURNS vector
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION array_to_vector(real[], integer, boolean) RETURNS vector
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION array_to_vector(double precision[], integer, boolean) RETURNS vector
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION array_to_vector(numeric[], integer, boolean) RETURNS vector
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+CREATE FUNCTION vector_to_float4(vector, integer, boolean) RETURNS real[]
+	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
+
+-- casts
+
+CREATE CAST (vector AS vector)
+	WITH FUNCTION vector(vector, integer, boolean) AS IMPLICIT;
+
+CREATE CAST (integer[] AS vector)
+	WITH FUNCTION array_to_vector(integer[], integer, boolean) AS IMPLICIT;
+
+CREATE CAST (real[] AS vector)
+	WITH FUNCTION array_to_vector(real[], integer, boolean) AS IMPLICIT;
+
+CREATE CAST (double precision[] AS vector)
+	WITH FUNCTION array_to_vector(double precision[], integer, boolean) AS IMPLICIT;
+
+CREATE CAST (numeric[] AS vector)
+	WITH FUNCTION array_to_vector(numeric[], integer, boolean) AS IMPLICIT;
+
+CREATE CAST (vector AS real[])
+	WITH FUNCTION vector_to_float4(vector, integer, boolean) AS IMPLICIT;
+
+-- operators
+
+CREATE OPERATOR <-> (
+	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = l2_distance,
+	COMMUTATOR = '<->'
+);
+
+CREATE OPERATOR <#> (
+	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = vector_negative_inner_product,
+	COMMUTATOR = '<#>'
+);
+
+CREATE OPERATOR <=> (
+	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = cosine_distance,
+	COMMUTATOR = '<=>'
+);
+
+CREATE OPERATOR + (
+	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = vector_add,
+	COMMUTATOR = +
+);
+
+CREATE OPERATOR - (
+	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = vector_sub,
+	COMMUTATOR = -
+);
+
+CREATE OPERATOR < (
+	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = vector_lt,
+	COMMUTATOR = > , NEGATOR = >= ,
+	RESTRICT = scalarltsel, JOIN = scalarltjoinsel
+);
+
+-- should use scalarlesel and scalarlejoinsel, but not supported in Postgres < 11
+CREATE OPERATOR <= (
+	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = vector_le,
+	COMMUTATOR = >= , NEGATOR = > ,
+	RESTRICT = scalarltsel, JOIN = scalarltjoinsel
+);
+
+CREATE OPERATOR = (
+	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = vector_eq,
+	COMMUTATOR = = , NEGATOR = <> ,
+	RESTRICT = eqsel, JOIN = eqjoinsel
+);
+
+CREATE OPERATOR <> (
+	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = vector_ne,
+	COMMUTATOR = <> , NEGATOR = = ,
+	RESTRICT = eqsel, JOIN = eqjoinsel
+);
+
+-- should use scalargesel and scalargejoinsel, but not supported in Postgres < 11
+CREATE OPERATOR >= (
+	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = vector_ge,
+	COMMUTATOR = <= , NEGATOR = < ,
+	RESTRICT = scalargtsel, JOIN = scalargtjoinsel
+);
+
+CREATE OPERATOR > (
+	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = vector_gt,
+	COMMUTATOR = < , NEGATOR = <= ,
+	RESTRICT = scalargtsel, JOIN = scalargtjoinsel
+);
+
+-- access method
+
+CREATE FUNCTION ivfflathandler(internal) RETURNS index_am_handler
+	AS 'MODULE_PATHNAME' LANGUAGE C;
+
+CREATE ACCESS METHOD ivfflat TYPE INDEX HANDLER ivfflathandler;
+
+COMMENT ON ACCESS METHOD ivfflat IS 'ivfflat index access method';
+
+-- opclasses
+
+CREATE OPERATOR CLASS vector_ops
+	DEFAULT FOR TYPE vector USING btree AS
+	OPERATOR 1 < ,
+	OPERATOR 2 <= ,
+	OPERATOR 3 = ,
+	OPERATOR 4 >= ,
+	OPERATOR 5 > ,
+	FUNCTION 1 vector_cmp(vector, vector);
+
+CREATE OPERATOR CLASS vector_l2_ops
+	DEFAULT FOR TYPE vector USING ivfflat AS
+	OPERATOR 1 <-> (vector, vector) FOR ORDER BY float_ops,
+	FUNCTION 1 vector_l2_squared_distance(vector, vector),
+	FUNCTION 3 l2_distance(vector, vector);
+
+CREATE OPERATOR CLASS vector_ip_ops
+	FOR TYPE vector USING ivfflat AS
+	OPERATOR 1 <#> (vector, vector) FOR ORDER BY float_ops,
+	FUNCTION 1 vector_negative_inner_product(vector, vector),
+	FUNCTION 3 vector_spherical_distance(vector, vector),
+	FUNCTION 4 vector_norm(vector);
+
+CREATE OPERATOR CLASS vector_cosine_ops
+	FOR TYPE vector USING ivfflat AS
+	OPERATOR 1 <=> (vector, vector) FOR ORDER BY float_ops,
+	FUNCTION 1 vector_negative_inner_product(vector, vector),
+	FUNCTION 2 vector_norm(vector),
+	FUNCTION 3 vector_spherical_distance(vector, vector),
+	FUNCTION 4 vector_norm(vector);

src/ivfbuild.c

@@ -41,10 +41,13 @@ SampleCallback(Relation index, CALLBACK_ITEM_POINTER, Datum *values,
 	if (isnull[0])
 		return;
 
-	/* Normalize the value */
-	if (buildstate->normprocinfo != NULL)
+	/*
+	 * Normalize with KMEANS_NORM_PROC since spherical distance function
+	 * expects unit vectors
+	 */
+	if (buildstate->kmeansnormprocinfo != NULL)
 	{
-		if (!IvfflatNormValue(buildstate->normprocinfo, buildstate->collation, &value, buildstate->normvec))
+		if (!IvfflatNormValue(buildstate->kmeansnormprocinfo, buildstate->collation, &value, buildstate->normvec))
 			return;
 	}
 
@@ -238,6 +241,8 @@ InsertTuples(Relation index, IvfflatBuildState * buildstate, ForkNumber forkNum)
 			if (PageAddItem(page, (Item) itup, itemsz, InvalidOffsetNumber, false, false) == InvalidOffsetNumber)
 				elog(ERROR, "failed to add index item to \"%s\"", RelationGetRelationName(index));
 
+			pfree(itup);
+
 			buildstate->indtuples += 1;
 
 			GetNextTuple(buildstate->sortstate, tupdesc, slot, &itup, &list);
@@ -275,6 +280,7 @@ InitBuildState(IvfflatBuildState * buildstate, Relation heap, Relation index, In
 	/* Get support functions */
 	buildstate->procinfo = index_getprocinfo(index, 1, IVFFLAT_DISTANCE_PROC);
 	buildstate->normprocinfo = IvfflatOptionalProcInfo(index, IVFFLAT_NORM_PROC);
+	buildstate->kmeansnormprocinfo = IvfflatOptionalProcInfo(index, IVFFLAT_KMEANS_NORM_PROC);
 	buildstate->collation = index->rd_indcollation[0];
 
 	/* Create tuple description for sorting */

src/ivfflat.c

@@ -1,11 +1,14 @@
 #include "postgres.h"
 
+#include <float.h>
+
 #include "access/amapi.h"
 #include "commands/vacuum.h"
 #include "ivfflat.h"
 #include "utils/guc.h"
 #include "utils/selfuncs.h"
 
+int			ivfflat_probes;
 static relopt_kind ivfflat_relopt_kind;
 
 /*
@@ -43,18 +46,29 @@ ivfflatcostestimate(PlannerInfo *root, IndexPath *path, double loop_count,
 	int			lists;
 	double		ratio;
 	Relation	indexRel;
-
 #if PG_VERSION_NUM < 120000
 	List	   *qinfos;
-
-	qinfos = deconstruct_indexquals(path);
 #endif
 
+	/* Never use index without order */
+	if (path->indexorderbys == NULL)
+	{
+		*indexStartupCost = DBL_MAX;
+		*indexTotalCost = DBL_MAX;
+		*indexSelectivity = 0;
+		*indexCorrelation = 0;
+#if PG_VERSION_NUM >= 100000
+		*indexPages = 0;
+#endif
+		return;
+	}
+
 	MemSet(&costs, 0, sizeof(costs));
 
 #if PG_VERSION_NUM >= 120000
 	genericcostestimate(root, path, loop_count, &costs);
 #else
+	qinfos = deconstruct_indexquals(path);
 	genericcostestimate(root, path, loop_count, qinfos, &costs);
 #endif
 

src/ivfflat.h

@@ -38,7 +38,7 @@
 #endif
 
 /* Variables */
-int			ivfflat_probes;
+extern int	ivfflat_probes;
 
 typedef struct VectorArrayData
 {
@@ -81,6 +81,7 @@ typedef struct IvfflatBuildState
 	/* Support functions */
 	FmgrInfo   *procinfo;
 	FmgrInfo   *normprocinfo;
+	FmgrInfo   *kmeansnormprocinfo;
 	Oid			collation;
 
 	/* Variables */

src/ivfscan.c

@@ -251,6 +251,10 @@ ivfflatgettuple(IndexScanDesc scan, ScanDirection dir)
 	{
 		Datum		value;
 
+		/* Safety check */
+		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;

src/vector.c

@@ -10,11 +10,16 @@
 #include "utils/array.h"
 #include "utils/builtins.h"
 #include "utils/lsyscache.h"
+#include "utils/numeric.h"
 
 #if PG_VERSION_NUM >= 120000
 #include "utils/float.h"
 #endif
 
+#if PG_VERSION_NUM < 130000
+#define TYPALIGN_INT 'i'
+#endif
+
 PG_MODULE_MAGIC;
 
 /*
@@ -244,14 +249,20 @@ vector_recv(PG_FUNCTION_ARGS)
 	int32		typmod = PG_GETARG_INT32(2);
 	Vector	   *result;
 	int16		dim;
+	int16		unused;
 	int			i;
 
 	dim = pq_getmsgint(buf, sizeof(int16));
-	pq_getmsgint(buf, sizeof(int16));	/* unused */
+	unused = pq_getmsgint(buf, sizeof(int16));
 
 	CheckDim(dim);
 	CheckExpectedDim(typmod, dim);
 
+	if (unused != 0)
+		ereport(ERROR,
+				(errcode(ERRCODE_DATA_EXCEPTION),
+				 errmsg("expected unused to be 0, not %d", unused)));
+
 	result = InitVector(dim);
 	for (i = 0; i < dim; i++)
 		result->x[i] = pq_getmsgfloat4(buf);
@@ -339,6 +350,8 @@ array_to_vector(PG_FUNCTION_ARGS)
 			result->x[i] = DatumGetFloat8(elemsp[i]);
 		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, NumericGetDatum(elemsp[i])));
 		else
 			ereport(ERROR,
 					(errcode(ERRCODE_DATA_EXCEPTION),
@@ -350,6 +363,29 @@ array_to_vector(PG_FUNCTION_ARGS)
 	PG_RETURN_POINTER(result);
 }
 
+/*
+ * Convert vector to float4[]
+ */
+PG_FUNCTION_INFO_V1(vector_to_float4);
+Datum
+vector_to_float4(PG_FUNCTION_ARGS)
+{
+	Vector	   *vec = PG_GETARG_VECTOR_P(0);
+	Datum	   *d;
+	ArrayType  *result;
+	int			i;
+
+	d = (Datum *) palloc(sizeof(Datum) * vec->dim);
+
+	for (i = 0; i < vec->dim; i++)
+		d[i] = Float4GetDatum(vec->x[i]);
+
+	/* Use TYPALIGN_INT for float4 */
+	result = construct_array(d, vec->dim, FLOAT4OID, sizeof(float4), true, TYPALIGN_INT);
+
+	PG_RETURN_POINTER(result);
+}
+
 /*
  * Get the L2 distance between vectors
  */

test/expected/cast.out

@@ -6,6 +6,12 @@ SELECT ARRAY[1,2,3]::vector;
  [1,2,3]
 (1 row)
 
+SELECT ARRAY[1.0,2.0,3.0]::vector;
+  array  
+---------
+ [1,2,3]
+(1 row)
+
 SELECT ARRAY[1,2,3]::float4[]::vector;
   array  
 ---------
@@ -28,3 +34,11 @@ SELECT '{-Infinity}'::real[]::vector;
 ERROR:  infinite value not allowed in vector
 SELECT '{}'::real[]::vector;
 ERROR:  vector must have at least 1 dimension
+SELECT '[1,2,3]'::vector::real[];
+ float4  
+---------
+ {1,2,3}
+(1 row)
+
+SELECT array_agg(n)::vector FROM generate_series(1, 1025) n;
+ERROR:  vector cannot have more than 1024 dimensions

test/expected/ivfflat_l2.out

@@ -19,4 +19,10 @@ SELECT * FROM t ORDER BY val <-> (SELECT NULL::vector);
 -----
 (0 rows)
 
+SELECT COUNT(*) FROM t;
+ count 
+-------
+     5
+(1 row)
+
 DROP TABLE t;

test/expected/ivfflat_options.out

@@ -0,0 +1,17 @@
+SET client_min_messages = warning;
+CREATE EXTENSION IF NOT EXISTS vector;
+SET enable_seqscan = off;
+CREATE TABLE t (val vector(3));
+CREATE INDEX ON t USING ivfflat (val) WITH (lists = 0);
+ERROR:  value 0 out of bounds for option "lists"
+DETAIL:  Valid values are between "1" and "32768".
+CREATE INDEX ON t USING ivfflat (val) WITH (lists = 32769);
+ERROR:  value 32769 out of bounds for option "lists"
+DETAIL:  Valid values are between "1" and "32768".
+SHOW ivfflat.probes;
+ ivfflat.probes 
+----------------
+ 1
+(1 row)
+
+DROP TABLE t;

test/sql/cast.sql

@@ -2,6 +2,7 @@ SET client_min_messages = warning;
 CREATE EXTENSION IF NOT EXISTS vector;
 
 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 '{NULL}'::real[]::vector;
@@ -9,3 +10,5 @@ SELECT '{NaN}'::real[]::vector;
 SELECT '{Infinity}'::real[]::vector;
 SELECT '{-Infinity}'::real[]::vector;
 SELECT '{}'::real[]::vector;
+SELECT '[1,2,3]'::vector::real[];
+SELECT array_agg(n)::vector FROM generate_series(1, 1025) n;

test/sql/input.sql

@@ -0,0 +1,15 @@
+SET client_min_messages = warning;
+CREATE EXTENSION IF NOT EXISTS vector;
+
+SELECT '[1,2,3]'::vector;
+SELECT '[-1,2,3]'::vector;
+SELECT '[hello,1]'::vector;
+SELECT '[NaN,1]'::vector;
+SELECT '[Infinity,1]'::vector;
+SELECT '[-Infinity,1]'::vector;
+SELECT '[1,2,3'::vector;
+SELECT '[1,2,3]9'::vector;
+SELECT '1,2,3'::vector;
+SELECT '[]'::vector;
+SELECT '[1,]'::vector;
+SELECT '[1,2,3]'::vector(2);

test/sql/ivfflat_l2.sql

@@ -10,5 +10,6 @@ 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 t;
 
 DROP TABLE t;

vector--0.1.1.sql

@@ -1,218 +0,0 @@
--- complain if script is sourced in psql, rather than via CREATE EXTENSION
-\echo Use "CREATE EXTENSION vector" to load this file. \quit
-
--- type
-
-CREATE TYPE vector;
-
-CREATE FUNCTION vector_in(cstring, oid, integer) RETURNS vector
-	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-
-CREATE FUNCTION vector_out(vector) RETURNS cstring
-	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-
-CREATE FUNCTION vector_typmod_in(cstring[]) RETURNS integer
-	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-
-CREATE FUNCTION vector_recv(internal, oid, integer) RETURNS vector
-	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-
-CREATE FUNCTION vector_send(vector) RETURNS bytea
-	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-
-CREATE TYPE vector (
-	INPUT     = vector_in,
-	OUTPUT    = vector_out,
-	TYPMOD_IN = vector_typmod_in,
-	RECEIVE   = vector_recv,
-	SEND      = vector_send
-);
-
--- functions
-
-CREATE FUNCTION l2_distance(vector, vector) RETURNS float8
-	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-
-CREATE FUNCTION inner_product(vector, vector) RETURNS float8
-	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-
-CREATE FUNCTION cosine_distance(vector, vector) RETURNS float8
-	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-
-CREATE FUNCTION vector_dims(vector) RETURNS integer
-	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-
-CREATE FUNCTION vector_norm(vector) RETURNS float8
-	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;
-
-CREATE FUNCTION vector_sub(vector, vector) RETURNS vector
-	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-
--- private functions
-
-CREATE FUNCTION vector_lt(vector, vector) RETURNS bool
-	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-
-CREATE FUNCTION vector_le(vector, vector) RETURNS bool
-	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-
-CREATE FUNCTION vector_eq(vector, vector) RETURNS bool
-	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-
-CREATE FUNCTION vector_ne(vector, vector) RETURNS bool
-	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-
-CREATE FUNCTION vector_ge(vector, vector) RETURNS bool
-	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-
-CREATE FUNCTION vector_gt(vector, vector) RETURNS bool
-	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-
-CREATE FUNCTION vector_cmp(vector, vector) RETURNS int4
-	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-
-CREATE FUNCTION vector_l2_squared_distance(vector, vector) 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;
-
-CREATE FUNCTION vector_spherical_distance(vector, vector) RETURNS float8
-	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-
--- cast functions
-
-CREATE FUNCTION vector(vector, integer, boolean) RETURNS vector
-	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-
-CREATE FUNCTION array_to_vector(integer[], integer, boolean) RETURNS vector
-	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-
-CREATE FUNCTION array_to_vector(real[], integer, boolean) RETURNS vector
-	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-
-CREATE FUNCTION array_to_vector(double precision[], integer, boolean) RETURNS vector
-	AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-
--- casts
-
-CREATE CAST (vector AS vector)
-	WITH FUNCTION vector(vector, integer, boolean) AS IMPLICIT;
-
-CREATE CAST (integer[] AS vector)
-	WITH FUNCTION array_to_vector(integer[], integer, boolean) AS IMPLICIT;
-
-CREATE CAST (real[] AS vector)
-	WITH FUNCTION array_to_vector(real[], integer, boolean) AS IMPLICIT;
-
-CREATE CAST (double precision[] AS vector)
-	WITH FUNCTION array_to_vector(double precision[], integer, boolean) AS IMPLICIT;
-
--- operators
-
-CREATE OPERATOR <-> (
-	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = l2_distance,
-	COMMUTATOR = '<->'
-);
-
-CREATE OPERATOR <#> (
-	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = vector_negative_inner_product,
-	COMMUTATOR = '<#>'
-);
-
-CREATE OPERATOR <=> (
-	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = cosine_distance,
-	COMMUTATOR = '<=>'
-);
-
-CREATE OPERATOR + (
-	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = vector_add,
-	COMMUTATOR = +
-);
-
-CREATE OPERATOR - (
-	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = vector_sub,
-	COMMUTATOR = -
-);
-
-CREATE OPERATOR < (
-	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = vector_lt,
-	COMMUTATOR = > , NEGATOR = >= ,
-	RESTRICT = scalarltsel, JOIN = scalarltjoinsel
-);
-
--- should use scalarlesel and scalarlejoinsel, but not supported in Postgres < 11
-CREATE OPERATOR <= (
-	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = vector_le,
-	COMMUTATOR = >= , NEGATOR = > ,
-	RESTRICT = scalarltsel, JOIN = scalarltjoinsel
-);
-
-CREATE OPERATOR = (
-	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = vector_eq,
-	COMMUTATOR = = , NEGATOR = <> ,
-	RESTRICT = eqsel, JOIN = eqjoinsel
-);
-
-CREATE OPERATOR <> (
-	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = vector_ne,
-	COMMUTATOR = <> , NEGATOR = = ,
-	RESTRICT = eqsel, JOIN = eqjoinsel
-);
-
--- should use scalargesel and scalargejoinsel, but not supported in Postgres < 11
-CREATE OPERATOR >= (
-	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = vector_ge,
-	COMMUTATOR = <= , NEGATOR = < ,
-	RESTRICT = scalargtsel, JOIN = scalargtjoinsel
-);
-
-CREATE OPERATOR > (
-	LEFTARG = vector, RIGHTARG = vector, PROCEDURE = vector_gt,
-	COMMUTATOR = < , NEGATOR = <= ,
-	RESTRICT = scalargtsel, JOIN = scalargtjoinsel
-);
-
--- access method
-
-CREATE FUNCTION ivfflathandler(internal) RETURNS index_am_handler
-	AS 'MODULE_PATHNAME' LANGUAGE C;
-
-CREATE ACCESS METHOD ivfflat TYPE INDEX HANDLER ivfflathandler;
-
-COMMENT ON ACCESS METHOD ivfflat IS 'ivfflat index access method';
-
--- opclasses
-
-CREATE OPERATOR CLASS vector_ops
-	DEFAULT FOR TYPE vector USING btree AS
-	OPERATOR 1 < ,
-	OPERATOR 2 <= ,
-	OPERATOR 3 = ,
-	OPERATOR 4 >= ,
-	OPERATOR 5 > ,
-	FUNCTION 1 vector_cmp(vector, vector);
-
-CREATE OPERATOR CLASS vector_l2_ops
-	DEFAULT FOR TYPE vector USING ivfflat AS
-	OPERATOR 1 <-> (vector, vector) FOR ORDER BY float_ops,
-	FUNCTION 1 vector_l2_squared_distance(vector, vector),
-	FUNCTION 3 l2_distance(vector, vector);
-
-CREATE OPERATOR CLASS vector_ip_ops
-	FOR TYPE vector USING ivfflat AS
-	OPERATOR 1 <#> (vector, vector) FOR ORDER BY float_ops,
-	FUNCTION 1 vector_negative_inner_product(vector, vector),
-	FUNCTION 3 vector_spherical_distance(vector, vector),
-	FUNCTION 4 vector_norm(vector);
-
-CREATE OPERATOR CLASS vector_cosine_ops
-	FOR TYPE vector USING ivfflat AS
-	OPERATOR 1 <=> (vector, vector) FOR ORDER BY float_ops,
-	FUNCTION 1 vector_negative_inner_product(vector, vector),
-	FUNCTION 2 vector_norm(vector),
-	FUNCTION 3 vector_spherical_distance(vector, vector),
-	FUNCTION 4 vector_norm(vector);

vector.control

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