pg_query 1.2.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7e8912d6c8962c7e999e1a14d4258f0553cdf6e538e20e6374cb4b362118ec84
-  data.tar.gz: e27779fc7d4e15c76d8a38195541240c2b48508d2d07fe17eef715ac00e91a06
+  metadata.gz: f3d7de9759711a5e173db293a6120a15ee6ab1f0f4c5804e7f68aaba99ec8ff8
+  data.tar.gz: 974e3fb0b709021a771803e52de2a8ca19309a679d81c1ee2a3deb105f297769
 SHA512:
-  metadata.gz: 8eaa86d4571c15b3ea496bf5f85a4e2b1c69f5b1c2f2ad179862d020ca00d6fac160f0a1296707d0bee802f5b0e7cf29b466deb4c04927ec6e6987e31d2347f7
-  data.tar.gz: d766dc39d5b3ec3ee9fe1809ece77ca8a83c78290e4d72893e86cff37e4d47eac18b2dc18437807e2f5b4a4c50ccfe518831a9dae9e7bdd7cfd778eed86c9415
+  metadata.gz: 3c13b36c353e6de6aaaba2b6428be7e21c933bf8ef159212cdd64ee4a765f8a664defe735f2f3e94ef6441f3403d7be6fbf19ca4d6b98e07a6b42a68a635238a
+  data.tar.gz: cc742d80bdf934c89e1faa1dd6e6560764339ecabb6fe2af67fd219b2a71b4fb6756e649ddc237d995413a90c6b036d33fe8492eb91030d8a891f970ca10510a

data/CHANGELOG.md

@@ -1,5 +1,32 @@
 # Changelog
 
+## 1.3.0     2020-12-28
+
+* Incorporate newer libpg_query updates in 10-1.0.3 and 10-1.0.4
+  * Adds support for running on ARM
+  * Fixes asprintf warning during builds
+  * Updates to newer Postgres 10 patch release (10.15)
+* Deparsing improvements by [@emin100](https://github.com/emin100)
+  * Add support for additional DROP statements (#147)
+  * Fix CREATE TABLE AS - Support without TEMP, Add ON COMMIT (#149)
+  * Empty target list support (#156)
+  * UNION parentheses (#158)
+  * OVERLAY keyword function (#161)
+  * Array indirection (#162)
+  * ARRAY functions (#163)
+  * Correctly handle column names that need escaping in INSERT and UPDATE statements (#164)
+  * INSERT INTO ON CONFLICT (#166)
+  * LATERAL JOIN (#168)
+  * UPDATE FROM clause (#170)
+  * SELECT aggregate FILTER (#175)
+  * INTERSECT operator (#176)
+* Deparsing: Improve handling of boolean type casts [@himanshu-pro](https://github.com/himanshu-pro) & [@emin100](https://github.com/emin100)
+* `tables` method: Find tables in the subquery of CREATE TABLE AS (#172) [@Tassosb](https://github.com/Tassosb)
+* Support Ruby 3.0, verify SHA256 checksum of downloaded libpg_query (#178) [@stanhu](https://github.com/stanhu)
+  * Verify SHA256 checksum to guard against any malicious attempts to change the archive
+  * Use `URI.open` to fix Ruby 3.0 support
+
+
 ## 1.2.0     2019-11-10
 
 * Reduce escaped keywords to Postgres-specific keywords, and ignore unreserved keywords
@@ -8,6 +35,7 @@
   * Note that this will lead to different output than in earlier pg_query versions,
     in some cases
 
+
 ## 1.1.1     2019-11-10
 
 * Deparsing improvements by [@emin100](https://github.com/emin100)

data/README.md

@@ -151,11 +151,15 @@ to support parsing normalized queries containing `?` replacement characters.
 
 Currently tested and officially supported Ruby versions:
 
-* MRI 2.1
-* MRI 2.2
-* MRI 2.3
-* MRI 2.4
+* CRuby 2.5
+* CRuby 2.6
+* CRuby 2.7
+* CRuby 3.0
 
+Not supported:
+
+* JRuby: `pg_query` relies on a C extension, which is discouraged / not properly supported for JRuby
+* TruffleRuby: GraalVM [does not support sigjmp](https://www.graalvm.org/reference-manual/llvm/NativeExecution/), which is used by the Postgres error handling code (`pg_query` uses a copy of the Postgres parser & error handling code)
 
 ## Resources
 

data/ext/pg_query/extconf.rb

@@ -1,30 +1,39 @@
 # rubocop:disable Style/GlobalVars
 
+require 'digest'
 require 'mkmf'
 require 'open-uri'
 
-LIB_PG_QUERY_TAG = '10-1.0.1'.freeze
+LIB_PG_QUERY_TAG = '10-1.0.4'.freeze
+LIB_PG_QUERY_SHA256SUM = '88cc90296e5fcaaebd0b360c46698b7c5badddf86f120e249ef682a820d41338'.freeze
 
 workdir = Dir.pwd
 libdir = File.join(workdir, 'libpg_query-' + LIB_PG_QUERY_TAG)
 gemdir = File.join(__dir__, '../..')
 libfile = libdir + '/libpg_query.a'
+filename = File.join(workdir, 'libpg_query-' + LIB_PG_QUERY_TAG + '.tar.gz')
 
-unless File.exist?("#{workdir}/libpg_query.tar.gz")
-  File.open("#{workdir}/libpg_query.tar.gz", 'wb') do |target_file|
-    open('https://codeload.github.com/lfittl/libpg_query/tar.gz/' + LIB_PG_QUERY_TAG, 'rb') do |read_file|
+unless File.exist?(filename)
+  File.open(filename, 'wb') do |target_file|
+    URI.open('https://codeload.github.com/lfittl/libpg_query/tar.gz/' + LIB_PG_QUERY_TAG, 'rb') do |read_file|
       target_file.write(read_file.read)
     end
   end
+
+  checksum = Digest::SHA256.hexdigest(File.read(filename))
+
+  if checksum != LIB_PG_QUERY_SHA256SUM
+    raise "SHA256 of #{filename} does not match: got #{checksum}, expected #{expected_sha256}"
+  end
 end
 
 unless Dir.exist?(libdir)
-  system("tar -xzf #{workdir}/libpg_query.tar.gz") || raise('ERROR')
+  system("tar -xzf #{filename}") || raise('ERROR')
 end
 
 unless Dir.exist?(libfile)
   # Build libpg_query (and parts of PostgreSQL)
-  system("cd #{libdir}; #{ENV['MAKE'] || (RUBY_PLATFORM =~ /bsd/ ? 'gmake' : 'make')} build")
+  system(format("cd %s; %s build", libdir, ENV['MAKE'] || (RUBY_PLATFORM =~ /bsd/ ? 'gmake' : 'make')))
 end
 
 # Copy test files (this intentionally overwrites existing files!)

data/lib/pg_query/deparse.rb

@@ -92,7 +92,7 @@ class PgQuery
       when COLUMN_DEF
         deparse_columndef(node)
       when COLUMN_REF
-        deparse_columnref(node)
+        deparse_columnref(node, context)
       when COMMON_TABLE_EXPR
         deparse_cte(node)
       when COMPOSITE_TYPE_STMT
@@ -127,8 +127,14 @@ class PgQuery
         deparse_delete_from(node)
       when DISCARD_STMT
         deparse_discard(node)
+      when DROP_ROLE
+        deparse_drop_role(node)
       when DROP_STMT
         deparse_drop(node)
+      when DROP_SUBSCRIPTION
+        deparse_drop_subscription(node)
+      when DROP_TABLESPACE
+        deparse_drop_tablespace(node)
       when EXPLAIN_STMT
         deparse_explain(node)
       when EXECUTE_STMT
@@ -210,6 +216,8 @@ class PgQuery
           format("'%s'", node['str'].gsub("'", "''"))
         elsif [FUNC_CALL, TYPE_NAME, :operator, :defname_as].include?(context)
           node['str']
+        elsif context == :excluded
+          node['str'].casecmp('EXCLUDED').zero? ? node['str'].upcase : deparse_identifier(node['str'], escape_always: true)
         else
           deparse_identifier(node['str'], escape_always: true)
         end
@@ -279,9 +287,9 @@ class PgQuery
       output.join(' ')
     end
 
-    def deparse_columnref(node)
+    def deparse_columnref(node, context = false)
       node['fields'].map do |field|
-        field.is_a?(String) ? '"' + field + '"' : deparse_item(field)
+        field.is_a?(String) ? '"' + field + '"' : deparse_item(field, context)
       end.join('.')
     end
 
@@ -302,7 +310,11 @@ class PgQuery
     def deparse_a_indirection(node)
       output = []
       arg = deparse_item(node['arg'])
-      output << if node['arg'].key?(FUNC_CALL) || node['arg'].key?(SUB_LINK)
+      array_indirection = []
+      if node['indirection']
+        array_indirection = node['indirection'].select { |a| a.key?(A_INDICES) }
+      end
+      output << if node['arg'].key?(FUNC_CALL) || node['arg'].key?(A_EXPR) || (node['arg'].key?(SUB_LINK) && array_indirection.count.zero?)
                   "(#{arg})."
                 else
                   arg
@@ -358,7 +370,7 @@ class PgQuery
 
     def deparse_object_with_args(node)
       output = []
-      output += node['objname'].map(&method(:deparse_item))
+      output << deparse_item_list(node['objname']).join('.')
       unless node['args_unspecified']
         args = node.fetch('objargs', []).map(&method(:deparse_item)).join(', ')
         output << "(#{args})"
@@ -387,7 +399,9 @@ class PgQuery
       if context == :select
         [deparse_item(node['val']), deparse_identifier(node['name'])].compact.join(' AS ')
       elsif context == :update
-        [node['name'], deparse_item(node['val'])].compact.join(' = ')
+        [deparse_identifier(node['name']), deparse_item(node['val'])].compact.join(' = ')
+      elsif context == :excluded
+        [deparse_identifier(node['name'], escape_always: true), deparse_item(node['val'], context)].compact.join(' = ')
       elsif node['val'].nil?
         node['name']
       else
@@ -403,10 +417,17 @@ class PgQuery
       # COUNT(*)
       args << '*' if node['agg_star']
 
-      name = (node['funcname'].map { |n| deparse_item(n, FUNC_CALL) } - ['pg_catalog']).join('.')
-      distinct = node['agg_distinct'] ? 'DISTINCT ' : ''
-      output << format('%s(%s%s)', name, distinct, args.join(', '))
-      output << format('OVER %s', deparse_item(node['over'])) if node['over']
+      name = (node['funcname'].map { |n| deparse_item(n, FUNC_CALL) }).join('.')
+      if name == 'pg_catalog.overlay'
+        # Note that this is a bit odd, but "OVERLAY" is a keyword on its own merit, and only accepts the
+        # keyword parameter style when its called as a keyword, not as a regular function (i.e. pg_catalog.overlay)
+        output << format('OVERLAY(%s PLACING %s FROM %s FOR %s)', args[0], args[1], args[2], args[3])
+      else
+        distinct = node['agg_distinct'] ? 'DISTINCT ' : ''
+        output << format('%s(%s%s)', name, distinct, args.join(', '))
+        output << format('FILTER (WHERE %s)', deparse_item(node['agg_filter'])) if node['agg_filter']
+        output << format('OVER %s', deparse_item(node['over'])) if node['over']
+      end
 
       output.join(' ')
     end
@@ -987,8 +1008,22 @@ class PgQuery
 
     def deparse_create_table_as(node)
       output = []
-      output << 'CREATE TEMPORARY TABLE'
+      output << 'CREATE'
+
+      into = node['into']['IntoClause']
+      persistence = relpersistence(into['rel'])
+      output << persistence if persistence
+
+      output << 'TABLE'
+
       output << deparse_item(node['into'])
+
+      if into['onCommit'] > 0
+        output << 'ON COMMIT'
+        output << 'DELETE ROWS' if into['onCommit'] == 2
+        output << 'DROP' if into['onCommit'] == 3
+      end
+
       output << 'AS'
       output << deparse_item(node['query'])
       output.join(' ')
@@ -1020,13 +1055,17 @@ class PgQuery
         format('%s %s ALL (%s)', deparse_item(node['testexpr']), deparse_item(node['operName'][0], :operator), deparse_item(node['subselect']))
       elsif node['subLinkType'] == SUBLINK_TYPE_EXISTS
         format('EXISTS(%s)', deparse_item(node['subselect']))
+      elsif node['subLinkType'] == SUBLINK_TYPE_ARRAY
+        format('ARRAY(%s)', deparse_item(node['subselect']))
       else
         format('(%s)', deparse_item(node['subselect']))
       end
     end
 
     def deparse_rangesubselect(node)
-      output = '(' + deparse_item(node['subquery']) + ')'
+      output = ''
+      output = 'LATERAL ' if node['lateral']
+      output = output + '(' + deparse_item(node['subquery']) + ')'
       if node['alias']
         output + ' ' + deparse_item(node['alias'])
       else
@@ -1044,10 +1083,14 @@ class PgQuery
       output << deparse_item(node['withClause']) if node['withClause']
 
       if node['op'] == 1
+        output << '(' if node['larg']['SelectStmt']['sortClause']
         output << deparse_item(node['larg'])
+        output << ')' if node['larg']['SelectStmt']['sortClause']
         output << 'UNION'
         output << 'ALL' if node['all']
+        output << '(' if node['rarg']['SelectStmt']['sortClause']
         output << deparse_item(node['rarg'])
+        output << ')' if node['rarg']['SelectStmt']['sortClause']
         output.join(' ')
       end
 
@@ -1058,8 +1101,16 @@ class PgQuery
         output.join(' ')
       end
 
+      if node['op'] == 2
+        output << deparse_item(node['larg'])
+        output << 'INTERSECT'
+        output << deparse_item(node['rarg'])
+        output.join(' ')
+      end
+
+      output << 'SELECT' if node[FROM_CLAUSE_FIELD] || node[TARGET_LIST_FIELD]
+
       if node[TARGET_LIST_FIELD]
-        output << 'SELECT'
         if node['distinctClause']
           output << 'DISTINCT'
           unless node['distinctClause'].compact.empty?
@@ -1167,12 +1218,16 @@ class PgQuery
 
       if node['cols']
         output << '(' + node['cols'].map do |column|
-          deparse_item(column)
+          deparse_item(column, :select)
         end.join(', ') + ')'
       end
 
       output << deparse_item(node['selectStmt'])
 
+      if node['onConflictClause']
+        output << deparse_insert_onconflict(node['onConflictClause'][ON_CONFLICT_CLAUSE])
+      end
+
       if node['returningList']
         output << 'RETURNING'
         output << node['returningList'].map do |column|
@@ -1183,6 +1238,40 @@ class PgQuery
       output.join(' ')
     end
 
+    def deparse_insert_onconflict(node) # rubocop:disable Metrics/CyclomaticComplexity
+      output = []
+      output << 'ON CONFLICT'
+
+      infer = node['infer']['InferClause']
+      if infer['indexElems']
+        output << '(' + infer['indexElems'].map do |column|
+          '"' + column['IndexElem']['name'] + '"'
+        end.join(', ') + ')'
+      end
+
+      if infer['conname']
+        output << 'ON CONSTRAINT'
+        output << deparse_identifier(infer['conname'], escape_always: true)
+      end
+
+      output << 'DO UPDATE' if node['action'] == 2
+
+      if node[TARGET_LIST_FIELD]
+        output << 'SET ' + node[TARGET_LIST_FIELD].map do |column|
+          deparse_item(column, :excluded)
+        end.join(', ')
+      end
+
+      if infer['whereClause']
+        output << 'WHERE'
+        output << deparse_item(infer['whereClause'])
+      end
+
+      output << 'DO NOTHING' if node['action'] == 1
+
+      output.join(' ')
+    end
+
     def deparse_update(node)
       output = []
       output << deparse_item(node['withClause']) if node['withClause']
@@ -1198,6 +1287,13 @@ class PgQuery
         output << columns.join(', ')
       end
 
+      if node[FROM_CLAUSE_FIELD]
+        output << 'FROM'
+        output << node[FROM_CLAUSE_FIELD].map do |item|
+          deparse_item(item)
+        end.join(', ')
+      end
+
       if node['whereClause']
         output << 'WHERE'
         output << deparse_item(node['whereClause'])
@@ -1214,13 +1310,34 @@ class PgQuery
       output.join(' ')
     end
 
+    # Builds a properly-qualified reference to a built-in Postgres type.
+    #
+    # Inspired by SystemTypeName in Postgres' gram.y, but without node name
+    # and locations, to simplify comparison.
+    def make_system_type_name(name)
+      {
+        'names' => [
+          { 'String' => { 'str' => 'pg_catalog' } },
+          { 'String' => { 'str' => name } }
+        ],
+        'typemod' => -1
+      }
+    end
+
+    def make_string(str)
+      { 'String' => { 'str' => str } }
+    end
+
     def deparse_typecast(node)
-      if deparse_item(node['typeName']) == 'boolean'
-        deparse_item(node['arg']) == "'t'" ? 'true' : 'false'
-      else
-        context = true if node['arg']['A_Expr']
-        deparse_item(node['arg'], context) + '::' + deparse_typename(node['typeName'][TYPE_NAME])
+      # Handle "bool" or "false" in the statement, which is represented as a typecast
+      # (other boolean casts should be represented as a cast, i.e. don't need special handling)
+      if node['arg'][A_CONST] && node['typeName'][TYPE_NAME].slice('names', 'typemod') == make_system_type_name('bool')
+        return 'true' if node['arg'][A_CONST]['val'] == make_string('t')
+        return 'false' if node['arg'][A_CONST]['val'] == make_string('f')
       end
+
+      context = true if node['arg']['A_Expr']
+      deparse_item(node['arg'], context) + '::' + deparse_typename(node['typeName'][TYPE_NAME])
     end
 
     def deparse_typename(node)
@@ -1446,20 +1563,98 @@ class PgQuery
 
     def deparse_drop(node) # rubocop:disable Metrics/CyclomaticComplexity
       output = ['DROP']
-      output << 'TABLE' if node['removeType'] == OBJECT_TYPE_TABLE
+
+      output << 'ACCESS METHOD' if node['removeType'] == OBJECT_TYPE_ACCESS_METHOD
+      output << 'AGGREGATE' if node['removeType'] == OBJECT_TYPE_AGGREGATE
+      output << 'CAST' if node['removeType'] == OBJECT_TYPE_CAST
+      output << 'COLLATION' if node['removeType'] == OBJECT_TYPE_COLLATION
+      output << 'DOMAIN' if node['removeType'] == OBJECT_TYPE_DOMAIN
+      output << 'CONVERSION' if node['removeType'] == OBJECT_TYPE_CONVERSION
+      output << 'EVENT TRIGGER' if node['removeType'] == OBJECT_TYPE_EVENT_TRIGGER
+      output << 'EXTENSION' if node['removeType'] == OBJECT_TYPE_EXTENSION
+      output << 'FOREIGN DATA WRAPPER' if node['removeType'] == OBJECT_TYPE_FDW
+      output << 'FOREIGN TABLE' if node['removeType'] == OBJECT_TYPE_FOREIGN_TABLE
+      output << 'FUNCTION' if node['removeType'] == OBJECT_TYPE_FUNCTION
+      output << 'INDEX' if node['removeType'] == OBJECT_TYPE_INDEX
+      output << 'MATERIALIZED VIEW' if node['removeType'] == OBJECT_TYPE_MATVIEW
+      output << 'OPERATOR CLASS' if node['removeType'] == OBJECT_TYPE_OPCLASS
+      output << 'OPERATOR FAMILY' if node['removeType'] == OBJECT_TYPE_OPFAMILY
+      output << 'POLICY' if node['removeType'] == OBJECT_TYPE_POLICY
+      output << 'PUBLICATION' if node['removeType'] == OBJECT_TYPE_PUBLICATION
+      output << 'RULE' if node['removeType'] == OBJECT_TYPE_RULE
       output << 'SCHEMA' if node['removeType'] == OBJECT_TYPE_SCHEMA
+      output << 'SERVER' if node['removeType'] == OBJECT_TYPE_FOREIGN_SERVER
+      output << 'SEQUENCE' if node['removeType'] == OBJECT_TYPE_SEQUENCE
+      output << 'STATISTICS' if node['removeType'] == OBJECT_TYPE_STATISTIC_EXT
+      output << 'TABLE' if node['removeType'] == OBJECT_TYPE_TABLE
+      output << 'TRANSFORM' if node['removeType'] == OBJECT_TYPE_TRANSFORM
+      output << 'TRIGGER' if node['removeType'] == OBJECT_TYPE_TRIGGER
+      output << 'TEXT SEARCH CONFIGURATION' if node['removeType'] == OBJECT_TYPE_TSCONFIGURATION
+      output << 'TEXT SEARCH DICTIONARY' if node['removeType'] == OBJECT_TYPE_TSDICTIONARY
+      output << 'TEXT SEARCH PARSER' if node['removeType'] == OBJECT_TYPE_TSPARSER
+      output << 'TEXT SEARCH TEMPLATE' if node['removeType'] == OBJECT_TYPE_TSTEMPLATE
+      output << 'TYPE' if node['removeType'] == OBJECT_TYPE_TYPE
+      output << 'VIEW' if node['removeType'] == OBJECT_TYPE_VIEW
+
       output << 'CONCURRENTLY' if node['concurrent']
       output << 'IF EXISTS' if node['missing_ok']
 
       objects = node['objects']
       objects = [objects] unless objects[0].is_a?(Array)
-      output << objects.map { |list| list.map { |object| deparse_item(object) } }.join(', ')
+      case node['removeType']
+      when OBJECT_TYPE_CAST
+        object = objects[0]
+        output << format('(%s)', deparse_item_list(object).join(' AS '))
+      when OBJECT_TYPE_FUNCTION, OBJECT_TYPE_AGGREGATE, OBJECT_TYPE_SCHEMA, OBJECT_TYPE_EXTENSION
+        output << objects.map { |list| list.map { |object_line| deparse_item(object_line) } }.join(', ')
+      when OBJECT_TYPE_OPFAMILY, OBJECT_TYPE_OPCLASS
+        object = objects[0]
+        output << deparse_item(object[1]) if object.length == 2
+        output << deparse_item_list(object[1..-1]).join('.') if object.length == 3
+        output << 'USING'
+        output << deparse_item(object[0])
+      when OBJECT_TYPE_TRIGGER, OBJECT_TYPE_RULE, OBJECT_TYPE_POLICY
+        object = objects[0]
+        output << deparse_item(object[-1])
+        output << 'ON'
+        output << deparse_item(object[0]) if object.length == 2
+        output << deparse_item_list(object[0..1]).join('.') if object.length == 3
+      when OBJECT_TYPE_TRANSFORM
+        object = objects[0]
+        output << 'FOR'
+        output << deparse_item(object[0])
+        output << 'LANGUAGE'
+        output << deparse_item(object[1])
+      else
+        output << objects.map { |list| list.map { |object_line| deparse_item(object_line) }.join('.') }.join(', ')
+      end
 
       output << 'CASCADE' if node['behavior'] == 1
 
       output.join(' ')
     end
 
+    def deparse_drop_role(node)
+      output = ['DROP ROLE']
+      output << 'IF EXISTS' if node['missing_ok']
+      output << node['roles'].map { |role| deparse_identifier(role['RoleSpec']['rolename']) }.join(', ')
+      output.join(' ')
+    end
+
+    def deparse_drop_subscription(node)
+      output = ['DROP SUBSCRIPTION']
+      output << 'IF EXISTS' if node['missing_ok']
+      output << deparse_identifier(node['subname'])
+      output.join(' ')
+    end
+
+    def deparse_drop_tablespace(node)
+      output = ['DROP TABLESPACE']
+      output << 'IF EXISTS' if node['missing_ok']
+      output << node['tablespacename']
+      output.join(' ')
+    end
+
     def deparse_explain(node)
       output = ['EXPLAIN']
       options = node.fetch('options', []).map { |option| option['DefElem']['defname'].upcase }

data/lib/pg_query/node_types.rb

@@ -44,6 +44,9 @@ class PgQuery
   DISCARD_STMT = 'DiscardStmt'.freeze
   DO_STMT = 'DoStmt'.freeze
   DROP_STMT = 'DropStmt'.freeze
+  DROP_SUBSCRIPTION = 'DropSubscriptionStmt'.freeze
+  DROP_TABLESPACE = 'DropTableSpaceStmt'.freeze
+  DROP_ROLE = 'DropRoleStmt'.freeze
   EXECUTE_STMT = 'ExecuteStmt'.freeze
   EXPLAIN_STMT = 'ExplainStmt'.freeze
   FETCH_STMT = 'FetchStmt'.freeze
@@ -65,6 +68,7 @@ class PgQuery
   NULL_TEST = 'NullTest'.freeze
   OBJECT_WITH_ARGS = 'ObjectWithArgs'.freeze
   OID_LIST = 'OidList'.freeze
+  ON_CONFLICT_CLAUSE = 'OnConflictClause'.freeze
   PARAM_REF = 'ParamRef'.freeze
   PREPARE_STMT = 'PrepareStmt'.freeze
   RANGE_FUNCTION = 'RangeFunction'.freeze

data/lib/pg_query/parse.rb

@@ -124,6 +124,9 @@ class PgQuery
           if statement[CREATE_TABLE_AS_STMT]['into'] && statement[CREATE_TABLE_AS_STMT]['into'][INTO_CLAUSE]['rel']
             from_clause_items << { item: statement[CREATE_TABLE_AS_STMT]['into'][INTO_CLAUSE]['rel'], type: :ddl }
           end
+          if statement[CREATE_TABLE_AS_STMT]['query']
+            statements << statement[CREATE_TABLE_AS_STMT]['query']
+          end
         when TRUNCATE_STMT
           from_clause_items += statement.values[0]['relations'].map { |r| { item: r, type: :ddl } }
         when VIEW_STMT

data/lib/pg_query/version.rb

@@ -1,3 +1,3 @@
 class PgQuery
-  VERSION = '1.2.0'.freeze
+  VERSION = '1.3.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pg_query
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.3.0
 platform: ruby
 authors:
 - Lukas Fittl
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-11-11 00:00:00.000000000 Z
+date: 2020-12-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -123,7 +123,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: PostgreSQL query parsing and normalization library