Backport 14.8 - 14.9 changes

contrib/fuzzystrmatch/expected/fuzzystrmatch.out

@@ -23,6 +23,12 @@ SELECT soundex('Anne'), soundex('Margaret'), difference('Anne', 'Margaret');
  A500    | M626    |          0
 (1 row)
 
+SELECT soundex(''), difference('', '');
+ soundex | difference 
+---------+------------
+         |          4
+(1 row)
+
 SELECT levenshtein('GUMBO', 'GAMBOL');
  levenshtein 
 -------------

contrib/fuzzystrmatch/fuzzystrmatch.c

@@ -727,16 +727,14 @@ _soundex(const char *instr, char *outstr)
 	AssertArg(instr);
 	AssertArg(outstr);
 
-	outstr[SOUNDEX_LEN] = '\0';
-
 	/* Skip leading non-alphabetic characters */
-	while (!isalpha((unsigned char) instr[0]) && instr[0])
+	while (*instr && !isalpha((unsigned char) *instr))
 		++instr;
 
-	/* No string left */
-	if (!instr[0])
+	/* If no string left, return all-zeroes buffer */
+	if (!*instr)
 	{
-		outstr[0] = (char) 0;
+		memset(outstr, '\0', SOUNDEX_LEN + 1);
 		return;
 	}
 
@@ -749,7 +747,7 @@ _soundex(const char *instr, char *outstr)
 		if (isalpha((unsigned char) *instr) &&
 			soundex_code(*instr) != soundex_code(*(instr - 1)))
 		{
-			*outstr = soundex_code(instr[0]);
+			*outstr = soundex_code(*instr);
 			if (*outstr != '0')
 			{
 				++outstr;
@@ -766,6 +764,9 @@ _soundex(const char *instr, char *outstr)
 		++outstr;
 		++count;
 	}
+
+	/* And null-terminate */
+	*outstr = '\0';
 }
 
 PG_FUNCTION_INFO_V1(difference);

contrib/fuzzystrmatch/sql/fuzzystrmatch.sql

@@ -6,6 +6,7 @@ SELECT soundex('hello world!');
 SELECT soundex('Anne'), soundex('Ann'), difference('Anne', 'Ann');
 SELECT soundex('Anne'), soundex('Andrew'), difference('Anne', 'Andrew');
 SELECT soundex('Anne'), soundex('Margaret'), difference('Anne', 'Margaret');
+SELECT soundex(''), difference('', '');
 
 
 SELECT levenshtein('GUMBO', 'GAMBOL');

contrib/hstore/Makefile

@@ -22,7 +22,7 @@ PGFILEDESC = "hstore - key/value pair data type"
 
 HEADERS = hstore.h
 
-REGRESS = hstore
+REGRESS = hstore hstore_utf8
 
 ifdef USE_PGXS
 PG_CONFIG = pg_config

contrib/hstore/expected/hstore_utf8.out

@@ -0,0 +1,36 @@
+/*
+ * This test must be run in a database with UTF-8 encoding,
+ * because other encodings don't support all the characters used.
+ */
+SELECT getdatabaseencoding() <> 'UTF8'
+       AS skip_test \gset
+\if :skip_test
+\quit
+\endif
+SET client_encoding = utf8;
+-- UTF-8 locale bug on macOS: isspace(0x85) returns true.  \u0105 encodes
+-- as 0xc4 0x85 in UTF-8; the 0x85 was interpreted here as a whitespace.
+SELECT E'key\u0105=>value\u0105'::hstore;
+      hstore      
+------------------
+ "keyą"=>"valueą"
+(1 row)
+
+SELECT 'keyą=>valueą'::hstore;
+      hstore      
+------------------
+ "keyą"=>"valueą"
+(1 row)
+
+SELECT 'ą=>ą'::hstore;
+  hstore  
+----------
+ "ą"=>"ą"
+(1 row)
+
+SELECT 'keyąfoo=>valueą'::hstore;
+       hstore        
+---------------------
+ "keyąfoo"=>"valueą"
+(1 row)
+

contrib/hstore/expected/hstore_utf8_1.out

@@ -0,0 +1,8 @@
+/*
+ * This test must be run in a database with UTF-8 encoding,
+ * because other encodings don't support all the characters used.
+ */
+SELECT getdatabaseencoding() <> 'UTF8'
+       AS skip_test \gset
+\if :skip_test
+\quit

contrib/hstore/hstore_io.c

@@ -12,6 +12,7 @@
 #include "hstore.h"
 #include "lib/stringinfo.h"
 #include "libpq/pqformat.h"
+#include "parser/scansup.h"
 #include "utils/builtins.h"
 #include "utils/json.h"
 #include "utils/jsonb.h"
@@ -88,7 +89,7 @@ get_val(HSParser *state, bool ignoreeq, bool *escaped)
 			{
 				st = GV_WAITESCIN;
 			}
-			else if (!isspace((unsigned char) *(state->ptr)))
+			else if (!scanner_isspace((unsigned char) *(state->ptr)))
 			{
 				*(state->cur) = *(state->ptr);
 				state->cur++;
@@ -111,7 +112,7 @@ get_val(HSParser *state, bool ignoreeq, bool *escaped)
 				state->ptr--;
 				return true;
 			}
-			else if (isspace((unsigned char) *(state->ptr)))
+			else if (scanner_isspace((unsigned char) *(state->ptr)))
 			{
 				return true;
 			}
@@ -219,7 +220,7 @@ parse_hstore(HSParser *state)
 			{
 				elog(ERROR, "Unexpected end of string");
 			}
-			else if (!isspace((unsigned char) *(state->ptr)))
+			else if (!scanner_isspace((unsigned char) *(state->ptr)))
 			{
 				elog(ERROR, "Syntax error near \"%.*s\" at position %d",
 					 pg_mblen(state->ptr), state->ptr,
@@ -271,7 +272,7 @@ parse_hstore(HSParser *state)
 			{
 				return;
 			}
-			else if (!isspace((unsigned char) *(state->ptr)))
+			else if (!scanner_isspace((unsigned char) *(state->ptr)))
 			{
 				elog(ERROR, "Syntax error near \"%.*s\" at position %d",
 					 pg_mblen(state->ptr), state->ptr,

contrib/hstore/sql/hstore_utf8.sql

@@ -0,0 +1,19 @@
+/*
+ * This test must be run in a database with UTF-8 encoding,
+ * because other encodings don't support all the characters used.
+ */
+
+SELECT getdatabaseencoding() <> 'UTF8'
+       AS skip_test \gset
+\if :skip_test
+\quit
+\endif
+
+SET client_encoding = utf8;
+
+-- UTF-8 locale bug on macOS: isspace(0x85) returns true.  \u0105 encodes
+-- as 0xc4 0x85 in UTF-8; the 0x85 was interpreted here as a whitespace.
+SELECT E'key\u0105=>value\u0105'::hstore;
+SELECT 'keyą=>valueą'::hstore;
+SELECT 'ą=>ą'::hstore;
+SELECT 'keyąfoo=>valueą'::hstore;

contrib/intarray/_int_gist.c

@@ -180,8 +180,10 @@ g_int_compress(PG_FUNCTION_ARGS)
 		PREPAREARR(r);
 
 		if (ARRNELEMS(r) >= 2 * num_ranges)
-			elog(NOTICE, "input array is too big (%d maximum allowed, %d current), use gist__intbig_ops opclass instead",
-				 2 * num_ranges - 1, ARRNELEMS(r));
+			ereport(ERROR,
+					(errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
+					 errmsg("input array is too big (%d maximum allowed, %d current), use gist__intbig_ops opclass instead",
+							2 * num_ranges - 1, ARRNELEMS(r))));
 
 		retval = palloc(sizeof(GISTENTRY));
 		gistentryinit(*retval, PointerGetDatum(r),
@@ -269,7 +271,8 @@ g_int_compress(PG_FUNCTION_ARGS)
 		lenr = internal_size(dr, len);
 		if (lenr < 0 || lenr > MAXNUMELTS)
 			ereport(ERROR,
-					(errmsg("data is too sparse, recreate index using gist__intbig_ops opclass instead")));
+					(errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
+					 errmsg("data is too sparse, recreate index using gist__intbig_ops opclass instead")));
 
 		r = resize_intArrayType(r, len);
 		retval = palloc(sizeof(GISTENTRY));
@@ -331,7 +334,8 @@ g_int_decompress(PG_FUNCTION_ARGS)
 	lenr = internal_size(din, lenin);
 	if (lenr < 0 || lenr > MAXNUMELTS)
 		ereport(ERROR,
-				(errmsg("compressed array is too big, recreate index using gist__intbig_ops opclass instead")));
+				(errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
+				 errmsg("compressed array is too big, recreate index using gist__intbig_ops opclass instead")));
 
 	r = new_intArrayType(lenr);
 	dr = ARRPTR(r);

contrib/intarray/expected/_int.out

@@ -552,6 +552,8 @@ SELECT count(*) from test__int WHERE a @@ '!20 & !21';
   6343
 (1 row)
 
+INSERT INTO test__int SELECT array(SELECT x FROM generate_series(1, 1001) x); -- should fail
+ERROR:  input array is too big (199 maximum allowed, 1001 current), use gist__intbig_ops opclass instead
 DROP INDEX text_idx;
 CREATE INDEX text_idx on test__int using gist (a gist__int_ops(numranges = 0));
 ERROR:  value 0 out of bounds for option "numranges"

contrib/intarray/sql/_int.sql

@@ -112,6 +112,8 @@ SELECT count(*) from test__int WHERE a @@ '(20&23)|(50&68)';
 SELECT count(*) from test__int WHERE a @@ '20 | !21';
 SELECT count(*) from test__int WHERE a @@ '!20 & !21';
 
+INSERT INTO test__int SELECT array(SELECT x FROM generate_series(1, 1001) x); -- should fail
+
 DROP INDEX text_idx;
 CREATE INDEX text_idx on test__int using gist (a gist__int_ops(numranges = 0));
 CREATE INDEX text_idx on test__int using gist (a gist__int_ops(numranges = 1021));

contrib/pageinspect/expected/gist.out

@@ -31,20 +31,25 @@ SELECT * FROM gist_page_opaque_info(get_raw_page('test_gist_idx', 2));
 
 COMMIT;
 SELECT * FROM gist_page_items(get_raw_page('test_gist_idx', 0), 'test_gist_idx');
- itemoffset |   ctid    | itemlen | dead |       keys        
-------------+-----------+---------+------+-------------------
-          1 | (1,65535) |      40 | f    | (p)=((669,669))
-          2 | (2,65535) |      40 | f    | (p)=((1000,1000))
-(2 rows)
+ itemoffset |   ctid    | itemlen | dead |             keys              
+------------+-----------+---------+------+-------------------------------
+          1 | (1,65535) |      40 | f    | (p)=("(166,166),(1,1)")
+          2 | (2,65535) |      40 | f    | (p)=("(332,332),(167,167)")
+          3 | (3,65535) |      40 | f    | (p)=("(498,498),(333,333)")
+          4 | (4,65535) |      40 | f    | (p)=("(664,664),(499,499)")
+          5 | (5,65535) |      40 | f    | (p)=("(830,830),(665,665)")
+          6 | (6,65535) |      40 | f    | (p)=("(996,996),(831,831)")
+          7 | (7,65535) |      40 | f    | (p)=("(1000,1000),(997,997)")
+(7 rows)
 
 SELECT * FROM gist_page_items(get_raw_page('test_gist_idx', 1), 'test_gist_idx') LIMIT 5;
- itemoffset | ctid  | itemlen | dead |    keys     
-------------+-------+---------+------+-------------
-          1 | (0,1) |      40 | f    | (p)=((1,1))
-          2 | (0,2) |      40 | f    | (p)=((2,2))
-          3 | (0,3) |      40 | f    | (p)=((3,3))
-          4 | (0,4) |      40 | f    | (p)=((4,4))
-          5 | (0,5) |      40 | f    | (p)=((5,5))
+ itemoffset | ctid  | itemlen | dead |        keys         
+------------+-------+---------+------+---------------------
+          1 | (0,1) |      40 | f    | (p)=("(1,1),(1,1)")
+          2 | (0,2) |      40 | f    | (p)=("(2,2),(2,2)")
+          3 | (0,3) |      40 | f    | (p)=("(3,3),(3,3)")
+          4 | (0,4) |      40 | f    | (p)=("(4,4),(4,4)")
+          5 | (0,5) |      40 | f    | (p)=("(5,5),(5,5)")
 (5 rows)
 
 -- gist_page_items_bytea prints the raw key data as a bytea. The output of that is
@@ -99,4 +104,27 @@ SELECT gist_page_opaque_info(decode(repeat('00', :block_size), 'hex'));
 
 (1 row)
 
+-- Test gist_page_items with included columns.
+-- Non-leaf pages contain only the key attributes, and leaf pages contain
+-- the included attributes.
+ALTER TABLE test_gist ADD COLUMN i int DEFAULT NULL;
+CREATE INDEX test_gist_idx_inc ON test_gist
+  USING gist (p) INCLUDE (t, i);
+-- Mask the value of the key attribute to avoid alignment issues.
+SELECT regexp_replace(keys, '\(p\)=\("(.*?)"\)', '(p)=("<val>")') AS keys_nonleaf_1
+  FROM gist_page_items(get_raw_page('test_gist_idx_inc', 0), 'test_gist_idx_inc')
+  WHERE itemoffset = 1;
+ keys_nonleaf_1 
+----------------
+ (p)=("<val>")
+(1 row)
+
+SELECT keys AS keys_leaf_1
+  FROM gist_page_items(get_raw_page('test_gist_idx_inc', 1), 'test_gist_idx_inc')
+  WHERE itemoffset = 1;
+                     keys_leaf_1                      
+------------------------------------------------------
+ (p) INCLUDE (t, i)=("(1,1),(1,1)") INCLUDE (1, null)
+(1 row)
+
 DROP TABLE test_gist;