pg_query 1.0.1 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 4a5be9c84a9ac788a7845fc900696e4c7df77bb3
-  data.tar.gz: e77d94ae2f8fb120c21efabf2faed451ad4e0966
+SHA256:
+  metadata.gz: f3d7de9759711a5e173db293a6120a15ee6ab1f0f4c5804e7f68aaba99ec8ff8
+  data.tar.gz: 974e3fb0b709021a771803e52de2a8ca19309a679d81c1ee2a3deb105f297769
 SHA512:
-  metadata.gz: 1f2f3fe149dfb181c7023fd243fa66f95f7613fffdb174c2968d947d37ade1d3dd15be599c27aa83ea67f8a289c8bff5e249c94902cb9fd61ca0306f61259927
-  data.tar.gz: ae8f01f2afc0172fad220c3119fb48806893b8e49e5e35ab58448e2342161933487a5ba9cbae8d95c656c68f453537458b450529c72c12cc77119327494e7aa1
+  metadata.gz: 3c13b36c353e6de6aaaba2b6428be7e21c933bf8ef159212cdd64ee4a765f8a664defe735f2f3e94ef6441f3403d7be6fbf19ca4d6b98e07a6b42a68a635238a
+  data.tar.gz: cc742d80bdf934c89e1faa1dd6e6560764339ecabb6fe2af67fd219b2a71b4fb6756e649ddc237d995413a90c6b036d33fe8492eb91030d8a891f970ca10510a

data/CHANGELOG.md

@@ -1,5 +1,102 @@
 # 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
+  * This matches the behaviour of Postgres' quote_identifier function, and avoids problems
+    when doing text comparisons with output involving that function
+  * 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)
+  * Deparse ILIKE, COLLATE and DISCARD (#133)
+  * CREATE CAST (#136)
+  * CREATE SCHEMA (#136)
+  * UNION, UNION ALL and EXCEPT in SELECT queries (#136)
+  * CREATE DOMAIN (#145)
+  * Subquery indirection (#157)
+  * Fix Type Cast Parentheses Problem (#152)
+  * SELECT INTO (#151)
+  * SET DEFAULT in INSERT INTO (#154)
+  * REVOKE (#155)
+  * PREPARE and EXECUTE (#148)
+  * INSERT INTO ... RETURNING (#153)
+  * Fix Alter .. RENAME SQL (#146)
+* Deparsing improvements by [@herwinw](https://github.com/herwinw)
+  * Fix subquery in COPY in deparse (#112)
+  * Function call indirection (#116)
+  * Function without parameters (#117)
+  * CREATE AGGREGATE
+  * CREATE OPERATOR
+  * CREATE TYPE
+  * GRANT statements
+  * DROP SCHEMA
+* Deparsing improvements by [@akiellor](https://github.com/akiellor)
+  * Named window functions (#150)
+* Deparsing improvements by [@himanshu](https://github.com/himanshu)
+  * Arguments in custom types (#143)
+  * Use "double precision" instead of "double" type name (#139)
+* Use explicit -z flag to support OpenBSD tar (#134) [@sirn](https://github.com/sirn)
+* Add Ruby 2.6 to Travis tests
+* Escape identifiers in more cases, if necessary
+
+
+## 1.1.0     2018-10-04
+
+* Deparsing improvements by [@herwinw](https://github.com/herwinw)
+  * Add NULLS FIRST/LAST to ORDER BY [#95](https://github.com/lfittl/pg_query/pull/95)
+  * VACUUM [#97](https://github.com/lfittl/pg_query/pull/97)
+  * UPDATE with multiple columns [#99](https://github.com/lfittl/pg_query/pull/99)
+  * DISTINCT ON [#101](https://github.com/lfittl/pg_query/pull/101)
+  * CREATE TABLE AS [#102](https://github.com/lfittl/pg_query/pull/102)
+  * SQL value functions [#103](https://github.com/lfittl/pg_query/pull/103)
+  * LOCK [#105](https://github.com/lfittl/pg_query/pull/105)
+  * EXPLAIN [#107](https://github.com/lfittl/pg_query/pull/107)
+  * COPY [#108](https://github.com/lfittl/pg_query/pull/108)
+  * DO [#109](https://github.com/lfittl/pg_query/pull/109)
+* Ignore pg_query.so in git checkout [#110](https://github.com/lfittl/pg_query/pull/110) [@herwinw](https://github.com/herwinw)
+* Prefer __dir__ over File.dirname(__FILE__) [#110](https://github.com/lfittl/pg_query/pull/104) [@herwinw](https://github.com/herwinw)
+
+
+## 1.0.2     2018-04-11
+
+* Deparsing improvements
+  * SELECT DISTINCT clause [#77](https://github.com/lfittl/pg_query/pull/77) [@Papierkorb](https://github.com/Papierkorb)
+  * "CASE expr WHEN ... END" clause [#78](https://github.com/lfittl/pg_query/pull/78) [@Papierkorb](https://github.com/Papierkorb)
+  * LEFT/RIGHT/FULL/NATURAL JOIN [#79](https://github.com/lfittl/pg_query/pull/79) [@Papierkorb](https://github.com/Papierkorb)
+  * SELECT that includes schema name [#80](https://github.com/lfittl/pg_query/pull/80) [@jcsjcs](https://github.com/jcsjcs)
+
+
 ## 1.0.1     2018-02-02
 
 * Parse CTEs and nested selects in INSERT/UPDATE [#76](https://github.com/lfittl/pg_query/pull/76) [@jcoleman](https://github.com/jcoleman)

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/Rakefile

@@ -17,7 +17,7 @@ task test: :spec
 task lint: :rubocop
 
 task :clean do
-  FileUtils.rm_rf File.join(File.dirname(__FILE__), 'tmp/')
-  FileUtils.rm_f Dir.glob(File.join(File.dirname(__FILE__), 'ext/pg_query/*.o'))
-  FileUtils.rm_f File.join(File.dirname(__FILE__), 'lib/pg_query/pg_query.bundle')
+  FileUtils.rm_rf File.join(__dir__, 'tmp/')
+  FileUtils.rm_f Dir.glob(File.join(__dir__, 'ext/pg_query/*.o'))
+  FileUtils.rm_f File.join(__dir__, 'lib/pg_query/pg_query.bundle')
 end

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(File.dirname(__FILE__), '../..')
+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 -xf #{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!)
@@ -36,7 +45,7 @@ $LOCAL_LIBS << '-lpg_query'
 $LIBPATH << libdir
 $CFLAGS << " -I #{libdir} -O3 -Wall -fno-strict-aliasing -fwrapv -g"
 
-SYMFILE = File.join(File.dirname(__FILE__), 'pg_query_ruby.sym')
+SYMFILE = File.join(__dir__, 'pg_query_ruby.sym')
 if RUBY_PLATFORM =~ /darwin/
   $DLDFLAGS << " -Wl,-exported_symbols_list #{SYMFILE}" unless defined?(::Rubinius)
 else

data/lib/pg_query/deparse.rb

@@ -1,5 +1,8 @@
-require_relative 'deparse/interval'
 require_relative 'deparse/alter_table'
+require_relative 'deparse/rename'
+require_relative 'deparse/interval'
+require_relative 'deparse/keywords'
+
 class PgQuery
   # Reconstruct all of the parsed queries into their original form
   def deparse(tree = @tree)
@@ -32,10 +35,14 @@ class PgQuery
         case node['kind']
         when AEXPR_OP
           deparse_aexpr(node, context)
+        when AEXPR_OP_ALL
+          deparse_aexpr_all(node)
         when AEXPR_OP_ANY
           deparse_aexpr_any(node)
         when AEXPR_IN
           deparse_aexpr_in(node)
+        when AEXPR_ILIKE
+          deparse_aexpr_ilike(node)
         when CONSTR_TYPE_FOREIGN
           deparse_aexpr_like(node)
         when AEXPR_BETWEEN, AEXPR_NOT_BETWEEN, AEXPR_BETWEEN_SYM, AEXPR_NOT_BETWEEN_SYM
@@ -45,6 +52,8 @@ class PgQuery
         else
           raise format("Can't deparse: %s: %s", type, node.inspect)
         end
+      when ACCESS_PRIV
+        deparse_access_priv(node)
       when ALIAS
         deparse_alias(node)
       when ALTER_TABLE_STMT
@@ -78,38 +87,82 @@ class PgQuery
         deparse_case(node)
       when COALESCE_EXPR
         deparse_coalesce(node)
+      when COLLATE_CLAUSE
+        deparse_collate(node)
       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
+        deparse_composite_type(node)
       when CONSTRAINT
         deparse_constraint(node)
+      when COPY_STMT
+        deparse_copy(node)
+      when CREATE_CAST_STMT
+        deparse_create_cast(node)
+      when CREATE_DOMAIN_STMT
+        deparse_create_domain(node)
+      when CREATE_ENUM_STMT
+        deparse_create_enum(node)
       when CREATE_FUNCTION_STMT
         deparse_create_function(node)
+      when CREATE_RANGE_STMT
+        deparse_create_range(node)
+      when CREATE_SCHEMA_STMT
+        deparse_create_schema(node)
       when CREATE_STMT
         deparse_create_table(node)
+      when CREATE_TABLE_AS_STMT
+        deparse_create_table_as(node)
+      when INTO_CLAUSE
+        deparse_into_clause(node)
       when DEF_ELEM
         deparse_defelem(node)
+      when DEFINE_STMT
+        deparse_define_stmt(node)
       when DELETE_STMT
         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
+        deparse_execute(node)
       when FUNC_CALL
         deparse_funccall(node)
       when FUNCTION_PARAMETER
         deparse_functionparameter(node)
+      when GRANT_ROLE_STMT
+        deparse_grant_role(node)
+      when GRANT_STMT
+        deparse_grant(node)
       when INSERT_STMT
         deparse_insert_into(node)
       when JOIN_EXPR
         deparse_joinexpr(node)
+      when LOCK_STMT
+        deparse_lock(node)
       when LOCKING_CLAUSE
         deparse_lockingclause(node)
       when NULL_TEST
         deparse_nulltest(node)
+      when OBJECT_WITH_ARGS
+        deparse_object_with_args(node)
       when PARAM_REF
         deparse_paramref(node)
+      when PREPARE_STMT
+        deparse_prepare(node)
       when RANGE_FUNCTION
         deparse_range_function(node)
       when RANGE_SUBSELECT
@@ -122,10 +175,14 @@ class PgQuery
         deparse_renamestmt(node)
       when RES_TARGET
         deparse_restarget(node, context)
+      when ROLE_SPEC
+        deparse_role_spec(node)
       when ROW_EXPR
         deparse_row(node)
       when SELECT_STMT
         deparse_select(node)
+      when SQL_VALUE_FUNCTION
+        deparse_sql_value_function(node)
       when SORT_BY
         deparse_sortby(node)
       when SUB_LINK
@@ -148,13 +205,21 @@ class PgQuery
         deparse_viewstmt(node)
       when VARIABLE_SET_STMT
         deparse_variable_set_stmt(node)
+      when VACUUM_STMT
+        deparse_vacuum_stmt(node)
+      when DO_STMT
+        deparse_do_stmt(node)
+      when SET_TO_DEFAULT
+        'DEFAULT'
       when STRING
         if context == A_CONST
           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
-          format('"%s"', node['str'].gsub('"', '""'))
+          deparse_identifier(node['str'], escape_always: true)
         end
       when INTEGER
         node['ival'].to_s
@@ -171,10 +236,20 @@ class PgQuery
       nodes.map { |n| deparse_item(n, context) }
     end
 
+    def deparse_identifier(ident, escape_always: false)
+      return if ident.nil?
+      if escape_always || !ident[/^\w+$/] || KEYWORDS.include?(ident.upcase)
+        format('"%s"', ident.gsub('"', '""'))
+      else
+        ident
+      end
+    end
+
     def deparse_rangevar(node)
       output = []
       output << 'ONLY' unless node['inh']
-      output << '"' + node['relname'] + '"'
+      schema = node['schemaname'] ? '"' + node['schemaname'] + '".' : ''
+      output << schema + '"' + node['relname'] + '"'
       output << deparse_item(node['alias']) if node['alias']
       output.join(' ')
     end
@@ -183,30 +258,43 @@ class PgQuery
       deparse_item(node[STMT_FIELD])
     end
 
-    def deparse_renamestmt(node)
-      output = []
-
-      case node['renameType']
-      when OBJECT_TYPE_TABLE
-        output << 'ALTER TABLE'
-        output << deparse_item(node['relation'])
-        output << 'RENAME TO'
-        output << node['newname']
+    def deparse_renamestmt_decision(node, type)
+      if node[type]
+        if node[type].is_a?(String)
+          deparse_identifier(node[type])
+        elsif node[type].is_a?(Array)
+          deparse_item_list(node[type])
+        elsif node[type].is_a?(Object)
+          deparse_item(node[type])
+        end
       else
-        raise format("Can't deparse: %s", node.inspect)
+        type
       end
+    end
+
+    def deparse_renamestmt(node)
+      output = []
+      output << 'ALTER'
+      command, type, options, type2, options2 = Rename.commands(node)
 
+      output << command if command
+      output << deparse_renamestmt_decision(node, type)
+      output << options if options
+      output << deparse_renamestmt_decision(node, type2) if type2
+      output << deparse_renamestmt_decision(node, options2) if options2
+      output << 'TO'
+      output << deparse_identifier(node['newname'], escape_always: true)
       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
 
     def deparse_a_arrayexp(node)
-      'ARRAY[' + node['elements'].map do |element|
+      'ARRAY[' + (node['elements'] || []).map do |element|
         deparse_item(element)
       end.join(', ') + ']'
     end
@@ -220,7 +308,17 @@ class PgQuery
     end
 
     def deparse_a_indirection(node)
-      output = [deparse_item(node['arg'])]
+      output = []
+      arg = deparse_item(node['arg'])
+      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
+                end
       node['indirection'].each do |subnode|
         output << deparse_item(subnode)
       end
@@ -236,13 +334,16 @@ class PgQuery
       if node['colnames']
         name + '(' + deparse_item_list(node['colnames']).join(', ') + ')'
       else
-        name
+        deparse_identifier(name)
       end
     end
 
     def deparse_alter_table(node)
       output = []
-      output << 'ALTER TABLE'
+      output << 'ALTER'
+
+      output << 'TABLE' if node['relkind'] == OBJECT_TYPE_TABLE
+      output << 'VIEW' if node['relkind'] == OBJECT_TYPE_VIEW
 
       output << deparse_item(node['relation'])
 
@@ -267,6 +368,16 @@ class PgQuery
       output.compact.join(' ')
     end
 
+    def deparse_object_with_args(node)
+      output = []
+      output << deparse_item_list(node['objname']).join('.')
+      unless node['args_unspecified']
+        args = node.fetch('objargs', []).map(&method(:deparse_item)).join(', ')
+        output << "(#{args})"
+      end
+      output.join('')
+    end
+
     def deparse_paramref(node)
       if node['number'].nil?
         '?'
@@ -275,11 +386,22 @@ class PgQuery
       end
     end
 
+    def deparse_prepare(node)
+      output = ['PREPARE']
+      output << deparse_identifier(node['name'])
+      output << "(#{deparse_item_list(node['argtypes']).join(', ')})" if node['argtypes']
+      output << 'AS'
+      output << deparse_item(node['query'])
+      output.join(' ')
+    end
+
     def deparse_restarget(node, context)
       if context == :select
-        [deparse_item(node['val']), node['name']].compact.join(' AS ')
+        [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
@@ -295,15 +417,24 @@ 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
 
     def deparse_windowdef(node)
+      return deparse_identifier(node['name']) if node['name']
+
       output = []
 
       if node['partitionClause']
@@ -320,13 +451,84 @@ class PgQuery
         end.join(', ')
       end
 
-      output.join(' ')
+      format('(%s)', output.join(' '))
     end
 
     def deparse_functionparameter(node)
       deparse_item(node['argType'])
     end
 
+    def deparse_grant_role(node)
+      output = []
+      output << ['GRANT'] if node['is_grant']
+      output << ['REVOKE'] unless node['is_grant']
+      output << node['granted_roles'].map(&method(:deparse_item)).join(', ')
+      output << ['TO'] if node['is_grant']
+      output << ['FROM'] unless node['is_grant']
+      output << node['grantee_roles'].map(&method(:deparse_item)).join(', ')
+      output << 'WITH ADMIN OPTION' if node['admin_opt']
+      output.join(' ')
+    end
+
+    def deparse_grant(node) # rubocop:disable Metrics/CyclomaticComplexity
+      objtype, allow_all = deparse_grant_objtype(node)
+      output = []
+      output << ['GRANT'] if node['is_grant']
+      output << ['REVOKE'] unless node['is_grant']
+      output << if node.key?('privileges')
+                  node['privileges'].map(&method(:deparse_item)).join(', ')
+                else
+                  'ALL'
+                end
+      output << 'ON'
+      objects = node['objects']
+      objects = objects[0] if %w[DOMAIN TYPE].include?(objtype)
+      objects = objects.map do |object|
+        deparsed = deparse_item(object)
+        if object.key?(RANGE_VAR) || object.key?(OBJECT_WITH_ARGS) || !allow_all
+          objtype == 'TABLE' ? deparsed : "#{objtype} #{deparsed}"
+        else
+          "ALL #{objtype}S IN SCHEMA #{deparsed}"
+        end
+      end
+      output << objects.join(', ')
+      output << ['TO'] if node['is_grant']
+      output << ['FROM'] unless node['is_grant']
+      output << node['grantees'].map(&method(:deparse_item)).join(', ')
+      output << 'WITH GRANT OPTION' if node['grant_option']
+      output.join(' ')
+    end
+
+    def deparse_grant_objtype(node)
+      {
+        1 => ['TABLE', true],
+        2 => ['SEQUENCE', true],
+        3 => ['DATABASE', false],
+        4 => ['DOMAIN', false],
+        5 => ['FOREIGN DATA WRAPPER', false],
+        6 => ['FOREIGN SERVER', false],
+        7 => ['FUNCTION', true],
+        8 => ['LANGUAGE', false],
+        9 => ['LARGE OBJECT', false],
+        10 => ['SCHEMA', false],
+        11 => ['TABLESPACE', false],
+        12 => ['TYPE', false]
+      }.fetch(node['objtype'])
+    end
+
+    def deparse_access_priv(node)
+      output = [node['priv_name']]
+      output << "(#{node['cols'].map(&method(:deparse_item)).join(', ')})" if node.key?('cols')
+      output.join(' ')
+    end
+
+    def deparse_role_spec(node)
+      return 'CURRENT_USER' if node['roletype'] == 1
+      return 'SESSION_USER' if node['roletype'] == 2
+      return 'PUBLIC' if node['roletype'] == 3
+      deparse_identifier(node['rolename'], escape_always: true)
+    end
+
     def deparse_aexpr_in(node)
       rexpr = Array(node['rexpr']).map { |arg| deparse_item(arg) }
       operator = node['name'].map { |n| deparse_item(n, :operator) } == ['='] ? 'IN' : 'NOT IN'
@@ -339,6 +541,12 @@ class PgQuery
       format('%s %s %s', deparse_item(node['lexpr']), operator, value)
     end
 
+    def deparse_aexpr_ilike(node)
+      value = deparse_item(node['rexpr'])
+      operator = node['name'][0]['String']['str'] == '~~*' ? 'ILIKE' : 'NOT ILIKE'
+      format('%s %s %s', deparse_item(node['lexpr']), operator, value)
+    end
+
     def deparse_bool_expr_not(node)
       format('NOT %s', deparse_item(node['args'][0]))
     end
@@ -405,6 +613,13 @@ class PgQuery
       output.join(' ' + deparse_item(node['name'][0], :operator) + ' ')
     end
 
+    def deparse_aexpr_all(node)
+      output = []
+      output << deparse_item(node['lexpr'])
+      output << format('ALL(%s)', deparse_item(node['rexpr']))
+      output.join(' ' + deparse_item(node['name'][0], :operator) + ' ')
+    end
+
     def deparse_aexpr_between(node)
       between = case node['kind']
                 when AEXPR_BETWEEN
@@ -432,9 +647,17 @@ class PgQuery
       output << deparse_item(node['larg'])
       case node['jointype']
       when 0
-        output << 'CROSS' if node['quals'].nil? && node['usingClause'].nil?
+        if node['isNatural']
+          output << 'NATURAL'
+        elsif node['quals'].nil? && node['usingClause'].nil?
+          output << 'CROSS'
+        end
       when 1
         output << 'LEFT'
+      when 2
+        output << 'FULL'
+      when 3
+        output << 'RIGHT'
       end
       output << 'JOIN'
       output << deparse_item(node['rarg'])
@@ -449,6 +672,14 @@ class PgQuery
       output.join(' ')
     end
 
+    def deparse_lock(node)
+      output = []
+      output << 'LOCK TABLE'
+      tables = node['relations'].map { |table| deparse_item(table) }
+      output << tables.join(', ')
+      output.join(' ')
+    end
+
     LOCK_CLAUSE_STRENGTH = {
       LCS_FORKEYSHARE => 'FOR KEY SHARE',
       LCS_FORSHARE => 'FOR SHARE',
@@ -472,6 +703,16 @@ class PgQuery
       output << deparse_item(node['node'])
       output << 'ASC' if node['sortby_dir'] == 1
       output << 'DESC' if node['sortby_dir'] == 2
+      output << 'NULLS FIRST' if node['sortby_nulls'] == 1
+      output << 'NULLS LAST' if node['sortby_nulls'] == 2
+      output.join(' ')
+    end
+
+    def deparse_collate(node)
+      output = []
+      output << deparse_item(node['arg'])
+      output << 'COLLATE'
+      output << deparse_item_list(node['collname'])
       output.join(' ')
     end
 
@@ -518,6 +759,35 @@ class PgQuery
       output.join(' ')
     end
 
+    def deparse_vacuum_stmt(node)
+      output = []
+      output << 'VACUUM'
+      output.concat(deparse_vacuum_options(node))
+      output << deparse_item(node['relation']) if node.key?('relation')
+      if node.key?('va_cols')
+        output << "(#{node['va_cols'].map(&method(:deparse_item)).join(', ')})"
+      end
+      output.join(' ')
+    end
+
+    def deparse_vacuum_options(node)
+      output = []
+      output << 'FULL' if node['options'][4] == 1
+      output << 'FREEZE' if node['options'][3] == 1
+      output << 'VERBOSE' if node['options'][2] == 1
+      output << 'ANALYZE' if node['options'][1] == 1
+      output
+    end
+
+    def deparse_do_stmt(node)
+      output = []
+      output << 'DO'
+      statement, *rest = node['args']
+      output << "$$#{statement['DefElem']['arg']['String']['str']}$$"
+      output += rest.map { |item| deparse_item(item) }
+      output.join(' ')
+    end
+
     def deparse_cte(node)
       output = []
       output << node['ctename']
@@ -528,6 +798,7 @@ class PgQuery
 
     def deparse_case(node)
       output = ['CASE']
+      output << deparse_item(node['arg']) if node['arg']
       output += node['args'].map { |arg| deparse_item(arg) }
       if node['defresult']
         output << 'ELSE'
@@ -549,9 +820,22 @@ class PgQuery
           deparse_item(item)
         end
       end
+      if node['collClause']
+        output << 'COLLATE'
+        output += node['collClause']['CollateClause']['collname'].map(&method(:deparse_item))
+      end
       output.compact.join(' ')
     end
 
+    def deparse_composite_type(node)
+      output = ['CREATE TYPE']
+      output << deparse_rangevar(node['typevar'][RANGE_VAR].merge('inh' => true))
+      output << 'AS'
+      coldeflist = node['coldeflist'].map(&method(:deparse_item))
+      output << "(#{coldeflist.join(', ')})"
+      output.join(' ')
+    end
+
     def deparse_constraint(node) # rubocop:disable Metrics/CyclomaticComplexity
       output = []
       if node['conname']
@@ -580,6 +864,7 @@ class PgQuery
       if node['raw_expr']
         expression = deparse_item(node['raw_expr'])
         # Unless it's simple, put parentheses around it
+        expression = '(' + expression + ')' if node['raw_expr'][BOOL_EXPR]
         expression = '(' + expression + ')' if node['raw_expr'][A_EXPR] && node['raw_expr'][A_EXPR]['kind'] == AEXPR_OP
         output << expression
       end
@@ -591,13 +876,75 @@ class PgQuery
       output.join(' ')
     end
 
+    def deparse_copy(node)
+      output = ['COPY']
+      if node.key?('relation')
+        output << deparse_item(node['relation'])
+      elsif node.key?('query')
+        output << "(#{deparse_item(node['query'])})"
+      end
+      columns = node.fetch('attlist', []).map { |column| deparse_item(column) }
+      output << "(#{columns.join(', ')})" unless columns.empty?
+      output << (node['is_from'] ? 'FROM' : 'TO')
+      output << 'PROGRAM' if node['is_program']
+      output << deparse_copy_output(node)
+      output.join(' ')
+    end
+
+    def deparse_copy_output(node)
+      return "'#{node['filename']}'" if node.key?('filename')
+      return 'STDIN' if node['is_from']
+      'STDOUT'
+    end
+
+    def deparse_create_enum(node)
+      output = ['CREATE TYPE']
+      output << deparse_item(node['typeName'][0])
+      output << 'AS ENUM'
+      vals = node['vals'].map { |val| deparse_item(val, A_CONST) }
+      output << "(#{vals.join(', ')})"
+      output.join(' ')
+    end
+
+    def deparse_create_cast(node)
+      output = []
+      output << 'CREATE'
+      output << 'CAST'
+      output << format('(%s AS %s)', deparse_item(node['sourcetype']), deparse_item(node['targettype']))
+      output << if node['func']
+                  function = node['func']['ObjectWithArgs']
+                  name = deparse_item_list(function['objname']).join('.')
+                  arguments = deparse_item_list(function['objargs']).join(', ')
+                  format('WITH FUNCTION %s(%s)', name, arguments)
+                elsif node['inout']
+                  'WITH INOUT'
+                else
+                  'WITHOUT FUNCTION'
+                end
+      output << 'AS IMPLICIT' if (node['context']).zero?
+      output << 'AS ASSIGNMENT' if node['context'] == 1
+      output.join(' ')
+    end
+
+    def deparse_create_domain(node)
+      output = []
+      output << 'CREATE'
+      output << 'DOMAIN'
+      output << deparse_item_list(node['domainname']).join('.')
+      output << 'AS'
+      output << deparse_item(node['typeName']) if node['typeName']
+      output << deparse_item(node['collClause']) if node['collClause']
+      output << deparse_item_list(node['constraints'])
+      output.join(' ')
+    end
+
     def deparse_create_function(node)
       output = []
       output << 'CREATE'
       output << 'OR REPLACE' if node['replace']
       output << 'FUNCTION'
 
-      arguments = deparse_item_list(node['parameters']).join(', ')
+      arguments = deparse_item_list(node.fetch('parameters', [])).join(', ')
 
       output << deparse_item_list(node['funcname']).join('.') + '(' + arguments + ')'
 
@@ -608,6 +955,30 @@ class PgQuery
       output.join(' ')
     end
 
+    def deparse_create_range(node)
+      output = ['CREATE TYPE']
+      output << deparse_item(node['typeName'][0])
+      output << 'AS RANGE'
+      params = node['params'].map do |param|
+        param_out = [param['DefElem']['defname']]
+        if param['DefElem'].key?('arg')
+          param_out << deparse_item(param['DefElem']['arg'])
+        end
+        param_out.join('=')
+      end
+      output << "(#{params.join(', ')})"
+      output.join(' ')
+    end
+
+    def deparse_create_schema(node)
+      output = ['CREATE SCHEMA']
+      output << 'IF NOT EXISTS' if node['if_not_exists']
+      output << deparse_identifier(node['schemaname']) if node.key?('schemaname')
+      output << format('AUTHORIZATION %s', deparse_item(node['authrole'])) if node.key?('authrole')
+      output << deparse_item_list(node['schemaElts']) if node.key?('schemaElts')
+      output.join(' ')
+    end
+
     def deparse_create_table(node)
       output = []
       output << 'CREATE'
@@ -635,6 +1006,40 @@ class PgQuery
       output.join(' ')
     end
 
+    def deparse_create_table_as(node)
+      output = []
+      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(' ')
+    end
+
+    def deparse_execute(node)
+      output = ['EXECUTE']
+      output << deparse_identifier(node['name'])
+      output << "(#{deparse_item_list(node['params']).join(', ')})" if node['params']
+      output.join(' ')
+    end
+
+    def deparse_into_clause(node)
+      deparse_item(node['rel'])
+    end
+
     def deparse_when(node)
       output = ['WHEN']
       output << deparse_item(node['expr'])
@@ -646,15 +1051,21 @@ class PgQuery
     def deparse_sublink(node)
       if node['subLinkType'] == SUBLINK_TYPE_ANY
         format('%s IN (%s)', deparse_item(node['testexpr']), deparse_item(node['subselect']))
+      elsif node['subLinkType'] == SUBLINK_TYPE_ALL
+        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
@@ -669,21 +1080,52 @@ class PgQuery
     def deparse_select(node) # rubocop:disable Metrics/CyclomaticComplexity
       output = []
 
+      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'])
-        return output.join(' ')
+        output << ')' if node['rarg']['SelectStmt']['sortClause']
+        output.join(' ')
       end
 
-      output << deparse_item(node['withClause']) if node['withClause']
+      if node['op'] == 3
+        output << deparse_item(node['larg'])
+        output << 'EXCEPT'
+        output << deparse_item(node['rarg'])
+        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?
+            columns = node['distinctClause'].map { |item| deparse_item(item, :select) }
+            output << "ON (#{columns.join(', ')})"
+          end
+        end
         output << node[TARGET_LIST_FIELD].map do |item|
           deparse_item(item, :select)
         end.join(', ')
+
+        if node['intoClause']
+          output << 'INTO'
+          output << deparse_item(node['intoClause'])
+        end
       end
 
       if node[FROM_CLAUSE_FIELD]
@@ -743,6 +1185,30 @@ class PgQuery
       output.join(' ')
     end
 
+    def deparse_sql_value_function(node)
+      output = []
+      lookup = [
+        'current_date',
+        'current_time',
+        'current_time', # with precision
+        'current_timestamp',
+        'current_timestamp', # with precision
+        'localtime',
+        'localtime', # with precision
+        'localtimestamp',
+        'localtimestamp', # with precision
+        'current_role',
+        'current_user',
+        'session_user',
+        'user',
+        'current_catalog',
+        'current_schema'
+      ]
+      output << lookup[node['op']]
+      output << "(#{node['typmod']})" unless node.fetch('typmod', -1) == -1
+      output.join('')
+    end
+
     def deparse_insert_into(node)
       output = []
       output << deparse_item(node['withClause']) if node['withClause']
@@ -752,12 +1218,57 @@ 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|
+          deparse_item(column, :select)
+        end.join(', ')
+      end
+
+      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
 
@@ -770,9 +1281,17 @@ class PgQuery
 
       if node[TARGET_LIST_FIELD]
         output << 'SET'
-        node[TARGET_LIST_FIELD].each do |item|
-          output << deparse_item(item, :update)
+        columns = node[TARGET_LIST_FIELD].map do |item|
+          deparse_item(item, :update)
         end
+        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']
@@ -791,12 +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
-        deparse_item(node['arg']) + '::' + 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)
@@ -825,7 +1366,7 @@ class PgQuery
       # Just pass along any custom types.
       # (The pg_catalog types are built-in Postgres system types and are
       #  handled in the case statement below)
-      return names.join('.') if catalog != 'pg_catalog'
+      return names.join('.') + (arguments.nil? ? '' : "(#{arguments})") if catalog != 'pg_catalog'
 
       case type
       when 'bpchar'
@@ -847,7 +1388,7 @@ class PgQuery
       when 'real', 'float4'
         'real'
       when 'float8'
-        'double'
+        'double precision'
       when 'time'
         'time'
       when 'timetz'
@@ -930,6 +1471,57 @@ class PgQuery
       end
     end
 
+    def deparse_define_stmt(node)
+      dispatch = {
+        1 => :deparse_create_aggregate,
+        25 => :deparse_create_operator,
+        45 => :deparse_create_type
+      }
+      method(dispatch.fetch(node['kind'])).call(node)
+    end
+
+    def deparse_create_aggregate(node)
+      output = ['CREATE AGGREGATE']
+      output << node['defnames'].map(&method(:deparse_item))
+      args = node['args'][0] || [{ A_STAR => nil }]
+      output << "(#{args.map(&method(:deparse_item)).join(', ')})"
+      definitions = node['definition'].map do |definition|
+        definition_output = [definition['DefElem']['defname']]
+        definition_output << definition['DefElem']['arg']['TypeName']['names'].map(&method(:deparse_item)).join(', ') if definition['DefElem'].key?('arg')
+        definition_output.join('=')
+      end
+      output << "(#{definitions.join(', ')})"
+      output.join(' ')
+    end
+
+    def deparse_create_operator(node)
+      output = ['CREATE OPERATOR']
+      output << node['defnames'][0]['String']['str']
+      definitions = node['definition'].map do |definition|
+        definition_output = [definition['DefElem']['defname']]
+        definition_output << definition['DefElem']['arg']['TypeName']['names'].map(&method(:deparse_item)).join(', ') if definition['DefElem'].key?('arg')
+        definition_output.join('=')
+      end
+      output << "(#{definitions.join(', ')})"
+      output.join(' ')
+    end
+
+    def deparse_create_type(node)
+      output = ['CREATE TYPE']
+      output << node['defnames'].map(&method(:deparse_item))
+      if node.key?('definition')
+        definitions = node['definition'].map do |definition|
+          definition_output = [definition['DefElem']['defname']]
+          if definition['DefElem'].key?('arg')
+            definition_output += definition['DefElem']['arg']['TypeName']['names'].map(&method(:deparse_item))
+          end
+          definition_output.join('=')
+        end
+        output << "(#{definitions.join(', ')})"
+      end
+      output.join(' ')
+    end
+
     def deparse_delete_from(node)
       output = []
       output << deparse_item(node['withClause']) if node['withClause']
@@ -960,19 +1552,121 @@ class PgQuery
       output.join(' ')
     end
 
-    def deparse_drop(node)
+    def deparse_discard(node)
+      output = ['DISCARD']
+      output << 'ALL' if (node['target']).zero?
+      output << 'PLANS' if node['target'] == 1
+      output << 'SEQUENCES' if node['target'] == 2
+      output << 'TEMP' if node['target'] == 3
+      output.join(' ')
+    end
+
+    def deparse_drop(node) # rubocop:disable Metrics/CyclomaticComplexity
       output = ['DROP']
+
+      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']
 
-      output << node['objects'].map { |list| list.map { |object| deparse_item(object) } }.join(', ')
+      objects = node['objects']
+      objects = [objects] unless objects[0].is_a?(Array)
+      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 }
+      if options.size == 1
+        output.concat(options)
+      elsif options.size > 1
+        output << "(#{options.join(', ')})"
+      end
+      output << deparse_item(node['query'])
+      output.join(' ')
+    end
+
     # The PG parser adds several pieces of view data onto the RANGEVAR
     # that need to be printed before deparse_rangevar is called.
     def relpersistence(rangevar)