pg_query 1.1.0 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0db8e898d08ff3642a800ab296d7ac10dd9556e3c5a626f005bae86d35273372
-  data.tar.gz: a869a1faeb3ae0bed9d5031f2a4d26263843fde368bfeb096c1c9f48ea30c9f8
+  metadata.gz: 9cb01b49c6ea65d1ff126562ce68adaa5635d37093ff726b1bc70d65c341ae9e
+  data.tar.gz: 4dc7fa1bf00d7ff6036a79d8a38fd9f3e383f449b21f0d53f0168be7d32df89a
 SHA512:
-  metadata.gz: e0f51970e5f268d9d9d32d791288db0d7a048c4880f706ff7d483b0efacd1a355600f5b8ca8a0b57b75a05cda8c7b207402bb6680fad0fdaeaf7809fab06c441
-  data.tar.gz: 6281530a32add88cd8a474a8e224e817723e288e850f9d9232aba69208b1178d89b7135d613d15800176bd611b3d6fcd0600fb48c3e8c880f6aa47f5296bae45
+  metadata.gz: ad48c885044147fcc9fa406543fc8a805c789fa227d71000bd1d25be0846aa1f7e183420e7ee86df262ff0d7ae668f2c4b1cd4ef15f5d305d5deeb5d86d6e8ad
+  data.tar.gz: 860aa2345238226eaf5594d20d34af5a6aed39177a0900e0b72e79771586f96bf2917ac73722d3672cf730e18c2977cd275617fe411e79b4af8266ac4e499124

data/CHANGELOG.md

@@ -1,5 +1,40 @@
 # Changelog
 
+## 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)

data/ext/pg_query/extconf.rb

@@ -19,7 +19,7 @@ unless File.exist?("#{workdir}/libpg_query.tar.gz")
 end
 
 unless Dir.exist?(libdir)
-  system("tar -xf #{workdir}/libpg_query.tar.gz") || raise('ERROR')
+  system("tar -xzf #{workdir}/libpg_query.tar.gz") || raise('ERROR')
 end
 
 unless Dir.exist?(libfile)

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,18 +87,32 @@ 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)
       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
@@ -98,16 +121,26 @@ class PgQuery
         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_STMT
         deparse_drop(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
@@ -118,8 +151,12 @@ class PgQuery
         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
@@ -132,6 +169,8 @@ 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
@@ -164,13 +203,15 @@ class PgQuery
         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']
         else
-          format('"%s"', node['str'].gsub('"', '""'))
+          deparse_identifier(node['str'], escape_always: true)
         end
       when INTEGER
         node['ival'].to_s
@@ -187,6 +228,15 @@ 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']
@@ -200,19 +250,32 @@ 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
 
@@ -223,7 +286,7 @@ class PgQuery
     end
 
     def deparse_a_arrayexp(node)
-      'ARRAY[' + node['elements'].map do |element|
+      'ARRAY[' + (node['elements'] || []).map do |element|
         deparse_item(element)
       end.join(', ') + ']'
     end
@@ -237,7 +300,13 @@ class PgQuery
     end
 
     def deparse_a_indirection(node)
-      output = [deparse_item(node['arg'])]
+      output = []
+      arg = deparse_item(node['arg'])
+      output << if node['arg'].key?(FUNC_CALL) || node['arg'].key?(SUB_LINK)
+                  "(#{arg})."
+                else
+                  arg
+                end
       node['indirection'].each do |subnode|
         output << deparse_item(subnode)
       end
@@ -253,13 +322,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'])
 
@@ -284,6 +356,16 @@ class PgQuery
       output.compact.join(' ')
     end
 
+    def deparse_object_with_args(node)
+      output = []
+      output += node['objname'].map(&method(:deparse_item))
+      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?
         '?'
@@ -292,9 +374,18 @@ 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(' = ')
       elsif node['val'].nil?
@@ -315,12 +406,14 @@ class PgQuery
       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']
+      output << format('OVER %s', deparse_item(node['over'])) if node['over']
 
       output.join(' ')
     end
 
     def deparse_windowdef(node)
+      return deparse_identifier(node['name']) if node['name']
+
       output = []
 
       if node['partitionClause']
@@ -337,13 +430,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'
@@ -356,6 +520,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
@@ -422,6 +592,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
@@ -510,6 +687,14 @@ class PgQuery
       output.join(' ')
     end
 
+    def deparse_collate(node)
+      output = []
+      output << deparse_item(node['arg'])
+      output << 'COLLATE'
+      output << deparse_item_list(node['collname'])
+      output.join(' ')
+    end
+
     def deparse_with_clause(node)
       output = ['WITH']
       output << 'RECURSIVE' if node['recursive']
@@ -614,9 +799,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']
@@ -645,6 +843,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
@@ -658,16 +857,63 @@ class PgQuery
 
     def deparse_copy(node)
       output = ['COPY']
-      output << deparse_item(node['relation'])
+      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 << if node.key?('filename')
-                  "'#{node['filename']}'"
+      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
-                  node['is_from'] ? 'STDIN' : 'STDOUT'
+                  '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
 
@@ -677,7 +923,7 @@ class PgQuery
       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 + ')'
 
@@ -688,6 +934,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'
@@ -724,6 +994,13 @@ class PgQuery
       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
@@ -739,6 +1016,8 @@ 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']))
       else
@@ -762,15 +1041,22 @@ class PgQuery
     def deparse_select(node) # rubocop:disable Metrics/CyclomaticComplexity
       output = []
 
+      output << deparse_item(node['withClause']) if node['withClause']
+
       if node['op'] == 1
         output << deparse_item(node['larg'])
         output << 'UNION'
         output << 'ALL' if node['all']
         output << deparse_item(node['rarg'])
-        return output.join(' ')
+        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[TARGET_LIST_FIELD]
         output << 'SELECT'
@@ -784,6 +1070,11 @@ class PgQuery
         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]
@@ -882,6 +1173,13 @@ class PgQuery
 
       output << deparse_item(node['selectStmt'])
 
+      if node['returningList']
+        output << 'RETURNING'
+        output << node['returningList'].map do |column|
+          deparse_item(column, :select)
+        end.join(', ')
+      end
+
       output.join(' ')
     end
 
@@ -920,7 +1218,8 @@ class PgQuery
       if deparse_item(node['typeName']) == 'boolean'
         deparse_item(node['arg']) == "'t'" ? 'true' : 'false'
       else
-        deparse_item(node['arg']) + '::' + deparse_typename(node['typeName'][TYPE_NAME])
+        context = true if node['arg']['A_Expr']
+        deparse_item(node['arg'], context) + '::' + deparse_typename(node['typeName'][TYPE_NAME])
       end
     end
 
@@ -950,7 +1249,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'
@@ -972,7 +1271,7 @@ class PgQuery
       when 'real', 'float4'
         'real'
       when 'float8'
-        'double'
+        'double precision'
       when 'time'
         'time'
       when 'timetz'
@@ -1055,6 +1354,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']
@@ -1085,13 +1435,25 @@ 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 << 'TABLE' if node['removeType'] == OBJECT_TYPE_TABLE
+      output << 'SCHEMA' if node['removeType'] == OBJECT_TYPE_SCHEMA
       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)
+      output << objects.map { |list| list.map { |object| deparse_item(object) } }.join(', ')
 
       output << 'CASCADE' if node['behavior'] == 1