pg_query 6.2.2 → 6.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e8fa448f7374b9cf04148d3c8d07903804122e7482b27d3a5f455ceb47ae9491
-  data.tar.gz: 936a383a21778c3a129bbbba8d85e8ad98cd969bc4c67bd3fffba9961dec82d2
+  metadata.gz: c200160a0eb146a7f9fa38a6d9dd904e3ba617b82bb249af4677e8ea37279a91
+  data.tar.gz: 023c133937589b4edd3f3e156b11df6ad4d2940a661a21c3a1ab82574a853c80
 SHA512:
-  metadata.gz: 156ebc20e60459230fdf485aac768634501f507e825b1021756feaa509936c13e4161de1118988fc4006f0127458ab490b4468d4e5eadd9dfeaf4e52c161d3ad
-  data.tar.gz: 1489fc1aa532728b5720f1514addccf33c46330851fa20515b980f31947f3e08beb5e54b3045a774aa6e50aef65c12f5b2870333a31160878a30ffabf6c22023
+  metadata.gz: e4ccb4134993fabd3883cac1753e7da88fdab116e6e9915f58fc9d3ee659550f65d570e161d3c2033a4635c5898b5e89ee0c7039e92783bc423b7c7fc9e9523b
+  data.tar.gz: 2d143a73b0b1edf30f839e0804a2d010716a795312e26389aa17eee15cea94ed2c70c1b40210c3b092a014f68cbe633594db616c35db699b3a3119d17cea7303

data/CHANGELOG.md

@@ -4,6 +4,23 @@
 
 * ...
 
+## 6.2.3     2026-08-26
+
+* Upgrade to libpg_query 17-6.2.3 ([#350](https://github.com/pganalyze/pg_query/pull/350))
+  - Deparser:
+    - Preserve parentheses around subscripted array constructors
+      - This prevents `(ARRAY[...])[...]` from being deparsed as invalid SQL
+    - Fix handling of constraint key named `value` in `ALTER TABLE` [#329](https://github.com/pganalyze/libpg_query/pull/329)
+  - Preserve `ARFLAGS` when overriding `AR` [#328](https://github.com/pganalyze/libpg_query/pull/328)
+* Add `PgQuery.summary` method ([#349](https://github.com/pganalyze/pg_query/pull/349))
+  - This uses the new `pg_query_summary` C function that significantly improves performance when
+    you need metadata (like a list of referenced tables) but don't need the full parse tree.
+* Support finding tables inside function/aggregate clauses ([#348](https://github.com/pganalyze/pg_query/pull/348))
+* Add support for Ruby 4.0, drop Ruby 3.0 and 3.1 ([#354](https://github.com/pganalyze/pg_query/pull/354))
+  - Bump `google-protobuf` dependency to `>= 4.34.0`
+    - 4.34.0 or newer is required for Ruby 4.0 support
+
+
 ## 6.2.2     2026-01-26
 
 * Upgrade to libpg_query 17-6.2.2

data/README.md

@@ -115,6 +115,30 @@ PgQuery.parse("SELECT $1 FROM x WHERE x.y = $2 AND z = $3").filter_columns
 => [["x", "y"], [nil, "z"]]
 ```
 
+### Summarizing a query
+
+`PgQuery.summary` returns the same kind of information as `PgQuery.parse` (tables, functions,
+CTE names, aliases, filter columns and statement types), but gathers it inside the native C
+library instead of sending the full parse tree over protobuf, which is significantly faster
+for large queries.
+
+```ruby
+summary = PgQuery.summary("SELECT $1 FROM x JOIN y USING (id) WHERE z = $2")
+
+summary.tables
+=> ["x", "y"]
+
+summary.statement_types
+=> ["SelectStmt"]
+
+# Like PgQuery.parse(query).truncate(40), except the limit has to be passed in up front
+PgQuery.summary("SELECT a, b, c, d, e, f FROM xyz WHERE a = b", truncate_limit: 40).truncated_query
+
+=> "SELECT ... FROM xyz WHERE a = b"
+```
+
+See the comments on `PgQuery::SummaryParserResult` for how it differs from `PgQuery::ParserResult`.
+
 ### Fingerprinting a query
 
 ```ruby
@@ -178,11 +202,10 @@ not correctly handle all CTEs, or rewrite columns with explicit table names.
 
 Currently tested and officially supported Ruby versions:
 
-* CRuby 3.0
-* CRuby 3.1
 * CRuby 3.2
 * CRuby 3.3
 * CRuby 3.4
+* CRuby 4.0
 
 Not supported:
 

data/Rakefile

@@ -5,8 +5,8 @@ require 'rspec/core/rake_task'
 require 'rubocop/rake_task'
 require 'open-uri'
 
-LIB_PG_QUERY_TAG = '17-6.2.2'.freeze
-LIB_PG_QUERY_SHA256SUM = 'e68962c18dbf5890821511be6c5c42261170bf8bfd51a82ea9176069f3d0df8b'.freeze
+LIB_PG_QUERY_TAG = '17-6.2.3'.freeze
+LIB_PG_QUERY_SHA256SUM = '1049617789dd0bea1f6e59e15a6c4906e59045f2f5271836fdce68466efe8d87'.freeze
 
 Rake::ExtensionTask.new 'pg_query' do |ext|
   ext.lib_dir = 'lib/pg_query'

data/ext/pg_query/pg_query_ruby.c

@@ -8,6 +8,7 @@ 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);
+void raise_ruby_summary_error(PgQuerySummaryParseResult result);
 
 VALUE pg_query_ruby_parse_protobuf(VALUE self, VALUE input);
 VALUE pg_query_ruby_deparse_protobuf(VALUE self, VALUE input);
@@ -17,6 +18,7 @@ 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_summary(VALUE self, VALUE input, VALUE truncate_limit);
 VALUE pg_query_ruby_hash_xxh3_64(VALUE self, VALUE input, VALUE seed);
 
 __attribute__((visibility ("default"))) void Init_pg_query(void)
@@ -33,6 +35,7 @@ __attribute__((visibility ("default"))) void Init_pg_query(void)
 	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, "_raw_summary", pg_query_ruby_summary, 2);
 	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));
@@ -165,6 +168,24 @@ void raise_ruby_split_error(PgQuerySplitResult result)
 	rb_exc_raise(rb_class_new_instance(4, args, cSplitError));
 }
 
+void raise_ruby_summary_error(PgQuerySummaryParseResult 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_summary_parse_result(result);
+
+	rb_exc_raise(rb_class_new_instance(4, args, cParseError));
+}
+
 VALUE pg_query_ruby_parse_protobuf(VALUE self, VALUE input)
 {
 	Check_Type(input, T_STRING);
@@ -366,6 +387,26 @@ VALUE pg_query_ruby_split_with_parser(VALUE self, VALUE input)
 	return output;
 }
 
+VALUE pg_query_ruby_summary(VALUE self, VALUE input, VALUE truncate_limit)
+{
+	Check_Type(input, T_STRING);
+	Check_Type(truncate_limit, T_FIXNUM);
+
+	VALUE output;
+	PgQuerySummaryParseResult result = pg_query_summary(StringValueCStr(input), 0, NUM2INT(truncate_limit));
+
+	if (result.error) raise_ruby_summary_error(result);
+
+	output = rb_ary_new();
+
+	rb_ary_push(output, rb_str_new(result.summary.data, result.summary.len));
+	rb_ary_push(output, rb_str_new2(result.stderr_buffer));
+
+	pg_query_free_summary_parse_result(result);
+
+	return output;
+}
+
 VALUE pg_query_ruby_hash_xxh3_64(VALUE self, VALUE input, VALUE seed)
 {
 	Check_Type(input, T_STRING);

data/ext/pg_query/postgres_deparse.c

@@ -93,6 +93,7 @@ typedef enum DeparseNodeContext {
 	DEPARSE_NODE_CONTEXT_A_EXPR,
 	DEPARSE_NODE_CONTEXT_CREATE_TYPE,
 	DEPARSE_NODE_CONTEXT_ALTER_TYPE,
+	DEPARSE_NODE_CONTEXT_ALTER_DOMAIN,
 	DEPARSE_NODE_CONTEXT_SET_STATEMENT,
 	DEPARSE_NODE_CONTEXT_FUNC_EXPR,
 	DEPARSE_NODE_CONTEXT_SELECT_SETOP,
@@ -231,7 +232,7 @@ static void deparseJsonFuncExpr(DeparseState *state, JsonFuncExpr *json_func_exp
 static void deparseJsonQuotesClauseOpt(DeparseState *state, JsonQuotes quotes);
 static void deparseJsonOnErrorClauseOpt(DeparseState *state, JsonBehavior *behavior);
 static void deparseJsonOnEmptyClauseOpt(DeparseState *state, JsonBehavior *behavior);
-static void deparseConstraint(DeparseState *state, Constraint *constraint);
+static void deparseConstraint(DeparseState *state, Constraint *constraint, DeparseNodeContext context);
 static void deparseSchemaStmt(DeparseState *state, Node *node);
 static void deparseExecuteStmt(DeparseState *state, ExecuteStmt *execute_stmt);
 static void deparseTriggerTransition(DeparseState *state, TriggerTransition *trigger_transition);
@@ -4638,6 +4639,7 @@ static void deparseAIndirection(DeparseState *state, A_Indirection *a_indirectio
 		IsA(a_indirection->arg, A_Expr) ||
 		IsA(a_indirection->arg, TypeCast) ||
 		IsA(a_indirection->arg, RowExpr) ||
+		IsA(a_indirection->arg, A_ArrayExpr) ||
 		(IsA(a_indirection->arg, ColumnRef) && !IsA(linitial(a_indirection->indirection), A_Indices)) ||
 		IsA(a_indirection->arg, JsonFuncExpr);
 
@@ -4769,7 +4771,7 @@ static void deparseColumnDef(DeparseState *state, ColumnDef *column_def)
 
 	foreach(lc, column_def->constraints)
 	{
-		deparseConstraint(state, castNode(Constraint, lfirst(lc)));
+		deparseConstraint(state, castNode(Constraint, lfirst(lc)), DEPARSE_NODE_CONTEXT_NONE);
 		deparseAppendStringInfoChar(state, ' ');
 	}
 
@@ -5332,7 +5334,7 @@ static void deparseCreateDomainStmt(DeparseState *state, CreateDomainStmt *creat
 
 	foreach(lc, create_domain_stmt->constraints)
 	{
-		deparseConstraint(state, castNode(Constraint, lfirst(lc)));
+		deparseConstraint(state, castNode(Constraint, lfirst(lc)), DEPARSE_NODE_CONTEXT_NONE);
 		deparseAppendStringInfoChar(state, ' ');
 	}
 
@@ -5381,7 +5383,7 @@ static void deparseCreateExtensionStmt(DeparseState *state, CreateExtensionStmt
 }
 
 // "ColConstraintElem" and "ConstraintElem" in gram.y
-static void deparseConstraint(DeparseState *state, Constraint *constraint)
+static void deparseConstraint(DeparseState *state, Constraint *constraint, DeparseNodeContext context)
 {
 	ListCell *lc;
 
@@ -5487,7 +5489,7 @@ static void deparseConstraint(DeparseState *state, Constraint *constraint)
 	{
 		bool valueOnly = false;
 
-		if (list_length(constraint->keys) == 1) {
+		if (context == DEPARSE_NODE_CONTEXT_ALTER_DOMAIN && list_length(constraint->keys) == 1) {
 			Node* firstKey = constraint->keys->elements[0].ptr_value;
 			valueOnly = IsA(firstKey, String) && !strcmp("value", ((String*)firstKey)->sval);
 		}
@@ -5997,7 +5999,7 @@ static void deparseTableElement(DeparseState *state, Node *node)
 			deparseTableLikeClause(state, castNode(TableLikeClause, node));
 			break;
 		case T_Constraint:
-			deparseConstraint(state, castNode(Constraint, node));
+			deparseConstraint(state, castNode(Constraint, node), DEPARSE_NODE_CONTEXT_NONE);
 			break;
 		default:
 			Assert(false);
@@ -7286,7 +7288,7 @@ static void deparseAlterTableCmd(DeparseState *state, AlterTableCmd *alter_table
 		case AT_AddIdentity:
 		case AT_AddConstraint:
 		case AT_AlterConstraint:
-			deparseConstraint(state, castNode(Constraint, alter_table_cmd->def));
+			deparseConstraint(state, castNode(Constraint, alter_table_cmd->def), DEPARSE_NODE_CONTEXT_NONE);
 			deparseAppendStringInfoChar(state, ' ');
 			break;
 		case AT_SetIdentity:
@@ -7452,7 +7454,7 @@ static void deparseAlterDomainStmt(DeparseState *state, AlterDomainStmt *alter_d
 			break;
 		case 'C':
 			deparseAppendStringInfoString(state, "ADD ");
-			deparseConstraint(state, castNode(Constraint, alter_domain_stmt->def));
+			deparseConstraint(state, castNode(Constraint, alter_domain_stmt->def), DEPARSE_NODE_CONTEXT_ALTER_DOMAIN);
 			break;
 		case 'X':
 			deparseAppendStringInfoString(state, "DROP CONSTRAINT ");

data/lib/pg_query/parse.rb

@@ -122,6 +122,7 @@ module PgQuery
             subselect_items.concat(statement.select_stmt.sort_clause.collect { |h| h.sort_by.node })
             subselect_items.concat(statement.select_stmt.group_clause.to_ary)
             subselect_items << statement.select_stmt.having_clause if statement.select_stmt.having_clause
+            subselect_items.concat(statement.select_stmt.values_lists.to_ary)
 
             case statement.select_stmt.op
             when :SETOP_NONE
@@ -164,6 +165,13 @@ module PgQuery
               end
             end
 
+            subselect_items.concat(value.returning_list.to_ary)
+
+            if statement.node == :insert_stmt && value.on_conflict_clause
+              subselect_items.concat(value.on_conflict_clause.target_list.to_ary)
+              subselect_items << value.on_conflict_clause.where_clause if value.on_conflict_clause.where_clause
+            end
+
             if value.with_clause
               cte_statements, cte_names = statements_and_cte_names_for_with_clause(value.with_clause)
               @cte_names.concat(cte_names)
@@ -294,10 +302,20 @@ module PgQuery
           when :func_call
             # See also CALL below
             subselect_items.concat(next_item.func_call.args.to_ary)
+            subselect_items.concat(next_item.func_call.agg_order.to_ary)
+            subselect_items << next_item.func_call.agg_filter if next_item.func_call.agg_filter
+            subselect_items << PgQuery::Node.new(window_def: next_item.func_call.over) if next_item.func_call.over
             @functions << {
               function: next_item.func_call.funcname.map { |f| f.string.sval }.join('.'),
               type: :call
             }
+          when :sort_by
+            subselect_items << next_item.sort_by.node
+          when :window_def
+            subselect_items.concat(next_item.window_def.partition_clause.to_ary)
+            subselect_items.concat(next_item.window_def.order_clause.to_ary)
+            subselect_items << next_item.window_def.start_offset if next_item.window_def.start_offset
+            subselect_items << next_item.window_def.end_offset if next_item.window_def.end_offset
           when :case_expr
             subselect_items.concat(next_item.case_expr.args.map { |arg| arg.case_when.expr })
             subselect_items.concat(next_item.case_expr.args.map { |arg| arg.case_when.result })

data/lib/pg_query/summary.rb

@@ -0,0 +1,145 @@
+module PgQuery
+  # Parses the given SQL statement and returns a summary of it.
+  #
+  # It is possible to gather the same information using PgQuery.parse and
+  # walking the parse tree, but summary does this work in C, and only sends
+  # the summarized information over protobuf. Avoiding sending the full parse
+  # tree over protobuf can be significantly faster for large queries.
+  #
+  # Note that truncation happens on the C side, and so the maximum length has
+  # to be passed in ahead of time. summary(query, truncate_limit: 100).truncated_query
+  # is the equivalent of parse(query).truncate(100).
+  def self.summary(query, truncate_limit: -1)
+    result, stderr = _raw_summary(query, truncate_limit)
+
+    begin
+      result = PgQuery::SummaryResult.decode(result)
+    rescue Google::Protobuf::ParseError => e
+      raise PgQuery::ParseError.new(format('Failed to parse summary: %s', e.message), __FILE__, __LINE__, -1)
+    end
+
+    warnings = []
+    stderr.each_line do |line|
+      next unless line[/^WARNING/]
+      warnings << line.strip
+    end
+
+    PgQuery::SummaryParserResult.new(query, result, warnings, truncate_limit)
+  end
+
+  # Result of PgQuery.summary.
+  #
+  # Where possible this is API compatible with ParserResult, with these caveats:
+  #
+  # - tables_with_details omits the location, inh and relpersistence values that
+  #   ParserResult reports, since the summary does not carry them
+  # - filter_columns only covers the WHERE clause of SELECT statements, so unlike
+  #   ParserResult#filter_columns it does not include JOIN conditions, or the WHERE
+  #   clause of UPDATE/DELETE statements
+  # - functions_with_details additionally returns the schema name and the bare
+  #   function name, which ParserResult does not provide
+  # - statement_types has no ParserResult equivalent, returns the statement types of
+  #   the query, e.g. ["SelectStmt"]
+  # - truncated_query is offered instead of ParserResult#truncate(max_length), since
+  #   truncation has already happened when the result is returned - it returns nil if
+  #   no truncate_limit was passed to PgQuery.summary
+  #
+  # The underlying protobuf message is available through #protobuf.
+  class SummaryParserResult
+    attr_reader :query, :protobuf, :warnings
+
+    def initialize(query, protobuf, warnings = [], truncate_limit = -1)
+      @query = query
+      @protobuf = protobuf
+      @warnings = warnings
+      @truncate_limit = truncate_limit
+    end
+
+    def tables
+      tables_with_details.map { |t| t[:name] }.uniq
+    end
+
+    def select_tables
+      tables_with_details.select { |t| t[:type] == :select }.map { |t| t[:name] }.uniq
+    end
+
+    def dml_tables
+      tables_with_details.select { |t| t[:type] == :dml }.map { |t| t[:name] }.uniq
+    end
+
+    def ddl_tables
+      tables_with_details.select { |t| t[:type] == :ddl }.map { |t| t[:name] }.uniq
+    end
+
+    def functions
+      functions_with_details.map { |f| f[:function] }.uniq
+    end
+
+    def ddl_functions
+      functions_with_details.select { |f| f[:type] == :ddl }.map { |f| f[:function] }.uniq
+    end
+
+    def call_functions
+      functions_with_details.select { |f| f[:type] == :call }.map { |f| f[:function] }.uniq
+    end
+
+    def cte_names
+      @cte_names ||= @protobuf.cte_names.to_a.uniq
+    end
+
+    def aliases
+      @aliases ||= @protobuf.aliases.to_h
+    end
+
+    def tables_with_details
+      @tables_with_details ||= @protobuf.tables.map do |table|
+        {
+          name: table.name,
+          type: context_to_type(table.context),
+          schemaname: (table.schema_name unless table.schema_name.empty?),
+          relname: table.table_name
+        }
+      end.uniq
+    end
+
+    def functions_with_details
+      @functions_with_details ||= @protobuf.functions.map do |function|
+        {
+          function: function.name,
+          type: context_to_type(function.context),
+          schemaname: (function.schema_name unless function.schema_name.empty?),
+          funcname: function.function_name
+        }
+      end.uniq
+    end
+
+    def filter_columns
+      @filter_columns ||= @protobuf.filter_columns.map do |filter_column|
+        table = [filter_column.schema_name, filter_column.table_name].reject(&:empty?).join('.')
+        table = nil if table.empty?
+        [aliases[table] || table, filter_column.column]
+      end.uniq
+    end
+
+    def statement_types
+      @statement_types ||= @protobuf.statement_types.to_a
+    end
+
+    def truncated_query
+      @protobuf.truncated_query unless @truncate_limit == -1
+    end
+
+    private
+
+    CONTEXT_TYPES = {
+      Select: :select,
+      DML: :dml,
+      DDL: :ddl,
+      Call: :call
+    }.freeze
+
+    def context_to_type(context)
+      CONTEXT_TYPES[context]
+    end
+  end
+end

data/lib/pg_query/version.rb

@@ -1,3 +1,3 @@
 module PgQuery
-  VERSION = '6.2.2'.freeze
+  VERSION = '6.2.3'.freeze
 end

data/lib/pg_query.rb

@@ -17,3 +17,4 @@ require 'pg_query/truncate'
 
 require 'pg_query/scan'
 require 'pg_query/split'
+require 'pg_query/summary'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pg_query
 version: !ruby/object:Gem::Version
-  version: 6.2.2
+  version: 6.2.3
 platform: ruby
 authors:
 - Lukas Fittl
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-01-27 00:00:00.000000000 Z
+date: 2026-09-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: google-protobuf
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.25.3
+        version: 4.34.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.25.3
+        version: 4.34.0
 description: Parses SQL queries using a copy of the PostgreSQL server query parser
 email: lukas@fittl.com
 executables: []
@@ -576,6 +576,7 @@ files:
 - lib/pg_query/pg_query_pb.rb
 - lib/pg_query/scan.rb
 - lib/pg_query/split.rb
+- lib/pg_query/summary.rb
 - lib/pg_query/treewalker.rb
 - lib/pg_query/truncate.rb
 - lib/pg_query/version.rb
@@ -596,7 +597,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.0'
+      version: '3.2'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="