diff --git i/src/backend/catalog/Makefile w/src/backend/catalog/Makefile
index 8bece078dd1..91766b76559 100644
--- i/src/backend/catalog/Makefile
+++ w/src/backend/catalog/Makefile
@@ -124,3 +124,10 @@ clean:
 
 maintainer-clean: clean
 	rm -f bki-stamp $(BKIFILES) $(GENERATED_HEADERS)
+
+gennodes.o: override CFLAGS += $(LLVM_CFLAGS)
+gennodes.o: override CPPFLAGS += $(LLVM_CPPFLAGS)
+gennodes: override LDFLAGS += -lclang
+
+gennodes-run: gennodes
+	./gennodes $(top_srcdir)/src/include/nodes/primnodes.h $(CPPFLAGS)  -include postgres.h  -include $(top_srcdir)/src/include/nodes/pathnodes.h -include $(top_srcdir)/src/include/nodes/plannodes.h -include $(top_srcdir)/src/include/nodes/execnodes.h -include $(top_srcdir)/src/include/nodes/memnodes.h -include $(top_srcdir)/src/include/nodes/value.h -include $(top_srcdir)/src/include/nodes/pg_list.h -include $(top_srcdir)/src/include/nodes/extensible.h -include $(top_srcdir)/src/include/nodes/parsenodes.h -include $(top_srcdir)/src/include/nodes/replnodes.h  -include $(top_srcdir)/src/include/nodes/value.h -I /usr/include/clang/7/include/ > $(top_srcdir)/src/include/nodes/nodeinfo.h
diff --git i/src/backend/catalog/gennodes.c w/src/backend/catalog/gennodes.c
new file mode 100644
index 00000000000..cc49480cd63
--- /dev/null
+++ w/src/backend/catalog/gennodes.c
@@ -0,0 +1,448 @@
+#include "postgres_fe.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdbool.h>
+
+#include <clang-c/Index.h>
+
+/* don't want to use pg_list.h here, as it's a node type itself */
+typedef struct arr
+{
+	size_t nelems;
+	size_t space;
+	char **elems;
+}  arr;
+
+typedef struct CollectInfo
+{
+	arr interesting_typedefs;
+	arr interesting_types;
+	arr type_strings;
+	arr component_strings;
+
+	CXType current_struct_type;
+	bool first;
+} CollectInfo;
+
+
+static void
+arr_resize(arr *arr, size_t newsize)
+{
+	if (arr->space == 0)
+	{
+		arr->space = newsize;
+		arr->elems = calloc(sizeof(void *), newsize);
+	}
+	else
+	{
+		arr->elems = realloc(arr->elems, sizeof(void *) * newsize);
+
+		if (arr->space < newsize)
+			memset(&arr->elems[arr->space],
+				   0,
+				   newsize - arr->space);
+		arr->space = newsize;
+		if (arr->space < arr->nelems)
+			arr->nelems = arr->space;
+	}
+}
+
+static void
+arr_append(arr *arr, void *el)
+{
+	if (arr->space == 0)
+		arr_resize(arr, 16);
+	else if (arr->nelems == arr->space)
+		arr_resize(arr, arr->space * 2);
+
+	arr->elems[arr->nelems++] = el;
+}
+
+/*
+ * FIXME: this is used for lookups in too many places - need something better
+ * than O(N).
+ */
+static int
+string_in_arr(arr *arr, const char *match)
+{
+	for (int i = 0; i < arr->nelems; i++)
+	{
+		const char *el = (const char *) arr->elems[i];
+
+		if (el == NULL && match != NULL)
+			continue;
+
+		if (strcmp(el, match) == 0)
+			return i;
+	}
+
+	return -1;
+}
+
+/* visit elements of the NodeTag enum, to collect the names of all node types */
+static enum CXChildVisitResult
+find_NodeTagElems_vis(CXCursor cursor, CXCursor parent, CXClientData client_data)
+{
+	if (clang_getCursorKind(cursor) == CXCursor_EnumConstantDecl)
+	{
+		CollectInfo *collect_info = (CollectInfo *) client_data;
+		const char *name = clang_getCString(clang_getCursorSpelling(cursor));
+
+		if (strncmp(name, "T_", 2) != 0)
+		{
+			fprintf(stderr, "unexpected name: %s\n", name);
+			exit(-1);
+		}
+		else
+		{
+			char buf[512];
+			snprintf(buf, sizeof(buf), "%s", (name + 2));
+			arr_append(&collect_info->interesting_typedefs, strdup(buf));
+		}
+	}
+
+	return CXChildVisit_Recurse;
+}
+
+/* find the NodeTag enum, and collect elements using find_NodeTagElems_vis */
+static enum CXChildVisitResult
+find_NodeTag_vis(CXCursor cursor, CXCursor parent, CXClientData client_data)
+{
+	if (clang_getCursorKind(cursor) == CXCursor_EnumDecl)
+	{
+		const char *spelling = clang_getCString(clang_getCursorSpelling(cursor));
+
+		if (strcmp(spelling, "NodeTag") != 0)
+			return CXChildVisit_Recurse;
+
+		clang_visitChildren(
+			cursor,
+			find_NodeTagElems_vis,
+			client_data);
+
+		return CXChildVisit_Break;
+	}
+	return CXChildVisit_Recurse;
+}
+
+/* FIXME: The generated code would be more readable if we had these  | ed in the output */
+#define TYPE_CAT_SCALAR (1 << 0)
+#define TYPE_CAT_POINTER (1 << 1)
+#define TYPE_CAT_STRING (1 << 2)
+#define TYPE_CAT_UNION (1 << 3)
+#define TYPE_CAT_INCOMPLETE (1 << 4)
+
+/* collect information about the elements of Node style struct members */
+static enum CXVisitorResult
+find_StructFields_vis(CXCursor cursor, CXClientData client_data)
+{
+	CollectInfo *collect_info = (CollectInfo *) client_data;
+	const char *structname = clang_getCString(clang_getTypeSpelling(collect_info->current_struct_type));
+	const char *fieldname = clang_getCString(clang_getCursorSpelling(cursor));
+	CXType fieldtype = clang_getCanonicalType(clang_getCursorType(cursor));
+	const char *fieldtypename =
+		clang_getCString(clang_getTypeSpelling(fieldtype));
+
+	int16 node_type_id = -1;
+	char *known_type_id = "KNOWN_TYPE_UNKNOWN";
+	char *s;
+	char *flags = NULL;
+
+	if (fieldtype.kind == CXType_Pointer)
+	{
+		CXType pointee_type = clang_getCanonicalType(clang_getPointeeType(fieldtype));
+		const char *pointee_type_name =
+			clang_getCString(clang_getTypeSpelling(pointee_type));
+		enum CXTypeKind kind = pointee_type.kind;
+
+		node_type_id = string_in_arr(&collect_info->interesting_types, pointee_type_name);
+
+		if (flags)
+			flags = psprintf("%s | TYPE_CAT_POINTER", flags);
+		else
+			flags = "TYPE_CAT_POINTER";
+
+		if (kind == CXType_Char_S || kind == CXType_SChar || kind == CXType_Char_U || kind == CXType_UChar)
+			known_type_id = "KNOWN_TYPE_STRING";
+		else if (kind == CXType_UShort || kind == CXType_UInt ||
+				 kind ==  CXType_ULong || kind ==  CXType_ULongLong ||
+				 kind == CXType_UInt128 ||
+				 kind == CXType_Short || kind == CXType_Int ||
+				 kind ==  CXType_Long || kind ==  CXType_LongLong ||
+				 kind == CXType_Int128)
+			known_type_id = "KNOWN_TYPE_INT";
+		else if (strcmp(fieldtypename, "struct Bitmapset *") == 0)
+			known_type_id = "KNOWN_TYPE_BITMAPSET";
+		else if (strcmp(fieldtypename, "struct Node *") == 0)
+			known_type_id = "KNOWN_TYPE_NODE";
+	}
+	else
+	{
+		node_type_id = string_in_arr(&collect_info->interesting_types, fieldtypename);
+		if (flags)
+			flags = psprintf("%s | TYPE_CAT_SCALAR", flags);
+		else
+			flags = "TYPE_CAT_SCALAR";
+	}
+
+	/* can't measure size for incomplete types (e.g. variable length arrays at the end of a struct) */
+	/*
+	 * FIXME: need a way to more sustainably build strings - StringInfo is
+	 * backend only however. Use pqexpbuffer?
+	 */
+	if (fieldtype.kind == CXType_IncompleteArray)
+	{
+		if (flags)
+			flags = psprintf("%s | TYPE_CAT_INCOMPLETE", flags);
+		else
+			flags = "TYPE_CAT_INCOMPLETE";
+
+		s = psprintf("{.fieldname = \"%s\", .fieldtype = \"%s\", .offset = offsetof(%s, %s), .size = -1, .flags = %s, .node_type_id = %d, .known_type_id = %s}",
+					 fieldname,
+					 fieldtypename,
+					 structname, /* offsetof */
+					 fieldname, /* offsetof */
+					 flags,
+					 node_type_id,
+					 known_type_id);
+	}
+	else
+	{
+		s = psprintf("{.fieldname = \"%s\", .fieldtype = \"%s\", .offset = offsetof(%s, %s), .size = sizeof(%s), .flags = %s, .node_type_id = %d, .known_type_id = %s}",
+					 fieldname,
+					 fieldtypename,
+					 structname, /* offsetof */
+					 fieldname, /* offsetof */
+					 fieldtypename,
+					 flags,
+					 node_type_id,
+					 known_type_id);
+	}
+
+	arr_append(&collect_info->component_strings, s);
+	return CXVisit_Continue;
+}
+
+/*
+ * Collect the names of all the structs that "implement" node types (those
+ * names have previously been collected with find_NodeTag_vis). As we
+ * sometimes have forward declarations, we need to use a canonicalized name,
+ * and it's far easier to always use the underlying struct names, than somehow
+ * go the other way.
+ */
+static enum CXChildVisitResult
+find_NodeStructs_vis(CXCursor cursor, CXCursor parent, CXClientData client_data)
+{
+	/*
+	 * We'll reach each struct type twice - once for the typedef, and once for
+	 * the struct itself. We only check typedef, including its name, because
+	 * that's what needs to correspond to the NodeTag names.
+	 */
+	if (clang_getCursorKind(cursor) == CXCursor_TypedefDecl)
+	{
+		const char *spelling =
+			clang_getCString(clang_getTypeSpelling(clang_getCursorType(cursor)));
+		CollectInfo *collect_info = (CollectInfo *) client_data;
+		int type_pos = string_in_arr(&collect_info->interesting_typedefs, spelling);
+
+		if (type_pos == -1)
+			return CXChildVisit_Continue;
+
+		collect_info->interesting_types.elems[type_pos] = (void *)
+			clang_getCString(clang_getTypeSpelling(clang_getCanonicalType(clang_getCursorType(cursor))));
+
+		return CXChildVisit_Continue;
+	}
+	return CXChildVisit_Recurse;
+}
+
+/*
+ * Collect the definition of all node structs. This is done separately from
+ * collecting the struct names (in find_NodeStructs_vis), because we need to
+ * identify whether struct members are node types themselves, for which we
+ * need their canonical names.
+ */
+static enum CXChildVisitResult
+find_NodeStructDefs_vis(CXCursor cursor, CXCursor parent, CXClientData client_data)
+{
+	/*
+	 * We'll reach each struct type twice - once for the typedef, and once for
+	 * the struct. Only check one.  XXX: Perhaps it'd be better to check the
+	 * name of the typedef? That's what makeNode() etc effectively use?
+	 */
+	if (clang_getCursorKind(cursor) == CXCursor_TypedefDecl)
+	{
+		const char *spelling =
+			clang_getCString(clang_getTypeSpelling(clang_getCursorType(cursor)));
+		CollectInfo *collect_info = (CollectInfo *) client_data;
+		size_t components_at_start;
+		char *s;
+		int type_pos = string_in_arr(&collect_info->interesting_typedefs, spelling);
+
+		if (type_pos == -1)
+			return CXChildVisit_Continue;
+
+		collect_info->first = true;
+		collect_info->current_struct_type = clang_getCanonicalType(clang_getCursorType(cursor));
+
+		components_at_start = collect_info->component_strings.nelems;
+
+		clang_Type_visitFields(
+			collect_info->current_struct_type,
+			find_StructFields_vis,
+			collect_info);
+
+		if (clang_Type_getSizeOf(collect_info->current_struct_type) == CXTypeLayoutError_Incomplete)
+		{
+			s = psprintf("{.structname = \"%s\", .nelems = %zd, .start_at = %zd, .size = -1}",
+						 spelling,
+						 collect_info->component_strings.nelems - components_at_start,
+						 components_at_start);
+		}
+		else
+		{
+			s = psprintf("{.structname = \"%s\", .nelems = %zd, .start_at = %zd, .size = sizeof(%s)}",
+						 spelling,
+						 collect_info->component_strings.nelems - components_at_start,
+						 components_at_start,
+						 spelling);
+		}
+		collect_info->type_strings.elems[type_pos] = s;
+		//arr_append(&print->type_strings, s);
+		return CXChildVisit_Continue;
+	}
+	return CXChildVisit_Recurse;
+}
+
+int main(int argc, char **argv)
+{
+	CXCursor cursor;
+	bool first;
+	CollectInfo collect_info = {0};
+	CXIndex index;
+	CXTranslationUnit unit;
+
+	index = clang_createIndex(0, 1);
+
+	unit = clang_parseTranslationUnit(
+		index,
+		argv[1], (const char * const *) argv + 2, argc - 2,
+		NULL, 0,
+		CXTranslationUnit_None);
+
+	if (unit == NULL)
+	{
+		fprintf(stderr, "Unable to parse translation unit. \n");
+		/* FIXME: display error */
+		exit(-1);
+	}
+
+	cursor = clang_getTranslationUnitCursor(unit);
+
+	/* first collect elements of NodeTag, to find which types needs support */
+	clang_visitChildren(
+		cursor,
+		find_NodeTag_vis,
+		&collect_info);
+
+	/* find the underlying types for the NodeTag elements where possible */
+	arr_resize(&collect_info.interesting_types, collect_info.interesting_typedefs.nelems);
+	collect_info.interesting_types.nelems = collect_info.interesting_typedefs.nelems;
+	clang_visitChildren(
+		cursor,
+		find_NodeStructs_vis,
+		&collect_info);
+
+	/* then traverse again, to find the structs definitions for the types above */
+	arr_resize(&collect_info.type_strings, collect_info.interesting_typedefs.nelems);
+	collect_info.type_strings.nelems = collect_info.interesting_typedefs.nelems;
+	clang_visitChildren(
+		cursor,
+		find_NodeStructDefs_vis,
+		&collect_info);
+
+	fprintf(stdout,
+"\n"
+"#include \"nodes/primnodes.h\"\n"
+"#include \"nodes/pathnodes.h\"\n"
+"#include \"nodes/plannodes.h\"\n"
+"#include \"nodes/execnodes.h\"\n"
+"#include \"nodes/memnodes.h\"\n"
+"#include \"nodes/pg_list.h\"\n"
+"#include \"nodes/extensible.h\"\n"
+"#include \"nodes/parsenodes.h\"\n"
+"#include \"nodes/replnodes.h\"\n"
+"#include \"nodes/value.h\"\n"
+"\n"
+"#define TYPE_CAT_SCALAR (1 << 0)\n"
+"#define TYPE_CAT_POINTER (1 << 1)\n"
+"#define TYPE_CAT_UNION (1 << 2)\n"
+"#define TYPE_CAT_INCOMPLETE (1 << 3)\n"
+"\n"
+"#define KNOWN_TYPE_UNKNOWN 0\n"
+"#define KNOWN_TYPE_STRING 1\n"
+"#define KNOWN_TYPE_INT 2\n"
+"#define KNOWN_TYPE_NODE 3\n"
+"#define KNOWN_TYPE_BITMAPSET 4\n"
+"\n"
+"typedef struct NodeTypeInfo\n"
+"{\n"
+"	/* FIXME: intern me */\n"
+"	const char *structname;\n"
+"	int16 nelems;\n"
+"	int16 start_at;\n"
+"	int16 size;\n"
+"} NodeTypeInfo;\n"
+"\n"
+"typedef struct NodeTypeComponents\n"
+"{\n"
+"	/* FIXME: intern me */\n"
+"	const char *fieldname;\n"
+"	/* FIXME: intern me */\n"
+"	const char *fieldtype;\n"
+"	int16 offset;\n"
+"	int16 size;\n"
+"	int16 flags;\n"
+"	int16 node_type_id;\n"
+"	int16 known_type_id;\n"
+"} NodeTypeComponents;\n"
+"\n\n");
+
+	first = true;
+	fprintf(stdout, "NodeTypeInfo node_type_info[]  = {\n");
+	for (size_t i = 0; i < collect_info.type_strings.nelems; i++)
+	{
+		const char *s = collect_info.type_strings.elems[i];
+
+		if (!first)
+			fprintf(stdout, ",\n");
+		else
+			first = false;
+
+		if (s)
+			fprintf(stdout, "\t%s", s);
+		else
+			fprintf(stdout, "\t{0}");
+	}
+	fprintf(stdout, "\n};\n\n");
+
+	first = true;
+	fprintf(stdout, "NodeTypeComponents node_type_components[] = {\n");
+	for (size_t i = 0; i < collect_info.component_strings.nelems; i++)
+	{
+		const char *s = collect_info.component_strings.elems[i];
+
+		if (!first)
+			fprintf(stdout, ",\n");
+		else
+			first = false;
+
+		fprintf(stdout, "\t%s", s);
+	}
+	fprintf(stdout, "\n};\n\n");
+
+	clang_disposeTranslationUnit(unit);
+	clang_disposeIndex(index);
+}
diff --git i/src/backend/nodes/Makefile w/src/backend/nodes/Makefile
index 0b1e98c0190..aced101f953 100644
--- i/src/backend/nodes/Makefile
+++ w/src/backend/nodes/Makefile
@@ -12,7 +12,7 @@ subdir = src/backend/nodes
 top_builddir = ../../..
 include $(top_builddir)/src/Makefile.global
 
-OBJS = nodeFuncs.o nodes.o list.o bitmapset.o tidbitmap.o \
+OBJS = newfuncs.o nodeFuncs.o nodes.o list.o bitmapset.o tidbitmap.o \
        copyfuncs.o equalfuncs.o extensible.o makefuncs.o \
        outfuncs.o readfuncs.o print.o read.o params.o value.o
 
diff --git i/src/backend/nodes/newfuncs.c w/src/backend/nodes/newfuncs.c
new file mode 100644
index 00000000000..aa72c205d04
--- /dev/null
+++ w/src/backend/nodes/newfuncs.c
@@ -0,0 +1,229 @@
+#include "postgres.h"
+
+#include "nodes/nodeinfo.h"
+#include "miscadmin.h"
+
+typedef struct NodeStat
+{
+	size_t node_size;
+	size_t element_size;
+	size_t variable_size; /* currently doesn't include overhead */
+	size_t padding_size;
+} NodeStat;
+
+static void
+node_stat_add(NodeStat *into, const NodeStat *from)
+{
+	into->node_size += from->node_size;
+	into->element_size += from->element_size;
+	into->variable_size += from->variable_size;
+	into->padding_size += from->padding_size;
+}
+
+static NodeStat
+measure_node_size_rec(Node *node, NodeTypeInfo *type_info)
+{
+	NodeStat sz = {0};
+	NodeTag tag = nodeTag(node);
+	NodeStat totalsubsz = {0};
+
+	sz.node_size += type_info->size;
+
+	check_stack_depth();
+
+	for (int i = 0; i < type_info->nelems; i++)
+	{
+		NodeTypeComponents *component_info = &node_type_components[type_info->start_at + i];
+
+		sz.element_size += component_info->size;
+
+		if (component_info->flags & TYPE_CAT_POINTER)
+		{
+			char *ptr = *(char **) ((char *) node + component_info->offset);
+
+			if (ptr != NULL)
+			{
+				if (component_info->node_type_id != -1)
+				{
+					Node *sub = (Node *) ptr;
+					NodeTag subtag = nodeTag(sub);
+					NodeTypeInfo *sub_type_info;
+					NodeStat subsz;
+
+					/*
+					 * The declared node type might differ from the actual
+					 * node type, because we frequently embed one node type in
+					 * another in a form of "subclassing".
+					 *
+					 * It could be worth restricting this to types actually
+					 * embedded, but it's not clear that that's worth it.
+					 */
+					if (component_info->node_type_id != subtag)
+					{
+#if 0
+						ereport(WARNING,
+								(errmsg("node type of %s->%s differs between declared type %s and actual type %s",
+										type_info->structname,
+										component_info->fieldname,
+										component_info->fieldtype,
+										node_type_info[subtag].structname),
+								 errhidestmt(true),
+								 errhidecontext(true)));
+#endif
+					}
+					sub_type_info = &node_type_info[subtag];
+
+					subsz = measure_node_size_rec(sub, sub_type_info);
+					node_stat_add(&totalsubsz, &subsz);
+				}
+				else if (component_info->known_type_id == KNOWN_TYPE_NODE)
+				{
+					Node *sub = (Node *) ptr;
+					NodeTypeInfo *sub_type_info;
+					NodeStat subsz;
+
+					sub_type_info = &node_type_info[nodeTag(sub)];
+					subsz = measure_node_size_rec(sub, sub_type_info);
+					node_stat_add(&totalsubsz, &subsz);
+				}
+				else if (component_info->known_type_id == KNOWN_TYPE_STRING)
+					totalsubsz.variable_size += strlen(ptr);
+				else if (component_info->known_type_id == KNOWN_TYPE_BITMAPSET)
+				{
+					Bitmapset *set = (Bitmapset *) ptr;
+
+					totalsubsz.variable_size += offsetof(Bitmapset, words) + set->nwords * BITS_PER_BITMAPWORD;
+				}
+				else if (tag != T_List && tag != T_OidList && tag != T_IntList)
+				{
+					ereport(WARNING,
+							(errmsg("don't know how to handle pointer field %s->%s of type \"%s\"",
+									type_info->structname,
+									component_info->fieldname,
+									component_info->fieldtype),
+							 errhidestmt(true),
+							 errhidecontext(true)));
+				}
+			}
+		}
+		else
+		{
+			/*
+			 * In contrast to node types pointed to, as handled above, we may
+			 * not check for the nodeTag() of the actual data: For one, we
+			 * frequently embed "superclasses" in "subclasses" - which means
+			 * that the nodeTag() will return the value from the subclass, but
+			 * we actually want to measure the superclass. For another, if the
+			 * embedded element were to differ from the actual type, the whole
+			 * layout of the struct would be broken.
+			 */
+			if (component_info->node_type_id != -1)
+			{
+				Node *sub_node = (Node *) ((char *) node + component_info->offset);
+				NodeTypeInfo *sub_type_info;
+				NodeStat subsz;
+
+				sub_type_info = &node_type_info[component_info->node_type_id];
+				subsz = measure_node_size_rec(sub_node, sub_type_info);
+
+				/* included in this node's size already */
+				subsz.node_size -= component_info->size;
+
+				node_stat_add(&totalsubsz, &subsz);
+			}
+		}
+	}
+
+	switch (tag)
+	{
+		case T_List:
+			{
+				List *list = (List *) node;
+				ListCell *lc;
+
+				foreach(lc, list)
+				{
+					Node *list_sub = (Node *) lfirst(lc);
+
+					if (list_sub != NULL)
+					{
+						NodeStat subsz;
+
+						subsz = measure_node_size_rec(list_sub, &node_type_info[nodeTag(list_sub)]);
+
+						node_stat_add(&totalsubsz, &subsz);
+					}
+				}
+			}
+			/* fallthrough */
+
+		case T_OidList:
+		case T_IntList:
+			{
+				List *list = (List *) node;
+
+				sz.variable_size += sizeof(ListCell) * list->max_length;
+
+				break;
+			}
+
+		case T_Float:
+		case T_String:
+		case T_BitString:
+			{
+				Value *val = (Value *) node;
+
+				if (val->val.str)
+					sz.variable_size += strlen(val->val.str);
+				break;
+			}
+
+		default:
+			break;
+	}
+
+#if 0
+	elog(WARNING, "size for %s (%u) is %zu (self: %zu, varself: %zu, elems: %zu, sub: %zu)",
+		 type_info->structname ? type_info->structname : "unknown",
+		 nodeTag(node),
+		 sz + varsz + subsz,
+		 sz,
+		 varsz,
+		 elemsz,
+		 subsz);
+#endif
+
+	sz.padding_size = sz.node_size - sz.element_size;
+	Assert((int64) sz.node_size - (int64) sz.element_size >= 0);
+
+	/* FIXME: should we compute this differently? */
+	node_stat_add(&sz, &totalsubsz);
+
+	return sz;
+}
+
+NodeStat
+measure_node_size(Node *node)
+{
+	NodeTypeInfo *node_info;
+
+	node_info = &node_type_info[nodeTag(node)];
+
+	return measure_node_size_rec(node, node_info);
+}
+
+void
+log_node_size(const char *context, Node *node)
+{
+	NodeStat sz = measure_node_size(node);
+
+	ereport(LOG, (errmsg("%s is %zu b (node: %zu b, elements: %zu b, padding: %zu b, var: %zu b)",
+						 context,
+						 sz.node_size + sz.variable_size,
+						 sz.node_size,
+						 sz.element_size,
+						 sz.padding_size,
+						 sz.variable_size),
+				  errhidestmt(true),
+				  errhidecontext(true)));
+}
diff --git i/src/backend/optimizer/plan/planner.c w/src/backend/optimizer/plan/planner.c
index 17c5f086fbf..f90a4ba9c39 100644
--- i/src/backend/optimizer/plan/planner.c
+++ w/src/backend/optimizer/plan/planner.c
@@ -560,6 +560,9 @@ standard_planner(Query *parse, int cursorOptions, ParamListInfo boundParams)
 	if (glob->partition_directory != NULL)
 		DestroyPartitionDirectory(glob->partition_directory);
 
+	log_node_size("parse tree", (Node *) parse);
+	log_node_size("plan tree", (Node *) result);
+
 	return result;
 }
 
diff --git i/src/include/nodes/nodeinfo.h w/src/include/nodes/nodeinfo.h
new file mode 100644
index 00000000000..86e3d94b79c
--- /dev/null
+++ w/src/include/nodes/nodeinfo.h
@@ -0,0 +1,3255 @@
+
+#include "nodes/primnodes.h"
+#include "nodes/pathnodes.h"
+#include "nodes/plannodes.h"
+#include "nodes/execnodes.h"
+#include "nodes/memnodes.h"
+#include "nodes/pg_list.h"
+#include "nodes/extensible.h"
+#include "nodes/parsenodes.h"
+#include "nodes/replnodes.h"
+#include "nodes/value.h"
+
+#define TYPE_CAT_SCALAR (1 << 0)
+#define TYPE_CAT_POINTER (1 << 1)
+#define TYPE_CAT_UNION (1 << 2)
+#define TYPE_CAT_INCOMPLETE (1 << 3)
+
+#define KNOWN_TYPE_UNKNOWN 0
+#define KNOWN_TYPE_STRING 1
+#define KNOWN_TYPE_INT 2
+#define KNOWN_TYPE_NODE 3
+#define KNOWN_TYPE_BITMAPSET 4
+
+typedef struct NodeTypeInfo
+{
+	/* FIXME: intern me */
+	const char *structname;
+	int16 nelems;
+	int16 start_at;
+	int16 size;
+} NodeTypeInfo;
+
+typedef struct NodeTypeComponents
+{
+	/* FIXME: intern me */
+	const char *fieldname;
+	/* FIXME: intern me */
+	const char *fieldtype;
+	int16 offset;
+	int16 size;
+	int16 flags;
+	int16 node_type_id;
+	int16 known_type_id;
+} NodeTypeComponents;
+
+
+NodeTypeInfo node_type_info[]  = {
+	{0},
+	{.structname = "IndexInfo", .nelems = 22, .start_at = 2128, .size = sizeof(IndexInfo)},
+	{.structname = "ExprContext", .nelems = 16, .start_at = 2150, .size = sizeof(ExprContext)},
+	{.structname = "ProjectionInfo", .nelems = 3, .start_at = 2174, .size = sizeof(ProjectionInfo)},
+	{.structname = "JunkFilter", .nelems = 6, .start_at = 2177, .size = sizeof(JunkFilter)},
+	{.structname = "OnConflictSetState", .nelems = 5, .start_at = 2183, .size = sizeof(OnConflictSetState)},
+	{.structname = "ResultRelInfo", .nelems = 30, .start_at = 2188, .size = sizeof(ResultRelInfo)},
+	{.structname = "EState", .nelems = 40, .start_at = 2218, .size = sizeof(EState)},
+	{.structname = "TupleTableSlot", .nelems = 10, .start_at = 2101, .size = sizeof(TupleTableSlot)},
+	{.structname = "Plan", .nelems = 15, .start_at = 1838, .size = sizeof(Plan)},
+	{.structname = "Result", .nelems = 2, .start_at = 1853, .size = sizeof(Result)},
+	{.structname = "ProjectSet", .nelems = 1, .start_at = 1855, .size = sizeof(ProjectSet)},
+	{.structname = "ModifyTable", .nelems = 22, .start_at = 1856, .size = sizeof(ModifyTable)},
+	{.structname = "Append", .nelems = 4, .start_at = 1878, .size = sizeof(Append)},
+	{.structname = "MergeAppend", .nelems = 8, .start_at = 1882, .size = sizeof(MergeAppend)},
+	{.structname = "RecursiveUnion", .nelems = 7, .start_at = 1890, .size = sizeof(RecursiveUnion)},
+	{.structname = "BitmapAnd", .nelems = 2, .start_at = 1897, .size = sizeof(BitmapAnd)},
+	{.structname = "BitmapOr", .nelems = 3, .start_at = 1899, .size = sizeof(BitmapOr)},
+	{.structname = "Scan", .nelems = 2, .start_at = 1902, .size = sizeof(Scan)},
+	{.structname = "SeqScan", .nelems = 2, .start_at = 1904, .size = sizeof(SeqScan)},
+	{.structname = "SampleScan", .nelems = 2, .start_at = 1906, .size = sizeof(SampleScan)},
+	{.structname = "IndexScan", .nelems = 8, .start_at = 1908, .size = sizeof(IndexScan)},
+	{.structname = "IndexOnlyScan", .nelems = 6, .start_at = 1916, .size = sizeof(IndexOnlyScan)},
+	{.structname = "BitmapIndexScan", .nelems = 5, .start_at = 1922, .size = sizeof(BitmapIndexScan)},
+	{.structname = "BitmapHeapScan", .nelems = 2, .start_at = 1927, .size = sizeof(BitmapHeapScan)},
+	{.structname = "TidScan", .nelems = 2, .start_at = 1929, .size = sizeof(TidScan)},
+	{.structname = "SubqueryScan", .nelems = 2, .start_at = 1931, .size = sizeof(SubqueryScan)},
+	{.structname = "FunctionScan", .nelems = 3, .start_at = 1933, .size = sizeof(FunctionScan)},
+	{.structname = "ValuesScan", .nelems = 2, .start_at = 1936, .size = sizeof(ValuesScan)},
+	{.structname = "TableFuncScan", .nelems = 2, .start_at = 1938, .size = sizeof(TableFuncScan)},
+	{.structname = "CteScan", .nelems = 3, .start_at = 1940, .size = sizeof(CteScan)},
+	{.structname = "NamedTuplestoreScan", .nelems = 2, .start_at = 1943, .size = sizeof(NamedTuplestoreScan)},
+	{.structname = "WorkTableScan", .nelems = 2, .start_at = 1945, .size = sizeof(WorkTableScan)},
+	{.structname = "ForeignScan", .nelems = 9, .start_at = 1947, .size = sizeof(ForeignScan)},
+	{.structname = "CustomScan", .nelems = 8, .start_at = 1956, .size = sizeof(CustomScan)},
+	{.structname = "Join", .nelems = 4, .start_at = 1964, .size = sizeof(Join)},
+	{.structname = "NestLoop", .nelems = 2, .start_at = 1968, .size = sizeof(NestLoop)},
+	{.structname = "MergeJoin", .nelems = 7, .start_at = 1973, .size = sizeof(MergeJoin)},
+	{.structname = "HashJoin", .nelems = 5, .start_at = 1980, .size = sizeof(HashJoin)},
+	{.structname = "Material", .nelems = 1, .start_at = 1985, .size = sizeof(Material)},
+	{.structname = "Sort", .nelems = 6, .start_at = 1986, .size = sizeof(Sort)},
+	{.structname = "Group", .nelems = 5, .start_at = 1992, .size = sizeof(Group)},
+	{.structname = "Agg", .nelems = 11, .start_at = 1997, .size = sizeof(Agg)},
+	{.structname = "WindowAgg", .nelems = 18, .start_at = 2008, .size = sizeof(WindowAgg)},
+	{.structname = "Unique", .nelems = 5, .start_at = 2026, .size = sizeof(Unique)},
+	{.structname = "Gather", .nelems = 6, .start_at = 2031, .size = sizeof(Gather)},
+	{.structname = "GatherMerge", .nelems = 9, .start_at = 2037, .size = sizeof(GatherMerge)},
+	{.structname = "Hash", .nelems = 6, .start_at = 2046, .size = sizeof(Hash)},
+	{.structname = "SetOp", .nelems = 10, .start_at = 2052, .size = sizeof(SetOp)},
+	{.structname = "LockRows", .nelems = 3, .start_at = 2062, .size = sizeof(LockRows)},
+	{.structname = "Limit", .nelems = 3, .start_at = 2065, .size = sizeof(Limit)},
+	{.structname = "NestLoopParam", .nelems = 3, .start_at = 1970, .size = sizeof(NestLoopParam)},
+	{.structname = "PlanRowMark", .nelems = 9, .start_at = 2068, .size = sizeof(PlanRowMark)},
+	{.structname = "PartitionPruneInfo", .nelems = 3, .start_at = 2077, .size = sizeof(PartitionPruneInfo)},
+	{.structname = "PartitionedRelPruneInfo", .nelems = 10, .start_at = 2080, .size = sizeof(PartitionedRelPruneInfo)},
+	{.structname = "PartitionPruneStepOp", .nelems = 5, .start_at = 2090, .size = sizeof(PartitionPruneStepOp)},
+	{.structname = "PartitionPruneStepCombine", .nelems = 3, .start_at = 2095, .size = sizeof(PartitionPruneStepCombine)},
+	{.structname = "PlanInvalItem", .nelems = 3, .start_at = 2098, .size = sizeof(PlanInvalItem)},
+	{.structname = "PlanState", .nelems = 31, .start_at = 2314, .size = sizeof(PlanState)},
+	{.structname = "ResultState", .nelems = 4, .start_at = 2345, .size = sizeof(ResultState)},
+	{.structname = "ProjectSetState", .nelems = 6, .start_at = 2349, .size = sizeof(ProjectSetState)},
+	{.structname = "ModifyTableState", .nelems = 19, .start_at = 2355, .size = sizeof(ModifyTableState)},
+	{.structname = "AppendState", .nelems = 10, .start_at = 2374, .size = sizeof(AppendState)},
+	{.structname = "MergeAppendState", .nelems = 11, .start_at = 2384, .size = sizeof(MergeAppendState)},
+	{.structname = "RecursiveUnionState", .nelems = 10, .start_at = 2395, .size = sizeof(RecursiveUnionState)},
+	{.structname = "BitmapAndState", .nelems = 3, .start_at = 2405, .size = sizeof(BitmapAndState)},
+	{.structname = "BitmapOrState", .nelems = 3, .start_at = 2408, .size = sizeof(BitmapOrState)},
+	{.structname = "ScanState", .nelems = 4, .start_at = 2411, .size = sizeof(ScanState)},
+	{.structname = "SeqScanState", .nelems = 2, .start_at = 2415, .size = sizeof(SeqScanState)},
+	{.structname = "SampleScanState", .nelems = 12, .start_at = 2417, .size = sizeof(SampleScanState)},
+	{.structname = "IndexScanState", .nelems = 21, .start_at = 2429, .size = sizeof(IndexScanState)},
+	{.structname = "IndexOnlyScanState", .nelems = 15, .start_at = 2450, .size = sizeof(IndexOnlyScanState)},
+	{.structname = "BitmapIndexScanState", .nelems = 12, .start_at = 2465, .size = sizeof(BitmapIndexScanState)},
+	{.structname = "BitmapHeapScanState", .nelems = 20, .start_at = 2477, .size = sizeof(BitmapHeapScanState)},
+	{.structname = "TidScanState", .nelems = 7, .start_at = 2497, .size = sizeof(TidScanState)},
+	{.structname = "SubqueryScanState", .nelems = 2, .start_at = 2504, .size = sizeof(SubqueryScanState)},
+	{.structname = "FunctionScanState", .nelems = 8, .start_at = 2506, .size = sizeof(FunctionScanState)},
+	{.structname = "TableFuncScanState", .nelems = 15, .start_at = 2519, .size = sizeof(TableFuncScanState)},
+	{.structname = "ValuesScanState", .nelems = 5, .start_at = 2514, .size = sizeof(ValuesScanState)},
+	{.structname = "CteScanState", .nelems = 7, .start_at = 2534, .size = sizeof(CteScanState)},
+	{.structname = "NamedTuplestoreScanState", .nelems = 4, .start_at = 2541, .size = sizeof(NamedTuplestoreScanState)},
+	{.structname = "WorkTableScanState", .nelems = 2, .start_at = 2545, .size = sizeof(WorkTableScanState)},
+	{.structname = "ForeignScanState", .nelems = 5, .start_at = 2547, .size = sizeof(ForeignScanState)},
+	{.structname = "CustomScanState", .nelems = 5, .start_at = 2552, .size = sizeof(CustomScanState)},
+	{.structname = "JoinState", .nelems = 4, .start_at = 2557, .size = sizeof(JoinState)},
+	{.structname = "NestLoopState", .nelems = 4, .start_at = 2561, .size = sizeof(NestLoopState)},
+	{.structname = "MergeJoinState", .nelems = 18, .start_at = 2565, .size = sizeof(MergeJoinState)},
+	{.structname = "HashJoinState", .nelems = 18, .start_at = 2583, .size = sizeof(HashJoinState)},
+	{.structname = "MaterialState", .nelems = 4, .start_at = 2601, .size = sizeof(MaterialState)},
+	{.structname = "SortState", .nelems = 10, .start_at = 2605, .size = sizeof(SortState)},
+	{.structname = "GroupState", .nelems = 3, .start_at = 2615, .size = sizeof(GroupState)},
+	{.structname = "AggState", .nelems = 36, .start_at = 2618, .size = sizeof(AggState)},
+	{.structname = "WindowAggState", .nelems = 52, .start_at = 2654, .size = sizeof(WindowAggState)},
+	{.structname = "UniqueState", .nelems = 2, .start_at = 2706, .size = sizeof(UniqueState)},
+	{.structname = "GatherState", .nelems = 10, .start_at = 2708, .size = sizeof(GatherState)},
+	{.structname = "GatherMergeState", .nelems = 15, .start_at = 2718, .size = sizeof(GatherMergeState)},
+	{.structname = "HashState", .nelems = 6, .start_at = 2733, .size = sizeof(HashState)},
+	{.structname = "SetOpState", .nelems = 12, .start_at = 2739, .size = sizeof(SetOpState)},
+	{.structname = "LockRowsState", .nelems = 3, .start_at = 2751, .size = sizeof(LockRowsState)},
+	{.structname = "LimitState", .nelems = 9, .start_at = 2754, .size = sizeof(LimitState)},
+	{.structname = "Alias", .nelems = 3, .start_at = 15, .size = sizeof(Alias)},
+	{.structname = "RangeVar", .nelems = 8, .start_at = 18, .size = sizeof(RangeVar)},
+	{.structname = "TableFunc", .nelems = 14, .start_at = 26, .size = sizeof(TableFunc)},
+	{.structname = "Expr", .nelems = 1, .start_at = 49, .size = sizeof(Expr)},
+	{.structname = "Var", .nelems = 10, .start_at = 50, .size = sizeof(Var)},
+	{.structname = "Const", .nelems = 9, .start_at = 60, .size = sizeof(Const)},
+	{.structname = "Param", .nelems = 7, .start_at = 69, .size = sizeof(Param)},
+	{.structname = "Aggref", .nelems = 18, .start_at = 76, .size = sizeof(Aggref)},
+	{.structname = "GroupingFunc", .nelems = 6, .start_at = 94, .size = sizeof(GroupingFunc)},
+	{.structname = "WindowFunc", .nelems = 11, .start_at = 100, .size = sizeof(WindowFunc)},
+	{.structname = "SubscriptingRef", .nelems = 9, .start_at = 111, .size = sizeof(SubscriptingRef)},
+	{.structname = "FuncExpr", .nelems = 10, .start_at = 120, .size = sizeof(FuncExpr)},
+	{.structname = "NamedArgExpr", .nelems = 5, .start_at = 130, .size = sizeof(NamedArgExpr)},
+	{.structname = "OpExpr", .nelems = 9, .start_at = 135, .size = sizeof(OpExpr)},
+	{.structname = "DistinctExpr", .nelems = 9, .start_at = 144, .size = sizeof(DistinctExpr)},
+	{.structname = "NullIfExpr", .nelems = 9, .start_at = 153, .size = sizeof(NullIfExpr)},
+	{.structname = "ScalarArrayOpExpr", .nelems = 7, .start_at = 162, .size = sizeof(ScalarArrayOpExpr)},
+	{.structname = "BoolExpr", .nelems = 4, .start_at = 169, .size = sizeof(BoolExpr)},
+	{.structname = "SubLink", .nelems = 7, .start_at = 173, .size = sizeof(SubLink)},
+	{.structname = "SubPlan", .nelems = 17, .start_at = 180, .size = sizeof(SubPlan)},
+	{.structname = "AlternativeSubPlan", .nelems = 2, .start_at = 197, .size = sizeof(AlternativeSubPlan)},
+	{.structname = "FieldSelect", .nelems = 6, .start_at = 199, .size = sizeof(FieldSelect)},
+	{.structname = "FieldStore", .nelems = 5, .start_at = 205, .size = sizeof(FieldStore)},
+	{.structname = "RelabelType", .nelems = 7, .start_at = 210, .size = sizeof(RelabelType)},
+	{.structname = "CoerceViaIO", .nelems = 6, .start_at = 217, .size = sizeof(CoerceViaIO)},
+	{.structname = "ArrayCoerceExpr", .nelems = 8, .start_at = 223, .size = sizeof(ArrayCoerceExpr)},
+	{.structname = "ConvertRowtypeExpr", .nelems = 5, .start_at = 231, .size = sizeof(ConvertRowtypeExpr)},
+	{.structname = "CollateExpr", .nelems = 4, .start_at = 236, .size = sizeof(CollateExpr)},
+	{.structname = "CaseExpr", .nelems = 7, .start_at = 240, .size = sizeof(CaseExpr)},
+	{.structname = "CaseWhen", .nelems = 4, .start_at = 247, .size = sizeof(CaseWhen)},
+	{.structname = "CaseTestExpr", .nelems = 4, .start_at = 251, .size = sizeof(CaseTestExpr)},
+	{.structname = "ArrayExpr", .nelems = 7, .start_at = 255, .size = sizeof(ArrayExpr)},
+	{.structname = "RowExpr", .nelems = 6, .start_at = 262, .size = sizeof(RowExpr)},
+	{.structname = "RowCompareExpr", .nelems = 7, .start_at = 268, .size = sizeof(RowCompareExpr)},
+	{.structname = "CoalesceExpr", .nelems = 5, .start_at = 275, .size = sizeof(CoalesceExpr)},
+	{.structname = "MinMaxExpr", .nelems = 7, .start_at = 280, .size = sizeof(MinMaxExpr)},
+	{.structname = "SQLValueFunction", .nelems = 5, .start_at = 287, .size = sizeof(SQLValueFunction)},
+	{.structname = "XmlExpr", .nelems = 10, .start_at = 292, .size = sizeof(XmlExpr)},
+	{.structname = "NullTest", .nelems = 5, .start_at = 302, .size = sizeof(NullTest)},
+	{.structname = "BooleanTest", .nelems = 4, .start_at = 307, .size = sizeof(BooleanTest)},
+	{.structname = "CoerceToDomain", .nelems = 7, .start_at = 311, .size = sizeof(CoerceToDomain)},
+	{.structname = "CoerceToDomainValue", .nelems = 5, .start_at = 318, .size = sizeof(CoerceToDomainValue)},
+	{.structname = "SetToDefault", .nelems = 5, .start_at = 323, .size = sizeof(SetToDefault)},
+	{.structname = "CurrentOfExpr", .nelems = 4, .start_at = 328, .size = sizeof(CurrentOfExpr)},
+	{.structname = "NextValueExpr", .nelems = 3, .start_at = 332, .size = sizeof(NextValueExpr)},
+	{.structname = "InferenceElem", .nelems = 4, .start_at = 335, .size = sizeof(InferenceElem)},
+	{.structname = "TargetEntry", .nelems = 8, .start_at = 339, .size = sizeof(TargetEntry)},
+	{.structname = "RangeTblRef", .nelems = 2, .start_at = 347, .size = sizeof(RangeTblRef)},
+	{.structname = "JoinExpr", .nelems = 9, .start_at = 349, .size = sizeof(JoinExpr)},
+	{.structname = "FromExpr", .nelems = 3, .start_at = 358, .size = sizeof(FromExpr)},
+	{.structname = "OnConflictExpr", .nelems = 9, .start_at = 361, .size = sizeof(OnConflictExpr)},
+	{.structname = "IntoClause", .nelems = 9, .start_at = 40, .size = sizeof(IntoClause)},
+	{.structname = "ExprState", .nelems = 17, .start_at = 2111, .size = sizeof(ExprState)},
+	{.structname = "AggrefExprState", .nelems = 3, .start_at = 2258, .size = sizeof(AggrefExprState)},
+	{.structname = "WindowFuncExprState", .nelems = 5, .start_at = 2261, .size = sizeof(WindowFuncExprState)},
+	{.structname = "SetExprState", .nelems = 13, .start_at = 2266, .size = sizeof(SetExprState)},
+	{.structname = "SubPlanState", .nelems = 26, .start_at = 2279, .size = sizeof(SubPlanState)},
+	{.structname = "AlternativeSubPlanState", .nelems = 4, .start_at = 2305, .size = sizeof(AlternativeSubPlanState)},
+	{.structname = "DomainConstraintState", .nelems = 5, .start_at = 2309, .size = sizeof(DomainConstraintState)},
+	{.structname = "PlannerInfo", .nelems = 60, .start_at = 1373, .size = sizeof(PlannerInfo)},
+	{.structname = "PlannerGlobal", .nelems = 21, .start_at = 1352, .size = sizeof(PlannerGlobal)},
+	{.structname = "RelOptInfo", .nelems = 57, .start_at = 1433, .size = sizeof(RelOptInfo)},
+	{.structname = "IndexOptInfo", .nelems = 34, .start_at = 1490, .size = sizeof(IndexOptInfo)},
+	{.structname = "ForeignKeyOptInfo", .nelems = 12, .start_at = 1524, .size = sizeof(ForeignKeyOptInfo)},
+	{.structname = "ParamPathInfo", .nelems = 4, .start_at = 1573, .size = sizeof(ParamPathInfo)},
+	{.structname = "Path", .nelems = 12, .start_at = 1577, .size = sizeof(Path)},
+	{.structname = "IndexPath", .nelems = 8, .start_at = 1589, .size = sizeof(IndexPath)},
+	{.structname = "BitmapHeapPath", .nelems = 2, .start_at = 1603, .size = sizeof(BitmapHeapPath)},
+	{.structname = "BitmapAndPath", .nelems = 3, .start_at = 1605, .size = sizeof(BitmapAndPath)},
+	{.structname = "BitmapOrPath", .nelems = 3, .start_at = 1608, .size = sizeof(BitmapOrPath)},
+	{.structname = "TidPath", .nelems = 2, .start_at = 1611, .size = sizeof(TidPath)},
+	{.structname = "SubqueryScanPath", .nelems = 2, .start_at = 1613, .size = sizeof(SubqueryScanPath)},
+	{.structname = "ForeignPath", .nelems = 3, .start_at = 1615, .size = sizeof(ForeignPath)},
+	{.structname = "CustomPath", .nelems = 5, .start_at = 1618, .size = sizeof(CustomPath)},
+	{.structname = "NestPath", .nelems = 6, .start_at = 1648, .size = sizeof(NestPath)},
+	{.structname = "MergePath", .nelems = 6, .start_at = 1654, .size = sizeof(MergePath)},
+	{.structname = "HashPath", .nelems = 4, .start_at = 1660, .size = sizeof(HashPath)},
+	{.structname = "AppendPath", .nelems = 5, .start_at = 1623, .size = sizeof(AppendPath)},
+	{.structname = "MergeAppendPath", .nelems = 4, .start_at = 1628, .size = sizeof(MergeAppendPath)},
+	{.structname = "GroupResultPath", .nelems = 2, .start_at = 1632, .size = sizeof(GroupResultPath)},
+	{.structname = "MaterialPath", .nelems = 2, .start_at = 1634, .size = sizeof(MaterialPath)},
+	{.structname = "UniquePath", .nelems = 5, .start_at = 1636, .size = sizeof(UniquePath)},
+	{.structname = "GatherPath", .nelems = 4, .start_at = 1641, .size = sizeof(GatherPath)},
+	{.structname = "GatherMergePath", .nelems = 3, .start_at = 1645, .size = sizeof(GatherMergePath)},
+	{.structname = "ProjectionPath", .nelems = 3, .start_at = 1664, .size = sizeof(ProjectionPath)},
+	{.structname = "ProjectSetPath", .nelems = 2, .start_at = 1667, .size = sizeof(ProjectSetPath)},
+	{.structname = "SortPath", .nelems = 2, .start_at = 1669, .size = sizeof(SortPath)},
+	{.structname = "GroupPath", .nelems = 4, .start_at = 1671, .size = sizeof(GroupPath)},
+	{.structname = "UpperUniquePath", .nelems = 3, .start_at = 1675, .size = sizeof(UpperUniquePath)},
+	{.structname = "AggPath", .nelems = 7, .start_at = 1678, .size = sizeof(AggPath)},
+	{.structname = "GroupingSetsPath", .nelems = 5, .start_at = 1695, .size = sizeof(GroupingSetsPath)},
+	{.structname = "MinMaxAggPath", .nelems = 3, .start_at = 1700, .size = sizeof(MinMaxAggPath)},
+	{.structname = "WindowAggPath", .nelems = 3, .start_at = 1703, .size = sizeof(WindowAggPath)},
+	{.structname = "SetOpPath", .nelems = 8, .start_at = 1706, .size = sizeof(SetOpPath)},
+	{.structname = "RecursiveUnionPath", .nelems = 6, .start_at = 1714, .size = sizeof(RecursiveUnionPath)},
+	{.structname = "LockRowsPath", .nelems = 4, .start_at = 1720, .size = sizeof(LockRowsPath)},
+	{.structname = "ModifyTablePath", .nelems = 14, .start_at = 1724, .size = sizeof(ModifyTablePath)},
+	{.structname = "LimitPath", .nelems = 4, .start_at = 1738, .size = sizeof(LimitPath)},
+	{.structname = "EquivalenceClass", .nelems = 15, .start_at = 1541, .size = sizeof(EquivalenceClass)},
+	{.structname = "EquivalenceMember", .nelems = 7, .start_at = 1556, .size = sizeof(EquivalenceMember)},
+	{.structname = "PathKey", .nelems = 5, .start_at = 1563, .size = sizeof(PathKey)},
+	{.structname = "PathTarget", .nelems = 5, .start_at = 1568, .size = sizeof(PathTarget)},
+	{.structname = "RestrictInfo", .nelems = 31, .start_at = 1742, .size = sizeof(RestrictInfo)},
+	{.structname = "IndexClause", .nelems = 6, .start_at = 1597, .size = sizeof(IndexClause)},
+	{.structname = "PlaceHolderVar", .nelems = 5, .start_at = 1773, .size = sizeof(PlaceHolderVar)},
+	{.structname = "SpecialJoinInfo", .nelems = 12, .start_at = 1778, .size = sizeof(SpecialJoinInfo)},
+	{.structname = "AppendRelInfo", .nelems = 7, .start_at = 1790, .size = sizeof(AppendRelInfo)},
+	{.structname = "PlaceHolderInfo", .nelems = 7, .start_at = 1797, .size = sizeof(PlaceHolderInfo)},
+	{.structname = "MinMaxAggInfo", .nelems = 8, .start_at = 1804, .size = sizeof(MinMaxAggInfo)},
+	{.structname = "PlannerParamItem", .nelems = 3, .start_at = 1812, .size = sizeof(PlannerParamItem)},
+	{.structname = "RollupData", .nelems = 7, .start_at = 1688, .size = sizeof(RollupData)},
+	{.structname = "GroupingSetData", .nelems = 3, .start_at = 1685, .size = sizeof(GroupingSetData)},
+	{.structname = "StatisticExtInfo", .nelems = 5, .start_at = 1536, .size = sizeof(StatisticExtInfo)},
+	{.structname = "MemoryContext", .nelems = 0, .start_at = 0, .size = sizeof(MemoryContext)},
+	{0},
+	{0},
+	{0},
+	{.structname = "Value", .nelems = 2, .start_at = 370, .size = sizeof(Value)},
+	{.structname = "Integer", .nelems = 2, .start_at = 372, .size = sizeof(Integer)},
+	{.structname = "Float", .nelems = 2, .start_at = 374, .size = sizeof(Float)},
+	{.structname = "String", .nelems = 2, .start_at = 376, .size = sizeof(String)},
+	{.structname = "BitString", .nelems = 2, .start_at = 378, .size = sizeof(BitString)},
+	{.structname = "Null", .nelems = 2, .start_at = 380, .size = sizeof(Null)},
+	{.structname = "List", .nelems = 5, .start_at = 0, .size = sizeof(List)},
+	{.structname = "IntList", .nelems = 5, .start_at = 10, .size = sizeof(IntList)},
+	{.structname = "OidList", .nelems = 5, .start_at = 5, .size = sizeof(OidList)},
+	{.structname = "ExtensibleNode", .nelems = 2, .start_at = 2763, .size = sizeof(ExtensibleNode)},
+	{.structname = "RawStmt", .nelems = 4, .start_at = 717, .size = sizeof(RawStmt)},
+	{.structname = "Query", .nelems = 37, .start_at = 391, .size = sizeof(Query)},
+	{.structname = "PlannedStmt", .nelems = 23, .start_at = 1815, .size = sizeof(PlannedStmt)},
+	{.structname = "InsertStmt", .nelems = 8, .start_at = 721, .size = sizeof(InsertStmt)},
+	{.structname = "DeleteStmt", .nelems = 6, .start_at = 729, .size = sizeof(DeleteStmt)},
+	{.structname = "UpdateStmt", .nelems = 7, .start_at = 735, .size = sizeof(UpdateStmt)},
+	{.structname = "SelectStmt", .nelems = 19, .start_at = 742, .size = sizeof(SelectStmt)},
+	{.structname = "AlterTableStmt", .nelems = 5, .start_at = 775, .size = sizeof(AlterTableStmt)},
+	{.structname = "AlterTableCmd", .nelems = 8, .start_at = 783, .size = sizeof(AlterTableCmd)},
+	{.structname = "AlterDomainStmt", .nelems = 7, .start_at = 793, .size = sizeof(AlterDomainStmt)},
+	{.structname = "SetOperationStmt", .nelems = 9, .start_at = 761, .size = sizeof(SetOperationStmt)},
+	{.structname = "GrantStmt", .nelems = 9, .start_at = 800, .size = sizeof(GrantStmt)},
+	{.structname = "GrantRoleStmt", .nelems = 7, .start_at = 816, .size = sizeof(GrantRoleStmt)},
+	{.structname = "AlterDefaultPrivilegesStmt", .nelems = 3, .start_at = 823, .size = sizeof(AlterDefaultPrivilegesStmt)},
+	{.structname = "ClosePortalStmt", .nelems = 2, .start_at = 1089, .size = sizeof(ClosePortalStmt)},
+	{.structname = "ClusterStmt", .nelems = 4, .start_at = 1241, .size = sizeof(ClusterStmt)},
+	{.structname = "CopyStmt", .nelems = 9, .start_at = 826, .size = sizeof(CopyStmt)},
+	{.structname = "CreateStmt", .nelems = 13, .start_at = 842, .size = sizeof(CreateStmt)},
+	{.structname = "DefineStmt", .nelems = 8, .start_at = 1031, .size = sizeof(DefineStmt)},
+	{.structname = "DropStmt", .nelems = 6, .start_at = 1066, .size = sizeof(DropStmt)},
+	{.structname = "TruncateStmt", .nelems = 4, .start_at = 1072, .size = sizeof(TruncateStmt)},
+	{.structname = "CommentStmt", .nelems = 4, .start_at = 1076, .size = sizeof(CommentStmt)},
+	{.structname = "FetchStmt", .nelems = 5, .start_at = 1091, .size = sizeof(FetchStmt)},
+	{.structname = "IndexStmt", .nelems = 22, .start_at = 1096, .size = sizeof(IndexStmt)},
+	{.structname = "CreateFunctionStmt", .nelems = 7, .start_at = 1125, .size = sizeof(CreateFunctionStmt)},
+	{.structname = "AlterFunctionStmt", .nelems = 4, .start_at = 1137, .size = sizeof(AlterFunctionStmt)},
+	{.structname = "DoStmt", .nelems = 2, .start_at = 1141, .size = sizeof(DoStmt)},
+	{.structname = "RenameStmt", .nelems = 9, .start_at = 1153, .size = sizeof(RenameStmt)},
+	{.structname = "RuleStmt", .nelems = 8, .start_at = 1181, .size = sizeof(RuleStmt)},
+	{.structname = "NotifyStmt", .nelems = 3, .start_at = 1189, .size = sizeof(NotifyStmt)},
+	{.structname = "ListenStmt", .nelems = 2, .start_at = 1192, .size = sizeof(ListenStmt)},
+	{.structname = "UnlistenStmt", .nelems = 2, .start_at = 1194, .size = sizeof(UnlistenStmt)},
+	{.structname = "TransactionStmt", .nelems = 6, .start_at = 1196, .size = sizeof(TransactionStmt)},
+	{.structname = "ViewStmt", .nelems = 7, .start_at = 1218, .size = sizeof(ViewStmt)},
+	{.structname = "LoadStmt", .nelems = 2, .start_at = 1225, .size = sizeof(LoadStmt)},
+	{.structname = "CreateDomainStmt", .nelems = 5, .start_at = 1039, .size = sizeof(CreateDomainStmt)},
+	{.structname = "CreatedbStmt", .nelems = 3, .start_at = 1227, .size = sizeof(CreatedbStmt)},
+	{.structname = "DropdbStmt", .nelems = 3, .start_at = 1236, .size = sizeof(DropdbStmt)},
+	{.structname = "VacuumStmt", .nelems = 4, .start_at = 1245, .size = sizeof(VacuumStmt)},
+	{.structname = "ExplainStmt", .nelems = 3, .start_at = 1253, .size = sizeof(ExplainStmt)},
+	{.structname = "CreateTableAsStmt", .nelems = 6, .start_at = 1256, .size = sizeof(CreateTableAsStmt)},
+	{.structname = "CreateSeqStmt", .nelems = 6, .start_at = 1020, .size = sizeof(CreateSeqStmt)},
+	{.structname = "AlterSeqStmt", .nelems = 5, .start_at = 1026, .size = sizeof(AlterSeqStmt)},
+	{.structname = "VariableSetStmt", .nelems = 5, .start_at = 835, .size = sizeof(VariableSetStmt)},
+	{.structname = "VariableShowStmt", .nelems = 2, .start_at = 840, .size = sizeof(VariableShowStmt)},
+	{.structname = "DiscardStmt", .nelems = 2, .start_at = 1267, .size = sizeof(DiscardStmt)},
+	{.structname = "CreateTrigStmt", .nelems = 15, .start_at = 975, .size = sizeof(CreateTrigStmt)},
+	{.structname = "CreatePLangStmt", .nelems = 7, .start_at = 998, .size = sizeof(CreatePLangStmt)},
+	{.structname = "CreateRoleStmt", .nelems = 4, .start_at = 1005, .size = sizeof(CreateRoleStmt)},
+	{.structname = "AlterRoleStmt", .nelems = 4, .start_at = 1009, .size = sizeof(AlterRoleStmt)},
+	{.structname = "DropRoleStmt", .nelems = 3, .start_at = 1017, .size = sizeof(DropRoleStmt)},
+	{.structname = "LockStmt", .nelems = 4, .start_at = 1269, .size = sizeof(LockStmt)},
+	{.structname = "ConstraintsSetStmt", .nelems = 3, .start_at = 1273, .size = sizeof(ConstraintsSetStmt)},
+	{.structname = "ReindexStmt", .nelems = 6, .start_at = 1276, .size = sizeof(ReindexStmt)},
+	{.structname = "CheckPointStmt", .nelems = 1, .start_at = 1266, .size = sizeof(CheckPointStmt)},
+	{.structname = "CreateSchemaStmt", .nelems = 5, .start_at = 770, .size = sizeof(CreateSchemaStmt)},
+	{.structname = "AlterDatabaseStmt", .nelems = 3, .start_at = 1230, .size = sizeof(AlterDatabaseStmt)},
+	{.structname = "AlterDatabaseSetStmt", .nelems = 3, .start_at = 1233, .size = sizeof(AlterDatabaseSetStmt)},
+	{.structname = "AlterRoleSetStmt", .nelems = 4, .start_at = 1013, .size = sizeof(AlterRoleSetStmt)},
+	{.structname = "CreateConversionStmt", .nelems = 6, .start_at = 1282, .size = sizeof(CreateConversionStmt)},
+	{.structname = "CreateCastStmt", .nelems = 6, .start_at = 1288, .size = sizeof(CreateCastStmt)},
+	{.structname = "CreateOpClassStmt", .nelems = 7, .start_at = 1044, .size = sizeof(CreateOpClassStmt)},
+	{.structname = "CreateOpFamilyStmt", .nelems = 3, .start_at = 1058, .size = sizeof(CreateOpFamilyStmt)},
+	{.structname = "AlterOpFamilyStmt", .nelems = 5, .start_at = 1061, .size = sizeof(AlterOpFamilyStmt)},
+	{.structname = "PrepareStmt", .nelems = 4, .start_at = 1300, .size = sizeof(PrepareStmt)},
+	{.structname = "ExecuteStmt", .nelems = 3, .start_at = 1304, .size = sizeof(ExecuteStmt)},
+	{.structname = "DeallocateStmt", .nelems = 2, .start_at = 1307, .size = sizeof(DeallocateStmt)},
+	{.structname = "DeclareCursorStmt", .nelems = 4, .start_at = 1085, .size = sizeof(DeclareCursorStmt)},
+	{.structname = "CreateTableSpaceStmt", .nelems = 5, .start_at = 884, .size = sizeof(CreateTableSpaceStmt)},
+	{.structname = "DropTableSpaceStmt", .nelems = 3, .start_at = 889, .size = sizeof(DropTableSpaceStmt)},
+	{.structname = "AlterObjectDependsStmt", .nelems = 5, .start_at = 1162, .size = sizeof(AlterObjectDependsStmt)},
+	{.structname = "AlterObjectSchemaStmt", .nelems = 6, .start_at = 1167, .size = sizeof(AlterObjectSchemaStmt)},
+	{.structname = "AlterOwnerStmt", .nelems = 5, .start_at = 1173, .size = sizeof(AlterOwnerStmt)},
+	{.structname = "AlterOperatorStmt", .nelems = 3, .start_at = 1178, .size = sizeof(AlterOperatorStmt)},
+	{.structname = "DropOwnedStmt", .nelems = 3, .start_at = 1309, .size = sizeof(DropOwnedStmt)},
+	{.structname = "ReassignOwnedStmt", .nelems = 3, .start_at = 1312, .size = sizeof(ReassignOwnedStmt)},
+	{.structname = "CompositeTypeStmt", .nelems = 3, .start_at = 1202, .size = sizeof(CompositeTypeStmt)},
+	{.structname = "CreateEnumStmt", .nelems = 3, .start_at = 1205, .size = sizeof(CreateEnumStmt)},
+	{.structname = "CreateRangeStmt", .nelems = 3, .start_at = 1208, .size = sizeof(CreateRangeStmt)},
+	{.structname = "AlterEnumStmt", .nelems = 7, .start_at = 1211, .size = sizeof(AlterEnumStmt)},
+	{.structname = "AlterTSDictionaryStmt", .nelems = 3, .start_at = 1315, .size = sizeof(AlterTSDictionaryStmt)},
+	{.structname = "AlterTSConfigurationStmt", .nelems = 8, .start_at = 1318, .size = sizeof(AlterTSConfigurationStmt)},
+	{.structname = "CreateFdwStmt", .nelems = 4, .start_at = 914, .size = sizeof(CreateFdwStmt)},
+	{.structname = "AlterFdwStmt", .nelems = 4, .start_at = 918, .size = sizeof(AlterFdwStmt)},
+	{.structname = "CreateForeignServerStmt", .nelems = 7, .start_at = 922, .size = sizeof(CreateForeignServerStmt)},
+	{.structname = "AlterForeignServerStmt", .nelems = 5, .start_at = 929, .size = sizeof(AlterForeignServerStmt)},
+	{.structname = "CreateUserMappingStmt", .nelems = 5, .start_at = 937, .size = sizeof(CreateUserMappingStmt)},
+	{.structname = "AlterUserMappingStmt", .nelems = 4, .start_at = 942, .size = sizeof(AlterUserMappingStmt)},
+	{.structname = "DropUserMappingStmt", .nelems = 4, .start_at = 946, .size = sizeof(DropUserMappingStmt)},
+	{.structname = "AlterTableSpaceOptionsStmt", .nelems = 4, .start_at = 892, .size = sizeof(AlterTableSpaceOptionsStmt)},
+	{.structname = "AlterTableMoveAllStmt", .nelems = 6, .start_at = 896, .size = sizeof(AlterTableMoveAllStmt)},
+	{.structname = "SecLabelStmt", .nelems = 5, .start_at = 1080, .size = sizeof(SecLabelStmt)},
+	{.structname = "CreateForeignTableStmt", .nelems = 3, .start_at = 934, .size = sizeof(CreateForeignTableStmt)},
+	{.structname = "ImportForeignSchemaStmt", .nelems = 7, .start_at = 950, .size = sizeof(ImportForeignSchemaStmt)},
+	{.structname = "CreateExtensionStmt", .nelems = 4, .start_at = 902, .size = sizeof(CreateExtensionStmt)},
+	{.structname = "AlterExtensionStmt", .nelems = 3, .start_at = 906, .size = sizeof(AlterExtensionStmt)},
+	{.structname = "AlterExtensionContentsStmt", .nelems = 5, .start_at = 909, .size = sizeof(AlterExtensionContentsStmt)},
+	{.structname = "CreateEventTrigStmt", .nelems = 5, .start_at = 990, .size = sizeof(CreateEventTrigStmt)},
+	{.structname = "AlterEventTrigStmt", .nelems = 3, .start_at = 995, .size = sizeof(AlterEventTrigStmt)},
+	{.structname = "RefreshMatViewStmt", .nelems = 4, .start_at = 1262, .size = sizeof(RefreshMatViewStmt)},
+	{.structname = "ReplicaIdentityStmt", .nelems = 3, .start_at = 780, .size = sizeof(ReplicaIdentityStmt)},
+	{.structname = "AlterSystemStmt", .nelems = 2, .start_at = 1239, .size = sizeof(AlterSystemStmt)},
+	{.structname = "CreatePolicyStmt", .nelems = 8, .start_at = 957, .size = sizeof(CreatePolicyStmt)},
+	{.structname = "AlterPolicyStmt", .nelems = 6, .start_at = 965, .size = sizeof(AlterPolicyStmt)},
+	{.structname = "CreateTransformStmt", .nelems = 6, .start_at = 1294, .size = sizeof(CreateTransformStmt)},
+	{.structname = "CreateAmStmt", .nelems = 4, .start_at = 971, .size = sizeof(CreateAmStmt)},
+	{.structname = "CreatePublicationStmt", .nelems = 5, .start_at = 1326, .size = sizeof(CreatePublicationStmt)},
+	{.structname = "AlterPublicationStmt", .nelems = 6, .start_at = 1331, .size = sizeof(AlterPublicationStmt)},
+	{.structname = "CreateSubscriptionStmt", .nelems = 5, .start_at = 1337, .size = sizeof(CreateSubscriptionStmt)},
+	{.structname = "AlterSubscriptionStmt", .nelems = 6, .start_at = 1342, .size = sizeof(AlterSubscriptionStmt)},
+	{.structname = "DropSubscriptionStmt", .nelems = 4, .start_at = 1348, .size = sizeof(DropSubscriptionStmt)},
+	{.structname = "CreateStatsStmt", .nelems = 7, .start_at = 1118, .size = sizeof(CreateStatsStmt)},
+	{.structname = "AlterCollationStmt", .nelems = 2, .start_at = 791, .size = sizeof(AlterCollationStmt)},
+	{.structname = "CallStmt", .nelems = 3, .start_at = 1148, .size = sizeof(CallStmt)},
+	{.structname = "A_Expr", .nelems = 6, .start_at = 443, .size = sizeof(A_Expr)},
+	{.structname = "ColumnRef", .nelems = 3, .start_at = 437, .size = sizeof(ColumnRef)},
+	{.structname = "ParamRef", .nelems = 3, .start_at = 440, .size = sizeof(ParamRef)},
+	{.structname = "A_Const", .nelems = 3, .start_at = 449, .size = sizeof(A_Const)},
+	{.structname = "FuncCall", .nelems = 11, .start_at = 464, .size = sizeof(FuncCall)},
+	{.structname = "A_Star", .nelems = 1, .start_at = 475, .size = sizeof(A_Star)},
+	{.structname = "A_Indices", .nelems = 4, .start_at = 476, .size = sizeof(A_Indices)},
+	{.structname = "A_Indirection", .nelems = 3, .start_at = 480, .size = sizeof(A_Indirection)},
+	{.structname = "A_ArrayExpr", .nelems = 3, .start_at = 483, .size = sizeof(A_ArrayExpr)},
+	{.structname = "ResTarget", .nelems = 5, .start_at = 486, .size = sizeof(ResTarget)},
+	{.structname = "MultiAssignRef", .nelems = 4, .start_at = 491, .size = sizeof(MultiAssignRef)},
+	{.structname = "TypeCast", .nelems = 4, .start_at = 452, .size = sizeof(TypeCast)},
+	{.structname = "CollateClause", .nelems = 4, .start_at = 456, .size = sizeof(CollateClause)},
+	{.structname = "SortBy", .nelems = 6, .start_at = 495, .size = sizeof(SortBy)},
+	{.structname = "WindowDef", .nelems = 9, .start_at = 501, .size = sizeof(WindowDef)},
+	{.structname = "RangeSubselect", .nelems = 4, .start_at = 510, .size = sizeof(RangeSubselect)},
+	{.structname = "RangeFunction", .nelems = 7, .start_at = 514, .size = sizeof(RangeFunction)},
+	{.structname = "RangeTableSample", .nelems = 6, .start_at = 537, .size = sizeof(RangeTableSample)},
+	{.structname = "RangeTableFunc", .nelems = 8, .start_at = 521, .size = sizeof(RangeTableFunc)},
+	{.structname = "RangeTableFuncCol", .nelems = 8, .start_at = 529, .size = sizeof(RangeTableFuncCol)},
+	{.structname = "TypeName", .nelems = 9, .start_at = 428, .size = sizeof(TypeName)},
+	{.structname = "ColumnDef", .nelems = 18, .start_at = 543, .size = sizeof(ColumnDef)},
+	{.structname = "IndexElem", .nelems = 8, .start_at = 564, .size = sizeof(IndexElem)},
+	{.structname = "Constraint", .nelems = 29, .start_at = 855, .size = sizeof(Constraint)},
+	{.structname = "DefElem", .nelems = 6, .start_at = 572, .size = sizeof(DefElem)},
+	{.structname = "RangeTblEntry", .nelems = 34, .start_at = 604, .size = sizeof(RangeTblEntry)},
+	{.structname = "RangeTblFunction", .nelems = 8, .start_at = 638, .size = sizeof(RangeTblFunction)},
+	{.structname = "TableSampleClause", .nelems = 4, .start_at = 646, .size = sizeof(TableSampleClause)},
+	{.structname = "WithCheckOption", .nelems = 6, .start_at = 650, .size = sizeof(WithCheckOption)},
+	{.structname = "SortGroupClause", .nelems = 6, .start_at = 656, .size = sizeof(SortGroupClause)},
+	{.structname = "GroupingSet", .nelems = 4, .start_at = 662, .size = sizeof(GroupingSet)},
+	{.structname = "WindowClause", .nelems = 15, .start_at = 666, .size = sizeof(WindowClause)},
+	{.structname = "ObjectWithArgs", .nelems = 4, .start_at = 809, .size = sizeof(ObjectWithArgs)},
+	{.structname = "AccessPriv", .nelems = 3, .start_at = 813, .size = sizeof(AccessPriv)},
+	{.structname = "CreateOpClassItem", .nelems = 7, .start_at = 1051, .size = sizeof(CreateOpClassItem)},
+	{.structname = "TableLikeClause", .nelems = 3, .start_at = 561, .size = sizeof(TableLikeClause)},
+	{.structname = "FunctionParameter", .nelems = 5, .start_at = 1132, .size = sizeof(FunctionParameter)},
+	{.structname = "LockingClause", .nelems = 4, .start_at = 578, .size = sizeof(LockingClause)},
+	{.structname = "RowMarkClause", .nelems = 5, .start_at = 681, .size = sizeof(RowMarkClause)},
+	{.structname = "XmlSerialize", .nelems = 5, .start_at = 582, .size = sizeof(XmlSerialize)},
+	{.structname = "WithClause", .nelems = 4, .start_at = 686, .size = sizeof(WithClause)},
+	{.structname = "InferClause", .nelems = 5, .start_at = 690, .size = sizeof(InferClause)},
+	{.structname = "OnConflictClause", .nelems = 6, .start_at = 695, .size = sizeof(OnConflictClause)},
+	{.structname = "CommonTableExpr", .nelems = 12, .start_at = 701, .size = sizeof(CommonTableExpr)},
+	{.structname = "RoleSpec", .nelems = 4, .start_at = 460, .size = sizeof(RoleSpec)},
+	{.structname = "TriggerTransition", .nelems = 4, .start_at = 713, .size = sizeof(TriggerTransition)},
+	{.structname = "PartitionElem", .nelems = 6, .start_at = 587, .size = sizeof(PartitionElem)},
+	{.structname = "PartitionSpec", .nelems = 4, .start_at = 593, .size = sizeof(PartitionSpec)},
+	{.structname = "PartitionBoundSpec", .nelems = 9, .start_at = 382, .size = sizeof(PartitionBoundSpec)},
+	{.structname = "PartitionRangeDatum", .nelems = 4, .start_at = 597, .size = sizeof(PartitionRangeDatum)},
+	{.structname = "PartitionCmd", .nelems = 3, .start_at = 601, .size = sizeof(PartitionCmd)},
+	{.structname = "VacuumRelation", .nelems = 4, .start_at = 1249, .size = sizeof(VacuumRelation)},
+	{.structname = "IdentifySystemCmd", .nelems = 1, .start_at = 2765, .size = sizeof(IdentifySystemCmd)},
+	{.structname = "BaseBackupCmd", .nelems = 2, .start_at = 2766, .size = sizeof(BaseBackupCmd)},
+	{.structname = "CreateReplicationSlotCmd", .nelems = 6, .start_at = 2768, .size = sizeof(CreateReplicationSlotCmd)},
+	{.structname = "DropReplicationSlotCmd", .nelems = 3, .start_at = 2774, .size = sizeof(DropReplicationSlotCmd)},
+	{.structname = "StartReplicationCmd", .nelems = 6, .start_at = 2777, .size = sizeof(StartReplicationCmd)},
+	{.structname = "TimeLineHistoryCmd", .nelems = 2, .start_at = 2783, .size = sizeof(TimeLineHistoryCmd)},
+	{.structname = "SQLCmd", .nelems = 1, .start_at = 2785, .size = sizeof(SQLCmd)},
+	{0},
+	{0},
+	{.structname = "ReturnSetInfo", .nelems = 8, .start_at = 2166, .size = sizeof(ReturnSetInfo)},
+	{0},
+	{.structname = "TIDBitmap", .nelems = 0, .start_at = 2111, .size = -1},
+	{.structname = "InlineCodeBlock", .nelems = 5, .start_at = 1143, .size = sizeof(InlineCodeBlock)},
+	{0},
+	{0},
+	{0},
+	{0},
+	{0},
+	{.structname = "CallContext", .nelems = 2, .start_at = 1151, .size = sizeof(CallContext)},
+	{0},
+	{0},
+	{0},
+	{0},
+	{0}
+};
+
+NodeTypeComponents node_type_components[] = {
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct List, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "length", .fieldtype = "int", .offset = offsetof(struct List, length), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "max_length", .fieldtype = "int", .offset = offsetof(struct List, max_length), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "elements", .fieldtype = "union ListCell *", .offset = offsetof(struct List, elements), .size = sizeof(union ListCell *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "initial_elements", .fieldtype = "union ListCell []", .offset = offsetof(struct List, initial_elements), .size = -1, .flags = TYPE_CAT_SCALAR | TYPE_CAT_INCOMPLETE, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct List, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "length", .fieldtype = "int", .offset = offsetof(struct List, length), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "max_length", .fieldtype = "int", .offset = offsetof(struct List, max_length), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "elements", .fieldtype = "union ListCell *", .offset = offsetof(struct List, elements), .size = sizeof(union ListCell *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "initial_elements", .fieldtype = "union ListCell []", .offset = offsetof(struct List, initial_elements), .size = -1, .flags = TYPE_CAT_SCALAR | TYPE_CAT_INCOMPLETE, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct List, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "length", .fieldtype = "int", .offset = offsetof(struct List, length), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "max_length", .fieldtype = "int", .offset = offsetof(struct List, max_length), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "elements", .fieldtype = "union ListCell *", .offset = offsetof(struct List, elements), .size = sizeof(union ListCell *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "initial_elements", .fieldtype = "union ListCell []", .offset = offsetof(struct List, initial_elements), .size = -1, .flags = TYPE_CAT_SCALAR | TYPE_CAT_INCOMPLETE, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct Alias, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "aliasname", .fieldtype = "char *", .offset = offsetof(struct Alias, aliasname), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "colnames", .fieldtype = "struct List *", .offset = offsetof(struct Alias, colnames), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct RangeVar, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "catalogname", .fieldtype = "char *", .offset = offsetof(struct RangeVar, catalogname), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "schemaname", .fieldtype = "char *", .offset = offsetof(struct RangeVar, schemaname), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "relname", .fieldtype = "char *", .offset = offsetof(struct RangeVar, relname), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "inh", .fieldtype = "_Bool", .offset = offsetof(struct RangeVar, inh), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "relpersistence", .fieldtype = "char", .offset = offsetof(struct RangeVar, relpersistence), .size = sizeof(char), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "alias", .fieldtype = "struct Alias *", .offset = offsetof(struct RangeVar, alias), .size = sizeof(struct Alias *), .flags = TYPE_CAT_POINTER, .node_type_id = 100, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct RangeVar, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct TableFunc, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ns_uris", .fieldtype = "struct List *", .offset = offsetof(struct TableFunc, ns_uris), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ns_names", .fieldtype = "struct List *", .offset = offsetof(struct TableFunc, ns_names), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "docexpr", .fieldtype = "struct Node *", .offset = offsetof(struct TableFunc, docexpr), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "rowexpr", .fieldtype = "struct Node *", .offset = offsetof(struct TableFunc, rowexpr), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "colnames", .fieldtype = "struct List *", .offset = offsetof(struct TableFunc, colnames), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "coltypes", .fieldtype = "struct List *", .offset = offsetof(struct TableFunc, coltypes), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "coltypmods", .fieldtype = "struct List *", .offset = offsetof(struct TableFunc, coltypmods), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "colcollations", .fieldtype = "struct List *", .offset = offsetof(struct TableFunc, colcollations), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "colexprs", .fieldtype = "struct List *", .offset = offsetof(struct TableFunc, colexprs), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "coldefexprs", .fieldtype = "struct List *", .offset = offsetof(struct TableFunc, coldefexprs), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "notnulls", .fieldtype = "struct Bitmapset *", .offset = offsetof(struct TableFunc, notnulls), .size = sizeof(struct Bitmapset *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_BITMAPSET},
+	{.fieldname = "ordinalitycol", .fieldtype = "int", .offset = offsetof(struct TableFunc, ordinalitycol), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct TableFunc, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct IntoClause, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "rel", .fieldtype = "struct RangeVar *", .offset = offsetof(struct IntoClause, rel), .size = sizeof(struct RangeVar *), .flags = TYPE_CAT_POINTER, .node_type_id = 101, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "colNames", .fieldtype = "struct List *", .offset = offsetof(struct IntoClause, colNames), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "accessMethod", .fieldtype = "char *", .offset = offsetof(struct IntoClause, accessMethod), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "options", .fieldtype = "struct List *", .offset = offsetof(struct IntoClause, options), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "onCommit", .fieldtype = "enum OnCommitAction", .offset = offsetof(struct IntoClause, onCommit), .size = sizeof(enum OnCommitAction), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "tableSpaceName", .fieldtype = "char *", .offset = offsetof(struct IntoClause, tableSpaceName), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "viewQuery", .fieldtype = "struct Node *", .offset = offsetof(struct IntoClause, viewQuery), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "skipData", .fieldtype = "_Bool", .offset = offsetof(struct IntoClause, skipData), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct Expr, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "xpr", .fieldtype = "struct Expr", .offset = offsetof(struct Var, xpr), .size = sizeof(struct Expr), .flags = TYPE_CAT_SCALAR, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "varno", .fieldtype = "unsigned int", .offset = offsetof(struct Var, varno), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "varattno", .fieldtype = "short", .offset = offsetof(struct Var, varattno), .size = sizeof(short), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "vartype", .fieldtype = "unsigned int", .offset = offsetof(struct Var, vartype), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "vartypmod", .fieldtype = "int", .offset = offsetof(struct Var, vartypmod), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "varcollid", .fieldtype = "unsigned int", .offset = offsetof(struct Var, varcollid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "varlevelsup", .fieldtype = "unsigned int", .offset = offsetof(struct Var, varlevelsup), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "varnoold", .fieldtype = "unsigned int", .offset = offsetof(struct Var, varnoold), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "varoattno", .fieldtype = "short", .offset = offsetof(struct Var, varoattno), .size = sizeof(short), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct Var, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "xpr", .fieldtype = "struct Expr", .offset = offsetof(struct Const, xpr), .size = sizeof(struct Expr), .flags = TYPE_CAT_SCALAR, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "consttype", .fieldtype = "unsigned int", .offset = offsetof(struct Const, consttype), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "consttypmod", .fieldtype = "int", .offset = offsetof(struct Const, consttypmod), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "constcollid", .fieldtype = "unsigned int", .offset = offsetof(struct Const, constcollid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "constlen", .fieldtype = "int", .offset = offsetof(struct Const, constlen), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "constvalue", .fieldtype = "unsigned long", .offset = offsetof(struct Const, constvalue), .size = sizeof(unsigned long), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "constisnull", .fieldtype = "_Bool", .offset = offsetof(struct Const, constisnull), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "constbyval", .fieldtype = "_Bool", .offset = offsetof(struct Const, constbyval), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct Const, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "xpr", .fieldtype = "struct Expr", .offset = offsetof(struct Param, xpr), .size = sizeof(struct Expr), .flags = TYPE_CAT_SCALAR, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "paramkind", .fieldtype = "enum ParamKind", .offset = offsetof(struct Param, paramkind), .size = sizeof(enum ParamKind), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "paramid", .fieldtype = "int", .offset = offsetof(struct Param, paramid), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "paramtype", .fieldtype = "unsigned int", .offset = offsetof(struct Param, paramtype), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "paramtypmod", .fieldtype = "int", .offset = offsetof(struct Param, paramtypmod), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "paramcollid", .fieldtype = "unsigned int", .offset = offsetof(struct Param, paramcollid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct Param, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "xpr", .fieldtype = "struct Expr", .offset = offsetof(struct Aggref, xpr), .size = sizeof(struct Expr), .flags = TYPE_CAT_SCALAR, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "aggfnoid", .fieldtype = "unsigned int", .offset = offsetof(struct Aggref, aggfnoid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "aggtype", .fieldtype = "unsigned int", .offset = offsetof(struct Aggref, aggtype), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "aggcollid", .fieldtype = "unsigned int", .offset = offsetof(struct Aggref, aggcollid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "inputcollid", .fieldtype = "unsigned int", .offset = offsetof(struct Aggref, inputcollid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "aggtranstype", .fieldtype = "unsigned int", .offset = offsetof(struct Aggref, aggtranstype), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "aggargtypes", .fieldtype = "struct List *", .offset = offsetof(struct Aggref, aggargtypes), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "aggdirectargs", .fieldtype = "struct List *", .offset = offsetof(struct Aggref, aggdirectargs), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "args", .fieldtype = "struct List *", .offset = offsetof(struct Aggref, args), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "aggorder", .fieldtype = "struct List *", .offset = offsetof(struct Aggref, aggorder), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "aggdistinct", .fieldtype = "struct List *", .offset = offsetof(struct Aggref, aggdistinct), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "aggfilter", .fieldtype = "struct Expr *", .offset = offsetof(struct Aggref, aggfilter), .size = sizeof(struct Expr *), .flags = TYPE_CAT_POINTER, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "aggstar", .fieldtype = "_Bool", .offset = offsetof(struct Aggref, aggstar), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "aggvariadic", .fieldtype = "_Bool", .offset = offsetof(struct Aggref, aggvariadic), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "aggkind", .fieldtype = "char", .offset = offsetof(struct Aggref, aggkind), .size = sizeof(char), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "agglevelsup", .fieldtype = "unsigned int", .offset = offsetof(struct Aggref, agglevelsup), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "aggsplit", .fieldtype = "enum AggSplit", .offset = offsetof(struct Aggref, aggsplit), .size = sizeof(enum AggSplit), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct Aggref, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "xpr", .fieldtype = "struct Expr", .offset = offsetof(struct GroupingFunc, xpr), .size = sizeof(struct Expr), .flags = TYPE_CAT_SCALAR, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "args", .fieldtype = "struct List *", .offset = offsetof(struct GroupingFunc, args), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "refs", .fieldtype = "struct List *", .offset = offsetof(struct GroupingFunc, refs), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "cols", .fieldtype = "struct List *", .offset = offsetof(struct GroupingFunc, cols), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "agglevelsup", .fieldtype = "unsigned int", .offset = offsetof(struct GroupingFunc, agglevelsup), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct GroupingFunc, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "xpr", .fieldtype = "struct Expr", .offset = offsetof(struct WindowFunc, xpr), .size = sizeof(struct Expr), .flags = TYPE_CAT_SCALAR, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "winfnoid", .fieldtype = "unsigned int", .offset = offsetof(struct WindowFunc, winfnoid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "wintype", .fieldtype = "unsigned int", .offset = offsetof(struct WindowFunc, wintype), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "wincollid", .fieldtype = "unsigned int", .offset = offsetof(struct WindowFunc, wincollid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "inputcollid", .fieldtype = "unsigned int", .offset = offsetof(struct WindowFunc, inputcollid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "args", .fieldtype = "struct List *", .offset = offsetof(struct WindowFunc, args), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "aggfilter", .fieldtype = "struct Expr *", .offset = offsetof(struct WindowFunc, aggfilter), .size = sizeof(struct Expr *), .flags = TYPE_CAT_POINTER, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "winref", .fieldtype = "unsigned int", .offset = offsetof(struct WindowFunc, winref), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "winstar", .fieldtype = "_Bool", .offset = offsetof(struct WindowFunc, winstar), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "winagg", .fieldtype = "_Bool", .offset = offsetof(struct WindowFunc, winagg), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct WindowFunc, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "xpr", .fieldtype = "struct Expr", .offset = offsetof(struct SubscriptingRef, xpr), .size = sizeof(struct Expr), .flags = TYPE_CAT_SCALAR, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "refcontainertype", .fieldtype = "unsigned int", .offset = offsetof(struct SubscriptingRef, refcontainertype), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "refelemtype", .fieldtype = "unsigned int", .offset = offsetof(struct SubscriptingRef, refelemtype), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "reftypmod", .fieldtype = "int", .offset = offsetof(struct SubscriptingRef, reftypmod), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "refcollid", .fieldtype = "unsigned int", .offset = offsetof(struct SubscriptingRef, refcollid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "refupperindexpr", .fieldtype = "struct List *", .offset = offsetof(struct SubscriptingRef, refupperindexpr), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "reflowerindexpr", .fieldtype = "struct List *", .offset = offsetof(struct SubscriptingRef, reflowerindexpr), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "refexpr", .fieldtype = "struct Expr *", .offset = offsetof(struct SubscriptingRef, refexpr), .size = sizeof(struct Expr *), .flags = TYPE_CAT_POINTER, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "refassgnexpr", .fieldtype = "struct Expr *", .offset = offsetof(struct SubscriptingRef, refassgnexpr), .size = sizeof(struct Expr *), .flags = TYPE_CAT_POINTER, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "xpr", .fieldtype = "struct Expr", .offset = offsetof(struct FuncExpr, xpr), .size = sizeof(struct Expr), .flags = TYPE_CAT_SCALAR, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "funcid", .fieldtype = "unsigned int", .offset = offsetof(struct FuncExpr, funcid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "funcresulttype", .fieldtype = "unsigned int", .offset = offsetof(struct FuncExpr, funcresulttype), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "funcretset", .fieldtype = "_Bool", .offset = offsetof(struct FuncExpr, funcretset), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "funcvariadic", .fieldtype = "_Bool", .offset = offsetof(struct FuncExpr, funcvariadic), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "funcformat", .fieldtype = "enum CoercionForm", .offset = offsetof(struct FuncExpr, funcformat), .size = sizeof(enum CoercionForm), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "funccollid", .fieldtype = "unsigned int", .offset = offsetof(struct FuncExpr, funccollid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "inputcollid", .fieldtype = "unsigned int", .offset = offsetof(struct FuncExpr, inputcollid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "args", .fieldtype = "struct List *", .offset = offsetof(struct FuncExpr, args), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct FuncExpr, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "xpr", .fieldtype = "struct Expr", .offset = offsetof(struct NamedArgExpr, xpr), .size = sizeof(struct Expr), .flags = TYPE_CAT_SCALAR, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "arg", .fieldtype = "struct Expr *", .offset = offsetof(struct NamedArgExpr, arg), .size = sizeof(struct Expr *), .flags = TYPE_CAT_POINTER, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "name", .fieldtype = "char *", .offset = offsetof(struct NamedArgExpr, name), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "argnumber", .fieldtype = "int", .offset = offsetof(struct NamedArgExpr, argnumber), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct NamedArgExpr, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "xpr", .fieldtype = "struct Expr", .offset = offsetof(struct OpExpr, xpr), .size = sizeof(struct Expr), .flags = TYPE_CAT_SCALAR, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "opno", .fieldtype = "unsigned int", .offset = offsetof(struct OpExpr, opno), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "opfuncid", .fieldtype = "unsigned int", .offset = offsetof(struct OpExpr, opfuncid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "opresulttype", .fieldtype = "unsigned int", .offset = offsetof(struct OpExpr, opresulttype), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "opretset", .fieldtype = "_Bool", .offset = offsetof(struct OpExpr, opretset), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "opcollid", .fieldtype = "unsigned int", .offset = offsetof(struct OpExpr, opcollid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "inputcollid", .fieldtype = "unsigned int", .offset = offsetof(struct OpExpr, inputcollid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "args", .fieldtype = "struct List *", .offset = offsetof(struct OpExpr, args), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct OpExpr, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "xpr", .fieldtype = "struct Expr", .offset = offsetof(struct OpExpr, xpr), .size = sizeof(struct Expr), .flags = TYPE_CAT_SCALAR, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "opno", .fieldtype = "unsigned int", .offset = offsetof(struct OpExpr, opno), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "opfuncid", .fieldtype = "unsigned int", .offset = offsetof(struct OpExpr, opfuncid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "opresulttype", .fieldtype = "unsigned int", .offset = offsetof(struct OpExpr, opresulttype), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "opretset", .fieldtype = "_Bool", .offset = offsetof(struct OpExpr, opretset), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "opcollid", .fieldtype = "unsigned int", .offset = offsetof(struct OpExpr, opcollid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "inputcollid", .fieldtype = "unsigned int", .offset = offsetof(struct OpExpr, inputcollid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "args", .fieldtype = "struct List *", .offset = offsetof(struct OpExpr, args), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct OpExpr, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "xpr", .fieldtype = "struct Expr", .offset = offsetof(struct OpExpr, xpr), .size = sizeof(struct Expr), .flags = TYPE_CAT_SCALAR, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "opno", .fieldtype = "unsigned int", .offset = offsetof(struct OpExpr, opno), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "opfuncid", .fieldtype = "unsigned int", .offset = offsetof(struct OpExpr, opfuncid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "opresulttype", .fieldtype = "unsigned int", .offset = offsetof(struct OpExpr, opresulttype), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "opretset", .fieldtype = "_Bool", .offset = offsetof(struct OpExpr, opretset), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "opcollid", .fieldtype = "unsigned int", .offset = offsetof(struct OpExpr, opcollid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "inputcollid", .fieldtype = "unsigned int", .offset = offsetof(struct OpExpr, inputcollid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "args", .fieldtype = "struct List *", .offset = offsetof(struct OpExpr, args), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct OpExpr, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "xpr", .fieldtype = "struct Expr", .offset = offsetof(struct ScalarArrayOpExpr, xpr), .size = sizeof(struct Expr), .flags = TYPE_CAT_SCALAR, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "opno", .fieldtype = "unsigned int", .offset = offsetof(struct ScalarArrayOpExpr, opno), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "opfuncid", .fieldtype = "unsigned int", .offset = offsetof(struct ScalarArrayOpExpr, opfuncid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "useOr", .fieldtype = "_Bool", .offset = offsetof(struct ScalarArrayOpExpr, useOr), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "inputcollid", .fieldtype = "unsigned int", .offset = offsetof(struct ScalarArrayOpExpr, inputcollid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "args", .fieldtype = "struct List *", .offset = offsetof(struct ScalarArrayOpExpr, args), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct ScalarArrayOpExpr, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "xpr", .fieldtype = "struct Expr", .offset = offsetof(struct BoolExpr, xpr), .size = sizeof(struct Expr), .flags = TYPE_CAT_SCALAR, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "boolop", .fieldtype = "enum BoolExprType", .offset = offsetof(struct BoolExpr, boolop), .size = sizeof(enum BoolExprType), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "args", .fieldtype = "struct List *", .offset = offsetof(struct BoolExpr, args), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct BoolExpr, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "xpr", .fieldtype = "struct Expr", .offset = offsetof(struct SubLink, xpr), .size = sizeof(struct Expr), .flags = TYPE_CAT_SCALAR, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "subLinkType", .fieldtype = "enum SubLinkType", .offset = offsetof(struct SubLink, subLinkType), .size = sizeof(enum SubLinkType), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "subLinkId", .fieldtype = "int", .offset = offsetof(struct SubLink, subLinkId), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "testexpr", .fieldtype = "struct Node *", .offset = offsetof(struct SubLink, testexpr), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "operName", .fieldtype = "struct List *", .offset = offsetof(struct SubLink, operName), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "subselect", .fieldtype = "struct Node *", .offset = offsetof(struct SubLink, subselect), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct SubLink, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "xpr", .fieldtype = "struct Expr", .offset = offsetof(struct SubPlan, xpr), .size = sizeof(struct Expr), .flags = TYPE_CAT_SCALAR, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "subLinkType", .fieldtype = "enum SubLinkType", .offset = offsetof(struct SubPlan, subLinkType), .size = sizeof(enum SubLinkType), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "testexpr", .fieldtype = "struct Node *", .offset = offsetof(struct SubPlan, testexpr), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "paramIds", .fieldtype = "struct List *", .offset = offsetof(struct SubPlan, paramIds), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "plan_id", .fieldtype = "int", .offset = offsetof(struct SubPlan, plan_id), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "plan_name", .fieldtype = "char *", .offset = offsetof(struct SubPlan, plan_name), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "firstColType", .fieldtype = "unsigned int", .offset = offsetof(struct SubPlan, firstColType), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "firstColTypmod", .fieldtype = "int", .offset = offsetof(struct SubPlan, firstColTypmod), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "firstColCollation", .fieldtype = "unsigned int", .offset = offsetof(struct SubPlan, firstColCollation), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "useHashTable", .fieldtype = "_Bool", .offset = offsetof(struct SubPlan, useHashTable), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "unknownEqFalse", .fieldtype = "_Bool", .offset = offsetof(struct SubPlan, unknownEqFalse), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "parallel_safe", .fieldtype = "_Bool", .offset = offsetof(struct SubPlan, parallel_safe), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "setParam", .fieldtype = "struct List *", .offset = offsetof(struct SubPlan, setParam), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "parParam", .fieldtype = "struct List *", .offset = offsetof(struct SubPlan, parParam), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "args", .fieldtype = "struct List *", .offset = offsetof(struct SubPlan, args), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "startup_cost", .fieldtype = "double", .offset = offsetof(struct SubPlan, startup_cost), .size = sizeof(double), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "per_call_cost", .fieldtype = "double", .offset = offsetof(struct SubPlan, per_call_cost), .size = sizeof(double), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "xpr", .fieldtype = "struct Expr", .offset = offsetof(struct AlternativeSubPlan, xpr), .size = sizeof(struct Expr), .flags = TYPE_CAT_SCALAR, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "subplans", .fieldtype = "struct List *", .offset = offsetof(struct AlternativeSubPlan, subplans), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "xpr", .fieldtype = "struct Expr", .offset = offsetof(struct FieldSelect, xpr), .size = sizeof(struct Expr), .flags = TYPE_CAT_SCALAR, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "arg", .fieldtype = "struct Expr *", .offset = offsetof(struct FieldSelect, arg), .size = sizeof(struct Expr *), .flags = TYPE_CAT_POINTER, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "fieldnum", .fieldtype = "short", .offset = offsetof(struct FieldSelect, fieldnum), .size = sizeof(short), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "resulttype", .fieldtype = "unsigned int", .offset = offsetof(struct FieldSelect, resulttype), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "resulttypmod", .fieldtype = "int", .offset = offsetof(struct FieldSelect, resulttypmod), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "resultcollid", .fieldtype = "unsigned int", .offset = offsetof(struct FieldSelect, resultcollid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "xpr", .fieldtype = "struct Expr", .offset = offsetof(struct FieldStore, xpr), .size = sizeof(struct Expr), .flags = TYPE_CAT_SCALAR, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "arg", .fieldtype = "struct Expr *", .offset = offsetof(struct FieldStore, arg), .size = sizeof(struct Expr *), .flags = TYPE_CAT_POINTER, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "newvals", .fieldtype = "struct List *", .offset = offsetof(struct FieldStore, newvals), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "fieldnums", .fieldtype = "struct List *", .offset = offsetof(struct FieldStore, fieldnums), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "resulttype", .fieldtype = "unsigned int", .offset = offsetof(struct FieldStore, resulttype), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "xpr", .fieldtype = "struct Expr", .offset = offsetof(struct RelabelType, xpr), .size = sizeof(struct Expr), .flags = TYPE_CAT_SCALAR, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "arg", .fieldtype = "struct Expr *", .offset = offsetof(struct RelabelType, arg), .size = sizeof(struct Expr *), .flags = TYPE_CAT_POINTER, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "resulttype", .fieldtype = "unsigned int", .offset = offsetof(struct RelabelType, resulttype), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "resulttypmod", .fieldtype = "int", .offset = offsetof(struct RelabelType, resulttypmod), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "resultcollid", .fieldtype = "unsigned int", .offset = offsetof(struct RelabelType, resultcollid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "relabelformat", .fieldtype = "enum CoercionForm", .offset = offsetof(struct RelabelType, relabelformat), .size = sizeof(enum CoercionForm), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct RelabelType, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "xpr", .fieldtype = "struct Expr", .offset = offsetof(struct CoerceViaIO, xpr), .size = sizeof(struct Expr), .flags = TYPE_CAT_SCALAR, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "arg", .fieldtype = "struct Expr *", .offset = offsetof(struct CoerceViaIO, arg), .size = sizeof(struct Expr *), .flags = TYPE_CAT_POINTER, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "resulttype", .fieldtype = "unsigned int", .offset = offsetof(struct CoerceViaIO, resulttype), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "resultcollid", .fieldtype = "unsigned int", .offset = offsetof(struct CoerceViaIO, resultcollid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "coerceformat", .fieldtype = "enum CoercionForm", .offset = offsetof(struct CoerceViaIO, coerceformat), .size = sizeof(enum CoercionForm), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct CoerceViaIO, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "xpr", .fieldtype = "struct Expr", .offset = offsetof(struct ArrayCoerceExpr, xpr), .size = sizeof(struct Expr), .flags = TYPE_CAT_SCALAR, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "arg", .fieldtype = "struct Expr *", .offset = offsetof(struct ArrayCoerceExpr, arg), .size = sizeof(struct Expr *), .flags = TYPE_CAT_POINTER, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "elemexpr", .fieldtype = "struct Expr *", .offset = offsetof(struct ArrayCoerceExpr, elemexpr), .size = sizeof(struct Expr *), .flags = TYPE_CAT_POINTER, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "resulttype", .fieldtype = "unsigned int", .offset = offsetof(struct ArrayCoerceExpr, resulttype), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "resulttypmod", .fieldtype = "int", .offset = offsetof(struct ArrayCoerceExpr, resulttypmod), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "resultcollid", .fieldtype = "unsigned int", .offset = offsetof(struct ArrayCoerceExpr, resultcollid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "coerceformat", .fieldtype = "enum CoercionForm", .offset = offsetof(struct ArrayCoerceExpr, coerceformat), .size = sizeof(enum CoercionForm), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct ArrayCoerceExpr, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "xpr", .fieldtype = "struct Expr", .offset = offsetof(struct ConvertRowtypeExpr, xpr), .size = sizeof(struct Expr), .flags = TYPE_CAT_SCALAR, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "arg", .fieldtype = "struct Expr *", .offset = offsetof(struct ConvertRowtypeExpr, arg), .size = sizeof(struct Expr *), .flags = TYPE_CAT_POINTER, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "resulttype", .fieldtype = "unsigned int", .offset = offsetof(struct ConvertRowtypeExpr, resulttype), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "convertformat", .fieldtype = "enum CoercionForm", .offset = offsetof(struct ConvertRowtypeExpr, convertformat), .size = sizeof(enum CoercionForm), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct ConvertRowtypeExpr, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "xpr", .fieldtype = "struct Expr", .offset = offsetof(struct CollateExpr, xpr), .size = sizeof(struct Expr), .flags = TYPE_CAT_SCALAR, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "arg", .fieldtype = "struct Expr *", .offset = offsetof(struct CollateExpr, arg), .size = sizeof(struct Expr *), .flags = TYPE_CAT_POINTER, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "collOid", .fieldtype = "unsigned int", .offset = offsetof(struct CollateExpr, collOid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct CollateExpr, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "xpr", .fieldtype = "struct Expr", .offset = offsetof(struct CaseExpr, xpr), .size = sizeof(struct Expr), .flags = TYPE_CAT_SCALAR, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "casetype", .fieldtype = "unsigned int", .offset = offsetof(struct CaseExpr, casetype), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "casecollid", .fieldtype = "unsigned int", .offset = offsetof(struct CaseExpr, casecollid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "arg", .fieldtype = "struct Expr *", .offset = offsetof(struct CaseExpr, arg), .size = sizeof(struct Expr *), .flags = TYPE_CAT_POINTER, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "args", .fieldtype = "struct List *", .offset = offsetof(struct CaseExpr, args), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "defresult", .fieldtype = "struct Expr *", .offset = offsetof(struct CaseExpr, defresult), .size = sizeof(struct Expr *), .flags = TYPE_CAT_POINTER, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct CaseExpr, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "xpr", .fieldtype = "struct Expr", .offset = offsetof(struct CaseWhen, xpr), .size = sizeof(struct Expr), .flags = TYPE_CAT_SCALAR, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "expr", .fieldtype = "struct Expr *", .offset = offsetof(struct CaseWhen, expr), .size = sizeof(struct Expr *), .flags = TYPE_CAT_POINTER, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "result", .fieldtype = "struct Expr *", .offset = offsetof(struct CaseWhen, result), .size = sizeof(struct Expr *), .flags = TYPE_CAT_POINTER, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct CaseWhen, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "xpr", .fieldtype = "struct Expr", .offset = offsetof(struct CaseTestExpr, xpr), .size = sizeof(struct Expr), .flags = TYPE_CAT_SCALAR, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "typeId", .fieldtype = "unsigned int", .offset = offsetof(struct CaseTestExpr, typeId), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "typeMod", .fieldtype = "int", .offset = offsetof(struct CaseTestExpr, typeMod), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "collation", .fieldtype = "unsigned int", .offset = offsetof(struct CaseTestExpr, collation), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "xpr", .fieldtype = "struct Expr", .offset = offsetof(struct ArrayExpr, xpr), .size = sizeof(struct Expr), .flags = TYPE_CAT_SCALAR, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "array_typeid", .fieldtype = "unsigned int", .offset = offsetof(struct ArrayExpr, array_typeid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "array_collid", .fieldtype = "unsigned int", .offset = offsetof(struct ArrayExpr, array_collid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "element_typeid", .fieldtype = "unsigned int", .offset = offsetof(struct ArrayExpr, element_typeid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "elements", .fieldtype = "struct List *", .offset = offsetof(struct ArrayExpr, elements), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "multidims", .fieldtype = "_Bool", .offset = offsetof(struct ArrayExpr, multidims), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct ArrayExpr, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "xpr", .fieldtype = "struct Expr", .offset = offsetof(struct RowExpr, xpr), .size = sizeof(struct Expr), .flags = TYPE_CAT_SCALAR, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "args", .fieldtype = "struct List *", .offset = offsetof(struct RowExpr, args), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "row_typeid", .fieldtype = "unsigned int", .offset = offsetof(struct RowExpr, row_typeid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "row_format", .fieldtype = "enum CoercionForm", .offset = offsetof(struct RowExpr, row_format), .size = sizeof(enum CoercionForm), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "colnames", .fieldtype = "struct List *", .offset = offsetof(struct RowExpr, colnames), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct RowExpr, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "xpr", .fieldtype = "struct Expr", .offset = offsetof(struct RowCompareExpr, xpr), .size = sizeof(struct Expr), .flags = TYPE_CAT_SCALAR, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "rctype", .fieldtype = "enum RowCompareType", .offset = offsetof(struct RowCompareExpr, rctype), .size = sizeof(enum RowCompareType), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "opnos", .fieldtype = "struct List *", .offset = offsetof(struct RowCompareExpr, opnos), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "opfamilies", .fieldtype = "struct List *", .offset = offsetof(struct RowCompareExpr, opfamilies), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "inputcollids", .fieldtype = "struct List *", .offset = offsetof(struct RowCompareExpr, inputcollids), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "largs", .fieldtype = "struct List *", .offset = offsetof(struct RowCompareExpr, largs), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "rargs", .fieldtype = "struct List *", .offset = offsetof(struct RowCompareExpr, rargs), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "xpr", .fieldtype = "struct Expr", .offset = offsetof(struct CoalesceExpr, xpr), .size = sizeof(struct Expr), .flags = TYPE_CAT_SCALAR, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "coalescetype", .fieldtype = "unsigned int", .offset = offsetof(struct CoalesceExpr, coalescetype), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "coalescecollid", .fieldtype = "unsigned int", .offset = offsetof(struct CoalesceExpr, coalescecollid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "args", .fieldtype = "struct List *", .offset = offsetof(struct CoalesceExpr, args), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct CoalesceExpr, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "xpr", .fieldtype = "struct Expr", .offset = offsetof(struct MinMaxExpr, xpr), .size = sizeof(struct Expr), .flags = TYPE_CAT_SCALAR, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "minmaxtype", .fieldtype = "unsigned int", .offset = offsetof(struct MinMaxExpr, minmaxtype), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "minmaxcollid", .fieldtype = "unsigned int", .offset = offsetof(struct MinMaxExpr, minmaxcollid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "inputcollid", .fieldtype = "unsigned int", .offset = offsetof(struct MinMaxExpr, inputcollid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "op", .fieldtype = "enum MinMaxOp", .offset = offsetof(struct MinMaxExpr, op), .size = sizeof(enum MinMaxOp), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "args", .fieldtype = "struct List *", .offset = offsetof(struct MinMaxExpr, args), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct MinMaxExpr, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "xpr", .fieldtype = "struct Expr", .offset = offsetof(struct SQLValueFunction, xpr), .size = sizeof(struct Expr), .flags = TYPE_CAT_SCALAR, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "op", .fieldtype = "enum SQLValueFunctionOp", .offset = offsetof(struct SQLValueFunction, op), .size = sizeof(enum SQLValueFunctionOp), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "unsigned int", .offset = offsetof(struct SQLValueFunction, type), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "typmod", .fieldtype = "int", .offset = offsetof(struct SQLValueFunction, typmod), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct SQLValueFunction, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "xpr", .fieldtype = "struct Expr", .offset = offsetof(struct XmlExpr, xpr), .size = sizeof(struct Expr), .flags = TYPE_CAT_SCALAR, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "op", .fieldtype = "enum XmlExprOp", .offset = offsetof(struct XmlExpr, op), .size = sizeof(enum XmlExprOp), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "name", .fieldtype = "char *", .offset = offsetof(struct XmlExpr, name), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "named_args", .fieldtype = "struct List *", .offset = offsetof(struct XmlExpr, named_args), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "arg_names", .fieldtype = "struct List *", .offset = offsetof(struct XmlExpr, arg_names), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "args", .fieldtype = "struct List *", .offset = offsetof(struct XmlExpr, args), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "xmloption", .fieldtype = "XmlOptionType", .offset = offsetof(struct XmlExpr, xmloption), .size = sizeof(XmlOptionType), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "unsigned int", .offset = offsetof(struct XmlExpr, type), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "typmod", .fieldtype = "int", .offset = offsetof(struct XmlExpr, typmod), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct XmlExpr, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "xpr", .fieldtype = "struct Expr", .offset = offsetof(struct NullTest, xpr), .size = sizeof(struct Expr), .flags = TYPE_CAT_SCALAR, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "arg", .fieldtype = "struct Expr *", .offset = offsetof(struct NullTest, arg), .size = sizeof(struct Expr *), .flags = TYPE_CAT_POINTER, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "nulltesttype", .fieldtype = "enum NullTestType", .offset = offsetof(struct NullTest, nulltesttype), .size = sizeof(enum NullTestType), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "argisrow", .fieldtype = "_Bool", .offset = offsetof(struct NullTest, argisrow), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct NullTest, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "xpr", .fieldtype = "struct Expr", .offset = offsetof(struct BooleanTest, xpr), .size = sizeof(struct Expr), .flags = TYPE_CAT_SCALAR, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "arg", .fieldtype = "struct Expr *", .offset = offsetof(struct BooleanTest, arg), .size = sizeof(struct Expr *), .flags = TYPE_CAT_POINTER, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "booltesttype", .fieldtype = "enum BoolTestType", .offset = offsetof(struct BooleanTest, booltesttype), .size = sizeof(enum BoolTestType), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct BooleanTest, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "xpr", .fieldtype = "struct Expr", .offset = offsetof(struct CoerceToDomain, xpr), .size = sizeof(struct Expr), .flags = TYPE_CAT_SCALAR, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "arg", .fieldtype = "struct Expr *", .offset = offsetof(struct CoerceToDomain, arg), .size = sizeof(struct Expr *), .flags = TYPE_CAT_POINTER, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "resulttype", .fieldtype = "unsigned int", .offset = offsetof(struct CoerceToDomain, resulttype), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "resulttypmod", .fieldtype = "int", .offset = offsetof(struct CoerceToDomain, resulttypmod), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "resultcollid", .fieldtype = "unsigned int", .offset = offsetof(struct CoerceToDomain, resultcollid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "coercionformat", .fieldtype = "enum CoercionForm", .offset = offsetof(struct CoerceToDomain, coercionformat), .size = sizeof(enum CoercionForm), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct CoerceToDomain, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "xpr", .fieldtype = "struct Expr", .offset = offsetof(struct CoerceToDomainValue, xpr), .size = sizeof(struct Expr), .flags = TYPE_CAT_SCALAR, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "typeId", .fieldtype = "unsigned int", .offset = offsetof(struct CoerceToDomainValue, typeId), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "typeMod", .fieldtype = "int", .offset = offsetof(struct CoerceToDomainValue, typeMod), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "collation", .fieldtype = "unsigned int", .offset = offsetof(struct CoerceToDomainValue, collation), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct CoerceToDomainValue, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "xpr", .fieldtype = "struct Expr", .offset = offsetof(struct SetToDefault, xpr), .size = sizeof(struct Expr), .flags = TYPE_CAT_SCALAR, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "typeId", .fieldtype = "unsigned int", .offset = offsetof(struct SetToDefault, typeId), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "typeMod", .fieldtype = "int", .offset = offsetof(struct SetToDefault, typeMod), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "collation", .fieldtype = "unsigned int", .offset = offsetof(struct SetToDefault, collation), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct SetToDefault, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "xpr", .fieldtype = "struct Expr", .offset = offsetof(struct CurrentOfExpr, xpr), .size = sizeof(struct Expr), .flags = TYPE_CAT_SCALAR, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "cvarno", .fieldtype = "unsigned int", .offset = offsetof(struct CurrentOfExpr, cvarno), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "cursor_name", .fieldtype = "char *", .offset = offsetof(struct CurrentOfExpr, cursor_name), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "cursor_param", .fieldtype = "int", .offset = offsetof(struct CurrentOfExpr, cursor_param), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "xpr", .fieldtype = "struct Expr", .offset = offsetof(struct NextValueExpr, xpr), .size = sizeof(struct Expr), .flags = TYPE_CAT_SCALAR, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "seqid", .fieldtype = "unsigned int", .offset = offsetof(struct NextValueExpr, seqid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "typeId", .fieldtype = "unsigned int", .offset = offsetof(struct NextValueExpr, typeId), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "xpr", .fieldtype = "struct Expr", .offset = offsetof(struct InferenceElem, xpr), .size = sizeof(struct Expr), .flags = TYPE_CAT_SCALAR, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "expr", .fieldtype = "struct Node *", .offset = offsetof(struct InferenceElem, expr), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "infercollid", .fieldtype = "unsigned int", .offset = offsetof(struct InferenceElem, infercollid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "inferopclass", .fieldtype = "unsigned int", .offset = offsetof(struct InferenceElem, inferopclass), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "xpr", .fieldtype = "struct Expr", .offset = offsetof(struct TargetEntry, xpr), .size = sizeof(struct Expr), .flags = TYPE_CAT_SCALAR, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "expr", .fieldtype = "struct Expr *", .offset = offsetof(struct TargetEntry, expr), .size = sizeof(struct Expr *), .flags = TYPE_CAT_POINTER, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "resno", .fieldtype = "short", .offset = offsetof(struct TargetEntry, resno), .size = sizeof(short), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "resname", .fieldtype = "char *", .offset = offsetof(struct TargetEntry, resname), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "ressortgroupref", .fieldtype = "unsigned int", .offset = offsetof(struct TargetEntry, ressortgroupref), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "resorigtbl", .fieldtype = "unsigned int", .offset = offsetof(struct TargetEntry, resorigtbl), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "resorigcol", .fieldtype = "short", .offset = offsetof(struct TargetEntry, resorigcol), .size = sizeof(short), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "resjunk", .fieldtype = "_Bool", .offset = offsetof(struct TargetEntry, resjunk), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct RangeTblRef, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "rtindex", .fieldtype = "int", .offset = offsetof(struct RangeTblRef, rtindex), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct JoinExpr, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "jointype", .fieldtype = "enum JoinType", .offset = offsetof(struct JoinExpr, jointype), .size = sizeof(enum JoinType), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "isNatural", .fieldtype = "_Bool", .offset = offsetof(struct JoinExpr, isNatural), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "larg", .fieldtype = "struct Node *", .offset = offsetof(struct JoinExpr, larg), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "rarg", .fieldtype = "struct Node *", .offset = offsetof(struct JoinExpr, rarg), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "usingClause", .fieldtype = "struct List *", .offset = offsetof(struct JoinExpr, usingClause), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "quals", .fieldtype = "struct Node *", .offset = offsetof(struct JoinExpr, quals), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "alias", .fieldtype = "struct Alias *", .offset = offsetof(struct JoinExpr, alias), .size = sizeof(struct Alias *), .flags = TYPE_CAT_POINTER, .node_type_id = 100, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "rtindex", .fieldtype = "int", .offset = offsetof(struct JoinExpr, rtindex), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct FromExpr, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "fromlist", .fieldtype = "struct List *", .offset = offsetof(struct FromExpr, fromlist), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "quals", .fieldtype = "struct Node *", .offset = offsetof(struct FromExpr, quals), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct OnConflictExpr, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "action", .fieldtype = "enum OnConflictAction", .offset = offsetof(struct OnConflictExpr, action), .size = sizeof(enum OnConflictAction), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "arbiterElems", .fieldtype = "struct List *", .offset = offsetof(struct OnConflictExpr, arbiterElems), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "arbiterWhere", .fieldtype = "struct Node *", .offset = offsetof(struct OnConflictExpr, arbiterWhere), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "constraint", .fieldtype = "unsigned int", .offset = offsetof(struct OnConflictExpr, constraint), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "onConflictSet", .fieldtype = "struct List *", .offset = offsetof(struct OnConflictExpr, onConflictSet), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "onConflictWhere", .fieldtype = "struct Node *", .offset = offsetof(struct OnConflictExpr, onConflictWhere), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "exclRelIndex", .fieldtype = "int", .offset = offsetof(struct OnConflictExpr, exclRelIndex), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "exclRelTlist", .fieldtype = "struct List *", .offset = offsetof(struct OnConflictExpr, exclRelTlist), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct Value, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "val", .fieldtype = "union ValUnion", .offset = offsetof(struct Value, val), .size = sizeof(union ValUnion), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct Value, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "val", .fieldtype = "union ValUnion", .offset = offsetof(struct Value, val), .size = sizeof(union ValUnion), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct Value, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "val", .fieldtype = "union ValUnion", .offset = offsetof(struct Value, val), .size = sizeof(union ValUnion), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct Value, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "val", .fieldtype = "union ValUnion", .offset = offsetof(struct Value, val), .size = sizeof(union ValUnion), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct Value, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "val", .fieldtype = "union ValUnion", .offset = offsetof(struct Value, val), .size = sizeof(union ValUnion), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct Value, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "val", .fieldtype = "union ValUnion", .offset = offsetof(struct Value, val), .size = sizeof(union ValUnion), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct PartitionBoundSpec, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "strategy", .fieldtype = "char", .offset = offsetof(struct PartitionBoundSpec, strategy), .size = sizeof(char), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "is_default", .fieldtype = "_Bool", .offset = offsetof(struct PartitionBoundSpec, is_default), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "modulus", .fieldtype = "int", .offset = offsetof(struct PartitionBoundSpec, modulus), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "remainder", .fieldtype = "int", .offset = offsetof(struct PartitionBoundSpec, remainder), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "listdatums", .fieldtype = "struct List *", .offset = offsetof(struct PartitionBoundSpec, listdatums), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "lowerdatums", .fieldtype = "struct List *", .offset = offsetof(struct PartitionBoundSpec, lowerdatums), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "upperdatums", .fieldtype = "struct List *", .offset = offsetof(struct PartitionBoundSpec, upperdatums), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct PartitionBoundSpec, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct Query, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "commandType", .fieldtype = "enum CmdType", .offset = offsetof(struct Query, commandType), .size = sizeof(enum CmdType), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "querySource", .fieldtype = "enum QuerySource", .offset = offsetof(struct Query, querySource), .size = sizeof(enum QuerySource), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "queryId", .fieldtype = "unsigned long", .offset = offsetof(struct Query, queryId), .size = sizeof(unsigned long), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "canSetTag", .fieldtype = "_Bool", .offset = offsetof(struct Query, canSetTag), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "utilityStmt", .fieldtype = "struct Node *", .offset = offsetof(struct Query, utilityStmt), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "resultRelation", .fieldtype = "int", .offset = offsetof(struct Query, resultRelation), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "hasAggs", .fieldtype = "_Bool", .offset = offsetof(struct Query, hasAggs), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "hasWindowFuncs", .fieldtype = "_Bool", .offset = offsetof(struct Query, hasWindowFuncs), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "hasTargetSRFs", .fieldtype = "_Bool", .offset = offsetof(struct Query, hasTargetSRFs), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "hasSubLinks", .fieldtype = "_Bool", .offset = offsetof(struct Query, hasSubLinks), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "hasDistinctOn", .fieldtype = "_Bool", .offset = offsetof(struct Query, hasDistinctOn), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "hasRecursive", .fieldtype = "_Bool", .offset = offsetof(struct Query, hasRecursive), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "hasModifyingCTE", .fieldtype = "_Bool", .offset = offsetof(struct Query, hasModifyingCTE), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "hasForUpdate", .fieldtype = "_Bool", .offset = offsetof(struct Query, hasForUpdate), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "hasRowSecurity", .fieldtype = "_Bool", .offset = offsetof(struct Query, hasRowSecurity), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "cteList", .fieldtype = "struct List *", .offset = offsetof(struct Query, cteList), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "rtable", .fieldtype = "struct List *", .offset = offsetof(struct Query, rtable), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "jointree", .fieldtype = "struct FromExpr *", .offset = offsetof(struct Query, jointree), .size = sizeof(struct FromExpr *), .flags = TYPE_CAT_POINTER, .node_type_id = 149, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "targetList", .fieldtype = "struct List *", .offset = offsetof(struct Query, targetList), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "override", .fieldtype = "enum OverridingKind", .offset = offsetof(struct Query, override), .size = sizeof(enum OverridingKind), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "onConflict", .fieldtype = "struct OnConflictExpr *", .offset = offsetof(struct Query, onConflict), .size = sizeof(struct OnConflictExpr *), .flags = TYPE_CAT_POINTER, .node_type_id = 150, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "returningList", .fieldtype = "struct List *", .offset = offsetof(struct Query, returningList), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "groupClause", .fieldtype = "struct List *", .offset = offsetof(struct Query, groupClause), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "groupingSets", .fieldtype = "struct List *", .offset = offsetof(struct Query, groupingSets), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "havingQual", .fieldtype = "struct Node *", .offset = offsetof(struct Query, havingQual), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "windowClause", .fieldtype = "struct List *", .offset = offsetof(struct Query, windowClause), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "distinctClause", .fieldtype = "struct List *", .offset = offsetof(struct Query, distinctClause), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "sortClause", .fieldtype = "struct List *", .offset = offsetof(struct Query, sortClause), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "limitOffset", .fieldtype = "struct Node *", .offset = offsetof(struct Query, limitOffset), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "limitCount", .fieldtype = "struct Node *", .offset = offsetof(struct Query, limitCount), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "rowMarks", .fieldtype = "struct List *", .offset = offsetof(struct Query, rowMarks), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "setOperations", .fieldtype = "struct Node *", .offset = offsetof(struct Query, setOperations), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "constraintDeps", .fieldtype = "struct List *", .offset = offsetof(struct Query, constraintDeps), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "withCheckOptions", .fieldtype = "struct List *", .offset = offsetof(struct Query, withCheckOptions), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "stmt_location", .fieldtype = "int", .offset = offsetof(struct Query, stmt_location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "stmt_len", .fieldtype = "int", .offset = offsetof(struct Query, stmt_len), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct TypeName, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "names", .fieldtype = "struct List *", .offset = offsetof(struct TypeName, names), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "typeOid", .fieldtype = "unsigned int", .offset = offsetof(struct TypeName, typeOid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "setof", .fieldtype = "_Bool", .offset = offsetof(struct TypeName, setof), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "pct_type", .fieldtype = "_Bool", .offset = offsetof(struct TypeName, pct_type), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "typmods", .fieldtype = "struct List *", .offset = offsetof(struct TypeName, typmods), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "typemod", .fieldtype = "int", .offset = offsetof(struct TypeName, typemod), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "arrayBounds", .fieldtype = "struct List *", .offset = offsetof(struct TypeName, arrayBounds), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct TypeName, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct ColumnRef, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "fields", .fieldtype = "struct List *", .offset = offsetof(struct ColumnRef, fields), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct ColumnRef, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct ParamRef, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "number", .fieldtype = "int", .offset = offsetof(struct ParamRef, number), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct ParamRef, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct A_Expr, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "kind", .fieldtype = "enum A_Expr_Kind", .offset = offsetof(struct A_Expr, kind), .size = sizeof(enum A_Expr_Kind), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "name", .fieldtype = "struct List *", .offset = offsetof(struct A_Expr, name), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "lexpr", .fieldtype = "struct Node *", .offset = offsetof(struct A_Expr, lexpr), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "rexpr", .fieldtype = "struct Node *", .offset = offsetof(struct A_Expr, rexpr), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct A_Expr, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct A_Const, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "val", .fieldtype = "struct Value", .offset = offsetof(struct A_Const, val), .size = sizeof(struct Value), .flags = TYPE_CAT_SCALAR, .node_type_id = 217, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct A_Const, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct TypeCast, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "arg", .fieldtype = "struct Node *", .offset = offsetof(struct TypeCast, arg), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "typeName", .fieldtype = "struct TypeName *", .offset = offsetof(struct TypeCast, typeName), .size = sizeof(struct TypeName *), .flags = TYPE_CAT_POINTER, .node_type_id = 361, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct TypeCast, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct CollateClause, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "arg", .fieldtype = "struct Node *", .offset = offsetof(struct CollateClause, arg), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "collname", .fieldtype = "struct List *", .offset = offsetof(struct CollateClause, collname), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct CollateClause, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct RoleSpec, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "roletype", .fieldtype = "enum RoleSpecType", .offset = offsetof(struct RoleSpec, roletype), .size = sizeof(enum RoleSpecType), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "rolename", .fieldtype = "char *", .offset = offsetof(struct RoleSpec, rolename), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct RoleSpec, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct FuncCall, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "funcname", .fieldtype = "struct List *", .offset = offsetof(struct FuncCall, funcname), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "args", .fieldtype = "struct List *", .offset = offsetof(struct FuncCall, args), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "agg_order", .fieldtype = "struct List *", .offset = offsetof(struct FuncCall, agg_order), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "agg_filter", .fieldtype = "struct Node *", .offset = offsetof(struct FuncCall, agg_filter), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "agg_within_group", .fieldtype = "_Bool", .offset = offsetof(struct FuncCall, agg_within_group), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "agg_star", .fieldtype = "_Bool", .offset = offsetof(struct FuncCall, agg_star), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "agg_distinct", .fieldtype = "_Bool", .offset = offsetof(struct FuncCall, agg_distinct), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "func_variadic", .fieldtype = "_Bool", .offset = offsetof(struct FuncCall, func_variadic), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "over", .fieldtype = "struct WindowDef *", .offset = offsetof(struct FuncCall, over), .size = sizeof(struct WindowDef *), .flags = TYPE_CAT_POINTER, .node_type_id = 355, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct FuncCall, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct A_Star, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct A_Indices, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "is_slice", .fieldtype = "_Bool", .offset = offsetof(struct A_Indices, is_slice), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "lidx", .fieldtype = "struct Node *", .offset = offsetof(struct A_Indices, lidx), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "uidx", .fieldtype = "struct Node *", .offset = offsetof(struct A_Indices, uidx), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct A_Indirection, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "arg", .fieldtype = "struct Node *", .offset = offsetof(struct A_Indirection, arg), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "indirection", .fieldtype = "struct List *", .offset = offsetof(struct A_Indirection, indirection), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct A_ArrayExpr, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "elements", .fieldtype = "struct List *", .offset = offsetof(struct A_ArrayExpr, elements), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct A_ArrayExpr, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct ResTarget, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "name", .fieldtype = "char *", .offset = offsetof(struct ResTarget, name), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "indirection", .fieldtype = "struct List *", .offset = offsetof(struct ResTarget, indirection), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "val", .fieldtype = "struct Node *", .offset = offsetof(struct ResTarget, val), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct ResTarget, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct MultiAssignRef, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "source", .fieldtype = "struct Node *", .offset = offsetof(struct MultiAssignRef, source), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "colno", .fieldtype = "int", .offset = offsetof(struct MultiAssignRef, colno), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ncolumns", .fieldtype = "int", .offset = offsetof(struct MultiAssignRef, ncolumns), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct SortBy, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "node", .fieldtype = "struct Node *", .offset = offsetof(struct SortBy, node), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "sortby_dir", .fieldtype = "enum SortByDir", .offset = offsetof(struct SortBy, sortby_dir), .size = sizeof(enum SortByDir), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "sortby_nulls", .fieldtype = "enum SortByNulls", .offset = offsetof(struct SortBy, sortby_nulls), .size = sizeof(enum SortByNulls), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "useOp", .fieldtype = "struct List *", .offset = offsetof(struct SortBy, useOp), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct SortBy, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct WindowDef, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "name", .fieldtype = "char *", .offset = offsetof(struct WindowDef, name), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "refname", .fieldtype = "char *", .offset = offsetof(struct WindowDef, refname), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "partitionClause", .fieldtype = "struct List *", .offset = offsetof(struct WindowDef, partitionClause), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "orderClause", .fieldtype = "struct List *", .offset = offsetof(struct WindowDef, orderClause), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "frameOptions", .fieldtype = "int", .offset = offsetof(struct WindowDef, frameOptions), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "startOffset", .fieldtype = "struct Node *", .offset = offsetof(struct WindowDef, startOffset), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "endOffset", .fieldtype = "struct Node *", .offset = offsetof(struct WindowDef, endOffset), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct WindowDef, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct RangeSubselect, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "lateral", .fieldtype = "_Bool", .offset = offsetof(struct RangeSubselect, lateral), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "subquery", .fieldtype = "struct Node *", .offset = offsetof(struct RangeSubselect, subquery), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "alias", .fieldtype = "struct Alias *", .offset = offsetof(struct RangeSubselect, alias), .size = sizeof(struct Alias *), .flags = TYPE_CAT_POINTER, .node_type_id = 100, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct RangeFunction, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "lateral", .fieldtype = "_Bool", .offset = offsetof(struct RangeFunction, lateral), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ordinality", .fieldtype = "_Bool", .offset = offsetof(struct RangeFunction, ordinality), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "is_rowsfrom", .fieldtype = "_Bool", .offset = offsetof(struct RangeFunction, is_rowsfrom), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "functions", .fieldtype = "struct List *", .offset = offsetof(struct RangeFunction, functions), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "alias", .fieldtype = "struct Alias *", .offset = offsetof(struct RangeFunction, alias), .size = sizeof(struct Alias *), .flags = TYPE_CAT_POINTER, .node_type_id = 100, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "coldeflist", .fieldtype = "struct List *", .offset = offsetof(struct RangeFunction, coldeflist), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct RangeTableFunc, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "lateral", .fieldtype = "_Bool", .offset = offsetof(struct RangeTableFunc, lateral), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "docexpr", .fieldtype = "struct Node *", .offset = offsetof(struct RangeTableFunc, docexpr), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "rowexpr", .fieldtype = "struct Node *", .offset = offsetof(struct RangeTableFunc, rowexpr), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "namespaces", .fieldtype = "struct List *", .offset = offsetof(struct RangeTableFunc, namespaces), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "columns", .fieldtype = "struct List *", .offset = offsetof(struct RangeTableFunc, columns), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "alias", .fieldtype = "struct Alias *", .offset = offsetof(struct RangeTableFunc, alias), .size = sizeof(struct Alias *), .flags = TYPE_CAT_POINTER, .node_type_id = 100, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct RangeTableFunc, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct RangeTableFuncCol, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "colname", .fieldtype = "char *", .offset = offsetof(struct RangeTableFuncCol, colname), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "typeName", .fieldtype = "struct TypeName *", .offset = offsetof(struct RangeTableFuncCol, typeName), .size = sizeof(struct TypeName *), .flags = TYPE_CAT_POINTER, .node_type_id = 361, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "for_ordinality", .fieldtype = "_Bool", .offset = offsetof(struct RangeTableFuncCol, for_ordinality), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "is_not_null", .fieldtype = "_Bool", .offset = offsetof(struct RangeTableFuncCol, is_not_null), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "colexpr", .fieldtype = "struct Node *", .offset = offsetof(struct RangeTableFuncCol, colexpr), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "coldefexpr", .fieldtype = "struct Node *", .offset = offsetof(struct RangeTableFuncCol, coldefexpr), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct RangeTableFuncCol, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct RangeTableSample, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "relation", .fieldtype = "struct Node *", .offset = offsetof(struct RangeTableSample, relation), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "method", .fieldtype = "struct List *", .offset = offsetof(struct RangeTableSample, method), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "args", .fieldtype = "struct List *", .offset = offsetof(struct RangeTableSample, args), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "repeatable", .fieldtype = "struct Node *", .offset = offsetof(struct RangeTableSample, repeatable), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct RangeTableSample, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct ColumnDef, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "colname", .fieldtype = "char *", .offset = offsetof(struct ColumnDef, colname), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "typeName", .fieldtype = "struct TypeName *", .offset = offsetof(struct ColumnDef, typeName), .size = sizeof(struct TypeName *), .flags = TYPE_CAT_POINTER, .node_type_id = 361, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "inhcount", .fieldtype = "int", .offset = offsetof(struct ColumnDef, inhcount), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "is_local", .fieldtype = "_Bool", .offset = offsetof(struct ColumnDef, is_local), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "is_not_null", .fieldtype = "_Bool", .offset = offsetof(struct ColumnDef, is_not_null), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "is_from_type", .fieldtype = "_Bool", .offset = offsetof(struct ColumnDef, is_from_type), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "storage", .fieldtype = "char", .offset = offsetof(struct ColumnDef, storage), .size = sizeof(char), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "raw_default", .fieldtype = "struct Node *", .offset = offsetof(struct ColumnDef, raw_default), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "cooked_default", .fieldtype = "struct Node *", .offset = offsetof(struct ColumnDef, cooked_default), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "identity", .fieldtype = "char", .offset = offsetof(struct ColumnDef, identity), .size = sizeof(char), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "identitySequence", .fieldtype = "struct RangeVar *", .offset = offsetof(struct ColumnDef, identitySequence), .size = sizeof(struct RangeVar *), .flags = TYPE_CAT_POINTER, .node_type_id = 101, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "generated", .fieldtype = "char", .offset = offsetof(struct ColumnDef, generated), .size = sizeof(char), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "collClause", .fieldtype = "struct CollateClause *", .offset = offsetof(struct ColumnDef, collClause), .size = sizeof(struct CollateClause *), .flags = TYPE_CAT_POINTER, .node_type_id = 353, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "collOid", .fieldtype = "unsigned int", .offset = offsetof(struct ColumnDef, collOid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "constraints", .fieldtype = "struct List *", .offset = offsetof(struct ColumnDef, constraints), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "fdwoptions", .fieldtype = "struct List *", .offset = offsetof(struct ColumnDef, fdwoptions), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct ColumnDef, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct TableLikeClause, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "relation", .fieldtype = "struct RangeVar *", .offset = offsetof(struct TableLikeClause, relation), .size = sizeof(struct RangeVar *), .flags = TYPE_CAT_POINTER, .node_type_id = 101, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "options", .fieldtype = "unsigned int", .offset = offsetof(struct TableLikeClause, options), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct IndexElem, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "name", .fieldtype = "char *", .offset = offsetof(struct IndexElem, name), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "expr", .fieldtype = "struct Node *", .offset = offsetof(struct IndexElem, expr), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "indexcolname", .fieldtype = "char *", .offset = offsetof(struct IndexElem, indexcolname), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "collation", .fieldtype = "struct List *", .offset = offsetof(struct IndexElem, collation), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "opclass", .fieldtype = "struct List *", .offset = offsetof(struct IndexElem, opclass), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ordering", .fieldtype = "enum SortByDir", .offset = offsetof(struct IndexElem, ordering), .size = sizeof(enum SortByDir), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "nulls_ordering", .fieldtype = "enum SortByNulls", .offset = offsetof(struct IndexElem, nulls_ordering), .size = sizeof(enum SortByNulls), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct DefElem, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "defnamespace", .fieldtype = "char *", .offset = offsetof(struct DefElem, defnamespace), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "defname", .fieldtype = "char *", .offset = offsetof(struct DefElem, defname), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "arg", .fieldtype = "struct Node *", .offset = offsetof(struct DefElem, arg), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "defaction", .fieldtype = "enum DefElemAction", .offset = offsetof(struct DefElem, defaction), .size = sizeof(enum DefElemAction), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct DefElem, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct LockingClause, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "lockedRels", .fieldtype = "struct List *", .offset = offsetof(struct LockingClause, lockedRels), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "strength", .fieldtype = "enum LockClauseStrength", .offset = offsetof(struct LockingClause, strength), .size = sizeof(enum LockClauseStrength), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "waitPolicy", .fieldtype = "enum LockWaitPolicy", .offset = offsetof(struct LockingClause, waitPolicy), .size = sizeof(enum LockWaitPolicy), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct XmlSerialize, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "xmloption", .fieldtype = "XmlOptionType", .offset = offsetof(struct XmlSerialize, xmloption), .size = sizeof(XmlOptionType), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "expr", .fieldtype = "struct Node *", .offset = offsetof(struct XmlSerialize, expr), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "typeName", .fieldtype = "struct TypeName *", .offset = offsetof(struct XmlSerialize, typeName), .size = sizeof(struct TypeName *), .flags = TYPE_CAT_POINTER, .node_type_id = 361, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct XmlSerialize, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct PartitionElem, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "name", .fieldtype = "char *", .offset = offsetof(struct PartitionElem, name), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "expr", .fieldtype = "struct Node *", .offset = offsetof(struct PartitionElem, expr), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "collation", .fieldtype = "struct List *", .offset = offsetof(struct PartitionElem, collation), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "opclass", .fieldtype = "struct List *", .offset = offsetof(struct PartitionElem, opclass), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct PartitionElem, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct PartitionSpec, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "strategy", .fieldtype = "char *", .offset = offsetof(struct PartitionSpec, strategy), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "partParams", .fieldtype = "struct List *", .offset = offsetof(struct PartitionSpec, partParams), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct PartitionSpec, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct PartitionRangeDatum, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "kind", .fieldtype = "enum PartitionRangeDatumKind", .offset = offsetof(struct PartitionRangeDatum, kind), .size = sizeof(enum PartitionRangeDatumKind), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "value", .fieldtype = "struct Node *", .offset = offsetof(struct PartitionRangeDatum, value), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct PartitionRangeDatum, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct PartitionCmd, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "name", .fieldtype = "struct RangeVar *", .offset = offsetof(struct PartitionCmd, name), .size = sizeof(struct RangeVar *), .flags = TYPE_CAT_POINTER, .node_type_id = 101, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "bound", .fieldtype = "struct PartitionBoundSpec *", .offset = offsetof(struct PartitionCmd, bound), .size = sizeof(struct PartitionBoundSpec *), .flags = TYPE_CAT_POINTER, .node_type_id = 389, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct RangeTblEntry, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "rtekind", .fieldtype = "enum RTEKind", .offset = offsetof(struct RangeTblEntry, rtekind), .size = sizeof(enum RTEKind), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "relid", .fieldtype = "unsigned int", .offset = offsetof(struct RangeTblEntry, relid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "relkind", .fieldtype = "char", .offset = offsetof(struct RangeTblEntry, relkind), .size = sizeof(char), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "rellockmode", .fieldtype = "int", .offset = offsetof(struct RangeTblEntry, rellockmode), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "tablesample", .fieldtype = "struct TableSampleClause *", .offset = offsetof(struct RangeTblEntry, tablesample), .size = sizeof(struct TableSampleClause *), .flags = TYPE_CAT_POINTER, .node_type_id = 368, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "subquery", .fieldtype = "struct Query *", .offset = offsetof(struct RangeTblEntry, subquery), .size = sizeof(struct Query *), .flags = TYPE_CAT_POINTER, .node_type_id = 228, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "security_barrier", .fieldtype = "_Bool", .offset = offsetof(struct RangeTblEntry, security_barrier), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "jointype", .fieldtype = "enum JoinType", .offset = offsetof(struct RangeTblEntry, jointype), .size = sizeof(enum JoinType), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "joinaliasvars", .fieldtype = "struct List *", .offset = offsetof(struct RangeTblEntry, joinaliasvars), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "functions", .fieldtype = "struct List *", .offset = offsetof(struct RangeTblEntry, functions), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "funcordinality", .fieldtype = "_Bool", .offset = offsetof(struct RangeTblEntry, funcordinality), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "tablefunc", .fieldtype = "struct TableFunc *", .offset = offsetof(struct RangeTblEntry, tablefunc), .size = sizeof(struct TableFunc *), .flags = TYPE_CAT_POINTER, .node_type_id = 102, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "values_lists", .fieldtype = "struct List *", .offset = offsetof(struct RangeTblEntry, values_lists), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ctename", .fieldtype = "char *", .offset = offsetof(struct RangeTblEntry, ctename), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "ctelevelsup", .fieldtype = "unsigned int", .offset = offsetof(struct RangeTblEntry, ctelevelsup), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "self_reference", .fieldtype = "_Bool", .offset = offsetof(struct RangeTblEntry, self_reference), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "coltypes", .fieldtype = "struct List *", .offset = offsetof(struct RangeTblEntry, coltypes), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "coltypmods", .fieldtype = "struct List *", .offset = offsetof(struct RangeTblEntry, coltypmods), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "colcollations", .fieldtype = "struct List *", .offset = offsetof(struct RangeTblEntry, colcollations), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "enrname", .fieldtype = "char *", .offset = offsetof(struct RangeTblEntry, enrname), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "enrtuples", .fieldtype = "double", .offset = offsetof(struct RangeTblEntry, enrtuples), .size = sizeof(double), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "alias", .fieldtype = "struct Alias *", .offset = offsetof(struct RangeTblEntry, alias), .size = sizeof(struct Alias *), .flags = TYPE_CAT_POINTER, .node_type_id = 100, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "eref", .fieldtype = "struct Alias *", .offset = offsetof(struct RangeTblEntry, eref), .size = sizeof(struct Alias *), .flags = TYPE_CAT_POINTER, .node_type_id = 100, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "lateral", .fieldtype = "_Bool", .offset = offsetof(struct RangeTblEntry, lateral), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "inh", .fieldtype = "_Bool", .offset = offsetof(struct RangeTblEntry, inh), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "inFromCl", .fieldtype = "_Bool", .offset = offsetof(struct RangeTblEntry, inFromCl), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "requiredPerms", .fieldtype = "unsigned int", .offset = offsetof(struct RangeTblEntry, requiredPerms), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "checkAsUser", .fieldtype = "unsigned int", .offset = offsetof(struct RangeTblEntry, checkAsUser), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "selectedCols", .fieldtype = "struct Bitmapset *", .offset = offsetof(struct RangeTblEntry, selectedCols), .size = sizeof(struct Bitmapset *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_BITMAPSET},
+	{.fieldname = "insertedCols", .fieldtype = "struct Bitmapset *", .offset = offsetof(struct RangeTblEntry, insertedCols), .size = sizeof(struct Bitmapset *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_BITMAPSET},
+	{.fieldname = "updatedCols", .fieldtype = "struct Bitmapset *", .offset = offsetof(struct RangeTblEntry, updatedCols), .size = sizeof(struct Bitmapset *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_BITMAPSET},
+	{.fieldname = "extraUpdatedCols", .fieldtype = "struct Bitmapset *", .offset = offsetof(struct RangeTblEntry, extraUpdatedCols), .size = sizeof(struct Bitmapset *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_BITMAPSET},
+	{.fieldname = "securityQuals", .fieldtype = "struct List *", .offset = offsetof(struct RangeTblEntry, securityQuals), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct RangeTblFunction, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "funcexpr", .fieldtype = "struct Node *", .offset = offsetof(struct RangeTblFunction, funcexpr), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "funccolcount", .fieldtype = "int", .offset = offsetof(struct RangeTblFunction, funccolcount), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "funccolnames", .fieldtype = "struct List *", .offset = offsetof(struct RangeTblFunction, funccolnames), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "funccoltypes", .fieldtype = "struct List *", .offset = offsetof(struct RangeTblFunction, funccoltypes), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "funccoltypmods", .fieldtype = "struct List *", .offset = offsetof(struct RangeTblFunction, funccoltypmods), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "funccolcollations", .fieldtype = "struct List *", .offset = offsetof(struct RangeTblFunction, funccolcollations), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "funcparams", .fieldtype = "struct Bitmapset *", .offset = offsetof(struct RangeTblFunction, funcparams), .size = sizeof(struct Bitmapset *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_BITMAPSET},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct TableSampleClause, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "tsmhandler", .fieldtype = "unsigned int", .offset = offsetof(struct TableSampleClause, tsmhandler), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "args", .fieldtype = "struct List *", .offset = offsetof(struct TableSampleClause, args), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "repeatable", .fieldtype = "struct Expr *", .offset = offsetof(struct TableSampleClause, repeatable), .size = sizeof(struct Expr *), .flags = TYPE_CAT_POINTER, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct WithCheckOption, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "kind", .fieldtype = "enum WCOKind", .offset = offsetof(struct WithCheckOption, kind), .size = sizeof(enum WCOKind), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "relname", .fieldtype = "char *", .offset = offsetof(struct WithCheckOption, relname), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "polname", .fieldtype = "char *", .offset = offsetof(struct WithCheckOption, polname), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "qual", .fieldtype = "struct Node *", .offset = offsetof(struct WithCheckOption, qual), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "cascaded", .fieldtype = "_Bool", .offset = offsetof(struct WithCheckOption, cascaded), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct SortGroupClause, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "tleSortGroupRef", .fieldtype = "unsigned int", .offset = offsetof(struct SortGroupClause, tleSortGroupRef), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "eqop", .fieldtype = "unsigned int", .offset = offsetof(struct SortGroupClause, eqop), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "sortop", .fieldtype = "unsigned int", .offset = offsetof(struct SortGroupClause, sortop), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "nulls_first", .fieldtype = "_Bool", .offset = offsetof(struct SortGroupClause, nulls_first), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "hashable", .fieldtype = "_Bool", .offset = offsetof(struct SortGroupClause, hashable), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct GroupingSet, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "kind", .fieldtype = "GroupingSetKind", .offset = offsetof(struct GroupingSet, kind), .size = sizeof(GroupingSetKind), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "content", .fieldtype = "struct List *", .offset = offsetof(struct GroupingSet, content), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct GroupingSet, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct WindowClause, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "name", .fieldtype = "char *", .offset = offsetof(struct WindowClause, name), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "refname", .fieldtype = "char *", .offset = offsetof(struct WindowClause, refname), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "partitionClause", .fieldtype = "struct List *", .offset = offsetof(struct WindowClause, partitionClause), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "orderClause", .fieldtype = "struct List *", .offset = offsetof(struct WindowClause, orderClause), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "frameOptions", .fieldtype = "int", .offset = offsetof(struct WindowClause, frameOptions), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "startOffset", .fieldtype = "struct Node *", .offset = offsetof(struct WindowClause, startOffset), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "endOffset", .fieldtype = "struct Node *", .offset = offsetof(struct WindowClause, endOffset), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "startInRangeFunc", .fieldtype = "unsigned int", .offset = offsetof(struct WindowClause, startInRangeFunc), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "endInRangeFunc", .fieldtype = "unsigned int", .offset = offsetof(struct WindowClause, endInRangeFunc), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "inRangeColl", .fieldtype = "unsigned int", .offset = offsetof(struct WindowClause, inRangeColl), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "inRangeAsc", .fieldtype = "_Bool", .offset = offsetof(struct WindowClause, inRangeAsc), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "inRangeNullsFirst", .fieldtype = "_Bool", .offset = offsetof(struct WindowClause, inRangeNullsFirst), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "winref", .fieldtype = "unsigned int", .offset = offsetof(struct WindowClause, winref), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "copiedOrder", .fieldtype = "_Bool", .offset = offsetof(struct WindowClause, copiedOrder), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct RowMarkClause, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "rti", .fieldtype = "unsigned int", .offset = offsetof(struct RowMarkClause, rti), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "strength", .fieldtype = "enum LockClauseStrength", .offset = offsetof(struct RowMarkClause, strength), .size = sizeof(enum LockClauseStrength), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "waitPolicy", .fieldtype = "enum LockWaitPolicy", .offset = offsetof(struct RowMarkClause, waitPolicy), .size = sizeof(enum LockWaitPolicy), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "pushedDown", .fieldtype = "_Bool", .offset = offsetof(struct RowMarkClause, pushedDown), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct WithClause, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ctes", .fieldtype = "struct List *", .offset = offsetof(struct WithClause, ctes), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "recursive", .fieldtype = "_Bool", .offset = offsetof(struct WithClause, recursive), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct WithClause, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct InferClause, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "indexElems", .fieldtype = "struct List *", .offset = offsetof(struct InferClause, indexElems), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "whereClause", .fieldtype = "struct Node *", .offset = offsetof(struct InferClause, whereClause), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "conname", .fieldtype = "char *", .offset = offsetof(struct InferClause, conname), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct InferClause, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct OnConflictClause, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "action", .fieldtype = "enum OnConflictAction", .offset = offsetof(struct OnConflictClause, action), .size = sizeof(enum OnConflictAction), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "infer", .fieldtype = "struct InferClause *", .offset = offsetof(struct OnConflictClause, infer), .size = sizeof(struct InferClause *), .flags = TYPE_CAT_POINTER, .node_type_id = 382, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "targetList", .fieldtype = "struct List *", .offset = offsetof(struct OnConflictClause, targetList), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "whereClause", .fieldtype = "struct Node *", .offset = offsetof(struct OnConflictClause, whereClause), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct OnConflictClause, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct CommonTableExpr, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ctename", .fieldtype = "char *", .offset = offsetof(struct CommonTableExpr, ctename), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "aliascolnames", .fieldtype = "struct List *", .offset = offsetof(struct CommonTableExpr, aliascolnames), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ctematerialized", .fieldtype = "enum CTEMaterialize", .offset = offsetof(struct CommonTableExpr, ctematerialized), .size = sizeof(enum CTEMaterialize), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ctequery", .fieldtype = "struct Node *", .offset = offsetof(struct CommonTableExpr, ctequery), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct CommonTableExpr, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "cterecursive", .fieldtype = "_Bool", .offset = offsetof(struct CommonTableExpr, cterecursive), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "cterefcount", .fieldtype = "int", .offset = offsetof(struct CommonTableExpr, cterefcount), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ctecolnames", .fieldtype = "struct List *", .offset = offsetof(struct CommonTableExpr, ctecolnames), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ctecoltypes", .fieldtype = "struct List *", .offset = offsetof(struct CommonTableExpr, ctecoltypes), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ctecoltypmods", .fieldtype = "struct List *", .offset = offsetof(struct CommonTableExpr, ctecoltypmods), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ctecolcollations", .fieldtype = "struct List *", .offset = offsetof(struct CommonTableExpr, ctecolcollations), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct TriggerTransition, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "name", .fieldtype = "char *", .offset = offsetof(struct TriggerTransition, name), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "isNew", .fieldtype = "_Bool", .offset = offsetof(struct TriggerTransition, isNew), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "isTable", .fieldtype = "_Bool", .offset = offsetof(struct TriggerTransition, isTable), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct RawStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "stmt", .fieldtype = "struct Node *", .offset = offsetof(struct RawStmt, stmt), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "stmt_location", .fieldtype = "int", .offset = offsetof(struct RawStmt, stmt_location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "stmt_len", .fieldtype = "int", .offset = offsetof(struct RawStmt, stmt_len), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct InsertStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "relation", .fieldtype = "struct RangeVar *", .offset = offsetof(struct InsertStmt, relation), .size = sizeof(struct RangeVar *), .flags = TYPE_CAT_POINTER, .node_type_id = 101, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "cols", .fieldtype = "struct List *", .offset = offsetof(struct InsertStmt, cols), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "selectStmt", .fieldtype = "struct Node *", .offset = offsetof(struct InsertStmt, selectStmt), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "onConflictClause", .fieldtype = "struct OnConflictClause *", .offset = offsetof(struct InsertStmt, onConflictClause), .size = sizeof(struct OnConflictClause *), .flags = TYPE_CAT_POINTER, .node_type_id = 383, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "returningList", .fieldtype = "struct List *", .offset = offsetof(struct InsertStmt, returningList), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "withClause", .fieldtype = "struct WithClause *", .offset = offsetof(struct InsertStmt, withClause), .size = sizeof(struct WithClause *), .flags = TYPE_CAT_POINTER, .node_type_id = 381, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "override", .fieldtype = "enum OverridingKind", .offset = offsetof(struct InsertStmt, override), .size = sizeof(enum OverridingKind), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct DeleteStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "relation", .fieldtype = "struct RangeVar *", .offset = offsetof(struct DeleteStmt, relation), .size = sizeof(struct RangeVar *), .flags = TYPE_CAT_POINTER, .node_type_id = 101, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "usingClause", .fieldtype = "struct List *", .offset = offsetof(struct DeleteStmt, usingClause), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "whereClause", .fieldtype = "struct Node *", .offset = offsetof(struct DeleteStmt, whereClause), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "returningList", .fieldtype = "struct List *", .offset = offsetof(struct DeleteStmt, returningList), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "withClause", .fieldtype = "struct WithClause *", .offset = offsetof(struct DeleteStmt, withClause), .size = sizeof(struct WithClause *), .flags = TYPE_CAT_POINTER, .node_type_id = 381, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct UpdateStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "relation", .fieldtype = "struct RangeVar *", .offset = offsetof(struct UpdateStmt, relation), .size = sizeof(struct RangeVar *), .flags = TYPE_CAT_POINTER, .node_type_id = 101, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "targetList", .fieldtype = "struct List *", .offset = offsetof(struct UpdateStmt, targetList), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "whereClause", .fieldtype = "struct Node *", .offset = offsetof(struct UpdateStmt, whereClause), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "fromClause", .fieldtype = "struct List *", .offset = offsetof(struct UpdateStmt, fromClause), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "returningList", .fieldtype = "struct List *", .offset = offsetof(struct UpdateStmt, returningList), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "withClause", .fieldtype = "struct WithClause *", .offset = offsetof(struct UpdateStmt, withClause), .size = sizeof(struct WithClause *), .flags = TYPE_CAT_POINTER, .node_type_id = 381, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct SelectStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "distinctClause", .fieldtype = "struct List *", .offset = offsetof(struct SelectStmt, distinctClause), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "intoClause", .fieldtype = "struct IntoClause *", .offset = offsetof(struct SelectStmt, intoClause), .size = sizeof(struct IntoClause *), .flags = TYPE_CAT_POINTER, .node_type_id = 151, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "targetList", .fieldtype = "struct List *", .offset = offsetof(struct SelectStmt, targetList), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "fromClause", .fieldtype = "struct List *", .offset = offsetof(struct SelectStmt, fromClause), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "whereClause", .fieldtype = "struct Node *", .offset = offsetof(struct SelectStmt, whereClause), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "groupClause", .fieldtype = "struct List *", .offset = offsetof(struct SelectStmt, groupClause), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "havingClause", .fieldtype = "struct Node *", .offset = offsetof(struct SelectStmt, havingClause), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "windowClause", .fieldtype = "struct List *", .offset = offsetof(struct SelectStmt, windowClause), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "valuesLists", .fieldtype = "struct List *", .offset = offsetof(struct SelectStmt, valuesLists), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "sortClause", .fieldtype = "struct List *", .offset = offsetof(struct SelectStmt, sortClause), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "limitOffset", .fieldtype = "struct Node *", .offset = offsetof(struct SelectStmt, limitOffset), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "limitCount", .fieldtype = "struct Node *", .offset = offsetof(struct SelectStmt, limitCount), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "lockingClause", .fieldtype = "struct List *", .offset = offsetof(struct SelectStmt, lockingClause), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "withClause", .fieldtype = "struct WithClause *", .offset = offsetof(struct SelectStmt, withClause), .size = sizeof(struct WithClause *), .flags = TYPE_CAT_POINTER, .node_type_id = 381, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "op", .fieldtype = "enum SetOperation", .offset = offsetof(struct SelectStmt, op), .size = sizeof(enum SetOperation), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "all", .fieldtype = "_Bool", .offset = offsetof(struct SelectStmt, all), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "larg", .fieldtype = "struct SelectStmt *", .offset = offsetof(struct SelectStmt, larg), .size = sizeof(struct SelectStmt *), .flags = TYPE_CAT_POINTER, .node_type_id = 233, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "rarg", .fieldtype = "struct SelectStmt *", .offset = offsetof(struct SelectStmt, rarg), .size = sizeof(struct SelectStmt *), .flags = TYPE_CAT_POINTER, .node_type_id = 233, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct SetOperationStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "op", .fieldtype = "enum SetOperation", .offset = offsetof(struct SetOperationStmt, op), .size = sizeof(enum SetOperation), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "all", .fieldtype = "_Bool", .offset = offsetof(struct SetOperationStmt, all), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "larg", .fieldtype = "struct Node *", .offset = offsetof(struct SetOperationStmt, larg), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "rarg", .fieldtype = "struct Node *", .offset = offsetof(struct SetOperationStmt, rarg), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "colTypes", .fieldtype = "struct List *", .offset = offsetof(struct SetOperationStmt, colTypes), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "colTypmods", .fieldtype = "struct List *", .offset = offsetof(struct SetOperationStmt, colTypmods), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "colCollations", .fieldtype = "struct List *", .offset = offsetof(struct SetOperationStmt, colCollations), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "groupClauses", .fieldtype = "struct List *", .offset = offsetof(struct SetOperationStmt, groupClauses), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct CreateSchemaStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "schemaname", .fieldtype = "char *", .offset = offsetof(struct CreateSchemaStmt, schemaname), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "authrole", .fieldtype = "struct RoleSpec *", .offset = offsetof(struct CreateSchemaStmt, authrole), .size = sizeof(struct RoleSpec *), .flags = TYPE_CAT_POINTER, .node_type_id = 385, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "schemaElts", .fieldtype = "struct List *", .offset = offsetof(struct CreateSchemaStmt, schemaElts), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "if_not_exists", .fieldtype = "_Bool", .offset = offsetof(struct CreateSchemaStmt, if_not_exists), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct AlterTableStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "relation", .fieldtype = "struct RangeVar *", .offset = offsetof(struct AlterTableStmt, relation), .size = sizeof(struct RangeVar *), .flags = TYPE_CAT_POINTER, .node_type_id = 101, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "cmds", .fieldtype = "struct List *", .offset = offsetof(struct AlterTableStmt, cmds), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "relkind", .fieldtype = "enum ObjectType", .offset = offsetof(struct AlterTableStmt, relkind), .size = sizeof(enum ObjectType), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "missing_ok", .fieldtype = "_Bool", .offset = offsetof(struct AlterTableStmt, missing_ok), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct ReplicaIdentityStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "identity_type", .fieldtype = "char", .offset = offsetof(struct ReplicaIdentityStmt, identity_type), .size = sizeof(char), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "name", .fieldtype = "char *", .offset = offsetof(struct ReplicaIdentityStmt, name), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct AlterTableCmd, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "subtype", .fieldtype = "enum AlterTableType", .offset = offsetof(struct AlterTableCmd, subtype), .size = sizeof(enum AlterTableType), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "name", .fieldtype = "char *", .offset = offsetof(struct AlterTableCmd, name), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "num", .fieldtype = "short", .offset = offsetof(struct AlterTableCmd, num), .size = sizeof(short), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "newowner", .fieldtype = "struct RoleSpec *", .offset = offsetof(struct AlterTableCmd, newowner), .size = sizeof(struct RoleSpec *), .flags = TYPE_CAT_POINTER, .node_type_id = 385, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "def", .fieldtype = "struct Node *", .offset = offsetof(struct AlterTableCmd, def), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "behavior", .fieldtype = "enum DropBehavior", .offset = offsetof(struct AlterTableCmd, behavior), .size = sizeof(enum DropBehavior), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "missing_ok", .fieldtype = "_Bool", .offset = offsetof(struct AlterTableCmd, missing_ok), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct AlterCollationStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "collname", .fieldtype = "struct List *", .offset = offsetof(struct AlterCollationStmt, collname), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct AlterDomainStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "subtype", .fieldtype = "char", .offset = offsetof(struct AlterDomainStmt, subtype), .size = sizeof(char), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "typeName", .fieldtype = "struct List *", .offset = offsetof(struct AlterDomainStmt, typeName), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "name", .fieldtype = "char *", .offset = offsetof(struct AlterDomainStmt, name), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "def", .fieldtype = "struct Node *", .offset = offsetof(struct AlterDomainStmt, def), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "behavior", .fieldtype = "enum DropBehavior", .offset = offsetof(struct AlterDomainStmt, behavior), .size = sizeof(enum DropBehavior), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "missing_ok", .fieldtype = "_Bool", .offset = offsetof(struct AlterDomainStmt, missing_ok), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct GrantStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "is_grant", .fieldtype = "_Bool", .offset = offsetof(struct GrantStmt, is_grant), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "targtype", .fieldtype = "enum GrantTargetType", .offset = offsetof(struct GrantStmt, targtype), .size = sizeof(enum GrantTargetType), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "objtype", .fieldtype = "enum ObjectType", .offset = offsetof(struct GrantStmt, objtype), .size = sizeof(enum ObjectType), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "objects", .fieldtype = "struct List *", .offset = offsetof(struct GrantStmt, objects), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "privileges", .fieldtype = "struct List *", .offset = offsetof(struct GrantStmt, privileges), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "grantees", .fieldtype = "struct List *", .offset = offsetof(struct GrantStmt, grantees), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "grant_option", .fieldtype = "_Bool", .offset = offsetof(struct GrantStmt, grant_option), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "behavior", .fieldtype = "enum DropBehavior", .offset = offsetof(struct GrantStmt, behavior), .size = sizeof(enum DropBehavior), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct ObjectWithArgs, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "objname", .fieldtype = "struct List *", .offset = offsetof(struct ObjectWithArgs, objname), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "objargs", .fieldtype = "struct List *", .offset = offsetof(struct ObjectWithArgs, objargs), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "args_unspecified", .fieldtype = "_Bool", .offset = offsetof(struct ObjectWithArgs, args_unspecified), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct AccessPriv, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "priv_name", .fieldtype = "char *", .offset = offsetof(struct AccessPriv, priv_name), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "cols", .fieldtype = "struct List *", .offset = offsetof(struct AccessPriv, cols), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct GrantRoleStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "granted_roles", .fieldtype = "struct List *", .offset = offsetof(struct GrantRoleStmt, granted_roles), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "grantee_roles", .fieldtype = "struct List *", .offset = offsetof(struct GrantRoleStmt, grantee_roles), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "is_grant", .fieldtype = "_Bool", .offset = offsetof(struct GrantRoleStmt, is_grant), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "admin_opt", .fieldtype = "_Bool", .offset = offsetof(struct GrantRoleStmt, admin_opt), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "grantor", .fieldtype = "struct RoleSpec *", .offset = offsetof(struct GrantRoleStmt, grantor), .size = sizeof(struct RoleSpec *), .flags = TYPE_CAT_POINTER, .node_type_id = 385, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "behavior", .fieldtype = "enum DropBehavior", .offset = offsetof(struct GrantRoleStmt, behavior), .size = sizeof(enum DropBehavior), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct AlterDefaultPrivilegesStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "options", .fieldtype = "struct List *", .offset = offsetof(struct AlterDefaultPrivilegesStmt, options), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "action", .fieldtype = "struct GrantStmt *", .offset = offsetof(struct AlterDefaultPrivilegesStmt, action), .size = sizeof(struct GrantStmt *), .flags = TYPE_CAT_POINTER, .node_type_id = 238, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct CopyStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "relation", .fieldtype = "struct RangeVar *", .offset = offsetof(struct CopyStmt, relation), .size = sizeof(struct RangeVar *), .flags = TYPE_CAT_POINTER, .node_type_id = 101, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "query", .fieldtype = "struct Node *", .offset = offsetof(struct CopyStmt, query), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "attlist", .fieldtype = "struct List *", .offset = offsetof(struct CopyStmt, attlist), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "is_from", .fieldtype = "_Bool", .offset = offsetof(struct CopyStmt, is_from), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "is_program", .fieldtype = "_Bool", .offset = offsetof(struct CopyStmt, is_program), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "filename", .fieldtype = "char *", .offset = offsetof(struct CopyStmt, filename), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "options", .fieldtype = "struct List *", .offset = offsetof(struct CopyStmt, options), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "whereClause", .fieldtype = "struct Node *", .offset = offsetof(struct CopyStmt, whereClause), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct VariableSetStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "kind", .fieldtype = "VariableSetKind", .offset = offsetof(struct VariableSetStmt, kind), .size = sizeof(VariableSetKind), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "name", .fieldtype = "char *", .offset = offsetof(struct VariableSetStmt, name), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "args", .fieldtype = "struct List *", .offset = offsetof(struct VariableSetStmt, args), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "is_local", .fieldtype = "_Bool", .offset = offsetof(struct VariableSetStmt, is_local), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct VariableShowStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "name", .fieldtype = "char *", .offset = offsetof(struct VariableShowStmt, name), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct CreateStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "relation", .fieldtype = "struct RangeVar *", .offset = offsetof(struct CreateStmt, relation), .size = sizeof(struct RangeVar *), .flags = TYPE_CAT_POINTER, .node_type_id = 101, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "tableElts", .fieldtype = "struct List *", .offset = offsetof(struct CreateStmt, tableElts), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "inhRelations", .fieldtype = "struct List *", .offset = offsetof(struct CreateStmt, inhRelations), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "partbound", .fieldtype = "struct PartitionBoundSpec *", .offset = offsetof(struct CreateStmt, partbound), .size = sizeof(struct PartitionBoundSpec *), .flags = TYPE_CAT_POINTER, .node_type_id = 389, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "partspec", .fieldtype = "struct PartitionSpec *", .offset = offsetof(struct CreateStmt, partspec), .size = sizeof(struct PartitionSpec *), .flags = TYPE_CAT_POINTER, .node_type_id = 388, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ofTypename", .fieldtype = "struct TypeName *", .offset = offsetof(struct CreateStmt, ofTypename), .size = sizeof(struct TypeName *), .flags = TYPE_CAT_POINTER, .node_type_id = 361, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "constraints", .fieldtype = "struct List *", .offset = offsetof(struct CreateStmt, constraints), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "options", .fieldtype = "struct List *", .offset = offsetof(struct CreateStmt, options), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "oncommit", .fieldtype = "enum OnCommitAction", .offset = offsetof(struct CreateStmt, oncommit), .size = sizeof(enum OnCommitAction), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "tablespacename", .fieldtype = "char *", .offset = offsetof(struct CreateStmt, tablespacename), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "accessMethod", .fieldtype = "char *", .offset = offsetof(struct CreateStmt, accessMethod), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "if_not_exists", .fieldtype = "_Bool", .offset = offsetof(struct CreateStmt, if_not_exists), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct Constraint, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "contype", .fieldtype = "enum ConstrType", .offset = offsetof(struct Constraint, contype), .size = sizeof(enum ConstrType), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "conname", .fieldtype = "char *", .offset = offsetof(struct Constraint, conname), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "deferrable", .fieldtype = "_Bool", .offset = offsetof(struct Constraint, deferrable), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "initdeferred", .fieldtype = "_Bool", .offset = offsetof(struct Constraint, initdeferred), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "location", .fieldtype = "int", .offset = offsetof(struct Constraint, location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "is_no_inherit", .fieldtype = "_Bool", .offset = offsetof(struct Constraint, is_no_inherit), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "raw_expr", .fieldtype = "struct Node *", .offset = offsetof(struct Constraint, raw_expr), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "cooked_expr", .fieldtype = "char *", .offset = offsetof(struct Constraint, cooked_expr), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "generated_when", .fieldtype = "char", .offset = offsetof(struct Constraint, generated_when), .size = sizeof(char), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "keys", .fieldtype = "struct List *", .offset = offsetof(struct Constraint, keys), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "including", .fieldtype = "struct List *", .offset = offsetof(struct Constraint, including), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "exclusions", .fieldtype = "struct List *", .offset = offsetof(struct Constraint, exclusions), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "options", .fieldtype = "struct List *", .offset = offsetof(struct Constraint, options), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "indexname", .fieldtype = "char *", .offset = offsetof(struct Constraint, indexname), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "indexspace", .fieldtype = "char *", .offset = offsetof(struct Constraint, indexspace), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "reset_default_tblspc", .fieldtype = "_Bool", .offset = offsetof(struct Constraint, reset_default_tblspc), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "access_method", .fieldtype = "char *", .offset = offsetof(struct Constraint, access_method), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "where_clause", .fieldtype = "struct Node *", .offset = offsetof(struct Constraint, where_clause), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "pktable", .fieldtype = "struct RangeVar *", .offset = offsetof(struct Constraint, pktable), .size = sizeof(struct RangeVar *), .flags = TYPE_CAT_POINTER, .node_type_id = 101, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "fk_attrs", .fieldtype = "struct List *", .offset = offsetof(struct Constraint, fk_attrs), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "pk_attrs", .fieldtype = "struct List *", .offset = offsetof(struct Constraint, pk_attrs), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "fk_matchtype", .fieldtype = "char", .offset = offsetof(struct Constraint, fk_matchtype), .size = sizeof(char), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "fk_upd_action", .fieldtype = "char", .offset = offsetof(struct Constraint, fk_upd_action), .size = sizeof(char), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "fk_del_action", .fieldtype = "char", .offset = offsetof(struct Constraint, fk_del_action), .size = sizeof(char), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "old_conpfeqop", .fieldtype = "struct List *", .offset = offsetof(struct Constraint, old_conpfeqop), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "old_pktable_oid", .fieldtype = "unsigned int", .offset = offsetof(struct Constraint, old_pktable_oid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "skip_validation", .fieldtype = "_Bool", .offset = offsetof(struct Constraint, skip_validation), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "initially_valid", .fieldtype = "_Bool", .offset = offsetof(struct Constraint, initially_valid), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct CreateTableSpaceStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "tablespacename", .fieldtype = "char *", .offset = offsetof(struct CreateTableSpaceStmt, tablespacename), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "owner", .fieldtype = "struct RoleSpec *", .offset = offsetof(struct CreateTableSpaceStmt, owner), .size = sizeof(struct RoleSpec *), .flags = TYPE_CAT_POINTER, .node_type_id = 385, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "location", .fieldtype = "char *", .offset = offsetof(struct CreateTableSpaceStmt, location), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "options", .fieldtype = "struct List *", .offset = offsetof(struct CreateTableSpaceStmt, options), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct DropTableSpaceStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "tablespacename", .fieldtype = "char *", .offset = offsetof(struct DropTableSpaceStmt, tablespacename), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "missing_ok", .fieldtype = "_Bool", .offset = offsetof(struct DropTableSpaceStmt, missing_ok), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct AlterTableSpaceOptionsStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "tablespacename", .fieldtype = "char *", .offset = offsetof(struct AlterTableSpaceOptionsStmt, tablespacename), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "options", .fieldtype = "struct List *", .offset = offsetof(struct AlterTableSpaceOptionsStmt, options), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "isReset", .fieldtype = "_Bool", .offset = offsetof(struct AlterTableSpaceOptionsStmt, isReset), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct AlterTableMoveAllStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "orig_tablespacename", .fieldtype = "char *", .offset = offsetof(struct AlterTableMoveAllStmt, orig_tablespacename), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "objtype", .fieldtype = "enum ObjectType", .offset = offsetof(struct AlterTableMoveAllStmt, objtype), .size = sizeof(enum ObjectType), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "roles", .fieldtype = "struct List *", .offset = offsetof(struct AlterTableMoveAllStmt, roles), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "new_tablespacename", .fieldtype = "char *", .offset = offsetof(struct AlterTableMoveAllStmt, new_tablespacename), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "nowait", .fieldtype = "_Bool", .offset = offsetof(struct AlterTableMoveAllStmt, nowait), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct CreateExtensionStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "extname", .fieldtype = "char *", .offset = offsetof(struct CreateExtensionStmt, extname), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "if_not_exists", .fieldtype = "_Bool", .offset = offsetof(struct CreateExtensionStmt, if_not_exists), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "options", .fieldtype = "struct List *", .offset = offsetof(struct CreateExtensionStmt, options), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct AlterExtensionStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "extname", .fieldtype = "char *", .offset = offsetof(struct AlterExtensionStmt, extname), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "options", .fieldtype = "struct List *", .offset = offsetof(struct AlterExtensionStmt, options), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct AlterExtensionContentsStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "extname", .fieldtype = "char *", .offset = offsetof(struct AlterExtensionContentsStmt, extname), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "action", .fieldtype = "int", .offset = offsetof(struct AlterExtensionContentsStmt, action), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "objtype", .fieldtype = "enum ObjectType", .offset = offsetof(struct AlterExtensionContentsStmt, objtype), .size = sizeof(enum ObjectType), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "object", .fieldtype = "struct Node *", .offset = offsetof(struct AlterExtensionContentsStmt, object), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct CreateFdwStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "fdwname", .fieldtype = "char *", .offset = offsetof(struct CreateFdwStmt, fdwname), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "func_options", .fieldtype = "struct List *", .offset = offsetof(struct CreateFdwStmt, func_options), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "options", .fieldtype = "struct List *", .offset = offsetof(struct CreateFdwStmt, options), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct AlterFdwStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "fdwname", .fieldtype = "char *", .offset = offsetof(struct AlterFdwStmt, fdwname), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "func_options", .fieldtype = "struct List *", .offset = offsetof(struct AlterFdwStmt, func_options), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "options", .fieldtype = "struct List *", .offset = offsetof(struct AlterFdwStmt, options), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct CreateForeignServerStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "servername", .fieldtype = "char *", .offset = offsetof(struct CreateForeignServerStmt, servername), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "servertype", .fieldtype = "char *", .offset = offsetof(struct CreateForeignServerStmt, servertype), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "version", .fieldtype = "char *", .offset = offsetof(struct CreateForeignServerStmt, version), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "fdwname", .fieldtype = "char *", .offset = offsetof(struct CreateForeignServerStmt, fdwname), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "if_not_exists", .fieldtype = "_Bool", .offset = offsetof(struct CreateForeignServerStmt, if_not_exists), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "options", .fieldtype = "struct List *", .offset = offsetof(struct CreateForeignServerStmt, options), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct AlterForeignServerStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "servername", .fieldtype = "char *", .offset = offsetof(struct AlterForeignServerStmt, servername), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "version", .fieldtype = "char *", .offset = offsetof(struct AlterForeignServerStmt, version), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "options", .fieldtype = "struct List *", .offset = offsetof(struct AlterForeignServerStmt, options), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "has_version", .fieldtype = "_Bool", .offset = offsetof(struct AlterForeignServerStmt, has_version), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "base", .fieldtype = "struct CreateStmt", .offset = offsetof(struct CreateForeignTableStmt, base), .size = sizeof(struct CreateStmt), .flags = TYPE_CAT_SCALAR, .node_type_id = 244, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "servername", .fieldtype = "char *", .offset = offsetof(struct CreateForeignTableStmt, servername), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "options", .fieldtype = "struct List *", .offset = offsetof(struct CreateForeignTableStmt, options), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct CreateUserMappingStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "user", .fieldtype = "struct RoleSpec *", .offset = offsetof(struct CreateUserMappingStmt, user), .size = sizeof(struct RoleSpec *), .flags = TYPE_CAT_POINTER, .node_type_id = 385, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "servername", .fieldtype = "char *", .offset = offsetof(struct CreateUserMappingStmt, servername), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "if_not_exists", .fieldtype = "_Bool", .offset = offsetof(struct CreateUserMappingStmt, if_not_exists), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "options", .fieldtype = "struct List *", .offset = offsetof(struct CreateUserMappingStmt, options), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct AlterUserMappingStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "user", .fieldtype = "struct RoleSpec *", .offset = offsetof(struct AlterUserMappingStmt, user), .size = sizeof(struct RoleSpec *), .flags = TYPE_CAT_POINTER, .node_type_id = 385, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "servername", .fieldtype = "char *", .offset = offsetof(struct AlterUserMappingStmt, servername), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "options", .fieldtype = "struct List *", .offset = offsetof(struct AlterUserMappingStmt, options), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct DropUserMappingStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "user", .fieldtype = "struct RoleSpec *", .offset = offsetof(struct DropUserMappingStmt, user), .size = sizeof(struct RoleSpec *), .flags = TYPE_CAT_POINTER, .node_type_id = 385, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "servername", .fieldtype = "char *", .offset = offsetof(struct DropUserMappingStmt, servername), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "missing_ok", .fieldtype = "_Bool", .offset = offsetof(struct DropUserMappingStmt, missing_ok), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct ImportForeignSchemaStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "server_name", .fieldtype = "char *", .offset = offsetof(struct ImportForeignSchemaStmt, server_name), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "remote_schema", .fieldtype = "char *", .offset = offsetof(struct ImportForeignSchemaStmt, remote_schema), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "local_schema", .fieldtype = "char *", .offset = offsetof(struct ImportForeignSchemaStmt, local_schema), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "list_type", .fieldtype = "enum ImportForeignSchemaType", .offset = offsetof(struct ImportForeignSchemaStmt, list_type), .size = sizeof(enum ImportForeignSchemaType), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "table_list", .fieldtype = "struct List *", .offset = offsetof(struct ImportForeignSchemaStmt, table_list), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "options", .fieldtype = "struct List *", .offset = offsetof(struct ImportForeignSchemaStmt, options), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct CreatePolicyStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "policy_name", .fieldtype = "char *", .offset = offsetof(struct CreatePolicyStmt, policy_name), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "table", .fieldtype = "struct RangeVar *", .offset = offsetof(struct CreatePolicyStmt, table), .size = sizeof(struct RangeVar *), .flags = TYPE_CAT_POINTER, .node_type_id = 101, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "cmd_name", .fieldtype = "char *", .offset = offsetof(struct CreatePolicyStmt, cmd_name), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "permissive", .fieldtype = "_Bool", .offset = offsetof(struct CreatePolicyStmt, permissive), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "roles", .fieldtype = "struct List *", .offset = offsetof(struct CreatePolicyStmt, roles), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "qual", .fieldtype = "struct Node *", .offset = offsetof(struct CreatePolicyStmt, qual), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "with_check", .fieldtype = "struct Node *", .offset = offsetof(struct CreatePolicyStmt, with_check), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct AlterPolicyStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "policy_name", .fieldtype = "char *", .offset = offsetof(struct AlterPolicyStmt, policy_name), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "table", .fieldtype = "struct RangeVar *", .offset = offsetof(struct AlterPolicyStmt, table), .size = sizeof(struct RangeVar *), .flags = TYPE_CAT_POINTER, .node_type_id = 101, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "roles", .fieldtype = "struct List *", .offset = offsetof(struct AlterPolicyStmt, roles), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "qual", .fieldtype = "struct Node *", .offset = offsetof(struct AlterPolicyStmt, qual), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "with_check", .fieldtype = "struct Node *", .offset = offsetof(struct AlterPolicyStmt, with_check), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct CreateAmStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "amname", .fieldtype = "char *", .offset = offsetof(struct CreateAmStmt, amname), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "handler_name", .fieldtype = "struct List *", .offset = offsetof(struct CreateAmStmt, handler_name), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "amtype", .fieldtype = "char", .offset = offsetof(struct CreateAmStmt, amtype), .size = sizeof(char), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct CreateTrigStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "trigname", .fieldtype = "char *", .offset = offsetof(struct CreateTrigStmt, trigname), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "relation", .fieldtype = "struct RangeVar *", .offset = offsetof(struct CreateTrigStmt, relation), .size = sizeof(struct RangeVar *), .flags = TYPE_CAT_POINTER, .node_type_id = 101, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "funcname", .fieldtype = "struct List *", .offset = offsetof(struct CreateTrigStmt, funcname), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "args", .fieldtype = "struct List *", .offset = offsetof(struct CreateTrigStmt, args), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "row", .fieldtype = "_Bool", .offset = offsetof(struct CreateTrigStmt, row), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "timing", .fieldtype = "short", .offset = offsetof(struct CreateTrigStmt, timing), .size = sizeof(short), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "events", .fieldtype = "short", .offset = offsetof(struct CreateTrigStmt, events), .size = sizeof(short), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "columns", .fieldtype = "struct List *", .offset = offsetof(struct CreateTrigStmt, columns), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "whenClause", .fieldtype = "struct Node *", .offset = offsetof(struct CreateTrigStmt, whenClause), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "isconstraint", .fieldtype = "_Bool", .offset = offsetof(struct CreateTrigStmt, isconstraint), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "transitionRels", .fieldtype = "struct List *", .offset = offsetof(struct CreateTrigStmt, transitionRels), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "deferrable", .fieldtype = "_Bool", .offset = offsetof(struct CreateTrigStmt, deferrable), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "initdeferred", .fieldtype = "_Bool", .offset = offsetof(struct CreateTrigStmt, initdeferred), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "constrrel", .fieldtype = "struct RangeVar *", .offset = offsetof(struct CreateTrigStmt, constrrel), .size = sizeof(struct RangeVar *), .flags = TYPE_CAT_POINTER, .node_type_id = 101, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct CreateEventTrigStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "trigname", .fieldtype = "char *", .offset = offsetof(struct CreateEventTrigStmt, trigname), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "eventname", .fieldtype = "char *", .offset = offsetof(struct CreateEventTrigStmt, eventname), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "whenclause", .fieldtype = "struct List *", .offset = offsetof(struct CreateEventTrigStmt, whenclause), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "funcname", .fieldtype = "struct List *", .offset = offsetof(struct CreateEventTrigStmt, funcname), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct AlterEventTrigStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "trigname", .fieldtype = "char *", .offset = offsetof(struct AlterEventTrigStmt, trigname), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "tgenabled", .fieldtype = "char", .offset = offsetof(struct AlterEventTrigStmt, tgenabled), .size = sizeof(char), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct CreatePLangStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "replace", .fieldtype = "_Bool", .offset = offsetof(struct CreatePLangStmt, replace), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "plname", .fieldtype = "char *", .offset = offsetof(struct CreatePLangStmt, plname), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "plhandler", .fieldtype = "struct List *", .offset = offsetof(struct CreatePLangStmt, plhandler), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "plinline", .fieldtype = "struct List *", .offset = offsetof(struct CreatePLangStmt, plinline), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "plvalidator", .fieldtype = "struct List *", .offset = offsetof(struct CreatePLangStmt, plvalidator), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "pltrusted", .fieldtype = "_Bool", .offset = offsetof(struct CreatePLangStmt, pltrusted), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct CreateRoleStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "stmt_type", .fieldtype = "enum RoleStmtType", .offset = offsetof(struct CreateRoleStmt, stmt_type), .size = sizeof(enum RoleStmtType), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "role", .fieldtype = "char *", .offset = offsetof(struct CreateRoleStmt, role), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "options", .fieldtype = "struct List *", .offset = offsetof(struct CreateRoleStmt, options), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct AlterRoleStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "role", .fieldtype = "struct RoleSpec *", .offset = offsetof(struct AlterRoleStmt, role), .size = sizeof(struct RoleSpec *), .flags = TYPE_CAT_POINTER, .node_type_id = 385, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "options", .fieldtype = "struct List *", .offset = offsetof(struct AlterRoleStmt, options), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "action", .fieldtype = "int", .offset = offsetof(struct AlterRoleStmt, action), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct AlterRoleSetStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "role", .fieldtype = "struct RoleSpec *", .offset = offsetof(struct AlterRoleSetStmt, role), .size = sizeof(struct RoleSpec *), .flags = TYPE_CAT_POINTER, .node_type_id = 385, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "database", .fieldtype = "char *", .offset = offsetof(struct AlterRoleSetStmt, database), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "setstmt", .fieldtype = "struct VariableSetStmt *", .offset = offsetof(struct AlterRoleSetStmt, setstmt), .size = sizeof(struct VariableSetStmt *), .flags = TYPE_CAT_POINTER, .node_type_id = 270, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct DropRoleStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "roles", .fieldtype = "struct List *", .offset = offsetof(struct DropRoleStmt, roles), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "missing_ok", .fieldtype = "_Bool", .offset = offsetof(struct DropRoleStmt, missing_ok), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct CreateSeqStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "sequence", .fieldtype = "struct RangeVar *", .offset = offsetof(struct CreateSeqStmt, sequence), .size = sizeof(struct RangeVar *), .flags = TYPE_CAT_POINTER, .node_type_id = 101, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "options", .fieldtype = "struct List *", .offset = offsetof(struct CreateSeqStmt, options), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ownerId", .fieldtype = "unsigned int", .offset = offsetof(struct CreateSeqStmt, ownerId), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "for_identity", .fieldtype = "_Bool", .offset = offsetof(struct CreateSeqStmt, for_identity), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "if_not_exists", .fieldtype = "_Bool", .offset = offsetof(struct CreateSeqStmt, if_not_exists), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct AlterSeqStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "sequence", .fieldtype = "struct RangeVar *", .offset = offsetof(struct AlterSeqStmt, sequence), .size = sizeof(struct RangeVar *), .flags = TYPE_CAT_POINTER, .node_type_id = 101, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "options", .fieldtype = "struct List *", .offset = offsetof(struct AlterSeqStmt, options), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "for_identity", .fieldtype = "_Bool", .offset = offsetof(struct AlterSeqStmt, for_identity), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "missing_ok", .fieldtype = "_Bool", .offset = offsetof(struct AlterSeqStmt, missing_ok), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct DefineStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "kind", .fieldtype = "enum ObjectType", .offset = offsetof(struct DefineStmt, kind), .size = sizeof(enum ObjectType), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "oldstyle", .fieldtype = "_Bool", .offset = offsetof(struct DefineStmt, oldstyle), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "defnames", .fieldtype = "struct List *", .offset = offsetof(struct DefineStmt, defnames), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "args", .fieldtype = "struct List *", .offset = offsetof(struct DefineStmt, args), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "definition", .fieldtype = "struct List *", .offset = offsetof(struct DefineStmt, definition), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "if_not_exists", .fieldtype = "_Bool", .offset = offsetof(struct DefineStmt, if_not_exists), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "replace", .fieldtype = "_Bool", .offset = offsetof(struct DefineStmt, replace), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct CreateDomainStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "domainname", .fieldtype = "struct List *", .offset = offsetof(struct CreateDomainStmt, domainname), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "typeName", .fieldtype = "struct TypeName *", .offset = offsetof(struct CreateDomainStmt, typeName), .size = sizeof(struct TypeName *), .flags = TYPE_CAT_POINTER, .node_type_id = 361, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "collClause", .fieldtype = "struct CollateClause *", .offset = offsetof(struct CreateDomainStmt, collClause), .size = sizeof(struct CollateClause *), .flags = TYPE_CAT_POINTER, .node_type_id = 353, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "constraints", .fieldtype = "struct List *", .offset = offsetof(struct CreateDomainStmt, constraints), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct CreateOpClassStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "opclassname", .fieldtype = "struct List *", .offset = offsetof(struct CreateOpClassStmt, opclassname), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "opfamilyname", .fieldtype = "struct List *", .offset = offsetof(struct CreateOpClassStmt, opfamilyname), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "amname", .fieldtype = "char *", .offset = offsetof(struct CreateOpClassStmt, amname), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "datatype", .fieldtype = "struct TypeName *", .offset = offsetof(struct CreateOpClassStmt, datatype), .size = sizeof(struct TypeName *), .flags = TYPE_CAT_POINTER, .node_type_id = 361, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "items", .fieldtype = "struct List *", .offset = offsetof(struct CreateOpClassStmt, items), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "isDefault", .fieldtype = "_Bool", .offset = offsetof(struct CreateOpClassStmt, isDefault), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct CreateOpClassItem, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "itemtype", .fieldtype = "int", .offset = offsetof(struct CreateOpClassItem, itemtype), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "name", .fieldtype = "struct ObjectWithArgs *", .offset = offsetof(struct CreateOpClassItem, name), .size = sizeof(struct ObjectWithArgs *), .flags = TYPE_CAT_POINTER, .node_type_id = 373, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "number", .fieldtype = "int", .offset = offsetof(struct CreateOpClassItem, number), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "order_family", .fieldtype = "struct List *", .offset = offsetof(struct CreateOpClassItem, order_family), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "class_args", .fieldtype = "struct List *", .offset = offsetof(struct CreateOpClassItem, class_args), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "storedtype", .fieldtype = "struct TypeName *", .offset = offsetof(struct CreateOpClassItem, storedtype), .size = sizeof(struct TypeName *), .flags = TYPE_CAT_POINTER, .node_type_id = 361, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct CreateOpFamilyStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "opfamilyname", .fieldtype = "struct List *", .offset = offsetof(struct CreateOpFamilyStmt, opfamilyname), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "amname", .fieldtype = "char *", .offset = offsetof(struct CreateOpFamilyStmt, amname), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct AlterOpFamilyStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "opfamilyname", .fieldtype = "struct List *", .offset = offsetof(struct AlterOpFamilyStmt, opfamilyname), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "amname", .fieldtype = "char *", .offset = offsetof(struct AlterOpFamilyStmt, amname), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "isDrop", .fieldtype = "_Bool", .offset = offsetof(struct AlterOpFamilyStmt, isDrop), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "items", .fieldtype = "struct List *", .offset = offsetof(struct AlterOpFamilyStmt, items), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct DropStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "objects", .fieldtype = "struct List *", .offset = offsetof(struct DropStmt, objects), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "removeType", .fieldtype = "enum ObjectType", .offset = offsetof(struct DropStmt, removeType), .size = sizeof(enum ObjectType), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "behavior", .fieldtype = "enum DropBehavior", .offset = offsetof(struct DropStmt, behavior), .size = sizeof(enum DropBehavior), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "missing_ok", .fieldtype = "_Bool", .offset = offsetof(struct DropStmt, missing_ok), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "concurrent", .fieldtype = "_Bool", .offset = offsetof(struct DropStmt, concurrent), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct TruncateStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "relations", .fieldtype = "struct List *", .offset = offsetof(struct TruncateStmt, relations), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "restart_seqs", .fieldtype = "_Bool", .offset = offsetof(struct TruncateStmt, restart_seqs), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "behavior", .fieldtype = "enum DropBehavior", .offset = offsetof(struct TruncateStmt, behavior), .size = sizeof(enum DropBehavior), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct CommentStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "objtype", .fieldtype = "enum ObjectType", .offset = offsetof(struct CommentStmt, objtype), .size = sizeof(enum ObjectType), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "object", .fieldtype = "struct Node *", .offset = offsetof(struct CommentStmt, object), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "comment", .fieldtype = "char *", .offset = offsetof(struct CommentStmt, comment), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct SecLabelStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "objtype", .fieldtype = "enum ObjectType", .offset = offsetof(struct SecLabelStmt, objtype), .size = sizeof(enum ObjectType), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "object", .fieldtype = "struct Node *", .offset = offsetof(struct SecLabelStmt, object), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "provider", .fieldtype = "char *", .offset = offsetof(struct SecLabelStmt, provider), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "label", .fieldtype = "char *", .offset = offsetof(struct SecLabelStmt, label), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct DeclareCursorStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "portalname", .fieldtype = "char *", .offset = offsetof(struct DeclareCursorStmt, portalname), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "options", .fieldtype = "int", .offset = offsetof(struct DeclareCursorStmt, options), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "query", .fieldtype = "struct Node *", .offset = offsetof(struct DeclareCursorStmt, query), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct ClosePortalStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "portalname", .fieldtype = "char *", .offset = offsetof(struct ClosePortalStmt, portalname), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct FetchStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "direction", .fieldtype = "enum FetchDirection", .offset = offsetof(struct FetchStmt, direction), .size = sizeof(enum FetchDirection), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "howMany", .fieldtype = "long", .offset = offsetof(struct FetchStmt, howMany), .size = sizeof(long), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "portalname", .fieldtype = "char *", .offset = offsetof(struct FetchStmt, portalname), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "ismove", .fieldtype = "_Bool", .offset = offsetof(struct FetchStmt, ismove), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct IndexStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "idxname", .fieldtype = "char *", .offset = offsetof(struct IndexStmt, idxname), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "relation", .fieldtype = "struct RangeVar *", .offset = offsetof(struct IndexStmt, relation), .size = sizeof(struct RangeVar *), .flags = TYPE_CAT_POINTER, .node_type_id = 101, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "accessMethod", .fieldtype = "char *", .offset = offsetof(struct IndexStmt, accessMethod), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "tableSpace", .fieldtype = "char *", .offset = offsetof(struct IndexStmt, tableSpace), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "indexParams", .fieldtype = "struct List *", .offset = offsetof(struct IndexStmt, indexParams), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "indexIncludingParams", .fieldtype = "struct List *", .offset = offsetof(struct IndexStmt, indexIncludingParams), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "options", .fieldtype = "struct List *", .offset = offsetof(struct IndexStmt, options), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "whereClause", .fieldtype = "struct Node *", .offset = offsetof(struct IndexStmt, whereClause), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "excludeOpNames", .fieldtype = "struct List *", .offset = offsetof(struct IndexStmt, excludeOpNames), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "idxcomment", .fieldtype = "char *", .offset = offsetof(struct IndexStmt, idxcomment), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "indexOid", .fieldtype = "unsigned int", .offset = offsetof(struct IndexStmt, indexOid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "oldNode", .fieldtype = "unsigned int", .offset = offsetof(struct IndexStmt, oldNode), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "unique", .fieldtype = "_Bool", .offset = offsetof(struct IndexStmt, unique), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "primary", .fieldtype = "_Bool", .offset = offsetof(struct IndexStmt, primary), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "isconstraint", .fieldtype = "_Bool", .offset = offsetof(struct IndexStmt, isconstraint), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "deferrable", .fieldtype = "_Bool", .offset = offsetof(struct IndexStmt, deferrable), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "initdeferred", .fieldtype = "_Bool", .offset = offsetof(struct IndexStmt, initdeferred), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "transformed", .fieldtype = "_Bool", .offset = offsetof(struct IndexStmt, transformed), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "concurrent", .fieldtype = "_Bool", .offset = offsetof(struct IndexStmt, concurrent), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "if_not_exists", .fieldtype = "_Bool", .offset = offsetof(struct IndexStmt, if_not_exists), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "reset_default_tblspc", .fieldtype = "_Bool", .offset = offsetof(struct IndexStmt, reset_default_tblspc), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct CreateStatsStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "defnames", .fieldtype = "struct List *", .offset = offsetof(struct CreateStatsStmt, defnames), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "stat_types", .fieldtype = "struct List *", .offset = offsetof(struct CreateStatsStmt, stat_types), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "exprs", .fieldtype = "struct List *", .offset = offsetof(struct CreateStatsStmt, exprs), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "relations", .fieldtype = "struct List *", .offset = offsetof(struct CreateStatsStmt, relations), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "stxcomment", .fieldtype = "char *", .offset = offsetof(struct CreateStatsStmt, stxcomment), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "if_not_exists", .fieldtype = "_Bool", .offset = offsetof(struct CreateStatsStmt, if_not_exists), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct CreateFunctionStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "is_procedure", .fieldtype = "_Bool", .offset = offsetof(struct CreateFunctionStmt, is_procedure), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "replace", .fieldtype = "_Bool", .offset = offsetof(struct CreateFunctionStmt, replace), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "funcname", .fieldtype = "struct List *", .offset = offsetof(struct CreateFunctionStmt, funcname), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "parameters", .fieldtype = "struct List *", .offset = offsetof(struct CreateFunctionStmt, parameters), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "returnType", .fieldtype = "struct TypeName *", .offset = offsetof(struct CreateFunctionStmt, returnType), .size = sizeof(struct TypeName *), .flags = TYPE_CAT_POINTER, .node_type_id = 361, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "options", .fieldtype = "struct List *", .offset = offsetof(struct CreateFunctionStmt, options), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct FunctionParameter, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "name", .fieldtype = "char *", .offset = offsetof(struct FunctionParameter, name), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "argType", .fieldtype = "struct TypeName *", .offset = offsetof(struct FunctionParameter, argType), .size = sizeof(struct TypeName *), .flags = TYPE_CAT_POINTER, .node_type_id = 361, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "mode", .fieldtype = "enum FunctionParameterMode", .offset = offsetof(struct FunctionParameter, mode), .size = sizeof(enum FunctionParameterMode), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "defexpr", .fieldtype = "struct Node *", .offset = offsetof(struct FunctionParameter, defexpr), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct AlterFunctionStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "objtype", .fieldtype = "enum ObjectType", .offset = offsetof(struct AlterFunctionStmt, objtype), .size = sizeof(enum ObjectType), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "func", .fieldtype = "struct ObjectWithArgs *", .offset = offsetof(struct AlterFunctionStmt, func), .size = sizeof(struct ObjectWithArgs *), .flags = TYPE_CAT_POINTER, .node_type_id = 373, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "actions", .fieldtype = "struct List *", .offset = offsetof(struct AlterFunctionStmt, actions), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct DoStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "args", .fieldtype = "struct List *", .offset = offsetof(struct DoStmt, args), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct InlineCodeBlock, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "source_text", .fieldtype = "char *", .offset = offsetof(struct InlineCodeBlock, source_text), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "langOid", .fieldtype = "unsigned int", .offset = offsetof(struct InlineCodeBlock, langOid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "langIsTrusted", .fieldtype = "_Bool", .offset = offsetof(struct InlineCodeBlock, langIsTrusted), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "atomic", .fieldtype = "_Bool", .offset = offsetof(struct InlineCodeBlock, atomic), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct CallStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "funccall", .fieldtype = "struct FuncCall *", .offset = offsetof(struct CallStmt, funccall), .size = sizeof(struct FuncCall *), .flags = TYPE_CAT_POINTER, .node_type_id = 345, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "funcexpr", .fieldtype = "struct FuncExpr *", .offset = offsetof(struct CallStmt, funcexpr), .size = sizeof(struct FuncExpr *), .flags = TYPE_CAT_POINTER, .node_type_id = 111, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct CallContext, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "atomic", .fieldtype = "_Bool", .offset = offsetof(struct CallContext, atomic), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct RenameStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "renameType", .fieldtype = "enum ObjectType", .offset = offsetof(struct RenameStmt, renameType), .size = sizeof(enum ObjectType), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "relationType", .fieldtype = "enum ObjectType", .offset = offsetof(struct RenameStmt, relationType), .size = sizeof(enum ObjectType), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "relation", .fieldtype = "struct RangeVar *", .offset = offsetof(struct RenameStmt, relation), .size = sizeof(struct RangeVar *), .flags = TYPE_CAT_POINTER, .node_type_id = 101, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "object", .fieldtype = "struct Node *", .offset = offsetof(struct RenameStmt, object), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "subname", .fieldtype = "char *", .offset = offsetof(struct RenameStmt, subname), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "newname", .fieldtype = "char *", .offset = offsetof(struct RenameStmt, newname), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "behavior", .fieldtype = "enum DropBehavior", .offset = offsetof(struct RenameStmt, behavior), .size = sizeof(enum DropBehavior), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "missing_ok", .fieldtype = "_Bool", .offset = offsetof(struct RenameStmt, missing_ok), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct AlterObjectDependsStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "objectType", .fieldtype = "enum ObjectType", .offset = offsetof(struct AlterObjectDependsStmt, objectType), .size = sizeof(enum ObjectType), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "relation", .fieldtype = "struct RangeVar *", .offset = offsetof(struct AlterObjectDependsStmt, relation), .size = sizeof(struct RangeVar *), .flags = TYPE_CAT_POINTER, .node_type_id = 101, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "object", .fieldtype = "struct Node *", .offset = offsetof(struct AlterObjectDependsStmt, object), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "extname", .fieldtype = "struct Value *", .offset = offsetof(struct AlterObjectDependsStmt, extname), .size = sizeof(struct Value *), .flags = TYPE_CAT_POINTER, .node_type_id = 217, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct AlterObjectSchemaStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "objectType", .fieldtype = "enum ObjectType", .offset = offsetof(struct AlterObjectSchemaStmt, objectType), .size = sizeof(enum ObjectType), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "relation", .fieldtype = "struct RangeVar *", .offset = offsetof(struct AlterObjectSchemaStmt, relation), .size = sizeof(struct RangeVar *), .flags = TYPE_CAT_POINTER, .node_type_id = 101, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "object", .fieldtype = "struct Node *", .offset = offsetof(struct AlterObjectSchemaStmt, object), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "newschema", .fieldtype = "char *", .offset = offsetof(struct AlterObjectSchemaStmt, newschema), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "missing_ok", .fieldtype = "_Bool", .offset = offsetof(struct AlterObjectSchemaStmt, missing_ok), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct AlterOwnerStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "objectType", .fieldtype = "enum ObjectType", .offset = offsetof(struct AlterOwnerStmt, objectType), .size = sizeof(enum ObjectType), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "relation", .fieldtype = "struct RangeVar *", .offset = offsetof(struct AlterOwnerStmt, relation), .size = sizeof(struct RangeVar *), .flags = TYPE_CAT_POINTER, .node_type_id = 101, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "object", .fieldtype = "struct Node *", .offset = offsetof(struct AlterOwnerStmt, object), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "newowner", .fieldtype = "struct RoleSpec *", .offset = offsetof(struct AlterOwnerStmt, newowner), .size = sizeof(struct RoleSpec *), .flags = TYPE_CAT_POINTER, .node_type_id = 385, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct AlterOperatorStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "opername", .fieldtype = "struct ObjectWithArgs *", .offset = offsetof(struct AlterOperatorStmt, opername), .size = sizeof(struct ObjectWithArgs *), .flags = TYPE_CAT_POINTER, .node_type_id = 373, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "options", .fieldtype = "struct List *", .offset = offsetof(struct AlterOperatorStmt, options), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct RuleStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "relation", .fieldtype = "struct RangeVar *", .offset = offsetof(struct RuleStmt, relation), .size = sizeof(struct RangeVar *), .flags = TYPE_CAT_POINTER, .node_type_id = 101, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "rulename", .fieldtype = "char *", .offset = offsetof(struct RuleStmt, rulename), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "whereClause", .fieldtype = "struct Node *", .offset = offsetof(struct RuleStmt, whereClause), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "event", .fieldtype = "enum CmdType", .offset = offsetof(struct RuleStmt, event), .size = sizeof(enum CmdType), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "instead", .fieldtype = "_Bool", .offset = offsetof(struct RuleStmt, instead), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "actions", .fieldtype = "struct List *", .offset = offsetof(struct RuleStmt, actions), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "replace", .fieldtype = "_Bool", .offset = offsetof(struct RuleStmt, replace), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct NotifyStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "conditionname", .fieldtype = "char *", .offset = offsetof(struct NotifyStmt, conditionname), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "payload", .fieldtype = "char *", .offset = offsetof(struct NotifyStmt, payload), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct ListenStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "conditionname", .fieldtype = "char *", .offset = offsetof(struct ListenStmt, conditionname), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct UnlistenStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "conditionname", .fieldtype = "char *", .offset = offsetof(struct UnlistenStmt, conditionname), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct TransactionStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "kind", .fieldtype = "enum TransactionStmtKind", .offset = offsetof(struct TransactionStmt, kind), .size = sizeof(enum TransactionStmtKind), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "options", .fieldtype = "struct List *", .offset = offsetof(struct TransactionStmt, options), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "savepoint_name", .fieldtype = "char *", .offset = offsetof(struct TransactionStmt, savepoint_name), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "gid", .fieldtype = "char *", .offset = offsetof(struct TransactionStmt, gid), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "chain", .fieldtype = "_Bool", .offset = offsetof(struct TransactionStmt, chain), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct CompositeTypeStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "typevar", .fieldtype = "struct RangeVar *", .offset = offsetof(struct CompositeTypeStmt, typevar), .size = sizeof(struct RangeVar *), .flags = TYPE_CAT_POINTER, .node_type_id = 101, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "coldeflist", .fieldtype = "struct List *", .offset = offsetof(struct CompositeTypeStmt, coldeflist), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct CreateEnumStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "typeName", .fieldtype = "struct List *", .offset = offsetof(struct CreateEnumStmt, typeName), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "vals", .fieldtype = "struct List *", .offset = offsetof(struct CreateEnumStmt, vals), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct CreateRangeStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "typeName", .fieldtype = "struct List *", .offset = offsetof(struct CreateRangeStmt, typeName), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "params", .fieldtype = "struct List *", .offset = offsetof(struct CreateRangeStmt, params), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct AlterEnumStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "typeName", .fieldtype = "struct List *", .offset = offsetof(struct AlterEnumStmt, typeName), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "oldVal", .fieldtype = "char *", .offset = offsetof(struct AlterEnumStmt, oldVal), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "newVal", .fieldtype = "char *", .offset = offsetof(struct AlterEnumStmt, newVal), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "newValNeighbor", .fieldtype = "char *", .offset = offsetof(struct AlterEnumStmt, newValNeighbor), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "newValIsAfter", .fieldtype = "_Bool", .offset = offsetof(struct AlterEnumStmt, newValIsAfter), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "skipIfNewValExists", .fieldtype = "_Bool", .offset = offsetof(struct AlterEnumStmt, skipIfNewValExists), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct ViewStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "view", .fieldtype = "struct RangeVar *", .offset = offsetof(struct ViewStmt, view), .size = sizeof(struct RangeVar *), .flags = TYPE_CAT_POINTER, .node_type_id = 101, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "aliases", .fieldtype = "struct List *", .offset = offsetof(struct ViewStmt, aliases), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "query", .fieldtype = "struct Node *", .offset = offsetof(struct ViewStmt, query), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "replace", .fieldtype = "_Bool", .offset = offsetof(struct ViewStmt, replace), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "options", .fieldtype = "struct List *", .offset = offsetof(struct ViewStmt, options), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "withCheckOption", .fieldtype = "enum ViewCheckOption", .offset = offsetof(struct ViewStmt, withCheckOption), .size = sizeof(enum ViewCheckOption), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct LoadStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "filename", .fieldtype = "char *", .offset = offsetof(struct LoadStmt, filename), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct CreatedbStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "dbname", .fieldtype = "char *", .offset = offsetof(struct CreatedbStmt, dbname), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "options", .fieldtype = "struct List *", .offset = offsetof(struct CreatedbStmt, options), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct AlterDatabaseStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "dbname", .fieldtype = "char *", .offset = offsetof(struct AlterDatabaseStmt, dbname), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "options", .fieldtype = "struct List *", .offset = offsetof(struct AlterDatabaseStmt, options), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct AlterDatabaseSetStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "dbname", .fieldtype = "char *", .offset = offsetof(struct AlterDatabaseSetStmt, dbname), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "setstmt", .fieldtype = "struct VariableSetStmt *", .offset = offsetof(struct AlterDatabaseSetStmt, setstmt), .size = sizeof(struct VariableSetStmt *), .flags = TYPE_CAT_POINTER, .node_type_id = 270, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct DropdbStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "dbname", .fieldtype = "char *", .offset = offsetof(struct DropdbStmt, dbname), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "missing_ok", .fieldtype = "_Bool", .offset = offsetof(struct DropdbStmt, missing_ok), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct AlterSystemStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "setstmt", .fieldtype = "struct VariableSetStmt *", .offset = offsetof(struct AlterSystemStmt, setstmt), .size = sizeof(struct VariableSetStmt *), .flags = TYPE_CAT_POINTER, .node_type_id = 270, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct ClusterStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "relation", .fieldtype = "struct RangeVar *", .offset = offsetof(struct ClusterStmt, relation), .size = sizeof(struct RangeVar *), .flags = TYPE_CAT_POINTER, .node_type_id = 101, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "indexname", .fieldtype = "char *", .offset = offsetof(struct ClusterStmt, indexname), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "options", .fieldtype = "int", .offset = offsetof(struct ClusterStmt, options), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct VacuumStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "options", .fieldtype = "struct List *", .offset = offsetof(struct VacuumStmt, options), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "rels", .fieldtype = "struct List *", .offset = offsetof(struct VacuumStmt, rels), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "is_vacuumcmd", .fieldtype = "_Bool", .offset = offsetof(struct VacuumStmt, is_vacuumcmd), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct VacuumRelation, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "relation", .fieldtype = "struct RangeVar *", .offset = offsetof(struct VacuumRelation, relation), .size = sizeof(struct RangeVar *), .flags = TYPE_CAT_POINTER, .node_type_id = 101, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "oid", .fieldtype = "unsigned int", .offset = offsetof(struct VacuumRelation, oid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "va_cols", .fieldtype = "struct List *", .offset = offsetof(struct VacuumRelation, va_cols), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct ExplainStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "query", .fieldtype = "struct Node *", .offset = offsetof(struct ExplainStmt, query), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "options", .fieldtype = "struct List *", .offset = offsetof(struct ExplainStmt, options), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct CreateTableAsStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "query", .fieldtype = "struct Node *", .offset = offsetof(struct CreateTableAsStmt, query), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "into", .fieldtype = "struct IntoClause *", .offset = offsetof(struct CreateTableAsStmt, into), .size = sizeof(struct IntoClause *), .flags = TYPE_CAT_POINTER, .node_type_id = 151, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "relkind", .fieldtype = "enum ObjectType", .offset = offsetof(struct CreateTableAsStmt, relkind), .size = sizeof(enum ObjectType), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "is_select_into", .fieldtype = "_Bool", .offset = offsetof(struct CreateTableAsStmt, is_select_into), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "if_not_exists", .fieldtype = "_Bool", .offset = offsetof(struct CreateTableAsStmt, if_not_exists), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct RefreshMatViewStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "concurrent", .fieldtype = "_Bool", .offset = offsetof(struct RefreshMatViewStmt, concurrent), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "skipData", .fieldtype = "_Bool", .offset = offsetof(struct RefreshMatViewStmt, skipData), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "relation", .fieldtype = "struct RangeVar *", .offset = offsetof(struct RefreshMatViewStmt, relation), .size = sizeof(struct RangeVar *), .flags = TYPE_CAT_POINTER, .node_type_id = 101, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct CheckPointStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct DiscardStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "target", .fieldtype = "enum DiscardMode", .offset = offsetof(struct DiscardStmt, target), .size = sizeof(enum DiscardMode), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct LockStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "relations", .fieldtype = "struct List *", .offset = offsetof(struct LockStmt, relations), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "mode", .fieldtype = "int", .offset = offsetof(struct LockStmt, mode), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "nowait", .fieldtype = "_Bool", .offset = offsetof(struct LockStmt, nowait), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct ConstraintsSetStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "constraints", .fieldtype = "struct List *", .offset = offsetof(struct ConstraintsSetStmt, constraints), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "deferred", .fieldtype = "_Bool", .offset = offsetof(struct ConstraintsSetStmt, deferred), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct ReindexStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "kind", .fieldtype = "enum ReindexObjectType", .offset = offsetof(struct ReindexStmt, kind), .size = sizeof(enum ReindexObjectType), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "relation", .fieldtype = "struct RangeVar *", .offset = offsetof(struct ReindexStmt, relation), .size = sizeof(struct RangeVar *), .flags = TYPE_CAT_POINTER, .node_type_id = 101, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "name", .fieldtype = "const char *", .offset = offsetof(struct ReindexStmt, name), .size = sizeof(const char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "options", .fieldtype = "int", .offset = offsetof(struct ReindexStmt, options), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "concurrent", .fieldtype = "_Bool", .offset = offsetof(struct ReindexStmt, concurrent), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct CreateConversionStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "conversion_name", .fieldtype = "struct List *", .offset = offsetof(struct CreateConversionStmt, conversion_name), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "for_encoding_name", .fieldtype = "char *", .offset = offsetof(struct CreateConversionStmt, for_encoding_name), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "to_encoding_name", .fieldtype = "char *", .offset = offsetof(struct CreateConversionStmt, to_encoding_name), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "func_name", .fieldtype = "struct List *", .offset = offsetof(struct CreateConversionStmt, func_name), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "def", .fieldtype = "_Bool", .offset = offsetof(struct CreateConversionStmt, def), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct CreateCastStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "sourcetype", .fieldtype = "struct TypeName *", .offset = offsetof(struct CreateCastStmt, sourcetype), .size = sizeof(struct TypeName *), .flags = TYPE_CAT_POINTER, .node_type_id = 361, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "targettype", .fieldtype = "struct TypeName *", .offset = offsetof(struct CreateCastStmt, targettype), .size = sizeof(struct TypeName *), .flags = TYPE_CAT_POINTER, .node_type_id = 361, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "func", .fieldtype = "struct ObjectWithArgs *", .offset = offsetof(struct CreateCastStmt, func), .size = sizeof(struct ObjectWithArgs *), .flags = TYPE_CAT_POINTER, .node_type_id = 373, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "context", .fieldtype = "enum CoercionContext", .offset = offsetof(struct CreateCastStmt, context), .size = sizeof(enum CoercionContext), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "inout", .fieldtype = "_Bool", .offset = offsetof(struct CreateCastStmt, inout), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct CreateTransformStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "replace", .fieldtype = "_Bool", .offset = offsetof(struct CreateTransformStmt, replace), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type_name", .fieldtype = "struct TypeName *", .offset = offsetof(struct CreateTransformStmt, type_name), .size = sizeof(struct TypeName *), .flags = TYPE_CAT_POINTER, .node_type_id = 361, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "lang", .fieldtype = "char *", .offset = offsetof(struct CreateTransformStmt, lang), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "fromsql", .fieldtype = "struct ObjectWithArgs *", .offset = offsetof(struct CreateTransformStmt, fromsql), .size = sizeof(struct ObjectWithArgs *), .flags = TYPE_CAT_POINTER, .node_type_id = 373, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "tosql", .fieldtype = "struct ObjectWithArgs *", .offset = offsetof(struct CreateTransformStmt, tosql), .size = sizeof(struct ObjectWithArgs *), .flags = TYPE_CAT_POINTER, .node_type_id = 373, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct PrepareStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "name", .fieldtype = "char *", .offset = offsetof(struct PrepareStmt, name), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "argtypes", .fieldtype = "struct List *", .offset = offsetof(struct PrepareStmt, argtypes), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "query", .fieldtype = "struct Node *", .offset = offsetof(struct PrepareStmt, query), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct ExecuteStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "name", .fieldtype = "char *", .offset = offsetof(struct ExecuteStmt, name), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "params", .fieldtype = "struct List *", .offset = offsetof(struct ExecuteStmt, params), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct DeallocateStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "name", .fieldtype = "char *", .offset = offsetof(struct DeallocateStmt, name), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct DropOwnedStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "roles", .fieldtype = "struct List *", .offset = offsetof(struct DropOwnedStmt, roles), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "behavior", .fieldtype = "enum DropBehavior", .offset = offsetof(struct DropOwnedStmt, behavior), .size = sizeof(enum DropBehavior), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct ReassignOwnedStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "roles", .fieldtype = "struct List *", .offset = offsetof(struct ReassignOwnedStmt, roles), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "newrole", .fieldtype = "struct RoleSpec *", .offset = offsetof(struct ReassignOwnedStmt, newrole), .size = sizeof(struct RoleSpec *), .flags = TYPE_CAT_POINTER, .node_type_id = 385, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct AlterTSDictionaryStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "dictname", .fieldtype = "struct List *", .offset = offsetof(struct AlterTSDictionaryStmt, dictname), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "options", .fieldtype = "struct List *", .offset = offsetof(struct AlterTSDictionaryStmt, options), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct AlterTSConfigurationStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "kind", .fieldtype = "enum AlterTSConfigType", .offset = offsetof(struct AlterTSConfigurationStmt, kind), .size = sizeof(enum AlterTSConfigType), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "cfgname", .fieldtype = "struct List *", .offset = offsetof(struct AlterTSConfigurationStmt, cfgname), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "tokentype", .fieldtype = "struct List *", .offset = offsetof(struct AlterTSConfigurationStmt, tokentype), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "dicts", .fieldtype = "struct List *", .offset = offsetof(struct AlterTSConfigurationStmt, dicts), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "override", .fieldtype = "_Bool", .offset = offsetof(struct AlterTSConfigurationStmt, override), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "replace", .fieldtype = "_Bool", .offset = offsetof(struct AlterTSConfigurationStmt, replace), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "missing_ok", .fieldtype = "_Bool", .offset = offsetof(struct AlterTSConfigurationStmt, missing_ok), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct CreatePublicationStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "pubname", .fieldtype = "char *", .offset = offsetof(struct CreatePublicationStmt, pubname), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "options", .fieldtype = "struct List *", .offset = offsetof(struct CreatePublicationStmt, options), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "tables", .fieldtype = "struct List *", .offset = offsetof(struct CreatePublicationStmt, tables), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "for_all_tables", .fieldtype = "_Bool", .offset = offsetof(struct CreatePublicationStmt, for_all_tables), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct AlterPublicationStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "pubname", .fieldtype = "char *", .offset = offsetof(struct AlterPublicationStmt, pubname), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "options", .fieldtype = "struct List *", .offset = offsetof(struct AlterPublicationStmt, options), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "tables", .fieldtype = "struct List *", .offset = offsetof(struct AlterPublicationStmt, tables), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "for_all_tables", .fieldtype = "_Bool", .offset = offsetof(struct AlterPublicationStmt, for_all_tables), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "tableAction", .fieldtype = "enum DefElemAction", .offset = offsetof(struct AlterPublicationStmt, tableAction), .size = sizeof(enum DefElemAction), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct CreateSubscriptionStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "subname", .fieldtype = "char *", .offset = offsetof(struct CreateSubscriptionStmt, subname), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "conninfo", .fieldtype = "char *", .offset = offsetof(struct CreateSubscriptionStmt, conninfo), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "publication", .fieldtype = "struct List *", .offset = offsetof(struct CreateSubscriptionStmt, publication), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "options", .fieldtype = "struct List *", .offset = offsetof(struct CreateSubscriptionStmt, options), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct AlterSubscriptionStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "kind", .fieldtype = "enum AlterSubscriptionType", .offset = offsetof(struct AlterSubscriptionStmt, kind), .size = sizeof(enum AlterSubscriptionType), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "subname", .fieldtype = "char *", .offset = offsetof(struct AlterSubscriptionStmt, subname), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "conninfo", .fieldtype = "char *", .offset = offsetof(struct AlterSubscriptionStmt, conninfo), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "publication", .fieldtype = "struct List *", .offset = offsetof(struct AlterSubscriptionStmt, publication), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "options", .fieldtype = "struct List *", .offset = offsetof(struct AlterSubscriptionStmt, options), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct DropSubscriptionStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "subname", .fieldtype = "char *", .offset = offsetof(struct DropSubscriptionStmt, subname), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "missing_ok", .fieldtype = "_Bool", .offset = offsetof(struct DropSubscriptionStmt, missing_ok), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "behavior", .fieldtype = "enum DropBehavior", .offset = offsetof(struct DropSubscriptionStmt, behavior), .size = sizeof(enum DropBehavior), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct PlannerGlobal, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "boundParams", .fieldtype = "struct ParamListInfoData *", .offset = offsetof(struct PlannerGlobal, boundParams), .size = sizeof(struct ParamListInfoData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "subplans", .fieldtype = "struct List *", .offset = offsetof(struct PlannerGlobal, subplans), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "subroots", .fieldtype = "struct List *", .offset = offsetof(struct PlannerGlobal, subroots), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "rewindPlanIDs", .fieldtype = "struct Bitmapset *", .offset = offsetof(struct PlannerGlobal, rewindPlanIDs), .size = sizeof(struct Bitmapset *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_BITMAPSET},
+	{.fieldname = "finalrtable", .fieldtype = "struct List *", .offset = offsetof(struct PlannerGlobal, finalrtable), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "finalrowmarks", .fieldtype = "struct List *", .offset = offsetof(struct PlannerGlobal, finalrowmarks), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "resultRelations", .fieldtype = "struct List *", .offset = offsetof(struct PlannerGlobal, resultRelations), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "rootResultRelations", .fieldtype = "struct List *", .offset = offsetof(struct PlannerGlobal, rootResultRelations), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "relationOids", .fieldtype = "struct List *", .offset = offsetof(struct PlannerGlobal, relationOids), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "invalItems", .fieldtype = "struct List *", .offset = offsetof(struct PlannerGlobal, invalItems), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "paramExecTypes", .fieldtype = "struct List *", .offset = offsetof(struct PlannerGlobal, paramExecTypes), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "lastPHId", .fieldtype = "unsigned int", .offset = offsetof(struct PlannerGlobal, lastPHId), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "lastRowMarkId", .fieldtype = "unsigned int", .offset = offsetof(struct PlannerGlobal, lastRowMarkId), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "lastPlanNodeId", .fieldtype = "int", .offset = offsetof(struct PlannerGlobal, lastPlanNodeId), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "transientPlan", .fieldtype = "_Bool", .offset = offsetof(struct PlannerGlobal, transientPlan), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "dependsOnRole", .fieldtype = "_Bool", .offset = offsetof(struct PlannerGlobal, dependsOnRole), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "parallelModeOK", .fieldtype = "_Bool", .offset = offsetof(struct PlannerGlobal, parallelModeOK), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "parallelModeNeeded", .fieldtype = "_Bool", .offset = offsetof(struct PlannerGlobal, parallelModeNeeded), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "maxParallelHazard", .fieldtype = "char", .offset = offsetof(struct PlannerGlobal, maxParallelHazard), .size = sizeof(char), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "partition_directory", .fieldtype = "struct PartitionDirectoryData *", .offset = offsetof(struct PlannerGlobal, partition_directory), .size = sizeof(struct PartitionDirectoryData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct PlannerInfo, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "parse", .fieldtype = "struct Query *", .offset = offsetof(struct PlannerInfo, parse), .size = sizeof(struct Query *), .flags = TYPE_CAT_POINTER, .node_type_id = 228, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "glob", .fieldtype = "struct PlannerGlobal *", .offset = offsetof(struct PlannerInfo, glob), .size = sizeof(struct PlannerGlobal *), .flags = TYPE_CAT_POINTER, .node_type_id = 160, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "query_level", .fieldtype = "unsigned int", .offset = offsetof(struct PlannerInfo, query_level), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "parent_root", .fieldtype = "struct PlannerInfo *", .offset = offsetof(struct PlannerInfo, parent_root), .size = sizeof(struct PlannerInfo *), .flags = TYPE_CAT_POINTER, .node_type_id = 159, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "plan_params", .fieldtype = "struct List *", .offset = offsetof(struct PlannerInfo, plan_params), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "outer_params", .fieldtype = "struct Bitmapset *", .offset = offsetof(struct PlannerInfo, outer_params), .size = sizeof(struct Bitmapset *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_BITMAPSET},
+	{.fieldname = "simple_rel_array", .fieldtype = "struct RelOptInfo **", .offset = offsetof(struct PlannerInfo, simple_rel_array), .size = sizeof(struct RelOptInfo **), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "simple_rel_array_size", .fieldtype = "int", .offset = offsetof(struct PlannerInfo, simple_rel_array_size), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "simple_rte_array", .fieldtype = "struct RangeTblEntry **", .offset = offsetof(struct PlannerInfo, simple_rte_array), .size = sizeof(struct RangeTblEntry **), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "append_rel_array", .fieldtype = "struct AppendRelInfo **", .offset = offsetof(struct PlannerInfo, append_rel_array), .size = sizeof(struct AppendRelInfo **), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "all_baserels", .fieldtype = "struct Bitmapset *", .offset = offsetof(struct PlannerInfo, all_baserels), .size = sizeof(struct Bitmapset *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_BITMAPSET},
+	{.fieldname = "nullable_baserels", .fieldtype = "struct Bitmapset *", .offset = offsetof(struct PlannerInfo, nullable_baserels), .size = sizeof(struct Bitmapset *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_BITMAPSET},
+	{.fieldname = "join_rel_list", .fieldtype = "struct List *", .offset = offsetof(struct PlannerInfo, join_rel_list), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "join_rel_hash", .fieldtype = "struct HTAB *", .offset = offsetof(struct PlannerInfo, join_rel_hash), .size = sizeof(struct HTAB *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "join_rel_level", .fieldtype = "struct List **", .offset = offsetof(struct PlannerInfo, join_rel_level), .size = sizeof(struct List **), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "join_cur_level", .fieldtype = "int", .offset = offsetof(struct PlannerInfo, join_cur_level), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "init_plans", .fieldtype = "struct List *", .offset = offsetof(struct PlannerInfo, init_plans), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "cte_plan_ids", .fieldtype = "struct List *", .offset = offsetof(struct PlannerInfo, cte_plan_ids), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "multiexpr_params", .fieldtype = "struct List *", .offset = offsetof(struct PlannerInfo, multiexpr_params), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "eq_classes", .fieldtype = "struct List *", .offset = offsetof(struct PlannerInfo, eq_classes), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ec_merging_done", .fieldtype = "_Bool", .offset = offsetof(struct PlannerInfo, ec_merging_done), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "canon_pathkeys", .fieldtype = "struct List *", .offset = offsetof(struct PlannerInfo, canon_pathkeys), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "left_join_clauses", .fieldtype = "struct List *", .offset = offsetof(struct PlannerInfo, left_join_clauses), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "right_join_clauses", .fieldtype = "struct List *", .offset = offsetof(struct PlannerInfo, right_join_clauses), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "full_join_clauses", .fieldtype = "struct List *", .offset = offsetof(struct PlannerInfo, full_join_clauses), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "join_info_list", .fieldtype = "struct List *", .offset = offsetof(struct PlannerInfo, join_info_list), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "append_rel_list", .fieldtype = "struct List *", .offset = offsetof(struct PlannerInfo, append_rel_list), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "rowMarks", .fieldtype = "struct List *", .offset = offsetof(struct PlannerInfo, rowMarks), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "placeholder_list", .fieldtype = "struct List *", .offset = offsetof(struct PlannerInfo, placeholder_list), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "fkey_list", .fieldtype = "struct List *", .offset = offsetof(struct PlannerInfo, fkey_list), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "query_pathkeys", .fieldtype = "struct List *", .offset = offsetof(struct PlannerInfo, query_pathkeys), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "group_pathkeys", .fieldtype = "struct List *", .offset = offsetof(struct PlannerInfo, group_pathkeys), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "window_pathkeys", .fieldtype = "struct List *", .offset = offsetof(struct PlannerInfo, window_pathkeys), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "distinct_pathkeys", .fieldtype = "struct List *", .offset = offsetof(struct PlannerInfo, distinct_pathkeys), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "sort_pathkeys", .fieldtype = "struct List *", .offset = offsetof(struct PlannerInfo, sort_pathkeys), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "part_schemes", .fieldtype = "struct List *", .offset = offsetof(struct PlannerInfo, part_schemes), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "initial_rels", .fieldtype = "struct List *", .offset = offsetof(struct PlannerInfo, initial_rels), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "upper_rels", .fieldtype = "struct List *[7]", .offset = offsetof(struct PlannerInfo, upper_rels), .size = sizeof(struct List *[7]), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "upper_targets", .fieldtype = "struct PathTarget *[7]", .offset = offsetof(struct PlannerInfo, upper_targets), .size = sizeof(struct PathTarget *[7]), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "processed_tlist", .fieldtype = "struct List *", .offset = offsetof(struct PlannerInfo, processed_tlist), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "grouping_map", .fieldtype = "short *", .offset = offsetof(struct PlannerInfo, grouping_map), .size = sizeof(short *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "minmax_aggs", .fieldtype = "struct List *", .offset = offsetof(struct PlannerInfo, minmax_aggs), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "planner_cxt", .fieldtype = "struct MemoryContextData *", .offset = offsetof(struct PlannerInfo, planner_cxt), .size = sizeof(struct MemoryContextData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "total_table_pages", .fieldtype = "double", .offset = offsetof(struct PlannerInfo, total_table_pages), .size = sizeof(double), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "tuple_fraction", .fieldtype = "double", .offset = offsetof(struct PlannerInfo, tuple_fraction), .size = sizeof(double), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "limit_tuples", .fieldtype = "double", .offset = offsetof(struct PlannerInfo, limit_tuples), .size = sizeof(double), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "qual_security_level", .fieldtype = "unsigned int", .offset = offsetof(struct PlannerInfo, qual_security_level), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "inhTargetKind", .fieldtype = "enum InheritanceKind", .offset = offsetof(struct PlannerInfo, inhTargetKind), .size = sizeof(enum InheritanceKind), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "hasJoinRTEs", .fieldtype = "_Bool", .offset = offsetof(struct PlannerInfo, hasJoinRTEs), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "hasLateralRTEs", .fieldtype = "_Bool", .offset = offsetof(struct PlannerInfo, hasLateralRTEs), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "hasHavingQual", .fieldtype = "_Bool", .offset = offsetof(struct PlannerInfo, hasHavingQual), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "hasPseudoConstantQuals", .fieldtype = "_Bool", .offset = offsetof(struct PlannerInfo, hasPseudoConstantQuals), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "hasRecursion", .fieldtype = "_Bool", .offset = offsetof(struct PlannerInfo, hasRecursion), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "wt_param_id", .fieldtype = "int", .offset = offsetof(struct PlannerInfo, wt_param_id), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "non_recursive_path", .fieldtype = "struct Path *", .offset = offsetof(struct PlannerInfo, non_recursive_path), .size = sizeof(struct Path *), .flags = TYPE_CAT_POINTER, .node_type_id = 165, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "curOuterRels", .fieldtype = "struct Bitmapset *", .offset = offsetof(struct PlannerInfo, curOuterRels), .size = sizeof(struct Bitmapset *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_BITMAPSET},
+	{.fieldname = "curOuterParams", .fieldtype = "struct List *", .offset = offsetof(struct PlannerInfo, curOuterParams), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "join_search_private", .fieldtype = "void *", .offset = offsetof(struct PlannerInfo, join_search_private), .size = sizeof(void *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "partColsUpdated", .fieldtype = "_Bool", .offset = offsetof(struct PlannerInfo, partColsUpdated), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct RelOptInfo, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "reloptkind", .fieldtype = "enum RelOptKind", .offset = offsetof(struct RelOptInfo, reloptkind), .size = sizeof(enum RelOptKind), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "relids", .fieldtype = "struct Bitmapset *", .offset = offsetof(struct RelOptInfo, relids), .size = sizeof(struct Bitmapset *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_BITMAPSET},
+	{.fieldname = "rows", .fieldtype = "double", .offset = offsetof(struct RelOptInfo, rows), .size = sizeof(double), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "consider_startup", .fieldtype = "_Bool", .offset = offsetof(struct RelOptInfo, consider_startup), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "consider_param_startup", .fieldtype = "_Bool", .offset = offsetof(struct RelOptInfo, consider_param_startup), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "consider_parallel", .fieldtype = "_Bool", .offset = offsetof(struct RelOptInfo, consider_parallel), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "reltarget", .fieldtype = "struct PathTarget *", .offset = offsetof(struct RelOptInfo, reltarget), .size = sizeof(struct PathTarget *), .flags = TYPE_CAT_POINTER, .node_type_id = 201, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "pathlist", .fieldtype = "struct List *", .offset = offsetof(struct RelOptInfo, pathlist), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ppilist", .fieldtype = "struct List *", .offset = offsetof(struct RelOptInfo, ppilist), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "partial_pathlist", .fieldtype = "struct List *", .offset = offsetof(struct RelOptInfo, partial_pathlist), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "cheapest_startup_path", .fieldtype = "struct Path *", .offset = offsetof(struct RelOptInfo, cheapest_startup_path), .size = sizeof(struct Path *), .flags = TYPE_CAT_POINTER, .node_type_id = 165, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "cheapest_total_path", .fieldtype = "struct Path *", .offset = offsetof(struct RelOptInfo, cheapest_total_path), .size = sizeof(struct Path *), .flags = TYPE_CAT_POINTER, .node_type_id = 165, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "cheapest_unique_path", .fieldtype = "struct Path *", .offset = offsetof(struct RelOptInfo, cheapest_unique_path), .size = sizeof(struct Path *), .flags = TYPE_CAT_POINTER, .node_type_id = 165, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "cheapest_parameterized_paths", .fieldtype = "struct List *", .offset = offsetof(struct RelOptInfo, cheapest_parameterized_paths), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "direct_lateral_relids", .fieldtype = "struct Bitmapset *", .offset = offsetof(struct RelOptInfo, direct_lateral_relids), .size = sizeof(struct Bitmapset *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_BITMAPSET},
+	{.fieldname = "lateral_relids", .fieldtype = "struct Bitmapset *", .offset = offsetof(struct RelOptInfo, lateral_relids), .size = sizeof(struct Bitmapset *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_BITMAPSET},
+	{.fieldname = "relid", .fieldtype = "unsigned int", .offset = offsetof(struct RelOptInfo, relid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "reltablespace", .fieldtype = "unsigned int", .offset = offsetof(struct RelOptInfo, reltablespace), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "rtekind", .fieldtype = "enum RTEKind", .offset = offsetof(struct RelOptInfo, rtekind), .size = sizeof(enum RTEKind), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "min_attr", .fieldtype = "short", .offset = offsetof(struct RelOptInfo, min_attr), .size = sizeof(short), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "max_attr", .fieldtype = "short", .offset = offsetof(struct RelOptInfo, max_attr), .size = sizeof(short), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "attr_needed", .fieldtype = "struct Bitmapset **", .offset = offsetof(struct RelOptInfo, attr_needed), .size = sizeof(struct Bitmapset **), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "attr_widths", .fieldtype = "int *", .offset = offsetof(struct RelOptInfo, attr_widths), .size = sizeof(int *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "lateral_vars", .fieldtype = "struct List *", .offset = offsetof(struct RelOptInfo, lateral_vars), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "lateral_referencers", .fieldtype = "struct Bitmapset *", .offset = offsetof(struct RelOptInfo, lateral_referencers), .size = sizeof(struct Bitmapset *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_BITMAPSET},
+	{.fieldname = "indexlist", .fieldtype = "struct List *", .offset = offsetof(struct RelOptInfo, indexlist), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "statlist", .fieldtype = "struct List *", .offset = offsetof(struct RelOptInfo, statlist), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "pages", .fieldtype = "unsigned int", .offset = offsetof(struct RelOptInfo, pages), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "tuples", .fieldtype = "double", .offset = offsetof(struct RelOptInfo, tuples), .size = sizeof(double), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "allvisfrac", .fieldtype = "double", .offset = offsetof(struct RelOptInfo, allvisfrac), .size = sizeof(double), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "eclass_indexes", .fieldtype = "struct Bitmapset *", .offset = offsetof(struct RelOptInfo, eclass_indexes), .size = sizeof(struct Bitmapset *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_BITMAPSET},
+	{.fieldname = "subroot", .fieldtype = "struct PlannerInfo *", .offset = offsetof(struct RelOptInfo, subroot), .size = sizeof(struct PlannerInfo *), .flags = TYPE_CAT_POINTER, .node_type_id = 159, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "subplan_params", .fieldtype = "struct List *", .offset = offsetof(struct RelOptInfo, subplan_params), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "rel_parallel_workers", .fieldtype = "int", .offset = offsetof(struct RelOptInfo, rel_parallel_workers), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "serverid", .fieldtype = "unsigned int", .offset = offsetof(struct RelOptInfo, serverid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "userid", .fieldtype = "unsigned int", .offset = offsetof(struct RelOptInfo, userid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "useridiscurrent", .fieldtype = "_Bool", .offset = offsetof(struct RelOptInfo, useridiscurrent), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "fdwroutine", .fieldtype = "struct FdwRoutine *", .offset = offsetof(struct RelOptInfo, fdwroutine), .size = sizeof(struct FdwRoutine *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "fdw_private", .fieldtype = "void *", .offset = offsetof(struct RelOptInfo, fdw_private), .size = sizeof(void *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "unique_for_rels", .fieldtype = "struct List *", .offset = offsetof(struct RelOptInfo, unique_for_rels), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "non_unique_for_rels", .fieldtype = "struct List *", .offset = offsetof(struct RelOptInfo, non_unique_for_rels), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "baserestrictinfo", .fieldtype = "struct List *", .offset = offsetof(struct RelOptInfo, baserestrictinfo), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "baserestrictcost", .fieldtype = "struct QualCost", .offset = offsetof(struct RelOptInfo, baserestrictcost), .size = sizeof(struct QualCost), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "baserestrict_min_security", .fieldtype = "unsigned int", .offset = offsetof(struct RelOptInfo, baserestrict_min_security), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "joininfo", .fieldtype = "struct List *", .offset = offsetof(struct RelOptInfo, joininfo), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "has_eclass_joins", .fieldtype = "_Bool", .offset = offsetof(struct RelOptInfo, has_eclass_joins), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "consider_partitionwise_join", .fieldtype = "_Bool", .offset = offsetof(struct RelOptInfo, consider_partitionwise_join), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "top_parent_relids", .fieldtype = "struct Bitmapset *", .offset = offsetof(struct RelOptInfo, top_parent_relids), .size = sizeof(struct Bitmapset *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_BITMAPSET},
+	{.fieldname = "part_scheme", .fieldtype = "struct PartitionSchemeData *", .offset = offsetof(struct RelOptInfo, part_scheme), .size = sizeof(struct PartitionSchemeData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "nparts", .fieldtype = "int", .offset = offsetof(struct RelOptInfo, nparts), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "boundinfo", .fieldtype = "struct PartitionBoundInfoData *", .offset = offsetof(struct RelOptInfo, boundinfo), .size = sizeof(struct PartitionBoundInfoData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "partition_qual", .fieldtype = "struct List *", .offset = offsetof(struct RelOptInfo, partition_qual), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "part_rels", .fieldtype = "struct RelOptInfo **", .offset = offsetof(struct RelOptInfo, part_rels), .size = sizeof(struct RelOptInfo **), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "partexprs", .fieldtype = "struct List **", .offset = offsetof(struct RelOptInfo, partexprs), .size = sizeof(struct List **), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "nullable_partexprs", .fieldtype = "struct List **", .offset = offsetof(struct RelOptInfo, nullable_partexprs), .size = sizeof(struct List **), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "partitioned_child_rels", .fieldtype = "struct List *", .offset = offsetof(struct RelOptInfo, partitioned_child_rels), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct IndexOptInfo, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "indexoid", .fieldtype = "unsigned int", .offset = offsetof(struct IndexOptInfo, indexoid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "reltablespace", .fieldtype = "unsigned int", .offset = offsetof(struct IndexOptInfo, reltablespace), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "rel", .fieldtype = "struct RelOptInfo *", .offset = offsetof(struct IndexOptInfo, rel), .size = sizeof(struct RelOptInfo *), .flags = TYPE_CAT_POINTER, .node_type_id = 161, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "pages", .fieldtype = "unsigned int", .offset = offsetof(struct IndexOptInfo, pages), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "tuples", .fieldtype = "double", .offset = offsetof(struct IndexOptInfo, tuples), .size = sizeof(double), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "tree_height", .fieldtype = "int", .offset = offsetof(struct IndexOptInfo, tree_height), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ncolumns", .fieldtype = "int", .offset = offsetof(struct IndexOptInfo, ncolumns), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "nkeycolumns", .fieldtype = "int", .offset = offsetof(struct IndexOptInfo, nkeycolumns), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "indexkeys", .fieldtype = "int *", .offset = offsetof(struct IndexOptInfo, indexkeys), .size = sizeof(int *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "indexcollations", .fieldtype = "unsigned int *", .offset = offsetof(struct IndexOptInfo, indexcollations), .size = sizeof(unsigned int *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "opfamily", .fieldtype = "unsigned int *", .offset = offsetof(struct IndexOptInfo, opfamily), .size = sizeof(unsigned int *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "opcintype", .fieldtype = "unsigned int *", .offset = offsetof(struct IndexOptInfo, opcintype), .size = sizeof(unsigned int *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "sortopfamily", .fieldtype = "unsigned int *", .offset = offsetof(struct IndexOptInfo, sortopfamily), .size = sizeof(unsigned int *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "reverse_sort", .fieldtype = "_Bool *", .offset = offsetof(struct IndexOptInfo, reverse_sort), .size = sizeof(_Bool *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "nulls_first", .fieldtype = "_Bool *", .offset = offsetof(struct IndexOptInfo, nulls_first), .size = sizeof(_Bool *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "canreturn", .fieldtype = "_Bool *", .offset = offsetof(struct IndexOptInfo, canreturn), .size = sizeof(_Bool *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "relam", .fieldtype = "unsigned int", .offset = offsetof(struct IndexOptInfo, relam), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "indexprs", .fieldtype = "struct List *", .offset = offsetof(struct IndexOptInfo, indexprs), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "indpred", .fieldtype = "struct List *", .offset = offsetof(struct IndexOptInfo, indpred), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "indextlist", .fieldtype = "struct List *", .offset = offsetof(struct IndexOptInfo, indextlist), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "indrestrictinfo", .fieldtype = "struct List *", .offset = offsetof(struct IndexOptInfo, indrestrictinfo), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "predOK", .fieldtype = "_Bool", .offset = offsetof(struct IndexOptInfo, predOK), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "unique", .fieldtype = "_Bool", .offset = offsetof(struct IndexOptInfo, unique), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "immediate", .fieldtype = "_Bool", .offset = offsetof(struct IndexOptInfo, immediate), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "hypothetical", .fieldtype = "_Bool", .offset = offsetof(struct IndexOptInfo, hypothetical), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "amcanorderbyop", .fieldtype = "_Bool", .offset = offsetof(struct IndexOptInfo, amcanorderbyop), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "amoptionalkey", .fieldtype = "_Bool", .offset = offsetof(struct IndexOptInfo, amoptionalkey), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "amsearcharray", .fieldtype = "_Bool", .offset = offsetof(struct IndexOptInfo, amsearcharray), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "amsearchnulls", .fieldtype = "_Bool", .offset = offsetof(struct IndexOptInfo, amsearchnulls), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "amhasgettuple", .fieldtype = "_Bool", .offset = offsetof(struct IndexOptInfo, amhasgettuple), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "amhasgetbitmap", .fieldtype = "_Bool", .offset = offsetof(struct IndexOptInfo, amhasgetbitmap), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "amcanparallel", .fieldtype = "_Bool", .offset = offsetof(struct IndexOptInfo, amcanparallel), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "amcostestimate", .fieldtype = "void (*)()", .offset = offsetof(struct IndexOptInfo, amcostestimate), .size = sizeof(void (*)()), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct ForeignKeyOptInfo, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "con_relid", .fieldtype = "unsigned int", .offset = offsetof(struct ForeignKeyOptInfo, con_relid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ref_relid", .fieldtype = "unsigned int", .offset = offsetof(struct ForeignKeyOptInfo, ref_relid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "nkeys", .fieldtype = "int", .offset = offsetof(struct ForeignKeyOptInfo, nkeys), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "conkey", .fieldtype = "short [32]", .offset = offsetof(struct ForeignKeyOptInfo, conkey), .size = sizeof(short [32]), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "confkey", .fieldtype = "short [32]", .offset = offsetof(struct ForeignKeyOptInfo, confkey), .size = sizeof(short [32]), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "conpfeqop", .fieldtype = "unsigned int [32]", .offset = offsetof(struct ForeignKeyOptInfo, conpfeqop), .size = sizeof(unsigned int [32]), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "nmatched_ec", .fieldtype = "int", .offset = offsetof(struct ForeignKeyOptInfo, nmatched_ec), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "nmatched_rcols", .fieldtype = "int", .offset = offsetof(struct ForeignKeyOptInfo, nmatched_rcols), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "nmatched_ri", .fieldtype = "int", .offset = offsetof(struct ForeignKeyOptInfo, nmatched_ri), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "eclass", .fieldtype = "struct EquivalenceClass *[32]", .offset = offsetof(struct ForeignKeyOptInfo, eclass), .size = sizeof(struct EquivalenceClass *[32]), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "rinfos", .fieldtype = "struct List *[32]", .offset = offsetof(struct ForeignKeyOptInfo, rinfos), .size = sizeof(struct List *[32]), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct StatisticExtInfo, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "statOid", .fieldtype = "unsigned int", .offset = offsetof(struct StatisticExtInfo, statOid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "rel", .fieldtype = "struct RelOptInfo *", .offset = offsetof(struct StatisticExtInfo, rel), .size = sizeof(struct RelOptInfo *), .flags = TYPE_CAT_POINTER, .node_type_id = 161, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "kind", .fieldtype = "char", .offset = offsetof(struct StatisticExtInfo, kind), .size = sizeof(char), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "keys", .fieldtype = "struct Bitmapset *", .offset = offsetof(struct StatisticExtInfo, keys), .size = sizeof(struct Bitmapset *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_BITMAPSET},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct EquivalenceClass, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ec_opfamilies", .fieldtype = "struct List *", .offset = offsetof(struct EquivalenceClass, ec_opfamilies), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ec_collation", .fieldtype = "unsigned int", .offset = offsetof(struct EquivalenceClass, ec_collation), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ec_members", .fieldtype = "struct List *", .offset = offsetof(struct EquivalenceClass, ec_members), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ec_sources", .fieldtype = "struct List *", .offset = offsetof(struct EquivalenceClass, ec_sources), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ec_derives", .fieldtype = "struct List *", .offset = offsetof(struct EquivalenceClass, ec_derives), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ec_relids", .fieldtype = "struct Bitmapset *", .offset = offsetof(struct EquivalenceClass, ec_relids), .size = sizeof(struct Bitmapset *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_BITMAPSET},
+	{.fieldname = "ec_has_const", .fieldtype = "_Bool", .offset = offsetof(struct EquivalenceClass, ec_has_const), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ec_has_volatile", .fieldtype = "_Bool", .offset = offsetof(struct EquivalenceClass, ec_has_volatile), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ec_below_outer_join", .fieldtype = "_Bool", .offset = offsetof(struct EquivalenceClass, ec_below_outer_join), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ec_broken", .fieldtype = "_Bool", .offset = offsetof(struct EquivalenceClass, ec_broken), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ec_sortref", .fieldtype = "unsigned int", .offset = offsetof(struct EquivalenceClass, ec_sortref), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ec_min_security", .fieldtype = "unsigned int", .offset = offsetof(struct EquivalenceClass, ec_min_security), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ec_max_security", .fieldtype = "unsigned int", .offset = offsetof(struct EquivalenceClass, ec_max_security), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ec_merged", .fieldtype = "struct EquivalenceClass *", .offset = offsetof(struct EquivalenceClass, ec_merged), .size = sizeof(struct EquivalenceClass *), .flags = TYPE_CAT_POINTER, .node_type_id = 198, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct EquivalenceMember, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "em_expr", .fieldtype = "struct Expr *", .offset = offsetof(struct EquivalenceMember, em_expr), .size = sizeof(struct Expr *), .flags = TYPE_CAT_POINTER, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "em_relids", .fieldtype = "struct Bitmapset *", .offset = offsetof(struct EquivalenceMember, em_relids), .size = sizeof(struct Bitmapset *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_BITMAPSET},
+	{.fieldname = "em_nullable_relids", .fieldtype = "struct Bitmapset *", .offset = offsetof(struct EquivalenceMember, em_nullable_relids), .size = sizeof(struct Bitmapset *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_BITMAPSET},
+	{.fieldname = "em_is_const", .fieldtype = "_Bool", .offset = offsetof(struct EquivalenceMember, em_is_const), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "em_is_child", .fieldtype = "_Bool", .offset = offsetof(struct EquivalenceMember, em_is_child), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "em_datatype", .fieldtype = "unsigned int", .offset = offsetof(struct EquivalenceMember, em_datatype), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct PathKey, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "pk_eclass", .fieldtype = "struct EquivalenceClass *", .offset = offsetof(struct PathKey, pk_eclass), .size = sizeof(struct EquivalenceClass *), .flags = TYPE_CAT_POINTER, .node_type_id = 198, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "pk_opfamily", .fieldtype = "unsigned int", .offset = offsetof(struct PathKey, pk_opfamily), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "pk_strategy", .fieldtype = "int", .offset = offsetof(struct PathKey, pk_strategy), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "pk_nulls_first", .fieldtype = "_Bool", .offset = offsetof(struct PathKey, pk_nulls_first), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct PathTarget, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "exprs", .fieldtype = "struct List *", .offset = offsetof(struct PathTarget, exprs), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "sortgrouprefs", .fieldtype = "unsigned int *", .offset = offsetof(struct PathTarget, sortgrouprefs), .size = sizeof(unsigned int *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "cost", .fieldtype = "struct QualCost", .offset = offsetof(struct PathTarget, cost), .size = sizeof(struct QualCost), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "width", .fieldtype = "int", .offset = offsetof(struct PathTarget, width), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct ParamPathInfo, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ppi_req_outer", .fieldtype = "struct Bitmapset *", .offset = offsetof(struct ParamPathInfo, ppi_req_outer), .size = sizeof(struct Bitmapset *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_BITMAPSET},
+	{.fieldname = "ppi_rows", .fieldtype = "double", .offset = offsetof(struct ParamPathInfo, ppi_rows), .size = sizeof(double), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ppi_clauses", .fieldtype = "struct List *", .offset = offsetof(struct ParamPathInfo, ppi_clauses), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct Path, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "pathtype", .fieldtype = "enum NodeTag", .offset = offsetof(struct Path, pathtype), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "parent", .fieldtype = "struct RelOptInfo *", .offset = offsetof(struct Path, parent), .size = sizeof(struct RelOptInfo *), .flags = TYPE_CAT_POINTER, .node_type_id = 161, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "pathtarget", .fieldtype = "struct PathTarget *", .offset = offsetof(struct Path, pathtarget), .size = sizeof(struct PathTarget *), .flags = TYPE_CAT_POINTER, .node_type_id = 201, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "param_info", .fieldtype = "struct ParamPathInfo *", .offset = offsetof(struct Path, param_info), .size = sizeof(struct ParamPathInfo *), .flags = TYPE_CAT_POINTER, .node_type_id = 164, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "parallel_aware", .fieldtype = "_Bool", .offset = offsetof(struct Path, parallel_aware), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "parallel_safe", .fieldtype = "_Bool", .offset = offsetof(struct Path, parallel_safe), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "parallel_workers", .fieldtype = "int", .offset = offsetof(struct Path, parallel_workers), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "rows", .fieldtype = "double", .offset = offsetof(struct Path, rows), .size = sizeof(double), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "startup_cost", .fieldtype = "double", .offset = offsetof(struct Path, startup_cost), .size = sizeof(double), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "total_cost", .fieldtype = "double", .offset = offsetof(struct Path, total_cost), .size = sizeof(double), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "pathkeys", .fieldtype = "struct List *", .offset = offsetof(struct Path, pathkeys), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "path", .fieldtype = "struct Path", .offset = offsetof(struct IndexPath, path), .size = sizeof(struct Path), .flags = TYPE_CAT_SCALAR, .node_type_id = 165, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "indexinfo", .fieldtype = "struct IndexOptInfo *", .offset = offsetof(struct IndexPath, indexinfo), .size = sizeof(struct IndexOptInfo *), .flags = TYPE_CAT_POINTER, .node_type_id = 162, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "indexclauses", .fieldtype = "struct List *", .offset = offsetof(struct IndexPath, indexclauses), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "indexorderbys", .fieldtype = "struct List *", .offset = offsetof(struct IndexPath, indexorderbys), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "indexorderbycols", .fieldtype = "struct List *", .offset = offsetof(struct IndexPath, indexorderbycols), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "indexscandir", .fieldtype = "enum ScanDirection", .offset = offsetof(struct IndexPath, indexscandir), .size = sizeof(enum ScanDirection), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "indextotalcost", .fieldtype = "double", .offset = offsetof(struct IndexPath, indextotalcost), .size = sizeof(double), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "indexselectivity", .fieldtype = "double", .offset = offsetof(struct IndexPath, indexselectivity), .size = sizeof(double), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct IndexClause, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "rinfo", .fieldtype = "struct RestrictInfo *", .offset = offsetof(struct IndexClause, rinfo), .size = sizeof(struct RestrictInfo *), .flags = TYPE_CAT_POINTER, .node_type_id = 202, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "indexquals", .fieldtype = "struct List *", .offset = offsetof(struct IndexClause, indexquals), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "lossy", .fieldtype = "_Bool", .offset = offsetof(struct IndexClause, lossy), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "indexcol", .fieldtype = "short", .offset = offsetof(struct IndexClause, indexcol), .size = sizeof(short), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "indexcols", .fieldtype = "struct List *", .offset = offsetof(struct IndexClause, indexcols), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "path", .fieldtype = "struct Path", .offset = offsetof(struct BitmapHeapPath, path), .size = sizeof(struct Path), .flags = TYPE_CAT_SCALAR, .node_type_id = 165, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "bitmapqual", .fieldtype = "struct Path *", .offset = offsetof(struct BitmapHeapPath, bitmapqual), .size = sizeof(struct Path *), .flags = TYPE_CAT_POINTER, .node_type_id = 165, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "path", .fieldtype = "struct Path", .offset = offsetof(struct BitmapAndPath, path), .size = sizeof(struct Path), .flags = TYPE_CAT_SCALAR, .node_type_id = 165, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "bitmapquals", .fieldtype = "struct List *", .offset = offsetof(struct BitmapAndPath, bitmapquals), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "bitmapselectivity", .fieldtype = "double", .offset = offsetof(struct BitmapAndPath, bitmapselectivity), .size = sizeof(double), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "path", .fieldtype = "struct Path", .offset = offsetof(struct BitmapOrPath, path), .size = sizeof(struct Path), .flags = TYPE_CAT_SCALAR, .node_type_id = 165, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "bitmapquals", .fieldtype = "struct List *", .offset = offsetof(struct BitmapOrPath, bitmapquals), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "bitmapselectivity", .fieldtype = "double", .offset = offsetof(struct BitmapOrPath, bitmapselectivity), .size = sizeof(double), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "path", .fieldtype = "struct Path", .offset = offsetof(struct TidPath, path), .size = sizeof(struct Path), .flags = TYPE_CAT_SCALAR, .node_type_id = 165, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "tidquals", .fieldtype = "struct List *", .offset = offsetof(struct TidPath, tidquals), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "path", .fieldtype = "struct Path", .offset = offsetof(struct SubqueryScanPath, path), .size = sizeof(struct Path), .flags = TYPE_CAT_SCALAR, .node_type_id = 165, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "subpath", .fieldtype = "struct Path *", .offset = offsetof(struct SubqueryScanPath, subpath), .size = sizeof(struct Path *), .flags = TYPE_CAT_POINTER, .node_type_id = 165, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "path", .fieldtype = "struct Path", .offset = offsetof(struct ForeignPath, path), .size = sizeof(struct Path), .flags = TYPE_CAT_SCALAR, .node_type_id = 165, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "fdw_outerpath", .fieldtype = "struct Path *", .offset = offsetof(struct ForeignPath, fdw_outerpath), .size = sizeof(struct Path *), .flags = TYPE_CAT_POINTER, .node_type_id = 165, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "fdw_private", .fieldtype = "struct List *", .offset = offsetof(struct ForeignPath, fdw_private), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "path", .fieldtype = "struct Path", .offset = offsetof(struct CustomPath, path), .size = sizeof(struct Path), .flags = TYPE_CAT_SCALAR, .node_type_id = 165, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "flags", .fieldtype = "unsigned int", .offset = offsetof(struct CustomPath, flags), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "custom_paths", .fieldtype = "struct List *", .offset = offsetof(struct CustomPath, custom_paths), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "custom_private", .fieldtype = "struct List *", .offset = offsetof(struct CustomPath, custom_private), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "methods", .fieldtype = "const struct CustomPathMethods *", .offset = offsetof(struct CustomPath, methods), .size = sizeof(const struct CustomPathMethods *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "path", .fieldtype = "struct Path", .offset = offsetof(struct AppendPath, path), .size = sizeof(struct Path), .flags = TYPE_CAT_SCALAR, .node_type_id = 165, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "partitioned_rels", .fieldtype = "struct List *", .offset = offsetof(struct AppendPath, partitioned_rels), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "subpaths", .fieldtype = "struct List *", .offset = offsetof(struct AppendPath, subpaths), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "first_partial_path", .fieldtype = "int", .offset = offsetof(struct AppendPath, first_partial_path), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "limit_tuples", .fieldtype = "double", .offset = offsetof(struct AppendPath, limit_tuples), .size = sizeof(double), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "path", .fieldtype = "struct Path", .offset = offsetof(struct MergeAppendPath, path), .size = sizeof(struct Path), .flags = TYPE_CAT_SCALAR, .node_type_id = 165, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "partitioned_rels", .fieldtype = "struct List *", .offset = offsetof(struct MergeAppendPath, partitioned_rels), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "subpaths", .fieldtype = "struct List *", .offset = offsetof(struct MergeAppendPath, subpaths), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "limit_tuples", .fieldtype = "double", .offset = offsetof(struct MergeAppendPath, limit_tuples), .size = sizeof(double), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "path", .fieldtype = "struct Path", .offset = offsetof(struct GroupResultPath, path), .size = sizeof(struct Path), .flags = TYPE_CAT_SCALAR, .node_type_id = 165, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "quals", .fieldtype = "struct List *", .offset = offsetof(struct GroupResultPath, quals), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "path", .fieldtype = "struct Path", .offset = offsetof(struct MaterialPath, path), .size = sizeof(struct Path), .flags = TYPE_CAT_SCALAR, .node_type_id = 165, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "subpath", .fieldtype = "struct Path *", .offset = offsetof(struct MaterialPath, subpath), .size = sizeof(struct Path *), .flags = TYPE_CAT_POINTER, .node_type_id = 165, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "path", .fieldtype = "struct Path", .offset = offsetof(struct UniquePath, path), .size = sizeof(struct Path), .flags = TYPE_CAT_SCALAR, .node_type_id = 165, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "subpath", .fieldtype = "struct Path *", .offset = offsetof(struct UniquePath, subpath), .size = sizeof(struct Path *), .flags = TYPE_CAT_POINTER, .node_type_id = 165, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "umethod", .fieldtype = "UniquePathMethod", .offset = offsetof(struct UniquePath, umethod), .size = sizeof(UniquePathMethod), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "in_operators", .fieldtype = "struct List *", .offset = offsetof(struct UniquePath, in_operators), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "uniq_exprs", .fieldtype = "struct List *", .offset = offsetof(struct UniquePath, uniq_exprs), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "path", .fieldtype = "struct Path", .offset = offsetof(struct GatherPath, path), .size = sizeof(struct Path), .flags = TYPE_CAT_SCALAR, .node_type_id = 165, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "subpath", .fieldtype = "struct Path *", .offset = offsetof(struct GatherPath, subpath), .size = sizeof(struct Path *), .flags = TYPE_CAT_POINTER, .node_type_id = 165, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "single_copy", .fieldtype = "_Bool", .offset = offsetof(struct GatherPath, single_copy), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "num_workers", .fieldtype = "int", .offset = offsetof(struct GatherPath, num_workers), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "path", .fieldtype = "struct Path", .offset = offsetof(struct GatherMergePath, path), .size = sizeof(struct Path), .flags = TYPE_CAT_SCALAR, .node_type_id = 165, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "subpath", .fieldtype = "struct Path *", .offset = offsetof(struct GatherMergePath, subpath), .size = sizeof(struct Path *), .flags = TYPE_CAT_POINTER, .node_type_id = 165, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "num_workers", .fieldtype = "int", .offset = offsetof(struct GatherMergePath, num_workers), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "path", .fieldtype = "struct Path", .offset = offsetof(struct JoinPath, path), .size = sizeof(struct Path), .flags = TYPE_CAT_SCALAR, .node_type_id = 165, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "jointype", .fieldtype = "enum JoinType", .offset = offsetof(struct JoinPath, jointype), .size = sizeof(enum JoinType), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "inner_unique", .fieldtype = "_Bool", .offset = offsetof(struct JoinPath, inner_unique), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "outerjoinpath", .fieldtype = "struct Path *", .offset = offsetof(struct JoinPath, outerjoinpath), .size = sizeof(struct Path *), .flags = TYPE_CAT_POINTER, .node_type_id = 165, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "innerjoinpath", .fieldtype = "struct Path *", .offset = offsetof(struct JoinPath, innerjoinpath), .size = sizeof(struct Path *), .flags = TYPE_CAT_POINTER, .node_type_id = 165, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "joinrestrictinfo", .fieldtype = "struct List *", .offset = offsetof(struct JoinPath, joinrestrictinfo), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "jpath", .fieldtype = "struct JoinPath", .offset = offsetof(struct MergePath, jpath), .size = sizeof(struct JoinPath), .flags = TYPE_CAT_SCALAR, .node_type_id = 174, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "path_mergeclauses", .fieldtype = "struct List *", .offset = offsetof(struct MergePath, path_mergeclauses), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "outersortkeys", .fieldtype = "struct List *", .offset = offsetof(struct MergePath, outersortkeys), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "innersortkeys", .fieldtype = "struct List *", .offset = offsetof(struct MergePath, innersortkeys), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "skip_mark_restore", .fieldtype = "_Bool", .offset = offsetof(struct MergePath, skip_mark_restore), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "materialize_inner", .fieldtype = "_Bool", .offset = offsetof(struct MergePath, materialize_inner), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "jpath", .fieldtype = "struct JoinPath", .offset = offsetof(struct HashPath, jpath), .size = sizeof(struct JoinPath), .flags = TYPE_CAT_SCALAR, .node_type_id = 174, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "path_hashclauses", .fieldtype = "struct List *", .offset = offsetof(struct HashPath, path_hashclauses), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "num_batches", .fieldtype = "int", .offset = offsetof(struct HashPath, num_batches), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "inner_rows_total", .fieldtype = "double", .offset = offsetof(struct HashPath, inner_rows_total), .size = sizeof(double), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "path", .fieldtype = "struct Path", .offset = offsetof(struct ProjectionPath, path), .size = sizeof(struct Path), .flags = TYPE_CAT_SCALAR, .node_type_id = 165, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "subpath", .fieldtype = "struct Path *", .offset = offsetof(struct ProjectionPath, subpath), .size = sizeof(struct Path *), .flags = TYPE_CAT_POINTER, .node_type_id = 165, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "dummypp", .fieldtype = "_Bool", .offset = offsetof(struct ProjectionPath, dummypp), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "path", .fieldtype = "struct Path", .offset = offsetof(struct ProjectSetPath, path), .size = sizeof(struct Path), .flags = TYPE_CAT_SCALAR, .node_type_id = 165, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "subpath", .fieldtype = "struct Path *", .offset = offsetof(struct ProjectSetPath, subpath), .size = sizeof(struct Path *), .flags = TYPE_CAT_POINTER, .node_type_id = 165, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "path", .fieldtype = "struct Path", .offset = offsetof(struct SortPath, path), .size = sizeof(struct Path), .flags = TYPE_CAT_SCALAR, .node_type_id = 165, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "subpath", .fieldtype = "struct Path *", .offset = offsetof(struct SortPath, subpath), .size = sizeof(struct Path *), .flags = TYPE_CAT_POINTER, .node_type_id = 165, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "path", .fieldtype = "struct Path", .offset = offsetof(struct GroupPath, path), .size = sizeof(struct Path), .flags = TYPE_CAT_SCALAR, .node_type_id = 165, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "subpath", .fieldtype = "struct Path *", .offset = offsetof(struct GroupPath, subpath), .size = sizeof(struct Path *), .flags = TYPE_CAT_POINTER, .node_type_id = 165, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "groupClause", .fieldtype = "struct List *", .offset = offsetof(struct GroupPath, groupClause), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "qual", .fieldtype = "struct List *", .offset = offsetof(struct GroupPath, qual), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "path", .fieldtype = "struct Path", .offset = offsetof(struct UpperUniquePath, path), .size = sizeof(struct Path), .flags = TYPE_CAT_SCALAR, .node_type_id = 165, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "subpath", .fieldtype = "struct Path *", .offset = offsetof(struct UpperUniquePath, subpath), .size = sizeof(struct Path *), .flags = TYPE_CAT_POINTER, .node_type_id = 165, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "numkeys", .fieldtype = "int", .offset = offsetof(struct UpperUniquePath, numkeys), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "path", .fieldtype = "struct Path", .offset = offsetof(struct AggPath, path), .size = sizeof(struct Path), .flags = TYPE_CAT_SCALAR, .node_type_id = 165, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "subpath", .fieldtype = "struct Path *", .offset = offsetof(struct AggPath, subpath), .size = sizeof(struct Path *), .flags = TYPE_CAT_POINTER, .node_type_id = 165, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "aggstrategy", .fieldtype = "enum AggStrategy", .offset = offsetof(struct AggPath, aggstrategy), .size = sizeof(enum AggStrategy), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "aggsplit", .fieldtype = "enum AggSplit", .offset = offsetof(struct AggPath, aggsplit), .size = sizeof(enum AggSplit), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "numGroups", .fieldtype = "double", .offset = offsetof(struct AggPath, numGroups), .size = sizeof(double), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "groupClause", .fieldtype = "struct List *", .offset = offsetof(struct AggPath, groupClause), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "qual", .fieldtype = "struct List *", .offset = offsetof(struct AggPath, qual), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct GroupingSetData, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "set", .fieldtype = "struct List *", .offset = offsetof(struct GroupingSetData, set), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "numGroups", .fieldtype = "double", .offset = offsetof(struct GroupingSetData, numGroups), .size = sizeof(double), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct RollupData, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "groupClause", .fieldtype = "struct List *", .offset = offsetof(struct RollupData, groupClause), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "gsets", .fieldtype = "struct List *", .offset = offsetof(struct RollupData, gsets), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "gsets_data", .fieldtype = "struct List *", .offset = offsetof(struct RollupData, gsets_data), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "numGroups", .fieldtype = "double", .offset = offsetof(struct RollupData, numGroups), .size = sizeof(double), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "hashable", .fieldtype = "_Bool", .offset = offsetof(struct RollupData, hashable), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "is_hashed", .fieldtype = "_Bool", .offset = offsetof(struct RollupData, is_hashed), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "path", .fieldtype = "struct Path", .offset = offsetof(struct GroupingSetsPath, path), .size = sizeof(struct Path), .flags = TYPE_CAT_SCALAR, .node_type_id = 165, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "subpath", .fieldtype = "struct Path *", .offset = offsetof(struct GroupingSetsPath, subpath), .size = sizeof(struct Path *), .flags = TYPE_CAT_POINTER, .node_type_id = 165, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "aggstrategy", .fieldtype = "enum AggStrategy", .offset = offsetof(struct GroupingSetsPath, aggstrategy), .size = sizeof(enum AggStrategy), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "rollups", .fieldtype = "struct List *", .offset = offsetof(struct GroupingSetsPath, rollups), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "qual", .fieldtype = "struct List *", .offset = offsetof(struct GroupingSetsPath, qual), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "path", .fieldtype = "struct Path", .offset = offsetof(struct MinMaxAggPath, path), .size = sizeof(struct Path), .flags = TYPE_CAT_SCALAR, .node_type_id = 165, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "mmaggregates", .fieldtype = "struct List *", .offset = offsetof(struct MinMaxAggPath, mmaggregates), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "quals", .fieldtype = "struct List *", .offset = offsetof(struct MinMaxAggPath, quals), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "path", .fieldtype = "struct Path", .offset = offsetof(struct WindowAggPath, path), .size = sizeof(struct Path), .flags = TYPE_CAT_SCALAR, .node_type_id = 165, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "subpath", .fieldtype = "struct Path *", .offset = offsetof(struct WindowAggPath, subpath), .size = sizeof(struct Path *), .flags = TYPE_CAT_POINTER, .node_type_id = 165, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "winclause", .fieldtype = "struct WindowClause *", .offset = offsetof(struct WindowAggPath, winclause), .size = sizeof(struct WindowClause *), .flags = TYPE_CAT_POINTER, .node_type_id = 372, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "path", .fieldtype = "struct Path", .offset = offsetof(struct SetOpPath, path), .size = sizeof(struct Path), .flags = TYPE_CAT_SCALAR, .node_type_id = 165, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "subpath", .fieldtype = "struct Path *", .offset = offsetof(struct SetOpPath, subpath), .size = sizeof(struct Path *), .flags = TYPE_CAT_POINTER, .node_type_id = 165, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "cmd", .fieldtype = "enum SetOpCmd", .offset = offsetof(struct SetOpPath, cmd), .size = sizeof(enum SetOpCmd), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "strategy", .fieldtype = "enum SetOpStrategy", .offset = offsetof(struct SetOpPath, strategy), .size = sizeof(enum SetOpStrategy), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "distinctList", .fieldtype = "struct List *", .offset = offsetof(struct SetOpPath, distinctList), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "flagColIdx", .fieldtype = "short", .offset = offsetof(struct SetOpPath, flagColIdx), .size = sizeof(short), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "firstFlag", .fieldtype = "int", .offset = offsetof(struct SetOpPath, firstFlag), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "numGroups", .fieldtype = "double", .offset = offsetof(struct SetOpPath, numGroups), .size = sizeof(double), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "path", .fieldtype = "struct Path", .offset = offsetof(struct RecursiveUnionPath, path), .size = sizeof(struct Path), .flags = TYPE_CAT_SCALAR, .node_type_id = 165, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "leftpath", .fieldtype = "struct Path *", .offset = offsetof(struct RecursiveUnionPath, leftpath), .size = sizeof(struct Path *), .flags = TYPE_CAT_POINTER, .node_type_id = 165, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "rightpath", .fieldtype = "struct Path *", .offset = offsetof(struct RecursiveUnionPath, rightpath), .size = sizeof(struct Path *), .flags = TYPE_CAT_POINTER, .node_type_id = 165, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "distinctList", .fieldtype = "struct List *", .offset = offsetof(struct RecursiveUnionPath, distinctList), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "wtParam", .fieldtype = "int", .offset = offsetof(struct RecursiveUnionPath, wtParam), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "numGroups", .fieldtype = "double", .offset = offsetof(struct RecursiveUnionPath, numGroups), .size = sizeof(double), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "path", .fieldtype = "struct Path", .offset = offsetof(struct LockRowsPath, path), .size = sizeof(struct Path), .flags = TYPE_CAT_SCALAR, .node_type_id = 165, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "subpath", .fieldtype = "struct Path *", .offset = offsetof(struct LockRowsPath, subpath), .size = sizeof(struct Path *), .flags = TYPE_CAT_POINTER, .node_type_id = 165, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "rowMarks", .fieldtype = "struct List *", .offset = offsetof(struct LockRowsPath, rowMarks), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "epqParam", .fieldtype = "int", .offset = offsetof(struct LockRowsPath, epqParam), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "path", .fieldtype = "struct Path", .offset = offsetof(struct ModifyTablePath, path), .size = sizeof(struct Path), .flags = TYPE_CAT_SCALAR, .node_type_id = 165, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "operation", .fieldtype = "enum CmdType", .offset = offsetof(struct ModifyTablePath, operation), .size = sizeof(enum CmdType), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "canSetTag", .fieldtype = "_Bool", .offset = offsetof(struct ModifyTablePath, canSetTag), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "nominalRelation", .fieldtype = "unsigned int", .offset = offsetof(struct ModifyTablePath, nominalRelation), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "rootRelation", .fieldtype = "unsigned int", .offset = offsetof(struct ModifyTablePath, rootRelation), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "partColsUpdated", .fieldtype = "_Bool", .offset = offsetof(struct ModifyTablePath, partColsUpdated), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "resultRelations", .fieldtype = "struct List *", .offset = offsetof(struct ModifyTablePath, resultRelations), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "subpaths", .fieldtype = "struct List *", .offset = offsetof(struct ModifyTablePath, subpaths), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "subroots", .fieldtype = "struct List *", .offset = offsetof(struct ModifyTablePath, subroots), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "withCheckOptionLists", .fieldtype = "struct List *", .offset = offsetof(struct ModifyTablePath, withCheckOptionLists), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "returningLists", .fieldtype = "struct List *", .offset = offsetof(struct ModifyTablePath, returningLists), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "rowMarks", .fieldtype = "struct List *", .offset = offsetof(struct ModifyTablePath, rowMarks), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "onconflict", .fieldtype = "struct OnConflictExpr *", .offset = offsetof(struct ModifyTablePath, onconflict), .size = sizeof(struct OnConflictExpr *), .flags = TYPE_CAT_POINTER, .node_type_id = 150, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "epqParam", .fieldtype = "int", .offset = offsetof(struct ModifyTablePath, epqParam), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "path", .fieldtype = "struct Path", .offset = offsetof(struct LimitPath, path), .size = sizeof(struct Path), .flags = TYPE_CAT_SCALAR, .node_type_id = 165, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "subpath", .fieldtype = "struct Path *", .offset = offsetof(struct LimitPath, subpath), .size = sizeof(struct Path *), .flags = TYPE_CAT_POINTER, .node_type_id = 165, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "limitOffset", .fieldtype = "struct Node *", .offset = offsetof(struct LimitPath, limitOffset), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "limitCount", .fieldtype = "struct Node *", .offset = offsetof(struct LimitPath, limitCount), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct RestrictInfo, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "clause", .fieldtype = "struct Expr *", .offset = offsetof(struct RestrictInfo, clause), .size = sizeof(struct Expr *), .flags = TYPE_CAT_POINTER, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "is_pushed_down", .fieldtype = "_Bool", .offset = offsetof(struct RestrictInfo, is_pushed_down), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "outerjoin_delayed", .fieldtype = "_Bool", .offset = offsetof(struct RestrictInfo, outerjoin_delayed), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "can_join", .fieldtype = "_Bool", .offset = offsetof(struct RestrictInfo, can_join), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "pseudoconstant", .fieldtype = "_Bool", .offset = offsetof(struct RestrictInfo, pseudoconstant), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "leakproof", .fieldtype = "_Bool", .offset = offsetof(struct RestrictInfo, leakproof), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "security_level", .fieldtype = "unsigned int", .offset = offsetof(struct RestrictInfo, security_level), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "clause_relids", .fieldtype = "struct Bitmapset *", .offset = offsetof(struct RestrictInfo, clause_relids), .size = sizeof(struct Bitmapset *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_BITMAPSET},
+	{.fieldname = "required_relids", .fieldtype = "struct Bitmapset *", .offset = offsetof(struct RestrictInfo, required_relids), .size = sizeof(struct Bitmapset *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_BITMAPSET},
+	{.fieldname = "outer_relids", .fieldtype = "struct Bitmapset *", .offset = offsetof(struct RestrictInfo, outer_relids), .size = sizeof(struct Bitmapset *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_BITMAPSET},
+	{.fieldname = "nullable_relids", .fieldtype = "struct Bitmapset *", .offset = offsetof(struct RestrictInfo, nullable_relids), .size = sizeof(struct Bitmapset *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_BITMAPSET},
+	{.fieldname = "left_relids", .fieldtype = "struct Bitmapset *", .offset = offsetof(struct RestrictInfo, left_relids), .size = sizeof(struct Bitmapset *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_BITMAPSET},
+	{.fieldname = "right_relids", .fieldtype = "struct Bitmapset *", .offset = offsetof(struct RestrictInfo, right_relids), .size = sizeof(struct Bitmapset *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_BITMAPSET},
+	{.fieldname = "orclause", .fieldtype = "struct Expr *", .offset = offsetof(struct RestrictInfo, orclause), .size = sizeof(struct Expr *), .flags = TYPE_CAT_POINTER, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "parent_ec", .fieldtype = "struct EquivalenceClass *", .offset = offsetof(struct RestrictInfo, parent_ec), .size = sizeof(struct EquivalenceClass *), .flags = TYPE_CAT_POINTER, .node_type_id = 198, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "eval_cost", .fieldtype = "struct QualCost", .offset = offsetof(struct RestrictInfo, eval_cost), .size = sizeof(struct QualCost), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "norm_selec", .fieldtype = "double", .offset = offsetof(struct RestrictInfo, norm_selec), .size = sizeof(double), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "outer_selec", .fieldtype = "double", .offset = offsetof(struct RestrictInfo, outer_selec), .size = sizeof(double), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "mergeopfamilies", .fieldtype = "struct List *", .offset = offsetof(struct RestrictInfo, mergeopfamilies), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "left_ec", .fieldtype = "struct EquivalenceClass *", .offset = offsetof(struct RestrictInfo, left_ec), .size = sizeof(struct EquivalenceClass *), .flags = TYPE_CAT_POINTER, .node_type_id = 198, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "right_ec", .fieldtype = "struct EquivalenceClass *", .offset = offsetof(struct RestrictInfo, right_ec), .size = sizeof(struct EquivalenceClass *), .flags = TYPE_CAT_POINTER, .node_type_id = 198, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "left_em", .fieldtype = "struct EquivalenceMember *", .offset = offsetof(struct RestrictInfo, left_em), .size = sizeof(struct EquivalenceMember *), .flags = TYPE_CAT_POINTER, .node_type_id = 199, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "right_em", .fieldtype = "struct EquivalenceMember *", .offset = offsetof(struct RestrictInfo, right_em), .size = sizeof(struct EquivalenceMember *), .flags = TYPE_CAT_POINTER, .node_type_id = 199, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "scansel_cache", .fieldtype = "struct List *", .offset = offsetof(struct RestrictInfo, scansel_cache), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "outer_is_left", .fieldtype = "_Bool", .offset = offsetof(struct RestrictInfo, outer_is_left), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "hashjoinoperator", .fieldtype = "unsigned int", .offset = offsetof(struct RestrictInfo, hashjoinoperator), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "left_bucketsize", .fieldtype = "double", .offset = offsetof(struct RestrictInfo, left_bucketsize), .size = sizeof(double), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "right_bucketsize", .fieldtype = "double", .offset = offsetof(struct RestrictInfo, right_bucketsize), .size = sizeof(double), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "left_mcvfreq", .fieldtype = "double", .offset = offsetof(struct RestrictInfo, left_mcvfreq), .size = sizeof(double), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "right_mcvfreq", .fieldtype = "double", .offset = offsetof(struct RestrictInfo, right_mcvfreq), .size = sizeof(double), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "xpr", .fieldtype = "struct Expr", .offset = offsetof(struct PlaceHolderVar, xpr), .size = sizeof(struct Expr), .flags = TYPE_CAT_SCALAR, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "phexpr", .fieldtype = "struct Expr *", .offset = offsetof(struct PlaceHolderVar, phexpr), .size = sizeof(struct Expr *), .flags = TYPE_CAT_POINTER, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "phrels", .fieldtype = "struct Bitmapset *", .offset = offsetof(struct PlaceHolderVar, phrels), .size = sizeof(struct Bitmapset *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_BITMAPSET},
+	{.fieldname = "phid", .fieldtype = "unsigned int", .offset = offsetof(struct PlaceHolderVar, phid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "phlevelsup", .fieldtype = "unsigned int", .offset = offsetof(struct PlaceHolderVar, phlevelsup), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct SpecialJoinInfo, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "min_lefthand", .fieldtype = "struct Bitmapset *", .offset = offsetof(struct SpecialJoinInfo, min_lefthand), .size = sizeof(struct Bitmapset *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_BITMAPSET},
+	{.fieldname = "min_righthand", .fieldtype = "struct Bitmapset *", .offset = offsetof(struct SpecialJoinInfo, min_righthand), .size = sizeof(struct Bitmapset *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_BITMAPSET},
+	{.fieldname = "syn_lefthand", .fieldtype = "struct Bitmapset *", .offset = offsetof(struct SpecialJoinInfo, syn_lefthand), .size = sizeof(struct Bitmapset *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_BITMAPSET},
+	{.fieldname = "syn_righthand", .fieldtype = "struct Bitmapset *", .offset = offsetof(struct SpecialJoinInfo, syn_righthand), .size = sizeof(struct Bitmapset *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_BITMAPSET},
+	{.fieldname = "jointype", .fieldtype = "enum JoinType", .offset = offsetof(struct SpecialJoinInfo, jointype), .size = sizeof(enum JoinType), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "lhs_strict", .fieldtype = "_Bool", .offset = offsetof(struct SpecialJoinInfo, lhs_strict), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "delay_upper_joins", .fieldtype = "_Bool", .offset = offsetof(struct SpecialJoinInfo, delay_upper_joins), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "semi_can_btree", .fieldtype = "_Bool", .offset = offsetof(struct SpecialJoinInfo, semi_can_btree), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "semi_can_hash", .fieldtype = "_Bool", .offset = offsetof(struct SpecialJoinInfo, semi_can_hash), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "semi_operators", .fieldtype = "struct List *", .offset = offsetof(struct SpecialJoinInfo, semi_operators), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "semi_rhs_exprs", .fieldtype = "struct List *", .offset = offsetof(struct SpecialJoinInfo, semi_rhs_exprs), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct AppendRelInfo, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "parent_relid", .fieldtype = "unsigned int", .offset = offsetof(struct AppendRelInfo, parent_relid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "child_relid", .fieldtype = "unsigned int", .offset = offsetof(struct AppendRelInfo, child_relid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "parent_reltype", .fieldtype = "unsigned int", .offset = offsetof(struct AppendRelInfo, parent_reltype), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "child_reltype", .fieldtype = "unsigned int", .offset = offsetof(struct AppendRelInfo, child_reltype), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "translated_vars", .fieldtype = "struct List *", .offset = offsetof(struct AppendRelInfo, translated_vars), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "parent_reloid", .fieldtype = "unsigned int", .offset = offsetof(struct AppendRelInfo, parent_reloid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct PlaceHolderInfo, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "phid", .fieldtype = "unsigned int", .offset = offsetof(struct PlaceHolderInfo, phid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ph_var", .fieldtype = "struct PlaceHolderVar *", .offset = offsetof(struct PlaceHolderInfo, ph_var), .size = sizeof(struct PlaceHolderVar *), .flags = TYPE_CAT_POINTER, .node_type_id = 204, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ph_eval_at", .fieldtype = "struct Bitmapset *", .offset = offsetof(struct PlaceHolderInfo, ph_eval_at), .size = sizeof(struct Bitmapset *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_BITMAPSET},
+	{.fieldname = "ph_lateral", .fieldtype = "struct Bitmapset *", .offset = offsetof(struct PlaceHolderInfo, ph_lateral), .size = sizeof(struct Bitmapset *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_BITMAPSET},
+	{.fieldname = "ph_needed", .fieldtype = "struct Bitmapset *", .offset = offsetof(struct PlaceHolderInfo, ph_needed), .size = sizeof(struct Bitmapset *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_BITMAPSET},
+	{.fieldname = "ph_width", .fieldtype = "int", .offset = offsetof(struct PlaceHolderInfo, ph_width), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct MinMaxAggInfo, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "aggfnoid", .fieldtype = "unsigned int", .offset = offsetof(struct MinMaxAggInfo, aggfnoid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "aggsortop", .fieldtype = "unsigned int", .offset = offsetof(struct MinMaxAggInfo, aggsortop), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "target", .fieldtype = "struct Expr *", .offset = offsetof(struct MinMaxAggInfo, target), .size = sizeof(struct Expr *), .flags = TYPE_CAT_POINTER, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "subroot", .fieldtype = "struct PlannerInfo *", .offset = offsetof(struct MinMaxAggInfo, subroot), .size = sizeof(struct PlannerInfo *), .flags = TYPE_CAT_POINTER, .node_type_id = 159, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "path", .fieldtype = "struct Path *", .offset = offsetof(struct MinMaxAggInfo, path), .size = sizeof(struct Path *), .flags = TYPE_CAT_POINTER, .node_type_id = 165, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "pathcost", .fieldtype = "double", .offset = offsetof(struct MinMaxAggInfo, pathcost), .size = sizeof(double), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "param", .fieldtype = "struct Param *", .offset = offsetof(struct MinMaxAggInfo, param), .size = sizeof(struct Param *), .flags = TYPE_CAT_POINTER, .node_type_id = 106, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct PlannerParamItem, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "item", .fieldtype = "struct Node *", .offset = offsetof(struct PlannerParamItem, item), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "paramId", .fieldtype = "int", .offset = offsetof(struct PlannerParamItem, paramId), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct PlannedStmt, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "commandType", .fieldtype = "enum CmdType", .offset = offsetof(struct PlannedStmt, commandType), .size = sizeof(enum CmdType), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "queryId", .fieldtype = "unsigned long", .offset = offsetof(struct PlannedStmt, queryId), .size = sizeof(unsigned long), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "hasReturning", .fieldtype = "_Bool", .offset = offsetof(struct PlannedStmt, hasReturning), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "hasModifyingCTE", .fieldtype = "_Bool", .offset = offsetof(struct PlannedStmt, hasModifyingCTE), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "canSetTag", .fieldtype = "_Bool", .offset = offsetof(struct PlannedStmt, canSetTag), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "transientPlan", .fieldtype = "_Bool", .offset = offsetof(struct PlannedStmt, transientPlan), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "dependsOnRole", .fieldtype = "_Bool", .offset = offsetof(struct PlannedStmt, dependsOnRole), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "parallelModeNeeded", .fieldtype = "_Bool", .offset = offsetof(struct PlannedStmt, parallelModeNeeded), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "jitFlags", .fieldtype = "int", .offset = offsetof(struct PlannedStmt, jitFlags), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "planTree", .fieldtype = "struct Plan *", .offset = offsetof(struct PlannedStmt, planTree), .size = sizeof(struct Plan *), .flags = TYPE_CAT_POINTER, .node_type_id = 9, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "rtable", .fieldtype = "struct List *", .offset = offsetof(struct PlannedStmt, rtable), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "resultRelations", .fieldtype = "struct List *", .offset = offsetof(struct PlannedStmt, resultRelations), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "rootResultRelations", .fieldtype = "struct List *", .offset = offsetof(struct PlannedStmt, rootResultRelations), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "subplans", .fieldtype = "struct List *", .offset = offsetof(struct PlannedStmt, subplans), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "rewindPlanIDs", .fieldtype = "struct Bitmapset *", .offset = offsetof(struct PlannedStmt, rewindPlanIDs), .size = sizeof(struct Bitmapset *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_BITMAPSET},
+	{.fieldname = "rowMarks", .fieldtype = "struct List *", .offset = offsetof(struct PlannedStmt, rowMarks), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "relationOids", .fieldtype = "struct List *", .offset = offsetof(struct PlannedStmt, relationOids), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "invalItems", .fieldtype = "struct List *", .offset = offsetof(struct PlannedStmt, invalItems), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "paramExecTypes", .fieldtype = "struct List *", .offset = offsetof(struct PlannedStmt, paramExecTypes), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "utilityStmt", .fieldtype = "struct Node *", .offset = offsetof(struct PlannedStmt, utilityStmt), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "stmt_location", .fieldtype = "int", .offset = offsetof(struct PlannedStmt, stmt_location), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "stmt_len", .fieldtype = "int", .offset = offsetof(struct PlannedStmt, stmt_len), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct Plan, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "startup_cost", .fieldtype = "double", .offset = offsetof(struct Plan, startup_cost), .size = sizeof(double), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "total_cost", .fieldtype = "double", .offset = offsetof(struct Plan, total_cost), .size = sizeof(double), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "plan_rows", .fieldtype = "double", .offset = offsetof(struct Plan, plan_rows), .size = sizeof(double), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "plan_width", .fieldtype = "int", .offset = offsetof(struct Plan, plan_width), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "parallel_aware", .fieldtype = "_Bool", .offset = offsetof(struct Plan, parallel_aware), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "parallel_safe", .fieldtype = "_Bool", .offset = offsetof(struct Plan, parallel_safe), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "plan_node_id", .fieldtype = "int", .offset = offsetof(struct Plan, plan_node_id), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "targetlist", .fieldtype = "struct List *", .offset = offsetof(struct Plan, targetlist), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "qual", .fieldtype = "struct List *", .offset = offsetof(struct Plan, qual), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "lefttree", .fieldtype = "struct Plan *", .offset = offsetof(struct Plan, lefttree), .size = sizeof(struct Plan *), .flags = TYPE_CAT_POINTER, .node_type_id = 9, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "righttree", .fieldtype = "struct Plan *", .offset = offsetof(struct Plan, righttree), .size = sizeof(struct Plan *), .flags = TYPE_CAT_POINTER, .node_type_id = 9, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "initPlan", .fieldtype = "struct List *", .offset = offsetof(struct Plan, initPlan), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "extParam", .fieldtype = "struct Bitmapset *", .offset = offsetof(struct Plan, extParam), .size = sizeof(struct Bitmapset *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_BITMAPSET},
+	{.fieldname = "allParam", .fieldtype = "struct Bitmapset *", .offset = offsetof(struct Plan, allParam), .size = sizeof(struct Bitmapset *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_BITMAPSET},
+	{.fieldname = "plan", .fieldtype = "struct Plan", .offset = offsetof(struct Result, plan), .size = sizeof(struct Plan), .flags = TYPE_CAT_SCALAR, .node_type_id = 9, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "resconstantqual", .fieldtype = "struct Node *", .offset = offsetof(struct Result, resconstantqual), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "plan", .fieldtype = "struct Plan", .offset = offsetof(struct ProjectSet, plan), .size = sizeof(struct Plan), .flags = TYPE_CAT_SCALAR, .node_type_id = 9, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "plan", .fieldtype = "struct Plan", .offset = offsetof(struct ModifyTable, plan), .size = sizeof(struct Plan), .flags = TYPE_CAT_SCALAR, .node_type_id = 9, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "operation", .fieldtype = "enum CmdType", .offset = offsetof(struct ModifyTable, operation), .size = sizeof(enum CmdType), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "canSetTag", .fieldtype = "_Bool", .offset = offsetof(struct ModifyTable, canSetTag), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "nominalRelation", .fieldtype = "unsigned int", .offset = offsetof(struct ModifyTable, nominalRelation), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "rootRelation", .fieldtype = "unsigned int", .offset = offsetof(struct ModifyTable, rootRelation), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "partColsUpdated", .fieldtype = "_Bool", .offset = offsetof(struct ModifyTable, partColsUpdated), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "resultRelations", .fieldtype = "struct List *", .offset = offsetof(struct ModifyTable, resultRelations), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "resultRelIndex", .fieldtype = "int", .offset = offsetof(struct ModifyTable, resultRelIndex), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "rootResultRelIndex", .fieldtype = "int", .offset = offsetof(struct ModifyTable, rootResultRelIndex), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "plans", .fieldtype = "struct List *", .offset = offsetof(struct ModifyTable, plans), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "withCheckOptionLists", .fieldtype = "struct List *", .offset = offsetof(struct ModifyTable, withCheckOptionLists), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "returningLists", .fieldtype = "struct List *", .offset = offsetof(struct ModifyTable, returningLists), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "fdwPrivLists", .fieldtype = "struct List *", .offset = offsetof(struct ModifyTable, fdwPrivLists), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "fdwDirectModifyPlans", .fieldtype = "struct Bitmapset *", .offset = offsetof(struct ModifyTable, fdwDirectModifyPlans), .size = sizeof(struct Bitmapset *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_BITMAPSET},
+	{.fieldname = "rowMarks", .fieldtype = "struct List *", .offset = offsetof(struct ModifyTable, rowMarks), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "epqParam", .fieldtype = "int", .offset = offsetof(struct ModifyTable, epqParam), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "onConflictAction", .fieldtype = "enum OnConflictAction", .offset = offsetof(struct ModifyTable, onConflictAction), .size = sizeof(enum OnConflictAction), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "arbiterIndexes", .fieldtype = "struct List *", .offset = offsetof(struct ModifyTable, arbiterIndexes), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "onConflictSet", .fieldtype = "struct List *", .offset = offsetof(struct ModifyTable, onConflictSet), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "onConflictWhere", .fieldtype = "struct Node *", .offset = offsetof(struct ModifyTable, onConflictWhere), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "exclRelRTI", .fieldtype = "unsigned int", .offset = offsetof(struct ModifyTable, exclRelRTI), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "exclRelTlist", .fieldtype = "struct List *", .offset = offsetof(struct ModifyTable, exclRelTlist), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "plan", .fieldtype = "struct Plan", .offset = offsetof(struct Append, plan), .size = sizeof(struct Plan), .flags = TYPE_CAT_SCALAR, .node_type_id = 9, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "appendplans", .fieldtype = "struct List *", .offset = offsetof(struct Append, appendplans), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "first_partial_plan", .fieldtype = "int", .offset = offsetof(struct Append, first_partial_plan), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "part_prune_info", .fieldtype = "struct PartitionPruneInfo *", .offset = offsetof(struct Append, part_prune_info), .size = sizeof(struct PartitionPruneInfo *), .flags = TYPE_CAT_POINTER, .node_type_id = 53, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "plan", .fieldtype = "struct Plan", .offset = offsetof(struct MergeAppend, plan), .size = sizeof(struct Plan), .flags = TYPE_CAT_SCALAR, .node_type_id = 9, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "mergeplans", .fieldtype = "struct List *", .offset = offsetof(struct MergeAppend, mergeplans), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "numCols", .fieldtype = "int", .offset = offsetof(struct MergeAppend, numCols), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "sortColIdx", .fieldtype = "short *", .offset = offsetof(struct MergeAppend, sortColIdx), .size = sizeof(short *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "sortOperators", .fieldtype = "unsigned int *", .offset = offsetof(struct MergeAppend, sortOperators), .size = sizeof(unsigned int *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "collations", .fieldtype = "unsigned int *", .offset = offsetof(struct MergeAppend, collations), .size = sizeof(unsigned int *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "nullsFirst", .fieldtype = "_Bool *", .offset = offsetof(struct MergeAppend, nullsFirst), .size = sizeof(_Bool *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "part_prune_info", .fieldtype = "struct PartitionPruneInfo *", .offset = offsetof(struct MergeAppend, part_prune_info), .size = sizeof(struct PartitionPruneInfo *), .flags = TYPE_CAT_POINTER, .node_type_id = 53, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "plan", .fieldtype = "struct Plan", .offset = offsetof(struct RecursiveUnion, plan), .size = sizeof(struct Plan), .flags = TYPE_CAT_SCALAR, .node_type_id = 9, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "wtParam", .fieldtype = "int", .offset = offsetof(struct RecursiveUnion, wtParam), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "numCols", .fieldtype = "int", .offset = offsetof(struct RecursiveUnion, numCols), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "dupColIdx", .fieldtype = "short *", .offset = offsetof(struct RecursiveUnion, dupColIdx), .size = sizeof(short *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "dupOperators", .fieldtype = "unsigned int *", .offset = offsetof(struct RecursiveUnion, dupOperators), .size = sizeof(unsigned int *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "dupCollations", .fieldtype = "unsigned int *", .offset = offsetof(struct RecursiveUnion, dupCollations), .size = sizeof(unsigned int *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "numGroups", .fieldtype = "long", .offset = offsetof(struct RecursiveUnion, numGroups), .size = sizeof(long), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "plan", .fieldtype = "struct Plan", .offset = offsetof(struct BitmapAnd, plan), .size = sizeof(struct Plan), .flags = TYPE_CAT_SCALAR, .node_type_id = 9, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "bitmapplans", .fieldtype = "struct List *", .offset = offsetof(struct BitmapAnd, bitmapplans), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "plan", .fieldtype = "struct Plan", .offset = offsetof(struct BitmapOr, plan), .size = sizeof(struct Plan), .flags = TYPE_CAT_SCALAR, .node_type_id = 9, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "isshared", .fieldtype = "_Bool", .offset = offsetof(struct BitmapOr, isshared), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "bitmapplans", .fieldtype = "struct List *", .offset = offsetof(struct BitmapOr, bitmapplans), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "plan", .fieldtype = "struct Plan", .offset = offsetof(struct Scan, plan), .size = sizeof(struct Plan), .flags = TYPE_CAT_SCALAR, .node_type_id = 9, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "scanrelid", .fieldtype = "unsigned int", .offset = offsetof(struct Scan, scanrelid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "plan", .fieldtype = "struct Plan", .offset = offsetof(struct Scan, plan), .size = sizeof(struct Plan), .flags = TYPE_CAT_SCALAR, .node_type_id = 9, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "scanrelid", .fieldtype = "unsigned int", .offset = offsetof(struct Scan, scanrelid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "scan", .fieldtype = "struct Scan", .offset = offsetof(struct SampleScan, scan), .size = sizeof(struct Scan), .flags = TYPE_CAT_SCALAR, .node_type_id = 18, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "tablesample", .fieldtype = "struct TableSampleClause *", .offset = offsetof(struct SampleScan, tablesample), .size = sizeof(struct TableSampleClause *), .flags = TYPE_CAT_POINTER, .node_type_id = 368, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "scan", .fieldtype = "struct Scan", .offset = offsetof(struct IndexScan, scan), .size = sizeof(struct Scan), .flags = TYPE_CAT_SCALAR, .node_type_id = 18, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "indexid", .fieldtype = "unsigned int", .offset = offsetof(struct IndexScan, indexid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "indexqual", .fieldtype = "struct List *", .offset = offsetof(struct IndexScan, indexqual), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "indexqualorig", .fieldtype = "struct List *", .offset = offsetof(struct IndexScan, indexqualorig), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "indexorderby", .fieldtype = "struct List *", .offset = offsetof(struct IndexScan, indexorderby), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "indexorderbyorig", .fieldtype = "struct List *", .offset = offsetof(struct IndexScan, indexorderbyorig), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "indexorderbyops", .fieldtype = "struct List *", .offset = offsetof(struct IndexScan, indexorderbyops), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "indexorderdir", .fieldtype = "enum ScanDirection", .offset = offsetof(struct IndexScan, indexorderdir), .size = sizeof(enum ScanDirection), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "scan", .fieldtype = "struct Scan", .offset = offsetof(struct IndexOnlyScan, scan), .size = sizeof(struct Scan), .flags = TYPE_CAT_SCALAR, .node_type_id = 18, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "indexid", .fieldtype = "unsigned int", .offset = offsetof(struct IndexOnlyScan, indexid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "indexqual", .fieldtype = "struct List *", .offset = offsetof(struct IndexOnlyScan, indexqual), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "indexorderby", .fieldtype = "struct List *", .offset = offsetof(struct IndexOnlyScan, indexorderby), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "indextlist", .fieldtype = "struct List *", .offset = offsetof(struct IndexOnlyScan, indextlist), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "indexorderdir", .fieldtype = "enum ScanDirection", .offset = offsetof(struct IndexOnlyScan, indexorderdir), .size = sizeof(enum ScanDirection), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "scan", .fieldtype = "struct Scan", .offset = offsetof(struct BitmapIndexScan, scan), .size = sizeof(struct Scan), .flags = TYPE_CAT_SCALAR, .node_type_id = 18, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "indexid", .fieldtype = "unsigned int", .offset = offsetof(struct BitmapIndexScan, indexid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "isshared", .fieldtype = "_Bool", .offset = offsetof(struct BitmapIndexScan, isshared), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "indexqual", .fieldtype = "struct List *", .offset = offsetof(struct BitmapIndexScan, indexqual), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "indexqualorig", .fieldtype = "struct List *", .offset = offsetof(struct BitmapIndexScan, indexqualorig), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "scan", .fieldtype = "struct Scan", .offset = offsetof(struct BitmapHeapScan, scan), .size = sizeof(struct Scan), .flags = TYPE_CAT_SCALAR, .node_type_id = 18, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "bitmapqualorig", .fieldtype = "struct List *", .offset = offsetof(struct BitmapHeapScan, bitmapqualorig), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "scan", .fieldtype = "struct Scan", .offset = offsetof(struct TidScan, scan), .size = sizeof(struct Scan), .flags = TYPE_CAT_SCALAR, .node_type_id = 18, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "tidquals", .fieldtype = "struct List *", .offset = offsetof(struct TidScan, tidquals), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "scan", .fieldtype = "struct Scan", .offset = offsetof(struct SubqueryScan, scan), .size = sizeof(struct Scan), .flags = TYPE_CAT_SCALAR, .node_type_id = 18, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "subplan", .fieldtype = "struct Plan *", .offset = offsetof(struct SubqueryScan, subplan), .size = sizeof(struct Plan *), .flags = TYPE_CAT_POINTER, .node_type_id = 9, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "scan", .fieldtype = "struct Scan", .offset = offsetof(struct FunctionScan, scan), .size = sizeof(struct Scan), .flags = TYPE_CAT_SCALAR, .node_type_id = 18, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "functions", .fieldtype = "struct List *", .offset = offsetof(struct FunctionScan, functions), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "funcordinality", .fieldtype = "_Bool", .offset = offsetof(struct FunctionScan, funcordinality), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "scan", .fieldtype = "struct Scan", .offset = offsetof(struct ValuesScan, scan), .size = sizeof(struct Scan), .flags = TYPE_CAT_SCALAR, .node_type_id = 18, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "values_lists", .fieldtype = "struct List *", .offset = offsetof(struct ValuesScan, values_lists), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "scan", .fieldtype = "struct Scan", .offset = offsetof(struct TableFuncScan, scan), .size = sizeof(struct Scan), .flags = TYPE_CAT_SCALAR, .node_type_id = 18, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "tablefunc", .fieldtype = "struct TableFunc *", .offset = offsetof(struct TableFuncScan, tablefunc), .size = sizeof(struct TableFunc *), .flags = TYPE_CAT_POINTER, .node_type_id = 102, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "scan", .fieldtype = "struct Scan", .offset = offsetof(struct CteScan, scan), .size = sizeof(struct Scan), .flags = TYPE_CAT_SCALAR, .node_type_id = 18, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ctePlanId", .fieldtype = "int", .offset = offsetof(struct CteScan, ctePlanId), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "cteParam", .fieldtype = "int", .offset = offsetof(struct CteScan, cteParam), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "scan", .fieldtype = "struct Scan", .offset = offsetof(struct NamedTuplestoreScan, scan), .size = sizeof(struct Scan), .flags = TYPE_CAT_SCALAR, .node_type_id = 18, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "enrname", .fieldtype = "char *", .offset = offsetof(struct NamedTuplestoreScan, enrname), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "scan", .fieldtype = "struct Scan", .offset = offsetof(struct WorkTableScan, scan), .size = sizeof(struct Scan), .flags = TYPE_CAT_SCALAR, .node_type_id = 18, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "wtParam", .fieldtype = "int", .offset = offsetof(struct WorkTableScan, wtParam), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "scan", .fieldtype = "struct Scan", .offset = offsetof(struct ForeignScan, scan), .size = sizeof(struct Scan), .flags = TYPE_CAT_SCALAR, .node_type_id = 18, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "operation", .fieldtype = "enum CmdType", .offset = offsetof(struct ForeignScan, operation), .size = sizeof(enum CmdType), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "fs_server", .fieldtype = "unsigned int", .offset = offsetof(struct ForeignScan, fs_server), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "fdw_exprs", .fieldtype = "struct List *", .offset = offsetof(struct ForeignScan, fdw_exprs), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "fdw_private", .fieldtype = "struct List *", .offset = offsetof(struct ForeignScan, fdw_private), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "fdw_scan_tlist", .fieldtype = "struct List *", .offset = offsetof(struct ForeignScan, fdw_scan_tlist), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "fdw_recheck_quals", .fieldtype = "struct List *", .offset = offsetof(struct ForeignScan, fdw_recheck_quals), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "fs_relids", .fieldtype = "struct Bitmapset *", .offset = offsetof(struct ForeignScan, fs_relids), .size = sizeof(struct Bitmapset *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_BITMAPSET},
+	{.fieldname = "fsSystemCol", .fieldtype = "_Bool", .offset = offsetof(struct ForeignScan, fsSystemCol), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "scan", .fieldtype = "struct Scan", .offset = offsetof(struct CustomScan, scan), .size = sizeof(struct Scan), .flags = TYPE_CAT_SCALAR, .node_type_id = 18, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "flags", .fieldtype = "unsigned int", .offset = offsetof(struct CustomScan, flags), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "custom_plans", .fieldtype = "struct List *", .offset = offsetof(struct CustomScan, custom_plans), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "custom_exprs", .fieldtype = "struct List *", .offset = offsetof(struct CustomScan, custom_exprs), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "custom_private", .fieldtype = "struct List *", .offset = offsetof(struct CustomScan, custom_private), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "custom_scan_tlist", .fieldtype = "struct List *", .offset = offsetof(struct CustomScan, custom_scan_tlist), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "custom_relids", .fieldtype = "struct Bitmapset *", .offset = offsetof(struct CustomScan, custom_relids), .size = sizeof(struct Bitmapset *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_BITMAPSET},
+	{.fieldname = "methods", .fieldtype = "const struct CustomScanMethods *", .offset = offsetof(struct CustomScan, methods), .size = sizeof(const struct CustomScanMethods *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "plan", .fieldtype = "struct Plan", .offset = offsetof(struct Join, plan), .size = sizeof(struct Plan), .flags = TYPE_CAT_SCALAR, .node_type_id = 9, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "jointype", .fieldtype = "enum JoinType", .offset = offsetof(struct Join, jointype), .size = sizeof(enum JoinType), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "inner_unique", .fieldtype = "_Bool", .offset = offsetof(struct Join, inner_unique), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "joinqual", .fieldtype = "struct List *", .offset = offsetof(struct Join, joinqual), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "join", .fieldtype = "struct Join", .offset = offsetof(struct NestLoop, join), .size = sizeof(struct Join), .flags = TYPE_CAT_SCALAR, .node_type_id = 35, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "nestParams", .fieldtype = "struct List *", .offset = offsetof(struct NestLoop, nestParams), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct NestLoopParam, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "paramno", .fieldtype = "int", .offset = offsetof(struct NestLoopParam, paramno), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "paramval", .fieldtype = "struct Var *", .offset = offsetof(struct NestLoopParam, paramval), .size = sizeof(struct Var *), .flags = TYPE_CAT_POINTER, .node_type_id = 104, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "join", .fieldtype = "struct Join", .offset = offsetof(struct MergeJoin, join), .size = sizeof(struct Join), .flags = TYPE_CAT_SCALAR, .node_type_id = 35, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "skip_mark_restore", .fieldtype = "_Bool", .offset = offsetof(struct MergeJoin, skip_mark_restore), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "mergeclauses", .fieldtype = "struct List *", .offset = offsetof(struct MergeJoin, mergeclauses), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "mergeFamilies", .fieldtype = "unsigned int *", .offset = offsetof(struct MergeJoin, mergeFamilies), .size = sizeof(unsigned int *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "mergeCollations", .fieldtype = "unsigned int *", .offset = offsetof(struct MergeJoin, mergeCollations), .size = sizeof(unsigned int *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "mergeStrategies", .fieldtype = "int *", .offset = offsetof(struct MergeJoin, mergeStrategies), .size = sizeof(int *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "mergeNullsFirst", .fieldtype = "_Bool *", .offset = offsetof(struct MergeJoin, mergeNullsFirst), .size = sizeof(_Bool *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "join", .fieldtype = "struct Join", .offset = offsetof(struct HashJoin, join), .size = sizeof(struct Join), .flags = TYPE_CAT_SCALAR, .node_type_id = 35, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "hashclauses", .fieldtype = "struct List *", .offset = offsetof(struct HashJoin, hashclauses), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "hashoperators", .fieldtype = "struct List *", .offset = offsetof(struct HashJoin, hashoperators), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "hashcollations", .fieldtype = "struct List *", .offset = offsetof(struct HashJoin, hashcollations), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "hashkeys", .fieldtype = "struct List *", .offset = offsetof(struct HashJoin, hashkeys), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "plan", .fieldtype = "struct Plan", .offset = offsetof(struct Material, plan), .size = sizeof(struct Plan), .flags = TYPE_CAT_SCALAR, .node_type_id = 9, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "plan", .fieldtype = "struct Plan", .offset = offsetof(struct Sort, plan), .size = sizeof(struct Plan), .flags = TYPE_CAT_SCALAR, .node_type_id = 9, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "numCols", .fieldtype = "int", .offset = offsetof(struct Sort, numCols), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "sortColIdx", .fieldtype = "short *", .offset = offsetof(struct Sort, sortColIdx), .size = sizeof(short *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "sortOperators", .fieldtype = "unsigned int *", .offset = offsetof(struct Sort, sortOperators), .size = sizeof(unsigned int *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "collations", .fieldtype = "unsigned int *", .offset = offsetof(struct Sort, collations), .size = sizeof(unsigned int *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "nullsFirst", .fieldtype = "_Bool *", .offset = offsetof(struct Sort, nullsFirst), .size = sizeof(_Bool *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "plan", .fieldtype = "struct Plan", .offset = offsetof(struct Group, plan), .size = sizeof(struct Plan), .flags = TYPE_CAT_SCALAR, .node_type_id = 9, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "numCols", .fieldtype = "int", .offset = offsetof(struct Group, numCols), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "grpColIdx", .fieldtype = "short *", .offset = offsetof(struct Group, grpColIdx), .size = sizeof(short *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "grpOperators", .fieldtype = "unsigned int *", .offset = offsetof(struct Group, grpOperators), .size = sizeof(unsigned int *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "grpCollations", .fieldtype = "unsigned int *", .offset = offsetof(struct Group, grpCollations), .size = sizeof(unsigned int *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "plan", .fieldtype = "struct Plan", .offset = offsetof(struct Agg, plan), .size = sizeof(struct Plan), .flags = TYPE_CAT_SCALAR, .node_type_id = 9, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "aggstrategy", .fieldtype = "enum AggStrategy", .offset = offsetof(struct Agg, aggstrategy), .size = sizeof(enum AggStrategy), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "aggsplit", .fieldtype = "enum AggSplit", .offset = offsetof(struct Agg, aggsplit), .size = sizeof(enum AggSplit), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "numCols", .fieldtype = "int", .offset = offsetof(struct Agg, numCols), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "grpColIdx", .fieldtype = "short *", .offset = offsetof(struct Agg, grpColIdx), .size = sizeof(short *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "grpOperators", .fieldtype = "unsigned int *", .offset = offsetof(struct Agg, grpOperators), .size = sizeof(unsigned int *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "grpCollations", .fieldtype = "unsigned int *", .offset = offsetof(struct Agg, grpCollations), .size = sizeof(unsigned int *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "numGroups", .fieldtype = "long", .offset = offsetof(struct Agg, numGroups), .size = sizeof(long), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "aggParams", .fieldtype = "struct Bitmapset *", .offset = offsetof(struct Agg, aggParams), .size = sizeof(struct Bitmapset *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_BITMAPSET},
+	{.fieldname = "groupingSets", .fieldtype = "struct List *", .offset = offsetof(struct Agg, groupingSets), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "chain", .fieldtype = "struct List *", .offset = offsetof(struct Agg, chain), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "plan", .fieldtype = "struct Plan", .offset = offsetof(struct WindowAgg, plan), .size = sizeof(struct Plan), .flags = TYPE_CAT_SCALAR, .node_type_id = 9, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "winref", .fieldtype = "unsigned int", .offset = offsetof(struct WindowAgg, winref), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "partNumCols", .fieldtype = "int", .offset = offsetof(struct WindowAgg, partNumCols), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "partColIdx", .fieldtype = "short *", .offset = offsetof(struct WindowAgg, partColIdx), .size = sizeof(short *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "partOperators", .fieldtype = "unsigned int *", .offset = offsetof(struct WindowAgg, partOperators), .size = sizeof(unsigned int *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "partCollations", .fieldtype = "unsigned int *", .offset = offsetof(struct WindowAgg, partCollations), .size = sizeof(unsigned int *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "ordNumCols", .fieldtype = "int", .offset = offsetof(struct WindowAgg, ordNumCols), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ordColIdx", .fieldtype = "short *", .offset = offsetof(struct WindowAgg, ordColIdx), .size = sizeof(short *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "ordOperators", .fieldtype = "unsigned int *", .offset = offsetof(struct WindowAgg, ordOperators), .size = sizeof(unsigned int *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "ordCollations", .fieldtype = "unsigned int *", .offset = offsetof(struct WindowAgg, ordCollations), .size = sizeof(unsigned int *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "frameOptions", .fieldtype = "int", .offset = offsetof(struct WindowAgg, frameOptions), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "startOffset", .fieldtype = "struct Node *", .offset = offsetof(struct WindowAgg, startOffset), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "endOffset", .fieldtype = "struct Node *", .offset = offsetof(struct WindowAgg, endOffset), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "startInRangeFunc", .fieldtype = "unsigned int", .offset = offsetof(struct WindowAgg, startInRangeFunc), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "endInRangeFunc", .fieldtype = "unsigned int", .offset = offsetof(struct WindowAgg, endInRangeFunc), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "inRangeColl", .fieldtype = "unsigned int", .offset = offsetof(struct WindowAgg, inRangeColl), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "inRangeAsc", .fieldtype = "_Bool", .offset = offsetof(struct WindowAgg, inRangeAsc), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "inRangeNullsFirst", .fieldtype = "_Bool", .offset = offsetof(struct WindowAgg, inRangeNullsFirst), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "plan", .fieldtype = "struct Plan", .offset = offsetof(struct Unique, plan), .size = sizeof(struct Plan), .flags = TYPE_CAT_SCALAR, .node_type_id = 9, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "numCols", .fieldtype = "int", .offset = offsetof(struct Unique, numCols), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "uniqColIdx", .fieldtype = "short *", .offset = offsetof(struct Unique, uniqColIdx), .size = sizeof(short *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "uniqOperators", .fieldtype = "unsigned int *", .offset = offsetof(struct Unique, uniqOperators), .size = sizeof(unsigned int *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "uniqCollations", .fieldtype = "unsigned int *", .offset = offsetof(struct Unique, uniqCollations), .size = sizeof(unsigned int *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "plan", .fieldtype = "struct Plan", .offset = offsetof(struct Gather, plan), .size = sizeof(struct Plan), .flags = TYPE_CAT_SCALAR, .node_type_id = 9, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "num_workers", .fieldtype = "int", .offset = offsetof(struct Gather, num_workers), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "rescan_param", .fieldtype = "int", .offset = offsetof(struct Gather, rescan_param), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "single_copy", .fieldtype = "_Bool", .offset = offsetof(struct Gather, single_copy), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "invisible", .fieldtype = "_Bool", .offset = offsetof(struct Gather, invisible), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "initParam", .fieldtype = "struct Bitmapset *", .offset = offsetof(struct Gather, initParam), .size = sizeof(struct Bitmapset *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_BITMAPSET},
+	{.fieldname = "plan", .fieldtype = "struct Plan", .offset = offsetof(struct GatherMerge, plan), .size = sizeof(struct Plan), .flags = TYPE_CAT_SCALAR, .node_type_id = 9, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "num_workers", .fieldtype = "int", .offset = offsetof(struct GatherMerge, num_workers), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "rescan_param", .fieldtype = "int", .offset = offsetof(struct GatherMerge, rescan_param), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "numCols", .fieldtype = "int", .offset = offsetof(struct GatherMerge, numCols), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "sortColIdx", .fieldtype = "short *", .offset = offsetof(struct GatherMerge, sortColIdx), .size = sizeof(short *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "sortOperators", .fieldtype = "unsigned int *", .offset = offsetof(struct GatherMerge, sortOperators), .size = sizeof(unsigned int *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "collations", .fieldtype = "unsigned int *", .offset = offsetof(struct GatherMerge, collations), .size = sizeof(unsigned int *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "nullsFirst", .fieldtype = "_Bool *", .offset = offsetof(struct GatherMerge, nullsFirst), .size = sizeof(_Bool *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "initParam", .fieldtype = "struct Bitmapset *", .offset = offsetof(struct GatherMerge, initParam), .size = sizeof(struct Bitmapset *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_BITMAPSET},
+	{.fieldname = "plan", .fieldtype = "struct Plan", .offset = offsetof(struct Hash, plan), .size = sizeof(struct Plan), .flags = TYPE_CAT_SCALAR, .node_type_id = 9, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "hashkeys", .fieldtype = "struct List *", .offset = offsetof(struct Hash, hashkeys), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "skewTable", .fieldtype = "unsigned int", .offset = offsetof(struct Hash, skewTable), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "skewColumn", .fieldtype = "short", .offset = offsetof(struct Hash, skewColumn), .size = sizeof(short), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "skewInherit", .fieldtype = "_Bool", .offset = offsetof(struct Hash, skewInherit), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "rows_total", .fieldtype = "double", .offset = offsetof(struct Hash, rows_total), .size = sizeof(double), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "plan", .fieldtype = "struct Plan", .offset = offsetof(struct SetOp, plan), .size = sizeof(struct Plan), .flags = TYPE_CAT_SCALAR, .node_type_id = 9, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "cmd", .fieldtype = "enum SetOpCmd", .offset = offsetof(struct SetOp, cmd), .size = sizeof(enum SetOpCmd), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "strategy", .fieldtype = "enum SetOpStrategy", .offset = offsetof(struct SetOp, strategy), .size = sizeof(enum SetOpStrategy), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "numCols", .fieldtype = "int", .offset = offsetof(struct SetOp, numCols), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "dupColIdx", .fieldtype = "short *", .offset = offsetof(struct SetOp, dupColIdx), .size = sizeof(short *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "dupOperators", .fieldtype = "unsigned int *", .offset = offsetof(struct SetOp, dupOperators), .size = sizeof(unsigned int *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "dupCollations", .fieldtype = "unsigned int *", .offset = offsetof(struct SetOp, dupCollations), .size = sizeof(unsigned int *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "flagColIdx", .fieldtype = "short", .offset = offsetof(struct SetOp, flagColIdx), .size = sizeof(short), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "firstFlag", .fieldtype = "int", .offset = offsetof(struct SetOp, firstFlag), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "numGroups", .fieldtype = "long", .offset = offsetof(struct SetOp, numGroups), .size = sizeof(long), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "plan", .fieldtype = "struct Plan", .offset = offsetof(struct LockRows, plan), .size = sizeof(struct Plan), .flags = TYPE_CAT_SCALAR, .node_type_id = 9, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "rowMarks", .fieldtype = "struct List *", .offset = offsetof(struct LockRows, rowMarks), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "epqParam", .fieldtype = "int", .offset = offsetof(struct LockRows, epqParam), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "plan", .fieldtype = "struct Plan", .offset = offsetof(struct Limit, plan), .size = sizeof(struct Plan), .flags = TYPE_CAT_SCALAR, .node_type_id = 9, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "limitOffset", .fieldtype = "struct Node *", .offset = offsetof(struct Limit, limitOffset), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "limitCount", .fieldtype = "struct Node *", .offset = offsetof(struct Limit, limitCount), .size = sizeof(struct Node *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_NODE},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct PlanRowMark, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "rti", .fieldtype = "unsigned int", .offset = offsetof(struct PlanRowMark, rti), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "prti", .fieldtype = "unsigned int", .offset = offsetof(struct PlanRowMark, prti), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "rowmarkId", .fieldtype = "unsigned int", .offset = offsetof(struct PlanRowMark, rowmarkId), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "markType", .fieldtype = "enum RowMarkType", .offset = offsetof(struct PlanRowMark, markType), .size = sizeof(enum RowMarkType), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "allMarkTypes", .fieldtype = "int", .offset = offsetof(struct PlanRowMark, allMarkTypes), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "strength", .fieldtype = "enum LockClauseStrength", .offset = offsetof(struct PlanRowMark, strength), .size = sizeof(enum LockClauseStrength), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "waitPolicy", .fieldtype = "enum LockWaitPolicy", .offset = offsetof(struct PlanRowMark, waitPolicy), .size = sizeof(enum LockWaitPolicy), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "isParent", .fieldtype = "_Bool", .offset = offsetof(struct PlanRowMark, isParent), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct PartitionPruneInfo, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "prune_infos", .fieldtype = "struct List *", .offset = offsetof(struct PartitionPruneInfo, prune_infos), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "other_subplans", .fieldtype = "struct Bitmapset *", .offset = offsetof(struct PartitionPruneInfo, other_subplans), .size = sizeof(struct Bitmapset *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_BITMAPSET},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct PartitionedRelPruneInfo, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "rtindex", .fieldtype = "unsigned int", .offset = offsetof(struct PartitionedRelPruneInfo, rtindex), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "present_parts", .fieldtype = "struct Bitmapset *", .offset = offsetof(struct PartitionedRelPruneInfo, present_parts), .size = sizeof(struct Bitmapset *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_BITMAPSET},
+	{.fieldname = "nparts", .fieldtype = "int", .offset = offsetof(struct PartitionedRelPruneInfo, nparts), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "subplan_map", .fieldtype = "int *", .offset = offsetof(struct PartitionedRelPruneInfo, subplan_map), .size = sizeof(int *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "subpart_map", .fieldtype = "int *", .offset = offsetof(struct PartitionedRelPruneInfo, subpart_map), .size = sizeof(int *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "relid_map", .fieldtype = "unsigned int *", .offset = offsetof(struct PartitionedRelPruneInfo, relid_map), .size = sizeof(unsigned int *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "initial_pruning_steps", .fieldtype = "struct List *", .offset = offsetof(struct PartitionedRelPruneInfo, initial_pruning_steps), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "exec_pruning_steps", .fieldtype = "struct List *", .offset = offsetof(struct PartitionedRelPruneInfo, exec_pruning_steps), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "execparamids", .fieldtype = "struct Bitmapset *", .offset = offsetof(struct PartitionedRelPruneInfo, execparamids), .size = sizeof(struct Bitmapset *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_BITMAPSET},
+	{.fieldname = "step", .fieldtype = "struct PartitionPruneStep", .offset = offsetof(struct PartitionPruneStepOp, step), .size = sizeof(struct PartitionPruneStep), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "opstrategy", .fieldtype = "unsigned short", .offset = offsetof(struct PartitionPruneStepOp, opstrategy), .size = sizeof(unsigned short), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "exprs", .fieldtype = "struct List *", .offset = offsetof(struct PartitionPruneStepOp, exprs), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "cmpfns", .fieldtype = "struct List *", .offset = offsetof(struct PartitionPruneStepOp, cmpfns), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "nullkeys", .fieldtype = "struct Bitmapset *", .offset = offsetof(struct PartitionPruneStepOp, nullkeys), .size = sizeof(struct Bitmapset *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_BITMAPSET},
+	{.fieldname = "step", .fieldtype = "struct PartitionPruneStep", .offset = offsetof(struct PartitionPruneStepCombine, step), .size = sizeof(struct PartitionPruneStep), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "combineOp", .fieldtype = "enum PartitionPruneCombineOp", .offset = offsetof(struct PartitionPruneStepCombine, combineOp), .size = sizeof(enum PartitionPruneCombineOp), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "source_stepids", .fieldtype = "struct List *", .offset = offsetof(struct PartitionPruneStepCombine, source_stepids), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct PlanInvalItem, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "cacheId", .fieldtype = "int", .offset = offsetof(struct PlanInvalItem, cacheId), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "hashValue", .fieldtype = "unsigned int", .offset = offsetof(struct PlanInvalItem, hashValue), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct TupleTableSlot, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "tts_flags", .fieldtype = "unsigned short", .offset = offsetof(struct TupleTableSlot, tts_flags), .size = sizeof(unsigned short), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "tts_nvalid", .fieldtype = "short", .offset = offsetof(struct TupleTableSlot, tts_nvalid), .size = sizeof(short), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "tts_ops", .fieldtype = "const struct TupleTableSlotOps *const", .offset = offsetof(struct TupleTableSlot, tts_ops), .size = sizeof(const struct TupleTableSlotOps *const), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "tts_tupleDescriptor", .fieldtype = "struct TupleDescData *", .offset = offsetof(struct TupleTableSlot, tts_tupleDescriptor), .size = sizeof(struct TupleDescData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "tts_values", .fieldtype = "unsigned long *", .offset = offsetof(struct TupleTableSlot, tts_values), .size = sizeof(unsigned long *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "tts_isnull", .fieldtype = "_Bool *", .offset = offsetof(struct TupleTableSlot, tts_isnull), .size = sizeof(_Bool *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "tts_mcxt", .fieldtype = "struct MemoryContextData *", .offset = offsetof(struct TupleTableSlot, tts_mcxt), .size = sizeof(struct MemoryContextData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "tts_tid", .fieldtype = "struct ItemPointerData", .offset = offsetof(struct TupleTableSlot, tts_tid), .size = sizeof(struct ItemPointerData), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "tts_tableOid", .fieldtype = "unsigned int", .offset = offsetof(struct TupleTableSlot, tts_tableOid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "tag", .fieldtype = "struct Node", .offset = offsetof(struct ExprState, tag), .size = sizeof(struct Node), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "flags", .fieldtype = "unsigned char", .offset = offsetof(struct ExprState, flags), .size = sizeof(unsigned char), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "resnull", .fieldtype = "_Bool", .offset = offsetof(struct ExprState, resnull), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "resvalue", .fieldtype = "unsigned long", .offset = offsetof(struct ExprState, resvalue), .size = sizeof(unsigned long), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "resultslot", .fieldtype = "struct TupleTableSlot *", .offset = offsetof(struct ExprState, resultslot), .size = sizeof(struct TupleTableSlot *), .flags = TYPE_CAT_POINTER, .node_type_id = 8, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "steps", .fieldtype = "struct ExprEvalStep *", .offset = offsetof(struct ExprState, steps), .size = sizeof(struct ExprEvalStep *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "evalfunc", .fieldtype = "unsigned long (*)(struct ExprState *, struct ExprContext *, _Bool *)", .offset = offsetof(struct ExprState, evalfunc), .size = sizeof(unsigned long (*)(struct ExprState *, struct ExprContext *, _Bool *)), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "expr", .fieldtype = "struct Expr *", .offset = offsetof(struct ExprState, expr), .size = sizeof(struct Expr *), .flags = TYPE_CAT_POINTER, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "evalfunc_private", .fieldtype = "void *", .offset = offsetof(struct ExprState, evalfunc_private), .size = sizeof(void *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "steps_len", .fieldtype = "int", .offset = offsetof(struct ExprState, steps_len), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "steps_alloc", .fieldtype = "int", .offset = offsetof(struct ExprState, steps_alloc), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "parent", .fieldtype = "struct PlanState *", .offset = offsetof(struct ExprState, parent), .size = sizeof(struct PlanState *), .flags = TYPE_CAT_POINTER, .node_type_id = 58, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ext_params", .fieldtype = "struct ParamListInfoData *", .offset = offsetof(struct ExprState, ext_params), .size = sizeof(struct ParamListInfoData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "innermost_caseval", .fieldtype = "unsigned long *", .offset = offsetof(struct ExprState, innermost_caseval), .size = sizeof(unsigned long *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "innermost_casenull", .fieldtype = "_Bool *", .offset = offsetof(struct ExprState, innermost_casenull), .size = sizeof(_Bool *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "innermost_domainval", .fieldtype = "unsigned long *", .offset = offsetof(struct ExprState, innermost_domainval), .size = sizeof(unsigned long *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "innermost_domainnull", .fieldtype = "_Bool *", .offset = offsetof(struct ExprState, innermost_domainnull), .size = sizeof(_Bool *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct IndexInfo, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ii_NumIndexAttrs", .fieldtype = "int", .offset = offsetof(struct IndexInfo, ii_NumIndexAttrs), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ii_NumIndexKeyAttrs", .fieldtype = "int", .offset = offsetof(struct IndexInfo, ii_NumIndexKeyAttrs), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ii_IndexAttrNumbers", .fieldtype = "short [32]", .offset = offsetof(struct IndexInfo, ii_IndexAttrNumbers), .size = sizeof(short [32]), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ii_Expressions", .fieldtype = "struct List *", .offset = offsetof(struct IndexInfo, ii_Expressions), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ii_ExpressionsState", .fieldtype = "struct List *", .offset = offsetof(struct IndexInfo, ii_ExpressionsState), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ii_Predicate", .fieldtype = "struct List *", .offset = offsetof(struct IndexInfo, ii_Predicate), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ii_PredicateState", .fieldtype = "struct ExprState *", .offset = offsetof(struct IndexInfo, ii_PredicateState), .size = sizeof(struct ExprState *), .flags = TYPE_CAT_POINTER, .node_type_id = 152, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ii_ExclusionOps", .fieldtype = "unsigned int *", .offset = offsetof(struct IndexInfo, ii_ExclusionOps), .size = sizeof(unsigned int *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "ii_ExclusionProcs", .fieldtype = "unsigned int *", .offset = offsetof(struct IndexInfo, ii_ExclusionProcs), .size = sizeof(unsigned int *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "ii_ExclusionStrats", .fieldtype = "unsigned short *", .offset = offsetof(struct IndexInfo, ii_ExclusionStrats), .size = sizeof(unsigned short *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "ii_UniqueOps", .fieldtype = "unsigned int *", .offset = offsetof(struct IndexInfo, ii_UniqueOps), .size = sizeof(unsigned int *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "ii_UniqueProcs", .fieldtype = "unsigned int *", .offset = offsetof(struct IndexInfo, ii_UniqueProcs), .size = sizeof(unsigned int *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "ii_UniqueStrats", .fieldtype = "unsigned short *", .offset = offsetof(struct IndexInfo, ii_UniqueStrats), .size = sizeof(unsigned short *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "ii_Unique", .fieldtype = "_Bool", .offset = offsetof(struct IndexInfo, ii_Unique), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ii_ReadyForInserts", .fieldtype = "_Bool", .offset = offsetof(struct IndexInfo, ii_ReadyForInserts), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ii_Concurrent", .fieldtype = "_Bool", .offset = offsetof(struct IndexInfo, ii_Concurrent), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ii_BrokenHotChain", .fieldtype = "_Bool", .offset = offsetof(struct IndexInfo, ii_BrokenHotChain), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ii_ParallelWorkers", .fieldtype = "int", .offset = offsetof(struct IndexInfo, ii_ParallelWorkers), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ii_Am", .fieldtype = "unsigned int", .offset = offsetof(struct IndexInfo, ii_Am), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ii_AmCache", .fieldtype = "void *", .offset = offsetof(struct IndexInfo, ii_AmCache), .size = sizeof(void *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ii_Context", .fieldtype = "struct MemoryContextData *", .offset = offsetof(struct IndexInfo, ii_Context), .size = sizeof(struct MemoryContextData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct ExprContext, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ecxt_scantuple", .fieldtype = "struct TupleTableSlot *", .offset = offsetof(struct ExprContext, ecxt_scantuple), .size = sizeof(struct TupleTableSlot *), .flags = TYPE_CAT_POINTER, .node_type_id = 8, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ecxt_innertuple", .fieldtype = "struct TupleTableSlot *", .offset = offsetof(struct ExprContext, ecxt_innertuple), .size = sizeof(struct TupleTableSlot *), .flags = TYPE_CAT_POINTER, .node_type_id = 8, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ecxt_outertuple", .fieldtype = "struct TupleTableSlot *", .offset = offsetof(struct ExprContext, ecxt_outertuple), .size = sizeof(struct TupleTableSlot *), .flags = TYPE_CAT_POINTER, .node_type_id = 8, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ecxt_per_query_memory", .fieldtype = "struct MemoryContextData *", .offset = offsetof(struct ExprContext, ecxt_per_query_memory), .size = sizeof(struct MemoryContextData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ecxt_per_tuple_memory", .fieldtype = "struct MemoryContextData *", .offset = offsetof(struct ExprContext, ecxt_per_tuple_memory), .size = sizeof(struct MemoryContextData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ecxt_param_exec_vals", .fieldtype = "struct ParamExecData *", .offset = offsetof(struct ExprContext, ecxt_param_exec_vals), .size = sizeof(struct ParamExecData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ecxt_param_list_info", .fieldtype = "struct ParamListInfoData *", .offset = offsetof(struct ExprContext, ecxt_param_list_info), .size = sizeof(struct ParamListInfoData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ecxt_aggvalues", .fieldtype = "unsigned long *", .offset = offsetof(struct ExprContext, ecxt_aggvalues), .size = sizeof(unsigned long *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "ecxt_aggnulls", .fieldtype = "_Bool *", .offset = offsetof(struct ExprContext, ecxt_aggnulls), .size = sizeof(_Bool *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "caseValue_datum", .fieldtype = "unsigned long", .offset = offsetof(struct ExprContext, caseValue_datum), .size = sizeof(unsigned long), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "caseValue_isNull", .fieldtype = "_Bool", .offset = offsetof(struct ExprContext, caseValue_isNull), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "domainValue_datum", .fieldtype = "unsigned long", .offset = offsetof(struct ExprContext, domainValue_datum), .size = sizeof(unsigned long), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "domainValue_isNull", .fieldtype = "_Bool", .offset = offsetof(struct ExprContext, domainValue_isNull), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ecxt_estate", .fieldtype = "struct EState *", .offset = offsetof(struct ExprContext, ecxt_estate), .size = sizeof(struct EState *), .flags = TYPE_CAT_POINTER, .node_type_id = 7, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ecxt_callbacks", .fieldtype = "struct ExprContext_CB *", .offset = offsetof(struct ExprContext, ecxt_callbacks), .size = sizeof(struct ExprContext_CB *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct ReturnSetInfo, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "econtext", .fieldtype = "struct ExprContext *", .offset = offsetof(struct ReturnSetInfo, econtext), .size = sizeof(struct ExprContext *), .flags = TYPE_CAT_POINTER, .node_type_id = 2, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "expectedDesc", .fieldtype = "struct TupleDescData *", .offset = offsetof(struct ReturnSetInfo, expectedDesc), .size = sizeof(struct TupleDescData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "allowedModes", .fieldtype = "int", .offset = offsetof(struct ReturnSetInfo, allowedModes), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "returnMode", .fieldtype = "SetFunctionReturnMode", .offset = offsetof(struct ReturnSetInfo, returnMode), .size = sizeof(SetFunctionReturnMode), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "isDone", .fieldtype = "ExprDoneCond", .offset = offsetof(struct ReturnSetInfo, isDone), .size = sizeof(ExprDoneCond), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "setResult", .fieldtype = "struct Tuplestorestate *", .offset = offsetof(struct ReturnSetInfo, setResult), .size = sizeof(struct Tuplestorestate *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "setDesc", .fieldtype = "struct TupleDescData *", .offset = offsetof(struct ReturnSetInfo, setDesc), .size = sizeof(struct TupleDescData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct ProjectionInfo, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "pi_state", .fieldtype = "struct ExprState", .offset = offsetof(struct ProjectionInfo, pi_state), .size = sizeof(struct ExprState), .flags = TYPE_CAT_SCALAR, .node_type_id = 152, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "pi_exprContext", .fieldtype = "struct ExprContext *", .offset = offsetof(struct ProjectionInfo, pi_exprContext), .size = sizeof(struct ExprContext *), .flags = TYPE_CAT_POINTER, .node_type_id = 2, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct JunkFilter, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "jf_targetList", .fieldtype = "struct List *", .offset = offsetof(struct JunkFilter, jf_targetList), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "jf_cleanTupType", .fieldtype = "struct TupleDescData *", .offset = offsetof(struct JunkFilter, jf_cleanTupType), .size = sizeof(struct TupleDescData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "jf_cleanMap", .fieldtype = "short *", .offset = offsetof(struct JunkFilter, jf_cleanMap), .size = sizeof(short *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "jf_resultSlot", .fieldtype = "struct TupleTableSlot *", .offset = offsetof(struct JunkFilter, jf_resultSlot), .size = sizeof(struct TupleTableSlot *), .flags = TYPE_CAT_POINTER, .node_type_id = 8, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "jf_junkAttNo", .fieldtype = "short", .offset = offsetof(struct JunkFilter, jf_junkAttNo), .size = sizeof(short), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct OnConflictSetState, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "oc_Existing", .fieldtype = "struct TupleTableSlot *", .offset = offsetof(struct OnConflictSetState, oc_Existing), .size = sizeof(struct TupleTableSlot *), .flags = TYPE_CAT_POINTER, .node_type_id = 8, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "oc_ProjSlot", .fieldtype = "struct TupleTableSlot *", .offset = offsetof(struct OnConflictSetState, oc_ProjSlot), .size = sizeof(struct TupleTableSlot *), .flags = TYPE_CAT_POINTER, .node_type_id = 8, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "oc_ProjInfo", .fieldtype = "struct ProjectionInfo *", .offset = offsetof(struct OnConflictSetState, oc_ProjInfo), .size = sizeof(struct ProjectionInfo *), .flags = TYPE_CAT_POINTER, .node_type_id = 3, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "oc_WhereClause", .fieldtype = "struct ExprState *", .offset = offsetof(struct OnConflictSetState, oc_WhereClause), .size = sizeof(struct ExprState *), .flags = TYPE_CAT_POINTER, .node_type_id = 152, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct ResultRelInfo, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ri_RangeTableIndex", .fieldtype = "unsigned int", .offset = offsetof(struct ResultRelInfo, ri_RangeTableIndex), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ri_RelationDesc", .fieldtype = "struct RelationData *", .offset = offsetof(struct ResultRelInfo, ri_RelationDesc), .size = sizeof(struct RelationData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ri_NumIndices", .fieldtype = "int", .offset = offsetof(struct ResultRelInfo, ri_NumIndices), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ri_IndexRelationDescs", .fieldtype = "struct RelationData **", .offset = offsetof(struct ResultRelInfo, ri_IndexRelationDescs), .size = sizeof(struct RelationData **), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ri_IndexRelationInfo", .fieldtype = "struct IndexInfo **", .offset = offsetof(struct ResultRelInfo, ri_IndexRelationInfo), .size = sizeof(struct IndexInfo **), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ri_TrigDesc", .fieldtype = "struct TriggerDesc *", .offset = offsetof(struct ResultRelInfo, ri_TrigDesc), .size = sizeof(struct TriggerDesc *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ri_TrigFunctions", .fieldtype = "struct FmgrInfo *", .offset = offsetof(struct ResultRelInfo, ri_TrigFunctions), .size = sizeof(struct FmgrInfo *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ri_TrigWhenExprs", .fieldtype = "struct ExprState **", .offset = offsetof(struct ResultRelInfo, ri_TrigWhenExprs), .size = sizeof(struct ExprState **), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ri_TrigInstrument", .fieldtype = "struct Instrumentation *", .offset = offsetof(struct ResultRelInfo, ri_TrigInstrument), .size = sizeof(struct Instrumentation *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ri_ReturningSlot", .fieldtype = "struct TupleTableSlot *", .offset = offsetof(struct ResultRelInfo, ri_ReturningSlot), .size = sizeof(struct TupleTableSlot *), .flags = TYPE_CAT_POINTER, .node_type_id = 8, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ri_TrigOldSlot", .fieldtype = "struct TupleTableSlot *", .offset = offsetof(struct ResultRelInfo, ri_TrigOldSlot), .size = sizeof(struct TupleTableSlot *), .flags = TYPE_CAT_POINTER, .node_type_id = 8, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ri_TrigNewSlot", .fieldtype = "struct TupleTableSlot *", .offset = offsetof(struct ResultRelInfo, ri_TrigNewSlot), .size = sizeof(struct TupleTableSlot *), .flags = TYPE_CAT_POINTER, .node_type_id = 8, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ri_FdwRoutine", .fieldtype = "struct FdwRoutine *", .offset = offsetof(struct ResultRelInfo, ri_FdwRoutine), .size = sizeof(struct FdwRoutine *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ri_FdwState", .fieldtype = "void *", .offset = offsetof(struct ResultRelInfo, ri_FdwState), .size = sizeof(void *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ri_usesFdwDirectModify", .fieldtype = "_Bool", .offset = offsetof(struct ResultRelInfo, ri_usesFdwDirectModify), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ri_WithCheckOptions", .fieldtype = "struct List *", .offset = offsetof(struct ResultRelInfo, ri_WithCheckOptions), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ri_WithCheckOptionExprs", .fieldtype = "struct List *", .offset = offsetof(struct ResultRelInfo, ri_WithCheckOptionExprs), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ri_ConstraintExprs", .fieldtype = "struct ExprState **", .offset = offsetof(struct ResultRelInfo, ri_ConstraintExprs), .size = sizeof(struct ExprState **), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ri_GeneratedExprs", .fieldtype = "struct ExprState **", .offset = offsetof(struct ResultRelInfo, ri_GeneratedExprs), .size = sizeof(struct ExprState **), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ri_junkFilter", .fieldtype = "struct JunkFilter *", .offset = offsetof(struct ResultRelInfo, ri_junkFilter), .size = sizeof(struct JunkFilter *), .flags = TYPE_CAT_POINTER, .node_type_id = 4, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ri_returningList", .fieldtype = "struct List *", .offset = offsetof(struct ResultRelInfo, ri_returningList), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ri_projectReturning", .fieldtype = "struct ProjectionInfo *", .offset = offsetof(struct ResultRelInfo, ri_projectReturning), .size = sizeof(struct ProjectionInfo *), .flags = TYPE_CAT_POINTER, .node_type_id = 3, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ri_onConflictArbiterIndexes", .fieldtype = "struct List *", .offset = offsetof(struct ResultRelInfo, ri_onConflictArbiterIndexes), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ri_onConflict", .fieldtype = "struct OnConflictSetState *", .offset = offsetof(struct ResultRelInfo, ri_onConflict), .size = sizeof(struct OnConflictSetState *), .flags = TYPE_CAT_POINTER, .node_type_id = 5, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ri_PartitionCheck", .fieldtype = "struct List *", .offset = offsetof(struct ResultRelInfo, ri_PartitionCheck), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ri_PartitionCheckExpr", .fieldtype = "struct ExprState *", .offset = offsetof(struct ResultRelInfo, ri_PartitionCheckExpr), .size = sizeof(struct ExprState *), .flags = TYPE_CAT_POINTER, .node_type_id = 152, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ri_PartitionRoot", .fieldtype = "struct RelationData *", .offset = offsetof(struct ResultRelInfo, ri_PartitionRoot), .size = sizeof(struct RelationData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ri_PartitionInfo", .fieldtype = "struct PartitionRoutingInfo *", .offset = offsetof(struct ResultRelInfo, ri_PartitionInfo), .size = sizeof(struct PartitionRoutingInfo *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ri_CopyMultiInsertBuffer", .fieldtype = "struct CopyMultiInsertBuffer *", .offset = offsetof(struct ResultRelInfo, ri_CopyMultiInsertBuffer), .size = sizeof(struct CopyMultiInsertBuffer *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct EState, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "es_direction", .fieldtype = "enum ScanDirection", .offset = offsetof(struct EState, es_direction), .size = sizeof(enum ScanDirection), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "es_snapshot", .fieldtype = "struct SnapshotData *", .offset = offsetof(struct EState, es_snapshot), .size = sizeof(struct SnapshotData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "es_crosscheck_snapshot", .fieldtype = "struct SnapshotData *", .offset = offsetof(struct EState, es_crosscheck_snapshot), .size = sizeof(struct SnapshotData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "es_range_table", .fieldtype = "struct List *", .offset = offsetof(struct EState, es_range_table), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "es_range_table_size", .fieldtype = "unsigned int", .offset = offsetof(struct EState, es_range_table_size), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "es_relations", .fieldtype = "struct RelationData **", .offset = offsetof(struct EState, es_relations), .size = sizeof(struct RelationData **), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "es_rowmarks", .fieldtype = "struct ExecRowMark **", .offset = offsetof(struct EState, es_rowmarks), .size = sizeof(struct ExecRowMark **), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "es_plannedstmt", .fieldtype = "struct PlannedStmt *", .offset = offsetof(struct EState, es_plannedstmt), .size = sizeof(struct PlannedStmt *), .flags = TYPE_CAT_POINTER, .node_type_id = 229, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "es_sourceText", .fieldtype = "const char *", .offset = offsetof(struct EState, es_sourceText), .size = sizeof(const char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "es_junkFilter", .fieldtype = "struct JunkFilter *", .offset = offsetof(struct EState, es_junkFilter), .size = sizeof(struct JunkFilter *), .flags = TYPE_CAT_POINTER, .node_type_id = 4, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "es_output_cid", .fieldtype = "unsigned int", .offset = offsetof(struct EState, es_output_cid), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "es_result_relations", .fieldtype = "struct ResultRelInfo *", .offset = offsetof(struct EState, es_result_relations), .size = sizeof(struct ResultRelInfo *), .flags = TYPE_CAT_POINTER, .node_type_id = 6, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "es_num_result_relations", .fieldtype = "int", .offset = offsetof(struct EState, es_num_result_relations), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "es_result_relation_info", .fieldtype = "struct ResultRelInfo *", .offset = offsetof(struct EState, es_result_relation_info), .size = sizeof(struct ResultRelInfo *), .flags = TYPE_CAT_POINTER, .node_type_id = 6, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "es_root_result_relations", .fieldtype = "struct ResultRelInfo *", .offset = offsetof(struct EState, es_root_result_relations), .size = sizeof(struct ResultRelInfo *), .flags = TYPE_CAT_POINTER, .node_type_id = 6, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "es_num_root_result_relations", .fieldtype = "int", .offset = offsetof(struct EState, es_num_root_result_relations), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "es_partition_directory", .fieldtype = "struct PartitionDirectoryData *", .offset = offsetof(struct EState, es_partition_directory), .size = sizeof(struct PartitionDirectoryData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "es_tuple_routing_result_relations", .fieldtype = "struct List *", .offset = offsetof(struct EState, es_tuple_routing_result_relations), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "es_trig_target_relations", .fieldtype = "struct List *", .offset = offsetof(struct EState, es_trig_target_relations), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "es_param_list_info", .fieldtype = "struct ParamListInfoData *", .offset = offsetof(struct EState, es_param_list_info), .size = sizeof(struct ParamListInfoData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "es_param_exec_vals", .fieldtype = "struct ParamExecData *", .offset = offsetof(struct EState, es_param_exec_vals), .size = sizeof(struct ParamExecData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "es_queryEnv", .fieldtype = "struct QueryEnvironment *", .offset = offsetof(struct EState, es_queryEnv), .size = sizeof(struct QueryEnvironment *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "es_query_cxt", .fieldtype = "struct MemoryContextData *", .offset = offsetof(struct EState, es_query_cxt), .size = sizeof(struct MemoryContextData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "es_tupleTable", .fieldtype = "struct List *", .offset = offsetof(struct EState, es_tupleTable), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "es_processed", .fieldtype = "unsigned long", .offset = offsetof(struct EState, es_processed), .size = sizeof(unsigned long), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "es_top_eflags", .fieldtype = "int", .offset = offsetof(struct EState, es_top_eflags), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "es_instrument", .fieldtype = "int", .offset = offsetof(struct EState, es_instrument), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "es_finished", .fieldtype = "_Bool", .offset = offsetof(struct EState, es_finished), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "es_exprcontexts", .fieldtype = "struct List *", .offset = offsetof(struct EState, es_exprcontexts), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "es_subplanstates", .fieldtype = "struct List *", .offset = offsetof(struct EState, es_subplanstates), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "es_auxmodifytables", .fieldtype = "struct List *", .offset = offsetof(struct EState, es_auxmodifytables), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "es_per_tuple_exprcontext", .fieldtype = "struct ExprContext *", .offset = offsetof(struct EState, es_per_tuple_exprcontext), .size = sizeof(struct ExprContext *), .flags = TYPE_CAT_POINTER, .node_type_id = 2, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "es_epqTupleSlot", .fieldtype = "struct TupleTableSlot **", .offset = offsetof(struct EState, es_epqTupleSlot), .size = sizeof(struct TupleTableSlot **), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "es_epqScanDone", .fieldtype = "_Bool *", .offset = offsetof(struct EState, es_epqScanDone), .size = sizeof(_Bool *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "es_use_parallel_mode", .fieldtype = "_Bool", .offset = offsetof(struct EState, es_use_parallel_mode), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "es_query_dsa", .fieldtype = "struct dsa_area *", .offset = offsetof(struct EState, es_query_dsa), .size = sizeof(struct dsa_area *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "es_jit_flags", .fieldtype = "int", .offset = offsetof(struct EState, es_jit_flags), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "es_jit", .fieldtype = "struct JitContext *", .offset = offsetof(struct EState, es_jit), .size = sizeof(struct JitContext *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "es_jit_worker_instr", .fieldtype = "struct JitInstrumentation *", .offset = offsetof(struct EState, es_jit_worker_instr), .size = sizeof(struct JitInstrumentation *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct AggrefExprState, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "aggref", .fieldtype = "struct Aggref *", .offset = offsetof(struct AggrefExprState, aggref), .size = sizeof(struct Aggref *), .flags = TYPE_CAT_POINTER, .node_type_id = 107, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "aggno", .fieldtype = "int", .offset = offsetof(struct AggrefExprState, aggno), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct WindowFuncExprState, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "wfunc", .fieldtype = "struct WindowFunc *", .offset = offsetof(struct WindowFuncExprState, wfunc), .size = sizeof(struct WindowFunc *), .flags = TYPE_CAT_POINTER, .node_type_id = 109, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "args", .fieldtype = "struct List *", .offset = offsetof(struct WindowFuncExprState, args), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "aggfilter", .fieldtype = "struct ExprState *", .offset = offsetof(struct WindowFuncExprState, aggfilter), .size = sizeof(struct ExprState *), .flags = TYPE_CAT_POINTER, .node_type_id = 152, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "wfuncno", .fieldtype = "int", .offset = offsetof(struct WindowFuncExprState, wfuncno), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct SetExprState, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "expr", .fieldtype = "struct Expr *", .offset = offsetof(struct SetExprState, expr), .size = sizeof(struct Expr *), .flags = TYPE_CAT_POINTER, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "args", .fieldtype = "struct List *", .offset = offsetof(struct SetExprState, args), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "elidedFuncState", .fieldtype = "struct ExprState *", .offset = offsetof(struct SetExprState, elidedFuncState), .size = sizeof(struct ExprState *), .flags = TYPE_CAT_POINTER, .node_type_id = 152, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "func", .fieldtype = "struct FmgrInfo", .offset = offsetof(struct SetExprState, func), .size = sizeof(struct FmgrInfo), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "funcResultStore", .fieldtype = "struct Tuplestorestate *", .offset = offsetof(struct SetExprState, funcResultStore), .size = sizeof(struct Tuplestorestate *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "funcResultSlot", .fieldtype = "struct TupleTableSlot *", .offset = offsetof(struct SetExprState, funcResultSlot), .size = sizeof(struct TupleTableSlot *), .flags = TYPE_CAT_POINTER, .node_type_id = 8, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "funcResultDesc", .fieldtype = "struct TupleDescData *", .offset = offsetof(struct SetExprState, funcResultDesc), .size = sizeof(struct TupleDescData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "funcReturnsTuple", .fieldtype = "_Bool", .offset = offsetof(struct SetExprState, funcReturnsTuple), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "funcReturnsSet", .fieldtype = "_Bool", .offset = offsetof(struct SetExprState, funcReturnsSet), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "setArgsValid", .fieldtype = "_Bool", .offset = offsetof(struct SetExprState, setArgsValid), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "shutdown_reg", .fieldtype = "_Bool", .offset = offsetof(struct SetExprState, shutdown_reg), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "fcinfo", .fieldtype = "struct FunctionCallInfoBaseData *", .offset = offsetof(struct SetExprState, fcinfo), .size = sizeof(struct FunctionCallInfoBaseData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct SubPlanState, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "subplan", .fieldtype = "struct SubPlan *", .offset = offsetof(struct SubPlanState, subplan), .size = sizeof(struct SubPlan *), .flags = TYPE_CAT_POINTER, .node_type_id = 119, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "planstate", .fieldtype = "struct PlanState *", .offset = offsetof(struct SubPlanState, planstate), .size = sizeof(struct PlanState *), .flags = TYPE_CAT_POINTER, .node_type_id = 58, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "parent", .fieldtype = "struct PlanState *", .offset = offsetof(struct SubPlanState, parent), .size = sizeof(struct PlanState *), .flags = TYPE_CAT_POINTER, .node_type_id = 58, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "testexpr", .fieldtype = "struct ExprState *", .offset = offsetof(struct SubPlanState, testexpr), .size = sizeof(struct ExprState *), .flags = TYPE_CAT_POINTER, .node_type_id = 152, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "args", .fieldtype = "struct List *", .offset = offsetof(struct SubPlanState, args), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "curTuple", .fieldtype = "struct HeapTupleData *", .offset = offsetof(struct SubPlanState, curTuple), .size = sizeof(struct HeapTupleData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "curArray", .fieldtype = "unsigned long", .offset = offsetof(struct SubPlanState, curArray), .size = sizeof(unsigned long), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "descRight", .fieldtype = "struct TupleDescData *", .offset = offsetof(struct SubPlanState, descRight), .size = sizeof(struct TupleDescData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "projLeft", .fieldtype = "struct ProjectionInfo *", .offset = offsetof(struct SubPlanState, projLeft), .size = sizeof(struct ProjectionInfo *), .flags = TYPE_CAT_POINTER, .node_type_id = 3, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "projRight", .fieldtype = "struct ProjectionInfo *", .offset = offsetof(struct SubPlanState, projRight), .size = sizeof(struct ProjectionInfo *), .flags = TYPE_CAT_POINTER, .node_type_id = 3, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "hashtable", .fieldtype = "struct TupleHashTableData *", .offset = offsetof(struct SubPlanState, hashtable), .size = sizeof(struct TupleHashTableData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "hashnulls", .fieldtype = "struct TupleHashTableData *", .offset = offsetof(struct SubPlanState, hashnulls), .size = sizeof(struct TupleHashTableData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "havehashrows", .fieldtype = "_Bool", .offset = offsetof(struct SubPlanState, havehashrows), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "havenullrows", .fieldtype = "_Bool", .offset = offsetof(struct SubPlanState, havenullrows), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "hashtablecxt", .fieldtype = "struct MemoryContextData *", .offset = offsetof(struct SubPlanState, hashtablecxt), .size = sizeof(struct MemoryContextData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "hashtempcxt", .fieldtype = "struct MemoryContextData *", .offset = offsetof(struct SubPlanState, hashtempcxt), .size = sizeof(struct MemoryContextData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "innerecontext", .fieldtype = "struct ExprContext *", .offset = offsetof(struct SubPlanState, innerecontext), .size = sizeof(struct ExprContext *), .flags = TYPE_CAT_POINTER, .node_type_id = 2, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "keyColIdx", .fieldtype = "short *", .offset = offsetof(struct SubPlanState, keyColIdx), .size = sizeof(short *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "tab_eq_funcoids", .fieldtype = "unsigned int *", .offset = offsetof(struct SubPlanState, tab_eq_funcoids), .size = sizeof(unsigned int *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "tab_collations", .fieldtype = "unsigned int *", .offset = offsetof(struct SubPlanState, tab_collations), .size = sizeof(unsigned int *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "tab_hash_funcs", .fieldtype = "struct FmgrInfo *", .offset = offsetof(struct SubPlanState, tab_hash_funcs), .size = sizeof(struct FmgrInfo *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "tab_eq_funcs", .fieldtype = "struct FmgrInfo *", .offset = offsetof(struct SubPlanState, tab_eq_funcs), .size = sizeof(struct FmgrInfo *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "lhs_hash_funcs", .fieldtype = "struct FmgrInfo *", .offset = offsetof(struct SubPlanState, lhs_hash_funcs), .size = sizeof(struct FmgrInfo *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "cur_eq_funcs", .fieldtype = "struct FmgrInfo *", .offset = offsetof(struct SubPlanState, cur_eq_funcs), .size = sizeof(struct FmgrInfo *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "cur_eq_comp", .fieldtype = "struct ExprState *", .offset = offsetof(struct SubPlanState, cur_eq_comp), .size = sizeof(struct ExprState *), .flags = TYPE_CAT_POINTER, .node_type_id = 152, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct AlternativeSubPlanState, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "subplan", .fieldtype = "struct AlternativeSubPlan *", .offset = offsetof(struct AlternativeSubPlanState, subplan), .size = sizeof(struct AlternativeSubPlan *), .flags = TYPE_CAT_POINTER, .node_type_id = 120, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "subplans", .fieldtype = "struct List *", .offset = offsetof(struct AlternativeSubPlanState, subplans), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "active", .fieldtype = "int", .offset = offsetof(struct AlternativeSubPlanState, active), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct DomainConstraintState, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "constrainttype", .fieldtype = "enum DomainConstraintType", .offset = offsetof(struct DomainConstraintState, constrainttype), .size = sizeof(enum DomainConstraintType), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "name", .fieldtype = "char *", .offset = offsetof(struct DomainConstraintState, name), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "check_expr", .fieldtype = "struct Expr *", .offset = offsetof(struct DomainConstraintState, check_expr), .size = sizeof(struct Expr *), .flags = TYPE_CAT_POINTER, .node_type_id = 103, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "check_exprstate", .fieldtype = "struct ExprState *", .offset = offsetof(struct DomainConstraintState, check_exprstate), .size = sizeof(struct ExprState *), .flags = TYPE_CAT_POINTER, .node_type_id = 152, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct PlanState, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "plan", .fieldtype = "struct Plan *", .offset = offsetof(struct PlanState, plan), .size = sizeof(struct Plan *), .flags = TYPE_CAT_POINTER, .node_type_id = 9, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "state", .fieldtype = "struct EState *", .offset = offsetof(struct PlanState, state), .size = sizeof(struct EState *), .flags = TYPE_CAT_POINTER, .node_type_id = 7, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ExecProcNode", .fieldtype = "struct TupleTableSlot *(*)(struct PlanState *)", .offset = offsetof(struct PlanState, ExecProcNode), .size = sizeof(struct TupleTableSlot *(*)(struct PlanState *)), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ExecProcNodeReal", .fieldtype = "struct TupleTableSlot *(*)(struct PlanState *)", .offset = offsetof(struct PlanState, ExecProcNodeReal), .size = sizeof(struct TupleTableSlot *(*)(struct PlanState *)), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "instrument", .fieldtype = "struct Instrumentation *", .offset = offsetof(struct PlanState, instrument), .size = sizeof(struct Instrumentation *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "worker_instrument", .fieldtype = "struct WorkerInstrumentation *", .offset = offsetof(struct PlanState, worker_instrument), .size = sizeof(struct WorkerInstrumentation *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "worker_jit_instrument", .fieldtype = "struct SharedJitInstrumentation *", .offset = offsetof(struct PlanState, worker_jit_instrument), .size = sizeof(struct SharedJitInstrumentation *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "qual", .fieldtype = "struct ExprState *", .offset = offsetof(struct PlanState, qual), .size = sizeof(struct ExprState *), .flags = TYPE_CAT_POINTER, .node_type_id = 152, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "lefttree", .fieldtype = "struct PlanState *", .offset = offsetof(struct PlanState, lefttree), .size = sizeof(struct PlanState *), .flags = TYPE_CAT_POINTER, .node_type_id = 58, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "righttree", .fieldtype = "struct PlanState *", .offset = offsetof(struct PlanState, righttree), .size = sizeof(struct PlanState *), .flags = TYPE_CAT_POINTER, .node_type_id = 58, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "initPlan", .fieldtype = "struct List *", .offset = offsetof(struct PlanState, initPlan), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "subPlan", .fieldtype = "struct List *", .offset = offsetof(struct PlanState, subPlan), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "chgParam", .fieldtype = "struct Bitmapset *", .offset = offsetof(struct PlanState, chgParam), .size = sizeof(struct Bitmapset *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_BITMAPSET},
+	{.fieldname = "ps_ResultTupleDesc", .fieldtype = "struct TupleDescData *", .offset = offsetof(struct PlanState, ps_ResultTupleDesc), .size = sizeof(struct TupleDescData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ps_ResultTupleSlot", .fieldtype = "struct TupleTableSlot *", .offset = offsetof(struct PlanState, ps_ResultTupleSlot), .size = sizeof(struct TupleTableSlot *), .flags = TYPE_CAT_POINTER, .node_type_id = 8, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ps_ExprContext", .fieldtype = "struct ExprContext *", .offset = offsetof(struct PlanState, ps_ExprContext), .size = sizeof(struct ExprContext *), .flags = TYPE_CAT_POINTER, .node_type_id = 2, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ps_ProjInfo", .fieldtype = "struct ProjectionInfo *", .offset = offsetof(struct PlanState, ps_ProjInfo), .size = sizeof(struct ProjectionInfo *), .flags = TYPE_CAT_POINTER, .node_type_id = 3, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "scandesc", .fieldtype = "struct TupleDescData *", .offset = offsetof(struct PlanState, scandesc), .size = sizeof(struct TupleDescData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "scanops", .fieldtype = "const struct TupleTableSlotOps *", .offset = offsetof(struct PlanState, scanops), .size = sizeof(const struct TupleTableSlotOps *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "outerops", .fieldtype = "const struct TupleTableSlotOps *", .offset = offsetof(struct PlanState, outerops), .size = sizeof(const struct TupleTableSlotOps *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "innerops", .fieldtype = "const struct TupleTableSlotOps *", .offset = offsetof(struct PlanState, innerops), .size = sizeof(const struct TupleTableSlotOps *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "resultops", .fieldtype = "const struct TupleTableSlotOps *", .offset = offsetof(struct PlanState, resultops), .size = sizeof(const struct TupleTableSlotOps *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "scanopsfixed", .fieldtype = "_Bool", .offset = offsetof(struct PlanState, scanopsfixed), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "outeropsfixed", .fieldtype = "_Bool", .offset = offsetof(struct PlanState, outeropsfixed), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "inneropsfixed", .fieldtype = "_Bool", .offset = offsetof(struct PlanState, inneropsfixed), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "resultopsfixed", .fieldtype = "_Bool", .offset = offsetof(struct PlanState, resultopsfixed), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "scanopsset", .fieldtype = "_Bool", .offset = offsetof(struct PlanState, scanopsset), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "outeropsset", .fieldtype = "_Bool", .offset = offsetof(struct PlanState, outeropsset), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "inneropsset", .fieldtype = "_Bool", .offset = offsetof(struct PlanState, inneropsset), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "resultopsset", .fieldtype = "_Bool", .offset = offsetof(struct PlanState, resultopsset), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ps", .fieldtype = "struct PlanState", .offset = offsetof(struct ResultState, ps), .size = sizeof(struct PlanState), .flags = TYPE_CAT_SCALAR, .node_type_id = 58, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "resconstantqual", .fieldtype = "struct ExprState *", .offset = offsetof(struct ResultState, resconstantqual), .size = sizeof(struct ExprState *), .flags = TYPE_CAT_POINTER, .node_type_id = 152, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "rs_done", .fieldtype = "_Bool", .offset = offsetof(struct ResultState, rs_done), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "rs_checkqual", .fieldtype = "_Bool", .offset = offsetof(struct ResultState, rs_checkqual), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ps", .fieldtype = "struct PlanState", .offset = offsetof(struct ProjectSetState, ps), .size = sizeof(struct PlanState), .flags = TYPE_CAT_SCALAR, .node_type_id = 58, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "elems", .fieldtype = "struct Node **", .offset = offsetof(struct ProjectSetState, elems), .size = sizeof(struct Node **), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "elemdone", .fieldtype = "ExprDoneCond *", .offset = offsetof(struct ProjectSetState, elemdone), .size = sizeof(ExprDoneCond *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "nelems", .fieldtype = "int", .offset = offsetof(struct ProjectSetState, nelems), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "pending_srf_tuples", .fieldtype = "_Bool", .offset = offsetof(struct ProjectSetState, pending_srf_tuples), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "argcontext", .fieldtype = "struct MemoryContextData *", .offset = offsetof(struct ProjectSetState, argcontext), .size = sizeof(struct MemoryContextData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ps", .fieldtype = "struct PlanState", .offset = offsetof(struct ModifyTableState, ps), .size = sizeof(struct PlanState), .flags = TYPE_CAT_SCALAR, .node_type_id = 58, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "operation", .fieldtype = "enum CmdType", .offset = offsetof(struct ModifyTableState, operation), .size = sizeof(enum CmdType), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "canSetTag", .fieldtype = "_Bool", .offset = offsetof(struct ModifyTableState, canSetTag), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "mt_done", .fieldtype = "_Bool", .offset = offsetof(struct ModifyTableState, mt_done), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "mt_plans", .fieldtype = "struct PlanState **", .offset = offsetof(struct ModifyTableState, mt_plans), .size = sizeof(struct PlanState **), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "mt_nplans", .fieldtype = "int", .offset = offsetof(struct ModifyTableState, mt_nplans), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "mt_whichplan", .fieldtype = "int", .offset = offsetof(struct ModifyTableState, mt_whichplan), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "mt_scans", .fieldtype = "struct TupleTableSlot **", .offset = offsetof(struct ModifyTableState, mt_scans), .size = sizeof(struct TupleTableSlot **), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "resultRelInfo", .fieldtype = "struct ResultRelInfo *", .offset = offsetof(struct ModifyTableState, resultRelInfo), .size = sizeof(struct ResultRelInfo *), .flags = TYPE_CAT_POINTER, .node_type_id = 6, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "rootResultRelInfo", .fieldtype = "struct ResultRelInfo *", .offset = offsetof(struct ModifyTableState, rootResultRelInfo), .size = sizeof(struct ResultRelInfo *), .flags = TYPE_CAT_POINTER, .node_type_id = 6, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "mt_arowmarks", .fieldtype = "struct List **", .offset = offsetof(struct ModifyTableState, mt_arowmarks), .size = sizeof(struct List **), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "mt_epqstate", .fieldtype = "struct EPQState", .offset = offsetof(struct ModifyTableState, mt_epqstate), .size = sizeof(struct EPQState), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "fireBSTriggers", .fieldtype = "_Bool", .offset = offsetof(struct ModifyTableState, fireBSTriggers), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "mt_excludedtlist", .fieldtype = "struct List *", .offset = offsetof(struct ModifyTableState, mt_excludedtlist), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "mt_root_tuple_slot", .fieldtype = "struct TupleTableSlot *", .offset = offsetof(struct ModifyTableState, mt_root_tuple_slot), .size = sizeof(struct TupleTableSlot *), .flags = TYPE_CAT_POINTER, .node_type_id = 8, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "mt_partition_tuple_routing", .fieldtype = "struct PartitionTupleRouting *", .offset = offsetof(struct ModifyTableState, mt_partition_tuple_routing), .size = sizeof(struct PartitionTupleRouting *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "mt_transition_capture", .fieldtype = "struct TransitionCaptureState *", .offset = offsetof(struct ModifyTableState, mt_transition_capture), .size = sizeof(struct TransitionCaptureState *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "mt_oc_transition_capture", .fieldtype = "struct TransitionCaptureState *", .offset = offsetof(struct ModifyTableState, mt_oc_transition_capture), .size = sizeof(struct TransitionCaptureState *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "mt_per_subplan_tupconv_maps", .fieldtype = "struct TupleConversionMap **", .offset = offsetof(struct ModifyTableState, mt_per_subplan_tupconv_maps), .size = sizeof(struct TupleConversionMap **), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ps", .fieldtype = "struct PlanState", .offset = offsetof(struct AppendState, ps), .size = sizeof(struct PlanState), .flags = TYPE_CAT_SCALAR, .node_type_id = 58, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "appendplans", .fieldtype = "struct PlanState **", .offset = offsetof(struct AppendState, appendplans), .size = sizeof(struct PlanState **), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "as_nplans", .fieldtype = "int", .offset = offsetof(struct AppendState, as_nplans), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "as_whichplan", .fieldtype = "int", .offset = offsetof(struct AppendState, as_whichplan), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "as_first_partial_plan", .fieldtype = "int", .offset = offsetof(struct AppendState, as_first_partial_plan), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "as_pstate", .fieldtype = "struct ParallelAppendState *", .offset = offsetof(struct AppendState, as_pstate), .size = sizeof(struct ParallelAppendState *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "pstate_len", .fieldtype = "unsigned long", .offset = offsetof(struct AppendState, pstate_len), .size = sizeof(unsigned long), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "as_prune_state", .fieldtype = "struct PartitionPruneState *", .offset = offsetof(struct AppendState, as_prune_state), .size = sizeof(struct PartitionPruneState *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "as_valid_subplans", .fieldtype = "struct Bitmapset *", .offset = offsetof(struct AppendState, as_valid_subplans), .size = sizeof(struct Bitmapset *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_BITMAPSET},
+	{.fieldname = "choose_next_subplan", .fieldtype = "_Bool (*)(struct AppendState *)", .offset = offsetof(struct AppendState, choose_next_subplan), .size = sizeof(_Bool (*)(struct AppendState *)), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ps", .fieldtype = "struct PlanState", .offset = offsetof(struct MergeAppendState, ps), .size = sizeof(struct PlanState), .flags = TYPE_CAT_SCALAR, .node_type_id = 58, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "mergeplans", .fieldtype = "struct PlanState **", .offset = offsetof(struct MergeAppendState, mergeplans), .size = sizeof(struct PlanState **), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ms_nplans", .fieldtype = "int", .offset = offsetof(struct MergeAppendState, ms_nplans), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ms_nkeys", .fieldtype = "int", .offset = offsetof(struct MergeAppendState, ms_nkeys), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ms_sortkeys", .fieldtype = "struct SortSupportData *", .offset = offsetof(struct MergeAppendState, ms_sortkeys), .size = sizeof(struct SortSupportData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ms_slots", .fieldtype = "struct TupleTableSlot **", .offset = offsetof(struct MergeAppendState, ms_slots), .size = sizeof(struct TupleTableSlot **), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ms_heap", .fieldtype = "struct binaryheap *", .offset = offsetof(struct MergeAppendState, ms_heap), .size = sizeof(struct binaryheap *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ms_initialized", .fieldtype = "_Bool", .offset = offsetof(struct MergeAppendState, ms_initialized), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ms_noopscan", .fieldtype = "_Bool", .offset = offsetof(struct MergeAppendState, ms_noopscan), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ms_prune_state", .fieldtype = "struct PartitionPruneState *", .offset = offsetof(struct MergeAppendState, ms_prune_state), .size = sizeof(struct PartitionPruneState *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ms_valid_subplans", .fieldtype = "struct Bitmapset *", .offset = offsetof(struct MergeAppendState, ms_valid_subplans), .size = sizeof(struct Bitmapset *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_BITMAPSET},
+	{.fieldname = "ps", .fieldtype = "struct PlanState", .offset = offsetof(struct RecursiveUnionState, ps), .size = sizeof(struct PlanState), .flags = TYPE_CAT_SCALAR, .node_type_id = 58, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "recursing", .fieldtype = "_Bool", .offset = offsetof(struct RecursiveUnionState, recursing), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "intermediate_empty", .fieldtype = "_Bool", .offset = offsetof(struct RecursiveUnionState, intermediate_empty), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "working_table", .fieldtype = "struct Tuplestorestate *", .offset = offsetof(struct RecursiveUnionState, working_table), .size = sizeof(struct Tuplestorestate *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "intermediate_table", .fieldtype = "struct Tuplestorestate *", .offset = offsetof(struct RecursiveUnionState, intermediate_table), .size = sizeof(struct Tuplestorestate *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "eqfuncoids", .fieldtype = "unsigned int *", .offset = offsetof(struct RecursiveUnionState, eqfuncoids), .size = sizeof(unsigned int *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "hashfunctions", .fieldtype = "struct FmgrInfo *", .offset = offsetof(struct RecursiveUnionState, hashfunctions), .size = sizeof(struct FmgrInfo *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "tempContext", .fieldtype = "struct MemoryContextData *", .offset = offsetof(struct RecursiveUnionState, tempContext), .size = sizeof(struct MemoryContextData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "hashtable", .fieldtype = "struct TupleHashTableData *", .offset = offsetof(struct RecursiveUnionState, hashtable), .size = sizeof(struct TupleHashTableData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "tableContext", .fieldtype = "struct MemoryContextData *", .offset = offsetof(struct RecursiveUnionState, tableContext), .size = sizeof(struct MemoryContextData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ps", .fieldtype = "struct PlanState", .offset = offsetof(struct BitmapAndState, ps), .size = sizeof(struct PlanState), .flags = TYPE_CAT_SCALAR, .node_type_id = 58, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "bitmapplans", .fieldtype = "struct PlanState **", .offset = offsetof(struct BitmapAndState, bitmapplans), .size = sizeof(struct PlanState **), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "nplans", .fieldtype = "int", .offset = offsetof(struct BitmapAndState, nplans), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ps", .fieldtype = "struct PlanState", .offset = offsetof(struct BitmapOrState, ps), .size = sizeof(struct PlanState), .flags = TYPE_CAT_SCALAR, .node_type_id = 58, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "bitmapplans", .fieldtype = "struct PlanState **", .offset = offsetof(struct BitmapOrState, bitmapplans), .size = sizeof(struct PlanState **), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "nplans", .fieldtype = "int", .offset = offsetof(struct BitmapOrState, nplans), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ps", .fieldtype = "struct PlanState", .offset = offsetof(struct ScanState, ps), .size = sizeof(struct PlanState), .flags = TYPE_CAT_SCALAR, .node_type_id = 58, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ss_currentRelation", .fieldtype = "struct RelationData *", .offset = offsetof(struct ScanState, ss_currentRelation), .size = sizeof(struct RelationData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ss_currentScanDesc", .fieldtype = "struct TableScanDescData *", .offset = offsetof(struct ScanState, ss_currentScanDesc), .size = sizeof(struct TableScanDescData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ss_ScanTupleSlot", .fieldtype = "struct TupleTableSlot *", .offset = offsetof(struct ScanState, ss_ScanTupleSlot), .size = sizeof(struct TupleTableSlot *), .flags = TYPE_CAT_POINTER, .node_type_id = 8, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ss", .fieldtype = "struct ScanState", .offset = offsetof(struct SeqScanState, ss), .size = sizeof(struct ScanState), .flags = TYPE_CAT_SCALAR, .node_type_id = 67, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "pscan_len", .fieldtype = "unsigned long", .offset = offsetof(struct SeqScanState, pscan_len), .size = sizeof(unsigned long), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ss", .fieldtype = "struct ScanState", .offset = offsetof(struct SampleScanState, ss), .size = sizeof(struct ScanState), .flags = TYPE_CAT_SCALAR, .node_type_id = 67, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "args", .fieldtype = "struct List *", .offset = offsetof(struct SampleScanState, args), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "repeatable", .fieldtype = "struct ExprState *", .offset = offsetof(struct SampleScanState, repeatable), .size = sizeof(struct ExprState *), .flags = TYPE_CAT_POINTER, .node_type_id = 152, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "tsmroutine", .fieldtype = "struct TsmRoutine *", .offset = offsetof(struct SampleScanState, tsmroutine), .size = sizeof(struct TsmRoutine *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "tsm_state", .fieldtype = "void *", .offset = offsetof(struct SampleScanState, tsm_state), .size = sizeof(void *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "use_bulkread", .fieldtype = "_Bool", .offset = offsetof(struct SampleScanState, use_bulkread), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "use_pagemode", .fieldtype = "_Bool", .offset = offsetof(struct SampleScanState, use_pagemode), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "begun", .fieldtype = "_Bool", .offset = offsetof(struct SampleScanState, begun), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "seed", .fieldtype = "unsigned int", .offset = offsetof(struct SampleScanState, seed), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "donetuples", .fieldtype = "long", .offset = offsetof(struct SampleScanState, donetuples), .size = sizeof(long), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "haveblock", .fieldtype = "_Bool", .offset = offsetof(struct SampleScanState, haveblock), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "done", .fieldtype = "_Bool", .offset = offsetof(struct SampleScanState, done), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ss", .fieldtype = "struct ScanState", .offset = offsetof(struct IndexScanState, ss), .size = sizeof(struct ScanState), .flags = TYPE_CAT_SCALAR, .node_type_id = 67, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "indexqualorig", .fieldtype = "struct ExprState *", .offset = offsetof(struct IndexScanState, indexqualorig), .size = sizeof(struct ExprState *), .flags = TYPE_CAT_POINTER, .node_type_id = 152, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "indexorderbyorig", .fieldtype = "struct List *", .offset = offsetof(struct IndexScanState, indexorderbyorig), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "iss_ScanKeys", .fieldtype = "struct ScanKeyData *", .offset = offsetof(struct IndexScanState, iss_ScanKeys), .size = sizeof(struct ScanKeyData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "iss_NumScanKeys", .fieldtype = "int", .offset = offsetof(struct IndexScanState, iss_NumScanKeys), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "iss_OrderByKeys", .fieldtype = "struct ScanKeyData *", .offset = offsetof(struct IndexScanState, iss_OrderByKeys), .size = sizeof(struct ScanKeyData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "iss_NumOrderByKeys", .fieldtype = "int", .offset = offsetof(struct IndexScanState, iss_NumOrderByKeys), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "iss_RuntimeKeys", .fieldtype = "IndexRuntimeKeyInfo *", .offset = offsetof(struct IndexScanState, iss_RuntimeKeys), .size = sizeof(IndexRuntimeKeyInfo *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "iss_NumRuntimeKeys", .fieldtype = "int", .offset = offsetof(struct IndexScanState, iss_NumRuntimeKeys), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "iss_RuntimeKeysReady", .fieldtype = "_Bool", .offset = offsetof(struct IndexScanState, iss_RuntimeKeysReady), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "iss_RuntimeContext", .fieldtype = "struct ExprContext *", .offset = offsetof(struct IndexScanState, iss_RuntimeContext), .size = sizeof(struct ExprContext *), .flags = TYPE_CAT_POINTER, .node_type_id = 2, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "iss_RelationDesc", .fieldtype = "struct RelationData *", .offset = offsetof(struct IndexScanState, iss_RelationDesc), .size = sizeof(struct RelationData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "iss_ScanDesc", .fieldtype = "struct IndexScanDescData *", .offset = offsetof(struct IndexScanState, iss_ScanDesc), .size = sizeof(struct IndexScanDescData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "iss_ReorderQueue", .fieldtype = "struct pairingheap *", .offset = offsetof(struct IndexScanState, iss_ReorderQueue), .size = sizeof(struct pairingheap *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "iss_ReachedEnd", .fieldtype = "_Bool", .offset = offsetof(struct IndexScanState, iss_ReachedEnd), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "iss_OrderByValues", .fieldtype = "unsigned long *", .offset = offsetof(struct IndexScanState, iss_OrderByValues), .size = sizeof(unsigned long *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "iss_OrderByNulls", .fieldtype = "_Bool *", .offset = offsetof(struct IndexScanState, iss_OrderByNulls), .size = sizeof(_Bool *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "iss_SortSupport", .fieldtype = "struct SortSupportData *", .offset = offsetof(struct IndexScanState, iss_SortSupport), .size = sizeof(struct SortSupportData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "iss_OrderByTypByVals", .fieldtype = "_Bool *", .offset = offsetof(struct IndexScanState, iss_OrderByTypByVals), .size = sizeof(_Bool *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "iss_OrderByTypLens", .fieldtype = "short *", .offset = offsetof(struct IndexScanState, iss_OrderByTypLens), .size = sizeof(short *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "iss_PscanLen", .fieldtype = "unsigned long", .offset = offsetof(struct IndexScanState, iss_PscanLen), .size = sizeof(unsigned long), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ss", .fieldtype = "struct ScanState", .offset = offsetof(struct IndexOnlyScanState, ss), .size = sizeof(struct ScanState), .flags = TYPE_CAT_SCALAR, .node_type_id = 67, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "indexqual", .fieldtype = "struct ExprState *", .offset = offsetof(struct IndexOnlyScanState, indexqual), .size = sizeof(struct ExprState *), .flags = TYPE_CAT_POINTER, .node_type_id = 152, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ioss_ScanKeys", .fieldtype = "struct ScanKeyData *", .offset = offsetof(struct IndexOnlyScanState, ioss_ScanKeys), .size = sizeof(struct ScanKeyData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ioss_NumScanKeys", .fieldtype = "int", .offset = offsetof(struct IndexOnlyScanState, ioss_NumScanKeys), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ioss_OrderByKeys", .fieldtype = "struct ScanKeyData *", .offset = offsetof(struct IndexOnlyScanState, ioss_OrderByKeys), .size = sizeof(struct ScanKeyData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ioss_NumOrderByKeys", .fieldtype = "int", .offset = offsetof(struct IndexOnlyScanState, ioss_NumOrderByKeys), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ioss_RuntimeKeys", .fieldtype = "IndexRuntimeKeyInfo *", .offset = offsetof(struct IndexOnlyScanState, ioss_RuntimeKeys), .size = sizeof(IndexRuntimeKeyInfo *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ioss_NumRuntimeKeys", .fieldtype = "int", .offset = offsetof(struct IndexOnlyScanState, ioss_NumRuntimeKeys), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ioss_RuntimeKeysReady", .fieldtype = "_Bool", .offset = offsetof(struct IndexOnlyScanState, ioss_RuntimeKeysReady), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ioss_RuntimeContext", .fieldtype = "struct ExprContext *", .offset = offsetof(struct IndexOnlyScanState, ioss_RuntimeContext), .size = sizeof(struct ExprContext *), .flags = TYPE_CAT_POINTER, .node_type_id = 2, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ioss_RelationDesc", .fieldtype = "struct RelationData *", .offset = offsetof(struct IndexOnlyScanState, ioss_RelationDesc), .size = sizeof(struct RelationData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ioss_ScanDesc", .fieldtype = "struct IndexScanDescData *", .offset = offsetof(struct IndexOnlyScanState, ioss_ScanDesc), .size = sizeof(struct IndexScanDescData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ioss_TableSlot", .fieldtype = "struct TupleTableSlot *", .offset = offsetof(struct IndexOnlyScanState, ioss_TableSlot), .size = sizeof(struct TupleTableSlot *), .flags = TYPE_CAT_POINTER, .node_type_id = 8, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ioss_VMBuffer", .fieldtype = "int", .offset = offsetof(struct IndexOnlyScanState, ioss_VMBuffer), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ioss_PscanLen", .fieldtype = "unsigned long", .offset = offsetof(struct IndexOnlyScanState, ioss_PscanLen), .size = sizeof(unsigned long), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ss", .fieldtype = "struct ScanState", .offset = offsetof(struct BitmapIndexScanState, ss), .size = sizeof(struct ScanState), .flags = TYPE_CAT_SCALAR, .node_type_id = 67, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "biss_result", .fieldtype = "struct TIDBitmap *", .offset = offsetof(struct BitmapIndexScanState, biss_result), .size = sizeof(struct TIDBitmap *), .flags = TYPE_CAT_POINTER, .node_type_id = 404, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "biss_ScanKeys", .fieldtype = "struct ScanKeyData *", .offset = offsetof(struct BitmapIndexScanState, biss_ScanKeys), .size = sizeof(struct ScanKeyData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "biss_NumScanKeys", .fieldtype = "int", .offset = offsetof(struct BitmapIndexScanState, biss_NumScanKeys), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "biss_RuntimeKeys", .fieldtype = "IndexRuntimeKeyInfo *", .offset = offsetof(struct BitmapIndexScanState, biss_RuntimeKeys), .size = sizeof(IndexRuntimeKeyInfo *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "biss_NumRuntimeKeys", .fieldtype = "int", .offset = offsetof(struct BitmapIndexScanState, biss_NumRuntimeKeys), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "biss_ArrayKeys", .fieldtype = "IndexArrayKeyInfo *", .offset = offsetof(struct BitmapIndexScanState, biss_ArrayKeys), .size = sizeof(IndexArrayKeyInfo *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "biss_NumArrayKeys", .fieldtype = "int", .offset = offsetof(struct BitmapIndexScanState, biss_NumArrayKeys), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "biss_RuntimeKeysReady", .fieldtype = "_Bool", .offset = offsetof(struct BitmapIndexScanState, biss_RuntimeKeysReady), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "biss_RuntimeContext", .fieldtype = "struct ExprContext *", .offset = offsetof(struct BitmapIndexScanState, biss_RuntimeContext), .size = sizeof(struct ExprContext *), .flags = TYPE_CAT_POINTER, .node_type_id = 2, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "biss_RelationDesc", .fieldtype = "struct RelationData *", .offset = offsetof(struct BitmapIndexScanState, biss_RelationDesc), .size = sizeof(struct RelationData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "biss_ScanDesc", .fieldtype = "struct IndexScanDescData *", .offset = offsetof(struct BitmapIndexScanState, biss_ScanDesc), .size = sizeof(struct IndexScanDescData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ss", .fieldtype = "struct ScanState", .offset = offsetof(struct BitmapHeapScanState, ss), .size = sizeof(struct ScanState), .flags = TYPE_CAT_SCALAR, .node_type_id = 67, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "bitmapqualorig", .fieldtype = "struct ExprState *", .offset = offsetof(struct BitmapHeapScanState, bitmapqualorig), .size = sizeof(struct ExprState *), .flags = TYPE_CAT_POINTER, .node_type_id = 152, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "tbm", .fieldtype = "struct TIDBitmap *", .offset = offsetof(struct BitmapHeapScanState, tbm), .size = sizeof(struct TIDBitmap *), .flags = TYPE_CAT_POINTER, .node_type_id = 404, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "tbmiterator", .fieldtype = "struct TBMIterator *", .offset = offsetof(struct BitmapHeapScanState, tbmiterator), .size = sizeof(struct TBMIterator *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "tbmres", .fieldtype = "struct TBMIterateResult *", .offset = offsetof(struct BitmapHeapScanState, tbmres), .size = sizeof(struct TBMIterateResult *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "can_skip_fetch", .fieldtype = "_Bool", .offset = offsetof(struct BitmapHeapScanState, can_skip_fetch), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "return_empty_tuples", .fieldtype = "int", .offset = offsetof(struct BitmapHeapScanState, return_empty_tuples), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "vmbuffer", .fieldtype = "int", .offset = offsetof(struct BitmapHeapScanState, vmbuffer), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "pvmbuffer", .fieldtype = "int", .offset = offsetof(struct BitmapHeapScanState, pvmbuffer), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "exact_pages", .fieldtype = "long", .offset = offsetof(struct BitmapHeapScanState, exact_pages), .size = sizeof(long), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "lossy_pages", .fieldtype = "long", .offset = offsetof(struct BitmapHeapScanState, lossy_pages), .size = sizeof(long), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "prefetch_iterator", .fieldtype = "struct TBMIterator *", .offset = offsetof(struct BitmapHeapScanState, prefetch_iterator), .size = sizeof(struct TBMIterator *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "prefetch_pages", .fieldtype = "int", .offset = offsetof(struct BitmapHeapScanState, prefetch_pages), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "prefetch_target", .fieldtype = "int", .offset = offsetof(struct BitmapHeapScanState, prefetch_target), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "prefetch_maximum", .fieldtype = "int", .offset = offsetof(struct BitmapHeapScanState, prefetch_maximum), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "pscan_len", .fieldtype = "unsigned long", .offset = offsetof(struct BitmapHeapScanState, pscan_len), .size = sizeof(unsigned long), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "initialized", .fieldtype = "_Bool", .offset = offsetof(struct BitmapHeapScanState, initialized), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "shared_tbmiterator", .fieldtype = "struct TBMSharedIterator *", .offset = offsetof(struct BitmapHeapScanState, shared_tbmiterator), .size = sizeof(struct TBMSharedIterator *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "shared_prefetch_iterator", .fieldtype = "struct TBMSharedIterator *", .offset = offsetof(struct BitmapHeapScanState, shared_prefetch_iterator), .size = sizeof(struct TBMSharedIterator *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "pstate", .fieldtype = "struct ParallelBitmapHeapState *", .offset = offsetof(struct BitmapHeapScanState, pstate), .size = sizeof(struct ParallelBitmapHeapState *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ss", .fieldtype = "struct ScanState", .offset = offsetof(struct TidScanState, ss), .size = sizeof(struct ScanState), .flags = TYPE_CAT_SCALAR, .node_type_id = 67, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "tss_tidexprs", .fieldtype = "struct List *", .offset = offsetof(struct TidScanState, tss_tidexprs), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "tss_isCurrentOf", .fieldtype = "_Bool", .offset = offsetof(struct TidScanState, tss_isCurrentOf), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "tss_NumTids", .fieldtype = "int", .offset = offsetof(struct TidScanState, tss_NumTids), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "tss_TidPtr", .fieldtype = "int", .offset = offsetof(struct TidScanState, tss_TidPtr), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "tss_TidList", .fieldtype = "struct ItemPointerData *", .offset = offsetof(struct TidScanState, tss_TidList), .size = sizeof(struct ItemPointerData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "tss_htup", .fieldtype = "struct HeapTupleData", .offset = offsetof(struct TidScanState, tss_htup), .size = sizeof(struct HeapTupleData), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ss", .fieldtype = "struct ScanState", .offset = offsetof(struct SubqueryScanState, ss), .size = sizeof(struct ScanState), .flags = TYPE_CAT_SCALAR, .node_type_id = 67, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "subplan", .fieldtype = "struct PlanState *", .offset = offsetof(struct SubqueryScanState, subplan), .size = sizeof(struct PlanState *), .flags = TYPE_CAT_POINTER, .node_type_id = 58, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ss", .fieldtype = "struct ScanState", .offset = offsetof(struct FunctionScanState, ss), .size = sizeof(struct ScanState), .flags = TYPE_CAT_SCALAR, .node_type_id = 67, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "eflags", .fieldtype = "int", .offset = offsetof(struct FunctionScanState, eflags), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ordinality", .fieldtype = "_Bool", .offset = offsetof(struct FunctionScanState, ordinality), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "simple", .fieldtype = "_Bool", .offset = offsetof(struct FunctionScanState, simple), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ordinal", .fieldtype = "long", .offset = offsetof(struct FunctionScanState, ordinal), .size = sizeof(long), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "nfuncs", .fieldtype = "int", .offset = offsetof(struct FunctionScanState, nfuncs), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "funcstates", .fieldtype = "struct FunctionScanPerFuncState *", .offset = offsetof(struct FunctionScanState, funcstates), .size = sizeof(struct FunctionScanPerFuncState *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "argcontext", .fieldtype = "struct MemoryContextData *", .offset = offsetof(struct FunctionScanState, argcontext), .size = sizeof(struct MemoryContextData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ss", .fieldtype = "struct ScanState", .offset = offsetof(struct ValuesScanState, ss), .size = sizeof(struct ScanState), .flags = TYPE_CAT_SCALAR, .node_type_id = 67, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "rowcontext", .fieldtype = "struct ExprContext *", .offset = offsetof(struct ValuesScanState, rowcontext), .size = sizeof(struct ExprContext *), .flags = TYPE_CAT_POINTER, .node_type_id = 2, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "exprlists", .fieldtype = "struct List **", .offset = offsetof(struct ValuesScanState, exprlists), .size = sizeof(struct List **), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "array_len", .fieldtype = "int", .offset = offsetof(struct ValuesScanState, array_len), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "curr_idx", .fieldtype = "int", .offset = offsetof(struct ValuesScanState, curr_idx), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ss", .fieldtype = "struct ScanState", .offset = offsetof(struct TableFuncScanState, ss), .size = sizeof(struct ScanState), .flags = TYPE_CAT_SCALAR, .node_type_id = 67, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "docexpr", .fieldtype = "struct ExprState *", .offset = offsetof(struct TableFuncScanState, docexpr), .size = sizeof(struct ExprState *), .flags = TYPE_CAT_POINTER, .node_type_id = 152, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "rowexpr", .fieldtype = "struct ExprState *", .offset = offsetof(struct TableFuncScanState, rowexpr), .size = sizeof(struct ExprState *), .flags = TYPE_CAT_POINTER, .node_type_id = 152, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "colexprs", .fieldtype = "struct List *", .offset = offsetof(struct TableFuncScanState, colexprs), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "coldefexprs", .fieldtype = "struct List *", .offset = offsetof(struct TableFuncScanState, coldefexprs), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ns_names", .fieldtype = "struct List *", .offset = offsetof(struct TableFuncScanState, ns_names), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ns_uris", .fieldtype = "struct List *", .offset = offsetof(struct TableFuncScanState, ns_uris), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "notnulls", .fieldtype = "struct Bitmapset *", .offset = offsetof(struct TableFuncScanState, notnulls), .size = sizeof(struct Bitmapset *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_BITMAPSET},
+	{.fieldname = "opaque", .fieldtype = "void *", .offset = offsetof(struct TableFuncScanState, opaque), .size = sizeof(void *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "routine", .fieldtype = "const struct TableFuncRoutine *", .offset = offsetof(struct TableFuncScanState, routine), .size = sizeof(const struct TableFuncRoutine *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "in_functions", .fieldtype = "struct FmgrInfo *", .offset = offsetof(struct TableFuncScanState, in_functions), .size = sizeof(struct FmgrInfo *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "typioparams", .fieldtype = "unsigned int *", .offset = offsetof(struct TableFuncScanState, typioparams), .size = sizeof(unsigned int *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "ordinal", .fieldtype = "long", .offset = offsetof(struct TableFuncScanState, ordinal), .size = sizeof(long), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "perTableCxt", .fieldtype = "struct MemoryContextData *", .offset = offsetof(struct TableFuncScanState, perTableCxt), .size = sizeof(struct MemoryContextData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "tupstore", .fieldtype = "struct Tuplestorestate *", .offset = offsetof(struct TableFuncScanState, tupstore), .size = sizeof(struct Tuplestorestate *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ss", .fieldtype = "struct ScanState", .offset = offsetof(struct CteScanState, ss), .size = sizeof(struct ScanState), .flags = TYPE_CAT_SCALAR, .node_type_id = 67, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "eflags", .fieldtype = "int", .offset = offsetof(struct CteScanState, eflags), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "readptr", .fieldtype = "int", .offset = offsetof(struct CteScanState, readptr), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "cteplanstate", .fieldtype = "struct PlanState *", .offset = offsetof(struct CteScanState, cteplanstate), .size = sizeof(struct PlanState *), .flags = TYPE_CAT_POINTER, .node_type_id = 58, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "leader", .fieldtype = "struct CteScanState *", .offset = offsetof(struct CteScanState, leader), .size = sizeof(struct CteScanState *), .flags = TYPE_CAT_POINTER, .node_type_id = 79, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "cte_table", .fieldtype = "struct Tuplestorestate *", .offset = offsetof(struct CteScanState, cte_table), .size = sizeof(struct Tuplestorestate *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "eof_cte", .fieldtype = "_Bool", .offset = offsetof(struct CteScanState, eof_cte), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ss", .fieldtype = "struct ScanState", .offset = offsetof(struct NamedTuplestoreScanState, ss), .size = sizeof(struct ScanState), .flags = TYPE_CAT_SCALAR, .node_type_id = 67, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "readptr", .fieldtype = "int", .offset = offsetof(struct NamedTuplestoreScanState, readptr), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "tupdesc", .fieldtype = "struct TupleDescData *", .offset = offsetof(struct NamedTuplestoreScanState, tupdesc), .size = sizeof(struct TupleDescData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "relation", .fieldtype = "struct Tuplestorestate *", .offset = offsetof(struct NamedTuplestoreScanState, relation), .size = sizeof(struct Tuplestorestate *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ss", .fieldtype = "struct ScanState", .offset = offsetof(struct WorkTableScanState, ss), .size = sizeof(struct ScanState), .flags = TYPE_CAT_SCALAR, .node_type_id = 67, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "rustate", .fieldtype = "struct RecursiveUnionState *", .offset = offsetof(struct WorkTableScanState, rustate), .size = sizeof(struct RecursiveUnionState *), .flags = TYPE_CAT_POINTER, .node_type_id = 64, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ss", .fieldtype = "struct ScanState", .offset = offsetof(struct ForeignScanState, ss), .size = sizeof(struct ScanState), .flags = TYPE_CAT_SCALAR, .node_type_id = 67, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "fdw_recheck_quals", .fieldtype = "struct ExprState *", .offset = offsetof(struct ForeignScanState, fdw_recheck_quals), .size = sizeof(struct ExprState *), .flags = TYPE_CAT_POINTER, .node_type_id = 152, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "pscan_len", .fieldtype = "unsigned long", .offset = offsetof(struct ForeignScanState, pscan_len), .size = sizeof(unsigned long), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "fdwroutine", .fieldtype = "struct FdwRoutine *", .offset = offsetof(struct ForeignScanState, fdwroutine), .size = sizeof(struct FdwRoutine *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "fdw_state", .fieldtype = "void *", .offset = offsetof(struct ForeignScanState, fdw_state), .size = sizeof(void *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ss", .fieldtype = "struct ScanState", .offset = offsetof(struct CustomScanState, ss), .size = sizeof(struct ScanState), .flags = TYPE_CAT_SCALAR, .node_type_id = 67, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "flags", .fieldtype = "unsigned int", .offset = offsetof(struct CustomScanState, flags), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "custom_ps", .fieldtype = "struct List *", .offset = offsetof(struct CustomScanState, custom_ps), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "pscan_len", .fieldtype = "unsigned long", .offset = offsetof(struct CustomScanState, pscan_len), .size = sizeof(unsigned long), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "methods", .fieldtype = "const struct CustomExecMethods *", .offset = offsetof(struct CustomScanState, methods), .size = sizeof(const struct CustomExecMethods *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ps", .fieldtype = "struct PlanState", .offset = offsetof(struct JoinState, ps), .size = sizeof(struct PlanState), .flags = TYPE_CAT_SCALAR, .node_type_id = 58, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "jointype", .fieldtype = "enum JoinType", .offset = offsetof(struct JoinState, jointype), .size = sizeof(enum JoinType), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "single_match", .fieldtype = "_Bool", .offset = offsetof(struct JoinState, single_match), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "joinqual", .fieldtype = "struct ExprState *", .offset = offsetof(struct JoinState, joinqual), .size = sizeof(struct ExprState *), .flags = TYPE_CAT_POINTER, .node_type_id = 152, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "js", .fieldtype = "struct JoinState", .offset = offsetof(struct NestLoopState, js), .size = sizeof(struct JoinState), .flags = TYPE_CAT_SCALAR, .node_type_id = 84, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "nl_NeedNewOuter", .fieldtype = "_Bool", .offset = offsetof(struct NestLoopState, nl_NeedNewOuter), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "nl_MatchedOuter", .fieldtype = "_Bool", .offset = offsetof(struct NestLoopState, nl_MatchedOuter), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "nl_NullInnerTupleSlot", .fieldtype = "struct TupleTableSlot *", .offset = offsetof(struct NestLoopState, nl_NullInnerTupleSlot), .size = sizeof(struct TupleTableSlot *), .flags = TYPE_CAT_POINTER, .node_type_id = 8, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "js", .fieldtype = "struct JoinState", .offset = offsetof(struct MergeJoinState, js), .size = sizeof(struct JoinState), .flags = TYPE_CAT_SCALAR, .node_type_id = 84, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "mj_NumClauses", .fieldtype = "int", .offset = offsetof(struct MergeJoinState, mj_NumClauses), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "mj_Clauses", .fieldtype = "struct MergeJoinClauseData *", .offset = offsetof(struct MergeJoinState, mj_Clauses), .size = sizeof(struct MergeJoinClauseData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "mj_JoinState", .fieldtype = "int", .offset = offsetof(struct MergeJoinState, mj_JoinState), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "mj_SkipMarkRestore", .fieldtype = "_Bool", .offset = offsetof(struct MergeJoinState, mj_SkipMarkRestore), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "mj_ExtraMarks", .fieldtype = "_Bool", .offset = offsetof(struct MergeJoinState, mj_ExtraMarks), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "mj_ConstFalseJoin", .fieldtype = "_Bool", .offset = offsetof(struct MergeJoinState, mj_ConstFalseJoin), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "mj_FillOuter", .fieldtype = "_Bool", .offset = offsetof(struct MergeJoinState, mj_FillOuter), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "mj_FillInner", .fieldtype = "_Bool", .offset = offsetof(struct MergeJoinState, mj_FillInner), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "mj_MatchedOuter", .fieldtype = "_Bool", .offset = offsetof(struct MergeJoinState, mj_MatchedOuter), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "mj_MatchedInner", .fieldtype = "_Bool", .offset = offsetof(struct MergeJoinState, mj_MatchedInner), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "mj_OuterTupleSlot", .fieldtype = "struct TupleTableSlot *", .offset = offsetof(struct MergeJoinState, mj_OuterTupleSlot), .size = sizeof(struct TupleTableSlot *), .flags = TYPE_CAT_POINTER, .node_type_id = 8, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "mj_InnerTupleSlot", .fieldtype = "struct TupleTableSlot *", .offset = offsetof(struct MergeJoinState, mj_InnerTupleSlot), .size = sizeof(struct TupleTableSlot *), .flags = TYPE_CAT_POINTER, .node_type_id = 8, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "mj_MarkedTupleSlot", .fieldtype = "struct TupleTableSlot *", .offset = offsetof(struct MergeJoinState, mj_MarkedTupleSlot), .size = sizeof(struct TupleTableSlot *), .flags = TYPE_CAT_POINTER, .node_type_id = 8, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "mj_NullOuterTupleSlot", .fieldtype = "struct TupleTableSlot *", .offset = offsetof(struct MergeJoinState, mj_NullOuterTupleSlot), .size = sizeof(struct TupleTableSlot *), .flags = TYPE_CAT_POINTER, .node_type_id = 8, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "mj_NullInnerTupleSlot", .fieldtype = "struct TupleTableSlot *", .offset = offsetof(struct MergeJoinState, mj_NullInnerTupleSlot), .size = sizeof(struct TupleTableSlot *), .flags = TYPE_CAT_POINTER, .node_type_id = 8, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "mj_OuterEContext", .fieldtype = "struct ExprContext *", .offset = offsetof(struct MergeJoinState, mj_OuterEContext), .size = sizeof(struct ExprContext *), .flags = TYPE_CAT_POINTER, .node_type_id = 2, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "mj_InnerEContext", .fieldtype = "struct ExprContext *", .offset = offsetof(struct MergeJoinState, mj_InnerEContext), .size = sizeof(struct ExprContext *), .flags = TYPE_CAT_POINTER, .node_type_id = 2, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "js", .fieldtype = "struct JoinState", .offset = offsetof(struct HashJoinState, js), .size = sizeof(struct JoinState), .flags = TYPE_CAT_SCALAR, .node_type_id = 84, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "hashclauses", .fieldtype = "struct ExprState *", .offset = offsetof(struct HashJoinState, hashclauses), .size = sizeof(struct ExprState *), .flags = TYPE_CAT_POINTER, .node_type_id = 152, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "hj_OuterHashKeys", .fieldtype = "struct List *", .offset = offsetof(struct HashJoinState, hj_OuterHashKeys), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "hj_HashOperators", .fieldtype = "struct List *", .offset = offsetof(struct HashJoinState, hj_HashOperators), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "hj_Collations", .fieldtype = "struct List *", .offset = offsetof(struct HashJoinState, hj_Collations), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "hj_HashTable", .fieldtype = "struct HashJoinTableData *", .offset = offsetof(struct HashJoinState, hj_HashTable), .size = sizeof(struct HashJoinTableData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "hj_CurHashValue", .fieldtype = "unsigned int", .offset = offsetof(struct HashJoinState, hj_CurHashValue), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "hj_CurBucketNo", .fieldtype = "int", .offset = offsetof(struct HashJoinState, hj_CurBucketNo), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "hj_CurSkewBucketNo", .fieldtype = "int", .offset = offsetof(struct HashJoinState, hj_CurSkewBucketNo), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "hj_CurTuple", .fieldtype = "struct HashJoinTupleData *", .offset = offsetof(struct HashJoinState, hj_CurTuple), .size = sizeof(struct HashJoinTupleData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "hj_OuterTupleSlot", .fieldtype = "struct TupleTableSlot *", .offset = offsetof(struct HashJoinState, hj_OuterTupleSlot), .size = sizeof(struct TupleTableSlot *), .flags = TYPE_CAT_POINTER, .node_type_id = 8, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "hj_HashTupleSlot", .fieldtype = "struct TupleTableSlot *", .offset = offsetof(struct HashJoinState, hj_HashTupleSlot), .size = sizeof(struct TupleTableSlot *), .flags = TYPE_CAT_POINTER, .node_type_id = 8, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "hj_NullOuterTupleSlot", .fieldtype = "struct TupleTableSlot *", .offset = offsetof(struct HashJoinState, hj_NullOuterTupleSlot), .size = sizeof(struct TupleTableSlot *), .flags = TYPE_CAT_POINTER, .node_type_id = 8, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "hj_NullInnerTupleSlot", .fieldtype = "struct TupleTableSlot *", .offset = offsetof(struct HashJoinState, hj_NullInnerTupleSlot), .size = sizeof(struct TupleTableSlot *), .flags = TYPE_CAT_POINTER, .node_type_id = 8, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "hj_FirstOuterTupleSlot", .fieldtype = "struct TupleTableSlot *", .offset = offsetof(struct HashJoinState, hj_FirstOuterTupleSlot), .size = sizeof(struct TupleTableSlot *), .flags = TYPE_CAT_POINTER, .node_type_id = 8, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "hj_JoinState", .fieldtype = "int", .offset = offsetof(struct HashJoinState, hj_JoinState), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "hj_MatchedOuter", .fieldtype = "_Bool", .offset = offsetof(struct HashJoinState, hj_MatchedOuter), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "hj_OuterNotEmpty", .fieldtype = "_Bool", .offset = offsetof(struct HashJoinState, hj_OuterNotEmpty), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ss", .fieldtype = "struct ScanState", .offset = offsetof(struct MaterialState, ss), .size = sizeof(struct ScanState), .flags = TYPE_CAT_SCALAR, .node_type_id = 67, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "eflags", .fieldtype = "int", .offset = offsetof(struct MaterialState, eflags), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "eof_underlying", .fieldtype = "_Bool", .offset = offsetof(struct MaterialState, eof_underlying), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "tuplestorestate", .fieldtype = "struct Tuplestorestate *", .offset = offsetof(struct MaterialState, tuplestorestate), .size = sizeof(struct Tuplestorestate *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ss", .fieldtype = "struct ScanState", .offset = offsetof(struct SortState, ss), .size = sizeof(struct ScanState), .flags = TYPE_CAT_SCALAR, .node_type_id = 67, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "randomAccess", .fieldtype = "_Bool", .offset = offsetof(struct SortState, randomAccess), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "bounded", .fieldtype = "_Bool", .offset = offsetof(struct SortState, bounded), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "bound", .fieldtype = "long", .offset = offsetof(struct SortState, bound), .size = sizeof(long), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "sort_Done", .fieldtype = "_Bool", .offset = offsetof(struct SortState, sort_Done), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "bounded_Done", .fieldtype = "_Bool", .offset = offsetof(struct SortState, bounded_Done), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "bound_Done", .fieldtype = "long", .offset = offsetof(struct SortState, bound_Done), .size = sizeof(long), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "tuplesortstate", .fieldtype = "void *", .offset = offsetof(struct SortState, tuplesortstate), .size = sizeof(void *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "am_worker", .fieldtype = "_Bool", .offset = offsetof(struct SortState, am_worker), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "shared_info", .fieldtype = "struct SharedSortInfo *", .offset = offsetof(struct SortState, shared_info), .size = sizeof(struct SharedSortInfo *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ss", .fieldtype = "struct ScanState", .offset = offsetof(struct GroupState, ss), .size = sizeof(struct ScanState), .flags = TYPE_CAT_SCALAR, .node_type_id = 67, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "eqfunction", .fieldtype = "struct ExprState *", .offset = offsetof(struct GroupState, eqfunction), .size = sizeof(struct ExprState *), .flags = TYPE_CAT_POINTER, .node_type_id = 152, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "grp_done", .fieldtype = "_Bool", .offset = offsetof(struct GroupState, grp_done), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ss", .fieldtype = "struct ScanState", .offset = offsetof(struct AggState, ss), .size = sizeof(struct ScanState), .flags = TYPE_CAT_SCALAR, .node_type_id = 67, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "aggs", .fieldtype = "struct List *", .offset = offsetof(struct AggState, aggs), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "numaggs", .fieldtype = "int", .offset = offsetof(struct AggState, numaggs), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "numtrans", .fieldtype = "int", .offset = offsetof(struct AggState, numtrans), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "aggstrategy", .fieldtype = "enum AggStrategy", .offset = offsetof(struct AggState, aggstrategy), .size = sizeof(enum AggStrategy), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "aggsplit", .fieldtype = "enum AggSplit", .offset = offsetof(struct AggState, aggsplit), .size = sizeof(enum AggSplit), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "phase", .fieldtype = "struct AggStatePerPhaseData *", .offset = offsetof(struct AggState, phase), .size = sizeof(struct AggStatePerPhaseData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "numphases", .fieldtype = "int", .offset = offsetof(struct AggState, numphases), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "current_phase", .fieldtype = "int", .offset = offsetof(struct AggState, current_phase), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "peragg", .fieldtype = "struct AggStatePerAggData *", .offset = offsetof(struct AggState, peragg), .size = sizeof(struct AggStatePerAggData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "pertrans", .fieldtype = "struct AggStatePerTransData *", .offset = offsetof(struct AggState, pertrans), .size = sizeof(struct AggStatePerTransData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "hashcontext", .fieldtype = "struct ExprContext *", .offset = offsetof(struct AggState, hashcontext), .size = sizeof(struct ExprContext *), .flags = TYPE_CAT_POINTER, .node_type_id = 2, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "aggcontexts", .fieldtype = "struct ExprContext **", .offset = offsetof(struct AggState, aggcontexts), .size = sizeof(struct ExprContext **), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "tmpcontext", .fieldtype = "struct ExprContext *", .offset = offsetof(struct AggState, tmpcontext), .size = sizeof(struct ExprContext *), .flags = TYPE_CAT_POINTER, .node_type_id = 2, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "curaggcontext", .fieldtype = "struct ExprContext *", .offset = offsetof(struct AggState, curaggcontext), .size = sizeof(struct ExprContext *), .flags = TYPE_CAT_POINTER, .node_type_id = 2, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "curperagg", .fieldtype = "struct AggStatePerAggData *", .offset = offsetof(struct AggState, curperagg), .size = sizeof(struct AggStatePerAggData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "curpertrans", .fieldtype = "struct AggStatePerTransData *", .offset = offsetof(struct AggState, curpertrans), .size = sizeof(struct AggStatePerTransData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "input_done", .fieldtype = "_Bool", .offset = offsetof(struct AggState, input_done), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "agg_done", .fieldtype = "_Bool", .offset = offsetof(struct AggState, agg_done), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "projected_set", .fieldtype = "int", .offset = offsetof(struct AggState, projected_set), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "current_set", .fieldtype = "int", .offset = offsetof(struct AggState, current_set), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "grouped_cols", .fieldtype = "struct Bitmapset *", .offset = offsetof(struct AggState, grouped_cols), .size = sizeof(struct Bitmapset *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_BITMAPSET},
+	{.fieldname = "all_grouped_cols", .fieldtype = "struct List *", .offset = offsetof(struct AggState, all_grouped_cols), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "maxsets", .fieldtype = "int", .offset = offsetof(struct AggState, maxsets), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "phases", .fieldtype = "struct AggStatePerPhaseData *", .offset = offsetof(struct AggState, phases), .size = sizeof(struct AggStatePerPhaseData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "sort_in", .fieldtype = "struct Tuplesortstate *", .offset = offsetof(struct AggState, sort_in), .size = sizeof(struct Tuplesortstate *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "sort_out", .fieldtype = "struct Tuplesortstate *", .offset = offsetof(struct AggState, sort_out), .size = sizeof(struct Tuplesortstate *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "sort_slot", .fieldtype = "struct TupleTableSlot *", .offset = offsetof(struct AggState, sort_slot), .size = sizeof(struct TupleTableSlot *), .flags = TYPE_CAT_POINTER, .node_type_id = 8, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "pergroups", .fieldtype = "struct AggStatePerGroupData **", .offset = offsetof(struct AggState, pergroups), .size = sizeof(struct AggStatePerGroupData **), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "grp_firstTuple", .fieldtype = "struct HeapTupleData *", .offset = offsetof(struct AggState, grp_firstTuple), .size = sizeof(struct HeapTupleData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "table_filled", .fieldtype = "_Bool", .offset = offsetof(struct AggState, table_filled), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "num_hashes", .fieldtype = "int", .offset = offsetof(struct AggState, num_hashes), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "perhash", .fieldtype = "struct AggStatePerHashData *", .offset = offsetof(struct AggState, perhash), .size = sizeof(struct AggStatePerHashData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "hash_pergroup", .fieldtype = "struct AggStatePerGroupData **", .offset = offsetof(struct AggState, hash_pergroup), .size = sizeof(struct AggStatePerGroupData **), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "all_pergroups", .fieldtype = "struct AggStatePerGroupData **", .offset = offsetof(struct AggState, all_pergroups), .size = sizeof(struct AggStatePerGroupData **), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "combinedproj", .fieldtype = "struct ProjectionInfo *", .offset = offsetof(struct AggState, combinedproj), .size = sizeof(struct ProjectionInfo *), .flags = TYPE_CAT_POINTER, .node_type_id = 3, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ss", .fieldtype = "struct ScanState", .offset = offsetof(struct WindowAggState, ss), .size = sizeof(struct ScanState), .flags = TYPE_CAT_SCALAR, .node_type_id = 67, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "funcs", .fieldtype = "struct List *", .offset = offsetof(struct WindowAggState, funcs), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "numfuncs", .fieldtype = "int", .offset = offsetof(struct WindowAggState, numfuncs), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "numaggs", .fieldtype = "int", .offset = offsetof(struct WindowAggState, numaggs), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "perfunc", .fieldtype = "struct WindowStatePerFuncData *", .offset = offsetof(struct WindowAggState, perfunc), .size = sizeof(struct WindowStatePerFuncData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "peragg", .fieldtype = "struct WindowStatePerAggData *", .offset = offsetof(struct WindowAggState, peragg), .size = sizeof(struct WindowStatePerAggData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "partEqfunction", .fieldtype = "struct ExprState *", .offset = offsetof(struct WindowAggState, partEqfunction), .size = sizeof(struct ExprState *), .flags = TYPE_CAT_POINTER, .node_type_id = 152, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ordEqfunction", .fieldtype = "struct ExprState *", .offset = offsetof(struct WindowAggState, ordEqfunction), .size = sizeof(struct ExprState *), .flags = TYPE_CAT_POINTER, .node_type_id = 152, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "buffer", .fieldtype = "struct Tuplestorestate *", .offset = offsetof(struct WindowAggState, buffer), .size = sizeof(struct Tuplestorestate *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "current_ptr", .fieldtype = "int", .offset = offsetof(struct WindowAggState, current_ptr), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "framehead_ptr", .fieldtype = "int", .offset = offsetof(struct WindowAggState, framehead_ptr), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "frametail_ptr", .fieldtype = "int", .offset = offsetof(struct WindowAggState, frametail_ptr), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "grouptail_ptr", .fieldtype = "int", .offset = offsetof(struct WindowAggState, grouptail_ptr), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "spooled_rows", .fieldtype = "long", .offset = offsetof(struct WindowAggState, spooled_rows), .size = sizeof(long), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "currentpos", .fieldtype = "long", .offset = offsetof(struct WindowAggState, currentpos), .size = sizeof(long), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "frameheadpos", .fieldtype = "long", .offset = offsetof(struct WindowAggState, frameheadpos), .size = sizeof(long), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "frametailpos", .fieldtype = "long", .offset = offsetof(struct WindowAggState, frametailpos), .size = sizeof(long), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "agg_winobj", .fieldtype = "struct WindowObjectData *", .offset = offsetof(struct WindowAggState, agg_winobj), .size = sizeof(struct WindowObjectData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "aggregatedbase", .fieldtype = "long", .offset = offsetof(struct WindowAggState, aggregatedbase), .size = sizeof(long), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "aggregatedupto", .fieldtype = "long", .offset = offsetof(struct WindowAggState, aggregatedupto), .size = sizeof(long), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "frameOptions", .fieldtype = "int", .offset = offsetof(struct WindowAggState, frameOptions), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "startOffset", .fieldtype = "struct ExprState *", .offset = offsetof(struct WindowAggState, startOffset), .size = sizeof(struct ExprState *), .flags = TYPE_CAT_POINTER, .node_type_id = 152, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "endOffset", .fieldtype = "struct ExprState *", .offset = offsetof(struct WindowAggState, endOffset), .size = sizeof(struct ExprState *), .flags = TYPE_CAT_POINTER, .node_type_id = 152, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "startOffsetValue", .fieldtype = "unsigned long", .offset = offsetof(struct WindowAggState, startOffsetValue), .size = sizeof(unsigned long), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "endOffsetValue", .fieldtype = "unsigned long", .offset = offsetof(struct WindowAggState, endOffsetValue), .size = sizeof(unsigned long), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "startInRangeFunc", .fieldtype = "struct FmgrInfo", .offset = offsetof(struct WindowAggState, startInRangeFunc), .size = sizeof(struct FmgrInfo), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "endInRangeFunc", .fieldtype = "struct FmgrInfo", .offset = offsetof(struct WindowAggState, endInRangeFunc), .size = sizeof(struct FmgrInfo), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "inRangeColl", .fieldtype = "unsigned int", .offset = offsetof(struct WindowAggState, inRangeColl), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "inRangeAsc", .fieldtype = "_Bool", .offset = offsetof(struct WindowAggState, inRangeAsc), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "inRangeNullsFirst", .fieldtype = "_Bool", .offset = offsetof(struct WindowAggState, inRangeNullsFirst), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "currentgroup", .fieldtype = "long", .offset = offsetof(struct WindowAggState, currentgroup), .size = sizeof(long), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "frameheadgroup", .fieldtype = "long", .offset = offsetof(struct WindowAggState, frameheadgroup), .size = sizeof(long), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "frametailgroup", .fieldtype = "long", .offset = offsetof(struct WindowAggState, frametailgroup), .size = sizeof(long), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "groupheadpos", .fieldtype = "long", .offset = offsetof(struct WindowAggState, groupheadpos), .size = sizeof(long), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "grouptailpos", .fieldtype = "long", .offset = offsetof(struct WindowAggState, grouptailpos), .size = sizeof(long), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "partcontext", .fieldtype = "struct MemoryContextData *", .offset = offsetof(struct WindowAggState, partcontext), .size = sizeof(struct MemoryContextData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "aggcontext", .fieldtype = "struct MemoryContextData *", .offset = offsetof(struct WindowAggState, aggcontext), .size = sizeof(struct MemoryContextData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "curaggcontext", .fieldtype = "struct MemoryContextData *", .offset = offsetof(struct WindowAggState, curaggcontext), .size = sizeof(struct MemoryContextData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "tmpcontext", .fieldtype = "struct ExprContext *", .offset = offsetof(struct WindowAggState, tmpcontext), .size = sizeof(struct ExprContext *), .flags = TYPE_CAT_POINTER, .node_type_id = 2, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "all_first", .fieldtype = "_Bool", .offset = offsetof(struct WindowAggState, all_first), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "all_done", .fieldtype = "_Bool", .offset = offsetof(struct WindowAggState, all_done), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "partition_spooled", .fieldtype = "_Bool", .offset = offsetof(struct WindowAggState, partition_spooled), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "more_partitions", .fieldtype = "_Bool", .offset = offsetof(struct WindowAggState, more_partitions), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "framehead_valid", .fieldtype = "_Bool", .offset = offsetof(struct WindowAggState, framehead_valid), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "frametail_valid", .fieldtype = "_Bool", .offset = offsetof(struct WindowAggState, frametail_valid), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "grouptail_valid", .fieldtype = "_Bool", .offset = offsetof(struct WindowAggState, grouptail_valid), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "first_part_slot", .fieldtype = "struct TupleTableSlot *", .offset = offsetof(struct WindowAggState, first_part_slot), .size = sizeof(struct TupleTableSlot *), .flags = TYPE_CAT_POINTER, .node_type_id = 8, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "framehead_slot", .fieldtype = "struct TupleTableSlot *", .offset = offsetof(struct WindowAggState, framehead_slot), .size = sizeof(struct TupleTableSlot *), .flags = TYPE_CAT_POINTER, .node_type_id = 8, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "frametail_slot", .fieldtype = "struct TupleTableSlot *", .offset = offsetof(struct WindowAggState, frametail_slot), .size = sizeof(struct TupleTableSlot *), .flags = TYPE_CAT_POINTER, .node_type_id = 8, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "agg_row_slot", .fieldtype = "struct TupleTableSlot *", .offset = offsetof(struct WindowAggState, agg_row_slot), .size = sizeof(struct TupleTableSlot *), .flags = TYPE_CAT_POINTER, .node_type_id = 8, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "temp_slot_1", .fieldtype = "struct TupleTableSlot *", .offset = offsetof(struct WindowAggState, temp_slot_1), .size = sizeof(struct TupleTableSlot *), .flags = TYPE_CAT_POINTER, .node_type_id = 8, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "temp_slot_2", .fieldtype = "struct TupleTableSlot *", .offset = offsetof(struct WindowAggState, temp_slot_2), .size = sizeof(struct TupleTableSlot *), .flags = TYPE_CAT_POINTER, .node_type_id = 8, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ps", .fieldtype = "struct PlanState", .offset = offsetof(struct UniqueState, ps), .size = sizeof(struct PlanState), .flags = TYPE_CAT_SCALAR, .node_type_id = 58, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "eqfunction", .fieldtype = "struct ExprState *", .offset = offsetof(struct UniqueState, eqfunction), .size = sizeof(struct ExprState *), .flags = TYPE_CAT_POINTER, .node_type_id = 152, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ps", .fieldtype = "struct PlanState", .offset = offsetof(struct GatherState, ps), .size = sizeof(struct PlanState), .flags = TYPE_CAT_SCALAR, .node_type_id = 58, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "initialized", .fieldtype = "_Bool", .offset = offsetof(struct GatherState, initialized), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "need_to_scan_locally", .fieldtype = "_Bool", .offset = offsetof(struct GatherState, need_to_scan_locally), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "tuples_needed", .fieldtype = "long", .offset = offsetof(struct GatherState, tuples_needed), .size = sizeof(long), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "funnel_slot", .fieldtype = "struct TupleTableSlot *", .offset = offsetof(struct GatherState, funnel_slot), .size = sizeof(struct TupleTableSlot *), .flags = TYPE_CAT_POINTER, .node_type_id = 8, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "pei", .fieldtype = "struct ParallelExecutorInfo *", .offset = offsetof(struct GatherState, pei), .size = sizeof(struct ParallelExecutorInfo *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "nworkers_launched", .fieldtype = "int", .offset = offsetof(struct GatherState, nworkers_launched), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "nreaders", .fieldtype = "int", .offset = offsetof(struct GatherState, nreaders), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "nextreader", .fieldtype = "int", .offset = offsetof(struct GatherState, nextreader), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "reader", .fieldtype = "struct TupleQueueReader **", .offset = offsetof(struct GatherState, reader), .size = sizeof(struct TupleQueueReader **), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ps", .fieldtype = "struct PlanState", .offset = offsetof(struct GatherMergeState, ps), .size = sizeof(struct PlanState), .flags = TYPE_CAT_SCALAR, .node_type_id = 58, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "initialized", .fieldtype = "_Bool", .offset = offsetof(struct GatherMergeState, initialized), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "gm_initialized", .fieldtype = "_Bool", .offset = offsetof(struct GatherMergeState, gm_initialized), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "need_to_scan_locally", .fieldtype = "_Bool", .offset = offsetof(struct GatherMergeState, need_to_scan_locally), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "tuples_needed", .fieldtype = "long", .offset = offsetof(struct GatherMergeState, tuples_needed), .size = sizeof(long), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "tupDesc", .fieldtype = "struct TupleDescData *", .offset = offsetof(struct GatherMergeState, tupDesc), .size = sizeof(struct TupleDescData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "gm_nkeys", .fieldtype = "int", .offset = offsetof(struct GatherMergeState, gm_nkeys), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "gm_sortkeys", .fieldtype = "struct SortSupportData *", .offset = offsetof(struct GatherMergeState, gm_sortkeys), .size = sizeof(struct SortSupportData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "pei", .fieldtype = "struct ParallelExecutorInfo *", .offset = offsetof(struct GatherMergeState, pei), .size = sizeof(struct ParallelExecutorInfo *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "nworkers_launched", .fieldtype = "int", .offset = offsetof(struct GatherMergeState, nworkers_launched), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "nreaders", .fieldtype = "int", .offset = offsetof(struct GatherMergeState, nreaders), .size = sizeof(int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "gm_slots", .fieldtype = "struct TupleTableSlot **", .offset = offsetof(struct GatherMergeState, gm_slots), .size = sizeof(struct TupleTableSlot **), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "reader", .fieldtype = "struct TupleQueueReader **", .offset = offsetof(struct GatherMergeState, reader), .size = sizeof(struct TupleQueueReader **), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "gm_tuple_buffers", .fieldtype = "struct GMReaderTupleBuffer *", .offset = offsetof(struct GatherMergeState, gm_tuple_buffers), .size = sizeof(struct GMReaderTupleBuffer *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "gm_heap", .fieldtype = "struct binaryheap *", .offset = offsetof(struct GatherMergeState, gm_heap), .size = sizeof(struct binaryheap *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ps", .fieldtype = "struct PlanState", .offset = offsetof(struct HashState, ps), .size = sizeof(struct PlanState), .flags = TYPE_CAT_SCALAR, .node_type_id = 58, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "hashtable", .fieldtype = "struct HashJoinTableData *", .offset = offsetof(struct HashState, hashtable), .size = sizeof(struct HashJoinTableData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "hashkeys", .fieldtype = "struct List *", .offset = offsetof(struct HashState, hashkeys), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "shared_info", .fieldtype = "struct SharedHashInfo *", .offset = offsetof(struct HashState, shared_info), .size = sizeof(struct SharedHashInfo *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "hinstrument", .fieldtype = "struct HashInstrumentation *", .offset = offsetof(struct HashState, hinstrument), .size = sizeof(struct HashInstrumentation *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "parallel_state", .fieldtype = "struct ParallelHashJoinState *", .offset = offsetof(struct HashState, parallel_state), .size = sizeof(struct ParallelHashJoinState *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ps", .fieldtype = "struct PlanState", .offset = offsetof(struct SetOpState, ps), .size = sizeof(struct PlanState), .flags = TYPE_CAT_SCALAR, .node_type_id = 58, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "eqfunction", .fieldtype = "struct ExprState *", .offset = offsetof(struct SetOpState, eqfunction), .size = sizeof(struct ExprState *), .flags = TYPE_CAT_POINTER, .node_type_id = 152, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "eqfuncoids", .fieldtype = "unsigned int *", .offset = offsetof(struct SetOpState, eqfuncoids), .size = sizeof(unsigned int *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_INT},
+	{.fieldname = "hashfunctions", .fieldtype = "struct FmgrInfo *", .offset = offsetof(struct SetOpState, hashfunctions), .size = sizeof(struct FmgrInfo *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "setop_done", .fieldtype = "_Bool", .offset = offsetof(struct SetOpState, setop_done), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "numOutput", .fieldtype = "long", .offset = offsetof(struct SetOpState, numOutput), .size = sizeof(long), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "pergroup", .fieldtype = "struct SetOpStatePerGroupData *", .offset = offsetof(struct SetOpState, pergroup), .size = sizeof(struct SetOpStatePerGroupData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "grp_firstTuple", .fieldtype = "struct HeapTupleData *", .offset = offsetof(struct SetOpState, grp_firstTuple), .size = sizeof(struct HeapTupleData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "hashtable", .fieldtype = "struct TupleHashTableData *", .offset = offsetof(struct SetOpState, hashtable), .size = sizeof(struct TupleHashTableData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "tableContext", .fieldtype = "struct MemoryContextData *", .offset = offsetof(struct SetOpState, tableContext), .size = sizeof(struct MemoryContextData *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "table_filled", .fieldtype = "_Bool", .offset = offsetof(struct SetOpState, table_filled), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "hashiter", .fieldtype = "struct tuplehash_iterator", .offset = offsetof(struct SetOpState, hashiter), .size = sizeof(struct tuplehash_iterator), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ps", .fieldtype = "struct PlanState", .offset = offsetof(struct LockRowsState, ps), .size = sizeof(struct PlanState), .flags = TYPE_CAT_SCALAR, .node_type_id = 58, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "lr_arowMarks", .fieldtype = "struct List *", .offset = offsetof(struct LockRowsState, lr_arowMarks), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "lr_epqstate", .fieldtype = "struct EPQState", .offset = offsetof(struct LockRowsState, lr_epqstate), .size = sizeof(struct EPQState), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "ps", .fieldtype = "struct PlanState", .offset = offsetof(struct LimitState, ps), .size = sizeof(struct PlanState), .flags = TYPE_CAT_SCALAR, .node_type_id = 58, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "limitOffset", .fieldtype = "struct ExprState *", .offset = offsetof(struct LimitState, limitOffset), .size = sizeof(struct ExprState *), .flags = TYPE_CAT_POINTER, .node_type_id = 152, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "limitCount", .fieldtype = "struct ExprState *", .offset = offsetof(struct LimitState, limitCount), .size = sizeof(struct ExprState *), .flags = TYPE_CAT_POINTER, .node_type_id = 152, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "offset", .fieldtype = "long", .offset = offsetof(struct LimitState, offset), .size = sizeof(long), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "count", .fieldtype = "long", .offset = offsetof(struct LimitState, count), .size = sizeof(long), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "noCount", .fieldtype = "_Bool", .offset = offsetof(struct LimitState, noCount), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "lstate", .fieldtype = "LimitStateCond", .offset = offsetof(struct LimitState, lstate), .size = sizeof(LimitStateCond), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "position", .fieldtype = "long", .offset = offsetof(struct LimitState, position), .size = sizeof(long), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "subSlot", .fieldtype = "struct TupleTableSlot *", .offset = offsetof(struct LimitState, subSlot), .size = sizeof(struct TupleTableSlot *), .flags = TYPE_CAT_POINTER, .node_type_id = 8, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct ExtensibleNode, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "extnodename", .fieldtype = "const char *", .offset = offsetof(struct ExtensibleNode, extnodename), .size = sizeof(const char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct IdentifySystemCmd, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct BaseBackupCmd, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "options", .fieldtype = "struct List *", .offset = offsetof(struct BaseBackupCmd, options), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct CreateReplicationSlotCmd, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "slotname", .fieldtype = "char *", .offset = offsetof(struct CreateReplicationSlotCmd, slotname), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "kind", .fieldtype = "enum ReplicationKind", .offset = offsetof(struct CreateReplicationSlotCmd, kind), .size = sizeof(enum ReplicationKind), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "plugin", .fieldtype = "char *", .offset = offsetof(struct CreateReplicationSlotCmd, plugin), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "temporary", .fieldtype = "_Bool", .offset = offsetof(struct CreateReplicationSlotCmd, temporary), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "options", .fieldtype = "struct List *", .offset = offsetof(struct CreateReplicationSlotCmd, options), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct DropReplicationSlotCmd, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "slotname", .fieldtype = "char *", .offset = offsetof(struct DropReplicationSlotCmd, slotname), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "wait", .fieldtype = "_Bool", .offset = offsetof(struct DropReplicationSlotCmd, wait), .size = sizeof(_Bool), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct StartReplicationCmd, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "kind", .fieldtype = "enum ReplicationKind", .offset = offsetof(struct StartReplicationCmd, kind), .size = sizeof(enum ReplicationKind), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "slotname", .fieldtype = "char *", .offset = offsetof(struct StartReplicationCmd, slotname), .size = sizeof(char *), .flags = TYPE_CAT_POINTER, .node_type_id = -1, .known_type_id = KNOWN_TYPE_STRING},
+	{.fieldname = "timeline", .fieldtype = "unsigned int", .offset = offsetof(struct StartReplicationCmd, timeline), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "startpoint", .fieldtype = "unsigned long", .offset = offsetof(struct StartReplicationCmd, startpoint), .size = sizeof(unsigned long), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "options", .fieldtype = "struct List *", .offset = offsetof(struct StartReplicationCmd, options), .size = sizeof(struct List *), .flags = TYPE_CAT_POINTER, .node_type_id = 223, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct TimeLineHistoryCmd, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "timeline", .fieldtype = "unsigned int", .offset = offsetof(struct TimeLineHistoryCmd, timeline), .size = sizeof(unsigned int), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN},
+	{.fieldname = "type", .fieldtype = "enum NodeTag", .offset = offsetof(struct SQLCmd, type), .size = sizeof(enum NodeTag), .flags = TYPE_CAT_SCALAR, .node_type_id = -1, .known_type_id = KNOWN_TYPE_UNKNOWN}
+};
+
diff --git i/src/include/nodes/nodes.h w/src/include/nodes/nodes.h
index 3cbb08df92a..0dc6e09d18f 100644
--- i/src/include/nodes/nodes.h
+++ w/src/include/nodes/nodes.h
@@ -605,6 +605,10 @@ castNodeImpl(NodeTag type, void *ptr)
 struct Bitmapset;				/* not to include bitmapset.h here */
 struct StringInfoData;			/* not to include stringinfo.h here */
 
+struct NodeStat;
+extern struct NodeStat measure_node_size(Node *node);
+extern void log_node_size(const char *context, Node *node);
+
 extern void outNode(struct StringInfoData *str, const void *obj);
 extern void outToken(struct StringInfoData *str, const char *s);
 extern void outBitmapset(struct StringInfoData *str,
diff --git i/src/include/nodes/pg_list.h w/src/include/nodes/pg_list.h
index 409d840e793..666e20bdded 100644
--- i/src/include/nodes/pg_list.h
+++ w/src/include/nodes/pg_list.h
@@ -58,6 +58,9 @@ typedef struct List
 	/* If elements == initial_elements, it's not a separate allocation */
 } List;
 
+typedef List OidList;
+typedef List IntList;
+
 /*
  * The *only* valid representation of an empty list is NIL; in other
  * words, a non-NIL list is guaranteed to have length >= 1.
diff --git i/src/include/nodes/value.h w/src/include/nodes/value.h
index 871ffa8fa9f..d2d79795877 100644
--- i/src/include/nodes/value.h
+++ w/src/include/nodes/value.h
@@ -49,6 +49,12 @@ typedef struct Value
 	}			val;
 } Value;
 
+typedef Value Integer;
+typedef Value Float;
+typedef Value String;
+typedef Value BitString;
+typedef Value Null;
+
 #define intVal(v)		(((Value *)(v))->val.ival)
 #define floatVal(v)		atof(((Value *)(v))->val.str)
 #define strVal(v)		(((Value *)(v))->val.str)