activerecord-oracle_enhanced-adapter 8.1.0-java

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

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+describe "OracleEnhancedAdapter handling of RAW columns" 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.raw       :binary_data,   limit: 1024
+      end
+    end
+    @binary_data = "\0\1\2\3\4\5\6\7\8\9" * 100
+    @binary_data2 = "\1\2\3\4\5\6\7\8\9\0" * 100
+  end
+
+  after(:all) do
+    schema_define do
+      drop_table :test_employees
+    end
+  end
+
+  before(:each) do
+    class ::TestEmployee < ActiveRecord::Base
+    end
+  end
+
+  after(:each) do
+    Object.send(:remove_const, "TestEmployee")
+    ActiveRecord::Base.clear_cache!
+  end
+
+  it "should create record with RAW 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 RAW 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 RAW 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 be_nil
+  end
+
+  it "should update record that has existing RAW data with different RAW 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 RAW 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 RAW data with zero-length RAW 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 be_nil
+  end
+
+  it "should update record that has zero-length BLOB data with non-empty RAW data" do
+    @employee = TestEmployee.create!(
+      first_name: "First",
+      last_name: "Last",
+      binary_data: ""
+    )
+    @employee.reload
+    @employee.binary_data = @binary_data
+    @employee.save!
+    @employee.reload
+    expect(@employee.binary_data).to eq(@binary_data)
+  end
+
+  it "should allow equality on select" do
+    TestEmployee.delete_all
+    TestEmployee.create!(
+      first_name: "First",
+      last_name: "Last",
+      binary_data: @binary_data,
+    )
+    TestEmployee.create!(
+      first_name: "First1",
+      last_name: "Last1",
+      binary_data: @binary_data2,
+    )
+    expect(TestEmployee.where(binary_data: @binary_data)).to have_attributes(count: 1)
+  end
+end

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

@@ -0,0 +1,295 @@
+# frozen_string_literal: true
+
+describe "OracleEnhancedAdapter handling of CLOB 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.text    :comments
+      end
+      create_table :test2_employees, force: true do |t|
+        t.string  :first_name, limit: 20
+        t.string  :last_name, limit: 25
+        t.text    :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, :text
+    end
+
+    @char_data = (0..127).to_a.pack("C*") * 800
+    @char_data2 = ((1..127).to_a.pack("C*") + "\0") * 800
+
+    class ::TestEmployee < ActiveRecord::Base; end
+    class ::Test2Employee < ActiveRecord::Base
+      serialize :comments
+    end
+    class ::TestEmployeeReadOnlyClob < 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, "TestEmployeeReadOnlyClob")
+    Object.send(:remove_const, "TestSerializeEmployee")
+    ActiveRecord::Base.clear_cache!
+  end
+
+  it "should create record without CLOB 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 CLOB column" do
+    @employee = TestEmployee.create!(
+      comments: :test_comment
+    )
+    expect(@employee).to be_valid
+  end
+
+  it "should respect attr_readonly setting for CLOB column" do
+    @employee = TestEmployeeReadOnlyClob.create!(
+      first_name: "First",
+      comments: "initial"
+    )
+    expect(@employee).to be_valid
+    @employee.reload
+    expect(@employee.comments).to eq("initial")
+    @employee.comments = "changed"
+    expect(@employee.save).to be(true)
+    @employee.reload
+    expect(@employee.comments).to eq("initial")
+  end
+
+  it "should work for serialized readonly CLOB 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 CLOB data" do
+    @employee = TestEmployee.create!(
+      first_name: "First",
+      last_name: "Last",
+      comments: @char_data
+    )
+    @employee.reload
+    expect(@employee.comments).to eq(@char_data)
+  end
+
+  it "should update record with CLOB data" do
+    @employee = TestEmployee.create!(
+      first_name: "First",
+      last_name: "Last"
+    )
+    @employee.reload
+    expect(@employee.comments).to be_nil
+    @employee.comments = @char_data
+    @employee.save!
+    @employee.reload
+    expect(@employee.comments).to eq(@char_data)
+  end
+
+  it "should update record with zero-length CLOB 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 CLOB data with different CLOB data" do
+    @employee = TestEmployee.create!(
+      first_name: "First",
+      last_name: "Last",
+      comments: @char_data
+    )
+    @employee.reload
+    @employee.comments = @char_data2
+    @employee.save!
+    @employee.reload
+    expect(@employee.comments).to eq(@char_data2)
+  end
+
+  it "should update record that has existing CLOB data with nil" do
+    @employee = TestEmployee.create!(
+      first_name: "First",
+      last_name: "Last",
+      comments: @char_data
+    )
+    @employee.reload
+    @employee.comments = nil
+    @employee.save!
+    @employee.reload
+    expect(@employee.comments).to be_nil
+  end
+
+  it "should update record that has existing CLOB data with zero-length CLOB data" do
+    @employee = TestEmployee.create!(
+      first_name: "First",
+      last_name: "Last",
+      comments: @char_data
+    )
+    @employee.reload
+    @employee.comments = ""
+    @employee.save!
+    @employee.reload
+    expect(@employee.comments).to eq("")
+  end
+
+  it "should update record that has zero-length CLOB data with non-empty CLOB data" do
+    @employee = TestEmployee.create!(
+      first_name: "First",
+      last_name: "Last",
+      comments: ""
+    )
+    @employee.reload
+    expect(@employee.comments).to eq("")
+    @employee.comments = @char_data
+    @employee.save!
+    @employee.reload
+    expect(@employee.comments).to eq(@char_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: "initial serialized data"
+    )
+    @employee.first_name = "Steve"
+    @employee.save
+    @employee.reload
+    expect(@employee.comments).to eq("initial serialized 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
+
+  it "should allow equality on select" do
+    search_data = "text search CLOB"
+    Test2Employee.create!(
+      first_name: "First",
+      last_name: "Last",
+      comments: search_data,
+    )
+    Test2Employee.create!(
+      first_name: "First1",
+      last_name: "Last1",
+      comments: "other data",
+    )
+    expect(Test2Employee.where(comments: search_data)).to have_attributes(count: 1)
+  end
+
+  describe "with prepared_statements disabled" do
+    around(:each) do |example|
+      old_prepared_statements = @conn.prepared_statements
+      @conn.instance_variable_set(:@prepared_statements, false)
+      example.run
+      @conn.instance_variable_set(:@prepared_statements, old_prepared_statements)
+    end
+
+    it "should create record with CLOB data when prepared_statements is false" do
+      @employee = TestEmployee.create!(
+        first_name: "First",
+        last_name: "Last",
+        comments: @char_data
+      )
+      @employee.reload
+      expect(@employee.comments).to eq(@char_data)
+    end
+
+    it "should create record with short CLOB data when prepared_statements is false" do
+      short_data = "Short CLOB content"
+      @employee = TestEmployee.create!(
+        first_name: "First",
+        last_name: "Last",
+        comments: short_data
+      )
+      @employee.reload
+      expect(@employee.comments).to eq(short_data)
+    end
+
+    it "should create record with empty CLOB when prepared_statements is false" do
+      @employee = TestEmployee.create!(
+        first_name: "First",
+        last_name: "Last",
+        comments: ""
+      )
+      @employee.reload
+      expect(@employee.comments).to eq("")
+    end
+
+    it "should create record with serialized CLOB data when prepared_statements is false" do
+      ruby_data = { "test" => ["ruby", :data, 123] }
+      @employee = Test2Employee.create!(
+        first_name: "First",
+        last_name: "Last",
+        comments: ruby_data
+      )
+      @employee.reload
+      expect(@employee.comments).to eq(ruby_data)
+    end
+  end
+end

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

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+describe "OracleEnhancedAdapter timestamp with timezone support" do
+  include SchemaSpecHelper
+
+  before(:all) do
+    ActiveRecord.default_timezone = :local
+    ActiveRecord::Base.establish_connection(CONNECTION_WITH_TIMEZONE_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.string        :email, limit: 25
+        t.string        :phone_number, limit: 20
+        t.date          :hire_date
+        t.decimal       :job_id, scale: 0, precision: 6
+        t.decimal       :salary, scale: 2, precision: 8
+        t.decimal       :commission_pct, scale: 2, precision: 2
+        t.decimal       :manager_id, scale: 0, precision: 6
+        t.decimal       :department_id, scale: 0, precision: 4
+        t.timestamp     :created_at
+        t.timestamptz   :created_at_tz
+        t.timestampltz  :created_at_ltz
+      end
+    end
+  end
+
+  after(:all) do
+    @conn.drop_table :test_employees, if_exists: true rescue nil
+    ActiveRecord.default_timezone = :utc
+  end
+
+  describe "/ TIMESTAMP WITH TIME ZONE values from ActiveRecord model" do
+    before(:all) do
+      class ::TestEmployee < ActiveRecord::Base
+      end
+    end
+
+    after(:all) do
+      Object.send(:remove_const, "TestEmployee")
+      ActiveRecord::Base.clear_cache!
+    end
+
+    it "should return Time value from TIMESTAMP columns" do
+      @now = Time.local(2008, 5, 26, 23, 11, 11, 0)
+      @employee = TestEmployee.create(
+        created_at: @now,
+        created_at_tz: @now,
+        created_at_ltz: @now
+      )
+      @employee.reload
+      [:created_at, :created_at_tz, :created_at_ltz].each do |c|
+        expect(@employee.send(c).class).to eq(Time)
+        expect(@employee.send(c).to_f).to eq(@now.to_f)
+      end
+    end
+
+    it "should return Time value with fractional seconds from TIMESTAMP columns" do
+      @now = Time.local(2008, 5, 26, 23, 11, 11, 10)
+      @employee = TestEmployee.create(
+        created_at: @now,
+        created_at_tz: @now,
+        created_at_ltz: @now
+      )
+      @employee.reload
+      [:created_at, :created_at_tz, :created_at_ltz].each do |c|
+        expect(@employee.send(c).class).to eq(Time)
+        expect(@employee.send(c).to_f).to eq(@now.to_f)
+      end
+    end
+
+    it "should return Time value with millisecond fractional seconds from TIMESTAMP columns" do
+      @now = Time.local(2008, 5, 26, 23, 11, 11, 123_000)  # 123 ms = 123_000 μs
+      @employee = TestEmployee.create(
+        created_at: @now,
+        created_at_tz: @now,
+        created_at_ltz: @now
+      )
+      @employee.reload
+      [:created_at, :created_at_tz, :created_at_ltz].each do |c|
+        expect(@employee.send(c).class).to eq(Time)
+        expect(@employee.send(c).to_f).to eq(@now.to_f)
+      end
+    end
+
+    it "should preserve microsecond precision when binding Time values" do
+      # Guard against the JDBC bind path going through Float (which can drift
+      # by 1 ms for current epoch values). Assert on Time#to_i and Time#usec
+      # directly instead of Time#to_f, which is too coarse to catch drift.
+      # Note: the TIMESTAMP columns above use the default fractional precision
+      # of 6, so the round-trip is truncated to microseconds.
+      @now = Time.local(2008, 5, 26, 23, 11, 11, 123_456)
+      @employee = TestEmployee.create(
+        created_at: @now,
+        created_at_tz: @now,
+        created_at_ltz: @now
+      )
+      @employee.reload
+      [:created_at, :created_at_tz, :created_at_ltz].each do |c|
+        expect(@employee.send(c).to_i).to eq(@now.to_i)
+        expect(@employee.send(c).usec).to eq(@now.usec)
+        expect(@employee.send(c).nsec).to eq(@now.nsec)
+      end
+    end
+  end
+end

data/spec/spec_config.yaml.template

@@ -0,0 +1,11 @@
+# copy this file to spec/spec_config.yaml and set appropriate values
+# you can also use environment variables, see spec_helper.rb
+database:
+  name:         'FREEPDB1'
+  host:         '127.0.0.1'
+  port:         1521
+  user:         'oracle_enhanced'
+  password:     'oracle_enhanced'
+  sys_password: 'oracle'
+  non_default_tablespace: 'SYSTEM'
+timezone: 'Europe/Riga'