arel_toolkit 0.1.0 → 0.2.0

data/lib/arel/extensions/select_statement.rb

@@ -0,0 +1,26 @@
+# rubocop:disable Naming/MethodName
+# rubocop:disable Naming/UncommunicativeMethodParamName
+
+module Arel
+  module Nodes
+    Arel::Nodes::SelectStatement.class_eval do
+      # For INSERT statements
+      attr_accessor :values_lists
+      attr_accessor :union
+      attr_writer :cores
+    end
+  end
+
+  module Visitors
+    class ToSql
+      alias old_visit_Nodes_SelectStatement visit_Arel_Nodes_SelectStatement
+      def visit_Arel_Nodes_SelectStatement(o, collector)
+        visit(o.union, collector) if o.union
+        old_visit_Nodes_SelectStatement(o, collector)
+      end
+    end
+  end
+end
+
+# rubocop:enable Naming/MethodName
+# rubocop:enable Naming/UncommunicativeMethodParamName

data/lib/arel/extensions/session_user.rb

@@ -0,0 +1,20 @@
+# rubocop:disable Naming/MethodName
+# rubocop:disable Naming/UncommunicativeMethodParamName
+
+module Arel
+  module Nodes
+    class SessionUser < Arel::Nodes::Node
+    end
+  end
+
+  module Visitors
+    class ToSql
+      def visit_Arel_Nodes_SessionUser(_o, collector)
+        collector << 'session_user'
+      end
+    end
+  end
+end
+
+# rubocop:enable Naming/MethodName
+# rubocop:enable Naming/UncommunicativeMethodParamName

data/lib/arel/extensions/set_to_default.rb

@@ -0,0 +1,21 @@
+# rubocop:disable Naming/MethodName
+# rubocop:disable Naming/UncommunicativeMethodParamName
+
+module Arel
+  module Nodes
+    # https://www.postgresql.org/docs/9.5/sql-insert.html
+    class SetToDefault < Arel::Nodes::Node
+    end
+  end
+
+  module Visitors
+    class ToSql
+      def visit_Arel_Nodes_SetToDefault(_o, collector)
+        collector << 'DEFAULT'
+      end
+    end
+  end
+end
+
+# rubocop:enable Naming/MethodName
+# rubocop:enable Naming/UncommunicativeMethodParamName

data/lib/arel/extensions/similar.rb

@@ -0,0 +1,32 @@
+# rubocop:disable Naming/MethodName
+# rubocop:disable Naming/UncommunicativeMethodParamName
+
+module Arel
+  module Nodes
+    # Postgres: https://www.postgresql.org/docs/9/functions-matching.html
+    class Similar < Arel::Nodes::Matches
+      def initialize(left, right, escape = nil)
+        super(left, right, escape, false)
+      end
+    end
+  end
+
+  module Visitors
+    class ToSql
+      def visit_Arel_Nodes_Similar(o, collector)
+        visit o.left, collector
+        collector << ' SIMILAR TO '
+        visit o.right, collector
+        if o.escape
+          collector << ' ESCAPE '
+          visit o.escape, collector
+        else
+          collector
+        end
+      end
+    end
+  end
+end
+
+# rubocop:enable Naming/MethodName
+# rubocop:enable Naming/UncommunicativeMethodParamName

data/lib/arel/extensions/square_root.rb

@@ -0,0 +1,10 @@
+module Arel
+  module Nodes
+    # https://www.postgresql.org/docs/9.4/functions-math.html
+    class SquareRoot < Arel::Nodes::UnaryOperation
+      def initialize(operand)
+        super('|/', operand)
+      end
+    end
+  end
+end

data/lib/arel/extensions/table.rb

@@ -0,0 +1,49 @@
+# rubocop:disable Naming/MethodName
+# rubocop:disable Naming/UncommunicativeMethodParamName
+# rubocop:disable Metrics/ParameterLists
+
+module Arel
+  module Nodes
+    Arel::Table.class_eval do
+      # postgres only: https://www.postgresql.org/docs/9.5/sql-select.html
+      attr_accessor :only
+      # postgres only: https://www.postgresql.org/docs/9.5/ddl-schemas.html
+      attr_accessor :schema_name
+      # postgres only: https://www.postgresql.org/docs/9.1/catalog-pg-class.html
+      attr_accessor :relpersistence
+
+      alias_method :old_initialize, :initialize
+      def initialize(
+        name,
+        as: nil,
+        type_caster: nil,
+        only: false,
+        schema_name: nil,
+        relpersistence: 'p'
+      )
+        @only = only
+        @schema_name = schema_name
+        @relpersistence = relpersistence
+
+        old_initialize(name, as: as, type_caster: type_caster)
+      end
+    end
+  end
+
+  module Visitors
+    class ToSql
+      alias old_visit_Arel_Table visit_Arel_Table
+      def visit_Arel_Table(o, collector)
+        collector << 'ONLY ' if o.only
+
+        collector << "\"#{o.schema_name}\"." if o.schema_name
+
+        old_visit_Arel_Table(o, collector)
+      end
+    end
+  end
+end
+
+# rubocop:enable Naming/MethodName
+# rubocop:enable Naming/UncommunicativeMethodParamName
+# rubocop:enable Metrics/ParameterLists

data/lib/arel/extensions/time_with_precision.rb

@@ -0,0 +1,13 @@
+module Arel
+  module Nodes
+    class TimeWithPrecision < Arel::Nodes::Node
+      attr_reader :precision
+
+      def initialize(precision: nil)
+        super()
+
+        @precision = precision
+      end
+    end
+  end
+end

data/lib/arel/extensions/type_cast.rb

@@ -0,0 +1,30 @@
+# rubocop:disable Naming/MethodName
+# rubocop:disable Naming/UncommunicativeMethodParamName
+
+module Arel
+  module Nodes
+    # Postgres: https://www.postgresql.org/docs/9.1/sql-expressions.html
+    class TypeCast < Arel::Nodes::Node
+      attr_reader :arg
+      attr_reader :type_name
+
+      def initialize(arg, type_name)
+        @arg = arg
+        @type_name = type_name
+      end
+    end
+  end
+
+  module Visitors
+    class ToSql
+      def visit_Arel_Nodes_TypeCast(o, collector)
+        visit o.arg, collector
+        collector << '::'
+        collector << o.type_name
+      end
+    end
+  end
+end
+
+# rubocop:enable Naming/MethodName
+# rubocop:enable Naming/UncommunicativeMethodParamName

data/lib/arel/extensions/unknown.rb

@@ -0,0 +1,20 @@
+# rubocop:disable Naming/MethodName
+# rubocop:disable Naming/UncommunicativeMethodParamName
+
+module Arel
+  module Nodes
+    class Unknown < Arel::Nodes::Node
+    end
+  end
+
+  module Visitors
+    class ToSql
+      def visit_Arel_Nodes_Unknown(_o, collector)
+        collector << 'UNKNOWN'
+      end
+    end
+  end
+end
+
+# rubocop:enable Naming/MethodName
+# rubocop:enable Naming/UncommunicativeMethodParamName

data/lib/arel/extensions/update_statement.rb

@@ -0,0 +1,63 @@
+# rubocop:disable Naming/MethodName
+# rubocop:disable Naming/UncommunicativeMethodParamName
+
+module Arel
+  module Nodes
+    # https://www.postgresql.org/docs/10/sql-update.html
+    Arel::Nodes::UpdateStatement.class_eval do
+      attr_accessor :with
+      attr_accessor :froms
+      attr_accessor :returning
+    end
+  end
+
+  module Visitors
+    class ToSql
+      # rubocop:disable Metrics/CyclomaticComplexity
+      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/PerceivedComplexity
+      def visit_Arel_Nodes_UpdateStatement(o, collector)
+        if o.with
+          collector = visit o.with, collector
+          collector << SPACE
+        end
+
+        wheres = if o.orders.empty? && o.limit.nil?
+                   o.wheres
+                 else
+                   [Nodes::In.new(o.key, [build_subselect(o.key, o)])]
+                 end
+
+        collector << 'UPDATE '
+        collector = visit o.relation, collector
+        unless o.values.empty?
+          collector << ' SET '
+          collector = inject_join o.values, collector, ', '
+        end
+
+        unless o.froms.empty?
+          collector << ' FROM '
+          collector = inject_join o.froms, collector, ', '
+        end
+
+        unless wheres.empty?
+          collector << ' WHERE '
+          collector = inject_join wheres, collector, ' AND '
+        end
+
+        unless o.returning.empty?
+          collector << ' RETURNING '
+          collector = inject_join o.returning, collector, ', '
+        end
+
+        collector
+      end
+      # rubocop:enable Metrics/AbcSize
+      # rubocop:enable Metrics/CyclomaticComplexity
+      # rubocop:enable Metrics/PerceivedComplexity
+    end
+  end
+end
+
+# rubocop:enable Naming/MethodName
+# rubocop:enable Naming/UncommunicativeMethodParamName

data/lib/arel/extensions/user.rb

@@ -0,0 +1,20 @@
+# rubocop:disable Naming/MethodName
+# rubocop:disable Naming/UncommunicativeMethodParamName
+
+module Arel
+  module Nodes
+    class User < Arel::Nodes::Node
+    end
+  end
+
+  module Visitors
+    class ToSql
+      def visit_Arel_Nodes_User(_o, collector)
+        collector << 'user'
+      end
+    end
+  end
+end
+
+# rubocop:enable Naming/MethodName
+# rubocop:enable Naming/UncommunicativeMethodParamName

data/lib/arel/extensions/with_ordinality.rb

@@ -0,0 +1,22 @@
+# rubocop:disable Naming/MethodName
+# rubocop:disable Naming/UncommunicativeMethodParamName
+
+module Arel
+  module Nodes
+    # Postgres: https://paquier.xyz/postgresql-2/postgres-9-4-feature-highlight-with-ordinality/
+    class WithOrdinality < Arel::Nodes::Unary
+    end
+  end
+
+  module Visitors
+    class ToSql
+      def visit_Arel_Nodes_WithOrdinality(o, collector)
+        visit o.expr, collector
+        collector << ' WITH ORDINALITY'
+      end
+    end
+  end
+end
+
+# rubocop:enable Naming/MethodName
+# rubocop:enable Naming/UncommunicativeMethodParamName

data/lib/arel/sql_to_arel.rb

@@ -0,0 +1,8 @@
+require 'arel/sql_to_arel/pg_query_visitor'
+require 'arel/sql_to_arel/unbound_column_reference'
+
+module Arel
+  def self.sql_to_arel(sql)
+    SqlToArel::PgQueryVisitor.new.accept(sql)
+  end
+end

data/lib/arel/sql_to_arel/frame_options.rb

@@ -0,0 +1,110 @@
+module Arel
+  module SqlToArel
+    class FrameOptions
+      class << self
+        def arel(frame_options, start_offset, end_offset)
+          frame_option_names = calculate_frame_option_names(frame_options)
+          return unless frame_option_names.include?('FRAMEOPTION_NONDEFAULT')
+
+          range_klass = if frame_option_names.include?('FRAMEOPTION_RANGE')
+                          Arel::Nodes::Range
+                        else
+                          Arel::Nodes::Rows
+                        end
+
+          start_node = calculate_frame_node(
+            'FRAMEOPTION_START_',
+            frame_option_names,
+            start_offset,
+          )
+          end_node = calculate_frame_node(
+            'FRAMEOPTION_END_',
+            frame_option_names,
+            end_offset,
+          )
+
+          if frame_option_names.include?('FRAMEOPTION_BETWEEN')
+            Arel::Nodes::Between.new(
+              range_klass.new,
+              Arel::Nodes::And.new([start_node, end_node]),
+            )
+          else
+            range_klass.new start_node
+          end
+        end
+
+        private
+
+        # always NONDEFAULT
+        # RANGE or ROWS
+        # mandatory BETWEEN
+        # RANGE only unbounded
+        # ROWS all
+        # https://github.com/postgres/postgres/blob/REL_10_1/src/include/nodes/parsenodes.h
+        FRAMEOPTIONS = {
+          'FRAMEOPTION_NONDEFAULT' => 0x00001,
+          'FRAMEOPTION_RANGE' => 0x00002,
+          'FRAMEOPTION_ROWS' => 0x00004,
+          'FRAMEOPTION_BETWEEN' => 0x00008,
+          'FRAMEOPTION_START_UNBOUNDED_PRECEDING' => 0x00010,
+          'FRAMEOPTION_END_UNBOUNDED_PRECEDING' => 0x00020,
+          'FRAMEOPTION_START_UNBOUNDED_FOLLOWING' => 0x00040,
+          'FRAMEOPTION_END_UNBOUNDED_FOLLOWING' => 0x00080,
+          'FRAMEOPTION_START_CURRENT_ROW' => 0x00100,
+          'FRAMEOPTION_END_CURRENT_ROW' => 0x00200,
+          'FRAMEOPTION_START_VALUE_PRECEDING' => 0x00400,
+          'FRAMEOPTION_END_VALUE_PRECEDING' => 0x00800,
+          'FRAMEOPTION_START_VALUE_FOLLOWING' => 0x01000,
+          'FRAMEOPTION_END_VALUE_FOLLOWING' => 0x02000
+        }.freeze
+
+        def biggest_detractable_number(number, candidates)
+          high_to_low_candidates = candidates.sort { |a, b| b <=> a }
+          high_to_low_candidates.find do |candidate|
+            number - candidate >= 0
+          end
+        end
+
+        def calculate_frame_option_names(frame_options, names = [])
+          return names if frame_options.zero?
+
+          number = biggest_detractable_number(frame_options, FRAMEOPTIONS.values)
+          name = FRAMEOPTIONS.key(number)
+          calculate_frame_option_names(
+            frame_options - number, names + [name]
+          )
+        end
+
+        def calculate_frame_node(pattern, frame_option_names, offset)
+          node_name = frame_option_names.select { |n| n.start_with?(pattern) }
+          raise "Don't know how to handle multiple nodes" if node_name.length > 1
+
+          node_name = node_name.first.gsub(/FRAMEOPTION_(START|END)_/, '')
+          name_to_node(node_name, offset)
+        end
+
+        def name_to_node(node_name, offset)
+          case node_name
+          when 'UNBOUNDED_PRECEDING'
+            Arel::Nodes::Preceding.new
+
+          when 'UNBOUNDED_FOLLOWING'
+            Arel::Nodes::Following.new
+
+          when 'CURRENT_ROW'
+            Arel::Nodes::CurrentRow.new
+
+          when 'VALUE_PRECEDING'
+            Arel::Nodes::Preceding.new offset
+
+          when 'VALUE_FOLLOWING'
+            Arel::Nodes::Following.new offset
+
+          else
+            raise "Unknown start / end frame node `#{node_name}`"
+          end
+        end
+      end
+    end
+  end
+end