gitlab-pg_query 1.3.0

data/lib/pg_query/deparse/alter_table.rb

@@ -0,0 +1,42 @@
+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

@@ -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'
+      }.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

@@ -0,0 +1,159 @@
+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

@@ -0,0 +1,41 @@
+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/filter_columns.rb

@@ -0,0 +1,107 @@
+class PgQuery
+  # Returns a list of columns that the query filters by - this excludes the
+  # target list, but includes things like JOIN condition and WHERE clause.
+  #
+  # Note: This also traverses into sub-selects.
+  def filter_columns # rubocop:disable Metrics/CyclomaticComplexity
+    load_tables_and_aliases! if @aliases.nil?
+
+    # Get condition items from the parsetree
+    statements = @tree.dup
+    condition_items = []
+    filter_columns = []
+    loop do
+      statement = statements.shift
+      if statement
+        if statement[RAW_STMT]
+          statements << statement[RAW_STMT][STMT_FIELD]
+        elsif statement[SELECT_STMT]
+          case statement[SELECT_STMT]['op']
+          when 0
+            if statement[SELECT_STMT][FROM_CLAUSE_FIELD]
+              # FROM subselects
+              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_STMT][FROM_CLAUSE_FIELD])
+            end
+
+            # WHERE clause
+            condition_items << statement[SELECT_STMT]['whereClause'] if statement[SELECT_STMT]['whereClause']
+
+            # CTEs
+            if statement[SELECT_STMT]['withClause']
+              statement[SELECT_STMT]['withClause']['WithClause']['ctes'].each do |item|
+                statements << item['CommonTableExpr']['ctequery'] if item['CommonTableExpr']
+              end
+            end
+          when 1
+            statements << statement[SELECT_STMT]['larg'] if statement[SELECT_STMT]['larg']
+            statements << statement[SELECT_STMT]['rarg'] if statement[SELECT_STMT]['rarg']
+          end
+        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[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[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[NULL_TEST]
+          condition_items << next_item[NULL_TEST]['arg']
+        elsif next_item[BOOLEAN_TEST]
+          condition_items << next_item[BOOLEAN_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[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
+
+      break if statements.empty? && condition_items.empty?
+    end
+
+    filter_columns.uniq
+  end
+
+  protected
+
+  def conditions_from_join_clauses(from_clause)
+    condition_items = []
+    from_clause.each do |item|
+      next unless item[JOIN_EXPR]
+
+      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][JOIN_EXPR]
+          joinexpr_items << next_item[side][JOIN_EXPR]
+        end
+      end
+    end
+    condition_items
+  end
+end