activerecord-oracle_enhanced-adapter 1.1.8 → 1.1.9

data/History.txt

@@ -1,3 +1,13 @@
+== 1.1.9 2009-01-02
+
+* Enhancements
+  * Added support for table and column comments in migrations
+  * Added support for specifying sequence start values
+  * Added :privilege option (e.g. :SYSDBA) to ActiveRecord::Base.establish_connection
+* Bug fixes:
+  * Do not mark empty decimals, strings and texts (stored as NULL in database) as changed when reassigning them (starting from Rails 2.1)
+  * Create booleans as VARCHAR2(1) columns if emulate_booleans_from_strings is true
+
 == 1.1.8 2008-10-10
 
 * Bug fixes:

data/README.txt

@@ -7,78 +7,19 @@
 Oracle "enhanced" ActiveRecord adapter contains useful additional methods for working with new and legacy Oracle databases
 from Rails which are extracted from current real projects' monkey patches of original Oracle adapter.
 
-See http://blog.rayapps.com/category/oracle-enhanced for more information.
+See http://github.com/rsim/oracle-enhanced/wikis for more information.
 
-Look ar RSpec tests under spec directory for usage examples.
+For questions and feature discussion please use http://groups.google.com/group/oracle-enhanced
 
-== FEATURES/PROBLEMS:
+Blog posts about oracle-enahnced can be found at http://blog.rayapps.com/category/oracle-enhanced
 
-
-== SYNOPSIS:
-
-In Rails config/database.yml file use oracle_enhanced as adapter name.
-
-Create config/initializers/oracle_advanced.rb file in your Rails application and put configuration options there.
-The following configuration options are available:
-
-* set to true if columns with DATE in their name should be emulated as Date (and not as Time which is default)
-ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = true
-
-* set to true if columns with ID at the end of column name should be emulated as Fixnum (and not as BigDecimal which is default)
-ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_integers_by_column_name = true
-
-* set to true if CHAR(1), VARCHAR2(1) columns or VARCHAR2 columns with FLAG or YN at the end of their name
-  should be emulated as booleans (and do not use NUMBER(1) as type for booleans which is default)
-ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans_from_strings = true
-
-* specify other date and time formats that should be used when assigning string values to :date and :datetime columns, e.g.:
-ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.string_to_date_format = "%d.%m.%Y"
-ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.string_to_time_format = "%d.%m.%Y %H:%M:%S"
-
-The following model class methods are available:
-* specify which table columns should be ignored by ActiveRecord
-ignore_table_columns :column1, :column2, :column3
-
-* specify which table columns should be with :date type (without time) or with :datetime type (with date and time) - this could be used
-if emulation by column names is not working because of different naming conventions
-set_date_columns :started_on, :finished_on
-set_datetime_columns :start_date_and_time, :end_date_and_time
-
-* specify which table columns should be with :boolean type  - this should be used together with boolean emulation from strings if
-there are other boolean columns with different naming convention
-set_boolean_columns :some_boolean_column
-
-* specify custom create, update and delete methods which should be used instead of Rails generated INSERT, UPDATE and DELETE statements
-# should return ID of new record
-set_create_method do
-  plsql.employees_pkg.create_employee(
-    :p_first_name => first_name,
-    :p_last_name => last_name,
-    :p_employee_id => nil
-  )[:p_employee_id]
-end
-set_update_method do
-  plsql.employees_pkg.update_employee(
-    :p_employee_id => id,
-    :p_first_name => first_name,
-    :p_last_name => last_name
-  )
-end
-set_delete_method do
-  plsql.employees_pkg.delete_employee(
-    :p_employee_id => id
-  )
-end
-
-Oracle enhanced adapter is also compatible with composite_primary_keys gem.
-
-See History.txt for other enhancements to original Oracle adapter.
+Bugs and enhancement requests can be reported at http://rsim.lighthouseapp.com/projects/11468-oracle-enhanced
 
 == REQUIREMENTS:
 
-* Works with ActiveRecord version 2.0 and 2.1 (which is included in Rails 2.0 and 2.1)
+* Works (has been tested) with ActiveRecord version 2.0, 2.1 and 2.2 (these are the same as Rails versions)
 * Requires ruby-oci8 library to connect to Oracle
-* Requires ruby-plsql gem to support custom create, update and delete methods
+* Requires ruby-plsql gem to support custom create, update and delete methods (but can be used without ruby-plsql if this functionality is not needed)
 
 == INSTALL:
 
@@ -88,7 +29,7 @@ See History.txt for other enhancements to original Oracle adapter.
 
 (The MIT License)
 
-Copyright (c) 2008 Graham Jenkins, Michael Schoen, Raimonds Simanovskis
+Copyright (c) 2009 Graham Jenkins, Michael Schoen, Raimonds Simanovskis
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/lib/active_record/connection_adapters/oracle_enhanced_adapter.rb

@@ -107,6 +107,10 @@ begin
         alias_method :add_order!, :add_order_with_lobs!
       end
       
+      # RSI: get table comment from schema definition
+      def self.table_comment
+        self.connection.table_comment(self.table_name)
+      end
     end
 
 
@@ -147,6 +151,12 @@ begin
           return string.to_time if string.is_a?(Date) && !OracleEnhancedAdapter.emulate_dates
           super
         end
+
+        # RSI: get column comment from schema definition
+        # will work only if using default ActiveRecord connection
+        def comment
+          ActiveRecord::Base.connection.column_comment(@table_name, name)
+        end
         
         private
         def simplified_type(field_type)
@@ -308,7 +318,9 @@ begin
             :time        => { :name => "DATE" },
             :date        => { :name => "DATE" },
             :binary      => { :name => "BLOB" },
-            :boolean     => { :name => "NUMBER", :limit => 1 }
+            # RSI: if emulate_booleans_from_strings then store booleans in VARCHAR2
+            :boolean     => emulate_booleans_from_strings ?
+              { :name => "VARCHAR2", :limit => 1 } : { :name => "NUMBER", :limit => 1 }
           }
         end
 
@@ -633,12 +645,16 @@ begin
           end
         end
 
+        # RSI: default sequence start with value
+        @@default_sequence_start_value = 10000
+        cattr_accessor :default_sequence_start_value
+
         def create_table(name, options = {}, &block) #:nodoc:
           create_sequence = options[:id] != false
-          if create_sequence
-            super(name, options, &block)
-          else
-            super(name, options) do |t|
+          column_comments = {}
+          super(name, options) do |t|
+            # store that primary key was defined in create_table block
+            unless create_sequence
               class <<t
                 attr_accessor :create_sequence
                 def primary_key(*args)
@@ -646,12 +662,34 @@ begin
                   super(*args)
                 end
               end
-              result = block.call(t)
-              create_sequence = t.create_sequence
             end
+
+            # store column comments
+            class <<t
+              attr_accessor :column_comments
+              def column(name, type, options = {})
+                if options[:comment]
+                  self.column_comments ||= {}
+                  self.column_comments[name] = options[:comment]
+                end
+                super(name, type, options)
+              end
+            end
+
+            result = block.call(t)
+            create_sequence = create_sequence || t.create_sequence
+            column_comments = t.column_comments if t.column_comments
           end
+
           seq_name = options[:sequence_name] || "#{name}_seq"
-          execute "CREATE SEQUENCE #{seq_name} START WITH 10000" if create_sequence
+          seq_start_value = options[:sequence_start_value] || default_sequence_start_value
+          execute "CREATE SEQUENCE #{seq_name} START WITH #{seq_start_value}" if create_sequence
+          
+          add_table_comment name, options[:comment]
+          column_comments.each do |column_name, comment|
+            add_comment name, column_name, comment
+          end
+          
         end
 
         def rename_table(name, new_name) #:nodoc:
@@ -687,6 +725,36 @@ begin
           execute "ALTER TABLE #{table_name} DROP COLUMN #{quote_column_name(column_name)}"
         end
 
+        # RSI: table and column comments
+        def add_comment(table_name, column_name, comment)
+          return if comment.blank?
+          execute "COMMENT ON COLUMN #{quote_table_name(table_name)}.#{column_name} IS '#{comment}'"
+        end
+
+        def add_table_comment(table_name, comment)
+          return if comment.blank?
+          execute "COMMENT ON TABLE #{quote_table_name(table_name)} IS '#{comment}'"
+        end
+
+        def table_comment(table_name)
+          (owner, table_name) = @connection.describe(table_name)
+          select_value <<-SQL
+            SELECT comments FROM all_tab_comments
+            WHERE owner = '#{owner}'
+              AND table_name = '#{table_name}'
+          SQL
+        end
+
+        def column_comment(table_name, column_name)
+          (owner, table_name) = @connection.describe(table_name)
+          select_value <<-SQL
+            SELECT comments FROM all_col_comments
+            WHERE owner = '#{owner}'
+              AND table_name = '#{table_name}'
+              AND column_name = '#{column_name.upcase}'
+          SQL
+        end
+
         # Find a table's primary key and sequence. 
         # *Note*: Only primary key is implemented - sequence will be nil.
         def pk_and_sequence_for(table_name)
@@ -916,8 +984,8 @@ begin
   # The OracleConnectionFactory factors out the code necessary to connect and
   # configure an Oracle/OCI connection.
   class OracleEnhancedConnectionFactory #:nodoc:
-    def new_connection(username, password, database, async, prefetch_rows, cursor_sharing)
-      conn = OCI8.new username, password, database
+    def new_connection(username, password, database, async, prefetch_rows, cursor_sharing, privilege)
+      conn = OCI8.new username, password, database, privilege
       conn.exec %q{alter session set nls_date_format = 'YYYY-MM-DD HH24:MI:SS'}
       conn.exec %q{alter session set nls_timestamp_format = 'YYYY-MM-DD HH24:MI:SS'} rescue nil
       conn.autocommit = true
@@ -953,7 +1021,8 @@ begin
       @prefetch_rows = config[:prefetch_rows] || 100
       @cursor_sharing = config[:cursor_sharing] || 'similar'
       @factory = factory
-      @connection  = @factory.new_connection @username, @password, @database, @async, @prefetch_rows, @cursor_sharing
+      @privilege = config[:privilege]
+      @connection  = @factory.new_connection @username, @password, @database, @async, @prefetch_rows, @cursor_sharing, @privilege
       super @connection
     end
 
@@ -972,7 +1041,7 @@ begin
     def reset!
       logoff rescue nil
       begin
-        @connection = @factory.new_connection @username, @password, @database, @async, @prefetch_rows, @cursor_sharing
+        @connection = @factory.new_connection @username, @password, @database, @async, @prefetch_rows, @cursor_sharing, @privilege
         __setobj__ @connection
         @active = true
       rescue
@@ -1048,3 +1117,6 @@ end
 
 # RSI: load additional methods for composite_primary_keys support
 require 'active_record/connection_adapters/oracle_enhanced_cpk'
+
+# RSI: load patch for dirty tracking methods
+require 'active_record/connection_adapters/oracle_enhanced_dirty'

data/lib/active_record/connection_adapters/oracle_enhanced_dirty.rb

@@ -0,0 +1,39 @@
+module ActiveRecord #:nodoc:
+  module ConnectionAdapters #:nodoc:
+    module OracleEnhancedDirty #:nodoc:
+
+      module InstanceMethods
+        private
+        
+        def field_changed?(attr, old, value)
+          if column = column_for_attribute(attr)
+            # RSI: added also :decimal type
+            if (column.type == :integer || column.type == :decimal) && column.null && (old.nil? || old == 0)
+              # For nullable integer columns, NULL gets stored in database for blank (i.e. '') values.
+              # Hence we don't record it as a change if the value changes from nil to ''.
+              # If an old value of 0 is set to '' we want this to get changed to nil as otherwise it'll
+              # be typecast back to 0 (''.to_i => 0)
+              value = nil if value.blank?
+            # RSI: Oracle stores empty string '' or empty text (CLOB) as NULL
+            # therefore need to convert empty string value to nil if old value is nil
+            elsif (column.type == :string || column.type == :text) && column.null && old.nil?
+              value = nil if value == ''
+            else
+              value = column.type_cast(value)
+            end
+          end
+
+          old != value
+        end
+        
+      end
+
+    end
+  end
+end
+
+if ActiveRecord::Base.instance_methods.include?('changed?')
+  ActiveRecord::Base.class_eval do
+    include ActiveRecord::ConnectionAdapters::OracleEnhancedDirty::InstanceMethods
+  end
+end

data/lib/active_record/connection_adapters/oracle_enhanced_version.rb

@@ -3,7 +3,7 @@ module ActiveRecord #:nodoc:
     module OracleEnhancedVersion #:nodoc:
       MAJOR = 1
       MINOR = 1
-      TINY  = 8
+      TINY  = 9
 
       STRING = [MAJOR, MINOR, TINY].join('.')
     end

data/spec/active_record/connection_adapters/oracle_enhanced_adapter_spec.rb

@@ -2,14 +2,21 @@ require File.dirname(__FILE__) + '/../../spec_helper.rb'
 
 describe "OracleEnhancedAdapter establish connection" do
   
-  before(:all) do
+  it "should connect to database" do
     ActiveRecord::Base.establish_connection(:adapter => "oracle_enhanced",
                                             :database => "xe",
                                             :username => "hr",
                                             :password => "hr")
+    ActiveRecord::Base.connection.should_not be_nil
+    ActiveRecord::Base.connection.class.should == ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter
   end
-  
-  it "should connect to database" do
+
+  it "should connect to database as SYSDBA" do
+    ActiveRecord::Base.establish_connection(:adapter => "oracle_enhanced",
+                                            :database => "xe",
+                                            :username => "sys",
+                                            :password => "manager",
+                                            :privilege => :SYSDBA)
     ActiveRecord::Base.connection.should_not be_nil
     ActiveRecord::Base.connection.class.should == ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter
   end
@@ -158,432 +165,6 @@ describe "OracleEnhancedAdapter database session store" do
 
 end
 
-describe "OracleEnhancedAdapter date type detection based on column names" do
-  before(:all) do
-    ActiveRecord::Base.establish_connection(:adapter => "oracle_enhanced",
-                                            :database => "xe",
-                                            :username => "hr",
-                                            :password => "hr")
-    @conn = ActiveRecord::Base.connection
-    @conn.execute <<-SQL
-      CREATE TABLE test_employees (
-        employee_id   NUMBER(6,0),
-        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,
-        updated_at    DATE
-      )
-    SQL
-    @conn.execute <<-SQL
-      CREATE SEQUENCE test_employees_seq  MINVALUE 1
-        INCREMENT BY 1 START WITH 10040 CACHE 20 NOORDER NOCYCLE
-    SQL
-  end
-  
-  after(:all) do
-    @conn.execute "DROP TABLE test_employees"
-    @conn.execute "DROP SEQUENCE test_employees_seq"
-  end
-
-  it "should set DATE column type as datetime if emulate_dates_by_column_name is false" do
-    ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = false
-    columns = @conn.columns('test_employees')
-    column = columns.detect{|c| c.name == "hire_date"}
-    column.type.should == :datetime
-  end
-
-  it "should set DATE column type as date if column name contains '_date_' and emulate_dates_by_column_name is true" do
-    ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = true
-    columns = @conn.columns('test_employees')
-    column = columns.detect{|c| c.name == "hire_date"}
-    column.type.should == :date
-  end
-
-  it "should set DATE column type as datetime 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
-    columns = @conn.columns('test_employees')
-    column = columns.detect{|c| c.name == "created_at"}
-    column.type.should == :datetime
-  end
-
-  it "should set DATE column type as datetime if column name contains 'date' as part of other word and emulate_dates_by_column_name is true" do
-    ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = true
-    columns = @conn.columns('test_employees')
-    column = columns.detect{|c| c.name == "updated_at"}
-    column.type.should == :datetime
-  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
-    columns = @conn.columns('test_employees')
-    column = columns.detect{|c| c.name == "hire_date"}
-    column.type_cast(Time.now).class.should == 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
-    columns = @conn.columns('test_employees')
-    column = columns.detect{|c| c.name == "hire_date"}
-    column.type_cast(Time.now).class.should == Date
-  end
-
-  describe "/ DATE values from ActiveRecord model" do
-    before(:each) do
-      ActiveRecord::Base.connection.clear_types_for_columns
-      ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = false
-      ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates = false
-      class TestEmployee < ActiveRecord::Base
-        set_table_name "hr.test_employees"
-        set_primary_key :employee_id
-      end
-    end
-    
-    def create_test_employee
-      @today = Date.new(2008,8,19)
-      @now = Time.local(2008,8,19,17,03,59)
-      @employee = TestEmployee.create(
-        :first_name => "First",
-        :last_name => "Last",
-        :hire_date => @today,
-        :created_at => @now
-      )
-      @employee.reload
-    end
-
-    after(:each) do
-      # @employee.destroy if @employee
-      Object.send(:remove_const, "TestEmployee")
-    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
-      create_test_employee
-      @employee.hire_date.class.should == 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
-      @employee.hire_date.class.should == 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
-      create_test_employee
-      @employee.created_at.class.should == 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
-      end
-      ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = false
-      create_test_employee
-      @employee.hire_date.class.should == 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
-      end
-      ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = true
-      create_test_employee
-      @employee.hire_date.class.should == Time
-      # change to current time with hours, minutes and seconds
-      @employee.hire_date = @now
-      @employee.save!
-      @employee.reload
-      @employee.hire_date.class.should == Time
-      @employee.hire_date.should == @now
-    end
-
-    it "should guess Date or Time value if emulate_dates is true" do
-      ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates = true
-      create_test_employee
-      @employee.hire_date.class.should == Date
-      @employee.created_at.class.should == Time
-    end
-
-  end
-
-end
-
-describe "OracleEnhancedAdapter integer type detection based on column names" do
-  before(:all) do
-    ActiveRecord::Base.establish_connection(:adapter => "oracle_enhanced",
-                                            :database => "xe",
-                                            :username => "hr",
-                                            :password => "hr")
-    @conn = ActiveRecord::Base.connection
-    @conn.execute <<-SQL
-      CREATE TABLE test2_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 test2_employees_seq  MINVALUE 1
-        INCREMENT BY 1 START WITH 10040 CACHE 20 NOORDER NOCYCLE
-    SQL
-  end
-  
-  after(:all) do
-    @conn.execute "DROP TABLE test2_employees"
-    @conn.execute "DROP SEQUENCE test2_employees_seq"
-  end
-
-  it "should set NUMBER column type as decimal if emulate_integers_by_column_name is false" do
-    ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_integers_by_column_name = false
-    columns = @conn.columns('test2_employees')
-    column = columns.detect{|c| c.name == "job_id"}
-    column.type.should == :decimal
-  end
-
-  it "should set NUMBER 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('test2_employees')
-    column = columns.detect{|c| c.name == "job_id"}
-    column.type.should == :integer
-    column = columns.detect{|c| c.name == "id"}
-    column.type.should == :integer
-  end
-
-  it "should set NUMBER column type as decimal 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
-    columns = @conn.columns('test2_employees')
-    column = columns.detect{|c| c.name == "salary"}
-    column.type.should == :decimal
-  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
-    columns = @conn.columns('test2_employees')
-    column = columns.detect{|c| c.name == "job_id"}
-    column.type_cast(1.0).class.should == BigDecimal
-  end
-
-  it "should return Fixnum 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
-    columns = @conn.columns('test2_employees')
-    column = columns.detect{|c| c.name == "job_id"}
-    column.type_cast(1.0).class.should == Fixnum
-  end
-
-  describe "/ NUMBER values from ActiveRecord model" do
-    before(:each) do
-      class Test2Employee < ActiveRecord::Base
-      end
-    end
-    
-    after(:each) do
-      Object.send(:remove_const, "Test2Employee")
-    end
-    
-    def create_employee2
-      @employee2 = Test2Employee.create(
-        :first_name => "First",
-        :last_name => "Last",
-        :job_id => 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
-      @employee2.job_id.class.should == BigDecimal
-    end
-
-    it "should return Fixnum 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
-      create_employee2
-      @employee2.job_id.class.should == Fixnum
-    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
-      @employee2.salary.class.should == BigDecimal
-    end
-
-  end
-
-end
-
-describe "OracleEnhancedAdapter boolean type detection based on string column types and names" do
-  before(:all) do
-    ActiveRecord::Base.establish_connection(:adapter => "oracle_enhanced",
-                                            :database => "xe",
-                                            :username => "hr",
-                                            :password => "hr")
-    @conn = ActiveRecord::Base.connection
-    @conn.execute <<-SQL
-      CREATE TABLE test3_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,
-        has_email     CHAR(1),
-        has_phone     VARCHAR2(1),
-        active_flag   VARCHAR2(2),
-        manager_yn    VARCHAR2(3),
-        test_boolean  VARCHAR2(3)
-      )
-    SQL
-    @conn.execute <<-SQL
-      CREATE SEQUENCE test3_employees_seq  MINVALUE 1
-        INCREMENT BY 1 START WITH 10040 CACHE 20 NOORDER NOCYCLE
-    SQL
-  end
-  
-  after(:all) do
-    @conn.execute "DROP TABLE test3_employees"
-    @conn.execute "DROP SEQUENCE test3_employees_seq"
-  end
-
-  it "should set CHAR/VARCHAR2 column type as string if emulate_booleans_from_strings is false" do
-    ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans_from_strings = false
-    columns = @conn.columns('test3_employees')
-    %w(has_email has_phone active_flag manager_yn).each do |col|
-      column = columns.detect{|c| c.name == col}
-      column.type.should == :string
-    end
-  end
-
-  it "should set CHAR/VARCHAR2 column type as boolean if emulate_booleans_from_strings is true" do
-    ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans_from_strings = true
-    columns = @conn.columns('test3_employees')
-    %w(has_email has_phone active_flag manager_yn).each do |col|
-      column = columns.detect{|c| c.name == col}
-      column.type.should == :boolean
-    end
-  end
-  
-  it "should set VARCHAR2 column type as string if column name does not contain 'flag' or 'yn' and emulate_booleans_from_strings is true" do
-    ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans_from_strings = true
-    columns = @conn.columns('test3_employees')
-    %w(phone_number email).each do |col|
-      column = columns.detect{|c| c.name == col}
-      column.type.should == :string
-    end
-  end
-  
-  it "should return string value from VARCHAR2 boolean column if emulate_booleans_from_strings is false" do
-    ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans_from_strings = false
-    columns = @conn.columns('test3_employees')
-    %w(has_email has_phone active_flag manager_yn).each do |col|
-      column = columns.detect{|c| c.name == col}
-      column.type_cast("Y").class.should == String
-    end
-  end
-  
-  it "should return boolean value from VARCHAR2 boolean column if emulate_booleans_from_strings is true" do
-    ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans_from_strings = true
-    columns = @conn.columns('test3_employees')
-    %w(has_email has_phone active_flag manager_yn).each do |col|
-      column = columns.detect{|c| c.name == col}
-      column.type_cast("Y").class.should == TrueClass
-      column.type_cast("N").class.should == FalseClass
-    end
-  end
-  
-  describe "/ VARCHAR2 boolean values from ActiveRecord model" do
-    before(:each) do
-      ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans_from_strings = false
-      class Test3Employee < ActiveRecord::Base
-      end
-    end
-    
-    after(:each) do
-      Object.send(:remove_const, "Test3Employee")
-    end
-    
-    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
-        }.merge(params)
-      )
-      @employee3.reload
-    end
-    
-    it "should return String value from VARCHAR2 boolean column if emulate_booleans_from_strings is false" do
-      ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans_from_strings = false
-      create_employee3
-      %w(has_email has_phone active_flag manager_yn).each do |col|
-        @employee3.send(col.to_sym).class.should == String
-      end
-    end
-  
-    it "should return boolean value from VARCHAR2 boolean column if emulate_booleans_from_strings is true" do
-      ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans_from_strings = true
-      create_employee3
-      %w(has_email active_flag).each do |col|
-        @employee3.send(col.to_sym).class.should == TrueClass
-        @employee3.send((col+"_before_type_cast").to_sym).should == "Y"
-      end
-      %w(has_phone manager_yn).each do |col|
-        @employee3.send(col.to_sym).class.should == FalseClass
-        @employee3.send((col+"_before_type_cast").to_sym).should == "N"
-      end
-    end
-      
-    it "should return string value from VARCHAR2 column if it is not boolean column and emulate_booleans_from_strings is true" do
-      ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_booleans_from_strings = true
-      create_employee3
-      @employee3.first_name.class.should == String
-    end
-
-    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
-      class Test3Employee < ActiveRecord::Base
-        set_boolean_columns :test_boolean
-      end
-      create_employee3(:test_boolean => true)
-      @employee3.test_boolean.class.should == TrueClass
-      @employee3.test_boolean_before_type_cast.should == "Y"
-      create_employee3(:test_boolean => false)
-      @employee3.test_boolean.class.should == FalseClass
-      @employee3.test_boolean_before_type_cast.should == "N"
-    end
-  
-  end
-
-end
-
-
 describe "OracleEnhancedAdapter ignore specified table columns" do
   before(:all) do
     ActiveRecord::Base.establish_connection(:adapter => "oracle_enhanced",
@@ -647,453 +228,223 @@ describe "OracleEnhancedAdapter ignore specified table columns" do
 
 end
 
+describe "OracleEnhancedAdapter table and sequence creation with non-default primary key" do
 
-describe "OracleEnhancedAdapter timestamp with timezone support" do
   before(:all) do
     ActiveRecord::Base.establish_connection(:adapter => "oracle_enhanced",
                                             :database => "xe",
                                             :username => "hr",
                                             :password => "hr")
-    @conn = ActiveRecord::Base.connection
-    @conn.execute <<-SQL
-      CREATE TABLE test_employees (
-        employee_id   NUMBER(6,0),
-        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    TIMESTAMP,
-        created_at_tz   TIMESTAMP WITH TIME ZONE,
-        created_at_ltz  TIMESTAMP WITH LOCAL TIME ZONE
-      )
-    SQL
-    @conn.execute <<-SQL
-      CREATE SEQUENCE test_employees_seq  MINVALUE 1
-        INCREMENT BY 1 CACHE 20 NOORDER NOCYCLE
-    SQL
-  end
-  
-  after(:all) do
-    @conn.execute "DROP TABLE test_employees"
-    @conn.execute "DROP SEQUENCE test_employees_seq"
-  end
-
-  it "should set TIMESTAMP columns type as datetime" do
-    columns = @conn.columns('test_employees')
-    ts_columns = columns.select{|c| c.name =~ /created_at/}
-    ts_columns.each {|c| c.type.should == :timestamp}
-  end
-
-  describe "/ TIMESTAMP WITH TIME ZONE values from ActiveRecord model" do
-    before(:all) do
-      class TestEmployee < ActiveRecord::Base
-        set_primary_key :employee_id
+    ActiveRecord::Schema.define do
+      suppress_messages do
+        create_table :keyboards, :force => true, :id  => false do |t|
+          t.primary_key :key_number
+          t.string      :name
+        end
+        create_table :id_keyboards, :force => true do |t|
+          t.string      :name
+        end
       end
     end
-
-    after(:all) do
-      Object.send(:remove_const, "TestEmployee")
+    class Keyboard < ActiveRecord::Base
+      set_primary_key :key_number
     end
-
-    it "should return Time value from TIMESTAMP columns" do
-      # currently fractional seconds are not retrieved from database
-      @now = Time.local(2008,5,26,23,11,11,0)
-      @employee = TestEmployee.create(
-        :created_at => @now,
-        :created_at_tz => @now,
-        :created_at_ltz => @now
-      )
-      @employee.reload
-      [:created_at, :created_at_tz, :created_at_ltz].each do |c|
-        @employee.send(c).class.should == Time
-        @employee.send(c).to_f.should == @now.to_f
-      end
+    class IdKeyboard < ActiveRecord::Base
     end
-
-    it "should return Time value without fractional seconds from TIMESTAMP columns" do
-      # currently fractional seconds are not retrieved from database
-      @now = Time.local(2008,5,26,23,11,11,10)
-      @employee = TestEmployee.create(
-        :created_at => @now,
-        :created_at_tz => @now,
-        :created_at_ltz => @now
-      )
-      @employee.reload
-      [:created_at, :created_at_tz, :created_at_ltz].each do |c|
-        @employee.send(c).class.should == Time
-        @employee.send(c).to_f.should == @now.to_f.to_i.to_f # remove fractional seconds
+  end
+  
+  after(:all) do
+    ActiveRecord::Schema.define do
+      suppress_messages do
+        drop_table :keyboards
+        drop_table :id_keyboards
       end
     end
-
+    Object.send(:remove_const, "Keyboard")
+    Object.send(:remove_const, "IdKeyboard")
+  end
+  
+  it "should create sequence for non-default primary key" do
+    ActiveRecord::Base.connection.next_sequence_value(Keyboard.sequence_name).should_not be_nil
   end
 
+  it "should create sequence for default primary key" do
+    ActiveRecord::Base.connection.next_sequence_value(IdKeyboard.sequence_name).should_not be_nil
+  end
 end
 
+describe "OracleEnhancedAdapter without composite_primary_keys" do
 
-describe "OracleEnhancedAdapter date and timestamp with different NLS date formats" do
   before(:all) do
     ActiveRecord::Base.establish_connection(:adapter => "oracle_enhanced",
                                             :database => "xe",
                                             :username => "hr",
                                             :password => "hr")
-    @conn = ActiveRecord::Base.connection
-    @conn.execute <<-SQL
-      CREATE TABLE test_employees (
-        employee_id   NUMBER(6,0),
-        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
+    Object.send(:remove_const, 'CompositePrimaryKeys') if defined?(CompositePrimaryKeys)
+    class Employee < ActiveRecord::Base
       set_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")    
-  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
-    create_test_employee
-    @employee.hire_date.class.should == Time
-    @employee.hire_date.should == @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
-    @employee.hire_date.class.should == Date
-    @employee.hire_date.should == @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
-    create_test_employee
-    @employee.created_at.class.should == Time
-    @employee.created_at.should == @now
-  end
-
-  it "should return Time value from TIMESTAMP columns" do
-    create_test_employee
-    @employee.created_at_ts.class.should == Time
-    @employee.created_at_ts.should == @now
-  end
-
-  it "should quote Date values with TO_DATE" do
-    @conn.quote(@today).should == "TO_DATE('#{@today.year}-#{"%02d" % @today.month}-#{"%02d" % @today.day}','YYYY-MM-DD HH24:MI:SS')"
-  end
-
-  it "should quote Time values with TO_DATE" do
-    @conn.quote(@now).should == "TO_DATE('#{@now.year}-#{"%02d" % @now.month}-#{"%02d" % @now.day} "+
-                                "#{"%02d" % @now.hour}:#{"%02d" % @now.min}:#{"%02d" % @now.sec}','YYYY-MM-DD HH24:MI:SS')"
+  it "should tell ActiveRecord that count distinct is supported" do
+    ActiveRecord::Base.connection.supports_count_distinct?.should be_true
   end
 
-  it "should quote Time values with TO_TIMESTAMP" do
-    @ts = Time.at(@now.to_f + 0.1)
-    @conn.quote(@ts).should == "TO_TIMESTAMP('#{@ts.year}-#{"%02d" % @ts.month}-#{"%02d" % @ts.day} "+
-                                "#{"%02d" % @ts.hour}:#{"%02d" % @ts.min}:#{"%02d" % @ts.sec}.100000','YYYY-MM-DD HH24:MI:SS.FF6')"
+  it "should execute correct SQL COUNT DISTINCT statement" do
+    lambda { Employee.count(:employee_id, :distinct => true) }.should_not raise_error
   end
 
 end
 
-describe "OracleEnhancedAdapter assign string to :date and :datetime columns" do
+describe "OracleEnhancedAdapter sequence creation parameters" do
+
   before(:all) do
     ActiveRecord::Base.establish_connection(:adapter => "oracle_enhanced",
                                             :database => "xe",
                                             :username => "hr",
                                             :password => "hr")
-    @conn = ActiveRecord::Base.connection
-    @conn.execute <<-SQL
-      CREATE TABLE test_employees (
-        employee_id   NUMBER(6,0),
-        first_name    VARCHAR2(20),
-        last_name     VARCHAR2(25),
-        hire_date     DATE,
-        last_login_at    DATE,
-        last_login_at_ts   TIMESTAMP
-      )
-    SQL
-    @conn.execute <<-SQL
-      CREATE SEQUENCE test_employees_seq  MINVALUE 1
-        INCREMENT BY 1 CACHE 20 NOORDER NOCYCLE
-    SQL
-    class TestEmployee < ActiveRecord::Base
-      set_primary_key :employee_id
+  end
+
+  def create_test_employees_table(sequence_start_value = nil)
+    ActiveRecord::Schema.define do
+      suppress_messages do
+        create_table :test_employees, sequence_start_value ? {:sequence_start_value => sequence_start_value} : {} do |t|
+          t.string      :first_name
+          t.string      :last_name
+        end
+      end
     end
   end
   
-  after(:all) do
-    Object.send(:remove_const, "TestEmployee")
-    @conn.execute "DROP TABLE test_employees"
-    @conn.execute "DROP SEQUENCE test_employees_seq"
+  def save_default_sequence_start_value
+    @saved_sequence_start_value = ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.default_sequence_start_value
+  end
+
+  def restore_default_sequence_start_value
+    ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.default_sequence_start_value = @saved_sequence_start_value
   end
 
   before(:each) do
-    @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_iso = "2008-06-28 13:34:33"
-    @now_nls = "28.06.2008 13:34:33"
-    @nls_time_format = "%d.%m.%Y %H:%M:%S"
-    ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.emulate_dates_by_column_name = true
+    save_default_sequence_start_value
   end
-  
-  it "should assign ISO string to date column" do
-    @employee = TestEmployee.create(
-      :first_name => "First",
-      :last_name => "Last",
-      :hire_date => @today_iso
-    )
-    @employee.reload
-    @employee.hire_date.should == @today
+  after(:each) do
+    restore_default_sequence_start_value
+    ActiveRecord::Schema.define do
+      suppress_messages do
+        drop_table :test_employees
+      end
+    end
+    Object.send(:remove_const, "TestEmployee")
   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
-    )
-    @employee.reload
-    @employee.hire_date.should == @today
-  end
+  it "should use default sequence start value 10000" do
+    ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.default_sequence_start_value.should == 10000
 
-  it "should assign ISO time string to date column" do
-    @employee = TestEmployee.create(
-      :first_name => "First",
-      :last_name => "Last",
-      :hire_date => @now_iso
-    )
-    @employee.reload
-    @employee.hire_date.should == @today
-  end
+    create_test_employees_table
+    class TestEmployee < ActiveRecord::Base; 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
-    )
-    @employee.reload
-    @employee.hire_date.should == @today
+    employee = TestEmployee.create!
+    employee.id.should == 10000
   end
 
-  it "should assign ISO time string to datetime column" do
-    @employee = TestEmployee.create(
-      :first_name => "First",
-      :last_name => "Last",
-      :last_login_at => @now_iso
-    )
-    @employee.reload
-    @employee.last_login_at.should == @now
-  end
+  it "should use specified default sequence start value" do
+    ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.default_sequence_start_value = 1
 
-  it "should assign NLS time string to datetime 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",
-      :last_login_at => @now_nls
-    )
-    @employee.reload
-    @employee.last_login_at.should == @now
-  end
-  
-  it "should assign ISO date string to datetime column" do
-    @employee = TestEmployee.create(
-      :first_name => "First",
-      :last_name => "Last",
-      :last_login_at => @today_iso
-    )
-    @employee.reload
-    @employee.last_login_at.should == @today.to_time
-  end
+    create_test_employees_table
+    class TestEmployee < ActiveRecord::Base; end
 
-  it "should assign NLS date string to datetime 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",
-      :last_login_at => @today_nls
-    )
-    @employee.reload
-    @employee.last_login_at.should == @today.to_time
+    employee = TestEmployee.create!
+    employee.id.should == 1
   end
-  
-end
 
-describe "OracleEnhancedAdapter handling of CLOB columns" do
-  before(:all) do
-    ActiveRecord::Base.establish_connection(:adapter => "oracle_enhanced",
-                                            :database => "xe",
-                                            :username => "hr",
-                                            :password => "hr")
-    @conn = ActiveRecord::Base.connection
-    @conn.execute <<-SQL
-      CREATE TABLE test_employees (
-        employee_id   NUMBER(6,0),
-        first_name    VARCHAR2(20),
-        last_name     VARCHAR2(25),
-        comments      CLOB
-      )
-    SQL
-    @conn.execute <<-SQL
-      CREATE SEQUENCE test_employees_seq  MINVALUE 1
-        INCREMENT BY 1 CACHE 20 NOORDER NOCYCLE
-    SQL
-    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"
-    @conn.execute "DROP SEQUENCE test_employees_seq"
-  end
+  it "should use sequence start value from table definition" do
+    create_test_employees_table(10)
+    class TestEmployee < ActiveRecord::Base; end
 
-  before(:each) do
-  end
-  
-  it "should create record without CLOB data when attribute is serialized" do
-    TestEmployee.serialize :comments
-    @employee = TestEmployee.create!(
-      :first_name => "First",
-      :last_name => "Last"
-    )
-    @employee.should be_valid
+    employee = TestEmployee.create!
+    employee.id.should == 10
   end
 
-  it "should order by CLOB column" do
-    @employee = TestEmployee.create!(
-      :first_name => "First",
-      :last_name => "Last",
-      :comments => "comments"
-    )
-    TestEmployee.find(:all, :order => "comments ASC").should_not be_empty
-    TestEmployee.find(:all, :order => " comments ASC ").should_not be_empty
-    TestEmployee.find(:all, :order => "comments").should_not be_empty
-    TestEmployee.find(:all, :order => " comments ").should_not be_empty
-    TestEmployee.find(:all, :order => :comments).should_not be_empty
-    TestEmployee.find(:all, :order => "  first_name DESC,  last_name   ASC   ").should_not be_empty
+  it "should use sequence start value and other options from table definition" do
+    create_test_employees_table("100 NOCACHE INCREMENT BY 10")
+    class TestEmployee < ActiveRecord::Base; end
+
+    employee = TestEmployee.create!
+    employee.id.should == 100
+    employee = TestEmployee.create!
+    employee.id.should == 110
   end
-  
+
 end
 
-describe "OracleEnhancedAdapter table and sequence creation with non-default primary key" do
+describe "OracleEnhancedAdapter table and column comments" do
+
   before(:all) do
     ActiveRecord::Base.establish_connection(:adapter => "oracle_enhanced",
                                             :database => "xe",
                                             :username => "hr",
                                             :password => "hr")
+    @conn = ActiveRecord::Base.connection
+  end
+
+  def create_test_employees_table(table_comment=nil, column_comments={})
     ActiveRecord::Schema.define do
-      create_table :keyboards, :force => true, :id  => false do |t|
-        t.primary_key :key_number
-        t.string      :name
-      end
-      create_table :id_keyboards, :force => true do |t|
-        t.string      :name
+      suppress_messages do
+        create_table :test_employees, :comment => table_comment do |t|
+          t.string      :first_name, :comment => column_comments[:first_name]
+          t.string      :last_name, :comment => column_comments[:last_name]
+        end
       end
     end
-    class Keyboard < ActiveRecord::Base
-      set_primary_key :key_number
-    end
-    class IdKeyboard < ActiveRecord::Base
-    end
   end
-  
-  after(:all) do
+
+  after(:each) do
     ActiveRecord::Schema.define do
-      drop_table :keyboards
-      drop_table :id_keyboards
+      suppress_messages do
+        drop_table :test_employees
+      end
     end
-    Object.send(:remove_const, "Keyboard")
-    Object.send(:remove_const, "IdKeyboard")
-  end
-  
-  it "should create sequence for non-default primary key" do
-    ActiveRecord::Base.connection.next_sequence_value(Keyboard.sequence_name).should_not be_nil
+    Object.send(:remove_const, "TestEmployee")
+    ActiveRecord::Base.table_name_prefix = nil
   end
 
-  it "should create sequence for default primary key" do
-    ActiveRecord::Base.connection.next_sequence_value(IdKeyboard.sequence_name).should_not be_nil
+  it "should create table with table comment" do
+    table_comment = "Test Employees"
+    create_test_employees_table(table_comment)
+    class TestEmployee < ActiveRecord::Base; end
+    
+    @conn.table_comment("test_employees").should == table_comment
+    TestEmployee.table_comment.should == table_comment
   end
-end
 
-describe "OracleEnhancedAdapter without composite_primary_keys" do
-
-  before(:all) do
-    ActiveRecord::Base.establish_connection(:adapter => "oracle_enhanced",
-                                            :database => "xe",
-                                            :username => "hr",
-                                            :password => "hr")
-    Object.send(:remove_const, 'CompositePrimaryKeys') if defined?(CompositePrimaryKeys)
-    class Employee < ActiveRecord::Base
-      set_primary_key :employee_id
+  it "should create table with columns comment" do
+    column_comments = {:first_name => "Given Name", :last_name => "Surname"}
+    create_test_employees_table(nil, column_comments)
+    class TestEmployee < ActiveRecord::Base; end
+    
+    [:first_name, :last_name].each do |attr|
+      @conn.column_comment("test_employees", attr.to_s).should == column_comments[attr]
+    end
+    [:first_name, :last_name].each do |attr|
+      TestEmployee.columns_hash[attr.to_s].comment.should == column_comments[attr]
     end
   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 { Employee.count(:employee_id, :distinct => true) }.should_not raise_error
+  it "should create table with table and columns comment and custom table name prefix" do
+    ActiveRecord::Base.table_name_prefix = "xxx_"
+    table_comment = "Test Employees"
+    column_comments = {:first_name => "Given Name", :last_name => "Surname"}
+    create_test_employees_table(table_comment, column_comments)
+    class TestEmployee < ActiveRecord::Base; end
+    
+    @conn.table_comment(TestEmployee.table_name).should == table_comment
+    TestEmployee.table_comment.should == table_comment
+    [:first_name, :last_name].each do |attr|
+      @conn.column_comment(TestEmployee.table_name, attr.to_s).should == column_comments[attr]
+    end
+    [:first_name, :last_name].each do |attr|
+      TestEmployee.columns_hash[attr.to_s].comment.should == column_comments[attr]
+    end
   end
 
 end