activerecord-oracle_enhanced-adapter 1.3.1 → 1.3.2

data/lib/active_record/connection_adapters/oracle_enhanced_procedures.rb

@@ -1,7 +1,11 @@
 # define accessors before requiring ruby-plsql as these accessors are used in clob writing callback and should be
 # available also if ruby-plsql could not be loaded
 ActiveRecord::Base.class_eval do
-  class_inheritable_accessor :custom_create_method, :custom_update_method, :custom_delete_method
+  if respond_to? :class_inheritable_accessor
+    class_inheritable_accessor :custom_create_method, :custom_update_method, :custom_delete_method
+  elsif respond_to? :class_attribute
+    class_attribute :custom_create_method, :custom_update_method, :custom_delete_method
+  end
 end
 
 require 'active_support'
@@ -153,6 +157,8 @@ module ActiveRecord #:nodoc:
             self.id = instance_eval(&self.class.custom_create_method)
           end
           @new_record = false
+          # Starting from ActiveRecord 3.0.3 @persisted is used instead of @new_record
+          @persisted = true
           id
         end
 

data/lib/active_record/connection_adapters/oracle_enhanced_schema_dumper.rb

@@ -35,9 +35,14 @@ module ActiveRecord #:nodoc:
           oracle_enhanced_table(tbl, stream)
           # add primary key trigger if table has it
           primary_key_trigger(tbl, stream)
-          # add foreign keys if table has them
+        end
+        # following table definitions
+        # add foreign keys if table has them
+        sorted_tables.each do |tbl|
+          next if ignore_table? tbl
           foreign_keys(tbl, stream)
         end
+
         # add synonyms in local schema
         synonyms(stream)
       end

data/lib/active_record/connection_adapters/oracle_enhanced_schema_statements.rb

@@ -112,19 +112,17 @@ module ActiveRecord
 
         if Hash === options # legacy support, since this param was a string
           index_type = options[:unique] ? "UNIQUE" : ""
-          index_name = options[:name] || index_name
+          index_name = options[:name].to_s if options.key?(:name)
           tablespace = options[:tablespace] ? " TABLESPACE #{options[:tablespace]}" : ""
         else
           index_type = options
         end
 
         if index_name.to_s.length > index_name_length
-          @logger.warn("Index name '#{index_name}' on table '#{table_name}' is too long; the limit is #{index_name_length} characters. Skipping.") if @logger
-          return
+          raise ArgumentError, "Index name '#{index_name}' on table '#{table_name}' is too long; the limit is #{index_name_length} characters"
         end
         if index_name_exists?(table_name, index_name, false)
-          @logger.warn("Index name '#{index_name}' on table '#{table_name}' already exists. Skipping.") if @logger
-          return
+          raise ArgumentError, "Index name '#{index_name}' on table '#{table_name}' already exists"
         end
         quoted_column_names = column_names.map { |e| quote_column_name(e) }.join(", ")
 
@@ -138,8 +136,7 @@ module ActiveRecord
       def remove_index(table_name, options = {}) #:nodoc:
         index_name = index_name(table_name, options)
         unless index_name_exists?(table_name, index_name, true)
-          @logger.warn("Index name '#{index_name}' on table '#{table_name}' does not exist. Skipping.") if @logger
-          return
+          raise ArgumentError, "Index name '#{index_name}' on table '#{table_name}' does not exist"
         end
         remove_index!(table_name, index_name)
       end
@@ -153,7 +150,7 @@ module ActiveRecord
 
       # returned shortened index name if default is too large
       def index_name(table_name, options) #:nodoc:
-        default_name = super(table_name, options)
+        default_name = super(table_name, options).to_s
         # sometimes options can be String or Array with column names
         options = {} unless options.is_a?(Hash)
         identifier_max_length = options[:identifier_max_length] || index_name_length
@@ -189,7 +186,7 @@ module ActiveRecord
              AND i.table_name = '#{table_name}'
              AND i.index_name = '#{index_name.to_s.upcase}'
         SQL
-        result == 1 ? true : false
+        result == 1
       end
 
       def add_column(table_name, column_name, type, options = {}) #:nodoc:

data/spec/active_record/connection_adapters/oracle_enhanced_adapter_spec.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+require 'spec_helper'
 
 describe "OracleEnhancedAdapter establish connection" do
 
@@ -39,11 +39,11 @@ describe "OracleEnhancedAdapter" do
 
   before(:all) do
     ActiveRecord::Base.establish_connection(CONNECTION_PARAMS)
-    @conn = ActiveRecord::Base.connection
   end
   
   describe "database session store" do
     before(:all) do
+      @conn = ActiveRecord::Base.connection
       @conn.execute <<-SQL
         CREATE TABLE sessions (
           id          NUMBER(38,0) NOT NULL,
@@ -111,6 +111,7 @@ describe "OracleEnhancedAdapter" do
 
   describe "ignore specified table columns" do
     before(:all) do
+      @conn = ActiveRecord::Base.connection
       @conn.execute <<-SQL
         CREATE TABLE test_employees (
           id            NUMBER PRIMARY KEY,
@@ -178,6 +179,7 @@ describe "OracleEnhancedAdapter" do
 
   describe "cache table columns" do
     before(:all) do
+      @conn = ActiveRecord::Base.connection
       @conn.execute "DROP TABLE test_employees" rescue nil
       @conn.execute <<-SQL
         CREATE TABLE test_employees (
@@ -198,6 +200,7 @@ describe "OracleEnhancedAdapter" do
     end
 
     after(:all) do
+      @conn = ActiveRecord::Base.connection
       Object.send(:remove_const, "TestEmployee")
       Object.send(:remove_const, "TestEmployee2")
       @conn.execute "DROP TABLE test_employees"
@@ -290,6 +293,7 @@ describe "OracleEnhancedAdapter" do
   describe "without composite_primary_keys" do
 
     before(:all) do
+      @conn = ActiveRecord::Base.connection
       @conn.execute "DROP TABLE test_employees" rescue nil
       @conn.execute <<-SQL
         CREATE TABLE test_employees (
@@ -452,6 +456,10 @@ describe "OracleEnhancedAdapter" do
       end
     end
 
+    before(:all) do
+      @conn = ActiveRecord::Base.connection
+    end
+
     after(:each) do
       ActiveRecord::Schema.define do
         suppress_messages do
@@ -491,6 +499,7 @@ describe "OracleEnhancedAdapter" do
 
   describe "access table over database link" do
     before(:all) 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
@@ -537,6 +546,10 @@ describe "OracleEnhancedAdapter" do
   end
 
   describe "session information" do
+    before(:all) do
+      @conn = ActiveRecord::Base.connection
+    end
+
     it "should get current database name" do
       # get database name if using //host:port/database connection string
       database_name = CONNECTION_PARAMS[:database].split('/').last
@@ -549,7 +562,10 @@ describe "OracleEnhancedAdapter" do
   end
 
   describe "temporary tables" do
-    
+    before(:all) do
+      @conn = ActiveRecord::Base.connection
+    end
+
     after(:each) do
       @conn.drop_table :foos rescue nil
     end
@@ -565,4 +581,48 @@ describe "OracleEnhancedAdapter" do
       @conn.temporary_table?("foos").should be_true
     end
   end
+
+  describe "eager loading" do
+    before(:all) do
+      schema_define do
+        create_table :test_posts do |t|
+          t.string      :title
+        end
+        create_table :test_comments do |t|
+          t.integer     :test_post_id
+          t.string      :description
+        end
+        add_index :test_comments, :test_post_id
+      end
+      class ::TestPost < ActiveRecord::Base
+        has_many :test_comments
+      end
+      class ::TestComment < ActiveRecord::Base
+        belongs_to :test_post
+      end
+      @ids = (1..1010).to_a
+      TestPost.transaction do
+        @ids.each do |id|
+          TestPost.create!(:id => id, :title => "Title #{id}")
+          TestComment.create!(:test_post_id => id, :description => "Description #{id}")
+        end
+      end
+    end
+
+    after(:all) do
+      schema_define do
+        drop_table :test_comments
+        drop_table :test_posts
+      end
+      Object.send(:remove_const, "TestPost")
+      Object.send(:remove_const, "TestComment")
+    end
+
+    it "should load included association with more than 1000 records" do
+      posts = TestPost.includes(:test_comments).all
+      posts.size.should == @ids.size
+    end
+
+  end if ENV['RAILS_GEM_VERSION'] >= '3.1'
+
 end

data/spec/active_record/connection_adapters/oracle_enhanced_connection_spec.rb

@@ -1,206 +1,287 @@
-require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+require 'spec_helper'
 
-describe "OracleEnhancedConnection create connection" do
+describe "OracleEnhancedConnection" do
 
-  before(:all) do
-    @conn = ActiveRecord::ConnectionAdapters::OracleEnhancedConnection.create(CONNECTION_PARAMS)
-  end
-  
-  before(:each) do
-    @conn = ActiveRecord::ConnectionAdapters::OracleEnhancedConnection.create(CONNECTION_PARAMS) unless @conn.active?
-  end
+  describe "create connection" do
+    before(:all) do
+      @conn = ActiveRecord::ConnectionAdapters::OracleEnhancedConnection.create(CONNECTION_PARAMS)
+    end
 
-  after(:all) do
-    @conn.logoff if @conn.active?
-  end
+    before(:each) do
+      @conn = ActiveRecord::ConnectionAdapters::OracleEnhancedConnection.create(CONNECTION_PARAMS) unless @conn.active?
+    end
 
-  it "should create new connection" do
-    @conn.should be_active
-  end
+    it "should create new connection" do
+      @conn.should be_active
+    end
 
-  it "should ping active connection" do
-    @conn.ping.should be_true
-  end
+    it "should ping active connection" do
+      @conn.ping.should be_true
+    end
 
-  it "should not ping inactive connection" do
-    @conn.logoff
-    lambda { @conn.ping }.should raise_error(ActiveRecord::ConnectionAdapters::OracleEnhancedConnectionException)
-  end
+    it "should not ping inactive connection" do
+      @conn.logoff
+      lambda { @conn.ping }.should raise_error(ActiveRecord::ConnectionAdapters::OracleEnhancedConnectionException)
+    end
 
-  it "should reset active connection" do
-    @conn.reset!
-    @conn.should be_active
-  end
+    it "should reset active connection" do
+      @conn.reset!
+      @conn.should be_active
+    end
+
+    it "should be in autocommit mode after connection" do
+      @conn.should be_autocommit
+    end
 
-  it "should be in autocommit mode after connection" do
-    @conn.should be_autocommit
   end
 
-end
+  describe "create connection with NLS parameters" do
+    after do
+      ENV['NLS_DATE_FORMAT'] = nil
+    end
 
-if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
+    it "should use NLS_DATE_FORMAT environment variable" do
+      ENV['NLS_DATE_FORMAT'] = 'YYYY-MM-DD'
+      @conn = ActiveRecord::ConnectionAdapters::OracleEnhancedConnection.create(CONNECTION_PARAMS)
+      @conn.select("SELECT value FROM v$nls_parameters WHERE parameter = 'NLS_DATE_FORMAT'").should == [{'value' => 'YYYY-MM-DD'}]
+    end
 
-  describe "OracleEnhancedConnection create JDBC connection" do
-    after(:each) do
-      @conn.logoff if @conn.active?
+    it "should use configuration value and ignore NLS_DATE_FORMAT environment variable" do
+      ENV['NLS_DATE_FORMAT'] = 'YYYY-MM-DD'
+      @conn = ActiveRecord::ConnectionAdapters::OracleEnhancedConnection.create(CONNECTION_PARAMS.merge(:nls_date_format => 'YYYY-MM-DD HH24:MI'))
+      @conn.select("SELECT value FROM v$nls_parameters WHERE parameter = 'NLS_DATE_FORMAT'").should == [{'value' => 'YYYY-MM-DD HH24:MI'}]
     end
 
-    it "should create new connection using :url" do
-      params = CONNECTION_PARAMS.dup
-      params[:url] = "jdbc:oracle:thin:@#{DATABASE_HOST && "#{DATABASE_HOST}:"}#{DATABASE_PORT && "#{DATABASE_PORT}:"}#{DATABASE_NAME}"
-      params[:host] = nil
-      params[:database] = nil
-      @conn = ActiveRecord::ConnectionAdapters::OracleEnhancedConnection.create(params)
-      @conn.should be_active
+    it "should use default value when NLS_DATE_FORMAT environment variable is not set" do
+      ENV['NLS_DATE_FORMAT'] = nil
+      @conn = ActiveRecord::ConnectionAdapters::OracleEnhancedConnection.create(CONNECTION_PARAMS)
+      default = ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter::DEFAULT_NLS_PARAMETERS[:nls_date_format]
+      @conn.select("SELECT value FROM v$nls_parameters WHERE parameter = 'NLS_DATE_FORMAT'").should == [{'value' => default}]
     end
+  end
 
-    it "should create new connection using :url and tnsnames alias" do
+  describe "with non-string parameters" do
+    before(:all) do
       params = CONNECTION_PARAMS.dup
-      params[:url] = "jdbc:oracle:thin:@#{DATABASE_NAME}"
-      params[:host] = nil
-      params[:database] = nil
+      params[:username] = params[:username].to_sym
+      params[:password] = params[:password].to_sym
+      params[:database] = params[:database].to_sym
       @conn = ActiveRecord::ConnectionAdapters::OracleEnhancedConnection.create(params)
-      @conn.should be_active
     end
 
-    it "should create new connection using just tnsnames alias" do
-      params = CONNECTION_PARAMS.dup
-      params[:host] = nil
-      @conn = ActiveRecord::ConnectionAdapters::OracleEnhancedConnection.create(params)
+    it "should create new connection" do
       @conn.should be_active
     end
-
   end
 
-end
+  if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
+
+    describe "create JDBC connection" do
+
+      it "should create new connection using :url" do
+        params = CONNECTION_PARAMS.dup
+        params[:url] = "jdbc:oracle:thin:@#{DATABASE_HOST && "#{DATABASE_HOST}:"}#{DATABASE_PORT && "#{DATABASE_PORT}:"}#{DATABASE_NAME}"
+        params[:host] = nil
+        params[:database] = nil
+        @conn = ActiveRecord::ConnectionAdapters::OracleEnhancedConnection.create(params)
+        @conn.should be_active
+      end
+
+      it "should create new connection using :url and tnsnames alias" do
+        params = CONNECTION_PARAMS.dup
+        params[:url] = "jdbc:oracle:thin:@#{DATABASE_NAME}"
+        params[:host] = nil
+        params[:database] = nil
+        @conn = ActiveRecord::ConnectionAdapters::OracleEnhancedConnection.create(params)
+        @conn.should be_active
+      end
+
+      it "should create new connection using just tnsnames alias" do
+        params = CONNECTION_PARAMS.dup
+        params[:host] = nil
+        @conn = ActiveRecord::ConnectionAdapters::OracleEnhancedConnection.create(params)
+        @conn.should be_active
+      end
+
+      it "should create a new connection using JNDI" do
+
+        begin
+          import 'oracle.jdbc.driver.OracleDriver'
+          import 'org.apache.commons.pool.impl.GenericObjectPool'
+          import 'org.apache.commons.dbcp.PoolingDataSource'
+          import 'org.apache.commons.dbcp.PoolableConnectionFactory'
+          import 'org.apache.commons.dbcp.DriverManagerConnectionFactory'
+        rescue NameError => e
+          return pending e.message
+        end
+
+        class InitialContextMock
+          def initialize
+            connection_pool = GenericObjectPool.new(nil)
+            uri = "jdbc:oracle:thin:@#{DATABASE_HOST && "#{DATABASE_HOST}:"}#{DATABASE_PORT && "#{DATABASE_PORT}:"}#{DATABASE_NAME}"
+            connection_factory = DriverManagerConnectionFactory.new(uri, DATABASE_USER, DATABASE_PASSWORD)
+            poolable_connection_factory = PoolableConnectionFactory.new(connection_factory,connection_pool,nil,nil,false,true)
+            @data_source = PoolingDataSource.new(connection_pool)
+            @data_source.access_to_underlying_connection_allowed = true
+          end
+          def lookup(path)
+            if (path == 'java:/comp/env')
+              return self
+            else
+              return @data_source
+            end
+          end
+        end
+
+        javax.naming.InitialContext.stub!(:new).and_return(InitialContextMock.new)
+
+        params = {}
+        params[:jndi] = 'java:comp/env/jdbc/test'
+        @conn = ActiveRecord::ConnectionAdapters::OracleEnhancedConnection.create(params)
+        @conn.should be_active
+      end
 
-describe "OracleEnhancedConnection SQL execution" do
+    end
 
-  before(:all) do
-    @conn = ActiveRecord::ConnectionAdapters::OracleEnhancedConnection.create(CONNECTION_PARAMS)
-  end
-  
-  before(:each) do
-    @conn = ActiveRecord::ConnectionAdapters::OracleEnhancedConnection.create(CONNECTION_PARAMS) unless @conn.active?
   end
 
-  after(:all) do
-    @conn.logoff if @conn.active?
-  end
+  describe "SQL execution" do
+    before(:all) do
+      @conn = ActiveRecord::ConnectionAdapters::OracleEnhancedConnection.create(CONNECTION_PARAMS)
+    end
 
-  it "should execute SQL statement" do
-    @conn.exec("SELECT * FROM dual").should_not be_nil
-  end
+    it "should execute SQL statement" do
+      @conn.exec("SELECT * FROM dual").should_not be_nil
+    end
 
-  it "should execute SQL select" do
-    @conn.select("SELECT * FROM dual").should == [{'dummy' => 'X'}]
-  end
+    it "should execute SQL select" do
+      @conn.select("SELECT * FROM dual").should == [{'dummy' => 'X'}]
+    end
+
+    it "should execute SQL select and return also columns" do
+      @conn.select("SELECT * FROM dual", nil, true).should == [ [{'dummy' => 'X'}], ['dummy'] ]
+    end
 
-  it "should execute SQL select and return also columns" do
-    @conn.select("SELECT * FROM dual", nil, true).should == [ [{'dummy' => 'X'}], ['dummy'] ]
   end
 
-end
+  describe "SQL with bind parameters" do
+    before(:all) do
+      @conn = ActiveRecord::ConnectionAdapters::OracleEnhancedConnection.create(CONNECTION_PARAMS)
+    end
 
-describe "OracleEnhancedConnection auto reconnection" do
+    it "should execute SQL statement with bind parameter" do
+      cursor = @conn.prepare("SELECT * FROM dual WHERE :1 = 1")
+      cursor.bind_param(1, 1)
+      cursor.exec
+      cursor.get_col_names.should == ['DUMMY']
+      cursor.fetch.should == ["X"]
+      cursor.close
+    end
 
-  before(:all) do
-    ActiveRecord::Base.establish_connection(CONNECTION_PARAMS)
-    @conn = ActiveRecord::Base.connection.instance_variable_get("@connection")
-    @sys_conn = ActiveRecord::ConnectionAdapters::OracleEnhancedConnection.create(SYS_CONNECTION_PARAMS)
-  end
-  
-  before(:each) do
-    ActiveRecord::Base.connection.reconnect! unless @conn.active?
-  end
+    it "should execute prepared statement with different bind parameters" do
+      cursor = @conn.prepare("SELECT * FROM dual WHERE :1 = 1")
+      cursor.bind_param(1, 1)
+      cursor.exec
+      cursor.fetch.should == ["X"]
+      cursor.bind_param(1, 0)
+      cursor.exec
+      cursor.fetch.should be_nil
+      cursor.close
+    end
 
-  after(:all) do
-    ActiveRecord::Base.connection.disconnect! if @conn.active?
   end
 
-  def kill_current_session
-    audsid = @conn.select("SELECT userenv('sessionid') audsid FROM dual").first['audsid']
-    sid_serial = @sys_conn.select("SELECT s.sid||','||s.serial# sid_serial
-        FROM   v$session s
-        WHERE  audsid = '#{audsid}'").first['sid_serial']
-    @sys_conn.exec "ALTER SYSTEM KILL SESSION '#{sid_serial}' IMMEDIATE"
-  end
+  describe "auto reconnection" do
+    before(:all) do
+      ActiveRecord::Base.establish_connection(CONNECTION_PARAMS)
+      @conn = ActiveRecord::Base.connection.instance_variable_get("@connection")
+      @sys_conn = ActiveRecord::ConnectionAdapters::OracleEnhancedConnection.create(SYS_CONNECTION_PARAMS)
+    end
 
-  it "should reconnect and execute SQL statement if connection is lost and auto retry is enabled" do
-    # @conn.auto_retry = true
-    ActiveRecord::Base.connection.auto_retry = true
-    kill_current_session
-    @conn.exec("SELECT * FROM dual").should_not be_nil
-  end
+    before(:each) do
+      ActiveRecord::Base.connection.reconnect! unless @conn.active?
+    end
 
-  it "should not reconnect and execute SQL statement if connection is lost and auto retry is disabled" do
-    # @conn.auto_retry = false
-    ActiveRecord::Base.connection.auto_retry = false
-    kill_current_session
-    lambda { @conn.exec("SELECT * FROM dual") }.should raise_error
-  end
+    def kill_current_session
+      audsid = @conn.select("SELECT userenv('sessionid') audsid FROM dual").first['audsid']
+      sid_serial = @sys_conn.select("SELECT s.sid||','||s.serial# sid_serial
+          FROM   v$session s
+          WHERE  audsid = '#{audsid}'").first['sid_serial']
+      @sys_conn.exec "ALTER SYSTEM KILL SESSION '#{sid_serial}' IMMEDIATE"
+    end
 
-  it "should reconnect and execute SQL select if connection is lost and auto retry is enabled" do
-    # @conn.auto_retry = true
-    ActiveRecord::Base.connection.auto_retry = true
-    kill_current_session
-    @conn.select("SELECT * FROM dual").should == [{'dummy' => 'X'}]
-  end
+    it "should reconnect and execute SQL statement if connection is lost and auto retry is enabled" do
+      # @conn.auto_retry = true
+      ActiveRecord::Base.connection.auto_retry = true
+      kill_current_session
+      @conn.exec("SELECT * FROM dual").should_not be_nil
+    end
 
-  it "should not reconnect and execute SQL select if connection is lost and auto retry is disabled" do
-    # @conn.auto_retry = false
-    ActiveRecord::Base.connection.auto_retry = false
-    kill_current_session
-    lambda { @conn.select("SELECT * FROM dual") }.should raise_error
-  end
+    it "should not reconnect and execute SQL statement if connection is lost and auto retry is disabled" do
+      # @conn.auto_retry = false
+      ActiveRecord::Base.connection.auto_retry = false
+      kill_current_session
+      lambda { @conn.exec("SELECT * FROM dual") }.should raise_error
+    end
 
-end
+    it "should reconnect and execute SQL select if connection is lost and auto retry is enabled" do
+      # @conn.auto_retry = true
+      ActiveRecord::Base.connection.auto_retry = true
+      kill_current_session
+      @conn.select("SELECT * FROM dual").should == [{'dummy' => 'X'}]
+    end
 
-describe "OracleEnhancedConnection describe table" do
+    it "should not reconnect and execute SQL select if connection is lost and auto retry is disabled" do
+      # @conn.auto_retry = false
+      ActiveRecord::Base.connection.auto_retry = false
+      kill_current_session
+      lambda { @conn.select("SELECT * FROM dual") }.should raise_error
+    end
 
-  before(:all) do
-    @conn = ActiveRecord::ConnectionAdapters::OracleEnhancedConnection.create(CONNECTION_PARAMS)
-    @owner = CONNECTION_PARAMS[:username].upcase
-  end
-  
-  after(:all) do
-    @conn.logoff if @conn.active?
   end
 
-  it "should describe existing table" do
-    @conn.exec "CREATE TABLE test_employees (first_name VARCHAR2(20))" rescue nil
-    @conn.describe("test_employees").should == [@owner, "TEST_EMPLOYEES"]
-    @conn.exec "DROP TABLE test_employees" rescue nil
-  end
+  describe "describe table" do
+    before(:all) do
+      @conn = ActiveRecord::ConnectionAdapters::OracleEnhancedConnection.create(CONNECTION_PARAMS)
+      @owner = CONNECTION_PARAMS[:username].upcase
+    end
 
-  it "should not describe non-existing table" do
-    lambda { @conn.describe("test_xxx") }.should raise_error(ActiveRecord::ConnectionAdapters::OracleEnhancedConnectionException)
-  end
+    it "should describe existing table" do
+      @conn.exec "CREATE TABLE test_employees (first_name VARCHAR2(20))" rescue nil
+      @conn.describe("test_employees").should == [@owner, "TEST_EMPLOYEES"]
+      @conn.exec "DROP TABLE test_employees" rescue nil
+    end
 
-  it "should describe table in other schema" do
-    @conn.describe("sys.dual").should == ["SYS", "DUAL"]
-  end
+    it "should not describe non-existing table" do
+      lambda { @conn.describe("test_xxx") }.should raise_error(ActiveRecord::ConnectionAdapters::OracleEnhancedConnectionException)
+    end
 
-  it "should describe existing view" do
-    @conn.exec "CREATE TABLE test_employees (first_name VARCHAR2(20))" rescue nil
-    @conn.exec "CREATE VIEW test_employees_v AS SELECT * FROM test_employees" rescue nil
-    @conn.describe("test_employees_v").should == [@owner, "TEST_EMPLOYEES_V"]
-    @conn.exec "DROP VIEW test_employees_v" rescue nil
-    @conn.exec "DROP TABLE test_employees" rescue nil
-  end
+    it "should describe table in other schema" do
+      @conn.describe("sys.dual").should == ["SYS", "DUAL"]
+    end
 
-  it "should describe view in other schema" do
-    @conn.describe("sys.v_$version").should == ["SYS", "V_$VERSION"]
-  end
+    it "should describe existing view" do
+      @conn.exec "CREATE TABLE test_employees (first_name VARCHAR2(20))" rescue nil
+      @conn.exec "CREATE VIEW test_employees_v AS SELECT * FROM test_employees" rescue nil
+      @conn.describe("test_employees_v").should == [@owner, "TEST_EMPLOYEES_V"]
+      @conn.exec "DROP VIEW test_employees_v" rescue nil
+      @conn.exec "DROP TABLE test_employees" rescue nil
+    end
 
-  it "should describe existing private synonym" do
-    @conn.exec "CREATE SYNONYM test_dual FOR sys.dual" rescue nil
-    @conn.describe("test_dual").should == ["SYS", "DUAL"]
-    @conn.exec "DROP SYNONYM test_dual" rescue nil
-  end
+    it "should describe view in other schema" do
+      @conn.describe("sys.v_$version").should == ["SYS", "V_$VERSION"]
+    end
+
+    it "should describe existing private synonym" do
+      @conn.exec "CREATE SYNONYM test_dual FOR sys.dual" rescue nil
+      @conn.describe("test_dual").should == ["SYS", "DUAL"]
+      @conn.exec "DROP SYNONYM test_dual" rescue nil
+    end
+
+    it "should describe existing public synonym" do
+      @conn.describe("all_tables").should == ["SYS", "ALL_TABLES"]
+    end
 
-  it "should describe existing public synonym" do
-    @conn.describe("all_tables").should == ["SYS", "ALL_TABLES"]
   end
 
-end
+end