pg_query 2.0.3 → 2.1.3

data/ext/pg_query/pg_query_deparse.c

@@ -2247,6 +2247,12 @@ static void deparseRangeVar(StringInfo str, RangeVar *range_var, DeparseNodeCont
 	if (!range_var->inh && context != DEPARSE_NODE_CONTEXT_CREATE_TYPE && context != DEPARSE_NODE_CONTEXT_ALTER_TYPE)
 		appendStringInfoString(str, "ONLY ");
 
+	if (range_var->catalogname != NULL)
+	{
+		appendStringInfoString(str, quote_identifier(range_var->catalogname));
+		appendStringInfoChar(str, '.');
+	}
+
 	if (range_var->schemaname != NULL)
 	{
 		appendStringInfoString(str, quote_identifier(range_var->schemaname));

data/ext/pg_query/pg_query_fingerprint.c

@@ -17,6 +17,8 @@
 #include "nodes/parsenodes.h"
 #include "nodes/value.h"
 
+#include "common/hashfn.h"
+
 #include <unistd.h>
 #include <fcntl.h>
 
@@ -26,15 +28,41 @@ typedef struct FingerprintContext
 {
 	XXH3_state_t *xxh_state;
 
+	struct listsort_cache_hash *listsort_cache;
+
 	bool write_tokens;
 	dlist_head tokens;
 } FingerprintContext;
 
-typedef struct FingerprintListContext
+typedef struct FingerprintListsortItem
 {
 	XXH64_hash_t hash;
 	size_t list_pos;
-} FingerprintListContext;
+} FingerprintListsortItem;
+
+typedef struct FingerprintListsortItemCacheEntry
+{
+	/* List node this cache entry is for */
+	uintptr_t node;
+
+	/* Hashes of all list items -- this is expensive to calculate */
+	FingerprintListsortItem **listsort_items;
+	size_t listsort_items_size;
+
+	/* hash entry status */
+	char status;
+} FingerprintListsortItemCacheEntry;
+
+#define SH_PREFIX listsort_cache
+#define SH_ELEMENT_TYPE FingerprintListsortItemCacheEntry
+#define SH_KEY_TYPE uintptr_t
+#define SH_KEY node
+#define SH_HASH_KEY(tb, key) hash_bytes((const unsigned char *) &key, sizeof(uintptr_t))
+#define SH_EQUAL(tb, a, b) a == b
+#define SH_SCOPE static inline
+#define SH_DEFINE
+#define SH_DECLARE
+#include "lib/simplehash.h"
 
 typedef struct FingerprintToken
 {
@@ -43,7 +71,7 @@ typedef struct FingerprintToken
 } FingerprintToken;
 
 static void _fingerprintNode(FingerprintContext *ctx, const void *obj, const void *parent, char *parent_field_name, unsigned int depth);
-static void _fingerprintInitContext(FingerprintContext *ctx, bool write_tokens);
+static void _fingerprintInitContext(FingerprintContext *ctx, FingerprintContext *parent, bool write_tokens);
 static void _fingerprintFreeContext(FingerprintContext *ctx);
 
 #define PG_QUERY_FINGERPRINT_VERSION 3
@@ -96,10 +124,10 @@ _fingerprintBitString(FingerprintContext *ctx, const Value *node)
 	}
 }
 
-static int compareFingerprintListContext(const void *a, const void *b)
+static int compareFingerprintListsortItem(const void *a, const void *b)
 {
-	FingerprintListContext *ca = *(FingerprintListContext**) a;
-	FingerprintListContext *cb = *(FingerprintListContext**) b;
+	FingerprintListsortItem *ca = *(FingerprintListsortItem**) a;
+	FingerprintListsortItem *cb = *(FingerprintListsortItem**) b;
 	if (ca->hash > cb->hash)
 		return 1;
 	else if (ca->hash < cb->hash)
@@ -111,38 +139,69 @@ static void
 _fingerprintList(FingerprintContext *ctx, const List *node, const void *parent, char *field_name, unsigned int depth)
 {
 	if (field_name != NULL && (strcmp(field_name, "fromClause") == 0 || strcmp(field_name, "targetList") == 0 ||
-			strcmp(field_name, "cols") == 0 || strcmp(field_name, "rexpr") == 0 || strcmp(field_name, "valuesLists") == 0 ||
-			strcmp(field_name, "args") == 0)) {
+		strcmp(field_name, "cols") == 0 || strcmp(field_name, "rexpr") == 0 || strcmp(field_name, "valuesLists") == 0 ||
+		strcmp(field_name, "args") == 0))
+	{
+		/*
+		 * Check for cached values for the hashes of subnodes
+		 *
+		 * Note this cache is important so we avoid exponential runtime behavior,
+		 * which would be the case if we fingerprinted each node twice, which
+		 * then would also again have to fingerprint each of its subnodes twice,
+		 * etc., leading to deep nodes to be fingerprinted many many times over.
+		 *
+		 * We have seen real-world problems with this logic here without
+		 * a cache in place.
+		 */
+		FingerprintListsortItem** listsort_items = NULL;
+		size_t listsort_items_size = 0;
+		FingerprintListsortItemCacheEntry *entry = listsort_cache_lookup(ctx->listsort_cache, (uintptr_t) node);
+		if (entry != NULL)
+		{
+			listsort_items = entry->listsort_items;
+			listsort_items_size = entry->listsort_items_size;
+		}
+		else
+		{
+			listsort_items = palloc0(node->length * sizeof(FingerprintListsortItem*));
+			listsort_items_size = 0;
+			ListCell *lc;
+			bool found;
 
-		FingerprintListContext** listCtxArr = palloc0(node->length * sizeof(FingerprintListContext*));
-		size_t listCtxCount = 0;
-		const ListCell *lc;
+			foreach(lc, node)
+			{
+				FingerprintContext fctx;
+				FingerprintListsortItem* lctx = palloc0(sizeof(FingerprintListsortItem));
 
-		foreach(lc, node)
-		{
-			FingerprintContext subCtx;
-			FingerprintListContext* listCtx = palloc0(sizeof(FingerprintListContext));
+				_fingerprintInitContext(&fctx, ctx, false);
+				_fingerprintNode(&fctx, lfirst(lc), parent, field_name, depth + 1);
+				lctx->hash = XXH3_64bits_digest(fctx.xxh_state);
+				lctx->list_pos = listsort_items_size;
+				_fingerprintFreeContext(&fctx);
 
-			_fingerprintInitContext(&subCtx, false);
-			_fingerprintNode(&subCtx, lfirst(lc), parent, field_name, depth + 1);
-			listCtx->hash = XXH3_64bits_digest(subCtx.xxh_state);
-			listCtx->list_pos = listCtxCount;
-			_fingerprintFreeContext(&subCtx);
+				listsort_items[listsort_items_size] = lctx;
+				listsort_items_size += 1;
+			}
 
-			listCtxArr[listCtxCount] = listCtx;
-			listCtxCount += 1;
-		}
+			pg_qsort(listsort_items, listsort_items_size, sizeof(FingerprintListsortItem*), compareFingerprintListsortItem);
 
-		pg_qsort(listCtxArr, listCtxCount, sizeof(FingerprintListContext*), compareFingerprintListContext);
+			FingerprintListsortItemCacheEntry *entry = listsort_cache_insert(ctx->listsort_cache, (uintptr_t) node, &found);
+			Assert(!found);
 
-		for (size_t i = 0; i < listCtxCount; i++)
+			entry->listsort_items = listsort_items;
+			entry->listsort_items_size = listsort_items_size;
+		}
+
+		for (size_t i = 0; i < listsort_items_size; i++)
 		{
-			if (i > 0 && listCtxArr[i - 1]->hash == listCtxArr[i]->hash)
+			if (i > 0 && listsort_items[i - 1]->hash == listsort_items[i]->hash)
 				continue; // Ignore duplicates
 
-			_fingerprintNode(ctx, lfirst(list_nth_cell(node, listCtxArr[i]->list_pos)), parent, field_name, depth + 1);
+			_fingerprintNode(ctx, lfirst(list_nth_cell(node, listsort_items[i]->list_pos)), parent, field_name, depth + 1);
 		}
-	} else {
+	}
+	else
+	{
 		const ListCell *lc;
 
 		foreach(lc, node)
@@ -155,15 +214,28 @@ _fingerprintList(FingerprintContext *ctx, const List *node, const void *parent,
 }
 
 static void
-_fingerprintInitContext(FingerprintContext *ctx, bool write_tokens) {
+_fingerprintInitContext(FingerprintContext *ctx, FingerprintContext *parent, bool write_tokens)
+{
 	ctx->xxh_state = XXH3_createState();
 	if (ctx->xxh_state == NULL) abort();
 	if (XXH3_64bits_reset_withSeed(ctx->xxh_state, PG_QUERY_FINGERPRINT_VERSION) == XXH_ERROR) abort();
 
-	if (write_tokens) {
+	if (parent != NULL)
+	{
+		ctx->listsort_cache = parent->listsort_cache;
+	}
+	else
+	{
+		ctx->listsort_cache = listsort_cache_create(CurrentMemoryContext, 128, NULL);
+	}
+
+	if (write_tokens)
+	{
 		ctx->write_tokens = true;
 		dlist_init(&ctx->tokens);
-	} else {
+	}
+	else
+	{
 		ctx->write_tokens = false;
 	}
 }
@@ -219,6 +291,21 @@ _fingerprintNode(FingerprintContext *ctx, const void *obj, const void *parent, c
 	}
 }
 
+uint64_t pg_query_fingerprint_node(const void *node)
+{
+	FingerprintContext ctx;
+	uint64 result;
+
+	_fingerprintInitContext(&ctx, NULL, false);
+	_fingerprintNode(&ctx, node, NULL, NULL, 0);
+
+	result = XXH3_64bits_digest(ctx.xxh_state);
+
+	_fingerprintFreeContext(&ctx);
+
+	return result;
+}
+
 PgQueryFingerprintResult pg_query_fingerprint_with_opts(const char* input, bool printTokens)
 {
 	MemoryContext ctx = NULL;
@@ -237,7 +324,7 @@ PgQueryFingerprintResult pg_query_fingerprint_with_opts(const char* input, bool
 		FingerprintContext ctx;
 		XXH64_canonical_t chash;
 
-		_fingerprintInitContext(&ctx, printTokens);
+		_fingerprintInitContext(&ctx, NULL, printTokens);
 
 		if (parsetree_and_error.tree != NULL) {
 			_fingerprintNode(&ctx, parsetree_and_error.tree, NULL, NULL, 0);

data/ext/pg_query/pg_query_fingerprint.h

@@ -3,6 +3,8 @@
 
 #include <stdbool.h>
 
-PgQueryFingerprintResult pg_query_fingerprint_with_opts(const char* input, bool printTokens);
+extern PgQueryFingerprintResult pg_query_fingerprint_with_opts(const char* input, bool printTokens);
+
+extern uint64_t pg_query_fingerprint_node(const void * node);
 
 #endif

data/ext/pg_query/pg_query_normalize.c

@@ -1,5 +1,6 @@
 #include "pg_query.h"
 #include "pg_query_internal.h"
+#include "pg_query_fingerprint.h"
 
 #include "parser/parser.h"
 #include "parser/scanner.h"
@@ -14,6 +15,7 @@ typedef struct pgssLocationLen
 {
 	int			location;		/* start offset in query text */
 	int			length;			/* length in bytes, or -1 to ignore */
+	int			param_id;		/* Param id to use - if negative prefix, need to abs(..) and add highest_extern_param_id */
 } pgssLocationLen;
 
 /*
@@ -30,14 +32,32 @@ typedef struct pgssConstLocations
 	/* Current number of valid entries in clocations array */
 	int			clocations_count;
 
+	/* highest Param id we have assigned, not yet taking into account external param refs */
+	int			highest_normalize_param_id;
+
 	/* highest Param id we've seen, in order to start normalization correctly */
 	int			highest_extern_param_id;
 
 	/* query text */
 	const char * query;
 	int			query_len;
+
+	/* optional recording of assigned or discovered param refs, only active if param_refs is not NULL */
+	int *param_refs;
+	int param_refs_buf_size;
+	int param_refs_count;
 } pgssConstLocations;
 
+/*
+ * Intermediate working state struct to remember param refs for individual target list elements
+ */
+typedef struct FpAndParamRefs
+{
+	uint64_t fp;
+	int* param_refs;
+	int param_refs_count;
+} FpAndParamRefs;
+
 /*
  * comp_location: comparator for qsorting pgssLocationLen structs by location
  */
@@ -230,7 +250,8 @@ generate_normalized_query(pgssConstLocations *jstate, int query_loc, int* query_
 	for (i = 0; i < jstate->clocations_count; i++)
 	{
 		int			off,		/* Offset from start for cur tok */
-					tok_len;	/* Length (in bytes) of that tok */
+					tok_len,	/* Length (in bytes) of that tok */
+					param_id;	/* Param ID to be assigned */
 
 		off = jstate->clocations[i].location;
 		/* Adjust recorded location if we're dealing with partial string */
@@ -250,8 +271,10 @@ generate_normalized_query(pgssConstLocations *jstate, int query_loc, int* query_
 		n_quer_loc += len_to_wrt;
 
 		/* And insert a param symbol in place of the constant token */
-		n_quer_loc += sprintf(norm_query + n_quer_loc, "$%d",
-							  i + 1 + jstate->highest_extern_param_id);
+		param_id = (jstate->clocations[i].param_id < 0) ?
+					jstate->highest_extern_param_id + abs(jstate->clocations[i].param_id) :
+					jstate->clocations[i].param_id;
+		n_quer_loc += sprintf(norm_query + n_quer_loc, "$%d", param_id);
 
 		quer_loc = off + tok_len;
 		last_off = off;
@@ -292,6 +315,18 @@ static void RecordConstLocation(pgssConstLocations *jstate, int location)
 		jstate->clocations[jstate->clocations_count].location = location;
 		/* initialize lengths to -1 to simplify fill_in_constant_lengths */
 		jstate->clocations[jstate->clocations_count].length = -1;
+		/* by default we assume that we need a new param ref */
+		jstate->clocations[jstate->clocations_count].param_id = - jstate->highest_normalize_param_id;
+		jstate->highest_normalize_param_id++;
+		/* record param ref number if requested */
+		if (jstate->param_refs != NULL) {
+			jstate->param_refs[jstate->param_refs_count] = jstate->clocations[jstate->clocations_count].param_id;
+			jstate->param_refs_count++;
+			if (jstate->param_refs_count >= jstate->param_refs_buf_size) {
+				jstate->param_refs_buf_size *= 2;
+				jstate->param_refs = (int *) repalloc(jstate->param_refs, jstate->param_refs_buf_size * sizeof(int));
+			}
+		}
 		jstate->clocations_count++;
 	}
 }
@@ -303,71 +338,188 @@ static bool const_record_walker(Node *node, pgssConstLocations *jstate)
 
 	if (node == NULL) return false;
 
-	if (IsA(node, A_Const))
+	switch (nodeTag(node))
 	{
-		RecordConstLocation(jstate, castNode(A_Const, node)->location);
-	}
-	else if (IsA(node, ParamRef))
-	{
-		/* Track the highest ParamRef number */
-		if (((ParamRef *) node)->number > jstate->highest_extern_param_id)
-			jstate->highest_extern_param_id = castNode(ParamRef, node)->number;
-	}
-	else if (IsA(node, 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;
-			  }
+		case T_A_Const:
+			RecordConstLocation(jstate, castNode(A_Const, node)->location);
+			break;
+		case T_ParamRef:
+			{
+				/* Track the highest ParamRef number */
+				if (((ParamRef *) node)->number > jstate->highest_extern_param_id)
+					jstate->highest_extern_param_id = castNode(ParamRef, node)->number;
+
+				if (jstate->param_refs != NULL) {
+					jstate->param_refs[jstate->param_refs_count] = ((ParamRef *) node)->number;
+					jstate->param_refs_count++;
+					if (jstate->param_refs_count >= jstate->param_refs_buf_size) {
+						jstate->param_refs_buf_size *= 2;
+						jstate->param_refs = (int *) repalloc(jstate->param_refs, jstate->param_refs_buf_size * sizeof(int));
+					}
+				}
 			}
-		}
-		return const_record_walker((Node *) ((DefElem *) node)->arg, jstate);
-	}
-	else if (IsA(node, RawStmt))
-	{
-		return const_record_walker((Node *) ((RawStmt *) node)->stmt, jstate);
-	}
-	else if (IsA(node, VariableSetStmt))
-	{
-		return const_record_walker((Node *) ((VariableSetStmt *) node)->args, jstate);
-	}
-	else if (IsA(node, CopyStmt))
-	{
-		return const_record_walker((Node *) ((CopyStmt *) node)->query, jstate);
-	}
-	else if (IsA(node, ExplainStmt))
-	{
-		return const_record_walker((Node *) ((ExplainStmt *) node)->query, jstate);
-	}
-	else if (IsA(node, CreateRoleStmt))
-	{
-		return const_record_walker((Node *) ((CreateRoleStmt *) node)->options, jstate);
-	}
-	else if (IsA(node, AlterRoleStmt))
-	{
-		return const_record_walker((Node *) ((AlterRoleStmt *) node)->options, jstate);
-	}
-	else if (IsA(node, DeclareCursorStmt))
-	{
-		return const_record_walker((Node *) ((DeclareCursorStmt *) node)->query, jstate);
-	}
+			break;
+		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;
+						}
+					}
+				}
+				return const_record_walker((Node *) ((DefElem *) node)->arg, jstate);
+			}
+			break;
+		case T_RawStmt:
+			return const_record_walker((Node *) ((RawStmt *) node)->stmt, jstate);
+		case T_VariableSetStmt:
+			return const_record_walker((Node *) ((VariableSetStmt *) node)->args, jstate);
+		case T_CopyStmt:
+			return const_record_walker((Node *) ((CopyStmt *) node)->query, jstate);
+		case T_ExplainStmt:
+			return const_record_walker((Node *) ((ExplainStmt *) node)->query, jstate);
+		case T_CreateRoleStmt:
+			return const_record_walker((Node *) ((CreateRoleStmt *) node)->options, jstate);
+		case T_AlterRoleStmt:
+			return const_record_walker((Node *) ((AlterRoleStmt *) node)->options, jstate);
+		case T_DeclareCursorStmt:
+			return const_record_walker((Node *) ((DeclareCursorStmt *) node)->query, jstate);
+		case T_TypeName:
+			/* Don't normalize constants in typmods or arrayBounds */
+			return false;
+		case T_SelectStmt:
+			{
+				SelectStmt *stmt = (SelectStmt *) node;
+				ListCell *lc;
+				List *fp_and_param_refs_list = NIL;
+
+				if (const_record_walker((Node *) stmt->distinctClause, jstate))
+					return true;
+				if (const_record_walker((Node *) stmt->intoClause, jstate))
+					return true;
+				foreach(lc, stmt->targetList)
+				{
+					ResTarget *res_target = lfirst_node(ResTarget, lc);
+					FpAndParamRefs *fp_and_param_refs = palloc0(sizeof(FpAndParamRefs));
+
+					/* Save all param refs we encounter or assign */
+					jstate->param_refs = palloc0(1 * sizeof(int));
+					jstate->param_refs_buf_size = 1;
+					jstate->param_refs_count = 0;
+
+					/* Walk the element */
+					if (const_record_walker((Node *) res_target, jstate))
+						return true;
+
+					/* Remember fingerprint and param refs for later */
+					fp_and_param_refs->fp = pg_query_fingerprint_node(res_target->val);
+					fp_and_param_refs->param_refs = jstate->param_refs;
+					fp_and_param_refs->param_refs_count = jstate->param_refs_count;
+					fp_and_param_refs_list = lappend(fp_and_param_refs_list, fp_and_param_refs);
+
+					/* Reset for next element, or stop recording if this is the last element */
+					jstate->param_refs = NULL;
+					jstate->param_refs_buf_size = 0;
+					jstate->param_refs_count = 0;
+				}
+				if (const_record_walker((Node *) stmt->fromClause, jstate))
+					return true;
+				if (const_record_walker((Node *) stmt->whereClause, jstate))
+					return true;
 
-	PG_TRY();
-	{
-		result = raw_expression_tree_walker(node, const_record_walker, (void*) jstate);
-	}
-	PG_CATCH();
-	{
-		MemoryContextSwitchTo(normalize_context);
-		result = false;
-		FlushErrorState();
+				/*
+				 * Instead of walking all of groupClause (like raw_expression_tree_walker does),
+				 * only walk certain items.
+				 */
+				foreach(lc, stmt->groupClause)
+				{
+					/*
+					 * Do not walk A_Const values that are simple integers, this avoids
+					 * turning "GROUP BY 1" into "GROUP BY $n", which obscures an important
+					 * semantic meaning. This matches how pg_stat_statements handles the
+					 * GROUP BY clause (i.e. it doesn't touch these constants)
+					 */
+					if (IsA(lfirst(lc), A_Const) && IsA(&castNode(A_Const, lfirst(lc))->val, Integer))
+						continue;
+
+					/*
+					 * Match up GROUP BY clauses against the target list, to assign the same
+					 * param refs as used in the target list - this ensures the query is valid,
+					 * instead of throwing a bogus "columns ... must appear in the GROUP BY
+					 * clause or be used in an aggregate function" error
+					 */
+					uint64_t fp = pg_query_fingerprint_node(lfirst(lc));
+					FpAndParamRefs *fppr = NULL;
+					ListCell *lc2;
+					foreach(lc2, fp_and_param_refs_list) {
+						if (fp == ((FpAndParamRefs *) lfirst(lc2))->fp) {
+							fppr = (FpAndParamRefs *) lfirst(lc2);
+							foreach_delete_current(fp_and_param_refs_list, lc2);
+							break;
+						}
+					}
+
+					int prev_cloc_count = jstate->clocations_count;
+					if (const_record_walker((Node *) lfirst(lc), jstate))
+						return true;
+
+					if (fppr != NULL && fppr->param_refs_count == jstate->clocations_count - prev_cloc_count) {
+						for (int i = prev_cloc_count; i < jstate->clocations_count; i++) {
+							jstate->clocations[i].param_id = fppr->param_refs[i - prev_cloc_count];
+						}
+						jstate->highest_normalize_param_id -= fppr->param_refs_count;
+					}
+				}
+				foreach(lc, stmt->sortClause)
+				{
+					/* Similarly, don't turn "ORDER BY 1" into "ORDER BY $n" */
+					if (IsA(lfirst(lc), SortBy) && IsA(castNode(SortBy, lfirst(lc))->node, A_Const) &&
+					    IsA(&castNode(A_Const, castNode(SortBy, lfirst(lc))->node)->val, Integer))
+						continue;
+
+					if (const_record_walker((Node *) lfirst(lc), jstate))
+						return true;
+				}
+				if (const_record_walker((Node *) stmt->havingClause, jstate))
+					return true;
+				if (const_record_walker((Node *) stmt->windowClause, jstate))
+					return true;
+				if (const_record_walker((Node *) stmt->valuesLists, jstate))
+					return true;
+				if (const_record_walker((Node *) stmt->limitOffset, jstate))
+					return true;
+				if (const_record_walker((Node *) stmt->limitCount, jstate))
+					return true;
+				if (const_record_walker((Node *) stmt->lockingClause, jstate))
+					return true;
+				if (const_record_walker((Node *) stmt->withClause, jstate))
+					return true;
+				if (const_record_walker((Node *) stmt->larg, jstate))
+					return true;
+				if (const_record_walker((Node *) stmt->rarg, jstate))
+					return true;
+
+				return false;
+			}
+		default:
+			{
+				PG_TRY();
+				{
+					return raw_expression_tree_walker(node, const_record_walker, (void*) jstate);
+				}
+				PG_CATCH();
+				{
+					MemoryContextSwitchTo(normalize_context);
+					FlushErrorState();
+				}
+				PG_END_TRY();
+			}
 	}
-	PG_END_TRY();
 
-	return result;
+	return false;
 }
 
 PgQueryNormalizeResult pg_query_normalize(const char* input)
@@ -393,9 +545,13 @@ PgQueryNormalizeResult pg_query_normalize(const char* input)
 		jstate.clocations = (pgssLocationLen *)
 			palloc(jstate.clocations_buf_size * sizeof(pgssLocationLen));
 		jstate.clocations_count = 0;
+		jstate.highest_normalize_param_id = 1;
 		jstate.highest_extern_param_id = 0;
 		jstate.query = input;
 		jstate.query_len = query_len;
+		jstate.param_refs = NULL;
+		jstate.param_refs_buf_size = 0;
+		jstate.param_refs_count = 0;
 
 		/* Walk tree and record const locations */
 		const_record_walker((Node *) tree, &jstate);
@@ -414,6 +570,8 @@ PgQueryNormalizeResult pg_query_normalize(const char* input)
 		error = malloc(sizeof(PgQueryError));
 		error->message   = strdup(error_data->message);
 		error->filename  = strdup(error_data->filename);
+		error->funcname  = strdup(error_data->funcname);
+		error->context   = NULL;
 		error->lineno    = error_data->lineno;
 		error->cursorpos = error_data->cursorpos;
 
@@ -432,6 +590,7 @@ void pg_query_free_normalize_result(PgQueryNormalizeResult result)
   if (result.error) {
     free(result.error->message);
     free(result.error->filename);
+    free(result.error->funcname);
     free(result.error);
   }
 

data/ext/pg_query/pg_query_parse_plpgsql.c

@@ -108,7 +108,7 @@ static PLpgSQL_function *compile_create_function_stmt(CreateFunctionStmt* stmt)
 		}
 	}
 
-	assert(proc_source);
+	assert(proc_source != NULL);
 
 	if (stmt->returnType != NULL) {
 		foreach(lc3, stmt->returnType->names)
@@ -179,6 +179,26 @@ static PLpgSQL_function *compile_create_function_stmt(CreateFunctionStmt* stmt)
 	plpgsql_DumpExecTree = false;
 	plpgsql_start_datums();
 
+	/* Setup parameter names */
+	foreach(lc, stmt->parameters)
+	{
+		FunctionParameter *param = lfirst_node(FunctionParameter, lc);
+		if (param->name != NULL)
+		{
+			char buf[32];
+			PLpgSQL_type *argdtype;
+			PLpgSQL_variable *argvariable;
+			PLpgSQL_nsitem_type argitemtype;
+			snprintf(buf, sizeof(buf), "$%d", foreach_current_index(lc) + 1);
+			argdtype = plpgsql_build_datatype(UNKNOWNOID, -1, InvalidOid, NULL);
+			argvariable = plpgsql_build_variable(param->name ? param->name : buf, 0, argdtype, false);
+			argitemtype = argvariable->dtype == PLPGSQL_DTYPE_VAR ? PLPGSQL_NSTYPE_VAR : PLPGSQL_NSTYPE_REC;
+			plpgsql_ns_additem(argitemtype, argvariable->dno, buf);
+			if (param->name != NULL)
+				plpgsql_ns_additem(argitemtype, argvariable->dno, param->name);
+		}
+	}
+
 	/* Set up as though in a function returning VOID */
 	function->fn_rettype = VOIDOID;
 	function->fn_retset = is_setof;

data/ext/pg_query/pg_query_ruby.c

@@ -14,7 +14,7 @@ VALUE pg_query_ruby_fingerprint(VALUE self, VALUE input);
 VALUE pg_query_ruby_scan(VALUE self, VALUE input);
 VALUE pg_query_ruby_hash_xxh3_64(VALUE self, VALUE input, VALUE seed);
 
-void Init_pg_query(void)
+__attribute__((visibility ("default"))) void Init_pg_query(void)
 {
 	VALUE cPgQuery;
 

data/ext/pg_query/pg_query_ruby.sym

@@ -1 +1,2 @@
 _Init_pg_query
+Init_pg_query