Moved sql and test files

test/expected/btree.out

@@ -0,0 +1,19 @@
+SET client_min_messages = warning;
+CREATE EXTENSION IF NOT EXISTS vector;
+SET enable_seqscan = off;
+CREATE TABLE t (val vector(3));
+INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
+CREATE INDEX ON t (val);
+SELECT * FROM t WHERE val = '[1,2,3]';
+   val   
+---------
+ [1,2,3]
+(1 row)
+
+SELECT * FROM t ORDER BY val LIMIT 1;
+   val   
+---------
+ [0,0,0]
+(1 row)
+
+DROP TABLE t;

test/expected/cast.out

@@ -0,0 +1,30 @@
+SET client_min_messages = warning;
+CREATE EXTENSION IF NOT EXISTS vector;
+SELECT ARRAY[1,2,3]::vector;
+  array  
+---------
+ [1,2,3]
+(1 row)
+
+SELECT ARRAY[1,2,3]::float4[]::vector;
+  array  
+---------
+ [1,2,3]
+(1 row)
+
+SELECT ARRAY[1,2,3]::float8[]::vector;
+  array  
+---------
+ [1,2,3]
+(1 row)
+
+SELECT '{NULL}'::real[]::vector;
+ERROR:  array must not containing NULLs
+SELECT '{NaN}'::real[]::vector;
+ERROR:  NaN not allowed in vector
+SELECT '{Infinity}'::real[]::vector;
+ERROR:  infinite value not allowed in vector
+SELECT '{-Infinity}'::real[]::vector;
+ERROR:  infinite value not allowed in vector
+SELECT '{}'::real[]::vector;
+ERROR:  vector must have at least 1 dimension

test/expected/copy.out

@@ -0,0 +1,18 @@
+SET client_min_messages = warning;
+CREATE EXTENSION IF NOT EXISTS vector;
+CREATE TABLE t (val vector(3));
+INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
+CREATE TABLE t2 (val vector(3));
+\copy t TO '/tmp/data.bin' WITH (FORMAT binary)
+\copy t2 FROM '/tmp/data.bin' WITH (FORMAT binary)
+SELECT * FROM t2 ORDER BY val;
+   val   
+---------
+ [0,0,0]
+ [1,1,1]
+ [1,2,3]
+ 
+(4 rows)
+
+DROP TABLE t;
+DROP TABLE t2;

test/expected/functions.out

@@ -0,0 +1,56 @@
+SET client_min_messages = warning;
+CREATE EXTENSION IF NOT EXISTS vector;
+SELECT '[1,2,3]'::vector + '[4,5,6]';
+ ?column? 
+----------
+ [5,7,9]
+(1 row)
+
+SELECT '[1,2,3]'::vector - '[4,5,6]';
+  ?column?  
+------------
+ [-3,-3,-3]
+(1 row)
+
+SELECT vector_dims('[1,2,3]');
+ vector_dims 
+-------------
+           3
+(1 row)
+
+SELECT round(vector_norm('[1,1]')::numeric, 5);
+  round  
+---------
+ 1.41421
+(1 row)
+
+SELECT round(l2_distance('[1,2]', '[0,0]')::numeric, 5);
+  round  
+---------
+ 2.23607
+(1 row)
+
+SELECT l2_distance('[1,2]', '[3]');
+ERROR:  different vector dimensions 2 and 1
+SELECT inner_product('[1,2]', '[3,4]');
+ inner_product 
+---------------
+            11
+(1 row)
+
+SELECT inner_product('[1,2]', '[3]');
+ERROR:  different vector dimensions 2 and 1
+SELECT round(cosine_distance('[1,2]', '[2,4]')::numeric, 5);
+  round  
+---------
+ 0.00000
+(1 row)
+
+SELECT cosine_distance('[1,2]', '[0,0]');
+ cosine_distance 
+-----------------
+             NaN
+(1 row)
+
+SELECT cosine_distance('[1,2]', '[3]');
+ERROR:  different vector dimensions 2 and 1

test/expected/ivfflat_cosine.out

@@ -0,0 +1,21 @@
+SET client_min_messages = warning;
+CREATE EXTENSION IF NOT EXISTS vector;
+SET enable_seqscan = off;
+CREATE TABLE t (val vector(3));
+INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
+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]';
+   val   
+---------
+ [1,1,1]
+ [1,2,3]
+ [1,2,4]
+(3 rows)
+
+SELECT * FROM t ORDER BY val <=> (SELECT NULL::vector);
+ val 
+-----
+(0 rows)
+
+DROP TABLE t;

test/expected/ivfflat_ip.out

@@ -0,0 +1,22 @@
+SET client_min_messages = warning;
+CREATE EXTENSION IF NOT EXISTS vector;
+SET enable_seqscan = off;
+CREATE TABLE t (val vector(3));
+INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
+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]';
+   val   
+---------
+ [1,2,4]
+ [1,2,3]
+ [1,1,1]
+ [0,0,0]
+(4 rows)
+
+SELECT * FROM t ORDER BY val <#> (SELECT NULL::vector);
+ val 
+-----
+(0 rows)
+
+DROP TABLE t;

test/expected/ivfflat_l2.out

@@ -0,0 +1,22 @@
+SET client_min_messages = warning;
+CREATE EXTENSION IF NOT EXISTS vector;
+SET enable_seqscan = off;
+CREATE TABLE t (val vector(3));
+INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
+CREATE INDEX ON t USING ivfflat (val) WITH (lists = 1);
+INSERT INTO t (val) VALUES ('[1,2,4]');
+SELECT * FROM t ORDER BY val <-> '[3,3,3]';
+   val   
+---------
+ [1,2,3]
+ [1,2,4]
+ [1,1,1]
+ [0,0,0]
+(4 rows)
+
+SELECT * FROM t ORDER BY val <-> (SELECT NULL::vector);
+ val 
+-----
+(0 rows)
+
+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/expected/ivfflat_unlogged.out

@@ -0,0 +1,15 @@
+SET client_min_messages = warning;
+CREATE EXTENSION IF NOT EXISTS vector;
+SET enable_seqscan = off;
+CREATE UNLOGGED TABLE t (val vector(3));
+INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
+CREATE INDEX ON t USING ivfflat (val) WITH (lists = 1);
+SELECT * FROM t ORDER BY val <-> '[3,3,3]';
+   val   
+---------
+ [1,2,3]
+ [1,1,1]
+ [0,0,0]
+(3 rows)
+
+DROP TABLE t;

test/expected/vector.out

@@ -0,0 +1,55 @@
+SET client_min_messages = warning;
+CREATE EXTENSION IF NOT EXISTS vector;
+SELECT '[1,2,3]'::vector;
+ vector  
+---------
+ [1,2,3]
+(1 row)
+
+SELECT '[-1,2,3]'::vector;
+  vector  
+----------
+ [-1,2,3]
+(1 row)
+
+SELECT '[hello,1]'::vector;
+ERROR:  invalid input syntax for type vector: "hello"
+LINE 1: SELECT '[hello,1]'::vector;
+               ^
+SELECT '[NaN,1]'::vector;
+ERROR:  NaN not allowed in vector
+LINE 1: SELECT '[NaN,1]'::vector;
+               ^
+SELECT '[Infinity,1]'::vector;
+ERROR:  infinite value not allowed in vector
+LINE 1: SELECT '[Infinity,1]'::vector;
+               ^
+SELECT '[-Infinity,1]'::vector;
+ERROR:  infinite value not allowed in vector
+LINE 1: SELECT '[-Infinity,1]'::vector;
+               ^
+SELECT '[1,2,3'::vector;
+ERROR:  malformed vector literal
+LINE 1: SELECT '[1,2,3'::vector;
+               ^
+DETAIL:  Unexpected end of input.
+SELECT '[1,2,3]9'::vector;
+ERROR:  malformed vector literal
+LINE 1: SELECT '[1,2,3]9'::vector;
+               ^
+DETAIL:  Junk after closing right brace.
+SELECT '1,2,3'::vector;
+ERROR:  malformed vector literal: "1,2,3"
+LINE 1: SELECT '1,2,3'::vector;
+               ^
+DETAIL:  Vector contents must start with "[".
+SELECT '[]'::vector;
+ERROR:  vector must have at least 1 dimension
+LINE 1: SELECT '[]'::vector;
+               ^
+SELECT '[1,]'::vector;
+ERROR:  invalid input syntax for type vector: "]"
+LINE 1: SELECT '[1,]'::vector;
+               ^
+SELECT '[1,2,3]'::vector(2);
+ERROR:  expected 2 dimensions, not 3

test/sql/btree.sql

@@ -0,0 +1,12 @@
+SET client_min_messages = warning;
+CREATE EXTENSION IF NOT EXISTS vector;
+SET enable_seqscan = off;
+
+CREATE TABLE t (val vector(3));
+INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
+CREATE INDEX ON t (val);
+
+SELECT * FROM t WHERE val = '[1,2,3]';
+SELECT * FROM t ORDER BY val LIMIT 1;
+
+DROP TABLE t;

test/sql/cast.sql

@@ -0,0 +1,11 @@
+SET client_min_messages = warning;
+CREATE EXTENSION IF NOT EXISTS vector;
+
+SELECT ARRAY[1,2,3]::vector;
+SELECT ARRAY[1,2,3]::float4[]::vector;
+SELECT ARRAY[1,2,3]::float8[]::vector;
+SELECT '{NULL}'::real[]::vector;
+SELECT '{NaN}'::real[]::vector;
+SELECT '{Infinity}'::real[]::vector;
+SELECT '{-Infinity}'::real[]::vector;
+SELECT '{}'::real[]::vector;

test/sql/copy.sql

@@ -0,0 +1,15 @@
+SET client_min_messages = warning;
+CREATE EXTENSION IF NOT EXISTS vector;
+
+CREATE TABLE t (val vector(3));
+INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
+
+CREATE TABLE t2 (val vector(3));
+
+\copy t TO '/tmp/data.bin' WITH (FORMAT binary)
+\copy t2 FROM '/tmp/data.bin' WITH (FORMAT binary)
+
+SELECT * FROM t2 ORDER BY val;
+
+DROP TABLE t;
+DROP TABLE t2;

test/sql/functions.sql

@@ -0,0 +1,18 @@
+SET client_min_messages = warning;
+CREATE EXTENSION IF NOT EXISTS vector;
+
+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 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 round(cosine_distance('[1,2]', '[2,4]')::numeric, 5);
+SELECT cosine_distance('[1,2]', '[0,0]');
+SELECT cosine_distance('[1,2]', '[3]');

test/sql/ivfflat_cosine.sql

@@ -0,0 +1,14 @@
+SET client_min_messages = warning;
+CREATE EXTENSION IF NOT EXISTS vector;
+SET enable_seqscan = off;
+
+CREATE TABLE t (val vector(3));
+INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
+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);
+
+DROP TABLE t;

test/sql/ivfflat_ip.sql

@@ -0,0 +1,14 @@
+SET client_min_messages = warning;
+CREATE EXTENSION IF NOT EXISTS vector;
+SET enable_seqscan = off;
+
+CREATE TABLE t (val vector(3));
+INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
+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);
+
+DROP TABLE t;

test/sql/ivfflat_l2.sql

@@ -0,0 +1,14 @@
+SET client_min_messages = warning;
+CREATE EXTENSION IF NOT EXISTS vector;
+SET enable_seqscan = off;
+
+CREATE TABLE t (val vector(3));
+INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
+CREATE INDEX ON t USING ivfflat (val) 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);
+
+DROP TABLE t;

test/sql/ivfflat_options.sql

@@ -0,0 +1,11 @@
+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);
+CREATE INDEX ON t USING ivfflat (val) WITH (lists = 32769);
+
+SHOW ivfflat.probes;
+
+DROP TABLE t;

test/sql/ivfflat_unlogged.sql

@@ -0,0 +1,11 @@
+SET client_min_messages = warning;
+CREATE EXTENSION IF NOT EXISTS vector;
+SET enable_seqscan = off;
+
+CREATE UNLOGGED TABLE t (val vector(3));
+INSERT INTO t (val) VALUES ('[0,0,0]'), ('[1,2,3]'), ('[1,1,1]'), (NULL);
+CREATE INDEX ON t USING ivfflat (val) WITH (lists = 1);
+
+SELECT * FROM t ORDER BY val <-> '[3,3,3]';
+
+DROP TABLE t;

test/sql/vector.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/t/001_wal.pl

@@ -0,0 +1,88 @@
+# Based on postgres/contrib/bloom/t/001_wal.pl
+
+# Test generic xlog record work for ivfflat index replication.
+use strict;
+use warnings;
+use PostgresNode;
+use TestLib;
+use Test::More tests => 31;
+
+my $node_primary;
+my $node_replica;
+
+# Run few queries on both primary and replica and check their results match.
+sub test_index_replay
+{
+	my ($test_name) = @_;
+
+	# Wait for replica to catch up
+	my $applname = $node_replica->name;
+
+	my $caughtup_query;
+	my $server_version_num = $node_primary->safe_psql("postgres", "SHOW server_version_num");
+	if ($server_version_num >= 100000) {
+		$caughtup_query = "SELECT pg_current_wal_lsn() <= replay_lsn FROM pg_stat_replication WHERE application_name = '$applname';";
+	} else {
+		# TODO figure out why replay location doesn't work
+		$caughtup_query = "SELECT pg_current_xlog_location() <= write_location FROM pg_stat_replication WHERE application_name = '$applname';";
+	}
+
+	$node_primary->poll_query_until('postgres', $caughtup_query)
+	  or die "Timed out while waiting for replica 1 to catch up";
+
+	my $r1 = rand();
+	my $r2 = rand();
+	my $r3 = rand();
+
+	my $queries = qq(SET enable_seqscan=off;
+SELECT * FROM tst ORDER BY v <-> '[$r1,$r2,$r3]' LIMIT 10;
+);
+
+	# Run test queries and compare their result
+	my $primary_result = $node_primary->safe_psql("postgres", $queries);
+	my $replica_result = $node_replica->safe_psql("postgres", $queries);
+
+	is($primary_result, $replica_result, "$test_name: query result matches");
+	return;
+}
+
+# Initialize primary node
+$node_primary = get_new_node('primary');
+$node_primary->init(allows_streaming => 1);
+$node_primary->start;
+my $backup_name = 'my_backup';
+
+# Take backup
+$node_primary->backup($backup_name);
+
+# Create streaming replica linking to primary
+$node_replica = get_new_node('replica');
+$node_replica->init_from_backup($node_primary, $backup_name,
+	has_streaming => 1);
+$node_replica->start;
+
+# Create ivfflat index on primary
+$node_primary->safe_psql("postgres", "CREATE EXTENSION vector;");
+$node_primary->safe_psql("postgres", "CREATE TABLE tst (i int4, v vector(3));");
+$node_primary->safe_psql("postgres",
+	"INSERT INTO tst SELECT i%10, ARRAY[random(), random(), random()] FROM generate_series(1,100000) i;"
+);
+$node_primary->safe_psql("postgres",
+	"CREATE INDEX ON tst USING ivfflat (v);");
+
+# Test that queries give same result
+test_index_replay('initial');
+
+# Run 10 cycles of table modification. Run test queries after each modification.
+for my $i (1 .. 10)
+{
+	$node_primary->safe_psql("postgres", "DELETE FROM tst WHERE i = $i;");
+	test_index_replay("delete $i");
+	$node_primary->safe_psql("postgres", "VACUUM tst;");
+	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[random(), random(), random()] FROM generate_series($start,$end) i;"
+	);
+	test_index_replay("insert $i");
+}