pg_query 2.2.0 → 6.1.0

data/ext/pg_query/src_backend_nodes_extensible.c

@@ -1,8 +1,6 @@
 /*--------------------------------------------------------------------
  * Symbols referenced in this file:
  * - GetExtensibleNodeMethods
- * - GetExtensibleNodeEntry
- * - extensible_node_methods
  *--------------------------------------------------------------------
  */
 
@@ -18,7 +16,7 @@
  * and GetExtensibleNodeMethods to get information about a previously
  * registered type of extensible node.
  *
- * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
@@ -31,7 +29,6 @@
 #include "nodes/extensible.h"
 #include "utils/hsearch.h"
 
-static __thread HTAB *extensible_node_methods = NULL;
 
 
 
@@ -59,40 +56,20 @@ typedef struct
 /*
  * An internal routine to get an ExtensibleNodeEntry by the given identifier
  */
-static const void *
-GetExtensibleNodeEntry(HTAB *htable, const char *extnodename, bool missing_ok)
-{
-	ExtensibleNodeEntry *entry = NULL;
-
-	if (htable != NULL)
-		entry = (ExtensibleNodeEntry *) hash_search(htable,
-													extnodename,
-													HASH_FIND, NULL);
-	if (!entry)
-	{
-		if (missing_ok)
-			return NULL;
-		ereport(ERROR,
-				(errcode(ERRCODE_UNDEFINED_OBJECT),
-				 errmsg("ExtensibleNodeMethods \"%s\" was not registered",
-						extnodename)));
-	}
-
-	return entry->extnodemethods;
-}
+
 
 /*
  * Get the methods for a given type of extensible node.
  */
+
 const ExtensibleNodeMethods *
 GetExtensibleNodeMethods(const char *extnodename, bool missing_ok)
 {
-	return (const ExtensibleNodeMethods *)
-		GetExtensibleNodeEntry(extensible_node_methods,
-							   extnodename,
-							   missing_ok);
+	return NULL;
 }
 
+
+
 /*
  * Get the methods for a given name of CustomScanMethods
  */

data/ext/pg_query/src_backend_nodes_list.c

@@ -1,11 +1,11 @@
 /*--------------------------------------------------------------------
  * Symbols referenced in this file:
- * - lappend
+ * - list_make1_impl
  * - new_list
+ * - check_list_invariants
+ * - lappend
  * - new_tail_cell
  * - enlarge_list
- * - check_list_invariants
- * - list_make1_impl
  * - list_make2_impl
  * - list_concat
  * - list_copy
@@ -13,7 +13,6 @@
  * - new_head_cell
  * - list_make3_impl
  * - list_make4_impl
- * - list_delete_cell
  * - list_delete_nth_cell
  * - list_free
  * - list_free_private
@@ -31,7 +30,7 @@
  * See comments in pg_list.h.
  *
  *
- * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  *
@@ -42,6 +41,7 @@
  */
 #include "postgres.h"
 
+#include "common/int.h"
 #include "nodes/pg_list.h"
 #include "port/pg_bitutils.h"
 #include "utils/memdebug.h"
@@ -79,6 +79,7 @@
 #define IsPointerList(l)		((l) == NIL || IsA((l), List))
 #define IsIntegerList(l)		((l) == NIL || IsA((l), IntList))
 #define IsOidList(l)			((l) == NIL || IsA((l), OidList))
+#define IsXidList(l)			((l) == NIL || IsA((l), XidList))
 
 #ifdef USE_ASSERT_CHECKING
 /*
@@ -96,7 +97,8 @@ check_list_invariants(const List *list)
 
 	Assert(list->type == T_List ||
 		   list->type == T_IntList ||
-		   list->type == T_OidList);
+		   list->type == T_OidList ||
+		   list->type == T_XidList);
 }
 #else
 #define check_list_invariants(l)  ((void) 0)
@@ -302,6 +304,8 @@ list_make4_impl(NodeTag t, ListCell datum1, ListCell datum2,
 	return list;
 }
 
+
+
 /*
  * Make room for a new head cell in the given (non-NIL) list.
  *
@@ -352,7 +356,7 @@ lappend(List *list, void *datum)
 	else
 		new_tail_cell(list);
 
-	lfirst(list_tail(list)) = datum;
+	llast(list) = datum;
 	check_list_invariants(list);
 	return list;
 }
@@ -367,6 +371,11 @@ lappend(List *list, void *datum)
  */
 
 
+/*
+ * Append a TransactionId to the specified list. See lappend()
+ */
+
+
 /*
  * Make room for a new cell at position 'pos' (measured from 0).
  * The data in the cell is left undefined, and must be filled in by the
@@ -379,6 +388,9 @@ lappend(List *list, void *datum)
 /*
  * Insert the given datum at position 'pos' (measured from 0) in the list.
  * 'pos' must be valid, ie, 0 <= pos <= list's length.
+ *
+ * Note that this takes time proportional to the distance to the end of the
+ * list, since the following entries must be moved.
  */
 
 
@@ -393,6 +405,9 @@ lappend(List *list, void *datum)
  * value, rather than continuing to use the pointer passed as the
  * second argument.
  *
+ * Note that this takes time proportional to the length of the list,
+ * since the existing entries must be moved.
+ *
  * Caution: before Postgres 8.0, the original List was unmodified and
  * could be considered to retain its separate identity.  This is no longer
  * the case.
@@ -407,7 +422,7 @@ lcons(void *datum, List *list)
 	else
 		new_head_cell(list);
 
-	lfirst(list_head(list)) = datum;
+	linitial(list) = datum;
 	check_list_invariants(list);
 	return list;
 }
@@ -432,6 +447,10 @@ lcons(void *datum, List *list)
  * Callers should be sure to use the return value as the new pointer to the
  * concatenated list: the 'list1' input pointer may or may not be the same
  * as the returned pointer.
+ *
+ * Note that this takes at least time proportional to the length of list2.
+ * It'd typically be the case that we have to enlarge list1's storage,
+ * probably adding time proportional to the length of list1.
  */
 List *
 list_concat(List *list1, const List *list2)
@@ -508,6 +527,8 @@ list_truncate(List *list, int new_size)
  * Return true iff 'datum' is a member of the list. Equality is
  * determined via equal(), so callers should ensure that they pass a
  * Node as 'datum'.
+ *
+ * This does a simple linear search --- avoid using it on long lists.
  */
 
 
@@ -527,10 +548,18 @@ list_truncate(List *list, int new_size)
  */
 
 
+/*
+ * Return true iff the TransactionId 'datum' is a member of the list.
+ */
+
+
 /*
  * Delete the n'th cell (counting from 0) in list.
  *
  * The List is pfree'd if this was the last member.
+ *
+ * Note that this takes time proportional to the distance to the end of the
+ * list, since the following entries must be moved.
  */
 List *
 list_delete_nth_cell(List *list, int n)
@@ -602,16 +631,17 @@ list_delete_nth_cell(List *list, int n)
  *
  * The List is pfree'd if this was the last member.  However, we do not
  * touch any data the cell might've been pointing to.
+ *
+ * Note that this takes time proportional to the distance to the end of the
+ * list, since the following entries must be moved.
  */
-List *
-list_delete_cell(List *list, ListCell *cell)
-{
-	return list_delete_nth_cell(list, cell - list->elements);
-}
+
 
 /*
  * Delete the first cell in list that matches datum, if any.
  * Equality is determined via equal().
+ *
+ * This does a simple linear search --- avoid using it on long lists.
  */
 
 
@@ -631,14 +661,18 @@ list_delete_cell(List *list, ListCell *cell)
  * where the intent is to alter the list rather than just traverse it.
  * Beware that the list is modified, whereas the Lisp-y coding leaves
  * the original list head intact in case there's another pointer to it.
+ *
+ * Note that this takes time proportional to the length of the list,
+ * since the remaining entries must be moved.  Consider reversing the
+ * list order so that you can use list_delete_last() instead.  However,
+ * if that causes you to replace lappend() with lcons(), you haven't
+ * improved matters.  (In short, you can make an efficient stack from
+ * a List, but not an efficient FIFO queue.)
  */
 
 
 /*
  * Delete the last element of the list.
- *
- * This is the opposite of list_delete_first(), but is noticeably cheaper
- * with a long list, since no data need be moved.
  */
 
 
@@ -646,6 +680,9 @@ list_delete_cell(List *list, ListCell *cell)
  * Delete the first N cells of the list.
  *
  * The List is pfree'd if the request causes all cells to be deleted.
+ *
+ * Note that this takes time proportional to the distance to the end of the
+ * list, since the following entries must be moved.
  */
 #ifndef DEBUG_LIST_MEMORY_USAGE
 #else
@@ -671,8 +708,10 @@ list_delete_cell(List *list, ListCell *cell)
  * you probably want to use list_concat_unique() instead to avoid wasting
  * the storage of the old x list.
  *
- * This function could probably be implemented a lot faster if it is a
- * performance bottleneck.
+ * Note that this takes time proportional to the product of the list
+ * lengths, so beware of using it on long lists.  (We could probably
+ * improve that, but really you should be using some other data structure
+ * if this'd be a performance bottleneck.)
  */
 
 
@@ -704,6 +743,11 @@ list_delete_cell(List *list, ListCell *cell)
  * This variant works on lists of pointers, and determines list
  * membership via equal().  Note that the list1 member will be pointed
  * to in the result.
+ *
+ * Note that this takes time proportional to the product of the list
+ * lengths, so beware of using it on long lists.  (We could probably
+ * improve that, but really you should be using some other data structure
+ * if this'd be a performance bottleneck.)
  */
 
 
@@ -720,6 +764,11 @@ list_delete_cell(List *list, ListCell *cell)
  *
  * This variant works on lists of pointers, and determines list
  * membership via equal()
+ *
+ * Note that this takes time proportional to the product of the list
+ * lengths, so beware of using it on long lists.  (We could probably
+ * improve that, but really you should be using some other data structure
+ * if this'd be a performance bottleneck.)
  */
 
 
@@ -744,6 +793,8 @@ list_delete_cell(List *list, ListCell *cell)
  *
  * Whether an element is already a member of the list is determined
  * via equal().
+ *
+ * This does a simple linear search --- avoid using it on long lists.
  */
 
 
@@ -773,6 +824,11 @@ list_delete_cell(List *list, ListCell *cell)
  * modified in-place rather than being copied. However, callers of this
  * function may have strict ordering expectations -- i.e. that the relative
  * order of those list2 elements that are not duplicates is preserved.
+ *
+ * Note that this takes time proportional to the product of the list
+ * lengths, so beware of using it on long lists.  (We could probably
+ * improve that, but really you should be using some other data structure
+ * if this'd be a performance bottleneck.)
  */
 
 
@@ -797,6 +853,8 @@ list_delete_cell(List *list, ListCell *cell)
  *
  * It is caller's responsibility to have sorted the list to bring duplicates
  * together, perhaps via list_sort(list, list_oid_cmp).
+ *
+ * Note that this takes time proportional to the length of the list.
  */
 
 
@@ -864,6 +922,12 @@ list_copy(const List *oldlist)
 	return newlist;
 }
 
+/*
+ * Return a shallow copy of the specified list containing only the first 'len'
+ * elements.  If oldlist is shorter than 'len' then we copy the entire list.
+ */
+
+
 /*
  * Return a shallow copy of the specified list, without the first N elements.
  */
@@ -925,6 +989,13 @@ list_copy_deep(const List *oldlist)
  *
  * Like qsort(), this provides no guarantees about sort stability
  * for equal keys.
+ *
+ * This is based on qsort(), so it likewise has O(N log N) runtime.
+ */
+
+
+/*
+ * list_sort comparator for sorting a list into ascending int order.
  */
 
 

data/ext/pg_query/src_backend_nodes_makefuncs.c

@@ -1,16 +1,23 @@
 /*--------------------------------------------------------------------
  * Symbols referenced in this file:
  * - makeDefElem
+ * - makeStringConst
  * - makeTypeNameFromNameList
  * - makeDefElemExtended
+ * - makeRangeVar
  * - makeVacuumRelation
  * - makeAlias
  * - makeSimpleA_Expr
  * - makeGroupingSet
+ * - makeJsonTablePathSpec
+ * - makeJsonFormat
  * - makeTypeName
  * - makeFuncCall
  * - makeA_Expr
- * - makeRangeVar
+ * - makeJsonIsPredicate
+ * - makeJsonBehavior
+ * - makeJsonValueExpr
+ * - makeJsonKeyValue
  * - makeBoolExpr
  *--------------------------------------------------------------------
  */
@@ -21,7 +28,7 @@
  *	  creator functions for various nodes. The functions here are for the
  *	  most frequently created nodes.
  *
- * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  *
@@ -262,6 +269,22 @@ makeTypeNameFromNameList(List *names)
  */
 
 
+/*
+ * makeStringConst -
+ * 	build a A_Const node of type T_String for given string
+ */
+Node *
+makeStringConst(char *str, int location)
+{
+	A_Const    *n = makeNode(A_Const);
+
+	n->val.sval.type = T_String;
+	n->val.sval.sval = str;
+	n->location = location;
+
+	return (Node *) n;
+}
+
 /*
  * makeDefElem -
  *	build a DefElem node
@@ -309,7 +332,7 @@ makeDefElemExtended(char *nameSpace, char *name, Node *arg,
  * supply.  Any non-default parameters have to be inserted by the caller.
  */
 FuncCall *
-makeFuncCall(List *name, List *args, int location)
+makeFuncCall(List *name, List *args, CoercionForm funcformat, int location)
 {
 	FuncCall   *n = makeNode(FuncCall);
 
@@ -317,11 +340,12 @@ makeFuncCall(List *name, List *args, int location)
 	n->args = args;
 	n->agg_order = NIL;
 	n->agg_filter = NULL;
+	n->over = NULL;
 	n->agg_within_group = false;
 	n->agg_star = false;
 	n->agg_distinct = false;
 	n->func_variadic = false;
-	n->over = NULL;
+	n->funcformat = funcformat;
 	n->location = location;
 	return n;
 }
@@ -415,3 +439,113 @@ makeVacuumRelation(RangeVar *relation, Oid oid, List *va_cols)
 	v->va_cols = va_cols;
 	return v;
 }
+
+/*
+ * makeJsonFormat -
+ *	  creates a JsonFormat node
+ */
+JsonFormat *
+makeJsonFormat(JsonFormatType type, JsonEncoding encoding, int location)
+{
+	JsonFormat *jf = makeNode(JsonFormat);
+
+	jf->format_type = type;
+	jf->encoding = encoding;
+	jf->location = location;
+
+	return jf;
+}
+
+/*
+ * makeJsonValueExpr -
+ *	  creates a JsonValueExpr node
+ */
+JsonValueExpr *
+makeJsonValueExpr(Expr *raw_expr, Expr *formatted_expr,
+				  JsonFormat *format)
+{
+	JsonValueExpr *jve = makeNode(JsonValueExpr);
+
+	jve->raw_expr = raw_expr;
+	jve->formatted_expr = formatted_expr;
+	jve->format = format;
+
+	return jve;
+}
+
+/*
+ * makeJsonBehavior -
+ *	  creates a JsonBehavior node
+ */
+JsonBehavior *
+makeJsonBehavior(JsonBehaviorType btype, Node *expr, int location)
+{
+	JsonBehavior *behavior = makeNode(JsonBehavior);
+
+	behavior->btype = btype;
+	behavior->expr = expr;
+	behavior->location = location;
+
+	return behavior;
+}
+
+/*
+ * makeJsonKeyValue -
+ *	  creates a JsonKeyValue node
+ */
+Node *
+makeJsonKeyValue(Node *key, Node *value)
+{
+	JsonKeyValue *n = makeNode(JsonKeyValue);
+
+	n->key = (Expr *) key;
+	n->value = castNode(JsonValueExpr, value);
+
+	return (Node *) n;
+}
+
+/*
+ * makeJsonIsPredicate -
+ *	  creates a JsonIsPredicate node
+ */
+Node *
+makeJsonIsPredicate(Node *expr, JsonFormat *format, JsonValueType item_type,
+					bool unique_keys, int location)
+{
+	JsonIsPredicate *n = makeNode(JsonIsPredicate);
+
+	n->expr = expr;
+	n->format = format;
+	n->item_type = item_type;
+	n->unique_keys = unique_keys;
+	n->location = location;
+
+	return (Node *) n;
+}
+
+/*
+ * makeJsonTablePathSpec -
+ *		Make JsonTablePathSpec node from given path string and name (if any)
+ */
+JsonTablePathSpec *
+makeJsonTablePathSpec(char *string, char *name, int string_location,
+					  int name_location)
+{
+	JsonTablePathSpec *pathspec = makeNode(JsonTablePathSpec);
+
+	Assert(string != NULL);
+	pathspec->string = makeStringConst(string, string_location);
+	if (name != NULL)
+		pathspec->name = pstrdup(name);
+
+	pathspec->name_location = name_location;
+	pathspec->location = string_location;
+
+	return pathspec;
+}
+
+/*
+ * makeJsonTablePath -
+ *		Make JsonTablePath node for given path string and name
+ */
+