pg_query 6.1.0 → 6.2.1

data/ext/pg_query/src_backend_catalog_namespace.c

@@ -2,6 +2,7 @@
  * Symbols referenced in this file:
  * - NameListToString
  * - get_collation_oid
+ * - makeRangeVarFromNameList
  *--------------------------------------------------------------------
  */
 
@@ -900,7 +901,35 @@ static bool MatchNamedCall(HeapTuple proctup, int nargs, List *argnames,
  * makeRangeVarFromNameList
  *		Utility routine to convert a qualified-name list into RangeVar form.
  */
+RangeVar *
+makeRangeVarFromNameList(const List *names)
+{
+	RangeVar   *rel = makeRangeVar(NULL, NULL, -1);
 
+	switch (list_length(names))
+	{
+		case 1:
+			rel->relname = strVal(linitial(names));
+			break;
+		case 2:
+			rel->schemaname = strVal(linitial(names));
+			rel->relname = strVal(lsecond(names));
+			break;
+		case 3:
+			rel->catalogname = strVal(linitial(names));
+			rel->schemaname = strVal(lsecond(names));
+			rel->relname = strVal(lthird(names));
+			break;
+		default:
+			ereport(ERROR,
+					(errcode(ERRCODE_SYNTAX_ERROR),
+					 errmsg("improper relation name (too many dotted names): %s",
+							NameListToString(names))));
+			break;
+	}
+
+	return rel;
+}
 
 /*
  * NameListToString

data/ext/pg_query/src_backend_nodes_bitmapset.c

@@ -6,6 +6,9 @@
  * - bms_free
  * - bms_next_member
  * - bms_num_members
+ * - bms_add_member
+ * - bms_make_singleton
+ * - bms_is_member
  *--------------------------------------------------------------------
  */
 
@@ -195,7 +198,23 @@ bms_equal(const Bitmapset *a, const Bitmapset *b)
 /*
  * bms_make_singleton - build a bitmapset containing a single member
  */
-
+Bitmapset *
+bms_make_singleton(int x)
+{
+	Bitmapset  *result;
+	int			wordnum,
+				bitnum;
+
+	if (x < 0)
+		elog(ERROR, "negative bitmapset member not allowed");
+	wordnum = WORDNUM(x);
+	bitnum = BITNUM(x);
+	result = (Bitmapset *) palloc0(BITMAPSET_SIZE(wordnum + 1));
+	result->type = T_Bitmapset;
+	result->nwords = wordnum + 1;
+	result->words[wordnum] = ((bitmapword) 1 << bitnum);
+	return result;
+}
 
 /*
  * bms_free - free a bitmapset
@@ -243,7 +262,28 @@ bms_free(Bitmapset *a)
 /*
  * bms_is_member - is X a member of A?
  */
+bool
+bms_is_member(int x, const Bitmapset *a)
+{
+	int			wordnum,
+				bitnum;
 
+	Assert(bms_is_valid_set(a));
+
+	/* XXX better to just return false for x<0 ? */
+	if (x < 0)
+		elog(ERROR, "negative bitmapset member not allowed");
+	if (a == NULL)
+		return false;
+
+	wordnum = WORDNUM(x);
+	bitnum = BITNUM(x);
+	if (wordnum >= a->nwords)
+		return false;
+	if ((a->words[wordnum] & ((bitmapword) 1 << bitnum)) != 0)
+		return true;
+	return false;
+}
 
 /*
  * bms_member_index
@@ -331,9 +371,52 @@ bms_num_members(const Bitmapset *a)
  *
  * 'a' is recycled when possible.
  */
+Bitmapset *
+bms_add_member(Bitmapset *a, int x)
+{
+	int			wordnum,
+				bitnum;
+
+	Assert(bms_is_valid_set(a));
+
+	if (x < 0)
+		elog(ERROR, "negative bitmapset member not allowed");
+	if (a == NULL)
+		return bms_make_singleton(x);
+
+	wordnum = WORDNUM(x);
+	bitnum = BITNUM(x);
+
+	/* enlarge the set if necessary */
+	if (wordnum >= a->nwords)
+	{
+		int			oldnwords = a->nwords;
+		int			i;
+
+		a = (Bitmapset *) repalloc(a, BITMAPSET_SIZE(wordnum + 1));
+		a->nwords = wordnum + 1;
+		/* zero out the enlarged portion */
+		i = oldnwords;
+		do
+		{
+			a->words[i] = 0;
+		} while (++i < a->nwords);
+	}
+
+	a->words[wordnum] |= ((bitmapword) 1 << bitnum);
+
 #ifdef REALLOCATE_BITMAPSETS
+
+	/*
+	 * There's no guarantee that the repalloc returned a new pointer, so copy
+	 * and free unconditionally here.
+	 */
+	a = bms_copy_and_free(a);
 #endif
 
+	return a;
+}
+
 /*
  * bms_del_member - remove a specified member from set
  *

data/ext/pg_query/src_backend_nodes_list.c

@@ -19,6 +19,10 @@
  * - list_copy_deep
  * - list_copy_tail
  * - list_truncate
+ * - list_delete_last
+ * - list_insert_nth
+ * - insert_new_cell
+ * - list_sort
  *--------------------------------------------------------------------
  */
 
@@ -383,7 +387,22 @@ lappend(List *list, void *datum)
  * list position, ie, 0 <= pos <= list's length.
  * Returns address of the new cell.
  */
+static ListCell *
+insert_new_cell(List *list, int pos)
+{
+	Assert(pos >= 0 && pos <= list->length);
 
+	/* Enlarge array if necessary */
+	if (list->length >= list->max_length)
+		enlarge_list(list, list->length + 1);
+	/* Now shove the existing data over */
+	if (pos < list->length)
+		memmove(&list->elements[pos + 1], &list->elements[pos],
+				(list->length - pos) * sizeof(ListCell));
+	list->length++;
+
+	return &list->elements[pos];
+}
 
 /*
  * Insert the given datum at position 'pos' (measured from 0) in the list.
@@ -392,7 +411,19 @@ lappend(List *list, void *datum)
  * Note that this takes time proportional to the distance to the end of the
  * list, since the following entries must be moved.
  */
-
+List *
+list_insert_nth(List *list, int pos, void *datum)
+{
+	if (list == NIL)
+	{
+		Assert(pos == 0);
+		return list_make1(datum);
+	}
+	Assert(IsPointerList(list));
+	lfirst(insert_new_cell(list, pos)) = datum;
+	check_list_invariants(list);
+	return list;
+}
 
 
 
@@ -674,7 +705,23 @@ list_delete_nth_cell(List *list, int n)
 /*
  * Delete the last element of the list.
  */
+List *
+list_delete_last(List *list)
+{
+	check_list_invariants(list);
 
+	if (list == NIL)
+		return NIL;				/* would an error be better? */
+
+	/* list_truncate won't free list if it goes to empty, but this should */
+	if (list_length(list) <= 1)
+	{
+		list_free(list);
+		return NIL;
+	}
+
+	return list_truncate(list, list_length(list) - 1);
+}
 
 /*
  * Delete the first N cells of the list.
@@ -992,7 +1039,19 @@ list_copy_deep(const List *oldlist)
  *
  * This is based on qsort(), so it likewise has O(N log N) runtime.
  */
+void
+list_sort(List *list, list_sort_comparator cmp)
+{
+	typedef int (*qsort_comparator) (const void *a, const void *b);
+	int			len;
+
+	check_list_invariants(list);
 
+	/* Nothing to do if there's less than two elements */
+	len = list_length(list);
+	if (len > 1)
+		qsort(list->elements, len, sizeof(ListCell), (qsort_comparator) cmp);
+}
 
 /*
  * list_sort comparator for sorting a list into ascending int order.