pg_query 0.8.0 → 0.9.0

data/lib/pg_query/deparse/alter_table.rb

@@ -5,9 +5,8 @@ class PgQuery
       # 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:
+      # If node['subtype'] is the integer 4 (AT_DropNotNull),
+      # then return value of this method will be:
       #
       #   ['ALTER COLUMN', 'DROP NOT NULL']
       #
@@ -16,128 +15,28 @@ class PgQuery
       #   ALTER COLUMN {column_name} DROP NOT NULL
       #
       def self.commands(node)
-        action = ALTER_TABLE[ALTER_TABLE_COMMANDS[node['subtype']]]
+        action = ALTER_TABLE_TYPES_MAPPING[node['subtype']] || fail(format("Can't deparse: %s", node.inspect))
         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
+      ALTER_TABLE_TYPES_MAPPING = {
+        AT_AddColumn                 => -> (_node) { ['ADD COLUMN'] },
+        AT_ColumnDefault             => -> (node) { ['ALTER COLUMN', node['def'] ? 'SET DEFAULT' : 'DROP DEFAULT'] },
+        AT_DropNotNull               => -> (_node) { ['ALTER COLUMN', 'DROP NOT NULL'] },
+        AT_SetNotNull                => -> (_node) { ['ALTER COLUMN', 'SET NOT NULL'] },
+        AT_SetStatistics             => -> (_node) { ['ALTER COLUMN', 'SET STATISTICS'] },
+        AT_SetOptions                => -> (_node) { ['ALTER COLUMN', 'SET'] },
+        AT_ResetOptions              => -> (_node) { ['ALTER COLUMN', 'RESET'] },
+        AT_SetStorage                => -> (_node) { ['ALTER COLUMN', 'SET STORAGE'] },
+        AT_DropColumn                => -> (_node) { ['DROP'] },
+        AT_AddIndex                  => -> (_node) { ['ADD INDEX'] },
+        AT_AddConstraint             => -> (_node) { ['ADD'] },
+        AT_AlterConstraint           => -> (_node) { ['ALTER CONSTRAINT'] },
+        AT_ValidateConstraint        => -> (_node) { ['VALIDATE CONSTRAINT'] },
+        AT_DropConstraint            => -> (_node) { ['DROP CONSTRAINT'] },
+        AT_AlterColumnType           => -> (_node) { ['ALTER COLUMN', 'TYPE'] },
+        AT_AlterColumnGenericOptions => -> (_node) { ['ALTER COLUMN', 'OPTIONS'] }
+      }.freeze
     end
   end
 end

data/lib/pg_query/filter_columns.rb

@@ -7,67 +7,69 @@ class PgQuery
     load_tables_and_aliases! if @aliases.nil?
 
     # Get condition items from the parsetree
-    statements = @parsetree.dup
+    statements = @tree.dup
     condition_items = []
     filter_columns = []
     loop do
       statement = statements.shift
       if statement
-        if statement['SELECT']
-          if statement['SELECT']['op'] == 0
-            if statement['SELECT']['fromClause']
+        if statement[SELECT_STMT]
+          if statement[SELECT_STMT]['op'] == 0
+            if statement[SELECT_STMT][FROM_CLAUSE_FIELD]
               # FROM subselects
-              statement['SELECT']['fromClause'].each do |item|
-                next unless item['RANGESUBSELECT']
-                statements << item['RANGESUBSELECT']['subquery']
+              statement[SELECT_STMT][FROM_CLAUSE_FIELD].each do |item|
+                next unless item['RangeSubselect']
+                statements << item['RangeSubselect']['subquery']
               end
 
               # JOIN ON conditions
-              condition_items += conditions_from_join_clauses(statement['SELECT']['fromClause'])
+              condition_items += conditions_from_join_clauses(statement[SELECT_STMT][FROM_CLAUSE_FIELD])
             end
 
             # WHERE clause
-            condition_items << statement['SELECT']['whereClause'] if statement['SELECT']['whereClause']
+            condition_items << statement[SELECT_STMT]['whereClause'] if statement[SELECT_STMT]['whereClause']
 
             # CTEs
-            if statement['SELECT']['withClause']
-              statement['SELECT']['withClause']['WITHCLAUSE']['ctes'].each do |item|
-                statements << item['COMMONTABLEEXPR']['ctequery'] if item['COMMONTABLEEXPR']
+            if statement[SELECT_STMT]['withClause']
+              statement[SELECT_STMT]['withClause']['WithClause']['ctes'].each do |item|
+                statements << item['CommonTableExpr']['ctequery'] if item['CommonTableExpr']
               end
             end
-          elsif statement['SELECT']['op'] == 1
-            statements << statement['SELECT']['larg'] if statement['SELECT']['larg']
-            statements << statement['SELECT']['rarg'] if statement['SELECT']['rarg']
+          elsif statement[SELECT_STMT]['op'] == 1
+            statements << statement[SELECT_STMT]['larg'] if statement[SELECT_STMT]['larg']
+            statements << statement[SELECT_STMT]['rarg'] if statement[SELECT_STMT]['rarg']
           end
-        elsif statement['UPDATE']
-          condition_items << statement['UPDATE']['whereClause'] if statement['UPDATE']['whereClause']
-        elsif statement['DELETE FROM']
-          condition_items << statement['DELETE FROM']['whereClause'] if statement['DELETE FROM']['whereClause']
+        elsif statement['UpdateStmt']
+          condition_items << statement['UpdateStmt']['whereClause'] if statement['UpdateStmt']['whereClause']
+        elsif statement['DeleteStmt']
+          condition_items << statement['DeleteStmt']['whereClause'] if statement['DeleteStmt']['whereClause']
         end
       end
 
       # Process both JOIN and WHERE conditions here
       next_item = condition_items.shift
       if next_item
-        if next_item.keys[0].start_with?('AEXPR') || next_item['ANY']
+        if next_item[A_EXPR]
           %w(lexpr rexpr).each do |side|
             expr = next_item.values[0][side]
             next unless expr && expr.is_a?(Hash)
             condition_items << expr
           end
-        elsif next_item['ROW']
-          condition_items += next_item['ROW']['args']
-        elsif next_item['COLUMNREF']
-          column, table = next_item['COLUMNREF']['fields'].reverse
+        elsif next_item[BOOL_EXPR]
+          condition_items += next_item[BOOL_EXPR]['args']
+        elsif next_item[ROW_EXPR]
+          condition_items += next_item[ROW_EXPR]['args']
+        elsif next_item[COLUMN_REF]
+          column, table = next_item[COLUMN_REF]['fields'].map { |f| f['String']['str'] }.reverse
           filter_columns << [@aliases[table] || table, column]
-        elsif next_item['NULLTEST']
-          condition_items << next_item['NULLTEST']['arg']
-        elsif next_item['FUNCCALL']
+        elsif next_item[NULL_TEST]
+          condition_items << next_item[NULL_TEST]['arg']
+        elsif next_item[FUNC_CALL]
           # FIXME: This should actually be extracted as a funccall and be compared with those indices
-          condition_items += next_item['FUNCCALL']['args'] if next_item['FUNCCALL']['args']
-        elsif next_item['SUBLINK']
-          condition_items << next_item['SUBLINK']['testexpr']
-          statements << next_item['SUBLINK']['subselect']
+          condition_items += next_item[FUNC_CALL]['args'] if next_item[FUNC_CALL]['args']
+        elsif next_item[SUB_LINK]
+          condition_items << next_item[SUB_LINK]['testexpr']
+          statements << next_item[SUB_LINK]['subselect']
         end
       end
 
@@ -82,16 +84,16 @@ class PgQuery
   def conditions_from_join_clauses(from_clause)
     condition_items = []
     from_clause.each do |item|
-      next unless item['JOINEXPR']
+      next unless item[JOIN_EXPR]
 
-      joinexpr_items = [item['JOINEXPR']]
+      joinexpr_items = [item[JOIN_EXPR]]
       loop do
         next_item = joinexpr_items.shift
         break unless next_item
         condition_items << next_item['quals'] if next_item['quals']
         %w(larg rarg).each do |side|
-          next unless next_item[side]['JOINEXPR']
-          joinexpr_items << next_item[side]['JOINEXPR']
+          next unless next_item[side][JOIN_EXPR]
+          joinexpr_items << next_item[side][JOIN_EXPR]
         end
       end
     end

data/lib/pg_query/fingerprint.rb

@@ -1,37 +1,106 @@
 require 'digest'
 
 class PgQuery
-  def fingerprint # rubocop:disable Metrics/CyclomaticComplexity
-    normalized_parsetree = deep_dup(parsetree)
-
-    # First delete all simple elements and attributes that can be removed
-    treewalker! normalized_parsetree do |expr, k, v|
-      if v.is_a?(Hash) && %w(A_CONST ALIAS PARAMREF).include?(v.keys[0])
-        # Remove constants, aliases and param references from tree
-        expr[k] = nil
-      elsif k == 'location'
-        # Remove location info in order to ignore whitespace and target list ordering
-        expr.delete(k)
+  def fingerprint
+    hash = Digest::SHA1.new
+    fingerprint_tree(hash)
+    format('%02x', FINGERPRINT_VERSION) + hash.hexdigest
+  end
+
+  private
+
+  FINGERPRINT_VERSION = 1
+
+  class FingerprintSubHash
+    attr_reader :parts
+
+    def initialize
+      @parts = []
+    end
+
+    def update(part)
+      @parts << part
+    end
+
+    def flush_to(hash)
+      parts.each do |part|
+        hash.update part
       end
     end
+  end
+
+  def ignored_fingerprint_value?(val)
+    [nil, 0, false, [], ''].include?(val)
+  end
+
+  def fingerprint_value(val, hash, field_name, need_to_write_name)
+    return if ignored_fingerprint_value?(val)
+
+    subhash = FingerprintSubHash.new
+
+    if val.is_a?(Hash)
+      fingerprint_node(val, subhash, field_name)
+    elsif val.is_a?(Array)
+      fingerprint_list(val, subhash, field_name)
+    else
+      subhash.update val.to_s
+    end
+
+    return if subhash.parts.empty?
 
-    # Now remove all unnecessary info
-    treewalker! normalized_parsetree do |expr, k, v|
-      if k == 'AEXPR IN' && v.is_a?(Hash) && v['rexpr'].is_a?(Array)
-        # Compact identical IN list elements to one
-        v['rexpr'].uniq!
-      elsif k == 'targetList' && v.is_a?(Array)
-        # Remove SELECT target list names & ignore order
-        v.each { |v2| v2['RESTARGET']['name'] = nil if v2['RESTARGET'] } # Remove names
-        v.sort_by!(&:to_s)
-        expr[k] = v
-      elsif k == 'cols' && v.is_a?(Array)
-        # Ignore INSERT cols order
-        v.sort_by!(&:to_s)
-        expr[k] = v
+    hash.update(field_name) if need_to_write_name
+    subhash.flush_to(hash)
+  end
+
+  def fingerprint_node(node, hash, parent_field_name = nil) # rubocop:disable Metrics/CyclomaticComplexity
+    node_name = node.keys.first
+    return if [A_CONST, ALIAS, PARAM_REF, SET_TO_DEFAULT, INT_LIST, OID_LIST, NULL].include?(node_name)
+
+    hash.update node_name
+
+    node.values.first.sort_by { |k, _| k }.each do |field_name, val|
+      next if ignored_fingerprint_value?(val)
+
+      case field_name
+      when 'location'
+        next
+      when 'name'
+        next if node_name == RES_TARGET && parent_field_name == TARGET_LIST_FIELD
+        next if [PREPARE_STMT, EXECUTE_STMT, DEALLOCATE_STMT].include?(node_name)
+      when 'gid'
+        next if node_name == TRANSACTION_STMT
+      when 'options'
+        next if node_name == TRANSACTION_STMT
+      end
+
+      fingerprint_value(val, hash, field_name, true)
+    end
+  end
+
+  def fingerprint_list(values, hash, parent_field_name)
+    if [FROM_CLAUSE_FIELD, TARGET_LIST_FIELD, COLS_FIELD, REXPR_FIELD].include?(parent_field_name)
+      values_subhashes = values.map do |val|
+        subhash = FingerprintSubHash.new
+        fingerprint_value(val, subhash, parent_field_name, false)
+        subhash
+      end
+
+      values_subhashes.uniq!(&:parts)
+      values_subhashes.sort_by!(&:parts)
+
+      values_subhashes.each do |subhash|
+        subhash.flush_to(hash)
+      end
+    else
+      values.each do |val|
+        fingerprint_value(val, hash, parent_field_name, false)
       end
     end
+  end
 
-    Digest::SHA1.hexdigest(normalized_parsetree.to_s)
+  def fingerprint_tree(hash)
+    @tree.each do |node|
+      fingerprint_node(node, hash)
+    end
   end
 end

data/lib/pg_query/legacy_parsetree.rb

@@ -0,0 +1,128 @@
+class PgQuery
+  # Legacy parsetree from 0.7 and earlier versions - migrate to "tree" format if you can
+  def parsetree # rubocop:disable Metrics/CyclomaticComplexity
+    @parsetree ||= transform_nodes!(@tree) do |node|
+      key = node.keys[0]
+      new_key = LEGACY_NODE_NAMES[key] || key.upcase
+
+      case key
+      when A_CONST
+        transform_parsetree_a_const(node)
+      when A_EXPR
+        transform_string_list(node[A_EXPR]['name'])
+        new_key = LEGACY_A_EXPR_NAMES[node[A_EXPR]['kind']]
+        node[A_EXPR].delete('kind')
+      when COLUMN_REF
+        transform_string_list(node[COLUMN_REF]['fields'])
+      when CREATE_FUNCTION_STMT
+        transform_string_list(node[CREATE_FUNCTION_STMT]['funcname'])
+      when CREATE_TRIG_STMT
+        transform_string_list(node[CREATE_TRIG_STMT]['funcname'])
+      when CONSTRAINT
+        node[CONSTRAINT]['contype'] = LEGACY_CONSTRAINT_TYPES[node[CONSTRAINT]['contype']]
+        transform_string_list(node[CONSTRAINT]['keys'])
+      when COPY_STMT
+        transform_string_list(node[COPY_STMT]['attlist'])
+      when DEF_ELEM
+        node[DEF_ELEM]['arg'] = node[DEF_ELEM]['arg'][INTEGER]['ival'] if node[DEF_ELEM]['arg'].is_a?(Hash) && node[DEF_ELEM]['arg'].keys[0] == INTEGER
+        node[DEF_ELEM]['arg'] = node[DEF_ELEM]['arg'][STRING]['str'] if node[DEF_ELEM]['arg'].is_a?(Hash) && node[DEF_ELEM]['arg'].keys[0] == STRING
+        transform_string_list(node[DEF_ELEM]['arg']) if node[DEF_ELEM]['arg'].is_a?(Array)
+      when DROP_STMT
+        node[DROP_STMT]['objects'].each { |obj| transform_string_list(obj) }
+      when FUNC_CALL
+        transform_string_list(node[FUNC_CALL]['funcname'])
+      when GRANT_ROLE_STMT
+        transform_string_list(node[GRANT_ROLE_STMT]['grantee_roles'])
+      when TYPE_NAME
+        transform_string_list(node[TYPE_NAME]['names'])
+      end
+
+      node[new_key] = node.delete(key)
+    end
+  end
+
+  private
+
+  LEGACY_NODE_NAMES = {
+    SELECT_STMT => 'SELECT',
+    ALTER_TABLE_CMD => 'ALTER TABLE CMD',
+    ALTER_TABLE_STMT => 'ALTER TABLE',
+    CHECK_POINT_STMT => 'CHECKPOINT',
+    CREATE_SCHEMA_STMT => 'CREATE SCHEMA',
+    CREATE_TABLE_AS_STMT => 'CREATE TABLE AS',
+    COPY_STMT => 'COPY',
+    DELETE_STMT => 'DELETE FROM',
+    DROP_STMT => 'DROP',
+    INSERT_STMT => 'INSERT INTO',
+    EXPLAIN_STMT => 'EXPLAIN',
+    LOCK_STMT => 'LOCK',
+    TRANSACTION_STMT => 'TRANSACTION',
+    TRUNCATE_STMT => 'TRUNCATE',
+    UPDATE_STMT => 'UPDATE',
+    VACUUM_STMT => 'VACUUM',
+    VARIABLE_SET_STMT => 'SET',
+    VARIABLE_SHOW_STMT => 'SHOW'
+    # All others default to simply upper-casing the input name
+  }.freeze
+
+  LEGACY_A_EXPR_NAMES = {
+    AEXPR_OP => 'AEXPR',
+    # AEXPR_OP_ANY = 1           # normal operator
+    # AEXPR_OP_ALL = 2           # scalar op ALL (array)
+    # AEXPR_DISTINCT = 3         # IS DISTINCT FROM - name must be "="
+    # AEXPR_NULLIF = 4           # NULLIF - name must be "="
+    # AEXPR_OF = 5               # IS [NOT] OF - name must be "=" or "<>"
+    # AEXPR_IN = 6               # [NOT] IN - name must be "=" or "<>"
+    # AEXPR_LIKE = 7             # [NOT] LIKE - name must be "~~" or "!~~"
+    # AEXPR_ILIKE = 8            # [NOT] ILIKE - name must be "~~*" or "!~~*"
+    AEXPR_SIMILAR => 'AEXPR',
+    # AEXPR_BETWEEN = 10         # name must be "BETWEEN"
+    # AEXPR_NOT_BETWEEN = 11     # name must be "NOT BETWEEN"
+    # AEXPR_BETWEEN_SYM = 12     # name must be "BETWEEN SYMMETRIC"
+    # AEXPR_NOT_BETWEEN_SYM = 13 # name must be "NOT BETWEEN SYMMETRIC"
+    # AEXPR_PAREN = 14           # nameless dummy node for parentheses
+  }.freeze
+
+  LEGACY_CONSTRAINT_TYPES = {
+    # CONSTR_TYPE_NULL = 0 # not standard SQL, but a lot of people expect it
+    # CONSTR_TYPE_NOTNULL = 1
+    # CONSTR_TYPE_DEFAULT = 2
+    # CONSTR_TYPE_CHECK = 3
+    CONSTR_TYPE_PRIMARY => 'PRIMARY_KEY',
+    # CONSTR_TYPE_UNIQUE = 5
+    # CONSTR_TYPE_EXCLUSION = 6
+    # CONSTR_TYPE_FOREIGN = 7
+    # CONSTR_TYPE_ATTR_DEFERRABLE = 8 # attributes for previous constraint node
+    # CONSTR_TYPE_ATTR_NOT_DEFERRABLE = 9
+    # CONSTR_TYPE_ATTR_DEFERRED = 10
+    # CONSTR_TYPE_ATTR_IMMEDIATE = 11
+  }.freeze
+
+  def transform_parsetree_a_const(node)
+    type_key = node[A_CONST]['val'].keys[0]
+
+    case type_key
+    when INTEGER
+      node[A_CONST]['type'] = 'integer'
+      node[A_CONST]['val'] = node[A_CONST]['val'][INTEGER]['ival']
+    when STRING
+      node[A_CONST]['type'] = 'integer'
+      node[A_CONST]['val'] = node[A_CONST]['val'][STRING]['ival']
+    when FLOAT
+      node[A_CONST]['type'] = 'float'
+      node[A_CONST]['val'] = node[A_CONST]['val'][FLOAT]['str'].to_f
+    when BIT_STRING
+      node[A_CONST]['type'] = 'bitstring'
+      node[A_CONST]['val'] = node[A_CONST]['val'][BIT_STRING]['str']
+    when NULL
+      node[A_CONST]['type'] = 'null'
+      node[A_CONST]['val'] = nil
+    end
+  end
+
+  def transform_string_list(list)
+    return if list.nil?
+
+    list.map! { |node| node.keys[0] == STRING ? node[STRING]['str'] : node }
+  end
+end