pg_query 6.1.0 → 6.2.1

data/ext/pg_query/pg_query_internal.h

@@ -8,17 +8,18 @@
 #define STDERR_BUFFER_LEN 4096
 #define DEBUG
 
-typedef struct {
-  List *tree;
-  char* stderr_buffer;
-  PgQueryError* error;
-} PgQueryInternalParsetreeAndError;
+typedef struct
+{
+	List	   *tree;
+	char	   *stderr_buffer;
+	PgQueryError *error;
+}			PgQueryInternalParsetreeAndError;
 
-PgQueryInternalParsetreeAndError pg_query_raw_parse(const char* input, int parser_options);
+PgQueryInternalParsetreeAndError pg_query_raw_parse(const char *input, int parser_options);
 
-void pg_query_free_error(PgQueryError *error);
+void		pg_query_free_error(PgQueryError * error);
 
 MemoryContext pg_query_enter_memory_context();
-void pg_query_exit_memory_context(MemoryContext ctx);
+void		pg_query_exit_memory_context(MemoryContext ctx);
 
 #endif

data/ext/pg_query/pg_query_is_utility_stmt.c

@@ -0,0 +1,70 @@
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdlib.h>
+
+#include "pg_query.h"
+#include "pg_query_internal.h"
+#include <nodes/nodes.h>
+#include <nodes/nodeFuncs.h>
+
+static
+bool
+is_utility_stmt_actual(RawStmt *raw_stmt)
+{
+	switch (nodeTag(raw_stmt->stmt))
+	{
+		case T_SelectStmt:
+		case T_InsertStmt:
+		case T_UpdateStmt:
+		case T_DeleteStmt:
+		case T_MergeStmt:
+			return false;
+
+		default:
+			return true;
+	}
+}
+
+PgQueryIsUtilityResult
+pg_query_is_utility_stmt(const char *query)
+{
+	PgQueryIsUtilityResult result = {0};
+	MemoryContext ctx = pg_query_enter_memory_context();
+
+	PgQueryInternalParsetreeAndError parsetree_and_error = pg_query_raw_parse(query, 0);
+
+	if (parsetree_and_error.error)
+	{
+		result.error = parsetree_and_error.error;
+	}
+	else
+	{
+		ListCell   *lc;
+
+		result.length = list_length(parsetree_and_error.tree);
+		result.items = malloc(sizeof(bool) * result.length);
+
+		foreach(lc, parsetree_and_error.tree)
+		{
+			RawStmt    *raw_stmt = lfirst_node(RawStmt, lc);
+
+			result.items[foreach_current_index(lc)] = is_utility_stmt_actual(raw_stmt);
+		}
+	}
+
+	if (parsetree_and_error.stderr_buffer)
+		free(parsetree_and_error.stderr_buffer);
+
+	pg_query_exit_memory_context(ctx);
+
+	return result;
+}
+
+void
+pg_query_free_is_utility_result(PgQueryIsUtilityResult result)
+{
+	if (result.error)
+		pg_query_free_error(result.error);
+
+	free(result.items);
+}

data/ext/pg_query/pg_query_normalize.c

@@ -406,6 +406,9 @@ static bool const_record_walker(Node *node, pgssConstLocations *jstate)
 		case T_CopyStmt:
 			if (jstate->normalize_utility_only) return false;
 			return const_record_walker((Node *) ((CopyStmt *) node)->query, jstate);
+		case T_CallStmt:
+			if (jstate->normalize_utility_only) return false;
+			return const_record_walker((Node *) ((CallStmt *) node)->funccall, jstate);
 		case T_ExplainStmt:
 			return const_record_walker((Node *) ((ExplainStmt *) node)->query, jstate);
 		case T_CreateRoleStmt:

data/ext/pg_query/pg_query_raw_tree_walker_supports.c

@@ -0,0 +1,117 @@
+#include <stdbool.h>
+
+#include "pg_query.h"
+#include "pg_query_internal.h"
+#include "pg_query_outfuncs.h"
+
+#include "parser/parser.h"
+#include "parser/scanner.h"
+#include "parser/scansup.h"
+
+#include "nodes/execnodes.h"
+#include "nodes/nodeFuncs.h"
+#include "nodes/pathnodes.h"
+
+#include "utils/builtins.h"
+
+/*
+ * Returns true if raw_expression_tree_walker() handles it,
+ * otherwise, returns false.
+ *
+ * Up-to-date with postgres 17' implementation as of Aug 19 2025.
+ * https://github.com/postgres/postgres/blob/REL_17_STABLE/src/backend/nodes/nodeFuncs.c#L3964
+ */
+bool
+pg_query_raw_tree_walker_supports(Node *node)
+{
+	switch (nodeTag(node))
+	{
+		case T_JsonFormat:
+		case T_SetToDefault:
+		case T_CurrentOfExpr:
+		case T_SQLValueFunction:
+		case T_Integer:
+		case T_Float:
+		case T_Boolean:
+		case T_String:
+		case T_BitString:
+		case T_ParamRef:
+		case T_A_Const:
+		case T_A_Star:
+		case T_MergeSupportFunc:
+		case T_Alias:
+		case T_RangeVar:
+		case T_GroupingFunc:
+		case T_SubLink:
+		case T_CaseExpr:
+		case T_RowExpr:
+		case T_CoalesceExpr:
+		case T_MinMaxExpr:
+		case T_XmlExpr:
+		case T_JsonReturning:
+		case T_JsonValueExpr:
+		case T_JsonParseExpr:
+		case T_JsonScalarExpr:
+		case T_JsonSerializeExpr:
+		case T_JsonConstructorExpr:
+		case T_JsonIsPredicate:
+		case T_JsonArgument:
+		case T_JsonFuncExpr:
+		case T_JsonBehavior:
+		case T_JsonTable:
+		case T_JsonTableColumn:
+		case T_JsonTablePathSpec:
+		case T_NullTest:
+		case T_BooleanTest:
+		case T_JoinExpr:
+		case T_IntoClause:
+		case T_List:
+		case T_InsertStmt:
+		case T_DeleteStmt:
+		case T_UpdateStmt:
+		case T_MergeStmt:
+		case T_MergeWhenClause:
+		case T_SelectStmt:
+		case T_PLAssignStmt:
+		case T_A_Expr:
+		case T_BoolExpr:
+		case T_ColumnRef:
+		case T_FuncCall:
+		case T_NamedArgExpr:
+		case T_A_Indices:
+		case T_A_Indirection:
+		case T_A_ArrayExpr:
+		case T_ResTarget:
+		case T_MultiAssignRef:
+		case T_TypeCast:
+		case T_CollateClause:
+		case T_SortBy:
+		case T_WindowDef:
+		case T_RangeSubselect:
+		case T_RangeFunction:
+		case T_RangeTableSample:
+		case T_RangeTableFunc:
+		case T_RangeTableFuncCol:
+		case T_TypeName:
+		case T_ColumnDef:
+		case T_IndexElem:
+		case T_GroupingSet:
+		case T_LockingClause:
+		case T_XmlSerialize:
+		case T_WithClause:
+		case T_InferClause:
+		case T_OnConflictClause:
+		case T_CommonTableExpr:
+		case T_JsonOutput:
+		case T_JsonKeyValue:
+		case T_JsonObjectConstructor:
+		case T_JsonArrayConstructor:
+		case T_JsonAggConstructor:
+		case T_JsonObjectAgg:
+		case T_JsonArrayAgg:
+		case T_JsonArrayQueryConstructor:
+			return true;
+		default:
+			return false;
+	}
+}

data/ext/pg_query/pg_query_ruby.c

@@ -1,4 +1,5 @@
 #include "pg_query.h"
+#include "postgres_deparse.h"
 #include "xxhash/xxhash.h"
 #include <ruby.h>
 
@@ -6,12 +7,16 @@ void raise_ruby_parse_error(PgQueryProtobufParseResult result);
 void raise_ruby_normalize_error(PgQueryNormalizeResult result);
 void raise_ruby_fingerprint_error(PgQueryFingerprintResult result);
 void raise_ruby_scan_error(PgQueryScanResult result);
+void raise_ruby_split_error(PgQuerySplitResult result);
 
 VALUE pg_query_ruby_parse_protobuf(VALUE self, VALUE input);
 VALUE pg_query_ruby_deparse_protobuf(VALUE self, VALUE input);
+VALUE pg_query_ruby_deparse_protobuf_opts(VALUE self, VALUE input, VALUE pretty_print, VALUE comments, VALUE indent_size, VALUE max_line_length, VALUE trailing_newline, VALUE commas_start_of_line);
+VALUE pg_query_ruby_deparse_comments_for_query(VALUE self, VALUE input);
 VALUE pg_query_ruby_normalize(VALUE self, VALUE input);
 VALUE pg_query_ruby_fingerprint(VALUE self, VALUE input);
 VALUE pg_query_ruby_scan(VALUE self, VALUE input);
+VALUE pg_query_ruby_split_with_parser(VALUE self, VALUE input);
 VALUE pg_query_ruby_hash_xxh3_64(VALUE self, VALUE input, VALUE seed);
 
 __attribute__((visibility ("default"))) void Init_pg_query(void)
@@ -22,9 +27,12 @@ __attribute__((visibility ("default"))) void Init_pg_query(void)
 
 	rb_define_singleton_method(cPgQuery, "parse_protobuf", pg_query_ruby_parse_protobuf, 1);
 	rb_define_singleton_method(cPgQuery, "deparse_protobuf", pg_query_ruby_deparse_protobuf, 1);
+	rb_define_singleton_method(cPgQuery, "deparse_protobuf_opts", pg_query_ruby_deparse_protobuf_opts, 7);
+	rb_define_singleton_method(cPgQuery, "deparse_comments_for_query", pg_query_ruby_deparse_comments_for_query, 1);
 	rb_define_singleton_method(cPgQuery, "normalize", pg_query_ruby_normalize, 1);
 	rb_define_singleton_method(cPgQuery, "fingerprint", pg_query_ruby_fingerprint, 1);
 	rb_define_singleton_method(cPgQuery, "_raw_scan", pg_query_ruby_scan, 1);
+	rb_define_singleton_method(cPgQuery, "_raw_split_with_parser", pg_query_ruby_split_with_parser, 1);
 	rb_define_singleton_method(cPgQuery, "hash_xxh3_64", pg_query_ruby_hash_xxh3_64, 2);
 	rb_define_const(cPgQuery, "PG_VERSION", rb_str_new2(PG_VERSION));
 	rb_define_const(cPgQuery, "PG_MAJORVERSION", rb_str_new2(PG_MAJORVERSION));
@@ -67,6 +75,24 @@ void raise_ruby_deparse_error(PgQueryDeparseResult result)
 	rb_exc_raise(rb_class_new_instance(4, args, cParseError));
 }
 
+void raise_ruby_deparse_comments_error(PgQueryDeparseCommentsResult result)
+{
+	VALUE cPgQuery, cParseError;
+	VALUE args[4];
+
+	cPgQuery    = rb_const_get(rb_cObject, rb_intern("PgQuery"));
+	cParseError = rb_const_get_at(cPgQuery, rb_intern("ParseError"));
+
+	args[0] = rb_str_new2(result.error->message);
+	args[1] = rb_str_new2(result.error->filename);
+	args[2] = INT2NUM(result.error->lineno);
+	args[3] = INT2NUM(result.error->cursorpos);
+
+	pg_query_free_deparse_comments_result(result);
+
+	rb_exc_raise(rb_class_new_instance(4, args, cParseError));
+}
+
 void raise_ruby_normalize_error(PgQueryNormalizeResult result)
 {
 	VALUE cPgQuery, cParseError;
@@ -121,6 +147,24 @@ void raise_ruby_scan_error(PgQueryScanResult result)
 	rb_exc_raise(rb_class_new_instance(4, args, cScanError));
 }
 
+void raise_ruby_split_error(PgQuerySplitResult result)
+{
+	VALUE cPgQuery, cSplitError;
+	VALUE args[4];
+
+	cPgQuery   = rb_const_get(rb_cObject, rb_intern("PgQuery"));
+	cSplitError = rb_const_get_at(cPgQuery, rb_intern("SplitError"));
+
+	args[0] = rb_str_new2(result.error->message);
+	args[1] = rb_str_new2(result.error->filename);
+	args[2] = INT2NUM(result.error->lineno);
+	args[3] = INT2NUM(result.error->cursorpos);
+
+	pg_query_free_split_result(result);
+
+	rb_exc_raise(rb_class_new_instance(4, args, cSplitError));
+}
+
 VALUE pg_query_ruby_parse_protobuf(VALUE self, VALUE input)
 {
 	Check_Type(input, T_STRING);
@@ -161,6 +205,83 @@ VALUE pg_query_ruby_deparse_protobuf(VALUE self, VALUE input)
 	return output;
 }
 
+VALUE pg_query_ruby_deparse_protobuf_opts(VALUE self, VALUE input, VALUE pretty_print, VALUE comments, VALUE indent_size, VALUE max_line_length, VALUE trailing_newline, VALUE commas_start_of_line)
+{
+	Check_Type(input, T_STRING);
+	Check_Type(comments, T_ARRAY);
+	Check_Type(indent_size, T_FIXNUM);
+	Check_Type(max_line_length, T_FIXNUM);
+
+	VALUE output;
+	PgQueryProtobuf pbuf = {0};
+	PgQueryDeparseResult result = {0};
+	PostgresDeparseOpts deparse_opts = {0};
+	deparse_opts.pretty_print = RTEST(pretty_print);
+	deparse_opts.indent_size = NUM2INT(indent_size);
+	deparse_opts.max_line_length = NUM2INT(max_line_length);
+	deparse_opts.trailing_newline = RTEST(trailing_newline);
+	deparse_opts.commas_start_of_line = RTEST(commas_start_of_line);
+	deparse_opts.comments = malloc(RARRAY_LEN(comments) * sizeof(PostgresDeparseComment *));
+	deparse_opts.comment_count = RARRAY_LEN(comments);
+	VALUE *comments_arr = RARRAY_PTR(comments);
+
+	for (int i = 0; i < RARRAY_LEN(comments); i++)
+	{
+		PostgresDeparseComment* comment  = malloc(sizeof(PostgresDeparseComment));
+		VALUE str_ref                    = rb_ivar_get(comments_arr[i], rb_intern("@str"));
+		comment->match_location          = NUM2INT(rb_ivar_get(comments_arr[i], rb_intern("@match_location")));
+		comment->newlines_before_comment = NUM2INT(rb_ivar_get(comments_arr[i], rb_intern("@newlines_before_comment")));
+		comment->newlines_after_comment  = NUM2INT(rb_ivar_get(comments_arr[i], rb_intern("@newlines_after_comment")));
+		comment->str                     = StringValueCStr(str_ref);
+
+		deparse_opts.comments[i] = comment;
+	}
+
+	pbuf.data = StringValuePtr(input);
+	pbuf.len = RSTRING_LEN(input);
+	result = pg_query_deparse_protobuf_opts(pbuf, deparse_opts);
+
+	if (result.error) raise_ruby_deparse_error(result);
+
+	output = rb_str_new2(result.query);
+
+	pg_query_free_deparse_result(result);
+	for (int i = 0; i < deparse_opts.comment_count; i++)
+		free(deparse_opts.comments[i]);
+	free(deparse_opts.comments);
+
+	return output;
+}
+
+VALUE pg_query_ruby_deparse_comments_for_query(VALUE self, VALUE input)
+{
+	Check_Type(input, T_STRING);
+
+	VALUE cPgQuery, cDeparseComment;
+
+	cPgQuery        = rb_const_get(rb_cObject, rb_intern("PgQuery"));
+	cDeparseComment = rb_const_get_at(cPgQuery, rb_intern("DeparseComment"));
+
+	VALUE output = rb_ary_new();
+	PgQueryDeparseCommentsResult result = pg_query_deparse_comments_for_query(StringValueCStr(input));
+	if (result.error) raise_ruby_deparse_comments_error(result);
+
+	for (int i = 0; i < result.comment_count; i++)
+	{
+		PostgresDeparseComment* comment = result.comments[i];
+		VALUE c = rb_class_new_instance(0, NULL, cDeparseComment);
+		rb_ivar_set(c, rb_intern("@str"), rb_str_new2(comment->str));
+		rb_ivar_set(c, rb_intern("@match_location"), INT2NUM(comment->match_location));
+		rb_ivar_set(c, rb_intern("@newlines_before_comment"), INT2NUM(comment->newlines_before_comment));
+		rb_ivar_set(c, rb_intern("@newlines_after_comment"), INT2NUM(comment->newlines_after_comment));
+		rb_ary_push(output, c);
+	}
+
+	pg_query_free_deparse_comments_result(result);
+
+	return output;
+}
+
 VALUE pg_query_ruby_normalize(VALUE self, VALUE input)
 {
 	Check_Type(input, T_STRING);
@@ -216,6 +337,35 @@ VALUE pg_query_ruby_scan(VALUE self, VALUE input)
 	return output;
 }
 
+VALUE pg_query_ruby_split_with_parser(VALUE self, VALUE input)
+{
+	Check_Type(input, T_STRING);
+
+	VALUE output;
+	VALUE stmts;
+	PgQuerySplitResult result = pg_query_split_with_parser(StringValueCStr(input));
+
+	if (result.error) raise_ruby_split_error(result);
+
+	output = rb_ary_new();
+	stmts = rb_ary_new();
+
+	for (int i = 0; i < result.n_stmts; i++)
+	{
+		VALUE stmt = rb_ary_new();
+		rb_ary_push(stmt, INT2NUM(result.stmts[i]->stmt_location));
+		rb_ary_push(stmt, INT2NUM(result.stmts[i]->stmt_len));
+		rb_ary_push(stmts, stmt);
+	}
+
+	rb_ary_push(output, stmts);
+	rb_ary_push(output, rb_str_new2(result.stderr_buffer));
+
+	pg_query_free_split_result(result);
+
+	return output;
+}
+
 VALUE pg_query_ruby_hash_xxh3_64(VALUE self, VALUE input, VALUE seed)
 {
 	Check_Type(input, T_STRING);