activerecord-oracle_enhanced-adapter 1.2.3 → 1.2.4

data/lib/active_record/connection_adapters/oracle_enhanced_jdbc_connection.rb

@@ -23,14 +23,7 @@ begin
 
 rescue LoadError, NameError
   # JDBC driver is unavailable.
-  error_message = "ERROR: ActiveRecord oracle_enhanced adapter could not load Oracle JDBC driver. "+
-                  "Please install ojdbc14.jar library."
-  if defined?(RAILS_DEFAULT_LOGGER)
-    RAILS_DEFAULT_LOGGER.error error_message
-  else
-    STDERR.puts error_message
-  end
-  raise LoadError
+  raise LoadError, "ERROR: ActiveRecord oracle_enhanced adapter could not load Oracle JDBC driver. Please install ojdbc14.jar library."
 end
 
 
@@ -53,46 +46,77 @@ module ActiveRecord
         new_connection(@config)
       end
 
+      # modified method to support JNDI connections
       def new_connection(config)
-        username, password, database = config[:username].to_s, config[:password].to_s, config[:database].to_s
-        privilege = config[:privilege] && config[:privilege].to_s
-        host, port = config[:host], config[:port]
-
-        # connection using TNS alias
-        if database && !host && !config[:url] && ENV['TNS_ADMIN']
-          url = "jdbc:oracle:thin:@#{database || 'XE'}"
+        username = nil
+  
+        if config[:jndi]
+          jndi = config[:jndi].to_s
+          ctx = javax.naming.InitialContext.new
+          ds = nil
+          
+          # tomcat needs first lookup method, oc4j (and maybe other application servers) need second method
+          begin
+            env = ctx.lookup('java:/comp/env')
+            ds = env.lookup(jndi)
+          rescue
+            ds = ctx.lookup(jndi)
+          end
+  
+          # check if datasource supports pooled connections, otherwise use default
+          if ds.respond_to?(:pooled_connection)
+            @raw_connection = ds.pooled_connection
+          else
+            @raw_connection = ds.connection
+          end
+  
+          config[:driver] ||= @raw_connection.meta_data.connection.java_class.name
+          username = @raw_connection.meta_data.user_name
         else
-          url = config[:url] || "jdbc:oracle:thin:@#{host || 'localhost'}:#{port || 1521}:#{database || 'XE'}"
+          username = config[:username].to_s
+          password, database = config[:password].to_s, config[:database].to_s
+          privilege = config[:privilege] && config[:privilege].to_s
+          host, port = config[:host], config[:port]
+  
+          # connection using TNS alias
+          if database && !host && !config[:url] && ENV['TNS_ADMIN']
+            url = "jdbc:oracle:thin:@#{database || 'XE'}"
+          else
+            url = config[:url] || "jdbc:oracle:thin:@#{host || 'localhost'}:#{port || 1521}:#{database || 'XE'}"
+          end
+  
+          prefetch_rows = config[:prefetch_rows] || 100
+          # get session time_zone from configuration or from TZ environment variable
+          time_zone = config[:time_zone] || ENV['TZ'] || java.util.TimeZone.default.getID
+  
+          properties = java.util.Properties.new
+          properties.put("user", username)
+          properties.put("password", password)
+          properties.put("defaultRowPrefetch", "#{prefetch_rows}") if prefetch_rows
+          properties.put("internal_logon", privilege) if privilege
+      
+          @raw_connection = java.sql.DriverManager.getConnection(url, properties)
+  
+          # Set session time zone to current time zone
+          @raw_connection.setSessionTimeZone(time_zone)
+  
+          # Set default number of rows to prefetch
+          # @raw_connection.setDefaultRowPrefetch(prefetch_rows) if prefetch_rows
         end
 
-        prefetch_rows = config[:prefetch_rows] || 100
-        cursor_sharing = config[:cursor_sharing] || 'force'
         # by default VARCHAR2 column size will be interpreted as max number of characters (and not bytes)
         nls_length_semantics = config[:nls_length_semantics] || 'CHAR'
-        # get session time_zone from configuration or from TZ environment variable
-        time_zone = config[:time_zone] || ENV['TZ'] || java.util.TimeZone.default.getID
-
-        properties = java.util.Properties.new
-        properties.put("user", username)
-        properties.put("password", password)
-        properties.put("defaultRowPrefetch", "#{prefetch_rows}") if prefetch_rows
-        properties.put("internal_logon", privilege) if privilege
-
-        @raw_connection = java.sql.DriverManager.getConnection(url, properties)
+        cursor_sharing = config[:cursor_sharing] || 'force'
+  
+        # from here it remaings common for both connections types
         exec %q{alter session set nls_date_format = 'YYYY-MM-DD HH24:MI:SS'}
         exec %q{alter session set nls_timestamp_format = 'YYYY-MM-DD HH24:MI:SS:FF6'}
         exec "alter session set cursor_sharing = #{cursor_sharing}"
         exec "alter session set nls_length_semantics = '#{nls_length_semantics}'"
         self.autocommit = true
-        
-        # Set session time zone to current time zone
-        @raw_connection.setSessionTimeZone(time_zone)
-        
-        # Set default number of rows to prefetch
-        # @raw_connection.setDefaultRowPrefetch(prefetch_rows) if prefetch_rows
-        
+  
         # default schema owner
-        @owner = username.upcase
+        @owner = username.upcase unless username.nil?
         
         @raw_connection
       end

data/lib/active_record/connection_adapters/oracle_enhanced_oci_connection.rb

@@ -1,24 +1,17 @@
 require 'delegate'
 
 begin
-  require 'oci8' unless self.class.const_defined? :OCI8
-
-  # added mapping for TIMESTAMP / WITH TIME ZONE / LOCAL TIME ZONE types
-  # latest version of Ruby-OCI8 supports fractional seconds for timestamps
-  # therefore default binding to Time class should be used
-  # OCI8::BindType::Mapping[OCI8::SQLT_TIMESTAMP] = OCI8::BindType::OraDate
-  # OCI8::BindType::Mapping[OCI8::SQLT_TIMESTAMP_TZ] = OCI8::BindType::OraDate
-  # OCI8::BindType::Mapping[OCI8::SQLT_TIMESTAMP_LTZ] = OCI8::BindType::OraDate
+  require "oci8"
 rescue LoadError
   # OCI8 driver is unavailable.
-  error_message = "ERROR: ActiveRecord oracle_enhanced adapter could not load ruby-oci8 library. "+
-                  "Please install ruby-oci8 library or gem."
-  if defined?(RAILS_DEFAULT_LOGGER)
-    RAILS_DEFAULT_LOGGER.error error_message
-  else
-    STDERR.puts error_message
-  end
-  raise LoadError
+  raise LoadError, "ERROR: ActiveRecord oracle_enhanced adapter could not load ruby-oci8 library. Please install ruby-oci8 gem."
+end
+
+# check ruby-oci8 version
+required_oci8_version = [2, 0, 3]
+oci8_version_ints = OCI8::VERSION.scan(/\d+/).map{|s| s.to_i}
+if (oci8_version_ints <=> required_oci8_version) < 0
+  raise LoadError, "ERROR: ruby-oci8 version #{OCI8::VERSION} is too old. Please install ruby-oci8 version #{required_oci8_version.join('.')} or later."
 end
 
 module ActiveRecord
@@ -156,10 +149,11 @@ module ActiveRecord
           value
         when String
           value
-        when Float
+        when Float, BigDecimal
+          # return Fixnum or Bignum if value is integer (to avoid issues with _before_type_cast values for id attributes)
           value == (v_to_i = value.to_i) ? v_to_i : value
-        # ruby-oci8 2.0 returns OraNumber if Oracle type is NUMBER
         when OraNumber
+          # change OraNumber value (returned in early versions of ruby-oci8 2.0.x) to BigDecimal
           value == (v_to_i = value.to_i) ? v_to_i : BigDecimal.new(value.to_s)
         when OCI8::LOB
           if get_lob_value
@@ -209,6 +203,7 @@ module ActiveRecord
           ::DateTime.civil(year, month, day, hour, min, sec, offset)
         end
       end
+
     end
     
     # The OracleEnhancedOCIFactory factors out the code necessary to connect and

data/lib/active_record/connection_adapters/oracle_enhanced_procedures.rb

@@ -4,7 +4,6 @@ ActiveRecord::Base.class_eval do
   class_inheritable_accessor :custom_create_method, :custom_update_method, :custom_delete_method
 end
 
-require 'ruby_plsql'
 require 'active_support'
 
 module ActiveRecord #:nodoc:
@@ -53,7 +52,7 @@ module ActiveRecord #:nodoc:
           self.custom_delete_method = block
         end
         
-        def create_method_name_before_custom_methods
+        def create_method_name_before_custom_methods #:nodoc:
           if private_method_defined?(:create_without_timestamps) && defined?(ActiveRecord::VERSION) && ActiveRecord::VERSION::STRING.to_f >= 2.3
             :create_without_timestamps
           elsif private_method_defined?(:create_without_callbacks)
@@ -63,7 +62,7 @@ module ActiveRecord #:nodoc:
           end
         end
         
-        def update_method_name_before_custom_methods
+        def update_method_name_before_custom_methods #:nodoc:
           if private_method_defined?(:update_without_dirty)
             :update_without_dirty
           elsif private_method_defined?(:update_without_timestamps) && defined?(ActiveRecord::VERSION) && ActiveRecord::VERSION::STRING.to_f >= 2.3
@@ -75,7 +74,7 @@ module ActiveRecord #:nodoc:
           end
         end
         
-        def destroy_method_name_before_custom_methods
+        def destroy_method_name_before_custom_methods #:nodoc:
           if public_method_defined?(:destroy_without_callbacks)
             :destroy_without_callbacks
           else

data/lib/active_record/connection_adapters/oracle_enhanced_schema_definitions.rb

@@ -6,6 +6,9 @@ module ActiveRecord
     class OracleEnhancedSynonymDefinition < Struct.new(:name, :table_owner, :table_name, :db_link) #:nodoc:
     end
 
+    class OracleEnhancedIndexDefinition < Struct.new(:table, :name, :unique, :tablespace, :columns) #:nodoc:
+    end
+
     module OracleEnhancedSchemaDefinitions #:nodoc:
       def self.included(base)
         base::TableDefinition.class_eval do

data/lib/active_record/connection_adapters/oracle_enhanced_schema_dumper.rb

@@ -26,7 +26,7 @@ module ActiveRecord #:nodoc:
           end
           # change table name inspect method
           tbl.extend TableInspect
-          table(tbl, stream)
+          oracle_enhanced_table(tbl, stream)
           # add primary key trigger if table has it
           primary_key_trigger(tbl, stream)
         end
@@ -94,6 +94,7 @@ module ActiveRecord #:nodoc:
             statment_parts << index.columns.inspect
             statment_parts << (':name => ' + index.name.inspect)
             statment_parts << ':unique => true' if index.unique
+            statment_parts << ':tablespace => ' + index.tablespace.inspect if index.tablespace
 
             '  ' + statment_parts.join(', ')
           end
@@ -103,6 +104,90 @@ module ActiveRecord #:nodoc:
         end
       end
 
+      def oracle_enhanced_table(table, stream)
+        columns = @connection.columns(table)
+        begin
+          tbl = StringIO.new
+
+          # first dump primary key column
+          if @connection.respond_to?(:pk_and_sequence_for)
+            pk, pk_seq = @connection.pk_and_sequence_for(table)
+          elsif @connection.respond_to?(:primary_key)
+            pk = @connection.primary_key(table)
+          end
+          
+          tbl.print "  create_table #{table.inspect}"
+          
+          # addition to make temporary option work
+          tbl.print ", :temporary => true" if @connection.temporary_table?(table)
+          
+          if columns.detect { |c| c.name == pk }
+            if pk != 'id'
+              tbl.print %Q(, :primary_key => "#{pk}")
+            end
+          else
+            tbl.print ", :id => false"
+          end
+          tbl.print ", :force => true"
+          tbl.puts " do |t|"
+
+          # then dump all non-primary key columns
+          column_specs = columns.map do |column|
+            raise StandardError, "Unknown type '#{column.sql_type}' for column '#{column.name}'" if @types[column.type].nil?
+            next if column.name == pk
+            spec = {}
+            spec[:name]      = column.name.inspect
+            spec[:type]      = column.type.to_s
+            spec[:limit]     = column.limit.inspect if column.limit != @types[column.type][:limit] && column.type != :decimal
+            spec[:precision] = column.precision.inspect if !column.precision.nil?
+            spec[:scale]     = column.scale.inspect if !column.scale.nil?
+            spec[:null]      = 'false' if !column.null
+            spec[:default]   = default_string(column.default) if column.has_default?
+            (spec.keys - [:name, :type]).each{ |k| spec[k].insert(0, "#{k.inspect} => ")}
+            spec
+          end.compact
+
+          # find all migration keys used in this table
+          keys = [:name, :limit, :precision, :scale, :default, :null] & column_specs.map(&:keys).flatten
+
+          # figure out the lengths for each column based on above keys
+          lengths = keys.map{ |key| column_specs.map{ |spec| spec[key] ? spec[key].length + 2 : 0 }.max }
+
+          # the string we're going to sprintf our values against, with standardized column widths
+          format_string = lengths.map{ |len| "%-#{len}s" }
+
+          # find the max length for the 'type' column, which is special
+          type_length = column_specs.map{ |column| column[:type].length }.max
+
+          # add column type definition to our format string
+          format_string.unshift "    t.%-#{type_length}s "
+
+          format_string *= ''
+
+          column_specs.each do |colspec|
+            values = keys.zip(lengths).map{ |key, len| colspec.key?(key) ? colspec[key] + ", " : " " * len }
+            values.unshift colspec[:type]
+            tbl.print((format_string % values).gsub(/,\s*$/, ''))
+            tbl.puts
+          end
+
+          tbl.puts "  end"
+          tbl.puts
+          
+          indexes(table, tbl)
+
+          tbl.rewind
+          stream.print tbl.read
+        rescue => e
+          stream.puts "# Could not dump table #{table.inspect} because of following #{e.class}"
+          stream.puts "#   #{e.message}"
+          stream.puts
+        end
+        
+        stream
+      end
+      
+      
       # remove table name prefix and suffix when doing #inspect (which is used in tables method)
       module TableInspect #:nodoc:
         def inspect

data/spec/active_record/connection_adapters/oracle_enhanced_adapter_spec.rb

@@ -249,18 +249,30 @@ describe "OracleEnhancedAdapter" do
   describe "without composite_primary_keys" do
 
     before(:all) do
+      @conn.execute "DROP TABLE test_employees" rescue nil
+      @conn.execute <<-SQL
+        CREATE TABLE test_employees (
+          employee_id   NUMBER PRIMARY KEY,
+          name          VARCHAR2(50)
+        )
+      SQL
       Object.send(:remove_const, 'CompositePrimaryKeys') if defined?(CompositePrimaryKeys)
-      class ::Employee < ActiveRecord::Base
+      class ::TestEmployee < ActiveRecord::Base
         set_primary_key :employee_id
       end
     end
 
+    after(:all) do
+      Object.send(:remove_const, "TestEmployee")
+      @conn.execute "DROP TABLE test_employees"
+    end
+
     it "should tell ActiveRecord that count distinct is supported" do
       ActiveRecord::Base.connection.supports_count_distinct?.should be_true
     end
 
     it "should execute correct SQL COUNT DISTINCT statement" do
-      lambda { Employee.count(:employee_id, :distinct => true) }.should_not raise_error
+      lambda { TestEmployee.count(:employee_id, :distinct => true) }.should_not raise_error
     end
 
   end
@@ -445,4 +457,21 @@ describe "OracleEnhancedAdapter" do
     end
   end
 
+  describe "temporary tables" do
+    
+    after(:each) do
+      @conn.drop_table :foos rescue nil
+    end
+    it "should create ok" do
+      @conn.create_table :foos, :temporary => true, :id => false do |t|
+        t.integer :id
+      end
+    end
+    it "should show up as temporary" do
+      @conn.create_table :foos, :temporary => true, :id => false do |t|
+        t.integer :id
+      end
+      @conn.temporary_table?("foos").should be_true
+    end
+  end
 end

data/spec/active_record/connection_adapters/oracle_enhanced_adapter_structure_dumper_spec.rb

@@ -0,0 +1,267 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+
+describe "OracleEnhancedAdapter structure dump" do
+  include LoggerSpecHelper
+
+  before(:all) do
+    ActiveRecord::Base.establish_connection(CONNECTION_PARAMS)
+    @conn = ActiveRecord::Base.connection
+  end
+  describe "structure dump" do
+    before(:each) do
+      @conn.create_table :test_posts, :force => true do |t|
+        t.string      :title
+        t.string      :foo
+        t.integer     :foo_id
+      end
+      @conn.create_table :foos do |t|
+      end
+      class ::TestPost < ActiveRecord::Base
+      end
+      TestPost.set_table_name "test_posts"
+    end
+  
+    after(:each) do
+      @conn.drop_table :test_posts 
+      @conn.drop_table :foos
+      @conn.execute "DROP SEQUENCE test_posts_seq" rescue nil
+      @conn.execute "ALTER TABLE test_posts drop CONSTRAINT fk_test_post_foo" rescue nil
+      @conn.execute "DROP TRIGGER test_post_trigger" rescue nil
+      @conn.execute "DROP TYPE TEST_TYPE" rescue nil
+      @conn.execute "DROP TABLE bars" rescue nil
+    end
+  
+    it "should dump single primary key" do
+      dump = ActiveRecord::Base.connection.structure_dump
+      dump.should =~ /CONSTRAINT (.+) PRIMARY KEY \(ID\)\n/
+    end
+  
+    it "should dump composite primary keys" do
+      pk = @conn.send(:select_one, <<-SQL)
+        select constraint_name from user_constraints where table_name = 'TEST_POSTS' and constraint_type='P'
+      SQL
+      @conn.execute <<-SQL
+        alter table test_posts drop constraint #{pk["constraint_name"]}
+      SQL
+      @conn.execute <<-SQL
+        ALTER TABLE TEST_POSTS
+        add CONSTRAINT pk_id_title PRIMARY KEY (id, title)
+      SQL
+      dump = ActiveRecord::Base.connection.structure_dump
+      dump.should =~ /CONSTRAINT (.+) PRIMARY KEY \(ID,TITLE\)\n/
+    end
+  
+    it "should dump foreign keys" do
+      @conn.execute <<-SQL
+        ALTER TABLE TEST_POSTS 
+        ADD CONSTRAINT fk_test_post_foo FOREIGN KEY (foo_id) REFERENCES foos(id)
+      SQL
+      dump = ActiveRecord::Base.connection.structure_dump_fk_constraints
+      dump.split('\n').length.should == 1
+      dump.should =~ /ALTER TABLE TEST_POSTS ADD CONSTRAINT fk_test_post_foo FOREIGN KEY \(foo_id\) REFERENCES foos\(id\)/
+    end
+  
+    it "should not error when no foreign keys are present" do
+      dump = ActiveRecord::Base.connection.structure_dump_fk_constraints
+      dump.split('\n').length.should == 0
+      dump.should == ''
+    end
+  
+    it "should dump triggers" do
+      @conn.execute <<-SQL
+        create or replace TRIGGER TEST_POST_TRIGGER
+          BEFORE INSERT
+          ON TEST_POSTS
+          FOR EACH ROW
+        BEGIN
+          SELECT 'bar' INTO :new.FOO FROM DUAL;
+        END;
+      SQL
+      dump = ActiveRecord::Base.connection.structure_dump_db_stored_code.gsub(/\n|\s+/,' ')
+      dump.should =~ /create or replace TRIGGER TEST_POST_TRIGGER/
+    end
+  
+    it "should dump types" do
+      @conn.execute <<-SQL
+        create or replace TYPE TEST_TYPE AS TABLE OF VARCHAR2(10);
+      SQL
+      dump = ActiveRecord::Base.connection.structure_dump_db_stored_code.gsub(/\n|\s+/,' ')
+      dump.should =~ /create or replace TYPE TEST_TYPE/
+    end
+  
+    it "should dump virtual columns" do
+      pending "Not supported in this database version" unless @conn.select_value("SELECT * FROM v$version WHERE banner LIKE 'Oracle%11g%'")
+      @conn.execute <<-SQL
+        CREATE TABLE bars (
+          id          NUMBER(38,0) NOT NULL,
+          id_plus     NUMBER GENERATED ALWAYS AS(id + 2) VIRTUAL,
+          PRIMARY KEY (ID)
+        )
+      SQL
+      dump = ActiveRecord::Base.connection.structure_dump
+      dump.should =~ /id_plus number GENERATED ALWAYS AS \(ID\+2\) VIRTUAL/
+    end
+  
+    it "should dump unique keys" do
+      @conn.execute <<-SQL
+        ALTER TABLE test_posts
+          add CONSTRAINT uk_foo_foo_id UNIQUE (foo, foo_id)
+      SQL
+      dump = ActiveRecord::Base.connection.structure_dump_unique_keys("test_posts")
+      dump.should == [" CONSTRAINT UK_FOO_FOO_ID UNIQUE (FOO,FOO_ID)"]
+    
+      dump = ActiveRecord::Base.connection.structure_dump
+      dump.should =~ /CONSTRAINT UK_FOO_FOO_ID UNIQUE \(FOO,FOO_ID\)/
+    end
+  
+    it "should dump indexes" do
+      ActiveRecord::Base.connection.add_index(:test_posts, :foo, :name => :ix_test_posts_foo)
+      ActiveRecord::Base.connection.add_index(:test_posts, :foo_id, :name => :ix_test_posts_foo_id, :unique => true)
+      
+      @conn.execute <<-SQL
+        ALTER TABLE test_posts
+          add CONSTRAINT uk_foo_foo_id UNIQUE (foo, foo_id)
+      SQL
+      
+      dump = ActiveRecord::Base.connection.structure_dump
+      dump.should =~ /create unique index ix_test_posts_foo_id on test_posts \(foo_id\)/i
+      dump.should =~ /create  index ix_test_posts_foo on test_posts \(foo\)/i
+      dump.should_not =~ /create unique index uk_test_posts_/i
+    end
+  end
+  describe "temporary tables" do
+    after(:all) do
+      @conn.drop_table :test_comments rescue nil
+    end
+    it "should dump correctly" do
+      @conn.create_table :test_comments, :temporary => true, :id => false do |t|
+        t.integer :post_id
+      end
+      dump = ActiveRecord::Base.connection.structure_dump
+      dump.should =~ /create global temporary table test_comments/i
+    end
+  end
+
+  describe "database stucture dump extentions" do
+    before(:all) do
+      @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 "temp_table_drop" do
+    before(:each) do
+      @conn.create_table :temp_tbl, :temporary => true do |t|
+        t.string :foo
+      end
+      @conn.create_table :not_temp_tbl do |t|
+        t.string :foo
+      end
+    end
+    it "should dump drop sql for just temp tables" do
+      dump = @conn.temp_table_drop
+      dump.should =~ /drop table temp_tbl/i
+      dump.should_not =~ /drop table not_temp_tbl/i
+    end
+    after(:each) do
+      @conn.drop_table :temp_tbl 
+      @conn.drop_table :not_temp_tbl
+    end
+  end
+  
+  describe "full drop" do
+    before(:each) do 
+      @conn.create_table :full_drop_test do |t|
+        t.integer :id
+      end
+      @conn.create_table :full_drop_test_temp, :temporary => true do |t|
+        t.string :foo
+      end
+      #view
+      @conn.execute <<-SQL
+        create or replace view full_drop_test_view (foo) as select id as "foo" from full_drop_test
+      SQL
+      #package
+      @conn.execute <<-SQL
+        create or replace package full_drop_test_package as
+          function test_func return varchar2;
+        end test_package;
+      SQL
+      @conn.execute <<-SQL
+        create or replace package body full_drop_test_package as 
+          function test_func return varchar2 is
+            begin
+              return ('foo');
+          end test_func;
+        end test_package;
+      SQL
+      #function
+      @conn.execute <<-SQL
+        create or replace function full_drop_test_function
+          return varchar2 
+        is
+          foo varchar2(3);
+        begin 
+          return('foo');
+        end;
+      SQL
+      #procedure
+      @conn.execute <<-SQL
+        create or replace procedure full_drop_test_procedure
+        begin
+          delete from full_drop_test where id=1231231231
+        exception
+        when no_data_found then
+          dbms_output.put_line('foo');
+        end;
+      SQL
+      #synonym
+      @conn.execute <<-SQL
+        create or replace synonym full_drop_test_synonym for full_drop_test
+      SQL
+      #type
+      @conn.execute <<-SQL
+        create or replace type full_drop_test_type as table of number
+      SQL
+    end
+    after(:each) do
+      @conn.drop_table :full_drop_test
+      @conn.drop_table :full_drop_test_temp
+      @conn.execute "DROP VIEW FULL_DROP_TEST_VIEW" rescue nil
+      @conn.execute "DROP SYNONYM FULL_DROP_TEST_SYNONYM" rescue nil
+      @conn.execute "DROP PACKAGE FULL_DROP_TEST_PACKAGE" rescue nil
+      @conn.execute "DROP FUNCTION FULL_DROP_TEST_FUNCTION" rescue nil
+      @conn.execute "DROP PROCEDURE FULL_DROP_TEST_PROCEDURE" rescue nil
+      @conn.execute "DROP TYPE FULL_DROP_TEST_TYPE" rescue nil
+    end
+    it "should contain correct sql" do
+      drop = @conn.full_drop
+      drop.should =~ /drop table full_drop_test cascade constraints/i
+      drop.should =~ /drop sequence full_drop_test_seq/i
+      drop.should =~ /drop view "full_drop_test_view"/i
+      drop.should =~ /drop package full_drop_test_package/i
+      drop.should =~ /drop function full_drop_test_function/i
+      drop.should =~ /drop procedure full_drop_test_procedure/i
+      drop.should =~ /drop synonym "full_drop_test_synonym"/i
+      drop.should =~ /drop type "full_drop_test_type"/i
+    end
+    it "should not drop tables when preserve_tables is true" do
+      drop = @conn.full_drop(true)
+      drop.should =~ /drop table full_drop_test_temp/i
+      drop.should_not =~ /drop table full_drop_test cascade constraints/i
+    end
+  end
+end