rsim-activerecord-oracle_enhanced-adapter 1.1.9.90

data/lib/active_record/connection_adapters/oracle_enhanced_cpk.rb

@@ -0,0 +1,21 @@
+module ActiveRecord #:nodoc:
+  module ConnectionAdapters #:nodoc:
+    module OracleEnhancedCpk #:nodoc:
+
+      # This mightn't be in Core, but count(distinct x,y) doesn't work for me
+      # RSI: return that not supported if composite_primary_keys gem is required
+      def supports_count_distinct? #:nodoc:
+        @supports_count_distinct ||= ! defined?(CompositePrimaryKeys)
+      end
+      
+      def concat(*columns)
+        "(#{columns.join('||')})"
+      end
+      
+    end
+  end
+end
+
+ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.class_eval do
+  include ActiveRecord::ConnectionAdapters::OracleEnhancedCpk
+end

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_procedures.rb

@@ -0,0 +1,110 @@
+# 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
+end
+
+require 'ruby_plsql'
+require 'activesupport'
+
+module ActiveRecord #:nodoc:
+  module ConnectionAdapters #:nodoc:
+    module OracleEnhancedProcedures #:nodoc:
+
+      module ClassMethods
+        def set_create_method(&block)
+          include_with_custom_methods
+          self.custom_create_method = block
+        end
+
+        def set_update_method(&block)
+          include_with_custom_methods
+          self.custom_update_method = block
+        end
+
+        def set_delete_method(&block)
+          include_with_custom_methods
+          self.custom_delete_method = block
+        end
+        
+        private
+        def include_with_custom_methods
+          unless included_modules.include? InstanceMethods
+            include InstanceMethods
+          end
+        end
+      end
+      
+      module InstanceMethods
+        def self.included(base)
+          base.instance_eval do
+            alias_method_chain :create, :custom_method
+            # insert after dirty checking in Rails 2.1
+            if private_instance_methods.include?('update_without_dirty')
+              alias_method :update_without_custom_method, :update_without_dirty
+              alias_method :update_without_dirty, :update_with_custom_method
+            else
+              alias_method_chain :update, :custom_method
+            end
+            private :create, :update
+            alias_method_chain :destroy, :custom_method
+            public :destroy
+          end
+        end
+        
+        private
+        
+        # Creates a record with custom create method
+        # and returns its id.
+        def create_with_custom_method
+          # check if class has custom create method
+          return create_without_custom_method unless self.class.custom_create_method
+          self.class.connection.log_custom_method("custom create method", "#{self.class.name} Create") do
+            self.id = self.class.custom_create_method.bind(self).call
+          end
+          @new_record = false
+          id
+        end
+
+        # Updates the associated record with custom update method
+        # Returns the number of affected rows.
+        def update_with_custom_method(attribute_names = @attributes.keys)
+          # check if class has custom create method
+          return update_without_custom_method unless self.class.custom_update_method
+          return 0 if attribute_names.empty?
+          self.class.connection.log_custom_method("custom update method with #{self.class.primary_key}=#{self.id}", "#{self.class.name} Update") do
+            self.class.custom_update_method.bind(self).call
+          end
+          1
+        end
+
+        # Deletes the record in the database with custom delete method
+        # and freezes this instance to reflect that no changes should
+        # be made (since they can't be persisted).
+        def destroy_with_custom_method
+          # check if class has custom create method
+          return destroy_without_custom_method unless self.class.custom_delete_method
+          unless new_record?
+            self.class.connection.log_custom_method("custom delete method with #{self.class.primary_key}=#{self.id}", "#{self.class.name} Destroy") do
+              self.class.custom_delete_method.bind(self).call
+            end
+          end
+
+          freeze
+        end
+
+      end
+
+    end
+  end
+end
+
+ActiveRecord::Base.class_eval do
+  extend ActiveRecord::ConnectionAdapters::OracleEnhancedProcedures::ClassMethods
+end
+
+ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.class_eval do
+  # public alias to log method which could be used from other objects
+  alias_method :log_custom_method, :log
+  public :log_custom_method
+end

data/lib/active_record/connection_adapters/oracle_enhanced_reserved_words.rb

@@ -0,0 +1,126 @@
+module ActiveRecord #:nodoc:
+  module ConnectionAdapters #:nodoc:
+    module OracleEnhancedReservedWords #:nodoc:
+
+      RESERVED_WORDS = {
+        "ACCESS" => true,
+        "ADD" => true,
+        "ALL" => true,
+        "ALTER" => true,
+        "AND" => true,
+        "ANY" => true,
+        "AS" => true,
+        "ASC" => true,
+        "AUDIT" => true,
+        "BETWEEN" => true,
+        "BY" => true,
+        "CHAR" => true,
+        "CHECK" => true,
+        "CLUSTER" => true,
+        "COLUMN" => true,
+        "COMMENT" => true,
+        "COMPRESS" => true,
+        "CONNECT" => true,
+        "CREATE" => true,
+        "CURRENT" => true,
+        "DATE" => true,
+        "DECIMAL" => true,
+        "DEFAULT" => true,
+        "DELETE" => true,
+        "DESC" => true,
+        "DISTINCT" => true,
+        "DROP" => true,
+        "ELSE" => true,
+        "EXCLUSIVE" => true,
+        "EXISTS" => true,
+        "FILE" => true,
+        "FLOAT" => true,
+        "FOR" => true,
+        "FROM" => true,
+        "GRANT" => true,
+        "GROUP" => true,
+        "HAVING" => true,
+        "IDENTIFIED" => true,
+        "IMMEDIATE" => true,
+        "IN" => true,
+        "INCREMENT" => true,
+        "INDEX" => true,
+        "INITIAL" => true,
+        "INSERT" => true,
+        "INTEGER" => true,
+        "INTERSECT" => true,
+        "INTO" => true,
+        "IS" => true,
+        "LEVEL" => true,
+        "LIKE" => true,
+        "LOCK" => true,
+        "LONG" => true,
+        "MAXEXTENTS" => true,
+        "MINUS" => true,
+        "MLSLABEL" => true,
+        "MODE" => true,
+        "MODIFY" => true,
+        "NOAUDIT" => true,
+        "NOCOMPRESS" => true,
+        "NOT" => true,
+        "NOWAIT" => true,
+        "NULL" => true,
+        "NUMBER" => true,
+        "OF" => true,
+        "OFFLINE" => true,
+        "ON" => true,
+        "ONLINE" => true,
+        "OPTION" => true,
+        "OR" => true,
+        "ORDER" => true,
+        "PCTFREE" => true,
+        "PRIOR" => true,
+        "PRIVILEGES" => true,
+        "PUBLIC" => true,
+        "RAW" => true,
+        "RENAME" => true,
+        "RESOURCE" => true,
+        "REVOKE" => true,
+        "ROW" => true,
+        "ROWID" => true,
+        "ROWNUM" => true,
+        "ROWS" => true,
+        "SELECT" => true,
+        "SESSION" => true,
+        "SET" => true,
+        "SHARE" => true,
+        "SIZE" => true,
+        "SMALLINT" => true,
+        "START" => true,
+        "SUCCESSFUL" => true,
+        "SYNONYM" => true,
+        "SYSDATE" => true,
+        "TABLE" => true,
+        "THEN" => true,
+        "TO" => true,
+        "TRIGGER" => true,
+        "UID" => true,
+        "UNION" => true,
+        "UNIQUE" => true,
+        "UPDATE" => true,
+        "USER" => true,
+        "VALIDATE" => true,
+        "VALUES" => true,
+        "VARCHAR" => true,
+        "VARCHAR2" => true,
+        "VIEW" => true,
+        "WHENEVER" => true,
+        "WHERE" => true,
+        "WITH" => true
+      }
+
+      def quote_oracle_reserved_words(name)
+        RESERVED_WORDS[name.to_s.upcase].nil? ? name : "\"#{name}\""
+      end
+    end
+  end
+end
+
+ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.class_eval do
+  include ActiveRecord::ConnectionAdapters::OracleEnhancedReservedWords
+end

data/lib/active_record/connection_adapters/oracle_enhanced_tasks.rb

@@ -0,0 +1,11 @@
+# RSI: implementation idea taken from JDBC adapter
+if defined?(Rake.application) && Rake.application
+  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,11 @@
+module ActiveRecord #:nodoc:
+  module ConnectionAdapters #:nodoc:
+    module OracleEnhancedVersion #:nodoc:
+      MAJOR = 1
+      MINOR = 1
+      TINY  = 9
+
+      STRING = [MAJOR, MINOR, TINY].join('.')
+    end
+  end
+end

data/oracle-enhanced.gemspec

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+Gem::Specification.new do |s|
+  s.name = %q{activerecord-oracle_enhanced-adapter}
+  s.version = "1.1.9.90"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Raimonds Simanovskis"]
+  s.date = %q{2009-03-14}
+  s.description = %q{Oracle enhanced adapter for ActiveRecord}
+  s.email = ["raimonds.simanovskis@gmail.com"]
+  s.extra_rdoc_files = ["History.txt", "License.txt", "Manifest.txt", "README.txt"]
+  s.files = ["History.txt", "License.txt", "Manifest.txt", "README.txt",
+    "lib/active_record/connection_adapters/emulation/oracle_adapter.rb",
+    "lib/active_record/connection_adapters/oracle_enhanced.rake",
+    "lib/active_record/connection_adapters/oracle_enhanced_adapter.rb",
+    "lib/active_record/connection_adapters/oracle_enhanced_cpk.rb",
+    "lib/active_record/connection_adapters/oracle_enhanced_dirty.rb",
+    "lib/active_record/connection_adapters/oracle_enhanced_procedures.rb",
+    "lib/active_record/connection_adapters/oracle_enhanced_reserved_words.rb",
+    "lib/active_record/connection_adapters/oracle_enhanced_tasks.rb",
+    "lib/active_record/connection_adapters/oracle_enhanced_version.rb",
+    "oracle-enhanced.gemspec",
+    "spec/active_record/connection_adapters/oracle_enhanced_adapter_spec.rb",
+    "spec/active_record/connection_adapters/oracle_enhanced_cpk_spec.rb",
+    "spec/active_record/connection_adapters/oracle_enhanced_data_types_spec.rb",
+    "spec/active_record/connection_adapters/oracle_enhanced_dirty_spec.rb",
+    "spec/active_record/connection_adapters/oracle_enhanced_emulate_oracle_adapter_spec.rb",
+    "spec/active_record/connection_adapters/oracle_enhanced_procedures_spec.rb",
+    "spec/spec.opts",
+    "spec/spec_helper.rb"]
+  s.has_rdoc = true
+  s.homepage = %q{http://oracle-enhanced.rubyforge.org}
+  s.post_install_message = %q{}
+  s.rdoc_options = ["--main", "README.txt"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{oracle-enhanced}
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{Oracle enhanced adapter for ActiveRecord}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<hoe>, [">= 1.8.0"])
+    else
+      s.add_dependency(%q<hoe>, [">= 1.8.0"])
+    end
+  else
+    s.add_dependency(%q<hoe>, [">= 1.8.0"])
+  end
+end

data/spec/active_record/connection_adapters/oracle_enhanced_adapter_spec.rb

@@ -0,0 +1,548 @@
+require File.dirname(__FILE__) + '/../../spec_helper.rb'
+
+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 schema dump" do
+
+  before(:all) do
+    if !defined?(RUBY_ENGINE)
+      @old_conn = ActiveRecord::Base.oracle_connection(CONNECTION_PARAMS)
+      @old_conn.class.should == ActiveRecord::ConnectionAdapters::OracleAdapter
+    elsif RUBY_ENGINE == 'jruby'
+      @old_conn = ActiveRecord::Base.jdbc_connection(JDBC_CONNECTION_PARAMS)
+      @old_conn.class.should == ActiveRecord::ConnectionAdapters::JdbcAdapter
+    end
+
+    @new_conn = ActiveRecord::Base.oracle_enhanced_connection(CONNECTION_PARAMS)
+    @new_conn.class.should == ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter
+  end
+
+  unless defined?(RUBY_ENGINE) && RUBY_ENGINE == "ruby" && RUBY_VERSION =~ /^1\.9/
+    it "should return the same tables list as original oracle adapter" do
+      @new_conn.tables.sort.should == @old_conn.tables.sort
+    end
+
+    it "should return the same index list as original oracle adapter" do
+      @new_conn.indexes('employees').sort_by(&:name).should == @old_conn.indexes('employees').sort_by(&:name)
+    end
+
+    it "should return the same pk_and_sequence_for as original oracle adapter" do
+      if @old_conn.respond_to?(:pk_and_sequence_for)
+        @new_conn.tables.each do |t|
+          @new_conn.pk_and_sequence_for(t).should == @old_conn.pk_and_sequence_for(t)
+        end
+      end
+    end
+
+    it "should return the same structure dump as original oracle adapter" do
+      @new_conn.structure_dump.should == @old_conn.structure_dump
+    end
+
+    it "should return the same structure drop as original oracle adapter" do
+      @new_conn.structure_drop.should == @old_conn.structure_drop
+    end
+  end
+
+  it "should return the character size of nvarchar fields" do
+    @new_conn.execute <<-SQL
+      CREATE TABLE nvarchartable (
+        session_id  NVARCHAR2(255) DEFAULT NULL
+      )
+    SQL
+    if /.*session_id nvarchar2\((\d+)\).*/ =~ @new_conn.structure_dump
+       "#$1".should == "255"
+    end
+    @new_conn.execute "DROP TABLE nvarchartable"
+  end
+end
+
+describe "OracleEnhancedAdapter database stucture dump extentions" do
+  before(:all) do
+    ActiveRecord::Base.establish_connection(CONNECTION_PARAMS)
+    @conn = ActiveRecord::Base.connection
+    @conn.execute <<-SQL
+      CREATE TABLE nvarchartable (
+        unq_nvarchar  NVARCHAR2(255) DEFAULT NULL
+      )
+    SQL
+  end
+
+  after(:all) do
+    @conn.execute "DROP TABLE nvarchartable"
+  end
+
+  it "should return the character size of nvarchar fields" do
+    if /.*unq_nvarchar nvarchar2\((\d+)\).*/ =~ @conn.structure_dump
+       "#$1".should == "255"
+    end
+  end
+end
+
+describe "OracleEnhancedAdapter database session store" do
+  before(:all) do
+    ActiveRecord::Base.establish_connection(CONNECTION_PARAMS)
+    @conn = ActiveRecord::Base.connection
+    @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
+  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 = CGI::Session::ActiveRecordStore::Session.new :session_id => "111111", :data  => "something" #, :updated_at => Time.now
+    @session.save!
+    @session = CGI::Session::ActiveRecordStore::Session.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 CGI::Session::ActiveRecordStore::Session.respond_to?(:partial_updates=)
+    CGI::Session::ActiveRecordStore::Session.partial_updates = true
+    @session = CGI::Session::ActiveRecordStore::Session.new :session_id => "222222", :data  => "something" #, :updated_at => Time.now
+    @session.save!
+    @session = CGI::Session::ActiveRecordStore::Session.find_by_session_id("222222")
+    @session.data = "other thing"
+    @session.save!
+    # second save should call again blob writing callback
+    @session.save!
+    @session = CGI::Session::ActiveRecordStore::Session.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 CGI::Session::ActiveRecordStore::Session.respond_to?(:after_save_callback_chain)
+    CGI::Session::ActiveRecordStore::Session.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 "OracleEnhancedAdapter ignore specified table columns" do
+  before(:all) do
+    ActiveRecord::Base.establish_connection(CONNECTION_PARAMS)
+    @conn = ActiveRecord::Base.connection
+    @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")
+  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
+
+
+end
+
+describe "OracleEnhancedAdapter table and sequence creation with non-default primary key" do
+
+  before(:all) do
+    ActiveRecord::Base.establish_connection(CONNECTION_PARAMS)
+    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
+    class Keyboard < ActiveRecord::Base
+      set_primary_key :key_number
+    end
+    class IdKeyboard < ActiveRecord::Base
+    end
+  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
+
+  before(:all) do
+    ActiveRecord::Base.establish_connection(CONNECTION_PARAMS)
+    Object.send(:remove_const, 'CompositePrimaryKeys') if defined?(CompositePrimaryKeys)
+    class Employee < ActiveRecord::Base
+      set_primary_key :employee_id
+    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
+  end
+
+end
+
+describe "OracleEnhancedAdapter sequence creation parameters" do
+
+  before(:all) do
+    ActiveRecord::Base.establish_connection(CONNECTION_PARAMS)
+  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
+
+  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
+    save_default_sequence_start_value
+  end
+  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 use default sequence start value 10000" do
+    ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.default_sequence_start_value.should == 10000
+
+    create_test_employees_table
+    class TestEmployee < ActiveRecord::Base; end
+
+    employee = TestEmployee.create!
+    employee.id.should == 10000
+  end
+
+  it "should use specified default sequence start value" do
+    ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.default_sequence_start_value = 1
+
+    create_test_employees_table
+    class TestEmployee < ActiveRecord::Base; end
+
+    employee = TestEmployee.create!
+    employee.id.should == 1
+  end
+
+  it "should use sequence start value from table definition" do
+    create_test_employees_table(10)
+    class TestEmployee < ActiveRecord::Base; end
+
+    employee = TestEmployee.create!
+    employee.id.should == 10
+  end
+
+  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 column comments" do
+
+  before(:all) do
+    ActiveRecord::Base.establish_connection(CONNECTION_PARAMS)
+    @conn = ActiveRecord::Base.connection
+  end
+
+  def create_test_employees_table(table_comment=nil, column_comments={})
+    ActiveRecord::Schema.define do
+      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
+  end
+
+  after(:each) do
+    ActiveRecord::Schema.define do
+      suppress_messages do
+        drop_table :test_employees
+      end
+    end
+    Object.send(:remove_const, "TestEmployee")
+    ActiveRecord::Base.table_name_prefix = nil
+  end
+
+  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
+
+  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 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
+
+describe "OracleEnhancedAdapter column quoting" do
+
+  before(:all) do
+    ActiveRecord::Base.establish_connection(CONNECTION_PARAMS)
+    @conn = ActiveRecord::Base.connection
+  end
+
+  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 "OracleEnhancedAdapter 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 "OracleEnhancedAdapter table quoting" do
+
+  before(:all) do
+    ActiveRecord::Base.establish_connection(CONNECTION_PARAMS)
+    @conn = ActiveRecord::Base.connection
+  end
+
+  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
+
+  after(:each) do
+    ActiveRecord::Schema.define do
+      suppress_messages do
+        drop_table "warehouse-things"
+      end
+    end
+    Object.send(:remove_const, "WarehouseThing")
+    ActiveRecord::Base.table_name_prefix = 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
+  end
+
+end