Moved other yql/essentials libs YQL-19206

init
commit_hash:7d4c435602078407bbf20dd3c32f9c90d2bbcbc0

1 files changed, 212 insertions, 0 deletions

diff --git a/yql/essentials/parser/pg_wrapper/postgresql/src/backend/nodes/copyfuncs.c b/yql/essentials/parser/pg_wrapper/postgresql/src/backend/nodes/copyfuncs.c
new file mode 100644
index 00000000000..f2568ff5e6a
--- /dev/null
+++ b/yql/essentials/parser/pg_wrapper/postgresql/src/backend/nodes/copyfuncs.c
@@ -0,0 +1,212 @@
+/*-------------------------------------------------------------------------
+ *
+ * copyfuncs.c
+ *	  Copy functions for Postgres tree nodes.
+ *
+ *
+ * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1994, Regents of the University of California
+ *
+ * IDENTIFICATION
+ *	  src/backend/nodes/copyfuncs.c
+ *
+ *-------------------------------------------------------------------------
+ */
+
+#include "postgres.h"
+
+#include "miscadmin.h"
+#include "utils/datum.h"
+
+
+/*
+ * Macros to simplify copying of different kinds of fields.  Use these
+ * wherever possible to reduce the chance for silly typos.  Note that these
+ * hard-wire the convention that the local variables in a Copy routine are
+ * named 'newnode' and 'from'.
+ */
+
+/* Copy a simple scalar field (int, float, bool, enum, etc) */
+#define COPY_SCALAR_FIELD(fldname) \
+	(newnode->fldname = from->fldname)
+
+/* Copy a field that is a pointer to some kind of Node or Node tree */
+#define COPY_NODE_FIELD(fldname) \
+	(newnode->fldname = copyObjectImpl(from->fldname))
+
+/* Copy a field that is a pointer to a Bitmapset */
+#define COPY_BITMAPSET_FIELD(fldname) \
+	(newnode->fldname = bms_copy(from->fldname))
+
+/* Copy a field that is a pointer to a C string, or perhaps NULL */
+#define COPY_STRING_FIELD(fldname) \
+	(newnode->fldname = from->fldname ? pstrdup(from->fldname) : (char *) NULL)
+
+/* Copy a field that is an inline array */
+#define COPY_ARRAY_FIELD(fldname) \
+	memcpy(newnode->fldname, from->fldname, sizeof(newnode->fldname))
+
+/* Copy a field that is a pointer to a simple palloc'd object of size sz */
+#define COPY_POINTER_FIELD(fldname, sz) \
+	do { \
+		Size	_size = (sz); \
+		if (_size > 0) \
+		{ \
+			newnode->fldname = palloc(_size); \
+			memcpy(newnode->fldname, from->fldname, _size); \
+		} \
+	} while (0)
+
+/* Copy a parse location field (for Copy, this is same as scalar case) */
+#define COPY_LOCATION_FIELD(fldname) \
+	(newnode->fldname = from->fldname)
+
+
+#include "copyfuncs.funcs.c"
+
+
+/*
+ * Support functions for nodes with custom_copy_equal attribute
+ */
+
+static Const *
+_copyConst(const Const *from)
+{
+	Const	   *newnode = makeNode(Const);
+
+	COPY_SCALAR_FIELD(consttype);
+	COPY_SCALAR_FIELD(consttypmod);
+	COPY_SCALAR_FIELD(constcollid);
+	COPY_SCALAR_FIELD(constlen);
+
+	if (from->constbyval || from->constisnull)
+	{
+		/*
+		 * passed by value so just copy the datum. Also, don't try to copy
+		 * struct when value is null!
+		 */
+		newnode->constvalue = from->constvalue;
+	}
+	else
+	{
+		/*
+		 * passed by reference.  We need a palloc'd copy.
+		 */
+		newnode->constvalue = datumCopy(from->constvalue,
+										from->constbyval,
+										from->constlen);
+	}
+
+	COPY_SCALAR_FIELD(constisnull);
+	COPY_SCALAR_FIELD(constbyval);
+	COPY_LOCATION_FIELD(location);
+
+	return newnode;
+}
+
+static A_Const *
+_copyA_Const(const A_Const *from)
+{
+	A_Const    *newnode = makeNode(A_Const);
+
+	COPY_SCALAR_FIELD(isnull);
+	if (!from->isnull)
+	{
+		/* This part must duplicate other _copy*() functions. */
+		COPY_SCALAR_FIELD(val.node.type);
+		switch (nodeTag(&from->val))
+		{
+			case T_Integer:
+				COPY_SCALAR_FIELD(val.ival.ival);
+				break;
+			case T_Float:
+				COPY_STRING_FIELD(val.fval.fval);
+				break;
+			case T_Boolean:
+				COPY_SCALAR_FIELD(val.boolval.boolval);
+				break;
+			case T_String:
+				COPY_STRING_FIELD(val.sval.sval);
+				break;
+			case T_BitString:
+				COPY_STRING_FIELD(val.bsval.bsval);
+				break;
+			default:
+				elog(ERROR, "unrecognized node type: %d",
+					 (int) nodeTag(&from->val));
+				break;
+		}
+	}
+
+	COPY_LOCATION_FIELD(location);
+
+	return newnode;
+}
+
+static ExtensibleNode *
+_copyExtensibleNode(const ExtensibleNode *from)
+{
+	ExtensibleNode *newnode;
+	const ExtensibleNodeMethods *methods;
+
+	methods = GetExtensibleNodeMethods(from->extnodename, false);
+	newnode = (ExtensibleNode *) newNode(methods->node_size,
+										 T_ExtensibleNode);
+	COPY_STRING_FIELD(extnodename);
+
+	/* copy the private fields */
+	methods->nodeCopy(newnode, from);
+
+	return newnode;
+}
+
+static Bitmapset *
+_copyBitmapset(const Bitmapset *from)
+{
+	return bms_copy(from);
+}
+
+
+/*
+ * copyObjectImpl -- implementation of copyObject(); see nodes/nodes.h
+ *
+ * Create a copy of a Node tree or list.  This is a "deep" copy: all
+ * substructure is copied too, recursively.
+ */
+void *
+copyObjectImpl(const void *from)
+{
+	void	   *retval;
+
+	if (from == NULL)
+		return NULL;
+
+	/* Guard against stack overflow due to overly complex expressions */
+	check_stack_depth();
+
+	switch (nodeTag(from))
+	{
+#include "copyfuncs.switch.c"
+
+		case T_List:
+			retval = list_copy_deep(from);
+			break;
+
+			/*
+			 * Lists of integers, OIDs and XIDs don't need to be deep-copied,
+			 * so we perform a shallow copy via list_copy()
+			 */
+		case T_IntList:
+		case T_OidList:
+		case T_XidList:
+			retval = list_copy(from);
+			break;
+
+		default:
+			elog(ERROR, "unrecognized node type: %d", (int) nodeTag(from));
+			retval = 0;			/* keep compiler quiet */
+			break;
+	}
+
+	return retval;
+}