arel_toolkit 0.3.0 → 0.4.4

data/lib/arel/middleware/database_executor.rb

@@ -0,0 +1,77 @@
+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(arel, context, final_block)
+        @index = 0
+        @context = context
+        @final_block = final_block
+
+        result = call(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
+
+        context[:cache_accessor].write(
+          transformed_sql: sql,
+          transformed_binds: binds,
+          original_sql: context[:original_sql],
+          original_binds: context[:original_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/no_op_cache.rb

@@ -0,0 +1,9 @@
+module Arel
+  module Middleware
+    module NoOpCache
+      def self.read(key); end
+
+      def self.write(key, sql); 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

@@ -1,10 +1,24 @@
 module Arel
   module Middleware
+    if defined? Rails::Railtie
+      class Railtie < Rails::Railtie
+        initializer 'arel.middleware.insert' do
+          ActiveSupport.on_load :active_record do
+            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.rb

@@ -1,8 +1,11 @@
-require 'arel/sql_to_arel/result'
-require 'arel/sql_to_arel/error'
-require 'arel/sql_to_arel/pg_query_visitor'
+require_relative './sql_to_arel/result'
+require_relative './sql_to_arel/error'
+require_relative './sql_to_arel/pg_query_visitor'
 
 module Arel
+  module SqlToArel
+  end
+
   def self.sql_to_arel(sql, binds: [])
     SqlToArel::PgQueryVisitor.new.accept(sql, binds)
   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,18 +281,20 @@ module Arel
       end
 
       def visit_ColumnRef(fields:)
-        visited_fields = visit(fields)
+        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]
 
-        if fields.length == 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]
-        else
-          Arel::Nodes::UnboundColumnReference.new visited_fields.join('.')
-        end
+        return attribute if table
+
+        Arel::Nodes::UnqualifiedColumn.new Arel::Attribute.new(nil, column)
       end
 
       def visit_CommonTableExpr(ctename:, ctequery:)
@@ -360,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
 
@@ -423,11 +422,16 @@ module Arel
                  [Arel::Nodes::Overlaps.new(start1, end1, start2, end2)]
 
                else
-                 if function_names.length > 1
-                   boom "Don't know how to handle function names `#{function_names}`"
+                 case function_names.length
+                 when 2
+                   func = Arel::Nodes::NamedFunction.new(function_names.last, args)
+                   func.schema_name = function_names.first
+                   func
+                 when 1
+                   Arel::Nodes::NamedFunction.new(function_names.first, args)
+                 else
+                   boom "Don't know how to handle function names length `#{function_names.length}`"
                  end
-
-                 Arel::Nodes::NamedFunction.new(function_names.first, args)
                end
 
         func.distinct = (agg_distinct.nil? ? false : true) unless func.is_a?(::Array)
@@ -444,17 +448,16 @@ module Arel
       end
 
       def visit_InferClause(conname: nil, index_elems: nil)
-        infer = Arel::Nodes::Infer.new
-        infer.name = Arel.sql(conname) if conname
-        infer.indexes = visit(index_elems) if index_elems
-        infer
+        left = Arel.sql(conname) if conname
+        right = visit(index_elems) if index_elems
+        Arel::Nodes::Infer.new left, right
       end
 
       def visit_IndexElem(name:, ordering:, nulls_ordering:)
         boom "Unknown ordering `#{ordering}`" unless ordering.zero?
         boom "Unknown nulls ordering `#{ordering}`" unless nulls_ordering.zero?
 
-        Arel.sql(name)
+        Arel.sql visit_String(str: name)
       end
 
       def visit_InsertStmt(
@@ -494,6 +497,12 @@ module Arel
         ival
       end
 
+      def visit_IntoClause(rel:, on_commit:)
+        raise "Unknown on_commit `#{on_commit}`" unless on_commit.zero?
+
+        Arel::Nodes::Into.new(visit(rel))
+      end
+
       def visit_JoinExpr(jointype:, is_natural: nil, larg:, rarg:, quals: nil)
         join_class = case jointype
                      when 0
@@ -531,12 +540,12 @@ module Arel
           1 => 'FOR KEY SHARE',
           2 => 'FOR SHARE',
           3 => 'FOR NO KEY UPDATE',
-          4 => 'FOR UPDATE'
+          4 => 'FOR UPDATE',
         }.fetch(strength)
         wait_policy_clause = {
           0 => '',
           1 => ' SKIP LOCKED',
-          2 => ' NOWAIT'
+          2 => ' NOWAIT',
         }.fetch(wait_policy)
 
         Arel::Nodes::Lock.new Arel.sql("#{strength_clause}#{wait_policy_clause}")
@@ -584,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?
@@ -600,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
 
@@ -632,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
@@ -669,6 +684,7 @@ module Arel
         op:,
         window_clause: nil,
         values_lists: nil,
+        into_clause: nil,
         all: nil,
         larg: nil,
         rarg: nil
@@ -702,6 +718,8 @@ module Arel
         select_core.groups = visit(group_clause) if group_clause
         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
@@ -726,7 +744,7 @@ module Arel
                 value
               when Integer
                 Arel.sql(value.to_s)
-              when Arel::Nodes::TypeCast
+              when Arel::Nodes::TypeCast, Arel::Nodes::UnqualifiedColumn
                 Arel.sql(value.to_sql)
               when Arel::Nodes::BindParam
                 value
@@ -930,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
@@ -1077,6 +1098,14 @@ module Arel
         end
       end
 
+      def visit_DeallocateStmt(name: nil)
+        Arel::Nodes::Dealocate.new name
+      end
+
+      def visit_PrepareStmt(name:, argtypes: nil, query:)
+        Arel::Nodes::Prepare.new name, argtypes && visit(argtypes), visit(query)
+      end
+
       def visit(attribute, context = nil)
         return attribute.map { |attr| visit(attr, context) } if attribute.is_a? Array