pg_query 2.1.4 → 2.2.1

data/ext/pg_query/pg_query_normalize.c

@@ -8,6 +8,8 @@
 #include "mb/pg_wchar.h"
 #include "nodes/nodeFuncs.h"
 
+#include "pg_query_outfuncs.h"
+
 /*
  * Struct for tracking locations/lengths of constants during normalization
  */
@@ -331,6 +333,27 @@ static void RecordConstLocation(pgssConstLocations *jstate, int location)
 	}
 }
 
+static void record_defelem_arg_location(pgssConstLocations *jstate, int location)
+{
+	for (int i = location; i < jstate->query_len; i++) {
+		if (jstate->query[i] == '\'' || jstate->query[i] == '$') {
+			RecordConstLocation(jstate, i);
+			break;
+		}
+	}
+}
+
+static void record_matching_string(pgssConstLocations *jstate, const char *str)
+{
+	char *loc = NULL;
+	if (str == NULL)
+		return;
+
+	loc = strstr(jstate->query, str);
+	if (loc != NULL)
+		RecordConstLocation(jstate, loc - jstate->query - 1);
+}
+
 static bool const_record_walker(Node *node, pgssConstLocations *jstate)
 {
 	bool result;
@@ -362,13 +385,12 @@ static bool const_record_walker(Node *node, pgssConstLocations *jstate)
 		case T_DefElem:
 			{
 				DefElem * defElem = (DefElem *) node;
-				if (defElem->arg != NULL && IsA(defElem->arg, String)) {
-					for (int i = defElem->location; i < jstate->query_len; i++) {
-						if (jstate->query[i] == '\'') {
-							RecordConstLocation(jstate, i);
-							break;
-						}
-					}
+				if (defElem->arg == NULL) {
+					// No argument
+				} else if (IsA(defElem->arg, String)) {
+					record_defelem_arg_location(jstate, defElem->location);
+				} else if (IsA(defElem->arg, List) && list_length((List *) defElem->arg) == 1 && IsA(linitial((List *) defElem->arg), String)) {
+					record_defelem_arg_location(jstate, defElem->location);
 				}
 				return const_record_walker((Node *) ((DefElem *) node)->arg, jstate);
 			}
@@ -387,6 +409,20 @@ static bool const_record_walker(Node *node, pgssConstLocations *jstate)
 			return const_record_walker((Node *) ((AlterRoleStmt *) node)->options, jstate);
 		case T_DeclareCursorStmt:
 			return const_record_walker((Node *) ((DeclareCursorStmt *) node)->query, jstate);
+		case T_CreateFunctionStmt:
+			return const_record_walker((Node *) ((CreateFunctionStmt *) node)->options, jstate);
+		case T_DoStmt:
+			return const_record_walker((Node *) ((DoStmt *) node)->args, jstate);
+		case T_CreateSubscriptionStmt:
+			record_matching_string(jstate, ((CreateSubscriptionStmt *) node)->conninfo);
+			break;
+		case T_AlterSubscriptionStmt:
+			record_matching_string(jstate, ((CreateSubscriptionStmt *) node)->conninfo);
+			break;
+		case T_CreateUserMappingStmt:
+			return const_record_walker((Node *) ((CreateUserMappingStmt *) node)->options, jstate);
+		case T_AlterUserMappingStmt:
+			return const_record_walker((Node *) ((AlterUserMappingStmt *) node)->options, jstate);
 		case T_TypeName:
 			/* Don't normalize constants in typmods or arrayBounds */
 			return false;

data/ext/pg_query/pg_query_outfuncs.h

@@ -5,6 +5,7 @@
 
 PgQueryProtobuf pg_query_nodes_to_protobuf(const void *obj);
 
+char *pg_query_node_to_json(const void *obj);
 char *pg_query_nodes_to_json(const void *obj);
 
 #endif

data/ext/pg_query/pg_query_outfuncs_json.c

@@ -259,6 +259,17 @@ _outNode(StringInfo out, const void *obj)
 	}
 }
 
+char *
+pg_query_node_to_json(const void *obj)
+{
+	StringInfoData out;
+
+	initStringInfo(&out);
+	_outNode(&out, obj);
+
+	return out.data;
+}
+
 char *
 pg_query_nodes_to_json(const void *obj)
 {

data/ext/pg_query/pg_query_parse_plpgsql.c

@@ -18,7 +18,7 @@ typedef struct {
 	PgQueryError* error;
 } PgQueryInternalPlpgsqlFuncAndError;
 
-static PgQueryInternalPlpgsqlFuncAndError pg_query_raw_parse_plpgsql(CreateFunctionStmt* stmt);
+static PgQueryInternalPlpgsqlFuncAndError pg_query_raw_parse_plpgsql(Node* stmt);
 
 static void add_dummy_return(PLpgSQL_function *function)
 {
@@ -73,6 +73,36 @@ static void plpgsql_compile_error_callback(void *arg)
 				   plpgsql_error_funcname, plpgsql_latest_lineno());
 }
 
+static PLpgSQL_function *compile_do_stmt(DoStmt* stmt)
+{
+	char *proc_source = NULL;
+	const ListCell *lc;
+	char *language = "plpgsql";
+
+	assert(IsA(stmt, DoStmt));
+
+	foreach(lc, stmt->args)
+	{
+		DefElem* elem = (DefElem*) lfirst(lc);
+
+		if (strcmp(elem->defname, "as") == 0) {
+
+			assert(IsA(elem->arg, String));
+			proc_source = strVal(elem->arg);
+		} else if (strcmp(elem->defname, "language") == 0) {
+			language = strVal(elem->arg);
+		}
+	}
+
+	assert(proc_source != NULL);
+
+	if(strcmp(language, "plpgsql") != 0) {
+		return (PLpgSQL_function *) palloc0(sizeof(PLpgSQL_function));
+	}
+	return plpgsql_compile_inline(proc_source);
+
+}
+
 static PLpgSQL_function *compile_create_function_stmt(CreateFunctionStmt* stmt)
 {
 	char *func_name;
@@ -87,6 +117,7 @@ static PLpgSQL_function *compile_create_function_stmt(CreateFunctionStmt* stmt)
 	const ListCell *lc, *lc2, *lc3;
 	bool is_trigger = false;
 	bool is_setof = false;
+	char *language = "plpgsql";
 
 	assert(IsA(stmt, CreateFunctionStmt));
 
@@ -105,11 +136,17 @@ static PLpgSQL_function *compile_create_function_stmt(CreateFunctionStmt* stmt)
 			{
 				proc_source = strVal(lfirst(lc2));
 			}
+		} else if (strcmp(elem->defname, "language") == 0) {
+			language = strVal(elem->arg);
 		}
 	}
 
 	assert(proc_source != NULL);
 
+	if(strcmp(language, "plpgsql") != 0) { 
+		return (PLpgSQL_function *) palloc0(sizeof(PLpgSQL_function));
+	}
+
 	if (stmt->returnType != NULL) {
 		foreach(lc3, stmt->returnType->names)
 		{
@@ -273,7 +310,7 @@ static PLpgSQL_function *compile_create_function_stmt(CreateFunctionStmt* stmt)
 	return function;
 }
 
-PgQueryInternalPlpgsqlFuncAndError pg_query_raw_parse_plpgsql(CreateFunctionStmt* stmt)
+PgQueryInternalPlpgsqlFuncAndError pg_query_raw_parse_plpgsql(Node* stmt)
 {
 	PgQueryInternalPlpgsqlFuncAndError result = {0};
 	MemoryContext cctx = CurrentMemoryContext;
@@ -306,7 +343,13 @@ PgQueryInternalPlpgsqlFuncAndError pg_query_raw_parse_plpgsql(CreateFunctionStmt
 
 	PG_TRY();
 	{
-		result.func = compile_create_function_stmt(stmt);
+		if (IsA(stmt, CreateFunctionStmt)) {
+			result.func = compile_create_function_stmt((CreateFunctionStmt *) stmt);
+		} else if (IsA(stmt, DoStmt)){
+			result.func = compile_do_stmt((DoStmt *) stmt);
+		} else {
+			elog(ERROR, "Unexpected node type for PL/pgSQL parsing: %d", nodeTag(stmt));
+		}
 
 #ifndef DEBUG
 		// Save stderr for result
@@ -354,36 +397,36 @@ PgQueryInternalPlpgsqlFuncAndError pg_query_raw_parse_plpgsql(CreateFunctionStmt
 	return result;
 }
 
-typedef struct createFunctionStmts
+typedef struct plStmts
 {
-	CreateFunctionStmt **stmts;
+	Node **stmts;
 	int stmts_buf_size;
 	int stmts_count;
-} createFunctionStmts;
+} plStmts;
 
-static bool create_function_stmts_walker(Node *node, createFunctionStmts *state)
+static bool stmts_walker(Node *node, plStmts *state)
 {
 	bool result;
 	MemoryContext ccxt = CurrentMemoryContext;
 
 	if (node == NULL) return false;
 
-	if (IsA(node, CreateFunctionStmt))
+	if (IsA(node, CreateFunctionStmt) || IsA(node, DoStmt))
 	{
 		if (state->stmts_count >= state->stmts_buf_size)
 		{
 			state->stmts_buf_size *= 2;
-			state->stmts = (CreateFunctionStmt**) repalloc(state->stmts, state->stmts_buf_size * sizeof(CreateFunctionStmt*));
+			state->stmts = (Node**) repalloc(state->stmts, state->stmts_buf_size * sizeof(Node*));
 		}
-		state->stmts[state->stmts_count] = (CreateFunctionStmt *) node;
+		state->stmts[state->stmts_count] = (Node *) node;
 		state->stmts_count++;
 	} else if (IsA(node, RawStmt)) {
-		return create_function_stmts_walker((Node *) ((RawStmt *) node)->stmt, state);
+		return stmts_walker((Node *) ((RawStmt *) node)->stmt, state);
 	}
 
 	PG_TRY();
 	{
-		result = raw_expression_tree_walker(node, create_function_stmts_walker, (void*) state);
+		result = raw_expression_tree_walker(node, stmts_walker, (void*) state);
 	}
 	PG_CATCH();
 	{
@@ -401,7 +444,7 @@ PgQueryPlpgsqlParseResult pg_query_parse_plpgsql(const char* input)
 	MemoryContext ctx = NULL;
 	PgQueryPlpgsqlParseResult result = {0};
 	PgQueryInternalParsetreeAndError parse_result;
-	createFunctionStmts statements;
+	plStmts statements;
 	size_t i;
 
 	ctx = pg_query_enter_memory_context();
@@ -414,10 +457,10 @@ PgQueryPlpgsqlParseResult pg_query_parse_plpgsql(const char* input)
 	}
 
 	statements.stmts_buf_size = 100;
-	statements.stmts = (CreateFunctionStmt**) palloc(statements.stmts_buf_size * sizeof(CreateFunctionStmt*));
+	statements.stmts = (Node**) palloc(statements.stmts_buf_size * sizeof(Node*));
 	statements.stmts_count = 0;
 
-	create_function_stmts_walker((Node*) parse_result.tree, &statements);
+	stmts_walker((Node*) parse_result.tree, &statements);
 
 	if (statements.stmts_count == 0) {
 		result.plpgsql_funcs = strdup("[]");

data/ext/pg_query/src_backend_catalog_namespace.c

@@ -62,6 +62,7 @@
 #include "utils/inval.h"
 #include "utils/lsyscache.h"
 #include "utils/memutils.h"
+#include "utils/snapmgr.h"
 #include "utils/syscache.h"
 #include "utils/varlena.h"
 

data/ext/pg_query/src_backend_libpq_pqcomm.c

@@ -404,6 +404,14 @@ const PQcommMethods *PqCommMethods = NULL;
  */
 
 
+/* --------------------------------
+ *		pq_buffer_has_data		- is any buffered data available to read?
+ *
+ * This will *not* attempt to read more data.
+ * --------------------------------
+ */
+
+
 
 /* --------------------------------
  *		pq_startmsgread - begin reading a message from the client.

data/ext/pg_query/src_backend_nodes_copyfuncs.c

@@ -345,8 +345,11 @@
 #define COPY_POINTER_FIELD(fldname, sz) \
 	do { \
 		Size	_size = (sz); \
-		newnode->fldname = palloc(_size); \
-		memcpy(newnode->fldname, from->fldname, _size); \
+		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) */
@@ -584,12 +587,9 @@ _copyRecursiveUnion(const RecursiveUnion *from)
 	 */
 	COPY_SCALAR_FIELD(wtParam);
 	COPY_SCALAR_FIELD(numCols);
-	if (from->numCols > 0)
-	{
-		COPY_POINTER_FIELD(dupColIdx, from->numCols * sizeof(AttrNumber));
-		COPY_POINTER_FIELD(dupOperators, from->numCols * sizeof(Oid));
-		COPY_POINTER_FIELD(dupCollations, from->numCols * sizeof(Oid));
-	}
+	COPY_POINTER_FIELD(dupColIdx, from->numCols * sizeof(AttrNumber));
+	COPY_POINTER_FIELD(dupOperators, from->numCols * sizeof(Oid));
+	COPY_POINTER_FIELD(dupCollations, from->numCols * sizeof(Oid));
 	COPY_SCALAR_FIELD(numGroups);
 
 	return newnode;
@@ -803,6 +803,7 @@ _copyIndexOnlyScan(const IndexOnlyScan *from)
 	 */
 	COPY_SCALAR_FIELD(indexid);
 	COPY_NODE_FIELD(indexqual);
+	COPY_NODE_FIELD(recheckqual);
 	COPY_NODE_FIELD(indexorderby);
 	COPY_NODE_FIELD(indextlist);
 	COPY_SCALAR_FIELD(indexorderdir);
@@ -1162,13 +1163,10 @@ _copyMergeJoin(const MergeJoin *from)
 	COPY_SCALAR_FIELD(skip_mark_restore);
 	COPY_NODE_FIELD(mergeclauses);
 	numCols = list_length(from->mergeclauses);
-	if (numCols > 0)
-	{
-		COPY_POINTER_FIELD(mergeFamilies, numCols * sizeof(Oid));
-		COPY_POINTER_FIELD(mergeCollations, numCols * sizeof(Oid));
-		COPY_POINTER_FIELD(mergeStrategies, numCols * sizeof(int));
-		COPY_POINTER_FIELD(mergeNullsFirst, numCols * sizeof(bool));
-	}
+	COPY_POINTER_FIELD(mergeFamilies, numCols * sizeof(Oid));
+	COPY_POINTER_FIELD(mergeCollations, numCols * sizeof(Oid));
+	COPY_POINTER_FIELD(mergeStrategies, numCols * sizeof(int));
+	COPY_POINTER_FIELD(mergeNullsFirst, numCols * sizeof(bool));
 
 	return newnode;
 }
@@ -1303,12 +1301,9 @@ _copyAgg(const Agg *from)
 	COPY_SCALAR_FIELD(aggstrategy);
 	COPY_SCALAR_FIELD(aggsplit);
 	COPY_SCALAR_FIELD(numCols);
-	if (from->numCols > 0)
-	{
-		COPY_POINTER_FIELD(grpColIdx, from->numCols * sizeof(AttrNumber));
-		COPY_POINTER_FIELD(grpOperators, from->numCols * sizeof(Oid));
-		COPY_POINTER_FIELD(grpCollations, from->numCols * sizeof(Oid));
-	}
+	COPY_POINTER_FIELD(grpColIdx, from->numCols * sizeof(AttrNumber));
+	COPY_POINTER_FIELD(grpOperators, from->numCols * sizeof(Oid));
+	COPY_POINTER_FIELD(grpCollations, from->numCols * sizeof(Oid));
 	COPY_SCALAR_FIELD(numGroups);
 	COPY_SCALAR_FIELD(transitionSpace);
 	COPY_BITMAPSET_FIELD(aggParams);
@@ -1330,19 +1325,13 @@ _copyWindowAgg(const WindowAgg *from)
 
 	COPY_SCALAR_FIELD(winref);
 	COPY_SCALAR_FIELD(partNumCols);
-	if (from->partNumCols > 0)
-	{
-		COPY_POINTER_FIELD(partColIdx, from->partNumCols * sizeof(AttrNumber));
-		COPY_POINTER_FIELD(partOperators, from->partNumCols * sizeof(Oid));
-		COPY_POINTER_FIELD(partCollations, from->partNumCols * sizeof(Oid));
-	}
+	COPY_POINTER_FIELD(partColIdx, from->partNumCols * sizeof(AttrNumber));
+	COPY_POINTER_FIELD(partOperators, from->partNumCols * sizeof(Oid));
+	COPY_POINTER_FIELD(partCollations, from->partNumCols * sizeof(Oid));
 	COPY_SCALAR_FIELD(ordNumCols);
-	if (from->ordNumCols > 0)
-	{
-		COPY_POINTER_FIELD(ordColIdx, from->ordNumCols * sizeof(AttrNumber));
-		COPY_POINTER_FIELD(ordOperators, from->ordNumCols * sizeof(Oid));
-		COPY_POINTER_FIELD(ordCollations, from->ordNumCols * sizeof(Oid));
-	}
+	COPY_POINTER_FIELD(ordColIdx, from->ordNumCols * sizeof(AttrNumber));
+	COPY_POINTER_FIELD(ordOperators, from->ordNumCols * sizeof(Oid));
+	COPY_POINTER_FIELD(ordCollations, from->ordNumCols * sizeof(Oid));
 	COPY_SCALAR_FIELD(frameOptions);
 	COPY_NODE_FIELD(startOffset);
 	COPY_NODE_FIELD(endOffset);
@@ -3510,6 +3499,7 @@ _copyAlterTableCmd(const AlterTableCmd *from)
 	COPY_NODE_FIELD(def);
 	COPY_SCALAR_FIELD(behavior);
 	COPY_SCALAR_FIELD(missing_ok);
+	COPY_SCALAR_FIELD(recurse);
 
 	return newnode;
 }

data/ext/pg_query/src_backend_nodes_equalfuncs.c

@@ -1335,6 +1335,7 @@ _equalAlterTableCmd(const AlterTableCmd *a, const AlterTableCmd *b)
 	COMPARE_NODE_FIELD(def);
 	COMPARE_SCALAR_FIELD(behavior);
 	COMPARE_SCALAR_FIELD(missing_ok);
+	COMPARE_SCALAR_FIELD(recurse);
 
 	return true;
 }

data/ext/pg_query/src_backend_nodes_list.c

@@ -642,6 +642,18 @@ 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.
+ */
+#ifndef DEBUG_LIST_MEMORY_USAGE
+#else
+#ifdef CLOBBER_FREED_MEMORY
+#else
+#endif
+#endif
+
 /*
  * Generate the union of two lists. This is calculated by copying
  * list1 via list_copy(), then adding to it all the members of list2

data/ext/pg_query/src_backend_parser_gram.c

@@ -457,7 +457,7 @@
      REASSIGN = 579,
      RECHECK = 580,
      RECURSIVE = 581,
-     REF = 582,
+     REF_P = 582,
      REFERENCES = 583,
      REFERENCING = 584,
      REFRESH = 585,
@@ -934,7 +934,7 @@
 #define REASSIGN 579
 #define RECHECK 580
 #define RECURSIVE 581
-#define REF 582
+#define REF_P 582
 #define REFERENCES 583
 #define REFERENCING 584
 #define REFRESH 585
@@ -3354,7 +3354,7 @@ static const char *const yytname[] =
   "PRESERVE", "PREPARE", "PREPARED", "PRIMARY", "PRIOR", "PRIVILEGES",
   "PROCEDURAL", "PROCEDURE", "PROCEDURES", "PROGRAM", "PUBLICATION",
   "QUOTE", "RANGE", "READ", "REAL", "REASSIGN", "RECHECK", "RECURSIVE",
-  "REF", "REFERENCES", "REFERENCING", "REFRESH", "REINDEX", "RELATIVE_P",
+  "REF_P", "REFERENCES", "REFERENCING", "REFRESH", "REINDEX", "RELATIVE_P",
   "RELEASE", "RENAME", "REPEATABLE", "REPLACE", "REPLICA", "RESET",
   "RESTART", "RESTRICT", "RETURNING", "RETURNS", "REVOKE", "RIGHT", "ROLE",
   "ROLLBACK", "ROLLUP", "ROUTINE", "ROUTINES", "ROW", "ROWS", "RULE",
@@ -46994,6 +46994,21 @@ insertSelectOptions(SelectStmt *stmt,
 			ereport(ERROR,
 					(errcode(ERRCODE_SYNTAX_ERROR),
 					 errmsg("WITH TIES cannot be specified without ORDER BY clause")));
+		if (limitClause->limitOption == LIMIT_OPTION_WITH_TIES && stmt->lockingClause)
+		{
+			ListCell   *lc;
+
+			foreach(lc, stmt->lockingClause)
+			{
+				LockingClause *lock = lfirst_node(LockingClause, lc);
+
+				if (lock->waitPolicy == LockWaitSkip)
+					ereport(ERROR,
+							(errcode(ERRCODE_SYNTAX_ERROR),
+							 errmsg("%s and %s options cannot be used together",
+									"SKIP LOCKED", "WITH TIES")));
+			}
+		}
 		stmt->limitOption = limitClause->limitOption;
 	}
 	if (withClause)