activerecord-oracle_enhanced-adapter 8.1.0-java

data/spec/active_record/connection_adapters/oracle_enhanced_data_types_spec.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+describe "OracleEnhancedAdapter date and datetime type detection based on attribute settings" do
+  before(:all) do
+    ActiveRecord::Base.establish_connection(CONNECTION_PARAMS)
+    @conn = ActiveRecord::Base.connection
+    @conn.execute "DROP TABLE test_employees" rescue nil
+    @conn.execute "DROP SEQUENCE test_employees_seq" rescue nil
+    @conn.execute <<~SQL
+      CREATE TABLE test_employees (
+        employee_id   NUMBER(6,0) PRIMARY KEY,
+        first_name    VARCHAR2(20),
+        last_name     VARCHAR2(25),
+        email         VARCHAR2(25),
+        phone_number  VARCHAR2(20),
+        hire_date     DATE,
+        job_id        NUMBER(6,0),
+        salary        NUMBER(8,2),
+        commission_pct  NUMBER(2,2),
+        manager_id    NUMBER(6,0),
+        department_id NUMBER(4,0),
+        created_at    DATE,
+        updated_at    DATE
+      )
+    SQL
+    @conn.execute <<~SQL
+      CREATE SEQUENCE test_employees_seq  MINVALUE 1
+        INCREMENT BY 1 START WITH 10040 CACHE 20 NOORDER NOCYCLE
+    SQL
+  end
+
+  after(:all) do
+    @conn.execute "DROP TABLE test_employees"
+    @conn.execute "DROP SEQUENCE test_employees_seq"
+  end
+
+  describe "/ DATE values from ActiveRecord model" do
+    before(:each) do
+      class ::TestEmployee < ActiveRecord::Base
+        self.primary_key = "employee_id"
+      end
+    end
+
+    def create_test_employee(params = {})
+      @today = params[:today] || Date.new(2008, 8, 19)
+      @now = params[:now] || Time.local(2008, 8, 19, 17, 03, 59)
+      @employee = TestEmployee.create(
+        first_name: "First",
+        last_name: "Last",
+        hire_date: @today,
+        created_at: @now
+      )
+      @employee.reload
+    end
+
+    after(:each) do
+      Object.send(:remove_const, "TestEmployee")
+      ActiveRecord::Base.clear_cache!
+    end
+
+    it "should return Date value from DATE column by default" do
+      create_test_employee
+      expect(@employee.hire_date.class).to eq(Date)
+    end
+
+    it "should return Date value from DATE column with old date value by default" do
+      create_test_employee(today: Date.new(1900, 1, 1))
+      expect(@employee.hire_date.class).to eq(Date)
+    end
+
+    it "should return Time value from DATE column if attribute is set to :datetime" do
+      class ::TestEmployee < ActiveRecord::Base
+        attribute :hire_date, :datetime
+      end
+      create_test_employee
+      expect(@employee.hire_date.class).to eq(Time)
+      # change to current time with hours, minutes and seconds
+      @employee.hire_date = @now
+      @employee.save!
+      @employee.reload
+      expect(@employee.hire_date.class).to eq(Time)
+      expect(@employee.hire_date).to eq(@now)
+    end
+  end
+end
+
+describe "OracleEnhancedAdapter assign string to :date and :datetime 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.date      :hire_date
+        t.date      :last_login_at
+        t.datetime  :last_login_at_ts
+      end
+    end
+    class ::TestEmployee < ActiveRecord::Base
+      attribute :last_login_at, :datetime
+    end
+    @today = Date.new(2008, 6, 28)
+    @today_iso = "2008-06-28"
+    @today_nls = "28.06.2008"
+    @nls_date_format = "%d.%m.%Y"
+    @now = Time.local(2008, 6, 28, 13, 34, 33)
+    @now_iso = "2008-06-28 13:34:33"
+    @now_nls = "28.06.2008 13:34:33"
+    @nls_time_format = "%d.%m.%Y %H:%M:%S"
+    @now_nls_with_tz = "28.06.2008 13:34:33+05:00"
+    @nls_with_tz_time_format = "%d.%m.%Y %H:%M:%S%Z"
+    @now_with_tz = Time.parse @now_nls_with_tz
+  end
+
+  after(:all) do
+    Object.send(:remove_const, "TestEmployee")
+    @conn.drop_table :test_employees, if_exists: true
+    ActiveRecord::Base.clear_cache!
+  end
+
+  after(:each) do
+    ActiveRecord.default_timezone = :utc
+  end
+
+  it "should assign ISO string to date column" do
+    @employee = TestEmployee.create(
+      first_name: "First",
+      last_name: "Last",
+      hire_date: @today_iso
+    )
+    expect(@employee.hire_date).to eq(@today)
+    @employee.reload
+    expect(@employee.hire_date).to eq(@today)
+  end
+
+  it "should assign NLS string to date column" do
+    @employee = TestEmployee.create(
+      first_name: "First",
+      last_name: "Last",
+      hire_date: @today_nls
+    )
+    expect(@employee.hire_date).to eq(@today)
+    @employee.reload
+    expect(@employee.hire_date).to eq(@today)
+  end
+
+  it "should assign ISO time string to date column" do
+    @employee = TestEmployee.create(
+      first_name: "First",
+      last_name: "Last",
+      hire_date: @now_iso
+    )
+    expect(@employee.hire_date).to eq(@today)
+    @employee.reload
+    expect(@employee.hire_date).to eq(@today)
+  end
+
+  it "should assign NLS time string to date column" do
+    @employee = TestEmployee.create(
+      first_name: "First",
+      last_name: "Last",
+      hire_date: @now_nls
+    )
+    expect(@employee.hire_date).to eq(@today)
+    @employee.reload
+    expect(@employee.hire_date).to eq(@today)
+  end
+
+  it "should assign ISO time string to datetime column" do
+    ActiveRecord.default_timezone = :local
+    @employee = TestEmployee.create(
+      first_name: "First",
+      last_name: "Last",
+      last_login_at: @now_iso
+    )
+    expect(@employee.last_login_at).to eq(@now)
+    @employee.reload
+    expect(@employee.last_login_at).to eq(@now)
+  end
+
+  it "should assign NLS time string to datetime column" do
+    ActiveRecord.default_timezone = :local
+    @employee = TestEmployee.create(
+      first_name: "First",
+      last_name: "Last",
+      last_login_at: @now_nls
+    )
+    expect(@employee.last_login_at).to eq(@now)
+    @employee.reload
+    expect(@employee.last_login_at).to eq(@now)
+  end
+
+  it "should assign NLS time string with time zone to datetime column" do
+    @employee = TestEmployee.create(
+      first_name: "First",
+      last_name: "Last",
+      last_login_at: @now_nls_with_tz
+    )
+    expect(@employee.last_login_at).to eq(@now_with_tz)
+    @employee.reload
+    expect(@employee.last_login_at).to eq(@now_with_tz)
+  end
+
+  it "should assign ISO date string to datetime column" do
+    ActiveRecord.default_timezone = :local
+    @employee = TestEmployee.create(
+      first_name: "First",
+      last_name: "Last",
+      last_login_at: @today_iso
+    )
+    expect(@employee.last_login_at).to eq(@today.to_time)
+    @employee.reload
+    expect(@employee.last_login_at).to eq(@today.to_time)
+  end
+
+  it "should assign NLS date string to datetime column" do
+    ActiveRecord.default_timezone = :local
+    @employee = TestEmployee.create(
+      first_name: "First",
+      last_name: "Last",
+      last_login_at: @today_nls
+    )
+    expect(@employee.last_login_at).to eq(@today.to_time)
+    @employee.reload
+    expect(@employee.last_login_at).to eq(@today.to_time)
+  end
+end

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

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+describe "OracleEnhancedAdapter handling of BLOB 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.binary  :binary_data
+      end
+    end
+    class ::TestEmployee < ActiveRecord::Base
+    end
+    @binary_data = "\0\1\2\3\4\5\6\7\8\9" * 10000
+    @binary_data2 = "\1\2\3\4\5\6\7\8\9\0" * 10000
+  end
+
+  after(:all) do
+    @conn.drop_table :test_employees, if_exists: true
+    Object.send(:remove_const, "TestEmployee")
+  end
+
+  after(:each) do
+    ActiveRecord::Base.clear_cache!
+  end
+
+  it "should create record with BLOB data" do
+    @employee = TestEmployee.create!(
+      first_name: "First",
+      last_name: "Last",
+      binary_data: @binary_data
+    )
+    @employee.reload
+    expect(@employee.binary_data).to eq(@binary_data)
+  end
+
+  it "should update record with BLOB data" do
+    @employee = TestEmployee.create!(
+      first_name: "First",
+      last_name: "Last"
+    )
+    @employee.reload
+    expect(@employee.binary_data).to be_nil
+    @employee.binary_data = @binary_data
+    @employee.save!
+    @employee.reload
+    expect(@employee.binary_data).to eq(@binary_data)
+  end
+
+  it "should update record with zero-length BLOB data" do
+    @employee = TestEmployee.create!(
+      first_name: "First",
+      last_name: "Last"
+    )
+    @employee.reload
+    expect(@employee.binary_data).to be_nil
+    @employee.binary_data = ""
+    @employee.save!
+    @employee.reload
+    expect(@employee.binary_data).to eq("")
+  end
+
+  it "should update record that has existing BLOB data with different BLOB data" do
+    @employee = TestEmployee.create!(
+      first_name: "First",
+      last_name: "Last",
+      binary_data: @binary_data
+    )
+    @employee.reload
+    @employee.binary_data = @binary_data2
+    @employee.save!
+    @employee.reload
+    expect(@employee.binary_data).to eq(@binary_data2)
+  end
+
+  it "should update record that has existing BLOB data with nil" do
+    @employee = TestEmployee.create!(
+      first_name: "First",
+      last_name: "Last",
+      binary_data: @binary_data
+    )
+    @employee.reload
+    @employee.binary_data = nil
+    @employee.save!
+    @employee.reload
+    expect(@employee.binary_data).to be_nil
+  end
+
+  it "should update record that has existing BLOB data with zero-length BLOB data" do
+    @employee = TestEmployee.create!(
+      first_name: "First",
+      last_name: "Last",
+      binary_data: @binary_data
+    )
+    @employee.reload
+    @employee.binary_data = ""
+    @employee.save!
+    @employee.reload
+    expect(@employee.binary_data).to eq("")
+  end
+
+  it "should update record that has zero-length BLOB data with non-empty BLOB data" do
+    @employee = TestEmployee.create!(
+      first_name: "First",
+      last_name: "Last",
+      binary_data: ""
+    )
+    @employee.reload
+    expect(@employee.binary_data).to eq("")
+    @employee.binary_data = @binary_data
+    @employee.save!
+    @employee.reload
+    expect(@employee.binary_data).to eq(@binary_data)
+  end
+end

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

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+describe "OracleEnhancedAdapter boolean type detection based on string column types and names" do
+  before(:all) do
+    ActiveRecord::Base.establish_connection(CONNECTION_PARAMS)
+    @conn = ActiveRecord::Base.connection
+    @conn.execute <<~SQL
+      CREATE TABLE test3_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),
+        department_id NUMBER(4,0),
+        created_at    DATE,
+        has_email     CHAR(1),
+        has_phone     VARCHAR2(1) DEFAULT 'Y',
+        active_flag   VARCHAR2(2),
+        manager_yn    VARCHAR2(3) DEFAULT 'N',
+        test_boolean  VARCHAR2(3)
+      )
+    SQL
+    @conn.execute <<~SQL
+      CREATE SEQUENCE test3_employees_seq  MINVALUE 1
+        INCREMENT BY 1 START WITH 10040 CACHE 20 NOORDER NOCYCLE
+    SQL
+  end
+
+  after(:all) do
+    @conn.execute "DROP TABLE test3_employees"
+    @conn.execute "DROP SEQUENCE test3_employees_seq"
+  end
+
+  before(:each) do
+    class ::Test3Employee < ActiveRecord::Base
+    end
+  end
+
+  after(:each) do
+    Object.send(:remove_const, "Test3Employee")
+    ActiveRecord::Base.clear_cache!
+  end
+
+  describe "default values in new records" do
+    context "when emulate_booleans_from_strings is false" do
+      before do
+        ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans_from_strings = false
+      end
+
+      it "are Y or N" do
+        subject = Test3Employee.new
+        expect(subject.has_phone).to eq("Y")
+        expect(subject.manager_yn).to eq("N")
+      end
+    end
+
+    context "when emulate_booleans_from_strings is true" do
+      before do
+        ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans_from_strings = true
+      end
+
+      it "are True or False" do
+        class ::Test3Employee < ActiveRecord::Base
+          attribute :has_phone, :boolean
+          attribute :manager_yn, :boolean, default: false
+        end
+        subject = Test3Employee.new
+        expect(subject.has_phone).to be_a(TrueClass)
+        expect(subject.manager_yn).to be_a(FalseClass)
+      end
+    end
+  end
+
+  it "should translate boolean type to NUMBER(1) if emulate_booleans_from_strings is false" do
+    ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans_from_strings = false
+    sql_type = ActiveRecord::Base.connection.type_to_sql(:boolean)
+    expect(sql_type).to eq("NUMBER(1)")
+  end
+
+  describe "/ VARCHAR2 boolean values from ActiveRecord model" do
+    before(:each) do
+      ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans_from_strings = false
+    end
+
+    after(:each) do
+      ActiveRecord::Base.clear_cache!
+    end
+
+    def create_employee3(params = {})
+      @employee3 = Test3Employee.create(
+        {
+        first_name: "First",
+        last_name: "Last",
+        has_email: true,
+        has_phone: false,
+        active_flag: true,
+        manager_yn: false
+        }.merge(params)
+      )
+      @employee3.reload
+    end
+
+    it "should return String value from VARCHAR2 boolean column if emulate_booleans_from_strings is false" do
+      ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans_from_strings = false
+      create_employee3
+      %w(has_email has_phone active_flag manager_yn).each do |col|
+        expect(@employee3.send(col.to_sym).class).to eq(String)
+      end
+    end
+
+    it "should return boolean value from VARCHAR2 boolean column if emulate_booleans_from_strings is true" do
+      ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans_from_strings = true
+      class ::Test3Employee < ActiveRecord::Base
+        attribute :has_email, :boolean
+        attribute :active_flag, :boolean
+        attribute :has_phone, :boolean, default: false
+        attribute :manager_yn, :boolean, default: false
+      end
+      create_employee3
+      %w(has_email active_flag).each do |col|
+        expect(@employee3.send(col.to_sym).class).to eq(TrueClass)
+        expect(@employee3.send((col + "_before_type_cast").to_sym)).to eq("Y")
+      end
+      %w(has_phone manager_yn).each do |col|
+        expect(@employee3.send(col.to_sym).class).to eq(FalseClass)
+        expect(@employee3.send((col + "_before_type_cast").to_sym)).to eq("N")
+      end
+    end
+
+    it "should return string value from VARCHAR2 column if it is not boolean column and emulate_booleans_from_strings is true" do
+      ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans_from_strings = true
+      create_employee3
+      expect(@employee3.first_name.class).to eq(String)
+    end
+
+    it "should return boolean value from VARCHAR2 boolean column if attribute is set to :boolean" do
+      ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans_from_strings = true
+      class ::Test3Employee < ActiveRecord::Base
+        attribute :test_boolean, :boolean
+      end
+      create_employee3(test_boolean: true)
+      expect(@employee3.test_boolean.class).to eq(TrueClass)
+      expect(@employee3.test_boolean_before_type_cast).to eq("Y")
+      create_employee3(test_boolean: false)
+      expect(@employee3.test_boolean.class).to eq(FalseClass)
+      expect(@employee3.test_boolean_before_type_cast).to eq("N")
+      create_employee3(test_boolean: nil)
+      expect(@employee3.test_boolean.class).to eq(NilClass)
+      expect(@employee3.test_boolean_before_type_cast).to be_nil
+      create_employee3(test_boolean: "")
+      expect(@employee3.test_boolean.class).to eq(NilClass)
+      expect(@employee3.test_boolean_before_type_cast).to be_nil
+    end
+
+    it "should return string value from VARCHAR2 column with boolean column name but attribute is set to :string" do
+      ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans_from_strings = true
+      class ::Test3Employee < ActiveRecord::Base
+        attribute :active_flag, :string
+      end
+      create_employee3
+      expect(@employee3.active_flag.class).to eq(String)
+    end
+  end
+end
+
+describe "OracleEnhancedAdapter boolean support when emulate_booleans_from_strings = true" do
+  include SchemaSpecHelper
+
+  before(:all) do
+    ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans_from_strings = true
+    ActiveRecord::Base.establish_connection(CONNECTION_PARAMS)
+    schema_define do
+      create_table :posts, force: true do |t|
+        t.string  :name,        null: false
+        t.boolean :is_default, default: false
+      end
+    end
+  end
+
+  after(:all) do
+    ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans_from_strings = false
+  end
+
+  before(:each) do
+    class ::Post < ActiveRecord::Base
+      attribute :is_default, :boolean
+    end
+  end
+
+  after(:each) do
+    Object.send(:remove_const, "Post")
+    ActiveRecord::Base.clear_cache!
+  end
+
+  it "boolean should not change after reload" do
+    post = Post.create(name: "Test 1", is_default: false)
+    expect(post.is_default).to be false
+    post.reload
+    expect(post.is_default).to be false
+  end
+end

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+describe "OracleEnhancedAdapter processing CHAR column" 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,
+        padded   CHAR(10)
+      )
+    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
+    TestItem.delete_all
+    Object.send(:remove_const, "TestItem")
+    ActiveRecord::Base.clear_cache!
+  end
+
+  it "should create and find record" do
+    str = "ABC"
+    TestItem.create!
+    item = TestItem.first
+    item.padded = str
+    item.save
+
+    expect(TestItem.where(padded: item.padded).count).to eq(1)
+
+    item_reloaded = TestItem.first
+    expect(item_reloaded.padded).to eq(str)
+  end
+
+  it "should support case sensitive matching" do
+    TestItem.create!(
+      padded: "First",
+    )
+    TestItem.create!(
+      padded: "first",
+    )
+
+    expect(TestItem.where(TestItem.arel_table[:padded].matches("first%", "\\", true))).to have_attributes(count: 1)
+  end
+
+  it "should support case insensitive matching" do
+    TestItem.create!(
+      padded: "First",
+    )
+    TestItem.create!(
+      padded: "first",
+    )
+
+    expect(TestItem.where(TestItem.arel_table[:padded].matches("first%", "\\", false))).to have_attributes(count: 2)
+    expect(TestItem.where(TestItem.arel_table[:padded].matches("first%"))).to have_attributes(count: 2)
+  end
+end

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "base64"
+
+describe "OracleEnhancedAdapter custom types handling" 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.text      :signature
+      end
+    end
+
+    class TestEmployee < ActiveRecord::Base
+      class AttributeSignature < ActiveRecord::Type::Text
+        def cast(value)
+          case value
+          when Signature
+            value
+          when nil
+            nil
+          else
+            Signature.new(Base64.decode64 value)
+          end
+        end
+
+        def serialize(value)
+          Base64.encode64 value.raw
+        end
+
+        def changed_in_place?(raw_old_value, new_value)
+          new_value != cast(raw_old_value)
+        end
+      end
+
+      class Signature
+        attr_reader :raw
+
+        def initialize(raw_value)
+          @raw = raw_value
+        end
+
+        def to_s
+          "Signature nice string #{raw[0..5]}"
+        end
+
+        def ==(object)
+          raw == object&.raw
+        end
+        alias eql? ==
+      end
+
+      attribute :signature, AttributeSignature.new
+    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 serialize LOBs when creating a record" do
+    raw_signature = "peter'ssignature"
+    signature = TestEmployee::Signature.new(raw_signature)
+    @employee = TestEmployee.create!(first_name: "Peter", last_name: "Doe", signature: signature)
+    @employee.reload
+    expect(@employee.signature).to eql(signature)
+    expect(@employee.signature).to_not be(signature)
+    expect(TestEmployee.first.read_attribute_before_type_cast(:signature)).to eq(Base64.encode64 raw_signature)
+  end
+
+  it "should serialize LOBs when updating a record" do
+    raw_signature = "peter'ssignature"
+    signature = TestEmployee::Signature.new(raw_signature)
+    @employee = TestEmployee.create!(first_name: "Peter", last_name: "Doe", signature: TestEmployee::Signature.new("old signature"))
+    @employee.signature = signature
+    @employee.save!
+    @employee.reload
+    expect(@employee.signature).to eql(signature)
+    expect(@employee.signature).to_not be(signature)
+    expect(TestEmployee.first.read_attribute_before_type_cast(:signature)).to eq(Base64.encode64 raw_signature)
+  end
+end