arel_extensions 0.8.0

data/test/support/fake_record.rb

@@ -0,0 +1,137 @@
+module FakeRecord
+  class Column < Struct.new(:name, :type)
+  end
+
+  class Connection
+    attr_reader :tables
+    attr_accessor :visitor
+
+    def initialize(visitor = nil)
+      @tables = %w{ users photos developers products}
+      @columns = {
+        'users' => [
+          Column.new('id', :integer),
+          Column.new('name', :string),
+          Column.new('comments', :text),
+          Column.new('bool', :boolean),
+          Column.new('created_at', :date),
+          Column.new('updated_at', :datetime)
+        ],
+        'products' => [
+          Column.new('id', :integer),
+          Column.new('price', :decimal)
+        ]
+      }
+      @columns_hash = {
+        'users' => Hash[@columns['users'].map { |x| [x.name, x] }],
+        'products' => Hash[@columns['products'].map { |x| [x.name, x] }]
+      }
+      @primary_keys = {
+        'users' => 'id',
+        'products' => 'id'
+      }
+      @visitor = visitor
+    end
+
+    def columns_hash table_name
+      @columns_hash[table_name]
+    end
+
+    def primary_key name
+      @primary_keys[name.to_s]
+    end
+
+    def table_exists? name
+      @tables.include? name.to_s
+    end
+
+    def columns name, message = nil
+      @columns[name.to_s]
+    end
+
+    def quote_table_name name
+      "\"#{name.to_s}\""
+    end
+
+    def quote_column_name name
+      "\"#{name.to_s}\""
+    end
+
+    def schema_cache
+      self
+    end
+
+    def quote thing, column = nil
+      if column && !thing.nil?
+        case column.type
+        when :integer
+          thing = thing.to_i
+        when :string
+          thing = thing.to_s
+        end
+      end
+
+      case thing
+      when DateTime
+        "'#{thing.strftime("%Y-%m-%d %H:%M:%S")}'"
+      when Date
+        "'#{thing.strftime("%Y-%m-%d")}'"
+      when true
+        "'t'"
+      when false
+        "'f'"
+      when nil
+        'NULL'
+      when Numeric
+        thing
+      else
+        "'#{thing.to_s.gsub("'", "\\\\'")}'"
+      end
+    end
+  end
+
+  class ConnectionPool
+    class Spec < Struct.new(:config)
+    end
+
+    attr_reader :spec, :connection
+
+    def initialize
+      @spec = Spec.new(:adapter => 'america')
+      @connection = Connection.new
+      @connection.visitor = Arel::Visitors::ToSql.new(connection)
+    end
+
+    def with_connection
+      yield connection
+    end
+
+    def table_exists? name
+      connection.tables.include? name.to_s
+    end
+
+    def columns_hash
+      connection.columns_hash
+    end
+
+    def schema_cache
+      connection
+    end
+
+    def quote thing, column = nil
+      connection.quote thing, column
+    end
+  end
+
+  class Base
+    attr_accessor :connection_pool
+
+    def initialize
+      @connection_pool = ConnectionPool.new
+    end
+
+    def connection
+      connection_pool.connection
+    end
+  end
+end

data/test/test_comparators.rb

@@ -0,0 +1,49 @@
+require 'helper'
+
+module Arel
+  module Nodes
+
+    describe ArelExtensions::Comparators do
+      it "< is equal lt" do
+        relation = Arel::Table.new(:users)
+        mgr = relation.project relation[:id]
+        mgr.where relation[:id]<(10)
+        res = mgr.to_sql
+        res.must_be_like('SELECT "users"."id" FROM "users" WHERE "users"."id" < 10')
+      end
+      
+      it "<= is equal lteq" do
+        relation = Arel::Table.new(:users)
+        mgr = relation.project relation[:id]
+        mgr.where relation[:id]<=(10)
+        res = mgr.to_sql
+        res.must_be_like('SELECT "users"."id" FROM "users" WHERE "users"."id" <= 10')
+      end
+
+      it "> is equal gt" do
+        relation = Arel::Table.new(:users)
+        mgr = relation.project relation[:id]
+        mgr.where relation[:id]>(10)
+        res = mgr.to_sql
+        res.must_be_like('SELECT "users"."id" FROM "users" WHERE "users"."id" > 10')
+      end
+
+      it "< is equal gteq" do
+        relation = Arel::Table.new(:users)
+        mgr = relation.project relation[:id]
+        mgr.where relation[:id]>=(10)
+        res = mgr.to_sql
+        res.must_be_like('SELECT "users"."id" FROM "users" WHERE "users"."id" >= 10')
+      end
+
+      it "should compare with dates" do
+        relation = Table.new(:users)
+        mgr = relation.project relation[:created_at]
+        mgr.where(relation[:created_at] >= Date.new(2016, 3, 31))
+        mgr.to_sql.must_match %{"users"."created_at" >= '2016-03-31'}
+      end
+
+    end
+
+  end
+end

data/test/visitors/test_bulk_insert_oracle.rb

@@ -0,0 +1,30 @@
+require 'helper'
+
+module ArelExtensions
+  module BulkInsertOracle
+    describe 'the oracle bulk insert visitor' do
+      before do
+        @conn = FakeRecord::Base.new
+        @visitor = Arel::Visitors::Oracle.new @conn.connection
+        @table = Arel::Table.new(:users)
+        @cols = ['id', 'name', 'comments', 'created_at']
+        @data = [
+        	[23, 'nom1', "sdfdsfdsfsdf", '2016-01-01'],
+        	[25, 'nom2', "sdfdsfdsfsdf", '2016-01-01']
+        ]
+      end
+
+      def compile node
+        @visitor.accept(node, Arel::Collectors::SQLString.new).value
+      end
+
+      it "should import large set of data in Oracle" do
+      	insert_manager = Arel::InsertManager.new(@conn).into(@table)
+      	insert_manager.bulk_insert(@cols, @data)
+      	sql = compile(insert_manager.ast)
+      	sql.must_be_like %Q[INSERT ALL INTO "users" ("id", "name", "comments", "created_at") VALUES (23, 'nom1', 'sdfdsfdsfsdf', '2016-01-01') INTO "users" ("id", "name", "comments", "created_at") VALUES (25, 'nom2', 'sdfdsfdsfsdf', '2016-01-01') SELECT 1 FROM dual]
+      end
+
+	  end
+  end
+end

data/test/visitors/test_bulk_insert_sqlite.rb

@@ -0,0 +1,31 @@
+require 'helper'
+
+module ArelExtensions
+  module BulkInsertSQLlite
+
+    describe 'the sqlite visitor can bulk insert' do
+      before do
+        @conn = FakeRecord::Base.new
+        @visitor = Arel::Visitors::SQLite.new @conn.connection
+        @table = Arel::Table.new(:users)
+        @cols = ['id', 'name', 'comments', 'created_at']
+        @data = [
+        	[23, 'nom1', "sdfdsfdsfsdf", '2016-01-01'],
+        	[25, 'nom2', "sdfdsfdsfsdf", '2016-01-01']
+        ]
+      end
+      
+      def compile node
+        @visitor.accept(node, Arel::Collectors::SQLString.new).value
+      end
+
+      it "should import large set of data" do
+        insert_manager = 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')]
+      end
+
+	  end
+  end
+end

data/test/visitors/test_bulk_insert_to_sql.rb

@@ -0,0 +1,32 @@
+require 'helper'
+
+module ArelExtensions
+  module BulkInsertToSql
+    describe 'the to_sql visitor can bulk insert' do
+      before do
+        @conn = FakeRecord::Base.new
+        @visitor = Arel::Visitors::ToSql.new @conn.connection
+        @table = Arel::Table.new(:users)
+        @cols = ['id', 'name', 'comments', 'created_at']
+        @data = [
+        	[23, 'nom1', "sdfdsfdsfsdf", '2016-01-01'],
+        	[25, 'nom2', "sdfdsfdsfsdf", '2016-01-01']
+        ]
+      end
+
+      def compile node
+        @visitor.accept(node, Arel::Collectors::SQLString.new).value
+      end
+
+
+      it "should import large set of data using ToSql" do
+      	insert_manager = 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')]
+      end
+
+
+	end
+  end
+end

data/test/visitors/test_oracle.rb

@@ -0,0 +1,105 @@
+require 'helper'
+
+module ArelExtensions
+  module VisitorOracle
+    describe 'the Oracle visitor' do
+      before do
+        @conn = FakeRecord::Base.new
+        @visitor = Arel::Visitors::Oracle.new @conn.connection
+        @table = Arel::Table.new(:users)
+        @attr = @table[:id]
+        @date = Date.new(2016, 3, 31)
+      end
+
+      def compile node
+        @visitor.accept(node, Arel::Collectors::SQLString.new).value
+      end
+
+      # Comparators
+
+      it "should accept comparators on integers" do
+        compile(@table[:id] == 42).must_match %{"users"."id" = 42}
+        compile(@table[:id] == @table[:id]).must_be_like %{"users"."id" = "users"."id"}
+        compile(@table[:id] != 42).must_match %{"users"."id" != 42}
+        compile(@table[:id] > 42).must_match %{"users"."id" > 42}
+        compile(@table[:id] >= 42).must_match %{"users"."id" >= 42}
+        compile(@table[:id] >= @table[:id]).must_be_like %{"users"."id" >= "users"."id"}
+        compile(@table[:id] < 42).must_match %{"users"."id" < 42}
+        compile(@table[:id] <= 42).must_match %{"users"."id" <= 42}
+        compile((@table[:id] <= 42).as('new_name')).must_match %{("users"."id" <= 42) AS new_name}
+      end
+
+      it "should accept comparators on dates" do
+        c = @table[:created_at]
+        u = @table[:updated_at]
+        compile(c > @date).must_be_like %{"users"."created_at" > '2016-03-31'}
+        compile(u >= @date).must_be_like %{"users"."updated_at" >= '2016-03-31'}
+        compile(c < u).must_be_like %{"users"."created_at" < "users"."updated_at"}
+      end
+
+      it "should accept comparators on strings" do
+        c = @table[:name]
+        compile(c == 'test').must_be_like %{"users"."name" = 'test'}
+        compile(c != 'test').must_be_like %{"users"."name" != 'test'}
+        compile(c > 'test').must_be_like %{"users"."name" > 'test'}
+        compile((c >= 'test').as('new_name')).must_be_like %{("users"."name" >= 'test') AS new_name}
+        compile(c <= @table[:comments]).must_be_like %{"users"."name" <= "users"."comments"}
+        compile(c =~ /\Atest\Z/).must_be_like %{REGEXP_LIKE("users"."name", '^test$')}
+        compile(c =~ '^test$').must_be_like %{REGEXP_LIKE("users"."name", '^test$')}
+        compile(c !~ /\Ate\Dst\Z/).must_be_like %{NOT REGEXP_LIKE("users"."name", '^te[^0-9]st$')}
+        compile(c.imatches('%test%')).must_be_like %{LOWER("users"."name") LIKE LOWER('%test%')}
+        compile(c.imatches_any(['%test%', 't2'])).must_be_like %{(LOWER("users"."name") LIKE LOWER('%test%') OR LOWER("users"."name") LIKE LOWER('t2'))}
+        compile(c.idoes_not_match('%test%')).must_be_like %{LOWER("users"."name") NOT LIKE LOWER('%test%')}
+      end
+
+
+      # Maths
+      # DateDiff
+      it "should diff date col and date" do
+        compile(@table[:created_at] - Date.new(2016, 3, 31)).must_match %{"users"."created_at" - '2016-03-31'}
+      end
+
+      it "should diff date col and datetime col" do
+        compile(@table[:created_at] - @table[:updated_at]).must_match %{"users"."created_at" - "users"."updated_at"}
+      end
+
+      it "should diff date col and datetime col with AS" do
+        sql = compile((@table[:updated_at] - @table[:created_at]).as('new_name'))
+        sql.must_be_like %{("users"."updated_at" - "users"."created_at") AS new_name}
+      end
+
+      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.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.must_match %{'2015-06-02' - "users"."updated_at"}
+      end
+
+      it "should accept operators on dates with numbers" do
+        c = @table[:created_at]
+#        u = @table[:updated_at]
+        compile(c - 42).must_be_like %{DATE_SUB("users"."created_at", 42)}
+        compile(c - @table[:id]).must_be_like %{DATE_SUB("users"."created_at", "users"."id")}
+      end
+
+      # Maths on sums
+      it "should accept math operators on anything" do
+        c = @table[:name]
+        (c == 'test').to_sql.must_be_like %{"users"."name" = 'test'}
+        (c != 'test').to_sql.must_be_like %{"users"."name" != 'test'}
+        (c > 'test').to_sql.must_be_like %{"users"."name" > 'test'}
+        compile((c >= 'test').as('new_name')).must_be_like %{("users"."name" >= 'test') AS new_name}
+        compile(c <= @table[:comments]).must_be_like %{"users"."name" <= "users"."comments"}
+        compile(c =~ /\Atest\Z/).must_be_like %{REGEXP_LIKE("users"."name", '^test$')}
+        compile(c !~ /\Ate\Dst\Z/).must_be_like %{NOT REGEXP_LIKE("users"."name", '^te[^0-9]st$')}
+      end
+
+    end
+  end
+end

data/test/visitors/test_to_sql.rb

@@ -0,0 +1,148 @@
+require 'helper'
+require 'set'
+
+module ArelExtensions
+  module VisitorToSql
+    describe 'the to_sql visitor' do
+      before do
+        @conn = FakeRecord::Base.new
+        Arel::Table.engine = @conn
+        @visitor = Arel::Visitors::ToSql.new @conn.connection
+        @table = Arel::Table.new(:users)
+        @attr = @table[:id]
+        @date = Date.new(2016, 3, 31)
+        @price = Arel::Table.new(:products)[:price]
+      end
+
+      def compile node
+        @visitor.accept(node, Arel::Collectors::SQLString.new).value
+      end
+
+      # Math Functions
+
+      it "should not break Arel functions" do
+        compile(@price + 42).must_be_like %{("products"."price" + 42)}
+      end
+
+      it "should return right calculations on numbers" do
+        compile(@price.abs + 42).must_be_like %{(ABS("products"."price") + 42)}
+        compile(@price.ceil + 42).must_be_like %{(CEIL("products"."price") + 42)}
+        compile(@price.floor + 42).must_be_like %{(FLOOR("products"."price") + 42)}
+        compile(@price.ceil + @price.floor).must_be_like %{(CEIL("products"."price") + FLOOR("products"."price"))}
+        compile((@price.ceil + @price.floor).abs).must_be_like %{ABS((CEIL("products"."price") + FLOOR("products"."price")))}
+        compile(@price.round + 42).must_be_like %{(ROUND("products"."price") + 42)}
+        compile(@price.round(2) + 42).must_be_like %{(ROUND("products"."price", 2) + 42)}
+        compile(Arel.rand + 42).must_be_like %{(RAND() + 42)}
+        compile(@price.sum + 42).must_be_like %{(SUM("products"."price") + 42)}
+        compile((@price + 42).sum).must_be_like %{SUM(("products"."price" + 42))}
+        compile((@price + 42).average).must_be_like %{AVG(("products"."price" + 42))}
+        compile((Arel.rand * 9).round + 42).must_be_like %{(ROUND(RAND() * 9) + 42)}        
+        compile((Arel.rand * @price).round(2) + @price).must_be_like %{(ROUND(RAND() * "products"."price", 2) + "products"."price")}        
+      end
+
+      # String Functions
+      it "should accept functions on strings" do
+        c = @table[:name]
+        compile(c + 'test').must_be_like %{"users"."name" || 'test'}
+        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 & 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}
+        compile(c <= @table[:comments]).must_be_like %{"users"."name" <= "users"."comments"}
+        compile(c =~ /\Atest\Z/).must_be_like %{"users"."name" REGEXP '^test$'}
+        compile(c !~ /\Ate\Dst\Z/).must_be_like %{"users"."name" NOT REGEXP '^te[^0-9]st$'}
+        compile(c.imatches('%test%')).must_be_like %{"users"."name" ILIKE '%test%'}
+        compile(c.imatches_any(['%test%', 't2'])).must_be_like %{("users"."name" ILIKE '%test%' OR "users"."name" ILIKE 't2')}
+        compile(c.idoes_not_match('%test%')).must_be_like %{"users"."name" NOT ILIKE '%test%'}
+      end
+
+      # Comparators
+
+      it "should accept comparators on integers" do
+        compile(@table[:id] == 42).must_match %{"users"."id" = 42}
+        compile(@table[:id] == @table[:id]).must_be_like %{"users"."id" = "users"."id"}
+        compile(@table[:id] != 42).must_match %{"users"."id" != 42}
+        compile(@table[:id] > 42).must_match %{"users"."id" > 42}
+        compile(@table[:id] >= 42).must_match %{"users"."id" >= 42}
+        compile(@table[:id] >= @table[:id]).must_be_like %{"users"."id" >= "users"."id"}
+        compile(@table[:id] < 42).must_match %{"users"."id" < 42}
+        compile(@table[:id] <= 42).must_match %{"users"."id" <= 42}
+        compile((@table[:id] <= 42).as('new_name')).must_match %{("users"."id" <= 42) AS new_name}
+      end
+
+      it "should accept comparators on dates" do
+        c = @table[:created_at]
+        u = @table[:updated_at]
+        compile(c > @date).must_be_like %{"users"."created_at" > '2016-03-31'}
+        compile(u >= @date).must_be_like %{"users"."updated_at" >= '2016-03-31'}
+        compile(c < u).must_be_like %{"users"."created_at" < "users"."updated_at"}
+      end
+
+      it "should accept comparators on strings" do
+        c = @table[:name]
+        compile(c == 'test').must_be_like %{"users"."name" = 'test'}
+        compile(c != 'test').must_be_like %{"users"."name" != 'test'}
+        compile(c > 'test').must_be_like %{"users"."name" > 'test'}
+        compile((c >= 'test').as('new_name')).must_be_like %{("users"."name" >= 'test') AS new_name}
+        compile(c <= @table[:comments]).must_be_like %{"users"."name" <= "users"."comments"}
+        compile(c =~ /\Atest\Z/).must_be_like %{"users"."name" REGEXP '^test$'}
+        compile(c !~ /\Ate\Dst\Z/).must_be_like %{"users"."name" NOT REGEXP '^te[^0-9]st$'}
+        compile(c.imatches('%test%')).must_be_like %{"users"."name" ILIKE '%test%'}
+        compile(c.imatches_any(['%test%', 't2'])).must_be_like %{("users"."name" ILIKE '%test%' OR "users"."name" ILIKE 't2')}
+        compile(c.idoes_not_match('%test%')).must_be_like %{"users"."name" NOT ILIKE '%test%'}
+      end
+
+
+      # Maths
+      # DateDiff
+      it "should diff date col and date" do
+        compile(@table[:created_at] - Date.new(2016, 3, 31)).must_match %{DATEDIFF("users"."created_at", '2016-03-31')}
+      end
+
+      it "should diff date col and datetime col" do
+        compile(@table[:created_at] - @table[:updated_at]).must_match %{DATEDIFF("users"."created_at", "users"."updated_at")}
+      end
+
+      it "should diff date col and datetime col with AS" do
+        sql = compile((@table[:updated_at] - @table[:created_at]).as('new_name'))
+        sql.must_match %{DATEDIFF("users"."updated_at", "users"."created_at") AS new_name}
+      end
+
+      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.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.must_match %{DATEDIFF('2015-06-02', "users"."updated_at")}
+      end
+
+      it "should accept operators on dates with numbers" do
+        c = @table[:created_at]
+#        u = @table[:updated_at]
+        compile(c - 42).must_be_like %{DATE_SUB("users"."created_at", 42)}
+        compile(c - @table[:id]).must_be_like %{DATE_SUB("users"."created_at", "users"."id")}
+      end
+
+      # Maths on sums
+      it "should accept math operators on anything" do
+        c = @table[:name]
+        (c == 'test').to_sql.must_be_like %{"users"."name" = 'test'}
+        (c != 'test').to_sql.must_be_like %{"users"."name" != 'test'}
+        (c > 'test').to_sql.must_be_like %{"users"."name" > 'test'}
+        compile((c >= 'test').as('new_name')).must_be_like %{("users"."name" >= 'test') AS new_name}
+        compile(c <= @table[:comments]).must_be_like %{"users"."name" <= "users"."comments"}
+        compile(c =~ /\Atest\Z/).must_be_like %{"users"."name" REGEXP '^test$'}
+        compile(c !~ /\Ate\Dst\Z/).must_be_like %{"users"."name" NOT REGEXP '^te[^0-9]st$'}
+      end
+
+    end
+  end
+end