gitlab-pg_query 1.3.1 → 2.0.4

data/ext/pg_query/pg_query_ruby.h

@@ -1,10 +0,0 @@
-#ifndef PG_QUERY_RUBY_H
-#define PG_QUERY_RUBY_H
-
-#include "pg_query.h"
-
-#include <ruby.h>
-
-void Init_pg_query(void);
-
-#endif

data/lib/pg_query/deep_dup.rb

@@ -1,16 +0,0 @@
-class PgQuery
-  def deep_dup(obj)
-    case obj
-    when Hash
-      obj.each_with_object(obj.dup) do |(key, value), hash|
-        hash[deep_dup(key)] = deep_dup(value)
-      end
-    when Array
-      obj.map { |it| deep_dup(it) }
-    when NilClass, FalseClass, TrueClass, Symbol, Numeric
-      obj # Can't be duplicated
-    else
-      obj.dup
-    end
-  end
-end

data/lib/pg_query/deparse/alter_table.rb

@@ -1,42 +0,0 @@
-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 (AT_DropNotNull),
-      # then 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_TYPES_MAPPING[node['subtype']] || raise(format("Can't deparse: %s", node.inspect))
-        PgQuery::Deparse.instance_exec(node, &action)
-      end
-
-      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/deparse/interval.rb

@@ -1,105 +0,0 @@
-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'
-      }.freeze
-      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]
-      }.freeze
-    end
-  end
-end

data/lib/pg_query/deparse/keywords.rb

@@ -1,159 +0,0 @@
-class PgQuery
-  module Deparse # rubocop:disable Metrics/ModuleLength
-    # Keywords that need to be escaped during deparsing. This matches they keywords
-    # excaped by quote_identifier in Postgres ruleutils.c. You can refresh this
-    # list using the kwlist.h file (make sure to ignore UNRESERVED_KEYWORD entries)
-    KEYWORDS = %w[
-      ALL
-      ANALYSE
-      ANALYZE
-      AND
-      ANY
-      ARRAY
-      AS
-      ASC
-      ASYMMETRIC
-      AUTHORIZATION
-      BETWEEN
-      BIGINT
-      BINARY
-      BIT
-      BOOLEAN
-      BOTH
-      CASE
-      CAST
-      CHAR
-      CHARACTER
-      CHECK
-      COALESCE
-      COLLATE
-      COLLATION
-      COLUMN
-      CONCURRENTLY
-      CONSTRAINT
-      CREATE
-      CROSS
-      CURRENT_CATALOG
-      CURRENT_DATE
-      CURRENT_ROLE
-      CURRENT_SCHEMA
-      CURRENT_TIME
-      CURRENT_TIMESTAMP
-      CURRENT_USER
-      DEC
-      DECIMAL
-      DEFAULT
-      DEFERRABLE
-      DESC
-      DISTINCT
-      DO
-      ELSE
-      END
-      EXCEPT
-      EXISTS
-      EXTRACT
-      FALSE
-      FETCH
-      FLOAT
-      FOR
-      FOREIGN
-      FREEZE
-      FROM
-      FULL
-      GRANT
-      GREATEST
-      GROUP
-      GROUPING
-      HAVING
-      ILIKE
-      IN
-      INITIALLY
-      INNER
-      INOUT
-      INT
-      INTEGER
-      INTERSECT
-      INTERVAL
-      INTO
-      IS
-      ISNULL
-      JOIN
-      LATERAL
-      LEADING
-      LEAST
-      LEFT
-      LIKE
-      LIMIT
-      LOCALTIME
-      LOCALTIMESTAMP
-      NATIONAL
-      NATURAL
-      NCHAR
-      NONE
-      NOT
-      NOTNULL
-      NULL
-      NULLIF
-      NUMERIC
-      OFFSET
-      ON
-      ONLY
-      OR
-      ORDER
-      OUT
-      OUTER
-      OVERLAPS
-      OVERLAY
-      PLACING
-      POSITION
-      PRECISION
-      PRIMARY
-      REAL
-      REFERENCES
-      RETURNING
-      RIGHT
-      ROW
-      SELECT
-      SESSION_USER
-      SETOF
-      SIMILAR
-      SMALLINT
-      SOME
-      SUBSTRING
-      SYMMETRIC
-      TABLE
-      TABLESAMPLE
-      THEN
-      TIME
-      TIMESTAMP
-      TO
-      TRAILING
-      TREAT
-      TRIM
-      TRUE
-      UNION
-      UNIQUE
-      USER
-      USING
-      VALUES
-      VARCHAR
-      VARIADIC
-      VERBOSE
-      WHEN
-      WHERE
-      WINDOW
-      WITH
-      XMLATTRIBUTES
-      XMLCONCAT
-      XMLELEMENT
-      XMLEXISTS
-      XMLFOREST
-      XMLNAMESPACES
-      XMLPARSE
-      XMLPI
-      XMLROOT
-      XMLSERIALIZE
-      XMLTABLE
-    ].freeze
-  end
-end

data/lib/pg_query/deparse/rename.rb

@@ -1,41 +0,0 @@
-class PgQuery
-  module Deparse
-    module Rename
-      # relation, subname and object is the array key in the node.
-      # Array return five value. First is the type like a TRIGGER, TABLE, DOMAIN
-      # Other values may be parameter or SQL key.
-      #
-      # If node['renameType'] is the integer 13 (OBJECT_TYPE_DOMCONSTRAINT),
-      # then return value of this method will be:
-      #
-      #   %w[DOMAIN object RENAME CONSTRAINT subname]
-      #
-      # Which will be composed into the SQL as:
-      #
-      #   ALTER {type} {name} RENAME CONSTRAINT {subname} TO {newname}
-      #
-      def self.commands(node)
-        action = RENAME_MAPPING[node['renameType']] || raise(format("Can't deparse: %s", node.inspect))
-        PgQuery::Deparse.instance_exec(node, &action)
-      end
-
-      RENAME_MAPPING = {
-        OBJECT_TYPE_CONVERSION       => ->(_node) { %w[CONVERSION object RENAME] },
-        OBJECT_TYPE_TABLE            => ->(_node) { %w[TABLE relation RENAME] },
-        OBJECT_TYPE_TABCONSTRAINT    => ->(_node) { %w[TABLE relation RENAME CONSTRAINT subname] },
-        OBJECT_TYPE_INDEX            => ->(_node) { %w[INDEX relation RENAME] },
-        OBJECT_TYPE_MATVIEW          => ->(_node) { ['MATERIALIZED VIEW', 'relation', 'RENAME'] },
-        OBJECT_TYPE_TABLESPACE       => ->(_node) { %w[TABLESPACE subname RENAME] },
-        OBJECT_TYPE_VIEW             => ->(_node) { %w[VIEW relation RENAME] },
-        OBJECT_TYPE_COLUMN           => ->(_node) { %w[TABLE relation RENAME COLUMN subname] },
-        OBJECT_TYPE_COLLATION        => ->(_node) { %w[COLLATION object RENAME] },
-        OBJECT_TYPE_TYPE             => ->(_node) { %w[TYPE object RENAME] },
-        OBJECT_TYPE_DOMCONSTRAINT    => ->(_node) { %w[DOMAIN object RENAME CONSTRAINT subname] },
-        OBJECT_TYPE_RULE             => ->(_node) { %w[RULE subname ON relation RENAME] },
-        OBJECT_TYPE_TRIGGER          => ->(_node) { %w[TRIGGER subname ON relation RENAME] },
-        OBJECT_TYPE_AGGREGATE        => ->(_node) { %w[AGGREGATE object RENAME] },
-        OBJECT_TYPE_FUNCTION         => ->(_node) { %w[FUNCTION object RENAME] }
-      }.freeze
-    end
-  end
-end

data/lib/pg_query/legacy_parsetree.rb

@@ -1,109 +0,0 @@
-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 |raw_node|
-      node = raw_node.keys[0] == RAW_STMT ? raw_node.delete(RAW_STMT)[STMT_FIELD] : raw_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
-        node[A_EXPR]['name'] = transform_string_list(node[A_EXPR]['name'])
-        node[key].delete('kind')
-      when COLUMN_REF
-        node[COLUMN_REF]['fields'] = transform_string_list(node[COLUMN_REF]['fields'])
-      when CREATE_FUNCTION_STMT
-        node[CREATE_FUNCTION_STMT]['funcname'] = transform_string_list(node[CREATE_FUNCTION_STMT]['funcname'])
-      when CREATE_TRIG_STMT
-        node[CREATE_TRIG_STMT]['funcname'] = transform_string_list(node[CREATE_TRIG_STMT]['funcname'])
-      when CONSTRAINT
-        node[CONSTRAINT]['contype'] = LEGACY_CONSTRAINT_TYPES[node[CONSTRAINT]['contype']]
-        node[CONSTRAINT]['keys'] = transform_string_list(node[CONSTRAINT]['keys'])
-      when COPY_STMT
-        node[COPY_STMT]['attlist'] = 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
-        node[DEF_ELEM]['arg'] = transform_string_list(node[DEF_ELEM]['arg']) if node[DEF_ELEM]['arg'].is_a?(Array)
-      when DROP_STMT
-        node[DROP_STMT]['objects'].each_with_index do |obj, idx|
-          node[DROP_STMT]['objects'][idx] = transform_string_list(obj)
-        end
-      when FUNC_CALL
-        node[FUNC_CALL]['funcname'] = transform_string_list(node[FUNC_CALL]['funcname'])
-      when GRANT_ROLE_STMT
-        node[GRANT_ROLE_STMT]['grantee_roles'] = transform_string_list(node[GRANT_ROLE_STMT]['grantee_roles'])
-      when RANGE_VAR
-        node[RANGE_VAR]['inhOpt'] = node[RANGE_VAR].delete('inh') ? 2 : 0
-      when TYPE_NAME
-        node[TYPE_NAME]['names'] = transform_string_list(node[TYPE_NAME]['names'])
-      end
-
-      raw_node[new_key] = node.delete(key)
-    end
-  end
-
-  private
-
-  LEGACY_NODE_NAMES = {
-    A_EXPR => 'AEXPR',
-    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_CONSTRAINT_TYPES = {
-    CONSTR_TYPE_PRIMARY => 'PRIMARY_KEY'
-  }.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'] = 'string'
-      node[A_CONST]['val'] = node[A_CONST]['val'][STRING]['str']
-    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?
-
-    if list.is_a?(Array)
-      list.map { |node| node.keys[0] == STRING ? node[STRING]['str'] : node }
-    else
-      [list.keys[0] == STRING ? list[STRING]['str'] : list]
-    end
-  end
-end