pg_query 2.2.0 → 6.1.0

data/lib/pg_query/node.rb

@@ -1,27 +1,32 @@
 module PgQuery
   # Patch the auto-generated generic node type with additional convenience functions
   class Node
+    def self.inner_class_to_name(klass)
+      @inner_class_to_name ||= descriptor.lookup_oneof('node').to_h { |f| [f.subtype.msgclass, f.name.to_sym] }
+      @inner_class_to_name[klass]
+    end
+
+    def inner
+      self[node.to_s]
+    end
+
+    def inner=(submsg)
+      name = self.class.inner_class_to_name(submsg.class)
+      public_send("#{name}=", submsg)
+    end
+
     def inspect
-      node ? format('<PgQuery::Node: %s: %s>', node, public_send(node).inspect) : '<PgQuery::Node>'
+      node ? format('<PgQuery::Node: %s: %s>', node, inner.inspect) : '<PgQuery::Node>'
     end
 
     # Make it easier to initialize nodes from a given node child object
     def self.from(node_field_val)
-      # This needs to match libpg_query naming for the Node message field names
-      # (see "underscore" method in libpg_query's scripts/generate_protobuf_and_funcs.rb)
-      node_field_name = node_field_val.class.name.split('::').last
-      node_field_name.gsub!(/^([A-Z\d])([A-Z][a-z])/, '\1__\2')
-      node_field_name.gsub!(/([A-Z\d]+[a-z]+)([A-Z][a-z])/, '\1_\2')
-      node_field_name.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
-      node_field_name.tr!('-', '_')
-      node_field_name.downcase!
-
-      PgQuery::Node.new(node_field_name => node_field_val)
+      PgQuery::Node.new(inner_class_to_name(node_field_val.class) => node_field_val)
     end
 
     # Make it easier to initialize value nodes
-    def self.from_string(str)
-      PgQuery::Node.new(string: PgQuery::String.new(str: str))
+    def self.from_string(sval)
+      PgQuery::Node.new(string: PgQuery::String.new(sval: sval))
     end
 
     def self.from_integer(ival)

data/lib/pg_query/param_refs.rb

@@ -3,11 +3,11 @@ module PgQuery
     def param_refs # rubocop:disable Metrics/CyclomaticComplexity
       results = []
 
-      treewalker! @tree do |_, _, node, location|
+      treewalker_with_location! @tree do |_, _, node, location|
         case node
         when PgQuery::ParamRef
           # Ignore param refs inside type casts, as these are already handled
-          next if location[-3..-1] == %i[type_cast arg param_ref]
+          next if location[-3..] == %i[type_cast arg param_ref]
 
           results << { 'location' => node.location,
                        'length' => param_ref_length(node) }
@@ -29,7 +29,7 @@ module PgQuery
             location = typeloc
           end
 
-          results << { 'location' => location, 'length' => length, 'typename' => t.names.map { |n| n.string.str } }
+          results << { 'location' => location, 'length' => length, 'typename' => t.names.map { |n| n.string.sval } }
         end
       end
 

data/lib/pg_query/parse.rb

@@ -24,9 +24,7 @@ module PgQuery
   end
 
   class ParserResult
-    attr_reader :query
-    attr_reader :tree
-    attr_reader :warnings
+    attr_reader :query, :tree, :warnings
 
     def initialize(query, tree, warnings = [])
       @query = query
@@ -139,9 +137,13 @@ module PgQuery
               @cte_names.concat(cte_names)
               statements.concat(cte_statements)
             end
+
+            if statement.select_stmt.into_clause
+              from_clause_items << { item: PgQuery::Node.new(range_var: statement.select_stmt.into_clause.rel), type: :ddl }
+            end
           # The following statements modify the contents of a table
           when :insert_stmt, :update_stmt, :delete_stmt
-            value = statement.public_send(statement.node)
+            value = statement.inner
             from_clause_items << { item: PgQuery::Node.new(range_var: value.relation), type: :dml }
             statements << value.select_stmt if statement.node == :insert_stmt && value.select_stmt
 
@@ -171,7 +173,12 @@ module PgQuery
             statements << statement.copy_stmt.query
           # The following statement types are DDL (changing table structure)
           when :alter_table_stmt
-            from_clause_items << { item: PgQuery::Node.new(range_var: statement.alter_table_stmt.relation), type: :ddl }
+            case statement.alter_table_stmt.objtype
+            when :OBJECT_INDEX # Index
+              # ignore `ALTER INDEX index_name`
+            else
+              from_clause_items << { item: PgQuery::Node.new(range_var: statement.alter_table_stmt.relation), type: :ddl }
+            end
           when :create_stmt
             from_clause_items << { item: PgQuery::Node.new(range_var: statement.create_stmt.relation), type: :ddl }
           when :create_table_as_stmt
@@ -203,9 +210,9 @@ module PgQuery
             objects = statement.drop_stmt.objects.map do |obj|
               case obj.node
               when :list
-                obj.list.items.map { |obj2| obj2.string.str if obj2.node == :string }
+                obj.list.items.map { |obj2| obj2.string.sval if obj2.node == :string }
               when :string
-                obj.string.str
+                obj.string.sval
               end
             end
             case statement.drop_stmt.remove_type
@@ -216,16 +223,16 @@ module PgQuery
             when :OBJECT_FUNCTION
               # Only one function can be dropped in a statement
               obj = statement.drop_stmt.objects[0].object_with_args
-              @functions << { function: obj.objname[0].string.str, type: :ddl }
+              @functions << { function: obj.objname.map { |f| f.string.sval }.join('.'), type: :ddl }
             end
           when :grant_stmt
             objects = statement.grant_stmt.objects
             case statement.grant_stmt.objtype
-            when :OBJECT_COLUMN # Column # rubocop:disable Lint/EmptyWhen
+            when :OBJECT_COLUMN # Column
               # FIXME
             when :OBJECT_TABLE # Table
               from_clause_items += objects.map { |o| { item: o, type: :ddl } }
-            when :OBJECT_SEQUENCE # Sequence # rubocop:disable Lint/EmptyWhen
+            when :OBJECT_SEQUENCE # Sequence
               # FIXME
             end
           when :lock_stmt
@@ -235,18 +242,20 @@ module PgQuery
             statements << statement.explain_stmt.query
           when :create_function_stmt
             @functions << {
-              function: statement.create_function_stmt.funcname[0].string.str,
+              function: statement.create_function_stmt.funcname.map { |f| f.string.sval }.join('.'),
               type: :ddl
             }
           when :rename_stmt
             if statement.rename_stmt.rename_type == :OBJECT_FUNCTION
-              original_name = statement.rename_stmt.object.object_with_args.objname[0].string.str
+              original_name = statement.rename_stmt.object.object_with_args.objname.map { |f| f.string.sval }.join('.')
               new_name = statement.rename_stmt.newname
               @functions += [
                 { function: original_name, type: :ddl },
                 { function: new_name, type: :ddl }
               ]
             end
+          when :prepare_stmt
+            statements << statement.prepare_stmt.query
           end
         end
 
@@ -278,7 +287,7 @@ module PgQuery
           when :func_call
             subselect_items.concat(next_item.func_call.args.to_ary)
             @functions << {
-              function: next_item.func_call.funcname.map { |f| f.string.str }.join('.'),
+              function: next_item.func_call.funcname.map { |f| f.string.sval }.join('.'),
               type: :call
             }
           when :case_expr
@@ -310,7 +319,8 @@ module PgQuery
               location: rangevar.location,
               schemaname: (rangevar.schemaname unless rangevar.schemaname.empty?),
               relname: rangevar.relname,
-              inh: rangevar.inh
+              inh: rangevar.inh,
+              relpersistence: rangevar.relpersistence
             }
             @aliases[rangevar.alias.aliasname] = table if rangevar.alias
           when :range_subselect
@@ -327,7 +337,7 @@ module PgQuery
       @cte_names.uniq!
     end
 
-    def statements_and_cte_names_for_with_clause(with_clause) # FIXME
+    def statements_and_cte_names_for_with_clause(with_clause)
       statements = []
       cte_names = []
 

data/lib/pg_query/parse_error.rb

@@ -1,6 +1,7 @@
 module PgQuery
   class ParseError < ArgumentError
     attr_reader :location
+
     def initialize(message, source_file, source_line, location)
       super("#{message} (#{source_file}:#{source_line})")
       @location = location