pg_query 2.1.0 → 4.2.1

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);
@@ -291,6 +311,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;
@@ -359,6 +394,7 @@ void pg_query_free_fingerprint_result(PgQueryFingerprintResult 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_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_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);
@@ -117,6 +116,7 @@ static void dump_return_next(StringInfo out, PLpgSQL_stmt_return_next *stmt);
 static void dump_return_query(StringInfo out, PLpgSQL_stmt_return_query *stmt);
 static void dump_raise(StringInfo out, PLpgSQL_stmt_raise *stmt);
 static void dump_raise_option(StringInfo out, PLpgSQL_raise_option *node);
+static void dump_assert(StringInfo out, PLpgSQL_stmt_assert *stmt);
 static void dump_execsql(StringInfo out, PLpgSQL_stmt_execsql *stmt);
 static void dump_dynexecute(StringInfo out, PLpgSQL_stmt_dynexecute *stmt);
 static void dump_dynfors(StringInfo out, PLpgSQL_stmt_dynfors *stmt);
@@ -126,6 +126,9 @@ static void dump_open(StringInfo out, PLpgSQL_stmt_open *stmt);
 static void dump_fetch(StringInfo out, PLpgSQL_stmt_fetch *stmt);
 static void dump_close(StringInfo out, PLpgSQL_stmt_close *stmt);
 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_expr(StringInfo out, PLpgSQL_expr *expr);
 static void dump_function(StringInfo out, PLpgSQL_function *func);
 static void dump_exception(StringInfo out, PLpgSQL_exception *node);
@@ -183,6 +186,9 @@ dump_stmt(StringInfo out, PLpgSQL_stmt *node)
 		case PLPGSQL_STMT_RAISE:
 			dump_raise(out, (PLpgSQL_stmt_raise *) node);
 			break;
+		case PLPGSQL_STMT_ASSERT:
+			dump_assert(out, (PLpgSQL_stmt_assert *) node);
+			break;
 		case PLPGSQL_STMT_EXECSQL:
 			dump_execsql(out, (PLpgSQL_stmt_execsql *) node);
 			break;
@@ -207,6 +213,15 @@ dump_stmt(StringInfo out, PLpgSQL_stmt *node)
 		case PLPGSQL_STMT_PERFORM:
 			dump_perform(out, (PLpgSQL_stmt_perform *) node);
 			break;
+		case PLPGSQL_STMT_CALL:
+			dump_call(out, (PLpgSQL_stmt_call *) node);
+			break;
+		case PLPGSQL_STMT_COMMIT:
+			dump_commit(out, (PLpgSQL_stmt_commit *) node);
+			break;
+		case PLPGSQL_STMT_ROLLBACK:
+			dump_rollback(out, (PLpgSQL_stmt_rollback *) node);
+			break;
 		default:
 			elog(ERROR, "unrecognized cmd_type: %d", node->cmd_type);
 			break;
@@ -444,6 +459,35 @@ dump_perform(StringInfo out, PLpgSQL_stmt_perform *node)
 	WRITE_EXPR_FIELD(expr);
 }
 
+static void
+dump_call(StringInfo out, PLpgSQL_stmt_call *node)
+{
+	WRITE_NODE_TYPE("PLpgSQL_stmt_call");
+
+	WRITE_INT_FIELD(lineno, lineno, lineno);
+	WRITE_EXPR_FIELD(expr);
+	WRITE_BOOL_FIELD(is_call, is_call, is_call);
+	WRITE_VARIABLE_FIELD(target);
+}
+
+static void
+dump_commit(StringInfo out, PLpgSQL_stmt_commit *node)
+{
+	WRITE_NODE_TYPE("PLpgSQL_stmt_commit");
+
+	WRITE_INT_FIELD(lineno, lineno, lineno);
+	WRITE_BOOL_FIELD(chain, chain, chain);
+}
+
+static void
+dump_rollback(StringInfo out, PLpgSQL_stmt_rollback *node)
+{
+	WRITE_NODE_TYPE("PLpgSQL_stmt_rollback");
+
+	WRITE_INT_FIELD(lineno, lineno, lineno);
+	WRITE_BOOL_FIELD(chain, chain, chain);
+}
+
 static void
 dump_exit(StringInfo out, PLpgSQL_stmt_exit *node)
 {
@@ -508,6 +552,16 @@ dump_raise_option(StringInfo out, PLpgSQL_raise_option *node)
 	WRITE_EXPR_FIELD(expr);
 }
 
+static void
+dump_assert(StringInfo out, PLpgSQL_stmt_assert *node)
+{
+	WRITE_NODE_TYPE("PLpgSQL_stmt_assert");
+
+	WRITE_INT_FIELD(lineno, lineno, lineno);
+	WRITE_EXPR_FIELD(cond);
+	WRITE_EXPR_FIELD(message);
+}
+
 static void
 dump_execsql(StringInfo out, PLpgSQL_stmt_execsql *node)
 {
@@ -605,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);
@@ -712,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

@@ -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"
@@ -7,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
  */
@@ -14,6 +17,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 +34,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 +252,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 +273,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,10 +317,43 @@ 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++;
 	}
 }
 
+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;
@@ -313,18 +371,26 @@ static bool const_record_walker(Node *node, pgssConstLocations *jstate)
 				/* 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));
+					}
+				}
 			}
 			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;
-						}
-					}
+				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);
 			}
@@ -343,39 +409,109 @@ 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;
 		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;
-				if (const_record_walker((Node *) stmt->targetList, 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;
 
-				// Instead of walking all of groupClause (like raw_expression_tree_walker does),
-				// only walk certain items.
+				/*
+				 * 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)
+					/*
+					 * 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"
+					/* 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;
@@ -436,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);
 
@@ -445,9 +581,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);
@@ -466,6 +606,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;
 
@@ -484,6 +626,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_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

@@ -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
+_outBitString(StringInfo out, const BitString *node)
+{
+	appendStringInfo(out, "\"bsval\":");
+	_outToken(out, node->bsval);
 }
 
 static void
-_outNull(StringInfo out, const Value *node)
+_outAConst(StringInfo out, const A_Const *node)
 {
-	// No fields
+	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"
@@ -259,6 +297,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)
 {