pg_query 6.2.2 → 6.2.5

data/lib/pg_query/fingerprint.rb

@@ -93,6 +93,12 @@ module PgQuery
         case postgres_field_name
         when 'location'
           next
+        when 'arg_location'
+          next if node.is_a?(DefElem)
+        when 'payload_location'
+          next if node.is_a?(NotifyStmt)
+        when 'conninfo_location'
+          next if [CreateSubscriptionStmt, AlterSubscriptionStmt].include?(node.class)
         when 'name'
           next if [PrepareStmt, ExecuteStmt, DeallocateStmt, FunctionParameter].include?(node.class)
           next if node.is_a?(ResTarget) && parent_node_name == 'SelectStmt' && parent_field_name == 'targetList'

data/lib/pg_query/parse.rb

@@ -102,6 +102,7 @@ module PgQuery
       @cte_names = []
       @aliases = {}
       @functions = [] # types: call, ddl
+      @cte_self_reference_locations = []
 
       statements = @tree.stmts.dup.to_a.map(&:stmt)
       from_clause_items = [] # types: select, dml, ddl
@@ -122,6 +123,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
@@ -134,6 +136,7 @@ module PgQuery
             end
 
             if statement.select_stmt.with_clause
+              record_cte_self_references!(statement.select_stmt.with_clause)
               cte_statements, cte_names = statements_and_cte_names_for_with_clause(statement.select_stmt.with_clause)
               @cte_names.concat(cte_names)
               statements.concat(cte_statements)
@@ -164,7 +167,15 @@ 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
+              record_cte_self_references!(value.with_clause)
               cte_statements, cte_names = statements_and_cte_names_for_with_clause(value.with_clause)
               @cte_names.concat(cte_names)
               statements.concat(cte_statements)
@@ -294,10 +305,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 })
@@ -329,7 +350,7 @@ module PgQuery
             from_clause_items += next_item[:item].row_expr.args.map { |a| { item: a, type: next_item[:type] } }
           when :range_var
             rangevar = next_item[:item].range_var
-            next if rangevar.schemaname.empty? && @cte_names.include?(rangevar.relname)
+            next if cte_reference?(rangevar, next_item[:type])
 
             table = [rangevar.schemaname, rangevar.relname].reject { |s| s.nil? || s.empty? }.join('.')
             @tables << {
@@ -368,5 +389,78 @@ module PgQuery
 
       [statements, cte_names]
     end
+
+    # Determines whether a RangeVar refers to a CTE rather than to a relation.
+    #
+    # Only plain (SELECT-style) references can resolve to a CTE: a CTE is not a
+    # valid target for DML (INSERT/UPDATE/DELETE/COPY) or DDL, so those always
+    # name a real relation even when a CTE in the same statement shares the name.
+    def cte_reference?(rangevar, type)
+      return false unless type == :select
+      return false unless rangevar.schemaname.empty?
+      return false unless @cte_names.include?(rangevar.relname)
+
+      !@cte_self_reference_locations.include?(rangevar.location)
+    end
+
+    # A non-recursive CTE is not visible inside its own definition, so a
+    # reference to its own name there resolves to a real relation:
+    #
+    #   WITH users AS (SELECT * FROM users) SELECT * FROM users
+    #                              ^^^^^ the table          ^^^^^ the CTE
+    #
+    # Records the locations of those self-references so they are not mistaken
+    # for CTE references. Locations uniquely identify a RangeVar occurrence,
+    # which keeps the outer (genuine) CTE reference above excluded.
+    def record_cte_self_references!(with_clause)
+      return if with_clause.recursive
+
+      with_clause.ctes.each do |item|
+        next unless item.node == :common_table_expr
+
+        record_self_references_for_cte!(item.common_table_expr)
+      end
+    end
+
+    def record_self_references_for_cte!(cte)
+      return if cte.ctequery.nil?
+      return if @cte_names.include?(cte.ctename)
+
+      record_self_references_in(cte.ctequery, cte.ctename)
+    end
+
+    # Depth-first scan of a CTE definition for unqualified RangeVars matching
+    # the CTE's own name.
+    #
+    # This deliberately avoids #walk!, which yields every node and iterates all
+    # of PgQuery::Node's oneof fields. Following the oneof directly via #inner
+    # keeps this proportional to the nodes actually present.
+    def record_self_references_in(node, cte_name)
+      case node
+      when PgQuery::Node
+        record_self_references_in(node.inner, cte_name)
+      when PgQuery::RangeVar
+        @cte_self_reference_locations << node.location if cte_self_reference?(node, cte_name)
+      when Google::Protobuf::RepeatedField
+        node.each { |child| record_self_references_in(child, cte_name) }
+      when Google::Protobuf::MessageExts
+        record_self_references_in_message(node, cte_name)
+      end
+    end
+
+    def record_self_references_in_message(message, cte_name)
+      message.class.descriptor.each do |field_descriptor|
+        child = field_descriptor.get(message)
+        next unless child.is_a?(Google::Protobuf::MessageExts) || child.is_a?(Google::Protobuf::RepeatedField)
+
+        record_self_references_in(child, cte_name)
+      end
+    end
+
+    def cte_self_reference?(node, cte_name)
+      node.schemaname.empty? &&
+        node.relname == cte_name &&
+        !node.location.negative?
+    end
   end
 end