pg_query 0.6.3 → 0.6.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f75ea93d3521a2b9f912943357d6b16e3598bbea
-  data.tar.gz: f320d5689ceda9ba637d751bf10e4f09d8dddaae
+  metadata.gz: 75abf971dc2e2ed3ba84e61b7964e7c52ac62faf
+  data.tar.gz: e80a542497240ffc2c36892422b972ff3049f02d
 SHA512:
-  metadata.gz: 2007ca5cea466541823b11818ba6ba9b86cdf447e3f449024a790b8ebfbf8a9762dfefc82e0e9abb6e96c42e5a3602c4c7bf7ed479aa431666f078f503911a7f
-  data.tar.gz: 687b67153015d9e3e36053a6ffc4e7c558cec3f4ca7eac3860188c0d88a72b41a38d57dcae0e02deb11535f3b8e2f499789fc1ad9281e1da8365c7d9a421e308
+  metadata.gz: 85e96b1d41a656569bf83a716194d71907f7c9d8c0a9c7282b30bc4b0110bdbc6c90d5cbf6df95c6211bd011d73763e58205de8eb626e5855c944ce96b6be0ac
+  data.tar.gz: 7f5b864b1e61711da44c0bca0d318edf719506633297310d9be4d7daf17729e7602daa2a4e191c19039670e54ac9a4f404fd3ab115caf0a2ffac21c7c9ce977d

data/CHANGELOG.md

@@ -1,10 +1,19 @@
 # Changelog
 
-## 0.6.4    UNRELEASED
+## 0.6.5    UNRELEASED
 
 * ...
 
 
+## 0.6.4    2015-10-01
+
+* Deparsing
+  * Constraints & Interval Types [#28](https://github.com/lfittl/pg_query/pull/28) [@JackDanger](https://github.com/JackDanger)
+  * Cross joins [#29](https://github.com/lfittl/pg_query/pull/29) [@mme](https://github.com/mme)
+  * ALTER TABLE [#30](https://github.com/lfittl/pg_query/pull/30) [@JackDanger](https://github.com/JackDanger)
+  * LIMIT and OFFSET [#33](https://github.com/lfittl/pg_query/pull/33) [@jcsjcs](https://github.com/jcsjcs)
+
+
 ## 0.6.3    2015-08-20
 
 * Deparsing

data/lib/pg_query/deparse.rb

@@ -1,15 +1,20 @@
+require_relative 'deparse/interval'
+require_relative 'deparse/alter_table'
 class PgQuery
   # Reconstruct all of the parsed queries into their original form
   def deparse(tree = @parsetree)
     tree.map do |item|
-      self.class.deparse(item)
+      Deparse.from(item)
     end.join('; ')
   end
 
-  class << self
+  # rubocop:disable Metrics/ModuleLength
+  module Deparse
+    extend self
+
     # Given one element of the PgQuery#parsetree reconstruct it back into the
     # original query.
-    def deparse(item)
+    def from(item)
       deparse_item(item)
     end
 
@@ -17,6 +22,7 @@ class PgQuery
 
     def deparse_item(item, context = nil) # rubocop:disable Metrics/CyclomaticComplexity
       return if item.nil?
+      return item if item.is_a?(Fixnum)
 
       type = item.keys[0]
       node = item.values[0]
@@ -33,9 +39,13 @@ class PgQuery
       when 'AEXPR OR'
         deparse_aexpr_or(node)
       when 'AEXPR'
-        deparse_aexpr(node)
+        deparse_aexpr(node, context)
       when 'ALIAS'
         deparse_alias(node)
+      when 'ALTER TABLE'
+        deparse_alter_table(node)
+      when 'ALTER TABLE CMD'
+        deparse_alter_table_cmd(node)
       when 'A_ARRAYEXPR'
         deparse_a_arrayexp(node)
       when 'A_CONST'
@@ -68,6 +78,8 @@ class PgQuery
         deparse_defelem(node)
       when 'DELETE FROM'
         deparse_delete_from(node)
+      when 'DROP'
+        deparse_drop(node)
       when 'FUNCCALL'
         deparse_funccall(node)
       when 'FUNCTIONPARAMETER'
@@ -86,6 +98,8 @@ class PgQuery
         deparse_rangesubselect(node)
       when 'RANGEVAR'
         deparse_rangevar(node)
+      when 'RENAMESTMT'
+        deparse_renamestmt(node)
       when 'RESTARGET'
         deparse_restarget(node, context)
       when 'ROW'
@@ -125,6 +139,19 @@ class PgQuery
       output.join(' ')
     end
 
+    def deparse_renamestmt(node)
+      output = []
+
+      if node['renameType'] == 26 # table
+        output << 'ALTER TABLE'
+        output << deparse_item(node['relation'])
+        output << 'RENAME TO'
+        output << node['newname']
+      end
+
+      output.join(' ')
+    end
+
     def deparse_columnref(node)
       node['fields'].map do |field|
         field.is_a?(String) ? field : deparse_item(field)
@@ -166,6 +193,33 @@ class PgQuery
       end
     end
 
+    def deparse_alter_table(node)
+      output = []
+      output << 'ALTER TABLE'
+
+      output << deparse_item(node['relation'])
+
+      output << node['cmds'].map do |item|
+        deparse_item(item)
+      end.join(', ')
+
+      output.join(' ')
+    end
+
+    def deparse_alter_table_cmd(node)
+      command, options = AlterTable.commands(node)
+
+      output = []
+      output << command if command
+      output << 'IF EXISTS' if node['missing_ok']
+      output << node['name']
+      output << options if options
+      output << deparse_item(node['def']) if node['def']
+      output << 'CASCADE' if node['behavior'] == 1
+
+      output.compact.join(' ')
+    end
+
     def deparse_paramref(node)
       if node['number'] == 0
         '?'
@@ -194,7 +248,8 @@ class PgQuery
       # COUNT(*)
       args << '*' if node['agg_star']
 
-      output << format('%s(%s)', node['funcname'].join('.'), args.join(', '))
+      name = (node['funcname'] - ['pg_catalog']).join('.')
+      output << format('%s(%s)', name, args.join(', '))
       output << format('OVER (%s)', deparse_item(node['over'])) if node['over']
 
       output.join(' ')
@@ -241,11 +296,16 @@ class PgQuery
       output.join(' ')
     end
 
-    def deparse_aexpr(node)
+    def deparse_aexpr(node, context = false)
       output = []
-      output << deparse_item(node['lexpr'])
-      output << deparse_item(node['rexpr'])
-      output.join(' ' + node['name'][0] + ' ')
+      output << deparse_item(node['lexpr'], context || true)
+      output << deparse_item(node['rexpr'], context || true)
+      output = output.join(' ' + node['name'][0] + ' ')
+      if context
+        # This is a nested expression, add parentheses.
+        output = '(' + output + ')'
+      end
+      output
     end
 
     def deparse_aexpr_and(node)
@@ -273,6 +333,7 @@ class PgQuery
       output = []
       output << deparse_item(node['larg'])
       output << 'LEFT' if node['jointype'] == 1
+      output << 'CROSS' if node['jointype'] == 0 && node['quals'].nil?
       output << 'JOIN'
       output << deparse_item(node['rarg'])
 
@@ -347,19 +408,35 @@ class PgQuery
     def deparse_columndef(node)
       output = [node['colname']]
       output << deparse_item(node['typeName'])
+      if node['raw_default']
+        output << 'USING'
+        output << deparse_item(node['raw_default'])
+      end
       if node['constraints']
         output += node['constraints'].map do |item|
           deparse_item(item)
         end
       end
-      output.join(' ')
+      output.compact.join(' ')
     end
 
     def deparse_constraint(node)
       output = []
+      if node['conname']
+        output << 'CONSTRAINT'
+        output << node['conname']
+      end
       # NOT_NULL -> NOT NULL
       output << node['contype'].gsub('_', ' ')
-      output << deparse_item(node['raw_expr']) if node['raw_expr']
+
+      if node['raw_expr']
+        expression = deparse_item(node['raw_expr'])
+        # Unless it's simple, put parentheses around it
+        expression = '(' + expression + ')' if node['raw_expr'].keys == ['AEXPR']
+        output << expression
+      end
+      output << '(' + node['keys'].join(', ') + ')' if node['keys']
+      output << "USING INDEX #{node['indexname']}" if node['indexname']
       output.join(' ')
     end
 
@@ -487,6 +564,16 @@ class PgQuery
         end.join(', ')
       end
 
+      if node['limitCount']
+        output << 'LIMIT'
+        output << deparse_item(node['limitCount'])
+      end
+
+      if node['limitOffset']
+        output << 'OFFSET'
+        output << deparse_item(node['limitOffset'])
+      end
+
       output.join(' ')
     end
 
@@ -547,6 +634,10 @@ class PgQuery
     end
 
     def deparse_typename(node)
+      # Intervals are tricky and should be handled in a separate method because
+      # they require performing some bitmask operations.
+      return deparse_interval_type(node) if node['names'] == %w(pg_catalog interval)
+
       output = []
       output << 'SETOF' if node['setof']
 
@@ -555,7 +646,6 @@ class PgQuery
           deparse_item(item)
         end.join(', ')
       end
-
       output << deparse_typename_cast(node['names'], arguments)
 
       output.join(' ')
@@ -589,11 +679,39 @@ class PgQuery
         'real'
       when 'float8'
         'double'
+      when 'time'
+        'time'
+      when 'timetz'
+        'time with time zone'
+      when 'timestamp'
+        'timestamp'
+      when 'timestamptz'
+        'timestamp with time zone'
       else
         fail format("Can't deparse type: %s", type)
       end
     end
 
+    # Deparses interval type expressions like `interval year to month` or
+    # `interval hour to second(5)`
+    def deparse_interval_type(node)
+      type = ['interval']
+
+      if node['typmods']
+        typmods = node['typmods'].map { |typmod| deparse_item(typmod) }
+        type << Interval.from_int(typmods.first.to_i).map do |part|
+          # only the `second` type can take an argument.
+          if part == 'second' && typmods.size == 2
+            "second(#{typmods.last})"
+          else
+            part
+          end.downcase
+        end.join(' to ')
+      end
+
+      type.join(' ')
+    end
+
     def deparse_nulltest(node)
       output = [deparse_item(node['arg'])]
       if node['nulltesttype'] == 0
@@ -668,6 +786,19 @@ class PgQuery
       output.join(' ')
     end
 
+    def deparse_drop(node)
+      output = ['DROP']
+      output << 'TABLE' if node['removeType'] == 26
+      output << 'CONCURRENTLY' if node['concurrent']
+      output << 'IF EXISTS' if node['missing_ok']
+
+      output << node['objects'].join(', ')
+
+      output << 'CASCADE'  if node['behavior'] == 1
+
+      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)

data/lib/pg_query/deparse/alter_table.rb

@@ -0,0 +1,143 @@
+class PgQuery
+  module Deparse
+    module AlterTable
+      # Returns a list of strings of length one or length two. The first string
+      # will be placed before the column name and the second, if present, will be
+      # placed after.
+      #
+      # If node['subtype'] is the integer 4,
+      # Then the fifth ALTER_TABLE entry ('DropNotNull') will be selected
+      # And the return value of this method will be:
+      #
+      #   ['ALTER COLUMN', 'DROP NOT NULL']
+      #
+      # Which will be composed into the SQL as:
+      #
+      #   ALTER COLUMN {column_name} DROP NOT NULL
+      #
+      def self.commands(node)
+        action = ALTER_TABLE[ALTER_TABLE_COMMANDS[node['subtype']]]
+        PgQuery::Deparse.instance_exec(node, &action)
+      end
+
+      # From include/nodes/parsenodes.h:1455
+      #
+      # Many of these will not be implemented here as they'll never be part of
+      # valid SQL. We keep them all here in their original order because we look
+      # these values up by array index.
+      NOT_IMPLEMENTED = 'NotImplemented'
+      ALTER_TABLE = {
+        # add column
+        'AddColumn'                  => -> (_node) { ['ADD COLUMN'] },
+        # internal to commands/tablecmds.c
+        'AddColumnRecurse'           => -> (_node) { NotImplemented },
+        # implicitly via CREATE OR REPLACE VIEW
+        'AddColumnToView'            => -> (_node) { NotImplemented },
+        # alter column default
+        'ColumnDefault'              => -> (node) { ['ALTER COLUMN', node['def'] ? 'SET DEFAULT' : 'DROP DEFAULT'] },
+        # alter column drop not null
+        'DropNotNull'                => -> (_node) { ['ALTER COLUMN', 'DROP NOT NULL'] },
+        # alter column set not null
+        'SetNotNull'                 => -> (_node) { ['ALTER COLUMN', 'SET NOT NULL'] },
+        # alter column set statistics
+        'SetStatistics'              => -> (_node) { ['ALTER COLUMN', 'SET STATISTICS'] },
+        # alter column set ( options )
+        'SetOptions'                 => -> (_node) { ['ALTER COLUMN', 'SET'] },
+        # alter column reset ( options )
+        'ResetOptions'               => -> (_node) { ['ALTER COLUMN', 'RESET'] },
+        # alter column set storage
+        'SetStorage'                 => -> (_node) { ['ALTER COLUMN', 'SET STORAGE'] },
+        # drop column
+        'DropColumn'                 => -> (_node) { ['DROP'] },
+        # internal to commands/tablecmds.c
+        'DropColumnRecurse'          => -> (_node) { NotImplemented },
+        # add index
+        'AddIndex'                   => -> (_node) { ['ADD INDEX'] },
+        # internal to commands/tablecmds.c
+        'ReAddIndex'                 => -> (_node) { NotImplemented },
+        # add constraint
+        'AddConstraint'              => -> (_node) { ['ADD'] },
+        # internal to commands/tablecmds.c
+        'AddConstraintRecurse'       => -> (_node) { NotImplemented },
+        # internal to commands/tablecmds.c
+        'ReAddConstraint'            => -> (_node) { NotImplemented },
+        # alter constraint
+        'AlterConstraint'            => -> (_node) { ['ALTER CONSTRAINT'] },
+        # validate constraint
+        'ValidateConstraint'         => -> (_node) { ['VALIDATE CONSTRAINT'] },
+        # internal to commands/tablecmds.c
+        'ValidateConstraintRecurse'  => -> (_node) { NotImplemented },
+        # pre-processed add constraint (local in parser/parse_utilcmd.c)
+        'ProcessedConstraint'        => -> (_node) { NotImplemented },
+        # add constraint using existing index
+        'AddIndexConstraint'         => -> (_node) { NotImplemented },
+        # drop constraint
+        'DropConstraint'             => -> (_node) { ['DROP CONSTRAINT'] },
+        # internal to commands/tablecmds.c
+        'DropConstraintRecurse'      => -> (_node) { NotImplemented },
+        # alter column type
+        'AlterColumnType'            => -> (_node) { ['ALTER COLUMN', 'TYPE'] },
+        # alter column OPTIONS (...)
+        'AlterColumnGenericOptions'  => -> (_node) { ['ALTER COLUMN', 'OPTIONS'] },
+        # change owner
+        'ChangeOwner'                => -> (_node) { NotImplemented },
+        # CLUSTER ON
+        'ClusterOn'                  => -> (_node) { NotImplemented },
+        # SET WITHOUT CLUSTER
+        'DropCluster'                => -> (_node) { NotImplemented },
+        # SET WITH OIDS
+        'AddOids'                    => -> (_node) { NotImplemented },
+        # internal to commands/tablecmds.c
+        'AddOidsRecurse'             => -> (_node) { NotImplemented },
+        # SET WITHOUT OIDS
+        'DropOids'                   => -> (_node) { NotImplemented },
+        # SET TABLESPACE
+        'SetTableSpace'              => -> (_node) { NotImplemented },
+        # SET (...) -- AM specific parameters
+        'SetRelOptions'              => -> (_node) { NotImplemented },
+        # RESET (...) -- AM specific parameters
+        'ResetRelOptions'            => -> (_node) { NotImplemented },
+        # replace reloption list in its entirety
+        'ReplaceRelOptions'          => -> (_node) { NotImplemented },
+        # ENABLE TRIGGER name
+        'EnableTrig'                 => -> (_node) { NotImplemented },
+        # ENABLE ALWAYS TRIGGER name
+        'EnableAlwaysTrig'           => -> (_node) { NotImplemented },
+        # ENABLE REPLICA TRIGGER name
+        'EnableReplicaTrig'          => -> (_node) { NotImplemented },
+        # DISABLE TRIGGER name
+        'DisableTrig'                => -> (_node) { NotImplemented },
+        # ENABLE TRIGGER ALL
+        'EnableTrigAll'              => -> (_node) { NotImplemented },
+        # DISABLE TRIGGER ALL
+        'DisableTrigAll'             => -> (_node) { NotImplemented },
+        # ENABLE TRIGGER USER
+        'EnableTrigUser'             => -> (_node) { NotImplemented },
+        # DISABLE TRIGGER USER
+        'DisableTrigUser'            => -> (_node) { NotImplemented },
+        # ENABLE RULE name
+        'EnableRule'                 => -> (_node) { NotImplemented },
+        # ENABLE ALWAYS RULE name
+        'EnableAlwaysRule'           => -> (_node) { NotImplemented },
+        # ENABLE REPLICA RULE name
+        'EnableReplicaRule'          => -> (_node) { NotImplemented },
+        # DISABLE RULE name
+        'DisableRule'                => -> (_node) { NotImplemented },
+        # INHERIT parent
+        'AddInherit'                 => -> (_node) { NotImplemented },
+        # NO INHERIT parent
+        'DropInherit'                => -> (_node) { NotImplemented },
+        # OF <type_name>
+        'AddOf'                      => -> (_node) { NotImplemented },
+        # NOT OF
+        'DropOf'                     => -> (_node) { NotImplemented },
+        # REPLICA IDENTITY
+        'ReplicaIdentity'            => -> (_node) { NotImplemented },
+        # OPTIONS (...)
+        'GenericOptions'             => -> (_node) { NotImplemented }
+      }
+      # Relying on Ruby's hashes maintaining key sort order
+      ALTER_TABLE_COMMANDS = ALTER_TABLE.keys
+    end
+  end
+end

data/lib/pg_query/deparse/interval.rb

@@ -0,0 +1,105 @@
+class PgQuery
+  module Deparse
+    module Interval
+      # A type called 'interval hour to minute' is stored in a compressed way by
+      # simplifying 'hour to minute' to a simple integer. This integer is computed
+      # by looking up the arbitrary number (always a power of two) for 'hour' and
+      # the one for 'minute' and XORing them together.
+      #
+      # For example, when parsing "interval hour to minute":
+      #
+      #   HOUR_MASK = 10
+      #   MINUTE_MASK = 11
+      #   mask = (1 << 10) | (1 << 11)
+      #   mask = 1024 | 2048
+      #   mask =     (010000000000
+      #                   xor
+      #               100000000000)
+      #   mask =      110000000000
+      #   mask = 3072
+      #
+      #   Postgres will store this type as 'interval,3072'
+      #   We deparse it by simply reversing that process.
+      #
+      def self.from_int(int)
+        SQL_BY_MASK[int]
+      end
+
+      # From src/include/utils/datetime.h
+      # The number is the power of 2 used for the mask.
+      MASKS = {
+        0  => 'RESERV',
+        1  => 'MONTH',
+        2  => 'YEAR',
+        3  => 'DAY',
+        4  => 'JULIAN',
+        5  => 'TZ',
+        6  => 'DTZ',
+        7  => 'DYNTZ',
+        8  => 'IGNORE_DTF',
+        9  => 'AMPM',
+        10 => 'HOUR',
+        11 => 'MINUTE',
+        12 => 'SECOND',
+        13 => 'MILLISECOND',
+        14 => 'MICROSECOND',
+        15 => 'DOY',
+        16 => 'DOW',
+        17 => 'UNITS',
+        18 => 'ADBC',
+        19 => 'AGO',
+        20 => 'ABS_BEFORE',
+        21 => 'ABS_AFTER',
+        22 => 'ISODATE',
+        23 => 'ISOTIME',
+        24 => 'WEEK',
+        25 => 'DECADE',
+        26 => 'CENTURY',
+        27 => 'MILLENNIUM',
+        28 => 'DTZMOD'
+      }
+      KEYS = MASKS.invert
+
+      # Postgres stores the interval 'day second' as 'day hour minute second' so
+      # we need to reconstruct the sql with only the largest and smallest time
+      # values. Since the rules for this are hardcoded in the grammar (and the
+      # above list is not sorted in any sensible way) it makes sense to hardcode
+      # the patterns here, too.
+      #
+      #  This hash takes the form:
+      #
+      #      { (1 << 1) | (1 << 2) => 'year to month' }
+      #
+      #  Which is:
+      #
+      #      { 6 => 'year to month' }
+      #
+      SQL_BY_MASK = {
+        (1 << KEYS['YEAR'])     => %w(year),
+        (1 << KEYS['MONTH'])    => %w(month),
+        (1 << KEYS['DAY'])      => %w(day),
+        (1 << KEYS['HOUR'])     => %w(hour),
+        (1 << KEYS['MINUTE'])   => %w(minute),
+        (1 << KEYS['SECOND'])   => %w(second),
+        (1 << KEYS['YEAR'] |
+           1 << KEYS['MONTH'])  => %w(year month),
+        (1 << KEYS['DAY'] |
+           1 << KEYS['HOUR'])   => %w(day hour),
+        (1 << KEYS['DAY'] |
+           1 << KEYS['HOUR'] |
+           1 << KEYS['MINUTE']) => %w(day minute),
+        (1 << KEYS['DAY'] |
+           1 << KEYS['HOUR'] |
+           1 << KEYS['MINUTE'] |
+           1 << KEYS['SECOND']) => %w(day second),
+        (1 << KEYS['HOUR'] |
+           1 << KEYS['MINUTE']) => %w(hour minute),
+        (1 << KEYS['HOUR'] |
+           1 << KEYS['MINUTE'] |
+           1 << KEYS['SECOND']) => %w(hour second),
+        (1 << KEYS['MINUTE'] |
+           1 << KEYS['SECOND']) => %w(minute second)
+      }
+    end
+  end
+end

data/lib/pg_query/version.rb

@@ -1,3 +1,3 @@
 class PgQuery
-  VERSION = '0.6.3'
+  VERSION = '0.6.4'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pg_query
 version: !ruby/object:Gem::Version
-  version: 0.6.3
+  version: 0.6.4
 platform: ruby
 authors:
 - Lukas Fittl
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-21 00:00:00.000000000 Z
+date: 2015-10-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake-compiler
@@ -102,6 +102,8 @@ files:
 - ext/pg_query/pg_query_parse.c
 - lib/pg_query.rb
 - lib/pg_query/deparse.rb
+- lib/pg_query/deparse/alter_table.rb
+- lib/pg_query/deparse/interval.rb
 - lib/pg_query/filter_columns.rb
 - lib/pg_query/fingerprint.rb
 - lib/pg_query/param_refs.rb
@@ -134,9 +136,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: PostgreSQL query parsing and normalization library
 test_files: []
-has_rdoc: