Merge branch 'master' into stable

Author: ololobus

.gitignore

@@ -38,6 +38,7 @@ lib*.pc
 /pgsql.sln.cache
 /Debug/
 /Release/
+/log/
 /tmp_install/
 Dockerfile
 pg_variables--1.1.sql

README.md

@@ -38,6 +38,10 @@ SELECT pgv_get('vars', 'trans_int', NULL::int);
      101
 ```
 
+You can aggregate variables into packages. This is done to be able to have
+variables with different names or to quickly remove the whole batch of
+variables. If the package becomes empty, it is automatically deleted.
+
 ## License
 
 This module available under the [license](LICENSE) similar to
@@ -56,7 +60,7 @@ Typical installation procedure may look like this:
 ## Module functions
 
 The functions provided by the **pg_variables** module are shown in the tables
-below. The module supports the following scalar and record types.
+below.
 
 To use **pgv_get()** function required package and variable must exists. It is
 necessary to set variable with **pgv_set()** function to use **pgv_get()**
@@ -98,6 +102,28 @@ Function | Returns
 `pgv_set(package text, name text, value anyarray, is_transactional bool default false)` | `void`
 `pgv_get(package text, name text, var_type anyarray, strict bool default true)` | `anyarray`
 
+`pgv_set` arguments:
+- `package` - name of the package, it will be created if it doesn't exist.
+- `name` - name of the variable, it will be created if it doesn't exist.
+`pgv_set` fails if the variable already exists and its transactionality doesn't
+match `is_transactional` argument.
+- `value` - new value for the variable. `pgv_set` fails if the variable already
+exists and its type doesn't match new value's type.
+- `is_transactional` - transactionality of the newly created variable, by
+default it is false.
+
+`pgv_get` arguments:
+- `package` - name of the existing package. If the package doesn't exist result
+depends on `strict` argument: if it is false then `pgv_get` returns NULL
+otherwise it fails.
+- `name` - name of the the existing variable. If the variable doesn't exist
+result depends on `strict` argument: if it is false then `pgv_get` returns NULL
+otherwise it fails.
+- `var_type` - type of the existing variable. It is necessary to pass it to get
+correct return type.
+- `strict` - pass false if `pgv_get` shouldn't raise an error if a variable or a
+package didn't created before, by default it is true.
+
 ## **Deprecated** scalar variables functions
 
 ### Integer variables

expected/pg_variables.out

@@ -1,4 +1,19 @@
 CREATE EXTENSION pg_variables;
+-- Test packages - sanity checks
+SELECT pgv_free();
+ pgv_free 
+----------
+ 
+(1 row)
+
+SELECT pgv_exists(NULL); -- fail
+ERROR:  package name can not be NULL
+SELECT pgv_remove(NULL); -- fail
+ERROR:  package name can not be NULL
+SELECT pgv_remove('vars'); -- fail
+ERROR:  unrecognized package "vars"
+SELECT pgv_exists('vars111111111111111111111111111111111111111111111111111111111111'); -- fail
+ERROR:  name "vars111111111111111111111111111111111111111111111111111111111111" is too long
 -- Integer variables
 SELECT pgv_get_int('vars', 'int1');
 ERROR:  unrecognized package "vars"
@@ -553,20 +568,44 @@ SELECT pgv_insert('vars3', 'r1', row(1, 1));
 ERROR:  new record structure differs from variable "r1" structure
 SELECT pgv_insert('vars3', 'r1', row('str1', 'str1'));
 ERROR:  new record structure differs from variable "r1" structure
-SELECT pgv_select('vars3', 'r1') LIMIT 2;
- pgv_select 
+SELECT pgv_select('vars3', 'r1', ARRAY[[1,2]]); -- fail
+ERROR:  searching for elements in multidimensional arrays is not supported
+-- Test variables caching
+SELECT pgv_insert('vars3', 'r2', row(1, 'str1', 'str2'));
+ pgv_insert 
 ------------
- (,strNULL)
- (1,str11)
-(2 rows)
+ 
+(1 row)
 
-SELECT pgv_select('vars3', 'r1') LIMIT 2 OFFSET 2;
- pgv_select 
+SELECT pgv_update('vars3', 'r1', row(3, 'str22'::varchar));
+ pgv_update 
 ------------
- (2,)
- (0,str00)
-(2 rows)
+ f
+(1 row)
 
+SELECT pgv_update('vars4', 'r1', row(3, 'str22'::varchar)); -- fail
+ERROR:  unrecognized package "vars4"
+select pgv_delete('vars3', 'r2', NULL::int);
+ pgv_delete 
+------------
+ f
+(1 row)
+
+select pgv_delete('vars4', 'r2', NULL::int); -- fail
+ERROR:  unrecognized package "vars4"
+-- Test NULL values
+SELECT pgv_insert('vars3', 'r2', NULL); -- fail
+ERROR:  record argument can not be NULL
+SELECT pgv_update('vars3', 'r2', NULL); -- fail
+ERROR:  record argument can not be NULL
+select pgv_delete('vars3', 'r2', NULL::int);
+ pgv_delete 
+------------
+ f
+(1 row)
+
+SELECT pgv_select('vars3', 'r1', NULL::int[]); -- fail
+ERROR:  array argument can not be NULL
 SELECT pgv_select('vars3', 'r1');
  pgv_select 
 ------------
@@ -582,6 +621,8 @@ SELECT pgv_select('vars3', 'r1', 1);
  (1,str11)
 (1 row)
 
+SELECT pgv_select('vars3', 'r1', 1::float); -- fail
+ERROR:  requested value type differs from variable "r1" key type
 SELECT pgv_select('vars3', 'r1', 0);
  pgv_select 
 ------------
@@ -612,6 +653,12 @@ SELECT pgv_update('vars3', 'r1', tab) FROM tab;
  t
 (4 rows)
 
+SELECT pgv_update('vars3', 'r1', row(4, 'str44'::varchar));
+ pgv_update 
+------------
+ f
+(1 row)
+
 SELECT pgv_select('vars3', 'r1');
  pgv_select 
 ------------
@@ -657,6 +704,119 @@ SELECT pgv_exists('vars3', 'r1');
 
 SELECT pgv_select('vars2', 'j1');
 ERROR:  variable "j1" requires "jsonb" value
+-- PGPRO-2601 - Test pgv_select() on TupleDesc of dropped table
+DROP TABLE tab;
+SELECT pgv_select('vars3', 'r1');
+ pgv_select 
+------------
+ (,strNULL)
+ (2,)
+ (0,str00)
+(3 rows)
+
+-- Tests for SRF's sequential scan of an internal hash table
+DO
+$$BEGIN
+    PERFORM pgv_select('vars3', 'r1') LIMIT 2 OFFSET 2;
+    PERFORM pgv_select('vars3', 'r3');
+END$$;
+ERROR:  unrecognized variable "r3"
+CONTEXT:  SQL statement "SELECT pgv_select('vars3', 'r3')"
+PL/pgSQL function inline_code_block line 3 at PERFORM
+-- Check that the hash table was cleaned up after rollback
+SET client_min_messages to 'ERROR';
+SELECT pgv_select('vars3', 'r1', 1);
+ pgv_select 
+------------
+ 
+(1 row)
+
+SELECT pgv_select('vars3', 'r1') LIMIT 2; -- warning
+ pgv_select 
+------------
+ (,strNULL)
+ (2,)
+(2 rows)
+
+SELECT pgv_select('vars3', 'r1') LIMIT 2 OFFSET 2;
+ pgv_select 
+------------
+ (0,str00)
+(1 row)
+
+-- PGPRO-2601 - Test a cursor with the hash table
+BEGIN;
+DECLARE r1_cur CURSOR FOR SELECT pgv_select('vars3', 'r1');
+FETCH 1 in r1_cur;
+ pgv_select 
+------------
+ (,strNULL)
+(1 row)
+
+SELECT pgv_select('vars3', 'r1');
+ pgv_select 
+------------
+ (,strNULL)
+ (2,)
+ (0,str00)
+(3 rows)
+
+FETCH 1 in r1_cur;
+ pgv_select 
+------------
+ (2,)
+(1 row)
+
+CLOSE r1_cur;
+COMMIT; -- warning
+RESET client_min_messages;
+-- Clean memory after unsuccessful creation of a variable
+SELECT pgv_insert('vars4', 'r1', row('str1', 'str1')); -- fail
+ERROR:  could not identify a hash function for type unknown
+SELECT package FROM pgv_stats() WHERE package = 'vars4';
+ package 
+---------
+(0 rows)
+
+-- Remove package if it is empty
+SELECT pgv_insert('vars4', 'r2', row(1, 'str1', 'str2'));
+ pgv_insert 
+------------
+ 
+(1 row)
+
+SELECT pgv_remove('vars4', 'r2');
+ pgv_remove 
+------------
+ 
+(1 row)
+
+SELECT package FROM pgv_stats() WHERE package = 'vars4';
+ package 
+---------
+(0 rows)
+
+-- Record variables as scalar
+SELECT pgv_set('vars5', 'r1', row(1, 'str11'));
+ pgv_set 
+---------
+ 
+(1 row)
+
+SELECT pgv_get('vars5', 'r1', NULL::record);
+  pgv_get  
+-----------
+ (1,str11)
+(1 row)
+
+SELECT pgv_set('vars5', 'r1', row(1, 'str11'), true); -- fail
+ERROR:  variable "r1" already created as NOT TRANSACTIONAL
+SELECT pgv_insert('vars5', 'r1', row(1, 'str11')); -- fail
+ERROR:  "r1" isn't a record variable
+SELECT pgv_select('vars5', 'r1'); -- fail
+ERROR:  "r1" isn't a record variable
+SELECT pgv_get('vars3', 'r1', NULL::record); -- fail
+ERROR:  "r1" isn't a scalar variable
 -- Manipulate variables
 SELECT * FROM pgv_list() order by package, name;
  package |   name   | is_transactional 
@@ -683,15 +843,18 @@ SELECT * FROM pgv_list() order by package, name;
  vars2   | j1       | f
  vars2   | j2       | f
  vars3   | r1       | f
-(22 rows)
+ vars3   | r2       | f
+ vars5   | r1       | f
+(24 rows)
 
 SELECT package FROM pgv_stats() order by package;
  package 
 ---------
  vars
  vars2
  vars3
-(3 rows)
+ vars5
+(4 rows)
 
 SELECT pgv_remove('vars', 'int3');
 ERROR:  unrecognized variable "int3"
@@ -745,7 +908,9 @@ SELECT * FROM pgv_list() order by package, name;
  vars    | tstz2    | f
  vars    | tstzNULL | f
  vars3   | r1       | f
-(19 rows)
+ vars3   | r2       | f
+ vars5   | r1       | f
+(21 rows)
 
 SELECT pgv_free();
  pgv_free 

expected/pg_variables_trans.out

@@ -63,7 +63,8 @@ typedef struct TransState
 /* List node that stores one of the package's states */
 typedef struct PackState
 {
-	TransState	state;
+	TransState		state;
+	unsigned long	trans_var_num; /* Number of valid transactional variables */
 }			PackState;
 
 /* List node that stores one of the variable's states */
@@ -101,6 +102,11 @@ typedef struct Variable
 	TransObject transObject;
 	Package    *package;
 	Oid			typid;
+	/*
+	 * We need an additional flag to determine variable's type since we can
+	 * store record type DATUM within scalar variable
+	 */
+	bool		is_record;
 
 	/*
 	 * The flag determines the further behavior of the variable. Can be
@@ -122,7 +128,7 @@ typedef struct HashRecordKey
 typedef struct HashRecordEntry
 {
 	HashRecordKey key;
-	HeapTuple	tuple;
+	Datum		tuple;
 }			HashRecordEntry;
 
 /* Element of list with objects created, changed or removed within transaction */
@@ -155,6 +161,8 @@ extern void check_record_key(Variable *variable, Oid typid);
 extern void insert_record(Variable *variable, HeapTupleHeader tupleHeader);
 extern bool update_record(Variable *variable, HeapTupleHeader tupleHeader);
 extern bool delete_record(Variable *variable, Datum value, bool is_null);
+extern void insert_record_copy(RecordVar *dest_record, Datum src_tuple,
+							   Variable *variable);
 extern void removeObject(TransObject *object, TransObjectType type);
 
 #define GetActualState(object) \
@@ -163,12 +171,11 @@ extern void removeObject(TransObject *object, TransObjectType type);
 #define GetActualValue(variable) \
 	(((VarState *) GetActualState(variable))->value)
 
+#define GetPackState(package) \
+	(((PackState *) GetActualState(package)))
+
 #define GetName(object) \
 	(AssertVariableIsOfTypeMacro(object->transObject, TransObject), \
 	 object->transObject.name)
 
-#define GetStateStorage(object) \
-	(AssertVariableIsOfTypeMacro(object->transObject, TransObject), \
-	 &(object->transObject.states))
-
 #endif							/* __PG_VARIABLES_H__ */

pg_variables.c

@@ -8,8 +8,10 @@
  *-------------------------------------------------------------------------
  */
 #include "postgres.h"
+#include "funcapi.h"
 
 #include "access/htup_details.h"
+#include "access/tuptoaster.h"
 #include "catalog/pg_collation.h"
 #include "catalog/pg_type.h"
 #include "utils/builtins.h"
@@ -134,7 +136,13 @@ init_record(RecordVar *record, TupleDesc tupdesc, Variable *variable)
 #endif
 
 	oldcxt = MemoryContextSwitchTo(record->hctx);
-	record->tupdesc = CreateTupleDescCopyConstr(tupdesc);
+	record->tupdesc = CreateTupleDescCopy(tupdesc);
+#if PG_VERSION_NUM < 120000
+	record->tupdesc->tdhasoid = false;
+#endif
+	record->tupdesc->tdtypeid = RECORDOID;
+	record->tupdesc->tdtypmod = -1;
+	record->tupdesc = BlessTupleDesc(record->tupdesc);
 
 	/* Initialize hash table. */
 	ctl.keysize = sizeof(HashRecordKey);
@@ -206,15 +214,78 @@ check_record_key(Variable *variable, Oid typid)
 						"key type", GetName(variable))));
 }
 
+static Datum
+copy_record_tuple(RecordVar *record, HeapTupleHeader tupleHeader)
+{
+	TupleDesc	tupdesc;
+	HeapTupleHeader result;
+	int			tuple_len;
+
+	tupdesc = record->tupdesc;
+
+	/*
+	 * If the tuple contains any external TOAST pointers, we have to inline
+	 * those fields to meet the conventions for composite-type Datums.
+	 */
+	if (HeapTupleHeaderHasExternal(tupleHeader))
+		return toast_flatten_tuple_to_datum(tupleHeader,
+									HeapTupleHeaderGetDatumLength(tupleHeader),
+											tupdesc);
+
+	/*
+	 * Fast path for easy case: just make a palloc'd copy and insert the
+	 * correct composite-Datum header fields (since those may not be set if
+	 * the given tuple came from disk, rather than from heap_form_tuple).
+	 */
+	tuple_len = HeapTupleHeaderGetDatumLength(tupleHeader);
+	result = (HeapTupleHeader) palloc(tuple_len);
+	memcpy((char *) result, (char *) tupleHeader, tuple_len);
+
+	HeapTupleHeaderSetDatumLength(result, tuple_len);
+	HeapTupleHeaderSetTypeId(result, tupdesc->tdtypeid);
+	HeapTupleHeaderSetTypMod(result, tupdesc->tdtypmod);
+
+	return PointerGetDatum(result);
+}
+
+static Datum
+get_record_key(Datum tuple, TupleDesc tupdesc, bool *isnull)
+{
+	HeapTupleHeader th = (HeapTupleHeader) DatumGetPointer(tuple);
+	bool		hasnulls = th->t_infomask & HEAP_HASNULL;
+	bits8	   *bp = th->t_bits;		/* ptr to null bitmap in tuple */
+	char	   *tp;						/* ptr to tuple data */
+	long		off;					/* offset in tuple data */
+	int			keyatt = 0;
+	Form_pg_attribute attr = GetTupleDescAttr(tupdesc, keyatt);
+
+	if (hasnulls && att_isnull(keyatt, bp))
+	{
+		*isnull = true;
+		return (Datum) NULL;
+	}
+
+	tp = (char *) th + th->t_hoff;
+	off = 0;
+	if (attr->attlen == -1)
+		off = att_align_pointer(off, attr->attalign, -1, tp + off);
+	else
+	{
+		/* not varlena, so safe to use att_align_nominal */
+		off = att_align_nominal(off, attr->attalign);
+	}
+
+	*isnull = false;
+	return fetchatt(attr, tp + off);
+}
+
 /*
  * Insert a new record. New record key should be unique in the variable.
  */
 void
 insert_record(Variable *variable, HeapTupleHeader tupleHeader)
 {
-	TupleDesc	tupdesc;
-	HeapTuple	tuple;
-	int			tuple_len;
+	Datum		tuple;
 	Datum		value;
 	bool		isnull;
 	RecordVar  *record;
@@ -229,20 +300,10 @@ insert_record(Variable *variable, HeapTupleHeader tupleHeader)
 
 	oldcxt = MemoryContextSwitchTo(record->hctx);
 
-	tupdesc = record->tupdesc;
-
-	/* Build a HeapTuple control structure */
-	tuple_len = HeapTupleHeaderGetDatumLength(tupleHeader);
-
-	tuple = (HeapTuple) palloc(HEAPTUPLESIZE + tuple_len);
-	tuple->t_len = tuple_len;
-	ItemPointerSetInvalid(&(tuple->t_self));
-	tuple->t_tableOid = InvalidOid;
-	tuple->t_data = (HeapTupleHeader) ((char *) tuple + HEAPTUPLESIZE);
-	memcpy((char *) tuple->t_data, (char *) tupleHeader, tuple_len);
+	tuple = copy_record_tuple(record, tupleHeader);
 
 	/* Inserting a new record */
-	value = fastgetattr(tuple, 1, tupdesc, &isnull);
+	value = get_record_key(tuple, record->tupdesc, &isnull);
 	/* First, check if there is a record with same key */
 	k.value = value;
 	k.is_null = isnull;
@@ -253,7 +314,7 @@ insert_record(Variable *variable, HeapTupleHeader tupleHeader)
 										   HASH_ENTER, &found);
 	if (found)
 	{
-		heap_freetuple(tuple);
+		pfree(DatumGetPointer(tuple));
 		MemoryContextSwitchTo(oldcxt);
 		ereport(ERROR,
 				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
@@ -272,9 +333,7 @@ insert_record(Variable *variable, HeapTupleHeader tupleHeader)
 bool
 update_record(Variable *variable, HeapTupleHeader tupleHeader)
 {
-	TupleDesc	tupdesc;
-	HeapTuple	tuple;
-	int			tuple_len;
+	Datum		tuple;
 	Datum		value;
 	bool		isnull;
 	RecordVar  *record;
@@ -289,20 +348,10 @@ update_record(Variable *variable, HeapTupleHeader tupleHeader)
 
 	oldcxt = MemoryContextSwitchTo(record->hctx);
 
-	tupdesc = record->tupdesc;
-
-	/* Build a HeapTuple control structure */
-	tuple_len = HeapTupleHeaderGetDatumLength(tupleHeader);
-
-	tuple = (HeapTuple) palloc(HEAPTUPLESIZE + tuple_len);
-	tuple->t_len = tuple_len;
-	ItemPointerSetInvalid(&(tuple->t_self));
-	tuple->t_tableOid = InvalidOid;
-	tuple->t_data = (HeapTupleHeader) ((char *) tuple + HEAPTUPLESIZE);
-	memcpy((char *) tuple->t_data, (char *) tupleHeader, tuple_len);
+	tuple = copy_record_tuple(record, tupleHeader);
 
 	/* Update a record */
-	value = fastgetattr(tuple, 1, tupdesc, &isnull);
+	value = get_record_key(tuple, record->tupdesc, &isnull);
 	k.value = value;
 	k.is_null = isnull;
 	k.hash_proc = &record->hash_proc;
@@ -312,13 +361,13 @@ update_record(Variable *variable, HeapTupleHeader tupleHeader)
 										   HASH_FIND, &found);
 	if (!found)
 	{
-		heap_freetuple(tuple);
+		pfree(DatumGetPointer(tuple));
 		MemoryContextSwitchTo(oldcxt);
 		return false;
 	}
 
 	/* Release old tuple */
-	heap_freetuple(item->tuple);
+	pfree(DatumGetPointer(item->tuple));
 	item->tuple = tuple;
 
 	MemoryContextSwitchTo(oldcxt);
@@ -346,7 +395,49 @@ delete_record(Variable *variable, Datum value, bool is_null)
 	item = (HashRecordEntry *) hash_search(record->rhash, &k,
 										   HASH_REMOVE, &found);
 	if (found)
-		heap_freetuple(item->tuple);
+		pfree(DatumGetPointer(item->tuple));
 
 	return found;
 }
+
+/*
+ * Copy record using src_tuple.
+ */
+void
+insert_record_copy(RecordVar *dest_record, Datum src_tuple, Variable *variable)
+{
+	Datum		tuple;
+	Datum		value;
+	bool		isnull;
+	HashRecordKey k;
+	HashRecordEntry *item;
+	bool		found;
+	MemoryContext oldcxt;
+
+	oldcxt = MemoryContextSwitchTo(dest_record->hctx);
+
+	/* Inserting a new record into dest_record */
+	tuple = copy_record_tuple(dest_record,
+							  (HeapTupleHeader) DatumGetPointer(src_tuple));
+	value = get_record_key(tuple, dest_record->tupdesc, &isnull);
+
+	k.value = value;
+	k.is_null = isnull;
+	k.hash_proc = &dest_record->hash_proc;
+	k.cmp_proc = &dest_record->cmp_proc;
+
+	item = (HashRecordEntry *) hash_search(dest_record->rhash, &k,
+										   HASH_ENTER, &found);
+	if (found)
+	{
+		pfree(DatumGetPointer(tuple));
+		MemoryContextSwitchTo(oldcxt);
+		ereport(ERROR,
+				(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
+				 errmsg("there is a record in the variable \"%s\" with same "
+						"key", GetName(variable))));
+	}
+	item->tuple = tuple;
+
+	MemoryContextSwitchTo(oldcxt);
+}

pg_variables.h

@@ -1,5 +1,12 @@
 CREATE EXTENSION pg_variables;
 
+-- Test packages - sanity checks
+SELECT pgv_free();
+SELECT pgv_exists(NULL); -- fail
+SELECT pgv_remove(NULL); -- fail
+SELECT pgv_remove('vars'); -- fail
+SELECT pgv_exists('vars111111111111111111111111111111111111111111111111111111111111'); -- fail
+
 -- Integer variables
 SELECT pgv_get_int('vars', 'int1');
 SELECT pgv_get_int('vars', 'int1', false);
@@ -152,18 +159,31 @@ SELECT pgv_insert('vars3', 'r1', tab) FROM tab;
 SELECT pgv_insert('vars3', 'r1', row(1, 'str1', 'str2'));
 SELECT pgv_insert('vars3', 'r1', row(1, 1));
 SELECT pgv_insert('vars3', 'r1', row('str1', 'str1'));
+SELECT pgv_select('vars3', 'r1', ARRAY[[1,2]]); -- fail
 
-SELECT pgv_select('vars3', 'r1') LIMIT 2;
-SELECT pgv_select('vars3', 'r1') LIMIT 2 OFFSET 2;
+-- Test variables caching
+SELECT pgv_insert('vars3', 'r2', row(1, 'str1', 'str2'));
+SELECT pgv_update('vars3', 'r1', row(3, 'str22'::varchar));
+SELECT pgv_update('vars4', 'r1', row(3, 'str22'::varchar)); -- fail
+select pgv_delete('vars3', 'r2', NULL::int);
+select pgv_delete('vars4', 'r2', NULL::int); -- fail
+
+-- Test NULL values
+SELECT pgv_insert('vars3', 'r2', NULL); -- fail
+SELECT pgv_update('vars3', 'r2', NULL); -- fail
+select pgv_delete('vars3', 'r2', NULL::int);
+SELECT pgv_select('vars3', 'r1', NULL::int[]); -- fail
 
 SELECT pgv_select('vars3', 'r1');
 SELECT pgv_select('vars3', 'r1', 1);
+SELECT pgv_select('vars3', 'r1', 1::float); -- fail
 SELECT pgv_select('vars3', 'r1', 0);
 SELECT pgv_select('vars3', 'r1', NULL::int);
 SELECT pgv_select('vars3', 'r1', ARRAY[1, 0, NULL]);
 
 UPDATE tab SET t = 'str33' WHERE id = 1;
 SELECT pgv_update('vars3', 'r1', tab) FROM tab;
+SELECT pgv_update('vars3', 'r1', row(4, 'str44'::varchar));
 SELECT pgv_select('vars3', 'r1');
 
 SELECT pgv_delete('vars3', 'r1', 1);
@@ -175,6 +195,51 @@ SELECT pgv_exists('vars3', 'r3');
 SELECT pgv_exists('vars3', 'r1');
 SELECT pgv_select('vars2', 'j1');
 
+-- PGPRO-2601 - Test pgv_select() on TupleDesc of dropped table
+DROP TABLE tab;
+SELECT pgv_select('vars3', 'r1');
+
+-- Tests for SRF's sequential scan of an internal hash table
+DO
+$$BEGIN
+    PERFORM pgv_select('vars3', 'r1') LIMIT 2 OFFSET 2;
+    PERFORM pgv_select('vars3', 'r3');
+END$$;
+-- Check that the hash table was cleaned up after rollback
+SET client_min_messages to 'ERROR';
+SELECT pgv_select('vars3', 'r1', 1);
+SELECT pgv_select('vars3', 'r1') LIMIT 2; -- warning
+SELECT pgv_select('vars3', 'r1') LIMIT 2 OFFSET 2;
+
+-- PGPRO-2601 - Test a cursor with the hash table
+BEGIN;
+DECLARE r1_cur CURSOR FOR SELECT pgv_select('vars3', 'r1');
+FETCH 1 in r1_cur;
+SELECT pgv_select('vars3', 'r1');
+FETCH 1 in r1_cur;
+CLOSE r1_cur;
+COMMIT; -- warning
+RESET client_min_messages;
+
+-- Clean memory after unsuccessful creation of a variable
+SELECT pgv_insert('vars4', 'r1', row('str1', 'str1')); -- fail
+SELECT package FROM pgv_stats() WHERE package = 'vars4';
+
+-- Remove package if it is empty
+SELECT pgv_insert('vars4', 'r2', row(1, 'str1', 'str2'));
+SELECT pgv_remove('vars4', 'r2');
+SELECT package FROM pgv_stats() WHERE package = 'vars4';
+
+-- Record variables as scalar
+SELECT pgv_set('vars5', 'r1', row(1, 'str11'));
+SELECT pgv_get('vars5', 'r1', NULL::record);
+SELECT pgv_set('vars5', 'r1', row(1, 'str11'), true); -- fail
+
+SELECT pgv_insert('vars5', 'r1', row(1, 'str11')); -- fail
+SELECT pgv_select('vars5', 'r1'); -- fail
+
+SELECT pgv_get('vars3', 'r1', NULL::record); -- fail
+
 -- Manipulate variables
 SELECT * FROM pgv_list() order by package, name;
 SELECT package FROM pgv_stats() order by package;

pg_variables_record.c

@@ -80,6 +80,8 @@ SELECT pgv_get_jsonb('vars2', 'j1');
 SELECT pgv_get_jsonb('vars2', 'j2');
 COMMIT;
 
+CREATE TABLE tab (id int, t varchar);
+INSERT INTO tab VALUES (0, 'str00'), (1, 'str33'), (2, NULL), (NULL, 'strNULL');
 
 BEGIN;
 SELECT pgv_insert('vars3', 'r1', tab, true) FROM tab;
@@ -482,4 +484,53 @@ RELEASE comm;
 SELECT pgv_get('vars', 'any1',NULL::text);
 COMMIT;
 
+-- Tests for PGPRO-2440
+SELECT pgv_insert('vars3', 'r3', row(1 :: integer, NULL::varchar), true);
+BEGIN;
+SELECT pgv_insert('vars3', 'r3', row(2 :: integer, NULL::varchar), true);
+SAVEPOINT comm;
+SELECT pgv_insert('vars3', 'r3', row(3 :: integer, NULL::varchar), true);
+COMMIT;
+SELECT pgv_delete('vars3', 'r3', 3);
+
+BEGIN;
+SELECT pgv_set('vars1', 't1', ''::text);
+SELECT pgv_set('vars2', 't2', ''::text, true);
+SAVEPOINT sp1;
+SAVEPOINT sp2;
+SELECT pgv_free();
+ERROR;
+COMMIT;
+
+BEGIN;
+SELECT pgv_set('vars', 'any1', 'some value'::text, true);
+SELECT pgv_free();
+SAVEPOINT sp_to_rollback;
+SELECT pgv_set('vars', 'any1', 'some value'::text, true);
+ROLLBACK TO sp_to_rollback;
+COMMIT;
+SELECT package FROM pgv_stats() ORDER BY package;
+
+-- Package should exist after rollback if it contains regular variable
+BEGIN;
+SELECT pgv_set('vars', 'any1', 'some value'::text);
+ROLLBACK;
+SELECT package FROM pgv_stats() ORDER BY package;
+
+-- Package should not exist if it becomes empty in rolled back transaction
+BEGIN;
+SAVEPOINT comm2;
+SELECT pgv_remove('vars');
+ROLLBACK TO comm2;
+SELECT pgv_exists('vars');
+SELECT package FROM pgv_stats() ORDER BY package;
+COMMIT;
+SELECT package FROM pgv_stats() ORDER BY package;
+
+SELECT pgv_set('vars', 'any1', 'some value'::text);
+BEGIN;
+SELECT pgv_remove('vars');
+ROLLBACK;
+SELECT package FROM pgv_stats() ORDER BY package;
+
 SELECT pgv_free();