arel_toolkit 0.4.0 → 0.4.1

data/lib/arel/middleware/database_executor.rb

@@ -0,0 +1,68 @@
+module Arel
+  module Middleware
+    class DatabaseExecutor
+      attr_reader :middleware
+
+      attr_accessor :index
+      attr_reader :context
+      attr_reader :final_block
+
+      def initialize(middleware)
+        @middleware = middleware
+      end
+
+      def run(enhanced_arel, context, final_block)
+        @index = 0
+        @context = context
+        @final_block = final_block
+
+        result = call(enhanced_arel)
+        check_return_type result
+        result
+      ensure
+        @index = 0
+        @context = nil
+        @final_block = nil
+      end
+
+      def call(next_arel)
+        check_argument_type next_arel
+
+        current_middleware = middleware[index]
+
+        return execute_sql(next_arel) if current_middleware.nil?
+
+        self.index += 1
+
+        case current_middleware.method(:call).arity
+        when 2
+          current_middleware.call(next_arel, self)
+        else
+          current_middleware.call(next_arel, self, context.dup)
+        end
+      end
+
+      private
+
+      def execute_sql(next_arel)
+        sql, binds = next_arel.to_sql_and_binds
+        sql_result = final_block.call(sql, binds)
+        check_return_type sql_result
+        sql_result
+      end
+
+      def check_argument_type(next_arel)
+        return if next_arel.is_a?(Arel::Enhance::Node)
+
+        raise "Only `Arel::Enhance::Node` is valid for middleware, passed `#{next_arel.class}`"
+      end
+
+      def check_return_type(return_object)
+        return if return_object.is_a?(Arel::Middleware::Result)
+
+        raise 'Object returned from middleware needs to be wrapped in `Arel::Middleware::Result`' \
+              " for object `#{return_object}`"
+      end
+    end
+  end
+end

data/lib/arel/middleware/postgresql_adapter.rb

@@ -8,18 +8,54 @@ module Arel
       end
 
       def execute(sql, name = nil)
-        sql = Arel::Middleware.current_chain.execute(sql)
         super(sql, name)
       end
 
+      alias parent_execute execute
+
+      # rubocop:disable Lint/DuplicateMethods
+      def execute(sql, name = nil)
+        Arel::Middleware.current_chain.execute(sql) do |processed_sql|
+          Arel::Middleware::Result.create(
+            data: parent_execute(processed_sql, name),
+            from: Arel::Middleware::PGResult,
+            to: Arel::Middleware::PGResult,
+          )
+        end
+      end
+      # rubocop:enable Lint/DuplicateMethods
+
+      def query(sql, name = nil)
+        Arel::Middleware.current_chain.execute(sql) do |processed_sql|
+          # NOTE: we're not calling `super` here, but execute.
+          # The `query` super does not return the columns, like the other methods.
+          # As we want the result objects to be the same, we call execute instead.
+          Arel::Middleware::Result.create(
+            data: parent_execute(processed_sql, name),
+            from: Arel::Middleware::PGResult,
+            to: Arel::Middleware::ArrayResult,
+          )
+        end
+      end
+
       def exec_no_cache(sql, name, binds)
-        sql = Arel::Middleware.current_chain.execute(sql, binds)
-        super(sql, name, binds)
+        Arel::Middleware.current_chain.execute(sql, binds) do |processed_sql, processed_binds|
+          Arel::Middleware::Result.create(
+            data: super(processed_sql, name, processed_binds),
+            from: Arel::Middleware::PGResult,
+            to: Arel::Middleware::PGResult,
+          )
+        end
       end
 
       def exec_cache(sql, name, binds)
-        sql = Arel::Middleware.current_chain.execute(sql, binds)
-        super(sql, name, binds)
+        Arel::Middleware.current_chain.execute(sql, binds) do |processed_sql, processed_binds|
+          Arel::Middleware::Result.create(
+            data: super(processed_sql, name, processed_binds),
+            from: Arel::Middleware::PGResult,
+            to: Arel::Middleware::PGResult,
+          )
+        end
       end
     end
   end

data/lib/arel/middleware/railtie.rb

@@ -4,17 +4,21 @@ module Arel
       class Railtie < Rails::Railtie
         initializer 'arel.middleware.insert' do
           ActiveSupport.on_load :active_record do
-            Arel::Middleware::Railtie.insert_postgresql
+            Arel::Middleware::Railtie.insert
           end
         end
       end
     end
 
     class Railtie
-      def self.insert_postgresql
+      def self.insert
         ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.prepend(
           Arel::Middleware::PostgreSQLAdapter,
         )
+
+        ActiveRecord::Base.singleton_class.prepend(
+          Arel::Middleware::ActiveRecordExtension,
+        )
       end
     end
   end

data/lib/arel/middleware/result.rb

@@ -0,0 +1,170 @@
+module Arel
+  module Middleware
+    class Column
+      attr_reader :name
+      attr_reader :metadata
+
+      def initialize(name, metadata)
+        @name = name
+        @metadata = metadata
+      end
+    end
+
+    # Class is very similar to ActiveRecord::Result
+    # activerecord/lib/active_record/result.rb
+    class Result
+      attr_reader :original_data
+
+      def self.create(from:, to:, data:)
+        Result.new from, to, data
+      end
+
+      def initialize(from_caster, to_caster, original_data)
+        @from_caster = from_caster
+        @to_caster = to_caster
+        @original_data = original_data
+        @modified = false
+      end
+
+      def columns
+        @columns ||= column_objects.map(&:name)
+      end
+
+      def column_objects
+        @column_objects ||= from_caster.column_objects(original_data)
+      end
+
+      def rows
+        @rows ||= from_caster.rows(original_data)
+      end
+
+      def remove_column(column_name)
+        column_index = columns.index(column_name)
+        raise "Unknown column `#{column_name}`. Existing columns: `#{columns}`" if column_index.nil?
+
+        @hash_rows = nil
+        @columns = nil
+        @modified = true
+
+        column_objects.delete_at(column_index)
+        deleted_rows = []
+
+        rows.map! do |row|
+          deleted_rows << row.delete_at(column_index)
+          row
+        end
+
+        deleted_rows
+      end
+
+      def hash_rows
+        @hash_rows ||=
+          begin
+            rows.map do |row|
+              hash = {}
+
+              index = 0
+              length = columns.length
+
+              while index < length
+                hash[columns[index]] = row[index]
+                index += 1
+              end
+
+              hash
+            end
+          end
+      end
+
+      def to_casted_result
+        to_caster.cast_to(self)
+      end
+
+      def modified?
+        @modified
+      end
+
+      private
+
+      attr_reader :to_caster, :from_caster
+    end
+
+    class PGResult
+      class << self
+        def column_objects(pg_result)
+          pg_result.fields.each_with_index.map do |field, index|
+            Column.new(
+              field,
+              tableid: pg_result.ftable(index),
+              columnid: pg_result.ftablecol(index),
+              format: pg_result.fformat(index),
+              typid: pg_result.ftype(index),
+              typlen: pg_result.fsize(index),
+              atttypmod: pg_result.fmod(index),
+            )
+          end
+        end
+
+        def rows(data)
+          data.values
+        end
+
+        def cast_to(result)
+          return result.original_data unless result.modified?
+
+          pg_columns = result_to_columns(result)
+          conn = ActiveRecord::Base.connection.raw_connection
+          new_result = PgResultInit.create(conn, result.original_data, pg_columns, result.rows)
+          result.original_data.clear
+          new_result
+        end
+
+        private
+
+        def result_to_columns(result)
+          result.column_objects.map do |column|
+            {
+              name: column.name,
+              tableid: column.metadata.fetch(:tableid, 0),
+              columnid: column.metadata.fetch(:columnid, 0),
+              format: column.metadata.fetch(:format, 0),
+              typid: column.metadata.fetch(:typid),
+              typlen: column.metadata.fetch(:typlen),
+              atttypmod: column.metadata.fetch(:atttypmod, -1),
+            }
+          end
+        end
+      end
+    end
+
+    class EmptyPGResult < PGResult
+      class << self
+        def cast_to(_result)
+          ActiveRecord::Base.connection.raw_connection.make_empty_pgresult(2)
+        end
+      end
+    end
+
+    class ArrayResult
+      def self.cast_to(result)
+        result.rows
+      end
+    end
+
+    class StringResult
+      class << self
+        def column_objects(_string)
+          []
+        end
+
+        def rows(_string)
+          []
+        end
+
+        def cast_to(result)
+          result.original_data
+        end
+      end
+    end
+  end
+end

data/lib/arel/middleware/to_sql_executor.rb

@@ -0,0 +1,15 @@
+module Arel
+  module Middleware
+    class ToSqlExecutor < DatabaseExecutor
+      private
+
+      def execute_sql(next_arel)
+        Arel::Middleware::Result.create(
+          data: next_arel.to_sql,
+          from: Arel::Middleware::StringResult,
+          to: Arel::Middleware::EmptyPGResult,
+        )
+      end
+    end
+  end
+end

data/lib/arel/middleware/to_sql_middleware.rb

@@ -0,0 +1,33 @@
+module Arel
+  module Middleware
+    class ToSqlMiddleware
+      attr_reader :sql, :type, :query_class
+
+      def initialize(type)
+        @sql = []
+        @type = type
+        @query_class = class_from_type
+      end
+
+      def call(next_arel, next_middleware)
+        sql << next_arel.to_sql unless next_arel.query(class: query_class).empty?
+        next_middleware.call(next_arel)
+      end
+
+      private
+
+      def class_from_type
+        case type
+        when :insert
+          Arel::Nodes::InsertStatement
+        when :select
+          Arel::Nodes::SelectStatement
+        when :update
+          Arel::Nodes::UpdateStatement
+        when :delete
+          Arel::Nodes::DeleteStatement
+        end
+      end
+    end
+  end
+end

data/lib/arel/sql_to_arel/pg_query_visitor.rb

@@ -26,6 +26,9 @@ module Arel
         @sql = sql
 
         Result.new visit(object, :top)
+      rescue ::PgQuery::ParseError => e
+        new_error = ::PgQuery::ParseError.new(e.message, __FILE__, __LINE__, -1)
+        raise new_error, e.message, e.backtrace
       rescue ::StandardError => e
         raise e.class, e.message, e.backtrace if e.is_a?(Arel::SqlToArel::Error)
 
@@ -192,7 +195,7 @@ module Arel
       end
 
       def visit_Alias(aliasname:)
-        aliasname
+        Arel.sql visit_String(nil, str: aliasname)
       end
 
       def visit_BitString(str:)
@@ -278,22 +281,20 @@ module Arel
       end
 
       def visit_ColumnRef(fields:)
-        case fields.length
-        when 1
-          visited_field = visit(fields[0], :operator)
-          Arel::Nodes::UnqualifiedColumn.new Arel::Attribute.new(nil, visited_field)
+        fields = fields.reverse
+        column = visit(fields[0], :operator)
+        table = visit(fields[1], :operator) if fields[1]
+        schema_name = visit(fields[2], :operator) if fields[2]
+        database = visit(fields[3], :operator) if fields[3]
 
-        when 2
-          table_reference, column_reference = fields
-          table_reference = visit(table_reference, :operator)
-          table = Arel::Table.new(table_reference)
+        table = Arel::Table.new(table) if table
+        attribute = Arel::Attribute.new(table, column)
+        attribute.schema_name = schema_name
+        attribute.database = database
 
-          column_reference = visit(column_reference, :operator)
-          table[column_reference]
+        return attribute if table
 
-        else
-          raise 'Can\'t deal with column refs that have more than 2 fields'
-        end
+        Arel::Nodes::UnqualifiedColumn.new Arel::Attribute.new(nil, column)
       end
 
       def visit_CommonTableExpr(ctename:, ctequery:)
@@ -364,15 +365,9 @@ module Arel
                when ['sum']
                  Arel::Nodes::Sum.new args
 
-               when ['rank']
-                 Arel::Nodes::Rank.new args
-
                when ['count']
                  Arel::Nodes::Count.new args
 
-               when ['generate_series']
-                 Arel::Nodes::GenerateSeries.new args
-
                when ['max']
                  Arel::Nodes::Max.new args
 
@@ -429,10 +424,6 @@ module Arel
                else
                  case function_names.length
                  when 2
-                   if function_names.first == PG_CATALOG
-                     boom "Missing postgres function `#{function_names.last}`"
-                   end
-
                    func = Arel::Nodes::NamedFunction.new(function_names.last, args)
                    func.schema_name = function_names.first
                    func
@@ -602,15 +593,19 @@ module Arel
         conflict
       end
 
-      def visit_ParamRef(number:)
+      def visit_ParamRef(number: nil)
         value = (binds[number - 1] unless binds.empty?)
 
         Arel::Nodes::BindParam.new(value)
       end
 
-      def visit_RangeFunction(is_rowsfrom:, functions:, lateral: false, ordinality: false)
-        boom 'https://github.com/mvgijssel/arel_toolkit/issues/36' unless is_rowsfrom == true
-
+      def visit_RangeFunction(
+        is_rowsfrom: nil,
+        functions:,
+        lateral: false,
+        ordinality: false,
+        aliaz: nil
+      )
         functions = functions.map do |function_array|
           function, empty_value = function_array
           boom 'https://github.com/mvgijssel/arel_toolkit/issues/37' unless empty_value.nil?
@@ -618,15 +613,16 @@ module Arel
           visit(function)
         end
 
-        node = Arel::Nodes::RangeFunction.new functions
+        node = Arel::Nodes::RangeFunction.new functions, is_rowsfrom: is_rowsfrom
         node = lateral ? Arel::Nodes::Lateral.new(node) : node
-        ordinality ? Arel::Nodes::WithOrdinality.new(node) : node
+        node = ordinality ? Arel::Nodes::WithOrdinality.new(node) : node
+        aliaz.nil? ? node : Arel::Nodes::As.new(node, visit(aliaz))
       end
 
       def visit_RangeSubselect(aliaz:, subquery:, lateral: false)
         aliaz = visit(aliaz)
         subquery = visit(subquery)
-        node = Arel::Nodes::TableAlias.new(Arel::Nodes::Grouping.new(subquery), aliaz)
+        node = Arel::Nodes::As.new(Arel::Nodes::Grouping.new(subquery), aliaz)
         lateral ? Arel::Nodes::Lateral.new(node) : node
       end
 
@@ -650,7 +646,8 @@ module Arel
           val = visit(val)
 
           if name
-            Arel::Nodes::As.new(val, Arel.sql(name))
+            aliaz = visit_Alias(aliasname: name)
+            Arel::Nodes::As.new(val, aliaz)
           else
             val
           end
@@ -722,6 +719,7 @@ module Arel
         select_core.havings = [visit(having_clause)] if having_clause
         select_core.windows = visit(window_clause) if window_clause
         select_core.into = visit(into_clause) if into_clause
+        select_core.top = ::Arel::Nodes::Top.new visit(limit_count) if limit_count
 
         if distinct_clause == [nil]
           select_core.set_quantifier = Arel::Nodes::Distinct.new
@@ -950,8 +948,11 @@ module Arel
         start_offset: nil,
         end_offset: nil
       )
-        instance = name.nil? ? Arel::Nodes::Window.new : Arel::Nodes::NamedWindow.new(name)
+        if name.present? && partition_clause.empty? && order_clause.empty?
+          return Arel::Nodes::SqlLiteral.new(name)
+        end
 
+        instance = name.nil? ? Arel::Nodes::Window.new : Arel::Nodes::NamedWindow.new(name)
         instance.tap do |window|
           window.orders = visit order_clause
           window.partitions = visit partition_clause