pg_query 2.2.0 → 4.2.0

data/ext/pg_query/pg_query_fingerprint.c

@@ -93,34 +93,48 @@ _fingerprintString(FingerprintContext *ctx, const char *str)
 }
 
 static void
-_fingerprintInteger(FingerprintContext *ctx, const Value *node)
+_fingerprintInteger(FingerprintContext *ctx, const union ValUnion *value)
 {
-	if (node->val.ival != 0) {
+	if (value->ival.ival != 0) {
 		_fingerprintString(ctx, "Integer");
 		_fingerprintString(ctx, "ival");
 		char buffer[50];
-		sprintf(buffer, "%d", node->val.ival);
+		sprintf(buffer, "%d", value->ival.ival);
 		_fingerprintString(ctx, buffer);
 	}
 }
 
 static void
-_fingerprintFloat(FingerprintContext *ctx, const Value *node)
+_fingerprintFloat(FingerprintContext *ctx, const union ValUnion *value)
 {
-	if (node->val.str != NULL) {
+	if (value->fval.fval != NULL) {
+		// NB: We output `str` here intentionally, to match the output format from libpg_query 14
+		// and below. This results in stable fingerprints, despite the field name being changed in
+		// PG15 to `fval`.
 		_fingerprintString(ctx, "Float");
 		_fingerprintString(ctx, "str");
-		_fingerprintString(ctx, node->val.str);
+		_fingerprintString(ctx, value->fval.fval);
 	}
 }
 
 static void
-_fingerprintBitString(FingerprintContext *ctx, const Value *node)
+_fingerprintBoolean(FingerprintContext *ctx, const union ValUnion *value)
 {
-	if (node->val.str != NULL) {
+	_fingerprintString(ctx, "Boolean");
+	_fingerprintString(ctx, "boolval");
+	_fingerprintString(ctx, value->boolval.boolval ? "true" : "false");
+}
+
+static void
+_fingerprintBitString(FingerprintContext *ctx, const union ValUnion *value)
+{
+	if (value->bsval.bsval != NULL) {
+		// NB: We output `str` here intentionally, to match the output format from libpg_query 14
+		// and below. This results in stable fingerprints, despite the field name being changed in
+		// PG15 to `bsval`.
 		_fingerprintString(ctx, "BitString");
 		_fingerprintString(ctx, "str");
-		_fingerprintString(ctx, node->val.str);
+		_fingerprintString(ctx, value->bsval.bsval);
 	}
 }
 
@@ -272,10 +286,16 @@ _fingerprintNode(FingerprintContext *ctx, const void *obj, const void *parent, c
 		case T_Float:
 			_fingerprintFloat(ctx, obj);
 			break;
+		case T_Boolean:
+			_fingerprintBoolean(ctx, obj);
+			break;
 		case T_String:
+			// NB: We output `str` here intentionally, to match the output format from libpg_query
+			// 14 and below. This results in stable fingerprints, despite the field name being
+			// changed in PG15 to `sval`.
 			_fingerprintString(ctx, "String");
 			_fingerprintString(ctx, "str");
-			_fingerprintString(ctx, ((Value*) obj)->val.str);
+			_fingerprintString(ctx, ((union ValUnion*) obj)->sval.sval);
 			break;
 		case T_BitString:
 			_fingerprintBitString(ctx, obj);

data/ext/pg_query/pg_query_json_plpgsql.c

@@ -96,7 +96,6 @@ static void dump_row(StringInfo out, PLpgSQL_row *stmt);
 static void dump_var(StringInfo out, PLpgSQL_var *stmt);
 static void dump_variable(StringInfo out, PLpgSQL_variable *stmt);
 static void dump_record_field(StringInfo out, PLpgSQL_recfield *node);
-static void dump_array_elem(StringInfo out, PLpgSQL_arrayelem *node);
 static void dump_stmt(StringInfo out, PLpgSQL_stmt *stmt);
 static void dump_block(StringInfo out, PLpgSQL_stmt_block *block);
 static void dump_exception_block(StringInfo out, PLpgSQL_exception_block *node);
@@ -130,7 +129,6 @@ static void dump_perform(StringInfo out, PLpgSQL_stmt_perform *stmt);
 static void dump_call(StringInfo out, PLpgSQL_stmt_call *stmt);
 static void dump_commit(StringInfo out, PLpgSQL_stmt_commit *stmt);
 static void dump_rollback(StringInfo out, PLpgSQL_stmt_rollback *stmt);
-static void dump_set(StringInfo out, PLpgSQL_stmt_set *stmt);
 static void dump_expr(StringInfo out, PLpgSQL_expr *expr);
 static void dump_function(StringInfo out, PLpgSQL_function *func);
 static void dump_exception(StringInfo out, PLpgSQL_exception *node);
@@ -224,9 +222,6 @@ dump_stmt(StringInfo out, PLpgSQL_stmt *node)
 		case PLPGSQL_STMT_ROLLBACK:
 			dump_rollback(out, (PLpgSQL_stmt_rollback *) node);
 			break;
-		case PLPGSQL_STMT_SET:
-			dump_set(out, (PLpgSQL_stmt_set *) node);
-			break;
 		default:
 			elog(ERROR, "unrecognized cmd_type: %d", node->cmd_type);
 			break;
@@ -493,15 +488,6 @@ dump_rollback(StringInfo out, PLpgSQL_stmt_rollback *node)
 	WRITE_BOOL_FIELD(chain, chain, chain);
 }
 
-static void
-dump_set(StringInfo out, PLpgSQL_stmt_set *node)
-{
-	WRITE_NODE_TYPE("PLpgSQL_stmt_set");
-
-	WRITE_INT_FIELD(lineno, lineno, lineno);
-	WRITE_EXPR_FIELD(expr);
-}
-
 static void
 dump_exit(StringInfo out, PLpgSQL_stmt_exit *node)
 {
@@ -673,9 +659,6 @@ dump_function(StringInfo out, PLpgSQL_function *node)
 			case PLPGSQL_DTYPE_RECFIELD:
 				dump_record_field(out, (PLpgSQL_recfield *) d);
 				break;
-			case PLPGSQL_DTYPE_ARRAYELEM:
-				dump_array_elem(out, (PLpgSQL_arrayelem *) d);
-				break;
 			default:
 				elog(WARNING, "could not dump unrecognized dtype: %d",
 					 (int) d->dtype);
@@ -780,14 +763,6 @@ dump_record_field(StringInfo out, PLpgSQL_recfield *node) {
 	WRITE_INT_FIELD(recparentno, recparentno, recparentno);
 }
 
-static void
-dump_array_elem(StringInfo out, PLpgSQL_arrayelem *node) {
-	WRITE_NODE_TYPE("PLpgSQL_arrayelem");
-
-	WRITE_EXPR_FIELD(subscript);
-	WRITE_INT_FIELD(arrayparentno, arrayparentno, arrayparentno);
-}
-
 char *
 plpgsqlToJSON(PLpgSQL_function *func)
 {

data/ext/pg_query/pg_query_normalize.c

@@ -572,7 +572,7 @@ PgQueryNormalizeResult pg_query_normalize(const char* input)
 		int query_len;
 
 		/* Parse query */
-		tree = raw_parser(input);
+		tree = raw_parser(input, RAW_PARSE_DEFAULT);
 
 		query_len = (int) strlen(input);
 

data/ext/pg_query/pg_query_outfuncs_json.c

@@ -195,39 +195,77 @@ _outOidList(StringInfo out, const List *node)
 }
 
 static void
-_outInteger(StringInfo out, const Value *node)
+_outInteger(StringInfo out, const Integer *node)
 {
-	appendStringInfo(out, "\"ival\":%d,", node->val.ival);
+	if (node->ival > 0)
+		appendStringInfo(out, "\"ival\":%d", node->ival);
 }
 
 static void
-_outFloat(StringInfo out, const Value *node)
+_outBoolean(StringInfo out, const Boolean *node)
 {
-	appendStringInfo(out, "\"str\":");
-	_outToken(out, node->val.str);
-	appendStringInfo(out, ",");
+	appendStringInfo(out, "\"boolval\":%s", booltostr(node->boolval));
 }
 
 static void
-_outString(StringInfo out, const Value *node)
+_outFloat(StringInfo out, const Float *node)
 {
-	appendStringInfo(out, "\"str\":");
-	_outToken(out, node->val.str);
-	appendStringInfo(out, ",");
+	appendStringInfo(out, "\"fval\":");
+	_outToken(out, node->fval);
 }
 
 static void
-_outBitString(StringInfo out, const Value *node)
+_outString(StringInfo out, const String *node)
 {
-	appendStringInfo(out, "\"str\":");
-	_outToken(out, node->val.str);
-	appendStringInfo(out, ",");
+	appendStringInfo(out, "\"sval\":");
+	_outToken(out, node->sval);
 }
 
 static void
-_outNull(StringInfo out, const Value *node)
+_outBitString(StringInfo out, const BitString *node)
 {
-	// No fields
+	appendStringInfo(out, "\"bsval\":");
+	_outToken(out, node->bsval);
+}
+
+static void
+_outAConst(StringInfo out, const A_Const *node)
+{
+	if (node->isnull) {
+		appendStringInfo(out, "\"isnull\":true");
+	} else {
+		switch (node->val.node.type) {
+			case T_Integer:
+				appendStringInfoString(out, "\"ival\":{");
+				_outInteger(out, &node->val.ival);
+				appendStringInfoChar(out, '}');
+				break;
+			case T_Float:
+				appendStringInfoString(out, "\"fval\":{");
+				_outFloat(out, &node->val.fval);
+				appendStringInfoChar(out, '}');
+				break;
+			case T_Boolean:
+				appendStringInfo(out, "\"boolval\":{%s}", node->val.boolval.boolval ? "\"boolval\":true" : "");
+				break;
+			case T_String:
+				appendStringInfoString(out, "\"sval\":{");
+				_outString(out, &node->val.sval);
+				appendStringInfoChar(out, '}');
+				break;
+			case T_BitString:
+				appendStringInfoString(out, "\"bsval\":{");
+				_outBitString(out, &node->val.bsval);
+				appendStringInfoChar(out, '}');
+				break;
+
+			// Unreachable, A_Const cannot contain any other nodes.
+			default:
+				Assert(false);
+		}
+	}
+
+	appendStringInfo(out, ",\"location\":%d", node->location);
 }
 
 #include "pg_query_enum_defs.c"

data/ext/pg_query/pg_query_outfuncs_protobuf.c

@@ -150,33 +150,93 @@ _outOidList(PgQuery__OidList* out, const List *node)
 // TODO: Add Bitmapset
 
 static void
-_outInteger(PgQuery__Integer* out, const Value *node)
+_outInteger(PgQuery__Integer* out, const Integer *node)
 {
-  out->ival = node->val.ival;
+  out->ival = node->ival;
 }
 
 static void
-_outFloat(PgQuery__Float* out, const Value *node)
+_outFloat(PgQuery__Float* out, const Float *node)
 {
-  out->str = node->val.str;
+  out->fval = node->fval;
 }
 
 static void
-_outString(PgQuery__String* out, const Value *node)
+_outBoolean(PgQuery__Boolean* out, const Boolean *node)
 {
-  out->str = node->val.str;
+  out->boolval = node->boolval;
 }
 
 static void
-_outBitString(PgQuery__BitString* out, const Value *node)
+_outString(PgQuery__String* out, const String *node)
 {
-  out->str = node->val.str;
+  out->sval = node->sval;
 }
 
 static void
-_outNull(PgQuery__Null* out, const Value *node)
+_outBitString(PgQuery__BitString* out, const BitString *node)
 {
-  // Null has no fields
+  out->bsval = node->bsval;
+}
+
+static void
+_outAConst(PgQuery__AConst* out, const A_Const *node)
+{
+  out->isnull = node->isnull;
+  out->location = node->location;
+
+  if (!node->isnull) {
+    switch (nodeTag(&node->val.node)) {
+      case T_Integer: {
+        PgQuery__Integer *value = palloc(sizeof(PgQuery__Integer));
+        pg_query__integer__init(value);
+        value->ival = node->val.ival.ival;
+
+        out->val_case = PG_QUERY__A__CONST__VAL_IVAL;
+        out->ival = value;
+        break;
+      }
+      case T_Float: {
+        PgQuery__Float *value = palloc(sizeof(PgQuery__Float));
+        pg_query__float__init(value);
+        value->fval = pstrdup(node->val.fval.fval);
+
+        out->val_case = PG_QUERY__A__CONST__VAL_FVAL;
+        out->fval = value;
+        break;
+      }
+      case T_Boolean: {
+        PgQuery__Boolean *value = palloc(sizeof(PgQuery__Boolean));
+        pg_query__boolean__init(value);
+        value->boolval = node->val.boolval.boolval;
+
+        out->val_case = PG_QUERY__A__CONST__VAL_BOOLVAL;
+        out->boolval = value;
+        break;
+      }
+      case T_String: {
+        PgQuery__String *value = palloc(sizeof(PgQuery__String));
+	pg_query__string__init(value);
+	value->sval = pstrdup(node->val.sval.sval);
+
+	out->val_case = PG_QUERY__A__CONST__VAL_SVAL;
+	out->sval = value;
+	break;
+      }
+      case T_BitString: {
+        PgQuery__BitString *value = palloc(sizeof(PgQuery__BitString));
+	pg_query__bit_string__init(value);
+	value->bsval = pstrdup(node->val.bsval.bsval);
+
+	out->val_case = PG_QUERY__A__CONST__VAL_BSVAL;
+	out->bsval = value;
+	break;
+      }
+      default:
+        // Unreachable
+        Assert(false);
+    }
+  }
 }
 
 #include "pg_query_enum_defs.c"

data/ext/pg_query/pg_query_parse.c

@@ -42,7 +42,7 @@ PgQueryInternalParsetreeAndError pg_query_raw_parse(const char* input)
 
 	PG_TRY();
 	{
-		result.tree = raw_parser(input);
+		result.tree = raw_parser(input, RAW_PARSE_DEFAULT);
 
 #ifndef DEBUG
 		// Save stderr for result

data/ext/pg_query/pg_query_readfuncs_protobuf.c

@@ -74,6 +74,12 @@
 
 static Node * _readNode(PgQuery__Node *msg);
 
+static String *
+_readString(PgQuery__String* msg)
+{
+	return makeString(pstrdup(msg->sval));
+}
+
 #include "pg_query_enum_defs.c"
 #include "pg_query_readfuncs_defs.c"
 
@@ -96,17 +102,45 @@ static Node * _readNode(PgQuery__Node *msg)
 		case PG_QUERY__NODE__NODE_INTEGER:
 			return (Node *) makeInteger(msg->integer->ival);
 		case PG_QUERY__NODE__NODE_FLOAT:
-			return (Node *) makeFloat(pstrdup(msg->float_->str));
+			return (Node *) makeFloat(pstrdup(msg->float_->fval));
+		case PG_QUERY__NODE__NODE_BOOLEAN:
+			return (Node *) makeBoolean(msg->boolean->boolval);
 		case PG_QUERY__NODE__NODE_STRING:
-			return (Node *) makeString(pstrdup(msg->string->str));
+			return (Node *) makeString(pstrdup(msg->string->sval));
 		case PG_QUERY__NODE__NODE_BIT_STRING:
-			return (Node *) makeBitString(pstrdup(msg->bit_string->str));
-		case PG_QUERY__NODE__NODE_NULL:
-			{
-				Value *v = makeNode(Value);
-				v->type = T_Null;
-				return (Node *) v;
+			return (Node *) makeBitString(pstrdup(msg->bit_string->bsval));
+		case PG_QUERY__NODE__NODE_A_CONST: {
+			A_Const *ac = makeNode(A_Const);
+			ac->location = msg->a_const->location;
+
+			if (msg->a_const->isnull) {
+				ac->isnull = true;
+			} else {
+				switch (msg->a_const->val_case) {
+					case PG_QUERY__A__CONST__VAL_IVAL:
+						ac->val.ival = *makeInteger(msg->a_const->ival->ival);
+						break;
+					case PG_QUERY__A__CONST__VAL_FVAL:
+						ac->val.fval = *makeFloat(pstrdup(msg->a_const->fval->fval));
+						break;
+					case PG_QUERY__A__CONST__VAL_BOOLVAL:
+						ac->val.boolval = *makeBoolean(msg->a_const->boolval->boolval);
+						break;
+					case PG_QUERY__A__CONST__VAL_SVAL:
+						ac->val.sval = *makeString(pstrdup(msg->a_const->sval->sval));
+						break;
+					case PG_QUERY__A__CONST__VAL_BSVAL:
+						ac->val.bsval = *makeBitString(pstrdup(msg->a_const->bsval->bsval));
+						break;
+					case PG_QUERY__A__CONST__VAL__NOT_SET:
+					case _PG_QUERY__A__CONST__VAL__CASE_IS_INT_SIZE:
+						Assert(false);
+						break;
+				}
 			}
+
+			return (Node *) ac;
+		}
 		case PG_QUERY__NODE__NODE_LIST:
 			return (Node *) _readList(msg->list);
 		case PG_QUERY__NODE__NODE__NOT_SET:

data/ext/pg_query/pg_query_scan.c

@@ -101,8 +101,9 @@ PgQueryScanResult pg_query_scan(const char* input)
       output_tokens[i]->token = tok;
 
       switch (tok) {
-      #define PG_KEYWORD(a,b,c) case b: output_tokens[i]->keyword_kind = c + 1; break;
+      #define PG_KEYWORD(a,b,c,d) case b: output_tokens[i]->keyword_kind = c + 1; break;
       #include "parser/kwlist.h"
+      #undef PG_KEYWORD
       default: output_tokens[i]->keyword_kind = 0;
       }
     }

data/ext/pg_query/pg_query_split.c

@@ -59,8 +59,9 @@ PgQuerySplitResult pg_query_split_with_scanner(const char* input)
     {
       int tok = core_yylex(&yylval, &yylloc, yyscanner);
       switch (tok) {
-      #define PG_KEYWORD(a,b,c) case b: is_keyword = true; break;
+      #define PG_KEYWORD(a,b,c,d) case b: is_keyword = true; break;
       #include "parser/kwlist.h"
+      #undef PG_KEYWORD
       default: is_keyword = false;
       }
       if (is_keyword)
@@ -88,7 +89,7 @@ PgQuerySplitResult pg_query_split_with_scanner(const char* input)
     {
       int tok = core_yylex(&yylval, &yylloc, yyscanner);
       switch (tok) {
-      #define PG_KEYWORD(a,b,c) case b: is_keyword = true; break;
+      #define PG_KEYWORD(a,b,c,d) case b: is_keyword = true; break;
       #include "parser/kwlist.h"
       default: is_keyword = false;
       }

data/ext/pg_query/src_backend_catalog_namespace.c

@@ -16,7 +16,7 @@
  * and implementing search-path-controlled searches.
  *
  *
- * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  * IDENTIFICATION
@@ -214,6 +214,7 @@ static void RemoveTempRelations(Oid tempNamespaceId);
 static void RemoveTempRelationsCallback(int code, Datum arg);
 static void NamespaceCallback(Datum arg, int cacheid, uint32 hashvalue);
 static bool MatchNamedCall(HeapTuple proctup, int nargs, List *argnames,
+						   bool include_out_arguments, int pronargs,
 						   int **argnumbers);
 
 
@@ -356,6 +357,12 @@ static bool MatchNamedCall(HeapTuple proctup, int nargs, List *argnames,
  * of additional args (which can be retrieved from the function's
  * proargdefaults entry).
  *
+ * If include_out_arguments is true, then OUT-mode arguments are considered to
+ * be included in the argument list.  Their types are included in the returned
+ * arrays, and argnumbers are indexes in proallargtypes not proargtypes.
+ * We also set nominalnargs to be the length of proallargtypes not proargtypes.
+ * Otherwise OUT-mode arguments are ignored.
+ *
  * It is not possible for nvargs and ndargs to both be nonzero in the same
  * list entry, since default insertion allows matches to functions with more
  * than nargs arguments while the variadic transformation requires the same
@@ -366,7 +373,8 @@ static bool MatchNamedCall(HeapTuple proctup, int nargs, List *argnames,
  * first any positional arguments, then the named arguments, then defaulted
  * arguments (if needed and allowed by expand_defaults).  The argnumbers[]
  * array can be used to map this back to the catalog information.
- * argnumbers[k] is set to the proargtypes index of the k'th call argument.
+ * argnumbers[k] is set to the proargtypes or proallargtypes index of the
+ * k'th call argument.
  *
  * We search a single namespace if the function name is qualified, else
  * all namespaces in the search path.  In the multiple-namespace case,
@@ -390,7 +398,7 @@ static bool MatchNamedCall(HeapTuple proctup, int nargs, List *argnames,
  * such an entry it should react as though the call were ambiguous.
  *
  * If missing_ok is true, an empty list (NULL) is returned if the name was
- * schema- qualified with a schema that does not exist.  Likewise if no
+ * schema-qualified with a schema that does not exist.  Likewise if no
  * candidate is found for other reasons.
  */
 
@@ -404,6 +412,10 @@ static bool MatchNamedCall(HeapTuple proctup, int nargs, List *argnames,
  * the function, in positions after the last positional argument, and there
  * are defaults for all unsupplied arguments.
  *
+ * If include_out_arguments is true, we are treating OUT arguments as
+ * included in the argument list.  pronargs is the number of arguments
+ * we're considering (the length of either proargtypes or proallargtypes).
+ *
  * The number of positional arguments is nargs - list_length(argnames).
  * Note caller has already done basic checks on argument count.
  *
@@ -428,8 +440,7 @@ static bool MatchNamedCall(HeapTuple proctup, int nargs, List *argnames,
  *		Given a possibly-qualified operator name and exact input datatypes,
  *		look up the operator.  Returns InvalidOid if not found.
  *
- * Pass oprleft = InvalidOid for a prefix op, oprright = InvalidOid for
- * a postfix op.
+ * Pass oprleft = InvalidOid for a prefix op.
  *
  * If the operator name is not schema-qualified, it is sought in the current
  * namespace search path.  If the name is schema-qualified and the given
@@ -451,8 +462,8 @@ static bool MatchNamedCall(HeapTuple proctup, int nargs, List *argnames,
  * namespace case, we arrange for entries in earlier namespaces to mask
  * identical entries in later namespaces.
  *
- * The returned items always have two args[] entries --- one or the other
- * will be InvalidOid for a prefix or postfix oprkind.  nargs is 2, too.
+ * The returned items always have two args[] entries --- the first will be
+ * InvalidOid for a prefix oprkind.  nargs is always 2, too.
  */
 #define SPACE_PER_OP MAXALIGN(offsetof(struct _FuncCandidateList, args) + \
 							  2 * sizeof(Oid))
@@ -677,7 +688,7 @@ static bool MatchNamedCall(HeapTuple proctup, int nargs, List *argnames,
 
 /*
  * QualifiedNameGetCreationNamespace
- *		Given a possibly-qualified name for an object (in List-of-Values
+ *		Given a possibly-qualified name for an object (in List-of-Strings
  *		format), determine what namespace the object should be created in.
  *		Also extract and return the object name (last component of list).
  *
@@ -710,7 +721,7 @@ static bool MatchNamedCall(HeapTuple proctup, int nargs, List *argnames,
  * This is used primarily to form error messages, and so we do not quote
  * the list elements, for the sake of legibility.
  *
- * In most scenarios the list elements should always be Value strings,
+ * In most scenarios the list elements should always be String values,
  * but we also allow A_Star for the convenience of ColumnRef processing.
  */
 char *

data/ext/pg_query/src_backend_catalog_pg_proc.c

@@ -9,7 +9,7 @@
  * pg_proc.c
  *	  routines to support manipulation of the pg_proc relation
  *
- * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  *
@@ -38,8 +38,11 @@
 #include "mb/pg_wchar.h"
 #include "miscadmin.h"
 #include "nodes/nodeFuncs.h"
+#include "parser/analyze.h"
 #include "parser/parse_coerce.h"
 #include "parser/parse_type.h"
+#include "pgstat.h"
+#include "rewrite/rewriteHandler.h"
 #include "tcop/pquery.h"
 #include "tcop/tcopprot.h"
 #include "utils/acl.h"

data/ext/pg_query/src_backend_commands_define.c

@@ -10,7 +10,7 @@
  *	  Support routines for various kinds of object creation.
  *
  *
- * Portions Copyright (c) 1996-2020, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
  * Portions Copyright (c) 1994, Regents of the University of California
  *
  *
@@ -92,6 +92,11 @@ defGetInt32(DefElem *def)
  */
 
 
+/*
+ * Extract an OID value from a DefElem.
+ */
+
+
 /*
  * Extract a possibly-qualified name (as a List of Strings) from a DefElem.
  */
@@ -115,3 +120,8 @@ defGetInt32(DefElem *def)
  * Extract a list of string values (otherwise uninterpreted) from a DefElem.
  */
 
+
+/*
+ * Raise an error about a conflicting DefElem.
+ */
+

data/ext/pg_query/src_backend_nodes_bitmapset.c

@@ -23,7 +23,7 @@
  * bms_is_empty() in preference to testing for NULL.)
  *
  *
- * Copyright (c) 2003-2020, PostgreSQL Global Development Group
+ * Copyright (c) 2003-2022, PostgreSQL Global Development Group
  *
  * IDENTIFICATION
  *	  src/backend/nodes/bitmapset.c
@@ -233,6 +233,8 @@ bms_free(Bitmapset *a)
 
 /*
  * bms_nonempty_difference - do sets have a nonempty difference?
+ *
+ * i.e., are any members set in 'a' that are not also set in 'b'.
  */