activerecord-oracle_enhanced-adapter 1.8.2 → 5.2.0.beta1

data/spec/active_record/connection_adapters/{oracle_enhanced_structure_dump_spec.rb → oracle_enhanced/structure_dump_spec.rb}

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 describe "OracleEnhancedAdapter structure dump" do
   include LoggerSpecHelper
 
@@ -150,6 +152,18 @@ describe "OracleEnhancedAdapter structure dump" do
       expect(dump).to match(/CREATE TABLE \"BARS\" \(\n \"ID\" NUMBER\(38,0\) NOT NULL,\n \"SUPER\" RAW\(255\) GENERATED ALWAYS AS \(HEXTORAW\(TO_CHAR\(ID\)\)\) VIRTUAL/)
     end
 
+    it "should dump NCLOB columns" do
+      @conn.execute <<-SQL
+        CREATE TABLE bars (
+          id          NUMBER(38,0) NOT NULL,
+          nclob_text  NCLOB,
+          PRIMARY KEY (ID)
+        )
+      SQL
+      dump = ActiveRecord::Base.connection.structure_dump
+      expect(dump).to match(/CREATE TABLE \"BARS\" \(\n \"ID\" NUMBER\(38,0\) NOT NULL,\n \"NCLOB_TEXT\" NCLOB/)
+    end
+
     it "should dump unique keys" do
       @conn.execute <<-SQL
         ALTER TABLE test_posts
@@ -232,7 +246,7 @@ describe "OracleEnhancedAdapter structure dump" do
   end
   describe "temporary tables" do
     after(:all) do
-      @conn.drop_table :test_comments rescue nil
+      @conn.drop_table :test_comments, if_exists: true
     end
     it "should dump correctly" do
       @conn.create_table :test_comments, temporary: true, id: false do |t|
@@ -243,7 +257,39 @@ describe "OracleEnhancedAdapter structure dump" do
     end
   end
 
-  describe "database stucture dump extentions" do
+  describe "sequences" do
+    let(:sequence_name) { "test_sequence_a" }
+    before(:each) do
+      @conn.execute sql
+    end
+    after(:each) do
+      @conn.execute "drop SEQUENCE \"#{sequence_name}\""
+    end
+    subject do
+      ActiveRecord::Base.connection.structure_dump
+    end
+    context "default sequence" do
+      let(:sql) { "CREATE SEQUENCE \"#{sequence_name}\"" }
+      it { is_expected.to_not match(%r{CREATE SEQUENCE \"#{sequence_name}" MAXVALUE \d+ MINVALUE \d+ NOORDER NOCYCLE}) }
+    end
+    context "noorder" do
+      let(:sql) { "CREATE SEQUENCE \"#{sequence_name}\" NOORDER" }
+      it { is_expected.to include("NOORDER") }
+      it { is_expected.to_not include(" ORDER") }
+    end
+    context "order" do
+      let(:sql) { "CREATE SEQUENCE \"#{sequence_name}\" ORDER" }
+      it { is_expected.to include(" ORDER") }
+      it { is_expected.to_not include("NOORDER") }
+    end
+    context "min max values" do
+      let(:sql) { "CREATE SEQUENCE \"#{sequence_name}\" MINVALUE 7 MAXVALUE 444" }
+      it { is_expected.to include("MINVALUE 7") }
+      it { is_expected.to include("MAXVALUE 444") }
+    end
+  end
+
+  describe "database structure dump extensions" do
     before(:all) do
       @conn.execute <<-SQL
         CREATE TABLE nvarchartable (

data/spec/active_record/connection_adapters/oracle_enhanced_adapter_spec.rb

@@ -1,35 +1,4 @@
-describe "OracleEnhancedAdapter establish connection" do
-
-  it "should connect to database" do
-    ActiveRecord::Base.establish_connection(CONNECTION_PARAMS)
-    expect(ActiveRecord::Base.connection).not_to be_nil
-    expect(ActiveRecord::Base.connection.class).to eq(ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter)
-  end
-
-  it "should connect to database as SYSDBA" do
-    ActiveRecord::Base.establish_connection(SYS_CONNECTION_PARAMS)
-    expect(ActiveRecord::Base.connection).not_to be_nil
-    expect(ActiveRecord::Base.connection.class).to eq(ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter)
-  end
-
-  it "should be active after connection to database" do
-    ActiveRecord::Base.establish_connection(CONNECTION_PARAMS)
-    expect(ActiveRecord::Base.connection).to be_active
-  end
-
-  it "should not be active after disconnection to database" do
-    ActiveRecord::Base.establish_connection(CONNECTION_PARAMS)
-    ActiveRecord::Base.connection.disconnect!
-    expect(ActiveRecord::Base.connection).not_to be_active
-  end
-
-  it "should be active after reconnection to database" do
-    ActiveRecord::Base.establish_connection(CONNECTION_PARAMS)
-    ActiveRecord::Base.connection.reconnect!
-    expect(ActiveRecord::Base.connection).to be_active
-  end
-
-end
+# frozen_string_literal: true
 
 describe "OracleEnhancedAdapter" do
   include LoggerSpecHelper
@@ -42,27 +11,27 @@ describe "OracleEnhancedAdapter" do
   describe "cache table columns" do
     before(:all) do
       @conn = ActiveRecord::Base.connection
-      @conn.execute "DROP TABLE test_employees" rescue nil
-      @oracle11g_or_higher = !! @conn.select_value(
-        "select * from product_component_version where product like 'Oracle%' and to_number(substr(version,1,2)) >= 11")
-      @conn.execute <<-SQL
-        CREATE TABLE test_employees (
-          id            NUMBER PRIMARY KEY,
-          first_name    VARCHAR2(20),
-          last_name     VARCHAR2(25),
-          #{ @oracle11g_or_higher ? "full_name AS (first_name || ' ' || last_name)," : "full_name VARCHAR2(46),"}
-          hire_date     DATE
-        )
-      SQL
-      @conn.execute <<-SQL
-        CREATE TABLE test_employees_without_pk (
-          first_name    VARCHAR2(20),
-          last_name     VARCHAR2(25),
-          hire_date     DATE
-        )
-      SQL
+      schema_define do
+        create_table :test_employees, force: true do |t|
+          t.string  :first_name, limit: 20
+          t.string  :last_name, limit: 25
+          if ActiveRecord::Base.connection.supports_virtual_columns?
+            t.virtual :full_name, as: "(first_name || ' ' || last_name)"
+          else
+            t.string  :full_name, limit: 46
+          end
+          t.date    :hire_date
+        end
+      end
+      schema_define do
+        create_table :test_employees_without_pk, id: false, force: true do |t|
+          t.string  :first_name, limit: 20
+          t.string  :last_name, limit: 25
+          t.date    :hire_date
+        end
+      end
       @column_names = ["id", "first_name", "last_name", "full_name", "hire_date"]
-      @column_sql_types = ["NUMBER", "VARCHAR2(20)", "VARCHAR2(25)", "VARCHAR2(46)", "DATE"]
+      @column_sql_types = ["NUMBER(38)", "VARCHAR2(20)", "VARCHAR2(25)", "VARCHAR2(46)", "DATE"]
       class ::TestEmployee < ActiveRecord::Base
       end
       # Another class using the same table
@@ -75,16 +44,14 @@ describe "OracleEnhancedAdapter" do
       @conn = ActiveRecord::Base.connection
       Object.send(:remove_const, "TestEmployee")
       Object.send(:remove_const, "TestEmployee2")
-      @conn.execute "DROP TABLE test_employees"
-      @conn.execute "DROP TABLE test_employees_without_pk"
-      ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.cache_columns = nil
+      @conn.drop_table :test_employees, if_exists: true
+      @conn.drop_table :test_employees_without_pk, if_exists: true
       ActiveRecord::Base.clear_cache!
     end
 
     before(:each) do
       set_logger
       @conn = ActiveRecord::Base.connection
-      @conn.clear_columns_cache
     end
 
     after(:each) do
@@ -93,12 +60,8 @@ describe "OracleEnhancedAdapter" do
 
     describe "without column caching" do
 
-      before(:each) do
-        ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.cache_columns = false
-      end
-
       it "should identify virtual columns as such" do
-        skip "Not supported in this database version" unless @oracle11g_or_higher
+        skip "Not supported in this database version" unless @conn.supports_virtual_columns?
         te = TestEmployee.connection.columns("test_employees").detect(&:virtual?)
         expect(te.name).to eq("full_name")
       end
@@ -116,14 +79,14 @@ describe "OracleEnhancedAdapter" do
       end
 
       it "should get primary key from database at first time" do
-        expect(TestEmployee.connection.pk_and_sequence_for("test_employees")).to eq(["id", nil])
+        expect(TestEmployee.connection.pk_and_sequence_for("test_employees")).to eq(["id", "test_employees_seq"])
         expect(@logger.logged(:debug).last).to match(/select .* from all_constraints/im)
       end
 
       it "should get primary key from database at first time" do
-        expect(TestEmployee.connection.pk_and_sequence_for("test_employees")).to eq(["id", nil])
+        expect(TestEmployee.connection.pk_and_sequence_for("test_employees")).to eq(["id", "test_employees_seq"])
         @logger.clear(:debug)
-        expect(TestEmployee.connection.pk_and_sequence_for("test_employees")).to eq(["id", nil])
+        expect(TestEmployee.connection.pk_and_sequence_for("test_employees")).to eq(["id", "test_employees_seq"])
         expect(@logger.logged(:debug).last).to match(/select .* from all_constraints/im)
       end
 
@@ -133,229 +96,6 @@ describe "OracleEnhancedAdapter" do
           expect(TestEmployee2.columns.map(&:sql_type)).to eq(@column_sql_types)
         end
       end
-
-    end
-
-    describe "with column caching" do
-
-      before(:each) do
-        ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.cache_columns = true
-      end
-
-      it "should get columns from database at first time" do
-        expect(TestEmployee.connection.columns("test_employees").map(&:name)).to eq(@column_names)
-        expect(@logger.logged(:debug).last).to match(/select .* from all_tab_cols/im)
-      end
-
-      it "should get columns from cache at second time" do
-        TestEmployee.connection.columns("test_employees")
-        @logger.clear(:debug)
-        expect(TestEmployee.connection.columns("test_employees").map(&:name)).to eq(@column_names)
-        expect(@logger.logged(:debug).last).to be_blank
-      end
-
-      it "should get primary key from database at first time" do
-        expect(TestEmployee.connection.pk_and_sequence_for("test_employees")).to eq(["id", nil])
-        expect(@logger.logged(:debug).last).to match(/select .* from all_constraints/im)
-      end
-
-      it "should get primary key from cache at first time" do
-        expect(TestEmployee.connection.pk_and_sequence_for("test_employees")).to eq(["id", nil])
-        @logger.clear(:debug)
-        expect(TestEmployee.connection.pk_and_sequence_for("test_employees")).to eq(["id", nil])
-        expect(@logger.logged(:debug).last).to be_blank
-      end
-
-      it "should store primary key as nil in cache at first time for table without primary key" do
-        expect(TestEmployee.connection.pk_and_sequence_for("test_employees_without_pk")).to eq(nil)
-        @logger.clear(:debug)
-        expect(TestEmployee.connection.pk_and_sequence_for("test_employees_without_pk")).to eq(nil)
-        expect(@logger.logged(:debug).last).to be_blank
-      end
-
-    end
-
-  end
-
-  describe "reserved words column quoting" do
-
-    before(:all) do
-      schema_define do
-        create_table :test_reserved_words do |t|
-          t.string      :varchar2
-          t.integer     :integer
-          t.text        :comment
-        end
-      end
-      class ::TestReservedWord < ActiveRecord::Base; end
-    end
-
-    after(:all) do
-      schema_define do
-        drop_table :test_reserved_words
-      end
-      Object.send(:remove_const, "TestReservedWord")
-      ActiveRecord::Base.table_name_prefix = nil
-      ActiveRecord::Base.clear_cache!
-    end
-
-    before(:each) do
-      set_logger
-    end
-
-    after(:each) do
-      clear_logger
-    end
-
-    it "should create table" do
-      [:varchar2, :integer, :comment].each do |attr|
-        expect(TestReservedWord.columns_hash[attr.to_s].name).to eq(attr.to_s)
-      end
-    end
-
-    it "should create record" do
-      attrs = {
-        varchar2: "dummy",
-        integer: 1,
-        comment: "dummy"
-      }
-      record = TestReservedWord.create!(attrs)
-      record.reload
-      attrs.each do |k, v|
-        expect(record.send(k)).to eq(v)
-      end
-    end
-
-    it "should remove double quotes in column quoting" do
-      expect(ActiveRecord::Base.connection.quote_column_name('aaa "bbb" ccc')).to eq('"aaa bbb ccc"')
-    end
-
-  end
-
-  describe "valid table names" do
-    before(:all) do
-      @adapter = ActiveRecord::ConnectionAdapters::OracleEnhanced::Quoting
-    end
-
-    it "should be valid with letters and digits" do
-      expect(@adapter.valid_table_name?("abc_123")).to be_truthy
-    end
-
-    it "should be valid with schema name" do
-      expect(@adapter.valid_table_name?("abc_123.def_456")).to be_truthy
-    end
-
-    it "should be valid with $ in name" do
-      expect(@adapter.valid_table_name?("sys.v$session")).to be_truthy
-    end
-
-    it "should be valid with upcase schema name" do
-      expect(@adapter.valid_table_name?("ABC_123.DEF_456")).to be_truthy
-    end
-
-    it "should be valid with irregular schema name and database links" do
-      expect(@adapter.valid_table_name?('abc$#_123.abc$#_123@abc$#@._123')).to be_truthy
-    end
-
-    it "should not be valid with two dots in name" do
-      expect(@adapter.valid_table_name?("abc_123.def_456.ghi_789")).to be_falsey
-    end
-
-    it "should not be valid with invalid characters" do
-      expect(@adapter.valid_table_name?("warehouse-things")).to be_falsey
-    end
-
-    it "should not be valid with for camel-case" do
-      expect(@adapter.valid_table_name?("Abc")).to be_falsey
-      expect(@adapter.valid_table_name?("aBc")).to be_falsey
-      expect(@adapter.valid_table_name?("abC")).to be_falsey
-    end
-
-    it "should not be valid for names > 30 characters" do
-      expect(@adapter.valid_table_name?("a" * 31)).to be_falsey
-    end
-
-    it "should not be valid for schema names > 30 characters" do
-      expect(@adapter.valid_table_name?(("a" * 31) + ".validname")).to be_falsey
-    end
-
-    it "should not be valid for database links > 128 characters" do
-      expect(@adapter.valid_table_name?("name@" + "a" * 129)).to be_falsey
-    end
-
-    it "should not be valid for names that do not begin with alphabetic characters" do
-      expect(@adapter.valid_table_name?("1abc")).to be_falsey
-      expect(@adapter.valid_table_name?("_abc")).to be_falsey
-      expect(@adapter.valid_table_name?("abc.1xyz")).to be_falsey
-      expect(@adapter.valid_table_name?("abc._xyz")).to be_falsey
-    end
-  end
-
-  describe "table quoting" do
-
-    def create_warehouse_things_table
-      ActiveRecord::Schema.define do
-        suppress_messages do
-          create_table "warehouse-things" do |t|
-            t.string      :name
-            t.integer     :foo
-          end
-        end
-      end
-    end
-
-    def create_camel_case_table
-      ActiveRecord::Schema.define do
-        suppress_messages do
-          create_table "CamelCase" do |t|
-            t.string      :name
-            t.integer     :foo
-          end
-        end
-      end
-    end
-
-    before(:all) do
-      @conn = ActiveRecord::Base.connection
-    end
-
-    after(:each) do
-      ActiveRecord::Schema.define do
-        suppress_messages do
-          drop_table "warehouse-things" rescue nil
-          drop_table "CamelCase" rescue nil
-        end
-      end
-      Object.send(:remove_const, "WarehouseThing") rescue nil
-      Object.send(:remove_const, "CamelCase") rescue nil
-    end
-
-    it "should allow creation of a table with non alphanumeric characters" do
-      create_warehouse_things_table
-      class ::WarehouseThing < ActiveRecord::Base
-        self.table_name = "warehouse-things"
-      end
-
-      wh = WarehouseThing.create!(name: "Foo", foo: 2)
-      expect(wh.id).not_to be_nil
-
-      expect(@conn.tables).to include("warehouse-things")
-    end
-
-    it "should allow creation of a table with CamelCase name" do
-      create_camel_case_table
-      class ::CamelCase < ActiveRecord::Base
-        self.table_name = "CamelCase"
-      end
-
-      cc = CamelCase.create!(name: "Foo", foo: 2)
-      expect(cc.id).not_to be_nil
-
-      expect(@conn.tables).to include("CamelCase")
-    end
-
-    it "properly quotes database links" do
-      expect(@conn.quote_table_name("asdf@some.link")).to eq('"ASDF"@"SOME.LINK"')
     end
   end
 
@@ -364,7 +104,7 @@ describe "OracleEnhancedAdapter" do
       @conn = ActiveRecord::Base.connection
       @db_link = "db_link"
       @sys_conn = ActiveRecord::Base.oracle_enhanced_connection(SYSTEM_CONNECTION_PARAMS)
-      @sys_conn.drop_table :test_posts rescue nil
+      @sys_conn.drop_table :test_posts, if_exists: true
       @sys_conn.create_table :test_posts do |t|
         t.string      :title
         # cannot update LOBs over database link
@@ -387,7 +127,7 @@ describe "OracleEnhancedAdapter" do
       @conn.execute "DROP SYNONYM test_posts"
       @conn.execute "DROP SYNONYM test_posts_seq"
       @conn.execute "DROP DATABASE LINK #{@db_link}" rescue nil
-      @sys_conn.drop_table :test_posts rescue nil
+      @sys_conn.drop_table :test_posts, if_exists: true
       Object.send(:remove_const, "TestPost") rescue nil
       ActiveRecord::Base.clear_cache!
     end
@@ -435,7 +175,7 @@ describe "OracleEnhancedAdapter" do
     end
 
     after(:each) do
-      @conn.drop_table :foos rescue nil
+      @conn.drop_table :foos, if_exists: true
     end
     it "should create ok" do
       @conn.create_table :foos, temporary: true, id: false do |t|
@@ -500,7 +240,7 @@ describe "OracleEnhancedAdapter" do
       ActiveRecord::Base.establish_connection(CONNECTION_PARAMS.merge(statement_limit: 3))
       @conn = ActiveRecord::Base.connection
       schema_define do
-        drop_table :test_posts rescue nil
+        drop_table :test_posts, if_exists: true
         create_table :test_posts
       end
       class ::TestPost < ActiveRecord::Base
@@ -521,23 +261,20 @@ describe "OracleEnhancedAdapter" do
     end
 
     it "should clear older cursors when statement limit is reached" do
-      pk = TestPost.columns_hash[TestPost.primary_key]
-      sub = Arel::Nodes::BindParam.new.to_sql
-      binds = [ActiveRecord::Relation::QueryAttribute.new(pk, 1, ActiveRecord::Type::Integer.new)]
-
+      binds = [ActiveRecord::Relation::QueryAttribute.new("id", 1, ActiveRecord::Type::OracleEnhanced::Integer.new)]
+      # free statement pool from dictionary selections  to ensure next selects will increase statement pool
+      @statements.clear
       expect {
         4.times do |i|
-          @conn.exec_query("SELECT * FROM test_posts WHERE #{i}=#{i} AND id = #{sub}", "SQL", binds)
+          @conn.exec_query("SELECT * FROM test_posts WHERE #{i}=#{i} AND id = :id", "SQL", binds)
         end
       }.to change(@statements, :length).by(+3)
     end
 
     it "should cache UPDATE statements with bind variables" do
       expect {
-        pk = TestPost.columns_hash[TestPost.primary_key]
-        sub = Arel::Nodes::BindParam.new.to_sql
-        binds = [ActiveRecord::Relation::QueryAttribute.new(pk, 1, ActiveRecord::Type::Integer.new)]
-        @conn.exec_update("UPDATE test_posts SET id = #{sub}", "SQL", binds)
+        binds = [ActiveRecord::Relation::QueryAttribute.new("id", 1, ActiveRecord::Type::OracleEnhanced::Integer.new)]
+        @conn.exec_update("UPDATE test_posts SET id = :id", "SQL", binds)
       }.to change(@statements, :length).by(+1)
     end
 
@@ -553,7 +290,7 @@ describe "OracleEnhancedAdapter" do
     before(:all) do
       @conn = ActiveRecord::Base.connection
       schema_define do
-        drop_table :test_posts rescue nil
+        drop_table :test_posts, if_exists: true
         create_table :test_posts
       end
       class ::TestPost < ActiveRecord::Base
@@ -575,35 +312,24 @@ describe "OracleEnhancedAdapter" do
     end
 
     it "should explain query with binds" do
-      pending "Pending until further investigation made for #908" if RUBY_ENGINE == "jruby"
-      pk = TestPost.columns_hash[TestPost.primary_key]
-      sub = Arel::Nodes::BindParam.new.to_sql
-      binds = [ActiveRecord::Relation::QueryAttribute.new(pk, 1, ActiveRecord::Type::Integer.new)]
-      explain = @conn.explain(TestPost.where(TestPost.arel_table[pk.name].eq(sub)), binds)
+      binds = [ActiveRecord::Relation::QueryAttribute.new("id", 1, ActiveRecord::Type::OracleEnhanced::Integer.new)]
+      explain = TestPost.where(id: binds).explain
       expect(explain).to include("Cost")
-      expect(explain).to include("INDEX UNIQUE SCAN")
+      expect(explain).to include("INDEX UNIQUE SCAN").or include("TABLE ACCESS FULL")
     end
   end
 
   describe "using offset and limit" do
     before(:all) do
       @conn = ActiveRecord::Base.connection
-      @conn.execute "DROP TABLE test_employees" rescue nil
-      @conn.execute <<-SQL
-        CREATE TABLE test_employees (
-          id            NUMBER PRIMARY KEY,
-          sort_order    NUMBER(38,0),
-          first_name    VARCHAR2(20),
-          last_name     VARCHAR2(25),
-          updated_at    DATE,
-          created_at    DATE
-        )
-      SQL
-      @conn.execute "DROP SEQUENCE test_employees_seq" rescue nil
-      @conn.execute <<-SQL
-        CREATE SEQUENCE test_employees_seq  MINVALUE 1
-          INCREMENT BY 1 START WITH 1 CACHE 20 NOORDER NOCYCLE
-      SQL
+      schema_define do
+        create_table :test_employees, force: true do |t|
+          t.integer   :sort_order
+          t.string    :first_name, limit: 20
+          t.string    :last_name, limit: 20
+          t.timestamps
+        end
+      end
       @employee = Class.new(ActiveRecord::Base) do
         self.table_name = :test_employees
       end
@@ -616,8 +342,7 @@ describe "OracleEnhancedAdapter" do
     end
 
     after(:all) do
-      @conn.execute "DROP TABLE test_employees"
-      @conn.execute "DROP SEQUENCE test_employees_seq"
+      @conn.drop_table :test_employees, if_exists: true
     end
 
     after(:each) do
@@ -643,15 +368,15 @@ describe "OracleEnhancedAdapter" do
   describe "valid_type?" do
     before(:all) do
       @conn = ActiveRecord::Base.connection
-      @conn.execute <<-SQL
-        CREATE TABLE test_employees (
-          first_name    VARCHAR2(20)
-       )
-      SQL
+      schema_define do
+        create_table :test_employees, force: true do |t|
+          t.string :first_name, limit: 20
+        end
+      end
     end
 
     after(:all) do
-      @conn.execute "DROP TABLE test_employees"
+      @conn.drop_table :test_employees, if_exists: true
     end
 
     it "returns true when passed a valid type" do
@@ -736,4 +461,150 @@ describe "OracleEnhancedAdapter" do
       expect(TestLog.count).to eq 2
     end
   end
+
+  describe "synonym_names" do
+    before(:all) do
+      schema_define do
+        create_table :test_comments, force: true do |t|
+          t.string :comment
+        end
+        add_synonym :synonym_comments, :test_comments
+      end
+    end
+
+    after(:all) do
+      schema_define do
+        drop_table :test_comments
+        remove_synonym :synonym_comments
+      end
+      ActiveRecord::Base.clear_cache! if ActiveRecord::Base.respond_to?(:"clear_cache!")
+    end
+
+    it "includes synonyms in data_source" do
+      conn = ActiveRecord::Base.connection
+      expect(conn).to be_data_source_exist("synonym_comments")
+      expect(conn.data_sources).to include("synonym_comments")
+    end
+  end
+
+  describe "dictionary selects with bind variables" do
+    before(:all) do
+      ActiveRecord::Base.establish_connection(CONNECTION_PARAMS)
+      @conn = ActiveRecord::Base.connection
+      schema_define do
+        drop_table :test_posts, if_exists: true
+        create_table :test_posts
+      end
+      class ::TestPost < ActiveRecord::Base
+      end
+    end
+
+    before(:each) do
+      @conn.clear_cache!
+      set_logger
+    end
+
+    after(:each) do
+      clear_logger
+    end
+
+    after(:all) do
+      schema_define do
+        drop_table :test_posts
+      end
+      Object.send(:remove_const, "TestPost")
+      ActiveRecord::Base.clear_cache!
+    end
+
+    it "should test table existence" do
+      expect(@conn.table_exists?("TEST_POSTS")).to eq true
+      expect(@conn.table_exists?("NOT_EXISTING")).to eq false
+    end
+
+    it "should return array from indexes with bind usage" do
+      expect(@conn.indexes("TEST_POSTS").class).to eq Array
+      expect(@logger.logged(:debug).last).to match(/:owner/)
+      expect(@logger.logged(:debug).last).to match(/\[\["owner", "#{DATABASE_USER.upcase}"\], \["owner", "#{DATABASE_USER.upcase}"\]\]/)
+    end
+
+    it "should not have primary key trigger with bind usage" do
+      expect(@conn.has_primary_key_trigger?("TEST_POSTS")).to eq false
+      expect(@logger.logged(:debug).last).to match(/:owner/)
+      expect(@logger.logged(:debug).last).to match(/:table_name/)
+      expect(@logger.logged(:debug).last).to match(/\[\["owner", "#{DATABASE_USER.upcase}"\], \["trigger_name", "TEST_POSTS_PKT"\], \["owner", "#{DATABASE_USER.upcase}"\], \["table_name", "TEST_POSTS"\]\]/)
+    end
+
+    it "should return content from columns with bind usage" do
+      expect(@conn.columns("TEST_POSTS").length).to be > 0
+      expect(@logger.logged(:debug).last).to match(/:owner/)
+      expect(@logger.logged(:debug).last).to match(/:table_name/)
+      expect(@logger.logged(:debug).last).to match(/\[\["owner", "#{DATABASE_USER.upcase}"\], \["table_name", "TEST_POSTS"\]\]/)
+    end
+
+    it "should return pk and sequence from pk_and_sequence_for with bind usage" do
+      expect(@conn.pk_and_sequence_for("TEST_POSTS").length).to eq 2
+      expect(@logger.logged(:debug).last).to match(/:owner/)
+      expect(@logger.logged(:debug).last).to match(/\[\["owner", "#{DATABASE_USER.upcase}"\], \["table_name", "TEST_POSTS"\]\]/)
+    end
+
+    it "should return pk from primary_keys with bind usage" do
+      expect(@conn.primary_keys("TEST_POSTS")).to eq ["id"]
+      expect(@logger.logged(:debug).last).to match(/:owner/)
+      expect(@logger.logged(:debug).last).to match(/\[\["owner", "#{DATABASE_USER.upcase}"\], \["table_name", "TEST_POSTS"\]\]/)
+    end
+
+    it "should return false from temporary_table? with bind usage" do
+      expect(@conn.temporary_table?("TEST_POSTS")).to eq false
+      expect(@logger.logged(:debug).last).to match(/:table_name/)
+      expect(@logger.logged(:debug).last).to match(/\[\["table_name", "TEST_POSTS"\]\]/)
+    end
+
+  end
+
+  describe "Transaction" do
+    before(:all) do
+      schema_define do
+        create_table :test_posts do |t|
+          t.string :title
+        end
+      end
+      class ::TestPost < ActiveRecord::Base
+      end
+    end
+
+    it "Raises Deadlocked when a deadlock is encountered" do
+      expect {
+        barrier = Concurrent::CyclicBarrier.new(2)
+
+        t1 = TestPost.create(title: "one")
+        t2 = TestPost.create(title: "two")
+
+        thread = Thread.new do
+          TestPost.transaction do
+            t1.lock!
+            barrier.wait
+            t2.update_attributes(title: "one")
+          end
+        end
+
+        begin
+          TestPost.transaction do
+            t2.lock!
+            barrier.wait
+            t1.update_attributes(title: "two")
+          end
+        ensure
+          thread.join
+        end
+      }.to raise_error(ActiveRecord::Deadlocked)
+    end
+
+    after(:all) do
+      schema_define do
+        drop_table :test_posts
+      end
+      Object.send(:remove_const, "TestPost") rescue nil
+      ActiveRecord::Base.clear_cache!
+    end
+  end
 end