arel_extensions 0.8.3 → 0.8.4

data/lib/arel_extensions/visitors/postgresql.rb

@@ -2,102 +2,22 @@ module ArelExtensions
   module Visitors
     Arel::Visitors::PostgreSQL.class_eval do
 
-      def visit_ArelExtensions_Nodes_DateDiff o, collector
-
-        collector = visit o.left, collector
-        collector << " -"
-        if(o.right.is_a?(Arel::Attributes::Attribute))
-          collector = visit o.left, collector
-        else
-          collector << " date '#{o.right}'"
-        end
-        collector
-      end
-
-
-      def visit_ArelExtensions_Nodes_Duration o, collector
-        #visit left for period
-        if o.left == "d"
-          collector << "EXTRACT(DAY FROM"
-        elsif o.left == "m"
-          collector << "EXTRACT(MONTH FROM "
-        elsif (o.left == "w")
-          collector << "EXTRACT(WEEK FROM"
-        elsif (o.left == "y")
-          collector << "EXTRACT(YEAR FROM"
-        end
-        #visit right
-        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_Locate o, collector
-        collector << "position("
-        if(o.val.is_a?(Arel::Attributes::Attribute))
-          collector = visit o.val, collector
-        else
-          collector << "'#{o.val}'"
-        end
-        collector << " IN "
-        collector = visit o.expr, collector
-        collector << ")"
-        collector
-      end
-
-      def visit_ArelExtensions_Nodes_Isnull o, collector
-        collector << "coalesce("
-        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_Rand o, collector
-        collector << "random("
+        collector << "RANDOM("
         if(o.left != nil && o.right != nil)
-         collector << "'#{o.left}'"
-         collector << ","
-         collector << "'#{o.right}'"
+          collector = visit o.left, collector
+          collector << Arel::Visitors::PostgreSQL::COMMA
+          collector = isit o.right, collector
         end
         collector << ")"
         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
-
-
       remove_method(:visit_Arel_Nodes_Regexp) rescue nil
       def visit_Arel_Nodes_Regexp o, collector
         collector = visit o.left, collector
         collector << " ~ "
-        collector << "'#{o.right}'"
+        collector = visit o.right, collector
         collector
       end
 
@@ -105,72 +25,113 @@ module ArelExtensions
       def visit_Arel_Nodes_NotRegexp o, collector
         collector = visit o.left, collector
         collector << " !~ "
-        collector << o.right
+        collector = visit o.right, collector
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Sum o, collector
-        collector << "sum("
-       if((o.expr).is_a?(Arel::Attributes::Attribute))
-        collector = visit o.expr, collector
-      else
-          collector << "'#{o.expr}'"
-       end
+      def visit_ArelExtensions_Nodes_GroupConcat o, collector
+        collector << "array_to_string(array_agg("
+        collector = visit o.left, collector
+        collector << ")"
+        if o.right
+          collector << Arel::Visitors::PostgreSQL::COMMA
+          collector = visit o.right, collector
+        else
+          collector << Arel::Visitors::PostgreSQL::COMMA
+          collector = visit Arel::Nodes.build_quoted(' '), collector
+        end
         collector << ")"
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Trim o , collector
+      def visit_ArelExtensions_Nodes_Trim o, collector
           collector << 'TRIM(BOTH '
-          if(o.right.is_a?(Arel::Attributes::Attribute))
-            collector = visit o.right, collector
-          else
-            collector << "'#{o.right}'"
-          end
+          collector = visit o.right, collector
           collector << " FROM "
           collector = visit o.left, collector
-
           collector << ")"
           collector
       end
 
-      def visit_ArelExtensions_Nodes_Ltrim o , collector
+      def visit_ArelExtensions_Nodes_Ltrim o, collector
           collector << 'TRIM(LEADING '
-          if(o.right.is_a?(Arel::Attributes::Attribute))
-            collector = visit o.right, collector
-          else
-            collector << "'#{o.right}'"
-          end
+          collector = visit o.right, collector
           collector << " FROM "
           collector = visit o.left, collector
-
           collector << ")"
           collector
       end
 
-
-      def visit_ArelExtensions_Nodes_Rtrim o , collector
-          collector << 'TRIM(TRAILING '
-        if(o.right.is_a?(Arel::Attributes::Attribute))
-          collector = visit o.right, collector
-        else
-          collector << "'#{o.right}'"
-        end
+      def visit_ArelExtensions_Nodes_Rtrim o, collector
+        collector << 'TRIM(TRAILING '
+        collector = visit o.right, collector
         collector << " FROM "
         collector = visit o.left, collector
+        collector << ")"
+        collector
+      end
+
+      def visit_ArelExtensions_Nodes_DateAdd o, collector
+        collector = visit o.left, collector
+        collector << (o.right.value >= 0 ? ' + ' : ' - ')
+        collector = visit o.postgresql_value(o.right), collector
+        collector
+      end
 
+      def visit_ArelExtensions_Nodes_DateDiff o, collector
+        collector << "DATE_PART('day'"
+        collector << Arel::Visitors::PostgreSQL::COMMA
+        collector = visit o.left, collector
+        collector << (o.date_type == :date ? '::date' : '::timestamp')
+        collector << " - "
+        collector = visit o.right, collector
+        collector << (o.date_type == :date ? '::date' : '::timestamp')
         collector << ")"
         collector
       end
 
+      def visit_ArelExtensions_Nodes_Duration o, collector
+        #visit left for period
+        if o.left == "d"
+          collector << "EXTRACT(DAY FROM"
+        elsif o.left == "m"
+          collector << "EXTRACT(MONTH FROM "
+        elsif (o.left == "w")
+          collector << "EXTRACT(WEEK FROM"
+        elsif (o.left == "y")
+          collector << "EXTRACT(YEAR FROM"
+        end
+        #visit right
+        collector = visit o.right, collector
+        collector << ")"
+        collector
+      end
+
+      def visit_ArelExtensions_Nodes_Locate o, collector
+        collector << "POSITION("
+        collector = visit o.right, collector
+        collector << " IN "
+        collector = visit o.left, 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_Sum o, collector
+        collector << "sum("
+        collector = visit o.expr, collector
+        collector << ")"
+        collector
+      end
 
       def visit_ArelExtensions_Nodes_Wday o, collector
-        collector << "date_part('dow', "
-        if((o.date).is_a?(Arel::Attributes::Attribute))
-          collector = visit o.date, collector
-        else
-          collector << "'#{o.date}'"
-        end
+        collector << "DATE_PART('dow', "
+        collector = visit o.date, collector
         collector << ")"
         collector
       end

data/lib/arel_extensions/visitors/sqlite.rb

@@ -2,11 +2,36 @@ module ArelExtensions
   module Visitors
     Arel::Visitors::SQLite.class_eval do
 
+      #String functions
+      def visit_ArelExtensions_Nodes_IMatches o, collector # insensitive on ASCII
+        collector = visit o.left, collector
+        collector << ' LIKE '
+        collector = visit o.right, collector
+        if o.escape
+          collector << ' ESCAPE '
+          visit o.escape, collector
+        else
+          collector
+        end
+      end
+
+      def visit_ArelExtensions_Nodes_IDoesNotMatch o, collector
+        collector = visit o.left.lower, collector
+        collector << ' NOT LIKE '
+        collector = visit o.right.lower(o.right), collector
+        if o.escape
+          collector << ' ESCAPE '
+          visit o.escape, collector
+        else
+          collector
+        end
+      end
+
       # Date operations
       def visit_ArelExtensions_Nodes_DateAdd o, collector
         collector << "date("
         collector = visit o.expressions.first, collector
-        collector << Arel::Visitors::ToSql::COMMA
+        collector << Arel::Visitors::SQLite::COMMA
         collector = visit o.sqlite_value, collector
         collector << ")"
         collector
@@ -21,7 +46,6 @@ module ArelExtensions
         collector
       end
 
-
       def visit_ArelExtensions_Nodes_Duration o, collector
         #visit left for period
         if(o.left == "d")
@@ -34,11 +58,7 @@ module ArelExtensions
           collector << "strftime('%Y',"
         end
         #visit right
-        if(o.right.is_a?(Arel::Attributes::Attribute))
-          collector = visit o.right, collector
-        else
-          collector << "#{o.right}"
-        end
+        collector = visit o.right, collector
         collector << ")"
         collector
       end
@@ -47,59 +67,24 @@ module ArelExtensions
       def visit_ArelExtensions_Nodes_Locate o, collector
         collector << "instr("
         collector = visit o.expr, collector
-        collector << ","
-        if(o.val.is_a?(Arel::Attributes::Attribute))
-          collector = visit o.val, collector
-        else
-          collector << "'#{o.val}'"
-        end
+        collector << Arel::Visitors::SQLite::COMMA
+        collector = visit o.val, collector
         collector << ")"
         collector
       end
 
-      def visit_ArelExtensions_Nodes_Isnull o, collector
-        collector << "ifnull("
+      def visit_ArelExtensions_Nodes_IsNull o, collector
         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 << ' IS NULL'
         collector
       end
 
       def visit_ArelExtensions_Nodes_Rand o, collector
         collector << "RANDOM("
-        if(o.left != nil && o.right != nil)
-          if(o.left.is_a?(Arel::Attributes::Attribute))
-            collector = visit o.left, collector
-          else
-            collector << "'#{o.left}'"
-          end
-          collector << ","
-          collector << "'#{o.right}'"
-        end
-        collector << ")"
-        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))
+        if o.left != nil && o.right != nil 
           collector = visit o.left, collector
-        else
-          collector << "'#{o.left}'"
-        end
-        collector << ","
-        if(o.right.is_a?(Arel::Attributes::Attribute))
+          collector << Arel::Visitors::SQLite::COMMA
           collector = visit o.right, collector
-        else
-          collector << "'#{o.right}'"
         end
         collector << ")"
         collector
@@ -107,28 +92,48 @@ module ArelExtensions
 
       def visit_Arel_Nodes_Regexp o, collector
         collector = visit o.left, collector
-        collector << " REGEXP '#{o.right}'"
+        collector << " REGEXP"
+        collector = visit o.right, collector
         collector
       end
 
       def visit_Arel_Nodes_NotRegexp o, collector
         collector = visit o.left, collector
         collector << " NOT REGEXP "
-        collector << "'#{o.right}'"
+        collector = visit o.right, collector
         collector
       end
 
       def visit_ArelExtensions_Nodes_Wday o, collector
         collector << "strftime('%w',"
-        if((o.date).is_a?(Arel::Attributes::Attribute))
-          collector = visit o.date, collector
-        else
-          collector << "'#{o.date}'"
-        end
+        collector = visit o.date, collector
         collector << ")"
         collector
       end
 
+      def visit_ArelExtensions_InsertManager_BulkValues o, collector
+        o.left.each_with_index do |row, idx|
+          collector << 'SELECT '
+          v = Arel::Nodes::Values.new(row, o.cols)
+          len = v.expressions.length - 1
+          v.expressions.zip(v.columns).each_with_index { |(value, attr), i|
+              case value
+              when Arel::Nodes::SqlLiteral, Arel::Nodes::BindParam
+                collector = visit value.as(attr.name), collector
+              else
+                collector << quote(value, attr && column_for(attr)).to_s
+                if idx == 0
+                  collector << " AS "
+                  collector << quote(attr.name)
+                end
+              end
+              collector << Arel::Visitors::SQLite::COMMA unless i == len
+          }
+          collector << ' UNION ALL ' unless idx == o.left.length - 1
+        end
+        collector
+      end
+
     end
   end
 end

data/lib/arel_extensions/visitors/to_sql.rb

@@ -53,7 +53,6 @@ module ArelExtensions
         collector
       end
 
-
       # String functions
       def visit_ArelExtensions_Nodes_Concat o, collector
         o.expressions.each_with_index { |arg, i|
@@ -63,15 +62,35 @@ module ArelExtensions
         collector
       end
 
+      def visit_ArelExtensions_Nodes_GroupConcat o, collector
+        collector << "GROUP_CONCAT("
+        collector = visit o.left, collector
+        if o.right
+          collector << Arel::Visitors::ToSql::COMMA
+          collector = visit o.right, collector
+        end
+        collector << ")"
+        collector
+      end
+
       def visit_ArelExtensions_Nodes_Length o, collector
         collector << "LENGTH("
-        collector = visit o.expr, collector
+        collector = visit o.left, collector
         collector << ")"
         collector
       end
 
       def visit_ArelExtensions_Nodes_Locate o, collector
         collector << "LOCATE("
+        collector = visit o.right, collector
+        collector << Arel::Visitors::ToSql::COMMA
+        collector = visit o.left, collector
+        collector << ")"
+        collector
+      end
+
+      def visit_ArelExtensions_Nodes_Replace o, collector
+        collector << "REPLACE("
         o.expressions.each_with_index { |arg, i|
           collector << Arel::Visitors::ToSql::COMMA unless i == 0
           collector = visit arg, collector
@@ -206,10 +225,16 @@ module ArelExtensions
         collector = infix_value o, collector, ' NOT ILIKE '
         if o.escape
           collector << ' ESCAPE '
-          visit o.escape, collector
-        else
-          collector
+          collector = visit o.escape, collector
         end
+        collector
+      end
+
+      def visit_ArelExtensions_Nodes_IsNull o, collector
+        collector << "ISNULL("
+        collector = visit o.left, collector
+        collector << ")"
+        collector
       end
 
       # Date operations

data/test/database.yml

@@ -16,11 +16,23 @@ jdbc-mysql:
   database: arext_test
   username: travis
   encoding: utf8
-postgres:
+postgresql:
   adapter: postgresql
   database: arext_test
   username: postgres
-jdbc-postgres:
+jdbc-postgresql:
   adapter: jdbcpostgresql
   database: arext_test
-  username: postgres
+  username: postgres
+oracle:
+  adapter: oracle_enhanced
+  database: xe
+  username: travis
+jdbc-oracle:
+  adapter: oracle_enhanced
+  database: xe
+  username: travis
+ibm_db:
+  adapter:  ibm_db
+  username: travis
+  database: arext_test

data/test/real_db_test.rb

@@ -47,7 +47,6 @@ class User < ActiveRecord::Base
 
 end
 
-
 class ListTest < Minitest::Test
 
   def setup

data/test/visitors/test_bulk_insert_sqlite.rb

@@ -8,6 +8,7 @@ module ArelExtensions
         @conn = FakeRecord::Base.new
         @visitor = Arel::Visitors::SQLite.new @conn.connection
         @table = Arel::Table.new(:users)
+        Arel::Table.engine = @conn
         @cols = ['id', 'name', 'comments', 'created_at']
         @data = [
         	[23, 'nom1', "sdfdsfdsfsdf", '2016-01-01'],
@@ -27,7 +28,7 @@ module ArelExtensions
         insert_manager = Arel::VERSION.to_i > 6 ? Arel::InsertManager.new().into(@table) : Arel::InsertManager.new(@conn).into(@table)
         insert_manager.bulk_insert(@cols, @data)
         sql = compile(insert_manager.ast)
-    	  sql.must_be_like %Q[INSERT INTO "users" ("id", "name", "comments", "created_at") VALUES (23, 'nom1', 'sdfdsfdsfsdf', '2016-01-01'), (25, 'nom2', 'sdfdsfdsfsdf', '2016-01-01')]
+    	  sql.must_be_like %Q[INSERT INTO "users" ("id", "name", "comments", "created_at") SELECT 23 AS 'id', 'nom1' AS 'name', 'sdfdsfdsfsdf' AS 'comments', '2016-01-01' AS 'created_at' UNION ALL SELECT 25, 'nom2', 'sdfdsfdsfsdf', '2016-01-01']
       end
 
 	  end

data/test/visitors/test_oracle.rb

@@ -76,13 +76,13 @@ module ArelExtensions
       it "should diff between time values" do
         d2 = Time.new(2015,6,1)
         d1 = DateTime.new(2015,6,2)
-        sql = compile(ArelExtensions::Nodes::DateDiff.new(d1,d2))
+        sql = compile(ArelExtensions::Nodes::DateDiff.new([d1,d2]))
         sql.must_match("'2015-06-02' - '2015-06-01'")
       end
 
       it "should diff between time values and time col" do
         d1 = DateTime.new(2015,6,2)
-        sql = compile(ArelExtensions::Nodes::DateDiff.new(d1, @table[:updated_at]))
+        sql = compile(ArelExtensions::Nodes::DateDiff.new([d1, @table[:updated_at]]))
         sql.must_match %{'2015-06-02' - "users"."updated_at"}
       end
 

data/test/visitors/test_to_sql.rb

@@ -23,7 +23,6 @@ module ArelExtensions
       end
 
       # Math Functions
-
       it "should not break Arel functions" do
         compile(@price + 42).must_be_like %{("products"."price" + 42)}
       end
@@ -51,7 +50,7 @@ module ArelExtensions
         compile(c + 'test' + ' chain').must_be_like %{"users"."name" || 'test' || ' chain'}
         compile(c.length).must_be_like %{LENGTH("users"."name")}
         compile(c.length.round + 42).must_be_like %{(ROUND(LENGTH("users"."name")) + 42)}
-        compile(c.locate('test')).must_be_like %{LOCATE("users"."name", 'test')}
+        compile(c.locate('test')).must_be_like %{LOCATE('test', "users"."name")}
         compile(c & 42).must_be_like %{FIND_IN_SET(42, "users"."name")}
 
         compile((c >= 'test').as('new_name')).must_be_like %{("users"."name" >= 'test') AS new_name}
@@ -118,13 +117,13 @@ module ArelExtensions
       it "should diff between time values" do
         d2 = Time.new(2015,6,1)
         d1 = DateTime.new(2015,6,2)
-        sql = compile(ArelExtensions::Nodes::DateDiff.new(d1,d2))
+        sql = compile(ArelExtensions::Nodes::DateDiff.new([d1, d2]))
         sql.must_match("DATEDIFF('2015-06-02', '2015-06-01')")
       end
 
       it "should diff between time values and time col" do
         d1 = DateTime.new(2015,6,2)
-        sql = compile(ArelExtensions::Nodes::DateDiff.new(d1, @table[:updated_at]))
+        sql = compile(ArelExtensions::Nodes::DateDiff.new([d1, @table[:updated_at]]))
         sql.must_match %{DATEDIFF('2015-06-02', "users"."updated_at")}
       end