test: add tests for 18 PostgreSQL

Author: ashenBlade

.github/workflows/testing.yml

@@ -49,7 +49,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix: 
-        pgversion: ['17', '16', '15', '14', '13', '12', '11', '10', '9.6']
+        pgversion: ['18', '17', '16', '15', '14', '13', '12', '11', '10', '9.6']
     steps:
     - name: Setup repository
       uses: actions/checkout@v4

src/test/README.md

@@ -45,24 +45,28 @@ To run tests use `./src/test/test.sh` script:
 
 It will run test pipeline with full matrix testing:
 
-- PG Version: 17 - 9.6
+- PG Version: 18 - 9.6
 - VS Code version: stable, 1.90, 1.80, 1.70
 - Debugger: CppDbg, CodeLLDB
 
 There are useful flags that allows to specify which value range to use:
 
 ```bash
-./src/test/test.sh --pg-versions="17 16 15" \
+./src/test/test.sh --pg-versions="18 17 16" \
                    --vscode-versions="stable 1.90" \
                    --debuggers="lldb"
 ```
 
 Use `--help` flag to get more info about.
 
-Also, there are 2 tested modules: `vars` (variables) and `format` (formatter).
-You can specify any of them using `--tests` argument, i.e. `--tests='vars'` or `--tests='vars,format'`.
+Also, there are 3 tested modules:
 
-By default only `vars` is used.
+- `vars` - variables (used by default), `./src/variables.ts`
+- `format` - formatter, `./src/formatter.ts`
+- `unit` - unit tests for common functionality, `./src/utils.ts`
+
+You can specify any of them using `--tests` argument, i.e. `--tests='vars'` or `--tests='vars,unit,format'`.
+Also you can use `all` to enable all modes: `--tests='all'`.
 
 ## Test design
 

src/test/patches/pg18.0.patch

@@ -0,0 +1,328 @@
+diff --git a/src/backend/optimizer/plan/Makefile b/src/backend/optimizer/plan/Makefile
+index 80ef162e484..84b847faaf9 100644
+--- a/src/backend/optimizer/plan/Makefile
++++ b/src/backend/optimizer/plan/Makefile
+@@ -20,6 +20,7 @@ OBJS = \
+ 	planmain.o \
+ 	planner.o \
+ 	setrefs.o \
+-	subselect.o
++	subselect.o \
++	vscodehelper.o
+ 
+ include $(top_srcdir)/src/backend/common.mk
+diff --git a/src/backend/optimizer/plan/planmain.c b/src/backend/optimizer/plan/planmain.c
+index e17d31a5c3e..0bc057825d3 100644
+--- a/src/backend/optimizer/plan/planmain.c
++++ b/src/backend/optimizer/plan/planmain.c
+@@ -29,6 +29,7 @@
+ #include "optimizer/placeholder.h"
+ #include "optimizer/planmain.h"
+ 
++extern void vscode_test_helper(PlannerInfo *root);
+ 
+ /*
+  * query_planner
+@@ -284,5 +285,7 @@ query_planner(PlannerInfo *root,
+ 		final_rel->cheapest_total_path->param_info != NULL)
+ 		elog(ERROR, "failed to construct the join relation");
+ 
++	vscode_test_helper(root);
++
+ 	return final_rel;
+ }
+diff --git a/src/backend/optimizer/plan/vscodehelper.c b/src/backend/optimizer/plan/vscodehelper.c
+new file mode 100644
+index 00000000000..7693688133b
+--- /dev/null
++++ b/src/backend/optimizer/plan/vscodehelper.c
+@@ -0,0 +1,288 @@
++#include "postgres.h"
++
++#include "nodes/bitmapset.h"
++#include "nodes/pathnodes.h"
++#include "utils/hsearch.h"
++
++extern void vscode_test_helper(PlannerInfo *root);
++extern void vscode_test_helper_unused(void *pointer);
++
++#define ARRAY_SIZE 16
++#define UNUSED(x) ((void)x)
++
++typedef struct TestStructure
++{
++	int value;
++} TestStructure;
++
++typedef struct TestEmbeddedStructure
++{
++	TestStructure value;
++} TestEmbeddedStructure;
++
++typedef struct TestPointerMember
++{
++	TestStructure *value;
++} TestPointerMember;
++
++typedef struct TestFixedArray
++{
++	int array[ARRAY_SIZE];
++} TestFixedArray;
++
++typedef struct TestFlexibleArrayMember
++{
++	int length;
++	int array[FLEXIBLE_ARRAY_MEMBER];
++} TestFlexibleArrayMember;
++
++typedef struct CustomListElement
++{
++	int value;
++} CustomListElement;
++
++typedef struct CustomListVariable
++{
++	List *value;
++} CustomListVariable;
++
++typedef struct TestHtabEntry
++{
++	int key;
++	int value;
++} TestHtabEntry;
++
++typedef struct SimpleHashEntry
++{
++	uint32 status;
++	uint32 hash;
++	int key;
++	int value;
++} SimpleHashEntry;
++
++typedef struct ArrayMember
++{
++	int *array_field;
++	int *array_expr;
++	int length;
++	int length2;
++} ArrayMember;
++
++typedef Expr *ExprAlias;
++
++#define SH_PREFIX 			testhash
++#define SH_ELEMENT_TYPE 	SimpleHashEntry
++#define SH_KEY_TYPE 		int
++#define SH_KEY				key
++#define SH_SCOPE 			static inline
++#define SH_HASH_KEY(tb, key)   ((uint32)(key))
++#define SH_EQUAL(tb, a, b) 	((a) == (b))
++#define SH_STORE_HASH
++#define SH_GET_HASH(tb, a)	((a)->hash)
++#define SH_DECLARE
++#define SH_DEFINE
++#include "lib/simplehash.h"
++
++static HTAB *create_htab(void);
++static testhash_hash *create_simplehash(void);
++static List *create_custom_list(void);
++static ArrayMember *create_special_array_member(void);
++static TestFlexibleArrayMember *create_flex_array_member(void);
++
++static HTAB *
++create_htab(void)
++{
++	HASHCTL ctl;
++	HTAB *htab;
++	TestHtabEntry *entry;
++	int key;
++
++	ctl.keysize = sizeof(int);
++	ctl.entrysize = sizeof(TestHtabEntry);
++	htab = hash_create("Test VSCode HTAB", 8, &ctl, HASH_ELEM | HASH_BLOBS);
++
++	key = 1;
++	entry = (TestHtabEntry *)hash_search(htab, &key, HASH_ENTER, NULL);
++	entry->value = 2;
++
++	key = 10;
++	entry = (TestHtabEntry *)hash_search(htab, &key, HASH_ENTER, NULL);
++	entry->value = 4;
++
++	key = 20;
++	entry = (TestHtabEntry *)hash_search(htab, &key, HASH_ENTER, NULL);
++	entry->value = 8;
++
++	return htab;
++}
++
++static testhash_hash *
++create_simplehash(void)
++{
++	testhash_hash *hash;
++	bool found;
++	SimpleHashEntry *entry;
++
++	hash = testhash_create(CurrentMemoryContext, 6, NULL);
++	entry = testhash_insert(hash, 1, &found);
++	entry->value = 2;
++	entry = testhash_insert(hash, 10, &found);
++	entry->value = 4;
++	entry = testhash_insert(hash, 20, &found);
++	entry->value = 8;
++
++	return hash;
++}
++
++static List *
++create_custom_list(void)
++{
++	List *list = NIL;
++	CustomListElement *element;
++
++	element = palloc(sizeof(CustomListElement));
++	element->value = 1;
++	list = lappend(list, element);
++
++	element = palloc(sizeof(CustomListElement));
++	element->value = 2;
++	list = lappend(list, element);
++
++	element = palloc(sizeof(CustomListElement));
++	element->value = 3;
++	list = lappend(list, element);
++
++	return list;
++}
++
++static ArrayMember *
++create_special_array_member(void)
++{
++	ArrayMember *array = palloc(sizeof(ArrayMember));
++	array->length = 2;
++	array->length2 = 2;
++	array->array_field = palloc(sizeof(int) * array->length);
++	array->array_expr = palloc(sizeof(int) * (array->length + array->length2));
++	array->array_field[0] = 1;
++	array->array_field[1] = 2;
++	array->array_expr[0] = 1;
++	array->array_expr[1] = 2;
++	array->array_expr[2] = 4;
++	array->array_expr[3] = 8;
++	return array;
++}
++
++static TestFlexibleArrayMember *
++create_flex_array_member(void)
++{
++	TestFlexibleArrayMember *member = palloc(offsetof(TestFlexibleArrayMember, array) + sizeof(int) * ARRAY_SIZE);
++	member->length = ARRAY_SIZE;
++	return member;
++}
++
++void
++vscode_test_helper_unused(void *pointer)
++{
++	/* This function is used to prevent symbol truncation in debug builds */
++	testhash_iterator iterator;
++	testhash_hash *hash = (testhash_hash *)pointer;
++	testhash_start_iterate(hash, &iterator);
++	testhash_iterate(hash, &iterator);
++}
++
++void
++vscode_test_helper(PlannerInfo *root)
++{
++	/* Correct variable handling */
++	int i;
++	int int_array[ARRAY_SIZE];
++	TestStructure structure_array[ARRAY_SIZE];
++	TestStructure *structure_pointer_array[ARRAY_SIZE];
++	TestStructure value_struct;
++	TestStructure *pointer_struct;
++	TestPointerMember pointer_member;
++	TestEmbeddedStructure embedded_member;
++	TestFixedArray fixed_size_array_member;
++
++	/* Config file */
++	ArrayMember *array_member;
++	ExprAlias expr_alias;
++	CustomListVariable custom_list_variable;
++	testhash_hash *simplehash;
++	List *custom_list;
++	HTAB *htab;
++	TestFlexibleArrayMember *flexible_array_member;
++
++	/* Node variables */
++	Bitmapset *bms;
++	Node *node;
++	Expr *expr;
++	List *list;
++	List *int_list;
++	RestrictInfo *rinfo;
++	EquivalenceClass *eclass;
++
++	/* Protect against arbitrary query */
++	if (!(   list_length(root->parse->rtable) == 3
++		  && list_length(root->eq_classes) > 0
++		  && list_length((root->simple_rel_array[1])->baserestrictinfo) > 0))
++		return;
++
++	int_list = list_make4_int(1, 2, 4, 8);
++	list = list_make3(root, root->parse, root->parse->rtable);
++	custom_list = create_custom_list();
++	custom_list_variable.value = custom_list;
++	node = (Node *) root;
++	bms = bms_add_range(NULL, 5, 9);
++	htab = create_htab();
++	simplehash = create_simplehash();
++	rinfo = (RestrictInfo *) linitial((root->simple_rel_array[1])->baserestrictinfo);
++	expr = rinfo->clause;
++	expr_alias = expr;
++	eclass = (EquivalenceClass *) linitial(root->eq_classes);
++	array_member = create_special_array_member();
++	flexible_array_member = create_flex_array_member();
++
++	i = 1;
++	value_struct.value = 1;
++	pointer_struct = palloc(sizeof(TestStructure));
++	pointer_struct->value = 1;
++	embedded_member.value = value_struct;
++	pointer_member.value = pointer_struct;
++	embedded_member.value = value_struct;
++	for (int j = 0; j < ARRAY_SIZE; j++)
++	{
++		fixed_size_array_member.array[j] = j + 1;
++		int_array[j] = j + 1;
++		structure_array[j].value = j + 1;
++		structure_pointer_array[j] = palloc(sizeof(TestStructure));
++		structure_pointer_array[j]->value = j + 1;
++		flexible_array_member->array[j] = j + 1;
++	}
++
++	UNUSED(bms);
++	UNUSED(node);
++	UNUSED(expr);
++	UNUSED(list);
++	UNUSED(int_list);
++	UNUSED(htab);
++	UNUSED(rinfo);
++	UNUSED(eclass);
++	UNUSED(array_member);
++	UNUSED(expr_alias);
++	UNUSED(simplehash);
++	UNUSED(i);
++	UNUSED(int_array);
++	UNUSED(structure_array);
++	UNUSED(structure_pointer_array);
++	UNUSED(value_struct);
++	UNUSED(pointer_struct);
++	UNUSED(pointer_member);
++	UNUSED(embedded_member);
++	UNUSED(fixed_size_array_member);
++	UNUSED(flexible_array_member);
++	UNUSED(custom_list);
++	UNUSED(custom_list_variable);
++
++	return;
++}
+\ No newline at end of file