activerecord-oracle_enhanced-adapter 7.2.1-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,244 @@
+# 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
+end

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+describe "OracleEnhancedAdapter timestamp with timezone support" do
+  include SchemaSpecHelper
+
+  before(:all) do
+    skip if ENV["DATABASE_SERVER_AND_CLIENT_VERSION_DO_NOT_MATCH"] == "true"
+    if ENV["DATABASE_VERSION"] == "11.2.0.2" && ENV["ORACLE_HOME"] == "/usr/lib/oracle/21/client64"
+      skip
+    end
+    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
+  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'

data/spec/spec_helper.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+require "rubygems"
+require "bundler"
+require "yaml"
+Bundler.setup(:default, :development)
+
+$:.unshift(File.expand_path("../../lib", __FILE__))
+config_path = File.expand_path("../spec_config.yaml", __FILE__)
+if File.exist?(config_path)
+  puts "==> Loading config from #{config_path}"
+  config = YAML.load_file(config_path)
+else
+  puts "==> Loading config from ENV or use default"
+  config = { "rails" => {}, "database" => {} }
+end
+
+require "rspec"
+
+if !defined?(RUBY_ENGINE) || RUBY_ENGINE == "ruby" || RUBY_ENGINE == "truffleruby"
+  puts "==> Running specs with ruby version #{RUBY_VERSION}"
+  require "oci8"
+elsif RUBY_ENGINE == "jruby"
+  puts "==> Running specs with JRuby version #{JRUBY_VERSION}"
+end
+
+require "active_record"
+
+require "active_support/core_ext/module/attribute_accessors"
+require "active_support/core_ext/class/attribute_accessors"
+
+require "active_support/log_subscriber"
+require "active_record/log_subscriber"
+
+require "logger"
+require "ruby-plsql"
+
+require "active_record/connection_adapters/oracle_enhanced_adapter"
+
+puts "==> Effective ActiveRecord version #{ActiveRecord::VERSION::STRING}"
+
+module LoggerSpecHelper
+  def set_logger
+    @logger = MockLogger.new
+    @old_logger = ActiveRecord::Base.logger
+
+    @notifier = ActiveSupport::Notifications::Fanout.new
+
+    ActiveSupport::LogSubscriber.colorize_logging = false
+
+    ActiveRecord::Base.logger = @logger
+    @old_notifier = ActiveSupport::Notifications.notifier
+    ActiveSupport::Notifications.notifier = @notifier
+
+    ActiveRecord::LogSubscriber.attach_to(:active_record)
+    ActiveSupport::Notifications.subscribe("sql.active_record", ActiveRecord::ExplainSubscriber.new)
+  end
+
+  class MockLogger
+    LEVELS = %i[debug info warn error fatal unknown]
+
+    attr_reader :flush_count
+
+    def initialize
+      @flush_count = 0
+      @logged = Hash.new { |h, k| h[k] = [] }
+    end
+
+    # used in ActiveRecord 2.x
+    def debug?
+      true
+    end
+
+    def level
+      0
+    end
+
+    def method_missing(*args)
+      if LEVELS.include?(args[0])
+        level, message  = args
+        @logged[level] << message
+      else
+        super
+      end
+    end
+
+    def logged(level)
+      @logged[level].compact.map { |l| l.to_s.strip }
+    end
+
+    def output(level)
+      logged(level).join("\n")
+    end
+
+    def flush
+      @flush_count += 1
+    end
+
+    def clear(level)
+      @logged[level] = []
+    end
+  end
+
+  def clear_logger
+    ActiveRecord::Base.logger = @old_logger
+    @logger = nil
+
+    ActiveSupport::Notifications.notifier = @old_notifier
+    @notifier = nil
+  end
+
+  # Wait notifications to be published (for Rails 3.0)
+  # should not be currently used with sync queues in tests
+  def wait
+    @notifier.wait if @notifier
+  end
+end
+
+ActiveRecord::LogSubscriber::IGNORE_PAYLOAD_NAMES.replace(["EXPLAIN"])
+
+module SchemaSpecHelper
+  def schema_define(&block)
+    ActiveRecord::Schema.define do
+      suppress_messages do
+        instance_eval(&block)
+      end
+    end
+  end
+end
+
+module SchemaDumpingHelper
+  def dump_table_schema(table, connection = ActiveRecord::Base.connection)
+    old_ignore_tables = ActiveRecord::SchemaDumper.ignore_tables
+    ActiveRecord::SchemaDumper.ignore_tables = connection.data_sources - [table]
+    stream = StringIO.new
+    ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection_pool, stream)
+    stream.string
+  ensure
+    ActiveRecord::SchemaDumper.ignore_tables = old_ignore_tables
+  end
+end
+
+DATABASE_NAME         = config["database"]["name"]         || ENV["DATABASE_NAME"]         || "orcl"
+DATABASE_HOST         = config["database"]["host"]         || ENV["DATABASE_HOST"]         || "127.0.0.1"
+DATABASE_PORT         = config["database"]["port"]         || ENV["DATABASE_PORT"]         || 1521
+DATABASE_USER         = config["database"]["user"]         || ENV["DATABASE_USER"]         || "oracle_enhanced"
+DATABASE_PASSWORD     = config["database"]["password"]     || ENV["DATABASE_PASSWORD"]     || "oracle_enhanced"
+DATABASE_SCHEMA       = config["database"]["schema"]       || ENV["DATABASE_SCHEMA"]       || "oracle_enhanced_schema"
+DATABASE_SYS_PASSWORD = config["database"]["sys_password"] || ENV["DATABASE_SYS_PASSWORD"] || "admin"
+
+CONNECTION_PARAMS = {
+  adapter: "oracle_enhanced",
+  database: DATABASE_NAME,
+  host: DATABASE_HOST,
+  port: DATABASE_PORT,
+  username: DATABASE_USER,
+  password: DATABASE_PASSWORD
+}
+
+CONNECTION_WITH_SCHEMA_PARAMS = {
+  adapter: "oracle_enhanced",
+  database: DATABASE_NAME,
+  host: DATABASE_HOST,
+  port: DATABASE_PORT,
+  username: DATABASE_USER,
+  password: DATABASE_PASSWORD,
+  schema: DATABASE_SCHEMA
+}
+
+CONNECTION_WITH_TIMEZONE_PARAMS = {
+  adapter: "oracle_enhanced",
+  database: DATABASE_NAME,
+  host: DATABASE_HOST,
+  port: DATABASE_PORT,
+  username: DATABASE_USER,
+  password: DATABASE_PASSWORD,
+  time_zone: "Europe/Riga"
+}
+
+SYS_CONNECTION_PARAMS = {
+  adapter: "oracle_enhanced",
+  database: DATABASE_NAME,
+  host: DATABASE_HOST,
+  port: DATABASE_PORT,
+  username: "sys",
+  password: DATABASE_SYS_PASSWORD,
+  privilege: "SYSDBA"
+}
+
+SYSTEM_CONNECTION_PARAMS = {
+  adapter: "oracle_enhanced",
+  database: DATABASE_NAME,
+  host: DATABASE_HOST,
+  port: DATABASE_PORT,
+  username: "system",
+  password: DATABASE_SYS_PASSWORD
+}
+
+SERVICE_NAME_CONNECTION_PARAMS = {
+  adapter: "oracle_enhanced",
+  database: "/#{DATABASE_NAME}",
+  host: DATABASE_HOST,
+  port: DATABASE_PORT,
+  username: DATABASE_USER,
+  password: DATABASE_PASSWORD
+}
+
+DATABASE_NON_DEFAULT_TABLESPACE = config["database"]["non_default_tablespace"] || ENV["DATABASE_NON_DEFAULT_TABLESPACE"] || "SYSTEM"
+
+# set default time zone in TZ environment variable
+# which will be used to set session time zone
+ENV["TZ"] ||= config["timezone"] || "Europe/Riga"
+
+ActiveRecord::Base.logger = ActiveSupport::Logger.new("debug.log", 0, 100 * 1024 * 1024)

data/spec/support/alter_system_set_open_cursors.sql

@@ -0,0 +1 @@
+alter system set open_cursors = 1200 scope = both;

data/spec/support/alter_system_user_password.sql

@@ -0,0 +1,2 @@
+alter user sys identified by admin;
+alter user system identified by admin;