oracle_enhanced 1.2.5

data/lib/active_record/connection_adapters/oracle_enhanced_schema_statements_ext.rb

@@ -0,0 +1,224 @@
+require 'digest/sha1'
+
+module ActiveRecord
+  module ConnectionAdapters
+    module OracleEnhancedSchemaStatementsExt
+      def supports_foreign_keys? #:nodoc:
+        true
+      end
+
+      # Create primary key trigger (so that you can skip primary key value in INSERT statement).
+      # By default trigger name will be "table_name_pkt", you can override the name with 
+      # :trigger_name option (but it is not recommended to override it as then this trigger will
+      # not be detected by ActiveRecord model and it will still do prefetching of sequence value).
+      #
+      #   add_primary_key_trigger :users
+      #
+      # You can also create primary key trigger using +create_table+ with :primary_key_trigger
+      # option:
+      #
+      #   create_table :users, :primary_key_trigger => true do |t|
+      #     # ...
+      #   end
+      #
+      def add_primary_key_trigger(table_name, options)
+        # call the same private method that is used for create_table :primary_key_trigger => true
+        create_primary_key_trigger(table_name, options)
+      end
+
+      # Adds a new foreign key to the +from_table+, referencing the primary key of +to_table+
+      # (syntax and partial implementation taken from http://github.com/matthuhiggins/foreigner)
+      #
+      # The foreign key will be named after the from and to tables unless you pass
+      # <tt>:name</tt> as an option.
+      #
+      # === Examples
+      # ==== Creating a foreign key
+      #  add_foreign_key(:comments, :posts)
+      # generates
+      #  ALTER TABLE comments ADD CONSTRAINT
+      #     comments_post_id_fk FOREIGN KEY (post_id) REFERENCES posts (id)
+      # 
+      # ==== Creating a named foreign key
+      #  add_foreign_key(:comments, :posts, :name => 'comments_belongs_to_posts')
+      # generates
+      #  ALTER TABLE comments ADD CONSTRAINT
+      #     comments_belongs_to_posts FOREIGN KEY (post_id) REFERENCES posts (id)
+      # 
+      # ==== Creating a cascading foreign_key on a custom column
+      #  add_foreign_key(:people, :people, :column => 'best_friend_id', :dependent => :nullify)
+      # generates
+      #  ALTER TABLE people ADD CONSTRAINT
+      #     people_best_friend_id_fk FOREIGN KEY (best_friend_id) REFERENCES people (id)
+      #     ON DELETE SET NULL
+      # 
+      # === Supported options
+      # [:column]
+      #   Specify the column name on the from_table that references the to_table. By default this is guessed
+      #   to be the singular name of the to_table with "_id" suffixed. So a to_table of :posts will use "post_id"
+      #   as the default <tt>:column</tt>.
+      # [:primary_key]
+      #   Specify the column name on the to_table that is referenced by this foreign key. By default this is
+      #   assumed to be "id".
+      # [:name]
+      #   Specify the name of the foreign key constraint. This defaults to use from_table and foreign key column.
+      # [:dependent]
+      #   If set to <tt>:delete</tt>, the associated records in from_table are deleted when records in to_table table are deleted.
+      #   If set to <tt>:nullify</tt>, the foreign key column is set to +NULL+.
+      def add_foreign_key(from_table, to_table, options = {})
+        column = options[:column] || "#{to_table.to_s.singularize}_id"
+        constraint_name = foreign_key_constraint_name(from_table, column, options)
+        sql = "ALTER TABLE #{quote_table_name(from_table)} ADD CONSTRAINT #{quote_column_name(constraint_name)} "
+        sql << foreign_key_definition(to_table, options)
+        execute sql
+      end
+
+      def foreign_key_definition(to_table, options = {}) #:nodoc:
+        column = options[:column] || "#{to_table.to_s.singularize}_id"
+        primary_key = options[:primary_key] || "id"
+        sql = "FOREIGN KEY (#{quote_column_name(column)}) REFERENCES #{quote_table_name(to_table)}(#{primary_key})"
+        case options[:dependent]
+        when :nullify
+          sql << " ON DELETE SET NULL"
+        when :delete
+          sql << " ON DELETE CASCADE"
+        end
+        sql
+      end
+
+      # Remove the given foreign key from the table.
+      #
+      # ===== Examples
+      # ====== Remove the suppliers_company_id_fk in the suppliers table.
+      #   remove_foreign_key :suppliers, :companies
+      # ====== Remove the foreign key named accounts_branch_id_fk in the accounts table.
+      #   remove_foreign_key :accounts, :column => :branch_id
+      # ====== Remove the foreign key named party_foreign_key in the accounts table.
+      #   remove_foreign_key :accounts, :name => :party_foreign_key
+      def remove_foreign_key(from_table, options)
+        if Hash === options
+          constraint_name = foreign_key_constraint_name(from_table, options[:column], options)
+        else
+          constraint_name = foreign_key_constraint_name(from_table, "#{options.to_s.singularize}_id")
+        end
+        execute "ALTER TABLE #{quote_table_name(from_table)} DROP CONSTRAINT #{quote_column_name(constraint_name)}"
+      end
+
+      private
+
+      def foreign_key_constraint_name(table_name, column, options = {})
+        constraint_name = original_name = options[:name] || "#{table_name}_#{column}_fk"
+        return constraint_name if constraint_name.length <= OracleEnhancedAdapter::IDENTIFIER_MAX_LENGTH
+        # leave just first three letters from each word
+        constraint_name = constraint_name.split('_').map{|w| w[0,3]}.join('_')
+        # generate unique name using hash function
+        if constraint_name.length > OracleEnhancedAdapter::IDENTIFIER_MAX_LENGTH
+          constraint_name = 'c'+Digest::SHA1.hexdigest(original_name)[0,OracleEnhancedAdapter::IDENTIFIER_MAX_LENGTH-1]
+        end
+        @logger.warn "#{adapter_name} shortened foreign key constraint name #{original_name} to #{constraint_name}" if @logger
+        constraint_name
+      end
+      
+
+      public
+
+      # get table foreign keys for schema dump
+      def foreign_keys(table_name) #:nodoc:
+        (owner, desc_table_name, db_link) = @connection.describe(table_name)
+
+        fk_info = select_all(<<-SQL, 'Foreign Keys')
+          SELECT r.table_name to_table
+                ,rc.column_name primary_key
+                ,cc.column_name
+                ,c.constraint_name name
+                ,c.delete_rule
+            FROM user_constraints#{db_link} c, user_cons_columns#{db_link} cc,
+                 user_constraints#{db_link} r, user_cons_columns#{db_link} rc
+           WHERE c.owner = '#{owner}'
+             AND c.table_name = '#{desc_table_name}'
+             AND c.constraint_type = 'R'
+             AND cc.owner = c.owner
+             AND cc.constraint_name = c.constraint_name
+             AND r.constraint_name = c.r_constraint_name
+             AND r.owner = c.owner
+             AND rc.owner = r.owner
+             AND rc.constraint_name = r.constraint_name
+             AND rc.position = cc.position
+        SQL
+
+        fk_info.map do |row|
+          options = {:column => oracle_downcase(row['column_name']), :name => oracle_downcase(row['name']),
+            :primary_key => oracle_downcase(row['primary_key'])}
+          case row['delete_rule']
+          when 'CASCADE'
+            options[:dependent] = :delete
+          when 'SET NULL'
+            options[:dependent] = :nullify
+          end
+          OracleEnhancedForeignKeyDefinition.new(table_name, oracle_downcase(row['to_table']), options)
+        end
+      end
+
+      # REFERENTIAL INTEGRITY ====================================
+
+      def disable_referential_integrity(&block) #:nodoc:
+        sql_constraints = <<-SQL
+        SELECT constraint_name, owner, table_name
+          FROM user_constraints
+          WHERE constraint_type = 'R'
+          AND status = 'ENABLED'
+        SQL
+        old_constraints = select_all(sql_constraints)
+        begin
+          old_constraints.each do |constraint|
+            execute "ALTER TABLE #{constraint["table_name"]} DISABLE CONSTRAINT #{constraint["constraint_name"]}"
+          end
+          yield
+        ensure
+          old_constraints.each do |constraint|
+            execute "ALTER TABLE #{constraint["table_name"]} ENABLE CONSTRAINT #{constraint["constraint_name"]}"
+          end
+        end
+      end
+
+      # Add synonym to existing table or view or sequence. Can be used to create local synonym to
+      # remote table in other schema or in other database
+      # Examples:
+      #
+      #   add_synonym :posts, "blog.posts"
+      #   add_synonym :posts_seq, "blog.posts_seq"
+      #   add_synonym :employees, "hr.employees@dblink", :force => true
+      #
+      def add_synonym(name, table_name, options = {})
+        sql = "CREATE"
+        if options[:force] == true
+          sql << " OR REPLACE"
+        end
+        sql << " SYNONYM #{quote_table_name(name)} FOR #{quote_table_name(table_name)}"
+        execute sql
+      end
+
+      # Remove existing synonym to table or view or sequence
+      # Example:
+      #
+      #   remove_synonym :posts, "blog.posts"
+      #
+      def remove_synonym(name)
+        execute "DROP SYNONYM #{quote_table_name(name)}"
+      end
+
+      # get synonyms for schema dump
+      def synonyms #:nodoc:
+        select_all("SELECT synonym_name, table_owner, table_name, db_link FROM user_synonyms").collect do |row|
+          OracleEnhancedSynonymDefinition.new(oracle_downcase(row['synonym_name']),
+            oracle_downcase(row['table_owner']), oracle_downcase(row['table_name']), oracle_downcase(row['db_link']))
+        end
+      end
+
+    end
+  end
+end
+
+ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.class_eval do
+  include ActiveRecord::ConnectionAdapters::OracleEnhancedSchemaStatementsExt
+end

data/lib/active_record/connection_adapters/oracle_enhanced_tasks.rb

@@ -0,0 +1,11 @@
+# implementation idea taken from JDBC adapter
+if defined?(Rake.application) && Rake.application && ActiveRecord::Base.configurations[RAILS_ENV]['adapter'] == 'oracle_enhanced'
+  oracle_enhanced_rakefile = File.dirname(__FILE__) + "/oracle_enhanced.rake"
+  if Rake.application.lookup("environment")
+    # rails tasks already defined; load the override tasks now
+    load oracle_enhanced_rakefile
+  else
+    # rails tasks not loaded yet; load as an import
+    Rake.application.add_import(oracle_enhanced_rakefile)
+  end
+end

data/lib/active_record/connection_adapters/oracle_enhanced_version.rb

@@ -0,0 +1 @@
+ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter::VERSION = '1.2.3'

data/spec/active_record/connection_adapters/oracle_enhanced_adapter_spec.rb

@@ -0,0 +1,477 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe "OracleEnhancedAdapter establish connection" do
+
+  it "should connect to database" do
+    ActiveRecord::Base.establish_connection(CONNECTION_PARAMS)
+    ActiveRecord::Base.connection.should_not be_nil
+    ActiveRecord::Base.connection.class.should == ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter
+  end
+
+  it "should connect to database as SYSDBA" do
+    ActiveRecord::Base.establish_connection(SYS_CONNECTION_PARAMS)
+    ActiveRecord::Base.connection.should_not be_nil
+    ActiveRecord::Base.connection.class.should == ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter
+  end
+
+  it "should be active after connection to database" do
+    ActiveRecord::Base.establish_connection(CONNECTION_PARAMS)
+    ActiveRecord::Base.connection.should be_active
+  end
+
+  it "should not be active after disconnection to database" do
+    ActiveRecord::Base.establish_connection(CONNECTION_PARAMS)
+    ActiveRecord::Base.connection.disconnect!
+    ActiveRecord::Base.connection.should_not be_active
+  end
+
+  it "should be active after reconnection to database" do
+    ActiveRecord::Base.establish_connection(CONNECTION_PARAMS)
+    ActiveRecord::Base.connection.reconnect!
+    ActiveRecord::Base.connection.should be_active
+  end
+  
+end
+
+describe "OracleEnhancedAdapter" do
+  include LoggerSpecHelper
+
+  before(:all) do
+    ActiveRecord::Base.establish_connection(CONNECTION_PARAMS)
+    @conn = ActiveRecord::Base.connection
+  end
+  
+  describe "database session store" do
+    before(:all) do
+      @conn.execute <<-SQL
+        CREATE TABLE sessions (
+          id          NUMBER(38,0) NOT NULL,
+          session_id  VARCHAR2(255) DEFAULT NULL,
+          data        CLOB DEFAULT NULL,
+          created_at  DATE DEFAULT NULL,
+          updated_at  DATE DEFAULT NULL,
+          PRIMARY KEY (ID)
+        )
+      SQL
+      @conn.execute <<-SQL
+        CREATE SEQUENCE sessions_seq  MINVALUE 1 MAXVALUE 999999999999999999999999999
+          INCREMENT BY 1 START WITH 10040 CACHE 20 NOORDER NOCYCLE
+      SQL
+      if ENV['RAILS_GEM_VERSION'] >= '2.3'
+        @session_class = ActiveRecord::SessionStore::Session
+      else
+        @session_class = CGI::Session::ActiveRecordStore::Session
+      end
+    end
+
+    after(:all) do
+      @conn.execute "DROP TABLE sessions"
+      @conn.execute "DROP SEQUENCE sessions_seq"
+    end
+
+    it "should create sessions table" do
+      ActiveRecord::Base.connection.tables.grep("sessions").should_not be_empty
+    end
+
+    it "should save session data" do
+      @session = @session_class.new :session_id => "111111", :data  => "something" #, :updated_at => Time.now
+      @session.save!
+      @session = @session_class.find_by_session_id("111111")
+      @session.data.should == "something"
+    end
+
+    it "should change session data when partial updates enabled" do
+      return pending("Not in this ActiveRecord version") unless @session_class.respond_to?(:partial_updates=)
+      @session_class.partial_updates = true
+      @session = @session_class.new :session_id => "222222", :data  => "something" #, :updated_at => Time.now
+      @session.save!
+      @session = @session_class.find_by_session_id("222222")
+      @session.data = "other thing"
+      @session.save!
+      # second save should call again blob writing callback
+      @session.save!
+      @session = @session_class.find_by_session_id("222222")
+      @session.data.should == "other thing"
+    end
+
+    it "should have one enhanced_write_lobs callback" do
+      return pending("Not in this ActiveRecord version") unless @session_class.respond_to?(:after_save_callback_chain)
+      @session_class.after_save_callback_chain.select{|cb| cb.method == :enhanced_write_lobs}.should have(1).record
+    end
+
+    it "should not set sessions table session_id column type as integer if emulate_integers_by_column_name is true" do
+      ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_integers_by_column_name = true
+      columns = @conn.columns('sessions')
+      column = columns.detect{|c| c.name == "session_id"}
+      column.type.should == :string
+    end
+
+  end
+
+  describe "ignore specified table columns" do
+    before(:all) do
+      @conn.execute <<-SQL
+        CREATE TABLE test_employees (
+          id            NUMBER,
+          first_name    VARCHAR2(20),
+          last_name     VARCHAR2(25),
+          email         VARCHAR2(25),
+          phone_number  VARCHAR2(20),
+          hire_date     DATE,
+          job_id        NUMBER,
+          salary        NUMBER,
+          commission_pct  NUMBER(2,2),
+          manager_id    NUMBER(6),
+          department_id NUMBER(4,0),
+          created_at    DATE
+        )
+      SQL
+      @conn.execute <<-SQL
+        CREATE SEQUENCE test_employees_seq  MINVALUE 1
+          INCREMENT BY 1 START WITH 1 CACHE 20 NOORDER NOCYCLE
+      SQL
+    end
+
+    after(:all) do
+      @conn.execute "DROP TABLE test_employees"
+      @conn.execute "DROP SEQUENCE test_employees_seq"
+    end
+
+    after(:each) do
+      Object.send(:remove_const, "TestEmployee")
+      ActiveRecord::Base.connection.clear_ignored_table_columns
+    end
+
+    it "should ignore specified table columns" do
+      class ::TestEmployee < ActiveRecord::Base
+        ignore_table_columns  :phone_number, :hire_date
+      end
+      TestEmployee.connection.columns('test_employees').select{|c| ['phone_number','hire_date'].include?(c.name) }.should be_empty
+    end
+
+    it "should ignore specified table columns specified in several lines" do
+      class ::TestEmployee < ActiveRecord::Base
+        ignore_table_columns  :phone_number
+        ignore_table_columns  :hire_date
+      end
+      TestEmployee.connection.columns('test_employees').select{|c| ['phone_number','hire_date'].include?(c.name) }.should be_empty
+    end
+
+    it "should not ignore unspecified table columns" do
+      class ::TestEmployee < ActiveRecord::Base
+        ignore_table_columns  :phone_number, :hire_date
+      end
+      TestEmployee.connection.columns('test_employees').select{|c| c.name == 'email' }.should_not be_empty
+    end
+
+    it "should ignore specified table columns in other connection" do
+      class ::TestEmployee < ActiveRecord::Base
+        ignore_table_columns  :phone_number, :hire_date
+      end
+      # establish other connection
+      other_conn = ActiveRecord::Base.oracle_enhanced_connection(CONNECTION_PARAMS)
+      other_conn.columns('test_employees').select{|c| ['phone_number','hire_date'].include?(c.name) }.should be_empty
+    end
+
+  end
+
+  describe "cache table columns" do
+    before(:all) do
+      @conn.execute "DROP TABLE test_employees" rescue nil
+      @conn.execute <<-SQL
+        CREATE TABLE test_employees (
+          id            NUMBER,
+          first_name    VARCHAR2(20),
+          last_name     VARCHAR2(25),
+          hire_date     DATE
+        )
+      SQL
+      @column_names = ['id', 'first_name', 'last_name', 'hire_date']
+      class ::TestEmployee < ActiveRecord::Base
+      end
+    end
+
+    after(:all) do
+      Object.send(:remove_const, "TestEmployee")
+      @conn.execute "DROP TABLE test_employees"
+      ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.cache_columns = nil
+    end
+
+    before(:each) do
+      @buffer = StringIO.new
+      log_to @buffer
+      @conn = ActiveRecord::Base.connection
+      @conn.clear_columns_cache
+    end
+
+    describe "without column caching" do
+
+      before(:each) do
+        ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.cache_columns = false
+      end
+
+      it "should get columns from database at first time" do
+        TestEmployee.connection.columns('test_employees').map(&:name).should == @column_names
+        @buffer.string.should =~ /select .* from all_tab_columns/im
+      end
+
+      it "should get columns from database at second time" do
+        TestEmployee.connection.columns('test_employees')
+        @buffer.truncate(0)
+        TestEmployee.connection.columns('test_employees').map(&:name).should == @column_names
+        @buffer.string.should =~ /select .* from all_tab_columns/im
+      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
+        TestEmployee.connection.columns('test_employees').map(&:name).should == @column_names
+        @buffer.string.should =~ /select .* from all_tab_columns/im
+      end
+
+      it "should get columns from cache at second time" do
+        TestEmployee.connection.columns('test_employees')
+        @buffer.truncate(0)
+        TestEmployee.connection.columns('test_employees').map(&:name).should == @column_names
+        @buffer.string.should be_blank
+      end
+
+    end
+
+  end
+
+  describe "without composite_primary_keys" do
+
+    before(:all) do
+      @conn.execute "DROP TABLE test_employees" rescue nil
+      @conn.execute <<-SQL
+        CREATE TABLE test_employees (
+          employee_id   NUMBER PRIMARY KEY,
+          name          VARCHAR2(50)
+        )
+      SQL
+      Object.send(:remove_const, 'CompositePrimaryKeys') if defined?(CompositePrimaryKeys)
+      class ::TestEmployee < ActiveRecord::Base
+        set_primary_key :employee_id
+      end
+    end
+
+    after(:all) do
+      Object.send(:remove_const, "TestEmployee")
+      @conn.execute "DROP TABLE test_employees"
+    end
+
+    it "should tell ActiveRecord that count distinct is supported" do
+      ActiveRecord::Base.connection.supports_count_distinct?.should be_true
+    end
+
+    it "should execute correct SQL COUNT DISTINCT statement" do
+      lambda { TestEmployee.count(:employee_id, :distinct => true) }.should_not raise_error
+    end
+
+  end
+
+
+  describe "column quoting" do
+
+    def create_test_reserved_words_table
+      ActiveRecord::Schema.define do
+        suppress_messages do
+          create_table :test_reserved_words do |t|
+            t.string      :varchar2
+            t.integer     :integer
+          end
+        end
+      end
+    end
+
+    after(:each) do
+      ActiveRecord::Schema.define do
+        suppress_messages do
+          drop_table :test_reserved_words
+        end
+      end
+      Object.send(:remove_const, "TestReservedWord")
+      ActiveRecord::Base.table_name_prefix = nil
+    end
+
+    it "should allow creation of a table with oracle reserved words as column names" do
+      create_test_reserved_words_table
+      class ::TestReservedWord < ActiveRecord::Base; end
+
+      [:varchar2, :integer].each do |attr|
+        TestReservedWord.columns_hash[attr.to_s].name.should == attr.to_s
+      end
+    end
+
+  end
+
+  describe "valid table names" do
+    before(:all) do
+      @adapter = ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter
+    end
+
+    it "should be valid with letters and digits" do
+      @adapter.valid_table_name?("abc_123").should be_true
+    end
+
+    it "should be valid with schema name" do
+      @adapter.valid_table_name?("abc_123.def_456").should be_true
+    end
+
+    it "should be valid with $ in name" do
+      @adapter.valid_table_name?("sys.v$session").should be_true
+    end
+
+    it "should not be valid with two dots in name" do
+      @adapter.valid_table_name?("abc_123.def_456.ghi_789").should be_false
+    end
+
+    it "should not be valid with invalid characters" do
+      @adapter.valid_table_name?("warehouse-things").should be_false
+    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
+
+    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
+        set_table_name "warehouse-things"
+      end
+
+      wh = WarehouseThing.create!(:name => "Foo", :foo => 2)
+      wh.id.should_not be_nil
+
+      @conn.tables.should include("warehouse-things")
+    end
+
+    it "should allow creation of a table with CamelCase name" do
+      create_camel_case_table
+      class ::CamelCase < ActiveRecord::Base
+        set_table_name "CamelCase"
+      end
+
+      cc = CamelCase.create!(:name => "Foo", :foo => 2)
+      cc.id.should_not be_nil
+    
+      @conn.tables.should include("CamelCase")
+    end
+
+  end
+
+  describe "access table over database link" do
+    before(:all) do
+      @db_link = "db_link"
+      @sys_conn = ActiveRecord::Base.oracle_enhanced_connection(SYSTEM_CONNECTION_PARAMS)
+      @sys_conn.drop_table :test_posts rescue nil
+      @sys_conn.create_table :test_posts do |t|
+        t.string      :title
+        # cannot update LOBs over database link
+        t.string      :body
+        t.timestamps
+      end
+      @db_link_username = SYSTEM_CONNECTION_PARAMS[:username]
+      @db_link_password = SYSTEM_CONNECTION_PARAMS[:password]
+      @db_link_database = SYSTEM_CONNECTION_PARAMS[:database]
+      @conn.execute "DROP DATABASE LINK #{@db_link}" rescue nil
+      @conn.execute "CREATE DATABASE LINK #{@db_link} CONNECT TO #{@db_link_username} IDENTIFIED BY #{@db_link_password} USING '#{@db_link_database}'"
+      @conn.execute "CREATE OR REPLACE SYNONYM test_posts FOR test_posts@#{@db_link}"
+      @conn.execute "CREATE OR REPLACE SYNONYM test_posts_seq FOR test_posts_seq@#{@db_link}"
+      class ::TestPost < ActiveRecord::Base
+      end
+      TestPost.set_table_name "test_posts"
+    end
+
+    after(:all) 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
+      Object.send(:remove_const, "TestPost") rescue nil
+    end
+
+    it "should verify database link" do
+      @conn.select_value("select * from dual@#{@db_link}") == 'X'
+    end
+
+    it "should get column names" do
+      TestPost.column_names.should == ["id", "title", "body", "created_at", "updated_at"]
+    end
+
+    it "should create record" do
+      p = TestPost.create(:title => "Title", :body => "Body")
+      p.id.should_not be_nil
+      TestPost.find(p.id).should_not be_nil
+    end
+
+  end
+
+  describe "session information" do
+    it "should get current database name" do
+      @conn.current_database.should == CONNECTION_PARAMS[:database]
+    end
+
+    it "should get current database session user" do
+      @conn.current_user.should == CONNECTION_PARAMS[:username].upcase
+    end
+  end
+
+  describe "temporary tables" do
+    
+    after(:each) do
+      @conn.drop_table :foos rescue nil
+    end
+    it "should create ok" do
+      @conn.create_table :foos, :temporary => true, :id => false do |t|
+        t.integer :id
+      end
+    end
+    it "should show up as temporary" do
+      @conn.create_table :foos, :temporary => true, :id => false do |t|
+        t.integer :id
+      end
+      @conn.temporary_table?("foos").should be_true
+    end
+  end
+end