arel_extensions 0.8.4 → 0.8.5

data/lib/arel_extensions/visitors/postgresql.rb

@@ -1,6 +1,7 @@
 module ArelExtensions
   module Visitors
     Arel::Visitors::PostgreSQL.class_eval do
+      Arel::Visitors::PostgreSQL::DATE_MAPPING = {'d' => 'DAY', 'm' => 'MONTH', 'w' => 'WEEK', 'y' => 'YEAR', 'wd' => 'DOW'}
 
       def visit_ArelExtensions_Nodes_Rand o, collector
         collector << "RANDOM("
@@ -91,17 +92,7 @@ module ArelExtensions
       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 << "EXTRACT(#{Arel::Visitors::PostgreSQL::DATE_MAPPING[o.left]} FROM "
         collector = visit o.right, collector
         collector << ")"
         collector
@@ -130,7 +121,7 @@ module ArelExtensions
       end
 
       def visit_ArelExtensions_Nodes_Wday o, collector
-        collector << "DATE_PART('dow', "
+        collector << "EXRTACT(DOW, "
         collector = visit o.date, collector
         collector << ")"
         collector

data/lib/arel_extensions/visitors/sqlite.rb

@@ -1,6 +1,7 @@
 module ArelExtensions
   module Visitors
     Arel::Visitors::SQLite.class_eval do
+      Arel::Visitors::SQLite::DATE_MAPPING = {'d' => '%d', 'm' => '%m', 'w' => '%W', 'y' => '%Y', 'wd' => '%w', 'M' => '%M'}
 
       #String functions
       def visit_ArelExtensions_Nodes_IMatches o, collector # insensitive on ASCII
@@ -47,17 +48,7 @@ module ArelExtensions
       end
 
       def visit_ArelExtensions_Nodes_Duration o, collector
-        #visit left for period
-        if(o.left == "d")
-          collector << "strftime('%d',"
-        elsif(o.left == "m")
-          collector << "strftime('%m',"
-        elsif (o.left == "w")
-          collector << "strftime('%W',"
-        elsif (o.left == "y")
-          collector << "strftime('%Y',"
-        end
-        #visit right
+        collector << "strftime('#{Arel::Visitors::SQLite::DATE_MAPPING[o.left]}'#{Arel::Visitors::SQLite::COMMA}"
         collector = visit o.right, collector
         collector << ")"
         collector

data/lib/arel_extensions/visitors/to_sql.rb

@@ -55,10 +55,12 @@ module ArelExtensions
 
       # String functions
       def visit_ArelExtensions_Nodes_Concat o, collector
+        collector << '('
         o.expressions.each_with_index { |arg, i|
           collector = visit arg, collector
           collector << ' || ' unless i == o.expressions.length - 1
         }
+        collector << ")"
         collector
       end
 
@@ -150,6 +152,26 @@ module ArelExtensions
         collector
       end
 
+      def visit_ArelExtensions_Nodes_Format o, collector
+        case o.col_type
+        when :date, :datetime
+          collector << "STRFTIME("
+          collector = visit o.right, collector
+          collector << Arel::Visitors::ToSql::COMMA
+          collector = visit o.left, collector
+          collector << ")"
+        when :integer, :float, :decimal
+          collector << "FORMAT("
+          collector = visit o.left, collector
+          collector << Arel::Visitors::ToSql::COMMA
+          collector = visit o.right, collector
+          collector << ")"
+        else
+          collector = visit o.left, collector
+        end
+        collector
+      end
+
   	  #comparators
 
       def visit_ArelExtensions_Nodes_Coalesce o, collector

data/test/database.yml

@@ -27,11 +27,13 @@ jdbc-postgresql:
 oracle:
   adapter: oracle_enhanced
   database: xe
-  username: travis
+  username: ruby
+  password: oci8
 jdbc-oracle:
   adapter: oracle_enhanced
   database: xe
-  username: travis
+  username: ruby
+  password: oci8
 ibm_db:
   adapter:  ibm_db
   username: travis

data/test/support/alter_system_user_password.sql

@@ -0,0 +1,2 @@
+alter user sys identified by admin;
+alter user system identified by admin;

data/test/support/create_oracle_enhanced_users.sql

@@ -0,0 +1,29 @@
+CREATE USER oracle_enhanced IDENTIFIED BY oracle_enhanced;
+
+GRANT unlimited tablespace, create session, create table, create sequence,
+create procedure, create trigger, create view, create materialized view,
+create database link, create synonym, create type, ctxapp TO oracle_enhanced;
+
+CREATE USER oracle_enhanced_schema IDENTIFIED BY oracle_enhanced_schema;
+
+GRANT unlimited tablespace, create session, create table, create sequence,
+create procedure, create trigger, create view, create materialized view,
+create database link, create synonym, create type, ctxapp TO oracle_enhanced_schema;
+
+CREATE USER arunit IDENTIFIED BY arunit;
+
+GRANT unlimited tablespace, create session, create table, create sequence,
+create procedure, create trigger, create view, create materialized view,
+create database link, create synonym, create type, ctxapp TO arunit;
+
+CREATE USER arunit2 IDENTIFIED BY arunit2;
+
+GRANT unlimited tablespace, create session, create table, create sequence,
+create procedure, create trigger, create view, create materialized view,
+create database link, create synonym, create type, ctxapp TO arunit2;
+
+CREATE USER ruby IDENTIFIED BY oci8;
+GRANT connect, resource, create view,create synonym TO ruby;
+GRANT EXECUTE ON dbms_lock TO ruby;
+GRANT CREATE VIEW TO ruby;
+GRANT unlimited tablespace to ruby;

data/test/visitors/test_to_sql.rb

@@ -46,8 +46,8 @@ module ArelExtensions
       # 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 + '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('test', "users"."name")}

data/test/with_ar/all_agnostic_test.rb

@@ -7,7 +7,13 @@ module ArelExtensions
     class ListTest < Minitest::Test
       def setup_db
         ActiveRecord::Base.configurations = YAML.load_file('test/database.yml')
-        ActiveRecord::Base.establish_connection(ENV['DB'].try(:to_sym) || (RUBY_PLATFORM == 'java' ? :"jdbc-sqlite" : :sqlite))
+        if ENV['DB'] == 'oracle' && ((defined?(RUBY_ENGINE) && RUBY_ENGINE == "rbx") || (RUBY_PLATFORM == 'java')) # not supported
+          @env_db = (RUBY_PLATFORM == 'java' ? "jdbc-sqlite" : 'sqlite')
+          skip "Platform not supported"
+        else
+          @env_db = ENV['DB']
+        end
+        ActiveRecord::Base.establish_connection(@env_db.try(:to_sym) || (RUBY_PLATFORM == 'java' ? :"jdbc-sqlite" : :sqlite))
         ActiveRecord::Base.default_timezone = :utc
         @cnx = ActiveRecord::Base.connection
         $sqlite ||= false
@@ -31,12 +37,12 @@ module ArelExtensions
             end
           end
         end
-        if File.exist?("init/#{ENV['DB']}.sql")
-          sql = File.read("init/#{ENV['DB']}.sql")
+        if File.exist?("init/#{@env_db}.sql")
+          sql = File.read("init/#{@env_db}.sql")
           @cnx.execute(sql) unless sql.blank?
         end
-        @cnx.drop_table(:users) rescue nil 
-        @cnx.create_table :users do |t|
+        @cnx.drop_table(:user_tests) rescue nil 
+        @cnx.create_table :user_tests do |t|
           t.column :age, :integer
           t.column :name, :string
           t.column :comments, :text
@@ -44,23 +50,19 @@ module ArelExtensions
           t.column :updated_at, :datetime
           t.column :score, :decimal, :precision => 20, :scale => 10
         end
-        @cnx.drop_table(:products) rescue nil
-        @cnx.create_table :products do |t|
+        @cnx.drop_table(:product_tests) rescue nil
+        @cnx.create_table :product_tests do |t|
           t.column :price, :decimal, :precision => 20, :scale => 10
         end
       end
 
-      def teardown_db
-        @cnx.drop_table(:users)
-        @cnx.drop_table(:products)
-      end
-
       class User < ActiveRecord::Base
+        self.table_name = 'user_tests'
       end
       class Product < ActiveRecord::Base
+        self.table_name = 'product_tests'
       end
 
-
       def setup
         d = Date.new(2016,05,23)
         setup_db
@@ -90,7 +92,8 @@ module ArelExtensions
       end
 
       def teardown
-        teardown_db
+        @cnx.drop_table(:user_tests)
+        @cnx.drop_table(:product_tests)
       end
 
       def t(scope, node)
@@ -109,17 +112,15 @@ module ArelExtensions
       end
 
       def test_ceil
-        if !$sqlite || !$load_extension_disabled
-          assert_equal 1, t(@neg, @score.ceil)
-          assert_equal 63, t(@arthur, @age.ceil + 42)
-        end
+        skip "Sqlite version can't load extension for ceil" if $sqlite && $load_extension_disabled
+        assert_equal 1, t(@neg, @score.ceil)
+        assert_equal 63, t(@arthur, @age.ceil + 42)
       end
 
       def test_floor
-        if !$sqlite || !$load_extension_disabled
-          assert_equal 0, t(@neg, @score.floor)
-          assert_equal 42, t(@arthur, @score.floor - 23)
-        end
+        skip "Sqlite version can't load extension for floor" if $sqlite && $load_extension_disabled
+        assert_equal 0, t(@neg, @score.floor)
+        assert_equal 42, t(@arthur, @score.floor - 23)
       end
 
       def test_rand
@@ -146,8 +147,8 @@ module ArelExtensions
       def test_concat
         assert_equal 'Camille Camille', t(@camille, @name + ' ' + @name)
         assert_equal 'Laure 2', t(@laure, @name + ' ' + 2)
-        if ENV['DB'] == 'postgresql'
-          assert_equal "Lucas Sophie", t(User.reorder(nil).from(User.select(:name).where(:name => ['Lucas', 'Sophie']).reorder(:name).as('users')), @name.group_concat(' '))
+        if @env_db == 'postgresql'
+          assert_equal "Lucas Sophie", t(User.reorder(nil).from(User.select(:name).where(:name => ['Lucas', 'Sophie']).reorder(:name).as('user_tests')), @name.group_concat(' '))
         else
           assert_equal "Lucas Sophie", t(User.where(:name => ['Lucas', 'Sophie']).reorder(:name), @name.group_concat(' '))
         end
@@ -160,32 +161,35 @@ module ArelExtensions
       end
 
       def test_locate
-        if !$sqlite || !$load_extension_disabled
-          assert_equal 1, t(@camille, @name.locate("C"))
-          assert_equal 0, t(@lucas, @name.locate("z"))
-          assert_equal 5, t(@lucas, @name.locate("s"))
-        end
+        skip "Sqlite version can't load extension for locate" if $sqlite && $load_extension_disabled
+        assert_equal 1, t(@camille, @name.locate("C"))
+        assert_equal 0, t(@lucas, @name.locate("z"))
+        assert_equal 5, t(@lucas, @name.locate("s"))
       end
 
       def test_find_in_set
-        if !$sqlite || !$load_extension_disabled
-          assert 4, t(@neg, @comments & 2)
-          assert 2, t(@neg, @comments & 6)
-        end
+        skip "Sqlite version can't load extension for find_in_set" if $sqlite && $load_extension_disabled
+        assert_equal 5, t(@neg, @comments & 2)
+        assert_equal 0, t(@neg, @comments & 6) # not found
       end
 
       def test_string_comparators
-        assert 1, t(@neg, @name >= 'test')
-        assert 1, t(@neg, @name <= @comments)
+        skip "Oracle can't use math operators to compare strings, any function to do that?" if @env_db == 'oracle'
+        if @env_db == 'postgresql' # may return real boolean
+          assert t(@neg, @name >= 'Mest') == true || t(@neg, @name >= 'Mest') == 't' # depends of ar version
+          assert t(@neg, @name <= (@name + 'Z')) == true || t(@neg, @name <= (@name + 'Z')) == 't'
+        else
+          assert_equal 1, t(@neg, @name >= 'Mest')
+          assert_equal 1, t(@neg, @name <= (@name + 'Z'))
+        end
       end
 
-      def test_regexp_not_regex
-        if !$sqlite || !$load_extension_disabled
-          assert_equal 1, User.where(@name =~ '^M').count
-          assert_equal 6, User.where(@name !~ '^L').count
-          assert_equal 1, User.where(@name =~ /^M/).count
-          assert_equal 6, User.where(@name !~ /^L/).count
-        end
+      def test_regexp_not_regexp
+        skip "Sqlite version can't load extension for regexp" if $sqlite && $load_extension_disabled
+        assert_equal 1, User.where(@name =~ '^M').count
+        assert_equal 6, User.where(@name !~ '^L').count
+        assert_equal 1, User.where(@name =~ /^M/).count
+        assert_equal 6, User.where(@name !~ /^L/).count
       end
 
       def test_imatches
@@ -195,26 +199,27 @@ module ArelExtensions
       end
 
       def test_replace
-        assert_equal "LucaX", t(@lucas, @name.replace("s","X"))
-        assert_equal "replace", t(@lucas, @name.replace(@name,"replace"))
+        assert_equal "LucaX", t(@lucas, @name.replace("s", "X"))
+        assert_equal "replace", t(@lucas, @name.replace(@name, "replace"))
       end
 
       def test_soundex
-        if (!$sqlite || !$load_extension_disabled) && (ENV['DB'] != 'postgresql')
-          assert_equal "C540", t(@camille, @name.soundex)
-          assert_equal 8, User.where(@name.soundex.eq(@name.soundex)).count
-        end
+        skip "Sqlite version can't load extension for soundex" if $sqlite && $load_extension_disabled
+        skip "PostgreSql version can't load extension for soundex" if @env_db == 'postgresql'
+        assert_equal "C540", t(@camille, @name.soundex)
+        assert_equal 8, User.where(@name.soundex.eq(@name.soundex)).count
       end
 
       def test_trim
         assert_equal "Myun", t(@myung, @name.rtrim("g"))
         assert_equal "yung", t(@myung, @name.ltrim("M"))
         assert_equal "yung", t(@myung, (@name + "M").trim("M"))
+        skip "Oracle does not accept multi char trim" if @env_db == 'oracle'
         assert_equal "", t(@myung, @name.rtrim(@name))
       end
 
       def test_coalesce
-        if ENV['DB'] == 'postgresql'
+        if @env_db == 'postgresql'
           assert_equal 100, t(@test, @age.coalesce(100))
           assert_equal "Camille", t(@camille, @name.coalesce(nil, "default"))
           assert_equal 20, t(@test, @age.coalesce(nil, 20))
@@ -224,7 +229,10 @@ module ArelExtensions
         end
       end
 
-      def test_comparator
+
+
+      # Comparators
+      def test_number_comparator
         assert_equal 2, User.where(@age < 6).count
         assert_equal 2, User.where(@age <= 10).count
         assert_equal 3, User.where(@age > 20).count
@@ -232,27 +240,31 @@ module ArelExtensions
         assert_equal 1, User.where(@age > 5).where(@age < 20).count
       end
 
+      def test_date_comparator
+        d = Date.new(2016,05,23)
+        assert_equal 0, User.where(@created_at < d).count
+        assert_equal 8, User.where(@created_at >= d).count
+      end
+
       def test_date_duration
         #Year
-        assert_equal 2016, @lucas.select((User.arel_table[:created_at].year).as("res")).first.res.to_i
+        assert_equal 2016, t(@lucas, @created_at.year).to_i
         assert_equal 0, User.where(@created_at.year.eq("2012")).count
         #Month
-        assert_equal 5, @camille.select((User.arel_table[:created_at].month).as("res")).first.res.to_i
-        assert_equal 8,User.where(User.arel_table[:created_at].month.eq("05")).count
+        assert_equal 5, t(@camille, @created_at.month).to_i
+        assert_equal 8, User.where(@created_at.month.eq("05")).count
         #Week
-        assert_equal 21,User.where(User.arel_table[:name].eq("Arthur")).select((User.arel_table[:created_at].week).as("res")).first.res.to_i
-        assert_equal 8,User.where(User.arel_table[:created_at].month.eq("05")).count
+        assert_equal 21, t(@arthur, @created_at.week).to_i
+        assert_equal 8, User.where(@created_at.month.eq("05")).count
         #Day
-        assert_equal 23,User.where(User.arel_table[:name].eq("Laure")).select((User.arel_table[:created_at].day).as("res")).first.res.to_i
-        assert_equal 0,User.where(User.arel_table[:created_at].day.eq("05")).count
+        assert_equal 23, t(@laure, @created_at.day).to_i
+        assert_equal 0, User.where(@created_at.day.eq("05")).count
       end
 
-
       def test_is_null
         assert_equal "Test", User.where(@age.is_null).select(@name).first.name
       end
 
-
       def test_math_plus
         d = Date.new(1997, 6, 15)
         #Concat String
@@ -261,7 +273,8 @@ module ArelExtensions
         assert_equal "Sophie1997-06-15", t(@sophie, @name + d)
         assert_equal "Sophie15", t(@sophie, @name + @age)
         assert_equal "SophieSophie", t(@sophie, @name + @name)
-        assert_equal "Sophie2016-05-23", t(@sophie, @name + @created_at)
+        #FIXME: should work as expected in Oracle
+        assert_equal "Sophie2016-05-23", t(@sophie, @name + @created_at) unless @env_db == 'oracle'
         #concat Integer
         assert_equal 1, User.where((@age + 10).eq(33)).count
         assert_equal 1, User.where((@age + "1").eq(6)).count
@@ -276,8 +289,8 @@ module ArelExtensions
       def test_math_moins
         d = Date.new(2016,05,20)
         #Datediff
-        assert_equal 8, User.where((User.arel_table[:created_at] - User.arel_table[:created_at]).eq(0)).count
-        assert_equal 3, User.where(User.arel_table[:name].eq("Laure")).select((User.arel_table[:created_at] - d).as("res")).first.res.abs.to_i
+        assert_equal 8, User.where((@created_at - User.arel_table[:created_at]).eq(0)).count
+        assert_equal 3, @laure.select((User.arel_table[:created_at] - d).as("res")).first.res.abs.to_i
         #Substraction
         assert_equal 0, User.where((@age - 10).eq(50)).count
         assert_equal 0, User.where((@age - "10").eq(50)).count
@@ -285,7 +298,7 @@ module ArelExtensions
 
       def test_wday
         d = Date.new(2016, 6, 26)
-        assert_equal 1, t(@myung, @created_at.wday).to_i
+        assert_equal (@env_db == 'oracle' ? 2 : 1), t(@myung, @created_at.wday).to_i # monday
         assert_equal 0, User.select(d.wday).as("res").first.to_i
       end
 

data/test/with_ar/insert_agnostic_test.rb

@@ -7,16 +7,22 @@ module ArelExtensions
     class InsertManagerTest < Minitest::Test
       def setup_db
         ActiveRecord::Base.configurations = YAML.load_file('test/database.yml')
-        ActiveRecord::Base.establish_connection(ENV['DB'].try(:to_sym) || (RUBY_PLATFORM == 'java' ? :"jdbc-sqlite" : :sqlite))
+        if ENV['DB'] == 'oracle' && ((defined?(RUBY_ENGINE) && RUBY_ENGINE == "rbx") || (RUBY_PLATFORM == 'java')) # not supported
+          @env_db = (RUBY_PLATFORM == 'java' ? "jdbc-sqlite" : 'sqlite')
+          skip "Platform not supported"
+        else
+          @env_db = ENV['DB']
+        end
+        ActiveRecord::Base.establish_connection(@env_db.try(:to_sym) || (RUBY_PLATFORM == 'java' ? :"jdbc-sqlite" : :sqlite))
         ActiveRecord::Base.default_timezone = :utc
         @cnx = ActiveRecord::Base.connection
         Arel::Table.engine = ActiveRecord::Base
-        if File.exist?("init/#{ENV['DB']}.sql")
-          sql = File.read("init/#{ENV['DB']}.sql")
+        if File.exist?("init/#{@env_db}.sql")
+          sql = File.read("init/#{@env_db}.sql")
           @cnx.execute(sql) unless sql.blank?
         end
-        @cnx.drop_table(:users) rescue nil 
-        @cnx.create_table :users do |t|
+        @cnx.drop_table(:user_tests) rescue nil 
+        @cnx.create_table :user_tests do |t|
           t.column :age, :integer
           t.column :name, :string
           t.column :comments, :text
@@ -28,7 +34,7 @@ module ArelExtensions
 
       def setup
         setup_db
-        @table = Arel::Table.new(:users)
+        @table = Arel::Table.new(:user_tests)
         @cols = ['id', 'name', 'comments', 'created_at']
         @data = [
           [23, 'nom1', "sdfdsfdsfsdfsd fdsf dsf dsf sdf afdg fsdg sg sd gsdfg e 54435 344", '2016-01-01'],
@@ -37,7 +43,7 @@ module ArelExtensions
       end
 
       def teardown
-        @cnx.drop_table(:users)
+        @cnx.drop_table(:user_tests)
       end
 
       # Math Functions