arel_extensions 2.0.1 → 2.0.4

data/lib/arel_extensions/visitors/postgresql.rb

@@ -83,23 +83,49 @@ module ArelExtensions
         collector
       end
 
+      def visit_Aggregate_For_AggregateFunction o, collector
+        if !o.order.blank? || !o.group.blank?
+          collector << " OVER ("
+          if !o.group.blank?
+            collector << " PARTITION BY "
+            o.group.each_with_index do |group, i|
+              collector << Arel::Visitors::PostgreSQL::COMMA unless i == 0
+              visit group, collector
+            end
+          end
+          if !o.order.blank?
+            collector << " ORDER BY "
+            o.order.each_with_index do |order, i|
+              collector << Arel::Visitors::PostgreSQL::COMMA unless i == 0
+              visit order, collector
+            end
+          end
+          collector << ")"
+        end
+        collector
+      end
+
       def visit_ArelExtensions_Nodes_GroupConcat o, collector
         collector << "array_to_string(array_agg("
         collector = visit o.left, collector
-        if !o.orders.blank?
-          collector << ' ORDER BY '
-          o.orders.each_with_index do |order,i|
+        if o.order && !o.order.blank?
+          collector << " ORDER BY"
+          o.order.each_with_index do |order, i|
             collector << Arel::Visitors::PostgreSQL::COMMA unless i == 0
-            collector = visit order, collector
+            collector << " "
+            visit order, collector
           end
         end
         collector << ")"
+        o.order = nil
+        visit_Aggregate_For_AggregateFunction o, collector
         collector << Arel::Visitors::PostgreSQL::COMMA
-        if o.right  && o.right != 'NULL'
-          collector = visit o.right, collector
-        else
-          collector = visit Arel::Nodes.build_quoted(','), collector
-        end
+        collector =
+          if o.separator && o.separator != 'NULL'
+            visit o.separator, collector
+          else
+            visit Arel::Nodes.build_quoted(','), collector
+          end
         collector << ")"
         collector
       end
@@ -277,6 +303,22 @@ module ArelExtensions
         collector
       end
 
+      def visit_ArelExtensions_Nodes_RegexpReplace o, collector
+        collector << "REGEXP_REPLACE("
+        visit o.left, collector
+        collector << Arel::Visitors::ToSql::COMMA
+        tab = o.pattern.inspect+ 'g' # Make it always global
+        pattern = tab.split('/')[1..-2].join('/') 
+        flags = tab.split('/')[-1]
+        visit Arel::Nodes.build_quoted(pattern), collector
+        collector << Arel::Visitors::ToSql::COMMA
+        visit o.substitute, collector
+        collector << Arel::Visitors::ToSql::COMMA
+        visit Arel::Nodes.build_quoted(flags+"g"), collector
+        collector << ")"
+        collector
+      end
+
       def visit_ArelExtensions_Nodes_IsNull o, collector
         collector = visit o.expr, collector
         collector << ' IS NULL'
@@ -293,6 +335,7 @@ module ArelExtensions
         collector << "sum("
         collector = visit o.expr, collector
         collector << ")"
+        visit_Aggregate_For_AggregateFunction o, collector
         collector
       end
 
@@ -345,27 +388,28 @@ module ArelExtensions
                   else(o.flags.include?('+') ? '+' : (o.flags.include?(' ') ? ' ' : ''))
         sign_length = ArelExtensions::Nodes::Length.new([sign])
 
-        if o.scientific_notation
-          number = ArelExtensions::Nodes::Concat.new([
-                  Arel::Nodes::NamedFunction.new('TRIM',[
-                    Arel::Nodes::NamedFunction.new('TO_CHAR',[
-                      col.abs/Arel::Nodes.build_quoted(10).pow(col.abs.log10.floor),
-                      Arel::Nodes.build_quoted('FM'+nines_before+'"'+comma+'"V'+nines_after)
-                    ])]),
-                  o.type,
-                  Arel::Nodes::NamedFunction.new('TRIM',[
-                    Arel::Nodes::NamedFunction.new('TO_CHAR',[
-                      col.abs.log10.floor,
-                      Arel::Nodes.build_quoted('FM'+nines_before)
-                    ])])
-                ])
-        else
-          number = Arel::Nodes::NamedFunction.new('TRIM',[
-                Arel::Nodes::NamedFunction.new('TO_CHAR',[
-                  Arel::Nodes.build_quoted(col.abs),
-                  Arel::Nodes.build_quoted('FM'+nines_before+'"'+comma+'"V'+nines_after)
-                ])])
-        end
+        number =
+          if o.scientific_notation
+            ArelExtensions::Nodes::Concat.new([
+                Arel::Nodes::NamedFunction.new('TRIM',[
+                  Arel::Nodes::NamedFunction.new('TO_CHAR',[
+                    col.abs/Arel::Nodes.build_quoted(10).pow(col.abs.log10.floor),
+                    Arel::Nodes.build_quoted('FM'+nines_before+'"'+comma+'"V'+nines_after)
+                  ])]),
+                o.type,
+                Arel::Nodes::NamedFunction.new('TRIM',[
+                  Arel::Nodes::NamedFunction.new('TO_CHAR',[
+                    col.abs.log10.floor,
+                    Arel::Nodes.build_quoted('FM'+nines_before)
+                  ])])
+              ])
+          else
+            Arel::Nodes::NamedFunction.new('TRIM',[
+              Arel::Nodes::NamedFunction.new('TO_CHAR',[
+                Arel::Nodes.build_quoted(col.abs),
+                Arel::Nodes.build_quoted('FM'+nines_before+'"'+comma+'"V'+nines_after)
+              ])])
+          end
 
         repeated_char = (o.width == 0) ? Arel::Nodes.build_quoted('') : ArelExtensions::Nodes::Case.new().
           when(Arel::Nodes.build_quoted(o.width).abs-(number.length+sign_length)>0).
@@ -420,6 +464,7 @@ module ArelExtensions
         collector << (o.unbiased_estimator ? "STDDEV_SAMP(" : "STDDEV_POP(")
         visit o.left, collector
         collector << ")"
+        visit_Aggregate_For_AggregateFunction o, collector
         collector
       end
 
@@ -427,6 +472,7 @@ module ArelExtensions
         collector << (o.unbiased_estimator ? "VAR_SAMP(" : "VAR_POP(")
         visit o.left, collector
         collector << ")"
+        visit_Aggregate_For_AggregateFunction o, collector
         collector
       end
 
@@ -438,7 +484,7 @@ module ArelExtensions
             if i != 0
               collector << Arel::Visitors::MySQL::COMMA
             end
-            collector  = visit v, collector
+            collector = visit v, collector
           end
           collector << '])'
         when Hash

data/lib/arel_extensions/visitors/sqlite.rb

@@ -193,18 +193,28 @@ module ArelExtensions
         collector
       end
 
-      # CASE WHEN ROUND(3.42,1) > round(3.42) THEN round(3.42) ELSE round(3.42)-1 END
-      # OR CAST(3.14 AS INTEGER)
+      # CAST(
+      #   CASE
+      #     WHEN 3.42 >= 0 THEN CAST(3.42 AS INT)
+      #     WHEN CAST(3.42 AS INT) = 3.42 THEN CAST(3.42 AS INT)
+      #     ELSE CAST((3.42 - 1.0) AS INT)
+      #   END
+      #   AS FLOAT
+      # )
       def visit_ArelExtensions_Nodes_Floor o, collector
-        collector << "CASE WHEN ROUND("
+        collector << "CAST(CASE WHEN "
         collector = visit o.left, collector
-        collector << ", 1) > ROUND("
+        collector << " >= 0 THEN CAST("
         collector = visit o.left, collector
-        collector << ") THEN ROUND("
+        collector << " AS INT) WHEN CAST("
+        collector = visit o.left, collector
+        collector << " AS INT) = "
+        collector = visit o.left, collector
+        collector << " THEN CAST("
         collector = visit o.left, collector
-        collector << ") ELSE ROUND("
+        collector << " AS INT) ELSE CAST(("
         collector = visit o.left, collector
-        collector << ") - 1 END"
+        collector << " - 1.0) AS INT) END AS FLOAT)"
         collector
       end
 
@@ -248,20 +258,20 @@ module ArelExtensions
         def visit_ArelExtensions_InsertManager_BulkValues o, collector
           o.left.each_with_index do |row, idx|
             collector << 'SELECT '
-            len = row.length - 1
-            row.each_with_index { |value, i|
-              attr = o.cols[i]
-              case value
-              when Arel::Nodes::SqlLiteral, Arel::Nodes::BindParam
-                collector = visit value.as(attr.name), collector
-              else
-                collector << (attr && attr.able_to_type_cast? ? quote(attr.type_cast_for_database(value)) : quote(value).to_s)
-                if idx == 0
-                  collector << " AS "
-                  collector << quote(attr.name)
+            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 << (attr && attr.able_to_type_cast? ? quote(attr.type_cast_for_database(value)) : quote(value).to_s)
+                  if idx == 0
+                    collector << " AS "
+                    collector << quote(attr.name)
+                  end
                 end
-              end
-              collector << Arel::Visitors::SQLite::COMMA unless i == len
+                collector << Arel::Visitors::SQLite::COMMA unless i == len
             }
             collector << ' UNION ALL ' unless idx == o.left.length - 1
           end
@@ -270,32 +280,36 @@ module ArelExtensions
       end
 
       def visit_ArelExtensions_Nodes_Union o, collector
-        if o.left.is_a?(Arel::SelectManager)
-          collector = visit o.left.ast, collector
-        else
-          collector = visit o.left, collector
-        end
+        collector =
+          if o.left.is_a?(Arel::SelectManager)
+            visit o.left.ast, collector
+          else
+            visit o.left, collector
+          end
         collector << " UNION "
-        if o.right.is_a?(Arel::SelectManager)
-          collector = visit o.right.ast, collector
-        else
-          collector = visit o.right, collector
-        end
+        collector =
+          if o.right.is_a?(Arel::SelectManager)
+            visit o.right.ast, collector
+          else
+            visit o.right, collector
+          end
         collector
       end
 
       def visit_ArelExtensions_Nodes_UnionAll o, collector
-        if o.left.is_a?(Arel::SelectManager)
-          collector = visit o.left.ast, collector
-        else
-          collector = visit o.left, collector
-        end
+        collector =
+          if o.left.is_a?(Arel::SelectManager)
+            visit o.left.ast, collector
+          else
+            visit o.left, collector
+          end
         collector << " UNION ALL "
-        if o.right.is_a?(Arel::SelectManager)
-          collector = visit o.right.ast, collector
-        else
-          collector = visit o.right, collector
-        end
+        collector =
+          if o.right.is_a?(Arel::SelectManager)
+            visit o.right.ast, collector
+          else
+            visit o.right, collector
+          end
         collector
       end
 

data/lib/arel_extensions/visitors/to_sql.rb

@@ -1,7 +1,7 @@
 module ArelExtensions
   module Visitors
-  Arel::Visitors::ToSql.class_eval do
-      Arel::Visitors::ToSql::COMMA = ", "
+    Arel::Visitors::ToSql.class_eval do
+      Arel::Visitors::ToSql::COMMA = ', ' unless defined?(Arel::Visitors::ToSql::COMMA)
 
       # Math Functions
       def visit_ArelExtensions_Nodes_Abs o, collector
@@ -53,14 +53,14 @@ module ArelExtensions
         collector << ")"
         collector
       end
-  
+
       def visit_ArelExtensions_Nodes_Log10 o, collector
         collector << "LOG10("
         collector = visit o.left, collector
         collector << ")"
         collector
       end
-  
+
       def visit_ArelExtensions_Nodes_Power o, collector
         collector << "POW("
         o.expressions.each_with_index { |arg, i|
@@ -71,6 +71,13 @@ module ArelExtensions
         collector
       end
 
+      def visit_ArelExtensions_Nodes_Sum o, collector
+        collector << "SUM("
+        collector = visit o.expr, collector
+        collector << ")"
+        collector
+      end
+
       # String functions
       def visit_ArelExtensions_Nodes_Concat o, collector
         collector << "CONCAT("
@@ -85,9 +92,9 @@ module ArelExtensions
       def visit_ArelExtensions_Nodes_GroupConcat o, collector
         collector << "GROUP_CONCAT("
         collector = visit o.left, collector
-        if o.right && o.right != 'NULL'
+        if o.separator && o.separator != 'NULL'
           collector << Arel::Visitors::ToSql::COMMA
-          collector = visit o.right, collector
+          collector = visit o.separator, collector
         end
         collector << ")"
         collector
@@ -128,14 +135,26 @@ module ArelExtensions
 
       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
-        }
+        visit o.left, collector
+        collector << Arel::Visitors::ToSql::COMMA
+        visit o.pattern, collector
+        collector << Arel::Visitors::ToSql::COMMA
+        visit o.substitute, collector
+        collector << ")"
+        collector
+      end
+
+      def visit_ArelExtensions_Nodes_RegexpReplace o, collector
+        collector << "REGEXP_REPLACE("
+        visit o.left, collector
+        collector << Arel::Visitors::ToSql::COMMA
+        visit Arel::Nodes.build_quoted(o.pattern.to_s), collector
+        collector << Arel::Visitors::ToSql::COMMA
+        visit o.substitute, collector
         collector << ")"
         collector
       end
-  
+
       def visit_ArelExtensions_Nodes_Repeat o, collector
         collector << "REPEAT("
         o.expressions.each_with_index { |arg, i|
@@ -270,12 +289,12 @@ module ArelExtensions
           as_attr = Arel::Nodes::SqlLiteral.new('int')
         when :decimal, :float, :number
           as_attr = Arel::Nodes::SqlLiteral.new('float')
-        when :datetime  
+        when :datetime
           as_attr = Arel::Nodes::SqlLiteral.new('datetime')
         when :time
           as_attr = Arel::Nodes::SqlLiteral.new('time')
-        when :binary  
-          as_attr = Arel::Nodes::SqlLiteral.new('binary')  
+        when :binary
+          as_attr = Arel::Nodes::SqlLiteral.new('binary')
         else
           as_attr = Arel::Nodes::SqlLiteral.new(o.as_attr.to_s)
         end
@@ -306,7 +325,7 @@ module ArelExtensions
         collector << ")"
         collector
       end
-  
+
       def visit_ArelExtensions_Nodes_DateSub o, collector
         collector << "DATE_SUB("
         collector = visit o.left, collector
@@ -385,7 +404,7 @@ module ArelExtensions
         collector = visit o.left, collector
         collector << ") THEN "
         collector = visit o.right, collector
-        if o.expressions[2]  
+        if o.expressions[2]
           collector << " ELSE "
           collector = visit o.expressions[2], collector
         end
@@ -430,9 +449,9 @@ module ArelExtensions
           row_nb = o.left.length
           o.left.each_with_index do |row, idx|
             collector << '('
-            len = row.length - 1
-            row.each_with_index { |value, i|
-              attr = o.cols[i]
+            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, collector
@@ -453,7 +472,7 @@ module ArelExtensions
         collector = visit o.right, collector
         collector
       end
-  
+
       def visit_ArelExtensions_Nodes_UnionAll o, collector
         collector = visit o.left, collector
         collector << " UNION ALL "
@@ -490,25 +509,25 @@ module ArelExtensions
         visit Arel::Nodes.build_quoted(o.expr), collector
       end
 
-      def visit_ArelExtensions_Nodes_FormattedNumber o, collector  
+      def visit_ArelExtensions_Nodes_FormattedNumber o, collector
         visit o.left, collector
       end
-  
-      remove_method(:visit_Arel_Nodes_LessThan) rescue nil  
+
+      remove_method(:visit_Arel_Nodes_LessThan) rescue nil
       def visit_Arel_Nodes_LessThan o, collector
         collector = visit o.left, collector
         collector << " < "
         visit o.right, collector
       end
-  
-      def visit_ArelExtensions_Nodes_Std o, collector  
+
+      def visit_ArelExtensions_Nodes_Std o, collector
         collector << "STD("
         visit o.left, collector
         collector << ")"
         collector
       end
-  
-      def visit_ArelExtensions_Nodes_Variance o, collector  
+
+      def visit_ArelExtensions_Nodes_Variance o, collector
         collector << "VARIANCE("
         visit o.left, collector
         collector << ")"
@@ -526,40 +545,40 @@ module ArelExtensions
 
       alias_method :old_visit_Arel_Nodes_And, :visit_Arel_Nodes_And
       def visit_Arel_Nodes_And o, collector
+        collector << '('
         case o.children.length
         when 0
           collector << '1=1' # but this should not happen
         when 1
           collector = visit o.children[0], collector
         else
-          collector << '('
           o.children.each_with_index { |arg, i|
             if i != 0
               collector << ') AND ('
             end
             collector = visit arg, collector
           }
-          collector << ')'
         end
+        collector << ')'
         collector
       end
 
       def visit_ArelExtensions_Nodes_Or o, collector
+        collector << '('
         case o.children.length
         when 0
           collector << '0=1' # but this should not happen
         when 1
           collector = visit o.children[0], collector
         else
-            collector << '('
             o.children.each_with_index { |arg, i|
               if i != 0
                 collector << ') OR ('
               end
               collector = visit arg, collector
             }
-            collector << ')'
         end
+        collector << ')'
         collector
       end
 

data/lib/arel_extensions.rb

@@ -93,6 +93,14 @@ module Arel
     ArelExtensions::Nodes::Duration.new(s.to_s+'i',expr)
   end
 
+  def self.true
+    Arel::Nodes::Equality.new(1,1)
+  end
+
+  def self.false
+    Arel::Nodes::Equality.new(1,0)
+  end
+
 end
 
 Arel::Attributes::Attribute.class_eval do
@@ -109,6 +117,12 @@ Arel::Nodes::Function.class_eval do
   include ArelExtensions::BooleanFunctions
   include ArelExtensions::NullFunctions
   include ArelExtensions::Predications
+
+  alias_method :old_as, :as
+  def as other
+    Arel::Nodes::As.new(self, Arel.sql(other))
+  end
+
 end
 
 Arel::Nodes::Unary.class_eval do
@@ -149,4 +163,9 @@ Arel::Nodes::As.class_eval do
   include ArelExtensions::Nodes
 end
 
-
+Arel::Table.class_eval do
+  alias_method :old_alias, :alias
+  def alias(name = "#{self.name}_2")
+    name.blank? ? self : Arel::Nodes::TableAlias.new(self,name)
+  end
+end

data/test/helper.rb

@@ -15,4 +15,4 @@ class Object
   def must_be_like other
     gsub(/\s+/, ' ').strip.must_equal other.gsub(/\s+/, ' ').strip
   end
-end
+end

data/test/real_db_test.rb

@@ -29,7 +29,7 @@ def setup_db
       func.result = value1.index(value2)
     end
   end
-  @cnx.drop_table(:users) rescue nil 
+  @cnx.drop_table(:users) rescue nil
   @cnx.create_table :users do |t|
       t.column :age, :integer
       t.column :name, :string

data/test/support/fake_record.rb

@@ -65,10 +65,6 @@ module FakeRecord
       self
     end
 
-    def in_clause_length
-      6
-    end
-
     def quote thing, column = nil
       if column && !thing.nil?
         case column.type

data/test/test_comparators.rb

@@ -22,7 +22,7 @@ module ArelExtensions
       it "< is equal lt" do
         compile(@table[:id] < 10).must_be_like('"users"."id" < 10')
       end
-      
+
       it "<= is equal lteq" do
         compile(@table[:id] <= 10).must_be_like('"users"."id" <= 10')
       end

data/test/visitors/test_bulk_insert_oracle.rb

@@ -9,8 +9,8 @@ module ArelExtensions
         @table = Arel::Table.new(:users)
         @cols = ['name', 'comments', 'created_at']
         @data = [
-        	['nom1', "sdfdsfdsfsdf", '2016-01-01'],
-        	['nom2', "sdfdsfdsfsdf", '2016-01-01']
+          ['nom1', "sdfdsfdsfsdf", '2016-01-01'],
+          ['nom2', "sdfdsfdsfsdf", '2016-01-01']
         ]
       end
 
@@ -24,11 +24,11 @@ module ArelExtensions
 
       it "should import large set of data in Oracle" do
         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" ("name", "comments", "created_at") ((SELECT 'nom1', 'sdfdsfdsfsdf', '2016-01-01' FROM DUAL) UNION ALL (SELECT 'nom2', 'sdfdsfdsfsdf', '2016-01-01' FROM DUAL))]
+        insert_manager.bulk_insert(@cols, @data)
+        sql = compile(insert_manager.ast)
+        sql.must_be_like %Q[INSERT INTO "users" ("name", "comments", "created_at") ((SELECT 'nom1', 'sdfdsfdsfsdf', '2016-01-01' FROM DUAL) UNION ALL (SELECT 'nom2', 'sdfdsfdsfsdf', '2016-01-01' FROM DUAL))]
       end
 
-	  end
+    end
   end
 end

data/test/visitors/test_bulk_insert_sqlite.rb

@@ -11,11 +11,11 @@ module ArelExtensions
         Arel::Table.engine = @conn
         @cols = ['id', 'name', 'comments', 'created_at']
         @data = [
-        	[23, 'nom1', "sdfdsfdsfsdf", '2016-01-01'],
-        	[25, 'nom2', "sdfdsfdsfsdf", '2016-01-01']
+          [23, 'nom1', "sdfdsfdsfsdf", '2016-01-01'],
+          [25, 'nom2', "sdfdsfdsfsdf", '2016-01-01']
         ]
       end
-      
+
       def compile node
         if Arel::VERSION.to_i > 5
           @visitor.accept(node, Arel::Collectors::SQLString.new).value
@@ -28,9 +28,9 @@ 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") 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']
+        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
+    end
   end
-end
+end

data/test/visitors/test_bulk_insert_to_sql.rb

@@ -10,8 +10,8 @@ module ArelExtensions
         @table = Arel::Table.new(:users)
         @cols = ['id', 'name', 'comments', 'created_at']
         @data = [
-        	[23, 'nom1', "sdfdsfdsfsdf", '2016-01-01'],
-        	[25, 'nom2', "sdfdsfdsfsdf", '2016-01-01']
+          [23, 'nom1', "sdfdsfdsfsdf", '2016-01-01'],
+          [25, 'nom2', "sdfdsfdsfsdf", '2016-01-01']
         ]
       end
 
@@ -26,12 +26,10 @@ module ArelExtensions
 
       it "should import large set of data using ToSql" do
         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')]
+        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')]
       end
-
-
-	end
+    end
   end
-end
+end