activerecord-oracle_enhanced-adapter 8.1.0-java

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+describe "OracleEnhancedAdapter handling of DECIMAL 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.decimal :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 DECIMAL column type as decimal" do
+    columns = @conn.columns("test2_employees")
+    column = columns.detect { |c| c.name == "hourly_rate" }
+    expect(column.type).to eq(:decimal)
+  end
+
+  it "should DECIMAL column type returns an exact value" do
+    employee = Test2Employee.create(hourly_rate: 4.40125)
+
+    employee.reload
+
+    expect(employee.hourly_rate).to eq(4.40125)
+  end
+
+  it "should DECIMAL column type rounds if scale is specified and value exceeds scale" do
+    employee = Test2Employee.create(commission_pct: 0.1575)
+
+    employee.reload
+
+    expect(employee.commission_pct).to eq(0.16)
+  end
+end

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

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+describe "OracleEnhancedAdapter dirty object tracking" do
+  include SchemaSpecHelper
+
+  before(:all) do
+    ActiveRecord::Base.establish_connection(CONNECTION_PARAMS)
+    schema_define do
+      create_table :test_employees, force: true do |t|
+        t.string    :first_name,  limit: 20
+        t.string    :last_name,   limit: 25
+        t.integer   :job_id,      limit: 6, null: true
+        t.decimal   :salary,      precision: 8, scale: 2
+        t.text      :comments
+        t.date      :hire_date
+      end
+    end
+
+    class TestEmployee < ActiveRecord::Base
+    end
+  end
+
+  after(:all) do
+    schema_define do
+      drop_table :test_employees
+    end
+    Object.send(:remove_const, "TestEmployee")
+    ActiveRecord::Base.clear_cache!
+  end
+
+  it "should not mark empty string (stored as NULL) as changed when reassigning it" do
+    @employee = TestEmployee.create!(first_name: "")
+    @employee.first_name = ""
+    expect(@employee).not_to be_changed
+    @employee.reload
+    @employee.first_name = ""
+    expect(@employee).not_to be_changed
+  end
+
+  it "should not mark empty integer (stored as NULL) as changed when reassigning it" do
+    @employee = TestEmployee.create!(job_id: "")
+    @employee.job_id = ""
+    expect(@employee).not_to be_changed
+    @employee.reload
+    @employee.job_id = ""
+    expect(@employee).not_to be_changed
+  end
+
+  it "should not mark empty decimal (stored as NULL) as changed when reassigning it" do
+    @employee = TestEmployee.create!(salary: "")
+    @employee.salary = ""
+    expect(@employee).not_to be_changed
+    @employee.reload
+    @employee.salary = ""
+    expect(@employee).not_to be_changed
+  end
+
+  it "should not mark empty text (stored as NULL) as changed when reassigning it" do
+    @employee = TestEmployee.create!(comments: nil)
+    @employee.comments = nil
+    expect(@employee).not_to be_changed
+    @employee.reload
+    @employee.comments = nil
+    expect(@employee).not_to be_changed
+  end
+
+  it "should not mark empty text (stored as empty_clob()) as changed when reassigning it" do
+    @employee = TestEmployee.create!(comments: "")
+    @employee.comments = ""
+    expect(@employee).not_to be_changed
+    @employee.reload
+    @employee.comments = ""
+    expect(@employee).not_to be_changed
+  end
+
+  it "should mark empty text (stored as empty_clob()) as changed when assigning nil to it" do
+    @employee = TestEmployee.create!(comments: "")
+    @employee.comments = nil
+    expect(@employee).to be_changed
+    @employee.reload
+    @employee.comments = nil
+    expect(@employee).to be_changed
+  end
+
+  it "should mark empty text (stored as NULL) as changed when assigning '' to it" do
+    @employee = TestEmployee.create!(comments: nil)
+    @employee.comments = ""
+    expect(@employee).to be_changed
+    @employee.reload
+    @employee.comments = ""
+    expect(@employee).to be_changed
+  end
+
+  it "should not mark empty date (stored as NULL) as changed when reassigning it" do
+    @employee = TestEmployee.create!(hire_date: "")
+    @employee.hire_date = ""
+    expect(@employee).not_to be_changed
+    @employee.reload
+    @employee.hire_date = ""
+    expect(@employee).not_to be_changed
+  end
+
+  it "should not mark integer as changed when reassigning it" do
+    @employee = TestEmployee.new
+    @employee.job_id = 0
+    expect(@employee.save!).to be_truthy
+
+    expect(@employee).not_to be_changed
+
+    @employee.job_id = "0"
+    expect(@employee).not_to be_changed
+  end
+
+  it "should not update unchanged CLOBs" do
+    @conn = nil
+    @raw_connection = nil
+    @employee = TestEmployee.create!(
+      comments: "initial"
+    )
+    expect(@employee.save!).to be_truthy
+    @employee.reload
+    expect(@employee.comments).to eq("initial")
+
+    oci_conn = @conn.instance_variable_get("@raw_connection")
+    class << oci_conn
+      def write_lob(lob, value, is_binary = false); raise "don't do this'"; end
+    end
+    @employee.comments = +"initial"
+    expect(@employee.comments_changed?).to be false
+    expect { @employee.save! }.not_to raise_error
+    class << oci_conn
+      remove_method :write_lob
+    end
+  end
+
+  it "should be able to handle attributes which are not backed by a column" do
+    TestEmployee.create!(comments: "initial")
+    @employee = TestEmployee.select("#{TestEmployee.quoted_table_name}.*, 24 ranking").first
+    expect { @employee.ranking = 25 }.to_not raise_error
+  end
+end

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,101 @@
+# 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.lease_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 = ActiveRecord::Base.lease_connection
+    conn.execute "DROP TABLE test2_employees"
+    conn.execute "DROP SEQUENCE test2_employees_seq"
+    ActiveRecord::Base.release_connection
+  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::ConnectionAdapters::OracleEnhancedAdapter.clear_type_map!
+      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
+
+    it "should return Integer value from NUMBER(1) column if emulate_booleans is set to false" do
+      ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans = false
+      ActiveRecord::Base.establish_connection(CONNECTION_PARAMS)
+      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,56 @@
+# 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 }
+      type = @conn.lookup_cast_type(column.sql_type)
+      value = type.serialize("abc")
+      expect(@conn.quote(value)).to eq(column.sql_type[0, 1] == "N" ? "N'abc'" : "'abc'")
+      nilvalue = type.serialize(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)
+    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 be(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 be(true)
+    expect(@employee).to be_valid
+    @employee.reload
+    expect(@employee.comments).to be_nil
+    @employee.comments = {}
+    expect(@employee.save).to be(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