arel_extensions 0.8.4 → 0.8.5

data/lib/arel_extensions/nodes/length.rb

@@ -1,6 +1,8 @@
 module ArelExtensions
   module Nodes
     class Length < Function
+      @@return_type = :integer
+
     end
   end
 end

data/lib/arel_extensions/nodes/rand.rb

@@ -2,6 +2,8 @@ module ArelExtensions
   module Nodes
     class Rand < Function
 
+      @@return_type = :number
+
       def initialize(seed = nil)
         if seed && seed.length == 1
           super seed
@@ -10,14 +12,6 @@ module ArelExtensions
         end
       end
 
-      def left
-        @expressions.first
-      end
-
-      def right
-        @expressions[1]
-      end
-
     end
   end
 end

data/lib/arel_extensions/version.rb

@@ -1,4 +1,4 @@
 # -*- encoding : utf-8 -*-
 module ArelExtensions
-  VERSION = "0.8.4".freeze
+  VERSION = "0.8.5".freeze
 end

data/lib/arel_extensions/visitors/ibm_db.rb

@@ -4,11 +4,7 @@ module ArelExtensions
 
       def visit_ArelExtensions_Nodes_Ceil o, collector
         collector << "CEILING("
-       if((o.expr).is_a?(Arel::Attributes::Attribute))
         collector = visit o.expr, collector
-      else
-          collector <<"#{o.expr}"
-       end
         collector << ")"
         collector
       end
@@ -35,28 +31,7 @@ module ArelExtensions
       end
 
 
-      def visit_ArelExtensions_Nodes_Coalesce o, collector
-        collector << "COALESCE("
-        if(o.left.is_a?(Arel::Attributes::Attribute))
-          collector = visit o.left, collector
-        else
-          collector << "#{o.left}"
-        end
-           o.other.each { |a|
-          collector << ","
-          if(a.is_a?(Arel::Attributes::Attribute))
-            collector = visit a, collector
-          else
-            collector << "#{a}"
-          end
-        }
-        collector << ")"
-        collector
-      end
-
-
       def visit_ArelExtensions_Nodes_DateDiff  o, collector
-
         collector << "DAY("
         collector = visit o.left, collector
         collector<< ","
@@ -92,11 +67,8 @@ module ArelExtensions
       end
 
 
-      def visit_ArelExtensions_Nodes_Findis o, collector
 
-      end
-
-      def visit_ArelExtensions_Nodes_Isnull o, collector
+      def visit_ArelExtensions_Nodes_IsNull o, collector
         collector << "COALESCE("
         collector = visit o.left, collector
         collector << ","
@@ -109,98 +81,6 @@ module ArelExtensions
         collector
       end
 
-
-      def visit_ArelExtensions_Nodes_Replace o, collector
-        collector << "REPLACE("
-        collector = visit o.expr,collector
-        collector << ","
-        if(o.left.is_a?(Arel::Attributes::Attribute))
-          collector = visit o.left, collector
-        else
-          collector << "'#{o.left}'"
-        end
-        collector << ","
-        if(o.right.is_a?(Arel::Attributes::Attribute))
-          collector = visit o.right, collector
-        else
-          collector << "'#{o.right}'"
-        end
-        collector <<")"
-        collector
-      end
-
-
-
-      def visit_ArelExtensions_Nodes_Soundex o, collector
-        collector << "SOUNDEX("
-       if((o.expr).is_a?(Arel::Attributes::Attribute))
-        collector = visit o.expr, collector
-      else
-          collector <<"'#{o.expr}'"
-       end
-        collector << ")"
-        collector
-      end
-
-
-      def visit_Arel_Nodes_Regexp o , collector
-        collector = visit o.left, collector
-        collector << " REGEXP "
-        collector << "'#{o.right}'"
-        collector
-      end
-
-
-
-      def visit_Arel_Nodes_NotRegexp o , collector
-        collector = visit o.left, collector
-        collector << " NOT REGEXP "
-        collector << "'#{o.right}'"
-        collector
-      end
-
-
-      def visit_ArelExtensions_Nodes_Trim o , collector
-          collector << "TRIM("
-        collector = visit o.left, collector
-        collector << ","
-        if(o.right.is_a?(Arel::Attributes::Attribute))
-          collector = visit o.right, collector
-        else
-          collector << "'#{o.right}'"
-        end
-        collector << ")"
-        collector
-      end
-
-      def visit_ArelExtensions_Nodes_Ltrim o , collector
-        collector << "LTRIM("
-        collector = visit o.left, collector
-        collector << ","
-        if(o.right.is_a?(Arel::Attributes::Attribute))
-          collector = visit o.right, collector
-        else
-          collector << "'#{o.right}'"
-        end
-        collector << ")"
-        collector
-      end
-
-
-      def visit_ArelExtensions_Nodes_Rtrim o , collector
-          collector << "RTRIM("
-        collector = visit o.left, collector
-        collector << ","
-        if(o.right.is_a?(Arel::Attributes::Attribute))
-          collector = visit o.right, collector
-        else
-          collector << "'#{o.right}'"
-        end
-        collector << ")"
-        collector
-      end
-
-
     end
   end
 end

data/lib/arel_extensions/visitors/mssql.rb

@@ -29,30 +29,10 @@ module ArelExtensions
         end
       end
 
-      def visit_ArelExtensions_Nodes_Coalesce o, collector
-        collector << "COALESCE("
-        if(o.left.is_a?(Arel::Attributes::Attribute))
-          collector = visit o.left, collector
-        else
-          collector << "#{o.left}"
-        end
-           o.other.each { |a|
-          collector << ","
-          if(a.is_a?(Arel::Attributes::Attribute))
-            collector = visit a, collector
-          else
-            collector << "#{a}"
-          end
-        }
-        collector << ")"
-        collector
-      end
-
       def visit_ArelExtensions_Nodes_DateDiff o, collector
-
-          collector << "DATEDIFF(day,"
-          collector = visit o.left, collector
-          collector<< ","
+        collector << "DATEDIFF(day,"
+        collector = visit o.left, collector
+        collector<< ","
         if(o.right.is_a?(Arel::Attributes::Attribute))
           collector = visit o.right, collector
         else
@@ -85,11 +65,6 @@ module ArelExtensions
         collector
       end
 
-
-     def visit_ArelExtensions_Nodes_Findis o,collector
-     end
-
-
      def visit_ArelExtensions_Nodes_Length o, collector
        collector << "LEN("
        collector = visit o.expr, collector
@@ -100,18 +75,14 @@ module ArelExtensions
 
      def visit_ArelExtensions_Nodes_Locate o, collector
        collector << "CHARINDEX("
-       if(o.val.is_a?(Arel::Attributes::Attribute))
-         collector = visit o.val, collector
-       else
-         collector << "'#{o.val}'"
-       end
+      collector = visit o.val, collector
        collector << ","
        collector = visit o.expr, collector
        collector << ")"
        collector
      end
 
-      def visit_ArelExtensions_Nodes_Isnull o, collector
+      def visit_ArelExtensions_Nodes_IsNull o, collector
         collector << "ISNULL("
         collector = visit o.left, collector
         collector << ","
@@ -157,57 +128,6 @@ module ArelExtensions
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Soundex o, collector
-        collector << "SOUNDEX("
-       if((o.expr).is_a?(Arel::Attributes::Attribute))
-        collector = visit o.expr, collector
-      else
-          collector << "'#{o.expr}'"
-       end
-        collector << ")"
-        collector
-      end
-
-      def visit_ArelExtensions_Nodes_Trim o , collector
-          collector << "TRIM("
-        collector = visit o.left, collector
-        collector << ","
-        if(o.right.is_a?(Arel::Attributes::Attribute))
-          collector = visit o.right, collector
-        else
-          collector << "'#{o.right}'"
-        end
-        collector << ")"
-        collector
-      end
-
-      def visit_ArelExtensions_Nodes_Ltrim o , collector
-          collector << "LTRIM("
-        collector = visit o.left, collector
-        collector << ","
-        if(o.right.is_a?(Arel::Attributes::Attribute))
-          collector = visit o.right, collector
-        else
-          collector << "'#{o.right}'"
-        end
-        collector << ")"
-        collector
-      end
-
-
-      def visit_ArelExtensions_Nodes_Rtrim o , collector
-          collector << "RTRIM("
-        collector = visit o.left, collector
-        collector << ","
-        if(o.right.is_a?(Arel::Attributes::Attribute))
-          collector = visit o.right, collector
-        else
-          collector << "'#{o.right}'"
-        end
-        collector << ")"
-        collector
-      end
-
     end
   end
 end

data/lib/arel_extensions/visitors/mysql.rb

@@ -1,6 +1,7 @@
 module ArelExtensions
   module Visitors
     Arel::Visitors::MySQL.class_eval do
+      Arel::Visitors::MySQL::DATE_MAPPING = {'d' => 'DAY', 'm' => 'MONTH', 'w' => 'WEEK', 'y' => 'YEAR', 'wd' => 'WEEKDAY'}
 
       #String functions
       def visit_ArelExtensions_Nodes_IMatches o, collector # insensitive on ASCII
@@ -94,23 +95,18 @@ module ArelExtensions
 
 
       def visit_ArelExtensions_Nodes_Duration o, collector
-        #visit left for period
-        if o.left == "d" 
-          collector << "DAY("
-        elsif(o.left == "m")
-          collector << "MONTH("
-        elsif (o.left == "w")
-          collector << "WEEK("
-        elsif (o.left == "y")
-          collector << "YEAR("
+        if o.left == 'wd'
+          collector << "(WEEKDAY("
+          collector = visit o.right, collector
+          collector << ") + 1) % 7"
+        else
+          collector << "#{Arel::Visitors::MySQL::DATE_MAPPING[o.left]}("
+          collector = visit o.right, collector
+          collector << ")"
         end
-        #visit right
-        collector = visit o.right, collector
-        collector << ")"
         collector
       end
 
-     #****************************************************************#
 
       def visit_ArelExtensions_Nodes_IsNull o, collector
         collector << "ISNULL("
@@ -123,18 +119,6 @@ module ArelExtensions
         collector
       end
 
-
-      def visit_ArelExtensions_Nodes_Replace o, collector
-        collector << "REPLACE("
-        o.expressions.each_with_index { |arg, i|
-          collector << Arel::Visitors::MySQL::COMMA unless i == 0
-          collector = visit arg, collector
-        }
-        collector << ")"
-        collector
-      end
-
-
       def visit_ArelExtensions_Nodes_Wday o, collector
         collector << "(WEEKDAY("
         collector = visit o.date, collector

data/lib/arel_extensions/visitors/oracle.rb

@@ -1,6 +1,17 @@
 module ArelExtensions
   module Visitors
     Arel::Visitors::Oracle.class_eval do
+      Arel::Visitors::Oracle::DATE_MAPPING = {'d' => 'DAY', 'm' => 'MONTH', 'w' => 'IW', 'y' => 'YEAR', 'wd' => 'D'}
+
+      def visit_ArelExtensions_Nodes_Concat o, collector
+        collector << '('
+        o.expressions.each_with_index { |arg, i|
+          collector = visit o.convert_to_string_node(arg), collector
+          collector << ' || ' unless i == o.expressions.length - 1
+        }
+        collector << ')'
+        collector
+      end
 
       def visit_ArelExtensions_Nodes_IMatches o, collector
         collector = visit o.left.lower, collector
@@ -27,170 +38,174 @@ module ArelExtensions
       end
 
       def visit_ArelExtensions_Nodes_GroupConcat o, collector
-        collector << "LISTAGG("
+        collector << "(LISTAGG("
         collector = visit o.left, collector
         if o.right
           collector << Arel::Visitors::Oracle::COMMA
           collector = visit o.right, collector
         end
-        collector << ")"
+        collector << ") WITHIN GROUP (ORDER BY "
+        collector = visit o.left, collector
+        collector << "))"
         collector
       end
 
       def visit_ArelExtensions_Nodes_Coalesce o, collector
         collector << "COALESCE("
-        collector = visit o.left, collector
-        o.other.each { |a|
-          collector << Arel::Visitors::Oracle::COMMA
-          collector = visit a, collector
+        o.expressions.each_with_index { |arg, i|
+          collector << Arel::Visitors::Oracle::COMMA unless i == 0
+          collector = visit arg, collector
         }
         collector << ")"
         collector
       end
 
-  def visit_ArelExtensions_Nodes_DateDiff o, collector
-    collector << '('
-    collector = visit o.left, collector
-    collector << " - "
-    collector = visit o.right, collector
-    collector << ')'
-    collector
-  end
-
+      def visit_ArelExtensions_Nodes_DateDiff o, collector
+        collector << '('
+        collector = visit o.left, collector
+        collector << " - "
+        collector = visit o.right, collector
+        collector << ')'
+        collector
+      end
 
-  def visit_ArelExtensions_Nodes_Duration o, collector
-    #visit left for period
-    if(o.left == "d")
-      collector << "DAY("
-    elsif(o.left == "m")
-      collector << "MONTH("
-    elsif (o.left == "w")
-      collector << "WEEK"
-    elsif (o.left == "y")
-      collector << "YEAR("
-    end
-    #visit right
-    collector = visit o.right, collector
-    collector << ")"
-    collector
-  end
+      def visit_ArelExtensions_Nodes_Duration o, collector
+        case o.left
+        when 'wd', 'w'
+          collector << "TO_CHAR("
+          collector = visit o.right, collector
+          collector << Arel::Visitors::Oracle::COMMA
+          collector = visit Arel::Nodes.build_quoted(Arel::Visitors::Oracle::DATE_MAPPING[o.left]), collector
+        else
+          collector << "EXTRACT(#{Arel::Visitors::Oracle::DATE_MAPPING[o.left]} FROM "
+          collector = visit o.right, collector
+        end
+        collector << ")"
+        collector
+      end
 
 
-  def visit_ArelExtensions_Nodes_Length o, collector
-    collector << "LENGTH("
-    collector = visit o.expr, collector
-    collector << ")"
-    collector
-  end
+      def visit_ArelExtensions_Nodes_Length o, collector
+        collector << "LENGTH("
+        collector = visit o.expr, collector
+        collector << ")"
+        collector
+      end
 
 
-  def visit_ArelExtensions_Nodes_IsNull o, collector
-    collector << "NVL("
-    collector = visit o.left, collector
-    collector << Arel::Visitors::Oracle::COMMA
-    collector = visit Arel::Nodes.build_quoted(true), collector
-    collector << ")"
-    collector
-  end
+      def visit_ArelExtensions_Nodes_IsNull o, collector
+        collector = visit o.left, collector
+        collector << ' IS NULL'
+        collector
+      end
 
-  def visit_ArelExtensions_Nodes_Rand o, collector
-    collector << "dbms_random.value("
-    if(o.left != nil && o.right != nil)
-      collector << "'#{o.left}'"
-      collector << Arel::Visitors::Oracle::COMMA
-      collector << "'#{o.right}'"
-    end
-    collector << ")"
-    collector
-  end
+      def visit_ArelExtensions_Nodes_Rand o, collector
+        collector << "DBMS_RANDOM.VALUE("
+        if(o.left != nil && o.right != nil)
+          collector = visit o.left, collector
+          collector << Arel::Visitors::Oracle::COMMA
+          collector = visit o.right, collector
+        end
+        collector << ")"
+        collector
+      end
 
-  def visit_ArelExtensions_Nodes_Replace o, collector
-    collector << "REPLACE("
-    collector = visit o.expr,collector
-    collector << Arel::Visitors::Oracle::COMMA
-    collector = visit o.left, collector
-    collector << Arel::Visitors::Oracle::COMMA
-    collector = visit o.right, collector
-    collector << ")"
-    collector
-  end
+      def visit_Arel_Nodes_Regexp o, collector
+        collector << " REGEXP_LIKE("
+        collector = visit o.left, collector
+        collector << Arel::Visitors::Oracle::COMMA
+        collector = visit o.right, collector
+        collector << ')'
+        collector
+      end
 
-    def visit_Arel_Nodes_Regexp o, collector
-      collector << " REGEXP_LIKE("
-      collector = visit o.left, collector
-      collector << Arel::Visitors::Oracle::COMMA
-      collector = visit o.right, collector
-      collector << ')'
-      collector
-    end
+      def visit_Arel_Nodes_NotRegexp o, collector
+        collector << " NOT REGEXP_LIKE("
+        collector = visit o.left, collector
+        collector << Arel::Visitors::Oracle::COMMA
+        collector = visit o.right, collector
+        collector << ')'
+        collector
+      end
 
+      def visit_ArelExtensions_Nodes_Soundex o, collector
+        collector << "SOUNDEX("
+        collector = visit o.expr, collector
+        collector << ")"
+        collector
+      end
 
-    def visit_Arel_Nodes_NotRegexp o, collector
-      collector << " NOT REGEXP_LIKE("
-      collector = visit o.left, collector
-      collector << Arel::Visitors::Oracle::COMMA
-      collector = visit o.right, collector
-      collector << ')'
-      collector
-    end
+      def visit_ArelExtensions_Nodes_Locate o, collector
+        collector << "INSTR("
+        o.expressions.each_with_index { |arg, i|
+          collector << Arel::Visitors::Oracle::COMMA unless i == 0
+          collector = visit arg, collector
+        }
+        collector << ")"
+        collector
+      end
 
-    def visit_ArelExtensions_Nodes_Soundex o, collector
-      collector << "SOUNDEX("
-      if((o.expr).is_a?(Arel::Attributes::Attribute))
-        collector = visit o.expr, collector
-      else
-        collector << "'#{o.expr}'"
+      def visit_ArelExtensions_Nodes_Trim o , collector
+        collector << 'TRIM(' # BOTH
+        collector = visit o.right, collector
+        collector << ' FROM '
+        collector = visit o.left, collector
+        collector << ")"
+        collector
       end
-      collector << ")"
-      collector
-    end
 
-    def visit_ArelExtensions_Nodes_Trim o , collector
-      collector << 'TRIM("BOTH"'
-      collector = visit o.left, collector
-      collector << ","
-      if(o.right.is_a?(Arel::Attributes::Attribute))
+      def visit_ArelExtensions_Nodes_Ltrim o, collector
+        collector << 'TRIM(LEADING '
         collector = visit o.right, collector
-      else
-        collector << "'#{o.right}'"
+        collector << ' FROM '
+        collector = visit o.left, collector
+        collector << ")"
+        collector
       end
-      collector << ")"
-      collector
-    end
 
-    def visit_ArelExtensions_Nodes_Ltrim o , collector
-      collector << 'TRIM("LEADING",'
-      collector = visit o.left, collector
-      collector << ","
-      if(o.right.is_a?(Arel::Attributes::Attribute))
+      def visit_ArelExtensions_Nodes_Rtrim o, collector
+        collector << 'TRIM(TRAILING '
         collector = visit o.right, collector
-      else
-        collector << "'#{o.right}'"
+        collector << ' FROM '
+        collector = visit o.left, collector
+        collector << ")"
+        collector
       end
-      collector << ")"
-      collector
-    end
 
+      def visit_ArelExtensions_Nodes_DateAdd o, collector
+        collector << '('
+        collector = visit o.left, collector
+        collector << (o.right.value >= 0 ? ' + ' : ' - ')
+        collector = visit o.oracle_value(o.right), collector
+        collector << ')'
+        collector
+      end
 
-    def visit_ArelExtensions_Nodes_Rtrim o , collector
-      collector << 'TRIM("TRAILING",'
-      collector = visit o.left, collector
-      collector << ","
-      if(o.right.is_a?(Arel::Attributes::Attribute))
-        collector = visit o.right, collector
-      else
-        collector << "'#{o.right}'"
+      def visit_ArelExtensions_Nodes_Format o, collector
+        case o.col_type
+        when :date, :datetime
+          collector << "TO_CHAR("
+          collector = visit o.left, collector
+          collector << Arel::Visitors::Oracle::COMMA unless i == 0
+          collector = visit o.right, collector
+          collector << ")"
+        when :integer, :float, :decimal
+          collector << "FORMAT("
+          collector = visit o.left, collector
+          collector << Arel::Visitors::Oracle::COMMA unless i == 0
+          collector = visit o.right, collector
+          collector << ")"
+        else
+          collector = visit o.left, collector
+        end
+        collector
       end
-      collector << ")"
-      collector
-    end
 
       def visit_ArelExtensions_InsertManager_BulkValues o, collector
         table = collector.value.sub(/\AINSERT INTO/, '')
         into = " INTO#{table}"
         collector = Arel::Collectors::SQLString.new
         collector << "INSERT ALL\n"
-  #      row_nb = o.left.length
         o.left.each_with_index do |row, idx|
           collector << "#{into} VALUES ("
           v = Arel::Nodes::Values.new(row, o.cols)