activerecord-oracle_enhanced-adapter 1.7.11 → 1.8.2

data/spec/active_record/connection_adapters/oracle_enhanced_data_types_spec.rb

@@ -1,5 +1,3 @@
-require 'spec_helper'
-
 describe "OracleEnhancedAdapter date type detection based on column names" do
   before(:all) do
     ActiveRecord::Base.establish_connection(CONNECTION_PARAMS)
@@ -36,21 +34,19 @@ describe "OracleEnhancedAdapter date type detection based on column names" do
 
   describe "/ DATE values from ActiveRecord model" do
     before(:each) do
-      # ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = false
-      # ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates = false
       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)
+    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
+        first_name: "First",
+        last_name: "Last",
+        hire_date: @today,
+        created_at: @now
       )
       @employee.reload
     end
@@ -58,11 +54,10 @@ describe "OracleEnhancedAdapter date type detection based on column names" do
     after(:each) do
       # @employee.destroy if @employee
       Object.send(:remove_const, "TestEmployee")
-      ActiveRecord::Base.clear_cache! if ActiveRecord::Base.respond_to?(:"clear_cache!")
+      ActiveRecord::Base.clear_cache!
     end
 
     it "should return Time value from DATE column if emulate_dates_by_column_name is false" do
-      # ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = false
       class ::TestEmployee < ActiveRecord::Base
         attribute :hire_date, :datetime
       end
@@ -71,19 +66,16 @@ describe "OracleEnhancedAdapter date type detection based on column names" do
     end
 
     it "should return Date value from DATE column if column name contains 'date' and emulate_dates_by_column_name is true" do
-      # ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = true
       create_test_employee
       expect(@employee.hire_date.class).to eq(Date)
     end
 
     it "should return Date value from DATE column with old date value if column name contains 'date' and emulate_dates_by_column_name is true" do
-      # ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = true
-      create_test_employee(:today => Date.new(1900,1,1))
+      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 column name does not contain 'date' and emulate_dates_by_column_name is true" do
-      # ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = true
       class ::TestEmployee < ActiveRecord::Base
         # set_date_columns :created_at
         attribute :created_at, :datetime
@@ -92,32 +84,11 @@ describe "OracleEnhancedAdapter date type detection based on column names" do
       expect(@employee.created_at.class).to eq(Time)
     end
 
-    it "should return Date value from DATE column if emulate_dates_by_column_name is false but column is defined as date" do
-      class ::TestEmployee < ActiveRecord::Base
-        # set_date_columns :hire_date
-        attribute :hire_date, :date
-      end
-      # ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = false
-      create_test_employee
-      expect(@employee.hire_date.class).to eq(Date)
-    end
-
-    it "should return Date value from DATE column with old date value if emulate_dates_by_column_name is false but column is defined as date" do
-      class ::TestEmployee < ActiveRecord::Base
-        # set_date_columns :hire_date
-        attribute :hire_date, :date
-      end
-      # ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = false
-      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 emulate_dates_by_column_name is true but column is defined as datetime" do
       class ::TestEmployee < ActiveRecord::Base
         # set_datetime_columns :hire_date
         attribute :hire_date, :datetime
       end
-      # ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = true
       create_test_employee
       expect(@employee.hire_date.class).to eq(Time)
       # change to current time with hours, minutes and seconds
@@ -129,7 +100,6 @@ describe "OracleEnhancedAdapter date type detection based on column names" do
     end
 
     it "should guess Date or Time value if emulate_dates is true" do
-      # ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates = true
       class ::TestEmployee < ActiveRecord::Base
         attribute :hire_date, :date
         attribute :created_at, :datetime
@@ -186,28 +156,26 @@ describe "OracleEnhancedAdapter integer type detection based on column names" do
     after(:each) do
       Object.send(:remove_const, "Test2Employee")
       ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans = true
-      ActiveRecord::Base.clear_cache! if ActiveRecord::Base.respond_to?(:"clear_cache!")
+      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
+        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 emulate_integers_by_column_name is false" do
-      # ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_integers_by_column_name = false
       create_employee2
       expect(@employee2.job_id.class).to eq(BigDecimal)
     end
 
     it "should return Integer value from NUMBER column if column name contains 'id' and emulate_integers_by_column_name is true" do
-      # ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_integers_by_column_name = true
       class ::Test2Employee < ActiveRecord::Base
         attribute :job_id, :integer
       end
@@ -216,20 +184,16 @@ describe "OracleEnhancedAdapter integer type detection based on column names" do
     end
 
     it "should return Integer value from NUMBER column with integer value using _before_type_cast method" do
-      # ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_integers_by_column_name = true
       create_employee2
       expect(@employee2.job_id_before_type_cast).to be_a(Integer)
     end
 
     it "should return BigDecimal value from NUMBER column if column name does not contain 'id' and emulate_integers_by_column_name is true" do
-      # ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_integers_by_column_name = true
       create_employee2
       expect(@employee2.salary.class).to eq(BigDecimal)
     end
 
     it "should return Integer value from NUMBER column if column specified in set_integer_columns" do
-      # ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_integers_by_column_name = false
-      # Test2Employee.set_integer_columns :job_id
       class ::Test2Employee < ActiveRecord::Base
         attribute :job_id, :integer
       end
@@ -238,13 +202,11 @@ describe "OracleEnhancedAdapter integer type detection based on column names" do
     end
 
     it "should return Boolean value from NUMBER(1) column if emulate booleans is used" do
-      # ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans = true
       create_employee2
       expect(@employee2.is_manager.class).to eq(TrueClass)
     end
 
     it "should return Integer value from NUMBER(1) column if emulate booleans is not used" do
-      # ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans = false
       class ::Test2Employee < ActiveRecord::Base
         attribute :is_manager, :integer
       end
@@ -253,8 +215,6 @@ describe "OracleEnhancedAdapter integer type detection based on column names" do
     end
 
     it "should return Integer value from NUMBER(1) column if column specified in set_integer_columns" do
-      # ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans = true
-      # Test2Employee.set_integer_columns :is_manager
       class ::Test2Employee < ActiveRecord::Base
         attribute :is_manager, :integer
       end
@@ -300,7 +260,6 @@ describe "OracleEnhancedAdapter boolean type detection based on string column ty
   after(:all) do
     @conn.execute "DROP TABLE test3_employees"
     @conn.execute "DROP SEQUENCE test3_employees_seq"
-    # ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans_from_strings = false
   end
 
   before(:each) do
@@ -310,7 +269,7 @@ describe "OracleEnhancedAdapter boolean type detection based on string column ty
 
   after(:each) do
     Object.send(:remove_const, "Test3Employee")
-    ActiveRecord::Base.clear_cache! if ActiveRecord::Base.respond_to?(:"clear_cache!")
+    ActiveRecord::Base.clear_cache!
   end
 
   describe "default values in new records" do
@@ -321,8 +280,8 @@ describe "OracleEnhancedAdapter boolean type detection based on string column ty
 
       it "are Y or N" do
         subject = Test3Employee.new
-        expect(subject.has_phone).to eq('Y')
-        expect(subject.manager_yn).to eq('N')
+        expect(subject.has_phone).to eq("Y")
+        expect(subject.manager_yn).to eq("N")
       end
     end
 
@@ -345,8 +304,8 @@ describe "OracleEnhancedAdapter boolean type detection based on string column ty
 
   it "should translate boolean type to NUMBER(1) if emulate_booleans_from_strings is false" do
     ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans_from_strings = false
-    expect(ActiveRecord::Base.connection.type_to_sql(
-      :boolean, nil, nil, nil)).to eq("NUMBER(1)")
+    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
@@ -355,18 +314,18 @@ describe "OracleEnhancedAdapter boolean type detection based on string column ty
     end
 
     after(:each) do
-      ActiveRecord::Base.clear_cache! if ActiveRecord::Base.respond_to?(:"clear_cache!")
+      ActiveRecord::Base.clear_cache!
     end
 
-    def create_employee3(params={})
+    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
+        first_name: "First",
+        last_name: "Last",
+        has_email: true,
+        has_phone: false,
+        active_flag: true,
+        manager_yn: false
         }.merge(params)
       )
       @employee3.reload
@@ -391,11 +350,11 @@ describe "OracleEnhancedAdapter boolean type detection based on string column ty
       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")
+        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")
+        expect(@employee3.send((col + "_before_type_cast").to_sym)).to eq("N")
       end
     end
 
@@ -407,27 +366,25 @@ describe "OracleEnhancedAdapter boolean type detection based on string column ty
 
     it "should return boolean value from VARCHAR2 boolean column if column specified in set_boolean_columns" do
       ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans_from_strings = true
-      # Test3Employee.set_boolean_columns :test_boolean
       class ::Test3Employee < ActiveRecord::Base
         attribute :test_boolean, :boolean
       end
-      create_employee3(:test_boolean => true)
+      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)
+      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)
+      create_employee3(test_boolean: nil)
       expect(@employee3.test_boolean.class).to eq(NilClass)
       expect(@employee3.test_boolean_before_type_cast).to eq(nil)
-      create_employee3(:test_boolean => "")
+      create_employee3(test_boolean: "")
       expect(@employee3.test_boolean.class).to eq(NilClass)
       expect(@employee3.test_boolean_before_type_cast).to eq(nil)
     end
 
     it "should return string value from VARCHAR2 column with boolean column name but is specified in set_string_columns" do
       ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans_from_strings = true
-      # Test3Employee.set_string_columns :active_flag
       class ::Test3Employee < ActiveRecord::Base
         attribute :active_flag, :string
       end
@@ -446,7 +403,7 @@ describe "OracleEnhancedAdapter boolean support when emulate_booleans_from_strin
     ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans_from_strings = true
     ActiveRecord::Base.establish_connection(CONNECTION_PARAMS)
     schema_define do
-      create_table :posts, :force => true do |t|
+      create_table :posts, force: true do |t|
         t.string  :name,        null: false
         t.boolean :is_default, default: false
       end
@@ -468,7 +425,7 @@ describe "OracleEnhancedAdapter boolean support when emulate_booleans_from_strin
   end
 
   it "boolean should not change after reload" do
-    post = Post.create(name: 'Test 1', is_default: false)
+    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
@@ -510,13 +467,6 @@ describe "OracleEnhancedAdapter timestamp with timezone support" do
     ActiveRecord::Base.default_timezone = :utc
   end
 
-  it "should set TIMESTAMP columns type as datetime" do
-    skip "TIMESTAMP sql_type should be :datetime in Rails 5"
-    columns = @conn.columns('test_employees')
-    ts_columns = columns.select{|c| c.name =~ /created_at/}
-    ts_columns.each {|c| expect(c.type).to eq(:timestamp)}
-  end
-
   describe "/ TIMESTAMP WITH TIME ZONE values from ActiveRecord model" do
     before(:all) do
       class ::TestEmployee < ActiveRecord::Base
@@ -526,15 +476,15 @@ describe "OracleEnhancedAdapter timestamp with timezone support" do
 
     after(:all) do
       Object.send(:remove_const, "TestEmployee")
-      ActiveRecord::Base.clear_cache! if ActiveRecord::Base.respond_to?(:"clear_cache!")
+      ActiveRecord::Base.clear_cache!
     end
 
     it "should return Time value from TIMESTAMP columns" do
-      @now = Time.local(2008,5,26,23,11,11,0)
+      @now = Time.local(2008, 5, 26, 23, 11, 11, 0)
       @employee = TestEmployee.create(
-        :created_at => @now,
-        :created_at_tz => @now,
-        :created_at_ltz => @now
+        created_at: @now,
+        created_at_tz: @now,
+        created_at_ltz: @now
       )
       @employee.reload
       [:created_at, :created_at_tz, :created_at_ltz].each do |c|
@@ -544,11 +494,11 @@ describe "OracleEnhancedAdapter timestamp with timezone support" do
     end
 
     it "should return Time value with fractional seconds from TIMESTAMP columns" do
-      @now = Time.local(2008,5,26,23,11,11,10)
+      @now = Time.local(2008, 5, 26, 23, 11, 11, 10)
       @employee = TestEmployee.create(
-        :created_at => @now,
-        :created_at_tz => @now,
-        :created_at_ltz => @now
+        created_at: @now,
+        created_at_tz: @now,
+        created_at_ltz: @now
       )
       @employee.reload
       [:created_at, :created_at_tz, :created_at_ltz].each do |c|
@@ -561,105 +511,6 @@ describe "OracleEnhancedAdapter timestamp with timezone support" do
 
 end
 
-describe "OracleEnhancedAdapter date and timestamp with different NLS date formats" do
-  before(:all) do
-    ActiveRecord::Base.establish_connection(CONNECTION_PARAMS)
-    @conn = ActiveRecord::Base.connection
-    @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,
-        created_at_ts   TIMESTAMP
-      )
-    SQL
-    @conn.execute <<-SQL
-      CREATE SEQUENCE test_employees_seq  MINVALUE 1
-        INCREMENT BY 1 CACHE 20 NOORDER NOCYCLE
-    SQL
-    # @conn.execute %q{alter session set nls_date_format = 'YYYY-MM-DD HH24:MI:SS'}
-    @conn.execute %q{alter session set nls_date_format = 'DD-MON-YYYY HH24:MI:SS'}
-    # @conn.execute %q{alter session set nls_timestamp_format = 'YYYY-MM-DD HH24:MI:SS'}
-    @conn.execute %q{alter session set nls_timestamp_format = 'DD-MON-YYYY HH24:MI:SS'}
-  end
-
-  after(:all) do
-    @conn.execute "DROP TABLE test_employees"
-    @conn.execute "DROP SEQUENCE test_employees_seq"
-  end
-
-  before(:each) do
-    # ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates = false
-    # ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = false
-    class ::TestEmployee < ActiveRecord::Base
-      self.primary_key = "employee_id"
-    end
-    @today = Date.new(2008,6,28)
-    @now = Time.local(2008,6,28,13,34,33)
-  end
-
-  after(:each) do
-    Object.send(:remove_const, "TestEmployee")
-    ActiveRecord::Base.clear_cache! if ActiveRecord::Base.respond_to?(:"clear_cache!")
-    ActiveRecord::Base.default_timezone = :utc
-  end
-
-  def create_test_employee
-    @employee = TestEmployee.create(
-      :first_name => "First",
-      :last_name => "Last",
-      :hire_date => @today,
-      :created_at => @now,
-      :created_at_ts => @now
-    )
-    @employee.reload
-  end
-
-  it "should return Time value from DATE column if emulate_dates_by_column_name is false" do
-    # ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = false
-    ActiveRecord::Base.default_timezone = :local
-    class ::TestEmployee < ActiveRecord::Base
-      attribute :hire_date, :datetime
-    end
-    create_test_employee
-    expect(@employee.hire_date.class).to eq(Time)
-    expect(@employee.hire_date).to eq(@today.to_time)
-  end
-
-  it "should return Date value from DATE column if column name contains 'date' and emulate_dates_by_column_name is true" do
-    # ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = true
-    create_test_employee
-    expect(@employee.hire_date.class).to eq(Date)
-    expect(@employee.hire_date).to eq(@today)
-  end
-
-  it "should return Time value from DATE column if column name does not contain 'date' and emulate_dates_by_column_name is true" do
-    # ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = true
-    class ::TestEmployee < ActiveRecord::Base
-      attribute :created_at, :datetime
-    end
-    create_test_employee
-    expect(@employee.created_at.class).to eq(Time)
-    expect(@employee.created_at).to eq(@now)
-  end
-
-  it "should return Time value from TIMESTAMP columns" do
-    create_test_employee
-    expect(@employee.created_at_ts.class).to eq(Time)
-    expect(@employee.created_at_ts).to eq(@now)
-  end
-
-end
-
 describe "OracleEnhancedAdapter assign string to :date and :datetime columns" do
   before(:all) do
     ActiveRecord::Base.establish_connection(CONNECTION_PARAMS)
@@ -682,11 +533,11 @@ describe "OracleEnhancedAdapter assign string to :date and :datetime columns" do
       self.primary_key = "employee_id"
       attribute :last_login_at, :datetime
     end
-    @today = Date.new(2008,6,28)
+    @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 = 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"
@@ -699,11 +550,7 @@ describe "OracleEnhancedAdapter assign string to :date and :datetime columns" do
     Object.send(:remove_const, "TestEmployee")
     @conn.execute "DROP TABLE test_employees"
     @conn.execute "DROP SEQUENCE test_employees_seq"
-    ActiveRecord::Base.clear_cache! if ActiveRecord::Base.respond_to?(:"clear_cache!")
-  end
-
-  before(:each) do
-    # ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = true
+    ActiveRecord::Base.clear_cache!
   end
 
   after(:each) do
@@ -712,9 +559,9 @@ describe "OracleEnhancedAdapter assign string to :date and :datetime columns" do
 
   it "should assign ISO string to date column" do
     @employee = TestEmployee.create(
-      :first_name => "First",
-      :last_name => "Last",
-      :hire_date => @today_iso
+      first_name: "First",
+      last_name: "Last",
+      hire_date: @today_iso
     )
     expect(@employee.hire_date).to eq(@today)
     @employee.reload
@@ -722,11 +569,10 @@ describe "OracleEnhancedAdapter assign string to :date and :datetime columns" do
   end
 
   it "should assign NLS string to date column" do
-    ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.string_to_date_format = @nls_date_format
     @employee = TestEmployee.create(
-      :first_name => "First",
-      :last_name => "Last",
-      :hire_date => @today_nls
+      first_name: "First",
+      last_name: "Last",
+      hire_date: @today_nls
     )
     expect(@employee.hire_date).to eq(@today)
     @employee.reload
@@ -735,9 +581,9 @@ describe "OracleEnhancedAdapter assign string to :date and :datetime columns" do
 
   it "should assign ISO time string to date column" do
     @employee = TestEmployee.create(
-      :first_name => "First",
-      :last_name => "Last",
-      :hire_date => @now_iso
+      first_name: "First",
+      last_name: "Last",
+      hire_date: @now_iso
     )
     expect(@employee.hire_date).to eq(@today)
     @employee.reload
@@ -745,12 +591,10 @@ describe "OracleEnhancedAdapter assign string to :date and :datetime columns" do
   end
 
   it "should assign NLS time string to date column" do
-    # ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.string_to_date_format = @nls_date_format
-    ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.string_to_time_format = @nls_time_format
     @employee = TestEmployee.create(
-      :first_name => "First",
-      :last_name => "Last",
-      :hire_date => @now_nls
+      first_name: "First",
+      last_name: "Last",
+      hire_date: @now_nls
     )
     expect(@employee.hire_date).to eq(@today)
     @employee.reload
@@ -760,9 +604,9 @@ describe "OracleEnhancedAdapter assign string to :date and :datetime columns" do
   it "should assign ISO time string to datetime column" do
     ActiveRecord::Base.default_timezone = :local
     @employee = TestEmployee.create(
-      :first_name => "First",
-      :last_name => "Last",
-      :last_login_at => @now_iso
+      first_name: "First",
+      last_name: "Last",
+      last_login_at: @now_iso
     )
     expect(@employee.last_login_at).to eq(@now)
     @employee.reload
@@ -771,11 +615,10 @@ describe "OracleEnhancedAdapter assign string to :date and :datetime columns" do
 
   it "should assign NLS time string to datetime column" do
     ActiveRecord::Base.default_timezone = :local
-    ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.string_to_time_format = @nls_time_format
     @employee = TestEmployee.create(
-      :first_name => "First",
-      :last_name => "Last",
-      :last_login_at => @now_nls
+      first_name: "First",
+      last_name: "Last",
+      last_login_at: @now_nls
     )
     expect(@employee.last_login_at).to eq(@now)
     @employee.reload
@@ -783,11 +626,10 @@ describe "OracleEnhancedAdapter assign string to :date and :datetime columns" do
   end
 
   it "should assign NLS time string with time zone to datetime column" do
-    ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.string_to_time_format = @nls_with_tz_time_format
     @employee = TestEmployee.create(
-      :first_name => "First",
-      :last_name => "Last",
-      :last_login_at => @now_nls_with_tz
+      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
@@ -797,9 +639,9 @@ describe "OracleEnhancedAdapter assign string to :date and :datetime columns" do
   it "should assign ISO date string to datetime column" do
     ActiveRecord::Base.default_timezone = :local
     @employee = TestEmployee.create(
-      :first_name => "First",
-      :last_name => "Last",
-      :last_login_at => @today_iso
+      first_name: "First",
+      last_name: "Last",
+      last_login_at: @today_iso
     )
     expect(@employee.last_login_at).to eq(@today.to_time)
     @employee.reload
@@ -808,12 +650,10 @@ describe "OracleEnhancedAdapter assign string to :date and :datetime columns" do
 
   it "should assign NLS date string to datetime column" do
     ActiveRecord::Base.default_timezone = :local
-    ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.string_to_date_format = @nls_date_format
-    # ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.string_to_time_format = @nls_time_format
     @employee = TestEmployee.create(
-      :first_name => "First",
-      :last_name => "Last",
-      :last_login_at => @today_nls
+      first_name: "First",
+      last_name: "Last",
+      last_login_at: @today_nls
     )
     expect(@employee.last_login_at).to eq(@today.to_time)
     @employee.reload
@@ -891,13 +731,13 @@ describe "OracleEnhancedAdapter handling of CLOB columns" do
     Object.send(:remove_const, "Test2Employee")
     Object.send(:remove_const, "TestEmployeeReadOnlyClob")
     Object.send(:remove_const, "TestSerializeEmployee")
-    ActiveRecord::Base.clear_cache! if ActiveRecord::Base.respond_to?(:"clear_cache!")
+    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"
+      first_name: "First",
+      last_name: "Last"
     )
     expect(@employee).to be_valid
     @employee.reload
@@ -906,29 +746,29 @@ describe "OracleEnhancedAdapter handling of CLOB columns" do
 
   it "should accept Symbol value for CLOB column" do
     @employee = TestEmployee.create!(
-      :comments => :test_comment
+      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"
+      first_name: "First",
+      comments: "initial"
     )
     expect(@employee).to be_valid
     @employee.reload
-    expect(@employee.comments).to eq('initial')
+    expect(@employee.comments).to eq("initial")
     @employee.comments = "changed"
     expect(@employee.save).to eq(true)
     @employee.reload
-    expect(@employee.comments).to eq('initial')
+    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
+      first_name: "First",
+      comments: nil
     )
     expect(@employee.comments).to be_nil
     expect(@employee.save).to eq(true)
@@ -944,9 +784,9 @@ describe "OracleEnhancedAdapter handling of CLOB columns" do
 
   it "should create record with CLOB data" do
     @employee = TestEmployee.create!(
-      :first_name => "First",
-      :last_name => "Last",
-      :comments => @char_data
+      first_name: "First",
+      last_name: "Last",
+      comments: @char_data
     )
     @employee.reload
     expect(@employee.comments).to eq(@char_data)
@@ -954,8 +794,8 @@ describe "OracleEnhancedAdapter handling of CLOB columns" do
 
   it "should update record with CLOB data" do
     @employee = TestEmployee.create!(
-      :first_name => "First",
-      :last_name => "Last"
+      first_name: "First",
+      last_name: "Last"
     )
     @employee.reload
     expect(@employee.comments).to be_nil
@@ -967,22 +807,22 @@ describe "OracleEnhancedAdapter handling of CLOB columns" do
 
   it "should update record with zero-length CLOB data" do
     @employee = TestEmployee.create!(
-      :first_name => "First",
-      :last_name => "Last"
+      first_name: "First",
+      last_name: "Last"
     )
     @employee.reload
     expect(@employee.comments).to be_nil
-    @employee.comments = ''
+    @employee.comments = ""
     @employee.save!
     @employee.reload
-    expect(@employee.comments).to eq('')
+    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
+      first_name: "First",
+      last_name: "Last",
+      comments: @char_data
     )
     @employee.reload
     @employee.comments = @char_data2
@@ -993,9 +833,9 @@ describe "OracleEnhancedAdapter handling of CLOB columns" do
 
   it "should update record that has existing CLOB data with nil" do
     @employee = TestEmployee.create!(
-      :first_name => "First",
-      :last_name => "Last",
-      :comments => @char_data
+      first_name: "First",
+      last_name: "Last",
+      comments: @char_data
     )
     @employee.reload
     @employee.comments = nil
@@ -1006,25 +846,25 @@ describe "OracleEnhancedAdapter handling of CLOB columns" do
 
   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
+      first_name: "First",
+      last_name: "Last",
+      comments: @char_data
     )
     @employee.reload
-    @employee.comments = ''
+    @employee.comments = ""
     @employee.save!
     @employee.reload
-    expect(@employee.comments).to eq('')
+    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 => ''
+      first_name: "First",
+      last_name: "Last",
+      comments: ""
     )
     @employee.reload
-    expect(@employee.comments).to eq('')
+    expect(@employee.comments).to eq("")
     @employee.comments = @char_data
     @employee.save!
     @employee.reload
@@ -1032,10 +872,10 @@ describe "OracleEnhancedAdapter handling of CLOB columns" do
   end
 
   it "should store serializable ruby data structures" do
-    ruby_data1 = {"arbitrary1" => ["ruby", :data, 123]}
-    ruby_data2 = {"arbitrary2" => ["ruby", :data, 123]}
+    ruby_data1 = { "arbitrary1" => ["ruby", :data, 123] }
+    ruby_data2 = { "arbitrary2" => ["ruby", :data, 123] }
     @employee = Test2Employee.create!(
-      :comments => ruby_data1
+      comments: ruby_data1
     )
     @employee.reload
     expect(@employee.comments).to eq(ruby_data1)
@@ -1047,9 +887,9 @@ describe "OracleEnhancedAdapter handling of CLOB columns" do
 
   it "should keep unchanged serialized data when other columns changed" do
     @employee = Test2Employee.create!(
-      :first_name => "First",
-      :last_name => "Last",
-      :comments => "initial serialized data"
+      first_name: "First",
+      last_name: "Last",
+      comments: "initial serialized data"
     )
     @employee.first_name = "Steve"
     @employee.save
@@ -1059,14 +899,14 @@ describe "OracleEnhancedAdapter handling of CLOB columns" do
 
   it "should keep serialized data after save" do
     @employee = Test2Employee.new
-    @employee.comments = {:length=>{:is=>1}}
+    @employee.comments = { length: { is: 1 } }
     @employee.save
     @employee.reload
-    expect(@employee.comments).to eq({:length=>{:is=>1}})
-    @employee.comments = {:length=>{:is=>2}}
+    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}})
+    expect(@employee.comments).to eq(length: { is: 2 })
   end
 end
 
@@ -1086,8 +926,8 @@ describe "OracleEnhancedAdapter handling of BLOB columns" do
       CREATE SEQUENCE test_employees_seq  MINVALUE 1
         INCREMENT BY 1 CACHE 20 NOORDER NOCYCLE
     SQL
-    @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
+    @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
@@ -1103,14 +943,14 @@ describe "OracleEnhancedAdapter handling of BLOB columns" do
 
   after(:each) do
     Object.send(:remove_const, "TestEmployee")
-    ActiveRecord::Base.clear_cache! if ActiveRecord::Base.respond_to?(:"clear_cache!")
+    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
+      first_name: "First",
+      last_name: "Last",
+      binary_data: @binary_data
     )
     @employee.reload
     expect(@employee.binary_data).to eq(@binary_data)
@@ -1118,8 +958,8 @@ describe "OracleEnhancedAdapter handling of BLOB columns" do
 
   it "should update record with BLOB data" do
     @employee = TestEmployee.create!(
-      :first_name => "First",
-      :last_name => "Last"
+      first_name: "First",
+      last_name: "Last"
     )
     @employee.reload
     expect(@employee.binary_data).to be_nil
@@ -1131,22 +971,22 @@ describe "OracleEnhancedAdapter handling of BLOB columns" do
 
   it "should update record with zero-length BLOB data" do
     @employee = TestEmployee.create!(
-      :first_name => "First",
-      :last_name => "Last"
+      first_name: "First",
+      last_name: "Last"
     )
     @employee.reload
     expect(@employee.binary_data).to be_nil
-    @employee.binary_data = ''
+    @employee.binary_data = ""
     @employee.save!
     @employee.reload
-    expect(@employee.binary_data).to eq('')
+    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
+      first_name: "First",
+      last_name: "Last",
+      binary_data: @binary_data
     )
     @employee.reload
     @employee.binary_data = @binary_data2
@@ -1157,9 +997,9 @@ describe "OracleEnhancedAdapter handling of BLOB columns" do
 
   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
+      first_name: "First",
+      last_name: "Last",
+      binary_data: @binary_data
     )
     @employee.reload
     @employee.binary_data = nil
@@ -1170,25 +1010,25 @@ describe "OracleEnhancedAdapter handling of BLOB columns" do
 
   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
+      first_name: "First",
+      last_name: "Last",
+      binary_data: @binary_data
     )
     @employee.reload
-    @employee.binary_data = ''
+    @employee.binary_data = ""
     @employee.save!
     @employee.reload
-    expect(@employee.binary_data).to eq('')
+    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 => ''
+      first_name: "First",
+      last_name: "Last",
+      binary_data: ""
     )
     @employee.reload
-    expect(@employee.binary_data).to eq('')
+    expect(@employee.binary_data).to eq("")
     @employee.binary_data = @binary_data
     @employee.save!
     @employee.reload
@@ -1197,46 +1037,42 @@ describe "OracleEnhancedAdapter handling of BLOB columns" do
 end
 
 describe "OracleEnhancedAdapter handling of RAW columns" do
+  include SchemaSpecHelper
+
   before(:all) do
     ActiveRecord::Base.establish_connection(CONNECTION_PARAMS)
-    @conn = ActiveRecord::Base.connection
-    @conn.execute <<-SQL
-      CREATE TABLE test_employees (
-        employee_id   NUMBER(6,0) PRIMARY KEY,
-        first_name    VARCHAR2(20),
-        last_name     VARCHAR2(25),
-        binary_data   RAW(1024)
-      )
-    SQL
-    @conn.execute <<-SQL
-      CREATE SEQUENCE test_employees_seq  MINVALUE 1
-        INCREMENT BY 1 CACHE 20 NOORDER NOCYCLE
-    SQL
-    @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
+    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
-    @conn.execute "DROP TABLE test_employees"
-    @conn.execute "DROP SEQUENCE test_employees_seq"
+    schema_define do
+      drop_table :test_employees
+    end
   end
 
   before(:each) do
     class ::TestEmployee < ActiveRecord::Base
-      self.primary_key = "employee_id"
     end
   end
 
   after(:each) do
     Object.send(:remove_const, "TestEmployee")
-    ActiveRecord::Base.clear_cache! if ActiveRecord::Base.respond_to?(:"clear_cache!")
+    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
+      first_name: "First",
+      last_name: "Last",
+      binary_data: @binary_data
     )
     @employee.reload
     expect(@employee.binary_data).to eq(@binary_data)
@@ -1244,8 +1080,8 @@ describe "OracleEnhancedAdapter handling of RAW columns" do
 
   it "should update record with RAW data" do
     @employee = TestEmployee.create!(
-      :first_name => "First",
-      :last_name => "Last"
+      first_name: "First",
+      last_name: "Last"
     )
     @employee.reload
     expect(@employee.binary_data).to be_nil
@@ -1257,12 +1093,12 @@ describe "OracleEnhancedAdapter handling of RAW columns" do
 
   it "should update record with zero-length RAW data" do
     @employee = TestEmployee.create!(
-      :first_name => "First",
-      :last_name => "Last"
+      first_name: "First",
+      last_name: "Last"
     )
     @employee.reload
     expect(@employee.binary_data).to be_nil
-    @employee.binary_data = ''
+    @employee.binary_data = ""
     @employee.save!
     @employee.reload
     expect(@employee.binary_data).to be_nil
@@ -1270,9 +1106,9 @@ describe "OracleEnhancedAdapter handling of RAW columns" do
 
   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
+      first_name: "First",
+      last_name: "Last",
+      binary_data: @binary_data
     )
     @employee.reload
     @employee.binary_data = @binary_data2
@@ -1283,9 +1119,9 @@ describe "OracleEnhancedAdapter handling of RAW columns" do
 
   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
+      first_name: "First",
+      last_name: "Last",
+      binary_data: @binary_data
     )
     @employee.reload
     @employee.binary_data = nil
@@ -1296,12 +1132,12 @@ describe "OracleEnhancedAdapter handling of RAW columns" do
 
   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
+      first_name: "First",
+      last_name: "Last",
+      binary_data: @binary_data
     )
     @employee.reload
-    @employee.binary_data = ''
+    @employee.binary_data = ""
     @employee.save!
     @employee.reload
     expect(@employee.binary_data).to be_nil
@@ -1309,9 +1145,9 @@ describe "OracleEnhancedAdapter handling of RAW columns" do
 
   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 => ''
+      first_name: "First",
+      last_name: "Last",
+      binary_data: ""
     )
     @employee.reload
     @employee.binary_data = @binary_data
@@ -1349,25 +1185,27 @@ describe "OracleEnhancedAdapter quoting of NCHAR and NVARCHAR2 columns" do
 
   after(:each) do
     Object.send(:remove_const, "TestItem")
-    ActiveRecord::Base.clear_cache! if ActiveRecord::Base.respond_to?(:"clear_cache!")
+    ActiveRecord::Base.clear_cache!
   end
 
   it "should quote with N prefix" do
-    columns = @conn.columns('test_items')
+    columns = @conn.columns("test_items")
     %w(nchar_column nvarchar2_column char_column varchar2_column).each do |col|
-      column = columns.detect{|c| c.name == col}
-      expect(@conn.quote('abc', column)).to eq(column.sql_type[0,1] == 'N' ? "N'abc'" : "'abc'")
-      expect(@conn.quote(nil, column)).to eq('NULL')
+      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 = 'āčē'
+    nchar_data = "āčē"
     item = TestItem.create(
-      :nchar_column => nchar_data,
-      :nvarchar2_column => nchar_data
+      nchar_column: nchar_data,
+      nvarchar2_column: nchar_data
     ).reload
-    expect(item.nchar_column).to eq(nchar_data + ' '*17)
+    expect(item.nchar_column).to eq(nchar_data + " " * 17)
     expect(item.nvarchar2_column).to eq(nchar_data)
   end
 
@@ -1414,8 +1252,8 @@ describe "OracleEnhancedAdapter handling of BINARY_FLOAT columns" do
   end
 
   it "should set BINARY_FLOAT column type as float" do
-    columns = @conn.columns('test2_employees')
-    column = columns.detect{|c| c.name == "hourly_rate"}
+    columns = @conn.columns("test2_employees")
+    column = columns.detect { |c| c.name == "hourly_rate" }
     expect(column.type).to eq(:float)
   end
 
@@ -1427,3 +1265,58 @@ describe "OracleEnhancedAdapter handling of BINARY_FLOAT columns" do
     expect(employee.hourly_rate).to eq(4.400000095367432)
   end
 end
+
+describe "OracleEnhancedAdapter attribute API support for JSON type" do
+
+  include SchemaSpecHelper
+
+  before(:all) do
+    @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
+    post = 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