activerecord-oracle_enhanced-adapter 1.4.3 → 5.2.0

data/spec/active_record/oracle_enhanced/type/float_spec.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+describe "OracleEnhancedAdapter handling of BINARY_FLOAT columns" do
+  include SchemaSpecHelper
+
+  before(:all) do
+    ActiveRecord::Base.establish_connection(CONNECTION_PARAMS)
+    @conn = ActiveRecord::Base.connection
+    schema_define do
+      create_table :test2_employees, force: true do |t|
+        t.string  :first_name, limit: 20
+        t.string  :last_name, limit: 25
+        t.string  :email, limit: 25
+        t.string  :phone_number, limit: 25
+        t.date    :hire_date
+        t.integer :job_id
+        t.integer :salary
+        t.decimal :commission_pct, scale: 2, precision: 2
+        t.float   :hourly_rate
+        t.integer :manager_id,  limit: 6
+        t.integer :is_manager,  limit: 1
+        t.decimal :department_id, scale: 0, precision: 4
+        t.timestamps
+      end
+    end
+    class ::Test2Employee < ActiveRecord::Base
+    end
+  end
+
+  after(:all) do
+    Object.send(:remove_const, "Test2Employee")
+    @conn.drop_table :test2_employees, if_exists:  true
+  end
+
+  it "should set BINARY_FLOAT column type as float" do
+    columns = @conn.columns("test2_employees")
+    column = columns.detect { |c| c.name == "hourly_rate" }
+    expect(column.type).to eq(:float)
+  end
+
+  it "should BINARY_FLOAT column type returns an approximate value" do
+    employee = Test2Employee.create(hourly_rate: 4.4)
+
+    employee.reload
+
+    expect(employee.hourly_rate).to eq(4.400000095367432)
+  end
+end

data/spec/active_record/oracle_enhanced/type/integer_spec.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+describe "OracleEnhancedAdapter integer type detection based on attribute settings" do
+  before(:all) do
+    ActiveRecord::Base.establish_connection(CONNECTION_PARAMS)
+    @conn = ActiveRecord::Base.connection
+    @conn.execute "DROP TABLE test2_employees" rescue nil
+    @conn.execute <<-SQL
+      CREATE TABLE test2_employees (
+        id            NUMBER PRIMARY KEY,
+        first_name    VARCHAR2(20),
+        last_name     VARCHAR2(25),
+        email         VARCHAR2(25),
+        phone_number  VARCHAR2(20),
+        hire_date     DATE,
+        job_id        NUMBER,
+        salary        NUMBER,
+        commission_pct  NUMBER(2,2),
+        manager_id    NUMBER(6),
+        is_manager    NUMBER(1),
+        department_id NUMBER(4,0),
+        created_at    DATE
+      )
+    SQL
+    @conn.execute "DROP SEQUENCE test2_employees_seq" rescue nil
+    @conn.execute <<-SQL
+      CREATE SEQUENCE test2_employees_seq  MINVALUE 1
+        INCREMENT BY 1 START WITH 10040 CACHE 20 NOORDER NOCYCLE
+    SQL
+  end
+
+  after(:all) do
+    @conn.execute "DROP TABLE test2_employees"
+    @conn.execute "DROP SEQUENCE test2_employees_seq"
+  end
+
+  describe "/ NUMBER values from ActiveRecord model" do
+    before(:each) do
+      class ::Test2Employee < ActiveRecord::Base
+      end
+    end
+
+    after(:each) do
+      Object.send(:remove_const, "Test2Employee")
+      ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans = true
+      ActiveRecord::Base.clear_cache!
+    end
+
+    def create_employee2
+      @employee2 = Test2Employee.create(
+        first_name: "First",
+        last_name: "Last",
+        job_id: 1,
+        is_manager: 1,
+        salary: 1000
+      )
+      @employee2.reload
+    end
+
+    it "should return BigDecimal value from NUMBER column if by default" do
+      create_employee2
+      expect(@employee2.job_id.class).to eq(BigDecimal)
+    end
+
+    it "should return Integer value from NUMBER column if attribute is set to integer" do
+      class ::Test2Employee < ActiveRecord::Base
+        attribute :job_id, :integer
+      end
+      create_employee2
+      expect(@employee2.job_id).to be_a(Integer)
+    end
+
+    it "should return Integer value from NUMBER column with integer value using _before_type_cast method" do
+      create_employee2
+      expect(@employee2.job_id_before_type_cast).to be_a(Integer)
+    end
+
+    it "should return Boolean value from NUMBER(1) column if emulate booleans is used" do
+      create_employee2
+      expect(@employee2.is_manager.class).to eq(TrueClass)
+    end
+
+    it "should return Integer value from NUMBER(1) column if attribute is set to integer" do
+      class ::Test2Employee < ActiveRecord::Base
+        attribute :is_manager, :integer
+      end
+      create_employee2
+      expect(@employee2.is_manager).to be_a(Integer)
+    end
+  end
+end

data/spec/active_record/oracle_enhanced/type/json_spec.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+describe "OracleEnhancedAdapter attribute API support for JSON type" do
+
+  include SchemaSpecHelper
+
+  before(:all) do
+    ActiveRecord::Base.establish_connection(CONNECTION_PARAMS)
+    @conn = ActiveRecord::Base.connection
+    @oracle12c_or_higher = !! @conn.select_value(
+      "select * from product_component_version where product like 'Oracle%' and to_number(substr(version,1,2)) >= 12")
+    skip "Not supported in this database version" unless @oracle12c_or_higher
+    ActiveRecord::Base.establish_connection(CONNECTION_PARAMS)
+    schema_define do
+      create_table :test_posts, force: true do |t|
+        t.string  :title
+        t.text    :article
+      end
+      execute "alter table test_posts add constraint test_posts_title_is_json check (title is json)"
+      execute "alter table test_posts add constraint test_posts_article_is_json check (article is json)"
+    end
+
+    class ::TestPost < ActiveRecord::Base
+      attribute :title, :json
+      attribute :article, :json
+    end
+  end
+
+  after(:all) do
+    ActiveRecord::Base.establish_connection(CONNECTION_PARAMS)
+    schema_define do
+      drop_table :test_posts, if_exists: true
+    end
+  end
+
+  before(:each) do
+    TestPost.delete_all
+  end
+
+  it "should support attribute api for JSON" do
+    post = TestPost.create!(title: { "publish" => true, "foo" => "bar" }, article: { "bar" => "baz" })
+    post.reload
+    expect(post.title).to eq ({ "publish" => true, "foo" => "bar" })
+    expect(post.article).to eq ({ "bar" => "baz" })
+    post.title = ({ "publish" => false, "foo" => "bar2" })
+    post.save
+    expect(post.reload.title).to eq ({ "publish" => false, "foo" => "bar2" })
+  end
+
+  it "should support IS JSON" do
+    TestPost.create!(title: { "publish" => true, "foo" => "bar" })
+    count_json = TestPost.where("title is json")
+    expect(count_json.size).to eq 1
+    count_non_json = TestPost.where("title is not json")
+    expect(count_non_json.size).to eq 0
+  end
+end

data/spec/active_record/oracle_enhanced/type/national_character_string_spec.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+describe "OracleEnhancedAdapter quoting of NCHAR and NVARCHAR2 columns" do
+  before(:all) do
+    ActiveRecord::Base.establish_connection(CONNECTION_PARAMS)
+    @conn = ActiveRecord::Base.connection
+    @conn.execute <<-SQL
+      CREATE TABLE test_items (
+        id                  NUMBER(6,0) PRIMARY KEY,
+        nchar_column        NCHAR(20),
+        nvarchar2_column    NVARCHAR2(20),
+        char_column         CHAR(20),
+        varchar2_column     VARCHAR2(20)
+      )
+    SQL
+    @conn.execute "CREATE SEQUENCE test_items_seq"
+  end
+
+  after(:all) do
+    @conn.execute "DROP TABLE test_items"
+    @conn.execute "DROP SEQUENCE test_items_seq"
+  end
+
+  before(:each) do
+    class ::TestItem < ActiveRecord::Base
+    end
+  end
+
+  after(:each) do
+    Object.send(:remove_const, "TestItem")
+    ActiveRecord::Base.clear_cache!
+  end
+
+  it "should quote with N prefix" do
+    columns = @conn.columns("test_items")
+    %w(nchar_column nvarchar2_column char_column varchar2_column).each do |col|
+      column = columns.detect { |c| c.name == col }
+      value = @conn.type_cast_from_column(column, "abc")
+      expect(@conn.quote(value)).to eq(column.sql_type[0, 1] == "N" ? "N'abc'" : "'abc'")
+      nilvalue = @conn.type_cast_from_column(column, nil)
+      expect(@conn.quote(nilvalue)).to eq("NULL")
+    end
+  end
+
+  it "should create record" do
+    nchar_data = "āčē"
+    item = TestItem.create(
+      nchar_column: nchar_data,
+      nvarchar2_column: nchar_data
+    ).reload
+    expect(item.nchar_column).to eq(nchar_data + " " * 17)
+    expect(item.nvarchar2_column).to eq(nchar_data)
+  end
+
+end

data/spec/active_record/oracle_enhanced/type/national_character_text_spec.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+describe "OracleEnhancedAdapter handling of NCLOB columns" do
+  include SchemaSpecHelper
+
+  before(:all) do
+    ActiveRecord::Base.establish_connection(CONNECTION_PARAMS)
+    @conn = ActiveRecord::Base.connection
+    schema_define do
+      create_table :test_employees, force: true do |t|
+        t.string  :first_name, limit: 20
+        t.string  :last_name, limit: 25
+        t.ntext   :comments
+      end
+      create_table :test2_employees, force: true do |t|
+        t.string  :first_name, limit: 20
+        t.string  :last_name, limit: 25
+        t.ntext   :comments
+      end
+      create_table :test_serialize_employees, force: true do |t|
+        t.string  :first_name, limit: 20
+        t.string  :last_name, limit: 25
+      end
+      add_column :test_serialize_employees, :comments, :ntext
+    end
+
+    # Some random multibyte characters. They say Hello (Kon'nichiwa) World (Sekai) in Japanese.
+    @nclob_data = "こんにちは"
+    @nclob_data2 = "世界"
+
+    class ::TestEmployee < ActiveRecord::Base; end
+    class ::Test2Employee < ActiveRecord::Base
+      serialize :comments
+    end
+    class ::TestEmployeeReadOnlyNClob < ActiveRecord::Base
+      self.table_name = "test_employees"
+      attr_readonly :comments
+    end
+    class ::TestSerializeEmployee < ActiveRecord::Base
+      serialize :comments
+      attr_readonly :comments
+    end
+  end
+
+  after(:all) do
+    @conn.drop_table :test_employees, if_exists: true
+    @conn.drop_table :test2_employees, if_exists: true
+    @conn.drop_table :test_serialize_employees, if_exists: true
+    Object.send(:remove_const, "TestEmployee")
+    Object.send(:remove_const, "Test2Employee")
+    Object.send(:remove_const, "TestEmployeeReadOnlyNClob")
+    Object.send(:remove_const, "TestSerializeEmployee")
+    ActiveRecord::Base.clear_cache!
+  end
+
+  it "should create record without NCLOB data when attribute is serialized" do
+    @employee = Test2Employee.create!(
+      first_name: "First",
+      last_name: "Last"
+    )
+    expect(@employee).to be_valid
+    @employee.reload
+    expect(@employee.comments).to be_nil
+  end
+
+  it "should accept Symbol value for NCLOB column" do
+    @employee = TestEmployee.create!(
+      comments: :test_comment
+    )
+    expect(@employee).to be_valid
+  end
+
+  it "should respect attr_readonly setting for NCLOB column" do
+    @employee = TestEmployeeReadOnlyNClob.create!(
+      first_name: "First",
+      comments: @nclob_data
+    )
+    expect(@employee).to be_valid
+    @employee.reload
+    expect(@employee.comments).to eq(@nclob_data)
+    @employee.comments = @nclob_data2
+    expect(@employee.save).to eq(true)
+    @employee.reload
+    expect(@employee.comments).to eq(@nclob_data)
+  end
+
+  it "should work for serialized readonly NCLOB columns", serialized: true do
+    @employee = TestSerializeEmployee.new(
+      first_name: "First",
+      comments: nil
+    )
+    expect(@employee.comments).to be_nil
+    expect(@employee.save).to eq(true)
+    expect(@employee).to be_valid
+    @employee.reload
+    expect(@employee.comments).to be_nil
+    @employee.comments = {}
+    expect(@employee.save).to eq(true)
+    @employee.reload
+    # should not set readonly
+    expect(@employee.comments).to be_nil
+  end
+
+  it "should create record with NCLOB data" do
+    @employee = TestEmployee.create!(
+      first_name: "First",
+      last_name: "Last",
+      comments: @nclob_data
+    )
+    @employee.reload
+    expect(@employee.comments).to eq(@nclob_data)
+  end
+
+  it "should update record with NCLOB data" do
+    @employee = TestEmployee.create!(
+      first_name: "First",
+      last_name: "Last"
+    )
+    @employee.reload
+    expect(@employee.comments).to be_nil
+    @employee.comments = @nclob_data
+    @employee.save!
+    @employee.reload
+    expect(@employee.comments).to eq(@nclob_data)
+  end
+
+  it "should update record with zero-length NCLOB data" do
+    @employee = TestEmployee.create!(
+      first_name: "First",
+      last_name: "Last"
+    )
+    @employee.reload
+    expect(@employee.comments).to be_nil
+    @employee.comments = ""
+    @employee.save!
+    @employee.reload
+    expect(@employee.comments).to eq("")
+  end
+
+  it "should update record that has existing NCLOB data with different NCLOB data" do
+    @employee = TestEmployee.create!(
+      first_name: "First",
+      last_name: "Last",
+      comments: @nclob_data
+    )
+    @employee.reload
+    @employee.comments = @nclob_data2
+    @employee.save!
+    @employee.reload
+    expect(@employee.comments).to eq(@nclob_data2)
+  end
+
+  it "should update record that has existing NCLOB data with nil" do
+    @employee = TestEmployee.create!(
+      first_name: "First",
+      last_name: "Last",
+      comments: @nclob_data
+    )
+    @employee.reload
+    @employee.comments = nil
+    @employee.save!
+    @employee.reload
+    expect(@employee.comments).to be_nil
+  end
+
+  it "should update record that has existing NCLOB data with zero-length NCLOB data" do
+    @employee = TestEmployee.create!(
+      first_name: "First",
+      last_name: "Last",
+      comments: @nclob_data
+    )
+    @employee.reload
+    @employee.comments = ""
+    @employee.save!
+    @employee.reload
+    expect(@employee.comments).to eq("")
+  end
+
+  it "should update record that has zero-length NCLOB data with non-empty NCLOB data" do
+    @employee = TestEmployee.create!(
+      first_name: "First",
+      last_name: "Last",
+      comments: ""
+    )
+    @employee.reload
+    expect(@employee.comments).to eq("")
+    @employee.comments = @nclob_data
+    @employee.save!
+    @employee.reload
+    expect(@employee.comments).to eq(@nclob_data)
+  end
+
+  it "should store serializable ruby data structures" do
+    ruby_data1 = { "arbitrary1" => ["ruby", :data, 123] }
+    ruby_data2 = { "arbitrary2" => ["ruby", :data, 123] }
+    @employee = Test2Employee.create!(
+      comments: ruby_data1
+    )
+    @employee.reload
+    expect(@employee.comments).to eq(ruby_data1)
+    @employee.comments = ruby_data2
+    @employee.save
+    @employee.reload
+    expect(@employee.comments).to eq(ruby_data2)
+  end
+
+  it "should keep unchanged serialized data when other columns changed" do
+    @employee = Test2Employee.create!(
+      first_name: "First",
+      last_name: "Last",
+      comments: @nclob_data
+    )
+    @employee.first_name = "Steve"
+    @employee.save
+    @employee.reload
+    expect(@employee.comments).to eq(@nclob_data)
+  end
+
+  it "should keep serialized data after save" do
+    @employee = Test2Employee.new
+    @employee.comments = { length: { is: 1 } }
+    @employee.save
+    @employee.reload
+    expect(@employee.comments).to eq(length: { is: 1 })
+    @employee.comments = { length: { is: 2 } }
+    @employee.save
+    @employee.reload
+    expect(@employee.comments).to eq(length: { is: 2 })
+  end
+end