arel_toolkit 0.2.0 → 0.3.0

data/lib/arel/middleware/postgresql_adapter.rb

@@ -0,0 +1,26 @@
+module Arel
+  module Middleware
+    module PostgreSQLAdapter
+      def initialize(*args)
+        Arel.middleware.none do
+          super(*args)
+        end
+      end
+
+      def execute(sql, name = nil)
+        sql = Arel::Middleware.current_chain.execute(sql)
+        super(sql, name)
+      end
+
+      def exec_no_cache(sql, name, binds)
+        sql = Arel::Middleware.current_chain.execute(sql, binds)
+        super(sql, name, binds)
+      end
+
+      def exec_cache(sql, name, binds)
+        sql = Arel::Middleware.current_chain.execute(sql, binds)
+        super(sql, name, binds)
+      end
+    end
+  end
+end

data/lib/arel/middleware/railtie.rb

@@ -0,0 +1,11 @@
+module Arel
+  module Middleware
+    class Railtie
+      def self.insert_postgresql
+        ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.prepend(
+          Arel::Middleware::PostgreSQLAdapter,
+        )
+      end
+    end
+  end
+end

data/lib/arel/middleware.rb

@@ -0,0 +1,23 @@
+require 'active_record'
+require_relative './middleware/railtie'
+require_relative './middleware/chain'
+require_relative './middleware/postgresql_adapter'
+
+module Arel
+  module Middleware
+    class << self
+      def current_chain
+        Thread.current[:arel_toolkit_middleware_current_chain] ||=
+          Arel::Middleware::Chain.new
+      end
+
+      def current_chain=(new_chain)
+        Thread.current[:arel_toolkit_middleware_current_chain] = new_chain
+      end
+    end
+  end
+
+  def self.middleware
+    Arel::Middleware.current_chain
+  end
+end

data/lib/arel/sql_formatter.rb

@@ -0,0 +1,59 @@
+module Arel
+  module Nodes
+    class Node
+      def to_formatted_sql(engine = Table.engine)
+        collector = Arel::Collectors::SQLString.new
+        Arel::SqlFormatter.new(engine.connection).accept self, collector
+        collector.value
+      end
+    end
+  end
+
+  class TreeManager
+    def to_formatted_sql(engine = Table.engine)
+      collector = Arel::Collectors::SQLString.new
+      Arel::SqlFormatter.new(engine.connection).accept @ast, collector
+      collector.value
+    end
+  end
+
+  class SqlFormatter < Arel::Visitors::PostgreSQL
+    def accept(object, collector)
+      super object, collector
+      collector << "\n"
+    end
+
+    private
+
+    # rubocop:disable Naming/MethodName
+    # rubocop:disable Naming/UncommunicativeMethodParamName
+    # rubocop:disable Metrics/AbcSize
+    def visit_Arel_Nodes_SelectCore(o, collector)
+      collector << "SELECT\n"
+
+      collector = maybe_visit o.top, collector
+
+      collector = maybe_visit o.set_quantifier, collector
+
+      collect_nodes_for(o.projections, collector, SPACE, ",\n")
+
+      if o.source && !o.source.empty?
+        collector << ' FROM '
+        collector = visit o.source, collector
+      end
+
+      collect_nodes_for o.wheres, collector, WHERE, AND
+      collect_nodes_for o.groups, collector, GROUP_BY
+      unless o.havings.empty?
+        collector << ' HAVING '
+        inject_join o.havings, collector, AND
+      end
+      collect_nodes_for o.windows, collector, WINDOW
+
+      collector
+    end
+    # rubocop:enable Metrics/AbcSize
+    # rubocop:enable Naming/MethodName
+    # rubocop:enable Naming/UncommunicativeMethodParamName
+  end
+end

data/lib/arel/sql_to_arel/error.rb

@@ -0,0 +1,6 @@
+module Arel
+  module SqlToArel
+    class Error < StandardError
+    end
+  end
+end

data/lib/arel/sql_to_arel/pg_query_visitor/frame_options.rb

@@ -0,0 +1,112 @@
+module Arel
+  module SqlToArel
+    class PgQueryVisitor
+      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
+end