sequel 3.21.0 → 3.39.0

data/spec/adapters/oracle_spec.rb

@@ -1,86 +1,98 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
-require "timeout"
 
 unless defined?(ORACLE_DB)
   ORACLE_DB = Sequel.connect('oracle://hr:hr@localhost/XE')
 end
 INTEGRATION_DB = ORACLE_DB unless defined?(INTEGRATION_DB)
 
-if ORACLE_DB.table_exists?(:items)
-  ORACLE_DB.drop_table :items
-end
-ORACLE_DB.create_table :items do
-  varchar2 :name, :size => 50
-  number :value, :size => 38
-  date :date_created
-  index :value
-end
+describe "An Oracle database" do
+  before(:all) do
+    ORACLE_DB.create_table!(:items) do
+      String :name, :size => 50
+      Integer :value
+      Date :date_created
+      index :value
+    end
 
-if ORACLE_DB.table_exists?(:books)
-  ORACLE_DB.drop_table :books
-end
-ORACLE_DB.create_table :books do
-  number :id, :size => 38
-  varchar2 :title, :size => 50
-  number :category_id, :size => 38
-end
+    ORACLE_DB.create_table!(:books) do
+      Integer :id
+      String :title, :size => 50
+      Integer :category_id
+    end
 
-if ORACLE_DB.table_exists?(:categories)
-  ORACLE_DB.drop_table :categories
-end
-ORACLE_DB.create_table :categories do
-  number :id, :size => 38
-  varchar2 :cat_name, :size => 50
-end
+    ORACLE_DB.create_table!(:categories) do
+      Integer :id
+      String :cat_name, :size => 50
+    end
+    @d = ORACLE_DB[:items]
+  end
+  after do
+    @d.delete
+  end
+  after(:all) do
+    ORACLE_DB.drop_table?(:items, :books, :categories)
+  end
 
-describe "An Oracle database" do
   specify "should provide disconnect functionality" do
     ORACLE_DB.execute("select user from dual")
     ORACLE_DB.pool.size.should == 1
     ORACLE_DB.disconnect
     ORACLE_DB.pool.size.should == 0
   end
+
+  specify "should have working view_exists?" do
+    begin
+      ORACLE_DB.view_exists?(:cats).should be_false
+      ORACLE_DB.create_view(:cats, ORACLE_DB[:categories])
+      ORACLE_DB.view_exists?(:cats).should be_true
+      om = ORACLE_DB.identifier_output_method
+      im = ORACLE_DB.identifier_input_method
+      ORACLE_DB.identifier_output_method = :reverse
+      ORACLE_DB.identifier_input_method = :reverse
+      ORACLE_DB.view_exists?(:STAC).should be_true
+      ORACLE_DB.view_exists?(:cats).should be_false
+    ensure
+      ORACLE_DB.identifier_output_method = om
+      ORACLE_DB.identifier_input_method = im
+      ORACLE_DB.drop_view(:cats)
+    end
+  end
+
+  specify "should be able to get current sequence value with SQL" do
+    begin
+      ORACLE_DB.create_table!(:foo){primary_key :id}
+      ORACLE_DB.fetch('SELECT seq_foo_id.nextval FROM DUAL').single_value.should == 1
+    ensure
+      ORACLE_DB.drop_table(:foo)
+    end
+  end
   
   specify "should provide schema information" do
-    books_schema = [
-      [:id, {:char_size=>0, :type=>:number, :allow_null=>true, :type_string=>"NUMBER(38)", :data_size=>22, :precision=>38, :char_used=>false, :scale=>0, :charset_form=>nil, :fsprecision=>38, :lfprecision=>0, :db_type=>"NUMBER(38)"}], 
-      [:title, {:char_size=>50, :type=>:varchar2, :allow_null=>true, :type_string=>"VARCHAR2(50)", :data_size=>50, :precision=>0, :char_used=>false, :scale=>0, :charset_form=>:implicit, :fsprecision=>0, :lfprecision=>0, :db_type=>"VARCHAR2(50)"}], 
-      [:category_id, {:char_size=>0, :type=>:number, :allow_null=>true, :type_string=>"NUMBER(38)", :data_size=>22, :precision=>38, :char_used=>false, :scale=>0, :charset_form=>nil, :fsprecision=>38, :lfprecision=>0, :db_type=>"NUMBER(38)"}]]
-    categories_schema = [
-      [:id, {:char_size=>0, :type=>:number, :allow_null=>true, :type_string=>"NUMBER(38)", :data_size=>22, :precision=>38, :char_used=>false, :scale=>0, :charset_form=>nil, :fsprecision=>38, :lfprecision=>0, :db_type=>"NUMBER(38)"}], 
-      [:cat_name, {:char_size=>50, :type=>:varchar2, :allow_null=>true, :type_string=>"VARCHAR2(50)", :data_size=>50, :precision=>0, :char_used=>false, :scale=>0, :charset_form=>:implicit, :fsprecision=>0, :lfprecision=>0, :db_type=>"VARCHAR2(50)"}]]
-    items_schema = [
-      [:name, {:char_size=>50, :type=>:varchar2, :allow_null=>true, :type_string=>"VARCHAR2(50)", :data_size=>50, :precision=>0, :char_used=>false, :scale=>0, :charset_form=>:implicit, :fsprecision=>0, :lfprecision=>0, :db_type=>"VARCHAR2(50)"}], 
-      [:value, {:char_size=>0, :type=>:number, :allow_null=>true, :type_string=>"NUMBER(38)", :data_size=>22, :precision=>38, :char_used=>false, :scale=>0, :charset_form=>nil, :fsprecision=>38, :lfprecision=>0, :db_type=>"NUMBER(38)"}],
-      [:date_created, {:charset_form=>nil, :type=>:date, :type_string=>"DATE", :fsprecision=>0, :data_size=>7, :lfprecision=>0, :precision=>0, :db_type=>"DATE", :char_used=>false, :char_size=>0, :scale=>0, :allow_null=>true}]]
+    books_schema = [[:id, [:integer, false, true, nil]],
+      [:title, [:string, false, true, nil]],
+      [:category_id, [:integer, false, true, nil]]]
+    categories_schema = [[:id, [:integer, false, true, nil]],
+      [:cat_name, [:string, false, true, nil]]]
+    items_schema = [[:name, [:string, false, true, nil]],
+      [:value, [:integer, false, true, nil]],
+      [:date_created, [:datetime, false, true, nil]]]
      
     {:books => books_schema, :categories => categories_schema, :items => items_schema}.each_pair do |table, expected_schema|
       schema = ORACLE_DB.schema(table)
       schema.should_not be_nil
-      expected_schema.should == schema
+      schema.map{|c, s| [c, s.values_at(:type, :primary_key, :allow_null, :ruby_default)]}.should == expected_schema
     end
   end
   
   specify "should create a temporary table" do
-    ORACLE_DB.create_table :test_tmp, :temporary => true do
+    ORACLE_DB.create_table! :test_tmp, :temp => true do
+      varchar2 :name, :size => 50
       primary_key :id, :integer, :null => false
-      column :name, :text
       index :name, :unique => true
     end
-    
-    ORACLE_DB.sqls.should == [
-      'CREATE GLOBAL TEMPORARY TABLE test_tmp (id integer NOT NULL PRIMARY KEY AUTOINCREMENT, name text)',
-      'CREATE UNIQUE INDEX test_tmp_name_index ON test_tmp (name)'
-    ]
+    ORACLE_DB.drop_table?(:test_tmp)
   end
-end
 
-describe "An Oracle dataset" do
-  before do
-    @d = ORACLE_DB[:items]
-    @d.delete # remove all records
-  end
-  
   specify "should return the correct record count" do
     @d.count.should == 0
     @d << {:name => 'abc', :value => 123}
@@ -106,7 +118,7 @@ describe "An Oracle dataset" do
       {:name => 'def'}
     ]
            
-    @d.order(:value.desc).limit(1).to_a.should == [
+    @d.order(Sequel.desc(:value)).limit(1).to_a.should == [
       {:date_created=>nil, :name => 'def', :value => 789}                                        
     ]
 
@@ -115,7 +127,7 @@ describe "An Oracle dataset" do
       {:date_created=>nil, :name => 'abc', :value => 456} 
     ]
     
-    @d.order(:value.desc).filter(:name => 'abc').to_a.should == [
+    @d.order(Sequel.desc(:value)).filter(:name => 'abc').to_a.should == [
       {:date_created=>nil, :name => 'abc', :value => 456},
       {:date_created=>nil, :name => 'abc', :value => 123} 
     ]
@@ -124,7 +136,7 @@ describe "An Oracle dataset" do
       {:date_created=>nil, :name => 'abc', :value => 123}                                        
     ]
         
-    @d.filter(:name => 'abc').order(:value.desc).limit(1).to_a.should == [
+    @d.filter(:name => 'abc').order(Sequel.desc(:value)).limit(1).to_a.should == [
       {:date_created=>nil, :name => 'abc', :value => 456}                                        
     ]
     
@@ -148,27 +160,27 @@ describe "An Oracle dataset" do
     
     @d.max(:value).to_i.should == 789
     
-    @d.select(:name, :AVG.sql_function(:value)).filter(:name => 'abc').group(:name).to_a.should == [
-      {:name => 'abc', :"avg(value)" => (456+123)/2.0}
+    @d.select(:name, Sequel.function(:AVG, :value).as(:avg)).filter(:name => 'abc').group(:name).to_a.should == [
+      {:name => 'abc', :avg => (456+123)/2.0}
     ]
 
-    @d.select(:AVG.sql_function(:value)).group(:name).order(:name).limit(1).to_a.should == [
-      {:"avg(value)" => (456+123)/2.0}
+    @d.select(Sequel.function(:AVG, :value).as(:avg)).group(:name).order(:name).limit(1).to_a.should == [
+      {:avg => (456+123)/2.0}
     ]
         
-    @d.select(:name, :AVG.sql_function(:value)).group(:name).order(:name).to_a.should == [
-      {:name => 'abc', :"avg(value)" => (456+123)/2.0},
-      {:name => 'def', :"avg(value)" => 789*1.0}
+    @d.select(:name, Sequel.function(:AVG, :value).as(:avg)).group(:name).order(:name).to_a.should == [
+      {:name => 'abc', :avg => (456+123)/2.0},
+      {:name => 'def', :avg => 789*1.0}
     ]
     
-    @d.select(:name, :AVG.sql_function(:value)).group(:name).order(:name).to_a.should == [
-      {:name => 'abc', :"avg(value)" => (456+123)/2.0},
-      {:name => 'def', :"avg(value)" => 789*1.0}
+    @d.select(:name, Sequel.function(:AVG, :value).as(:avg)).group(:name).order(:name).to_a.should == [
+      {:name => 'abc', :avg => (456+123)/2.0},
+      {:name => 'def', :avg => 789*1.0}
     ]
 
-    @d.select(:name, :AVG.sql_function(:value)).group(:name).having(:name => ['abc', 'def']).order(:name).to_a.should == [
-      {:name => 'abc', :"avg(value)" => (456+123)/2.0},
-      {:name => 'def', :"avg(value)" => 789*1.0}
+    @d.select(:name, Sequel.function(:AVG, :value).as(:avg)).group(:name).having(:name => ['abc', 'def']).order(:name).to_a.should == [
+      {:name => 'abc', :avg => (456+123)/2.0},
+      {:name => 'def', :avg => 789*1.0}
     ]
     
     @d.select(:name, :value).filter(:name => 'abc').union(@d.select(:name, :value).filter(:name => 'def')).order(:value).to_a.should == [
@@ -185,8 +197,6 @@ describe "An Oracle dataset" do
     @d << {:name => 'def', :value => 789}
     @d.filter(:name => 'abc').update(:value => 530)
     
-    # the third record should stay the same
-    # floating-point precision bullshit
     @d[:name => 'def'][:value].should == 789
     @d.filter(:value => 530).count.should == 2
   end
@@ -194,9 +204,9 @@ describe "An Oracle dataset" do
   specify "should translate values correctly" do
     @d << {:name => 'abc', :value => 456}
     @d << {:name => 'def', :value => 789}
-    @d.filter(:value > 500).update(:date_created => "to_timestamp('2009-09-09', 'YYYY-MM-DD')".lit)
+    @d.filter('value > 500').update(:date_created => Sequel.lit("to_timestamp('2009-09-09', 'YYYY-MM-DD')"))
     
-    @d[:name => 'def'][:date_created].should == Time.parse('2009-09-09')
+    @d[:name => 'def'][:date_created].strftime('%F').should == '2009-09-09'
   end
   
   specify "should delete records correctly" do
@@ -221,24 +231,20 @@ describe "An Oracle dataset" do
 
     @d.count.should == 1
   end
-end
 
-describe "Joined Oracle dataset" do
-  before do
+  specify "should return correct result" do
     @d1 = ORACLE_DB[:books]
-    @d1.delete # remove all records
+    @d1.delete
     @d1 << {:id => 1, :title => 'aaa', :category_id => 100}
     @d1 << {:id => 2, :title => 'bbb', :category_id => 100}
     @d1 << {:id => 3, :title => 'ccc', :category_id => 101}
     @d1 << {:id => 4, :title => 'ddd', :category_id => 102}
     
     @d2 = ORACLE_DB[:categories]
-    @d2.delete # remove all records
+    @d2.delete
     @d2 << {:id => 100, :cat_name => 'ruby'}
     @d2 << {:id => 101, :cat_name => 'rails'}
-  end
   
-  specify "should return correct result" do
     @d1.join(:categories, :id => :category_id).select(:books__id, :title, :cat_name).order(:books__id).to_a.should == [
       {:id => 1, :title => 'aaa', :cat_name => 'ruby'},
       {:id => 2, :title => 'bbb', :cat_name => 'ruby'},
@@ -257,24 +263,20 @@ describe "Joined Oracle dataset" do
       {:id => 4, :title => 'ddd', :cat_name => nil} 
     ]
     
-    @d1.left_outer_join(:categories, :id => :category_id).select(:books__id, :title, :cat_name).order(:books__id.desc).limit(2, 0).to_a.should == [      
+    @d1.left_outer_join(:categories, :id => :category_id).select(:books__id, :title, :cat_name).reverse_order(:books__id).limit(2, 0).to_a.should == [      
       {:id => 4, :title => 'ddd', :cat_name => nil}, 
       {:id => 3, :title => 'ccc', :cat_name => 'rails'}
     ]      
   end  
-end
 
-describe "Oracle aliasing" do
-  before do
+  specify "should allow columns to be renamed" do
     @d1 = ORACLE_DB[:books]
-    @d1.delete # remove all records
+    @d1.delete
     @d1 << {:id => 1, :title => 'aaa', :category_id => 100}
     @d1 << {:id => 2, :title => 'bbb', :category_id => 100}
     @d1 << {:id => 3, :title => 'bbb', :category_id => 100}
-  end
 
-  specify "should allow columns to be renamed" do
-    @d1.select(:title.as(:name)).order_by(:id).to_a.should == [
+    @d1.select(Sequel.as(:title, :name)).order_by(:id).to_a.should == [
       { :name => 'aaa' },
       { :name => 'bbb' },
       { :name => 'bbb' },
@@ -282,41 +284,14 @@ describe "Oracle aliasing" do
   end
 
   specify "nested queries should work" do
-    @d1.select(:title).group_by(:title).count.should == 2
-  end
-end
-
-describe "Row locks in Oracle" do
-  before do
-    @d1 = ORACLE_DB[:books]
-    @d1.delete # remove all records
-    @d1 << {:id => 1, :title => 'aaa'}
+    ORACLE_DB[:books].select(:title).group_by(:title).count.should == 2
   end
 
   specify "#for_update should use FOR UPDATE" do
-    @d1.for_update.sql.should == "SELECT * FROM BOOKS FOR UPDATE"
+    ORACLE_DB[:books].for_update.sql.should == 'SELECT * FROM "BOOKS" FOR UPDATE'
   end
 
   specify "#lock_style should accept symbols" do
-    @d1.lock_style(:update).sql.should == "SELECT * FROM BOOKS FOR UPDATE"
-  end
-
-  specify "should not update during row lock" do
-    ORACLE_DB.transaction do
-      @d1.filter(:id => 1).for_update.to_a
-      proc do
-        t1 = Thread.start do
-          # wait for unlock
-          Timeout::timeout(0.02) do
-            ORACLE_DB[:books].filter(:id => 1).update(:title => "bbb")
-          end
-        end
-        t1.join
-      end.should raise_error
-      @d1.filter(:id => 1).first[:title].should == "aaa"
-    end
-    t2 = Thread.start { ORACLE_DB[:books].filter(:id => 1).update(:title => "bbb") }
-    t2.join
-    @d1.filter(:id => 1).first[:title].should == "bbb"
+    ORACLE_DB[:books].lock_style(:update).sql.should == 'SELECT * FROM "BOOKS" FOR UPDATE'
   end
 end