activerecord-oracle_enhanced-adapter 1.7.11 → 1.8.0.beta1

data/lib/active_record/connection_adapters/oracle_enhanced/schema_definitions.rb

@@ -1,14 +1,32 @@
 module ActiveRecord
   module ConnectionAdapters
     module OracleEnhanced
-      class ForeignKeyDefinition < ActiveRecord::ConnectionAdapters::ForeignKeyDefinition
-        def name
-          if options[:name].length > OracleEnhancedAdapter::IDENTIFIER_MAX_LENGTH
-            ActiveSupport::Deprecation.warn "Foreign key name #{options[:name]} is too long. It will not get shorten in later version of Oracle enhanced adapter"
-            'c'+Digest::SHA1.hexdigest(options[:name])[0,OracleEnhancedAdapter::IDENTIFIER_MAX_LENGTH-1]
-          else
-            options[:name]
-          end
+      module ColumnMethods
+        def primary_key(name, type = :primary_key, **options)
+          # This is a placeholder for future :auto_increment support
+          super
+        end
+
+        [
+          :raw
+        ].each do |column_type|
+          module_eval <<-CODE, __FILE__, __LINE__ + 1
+            def #{column_type}(*args, **options)
+              args.each { |name| column(name, :#{column_type}, options) }
+            end
+          CODE
+        end
+      end
+
+      class ReferenceDefinition < ActiveRecord::ConnectionAdapters::ReferenceDefinition # :nodoc:
+        def initialize(
+          name,
+          polymorphic: false,
+          index: true,
+          foreign_key: false,
+          type: :integer,
+          **options)
+          super
         end
       end
 
@@ -26,10 +44,9 @@ module ActiveRecord
         end
       end
 
-      class ColumnDefinition < ActiveRecord::ConnectionAdapters::ColumnDefinition
-      end
-
       class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
+        include ActiveRecord::ConnectionAdapters::OracleEnhanced::ColumnMethods
+
         attr_accessor :tablespace, :organization
         def initialize(name, temporary = false, options = nil, as = nil, tablespace = nil, organization = nil, comment: nil)
           @tablespace = tablespace
@@ -37,51 +54,20 @@ module ActiveRecord
           super(name, temporary, options, as, comment: comment)
         end
 
-        def virtual(* args)
-          options = args.extract_options!
-          column_names = args
-          column_names.each { |name| column(name, :virtual, options) }
-        end
-
-        def column(name, type, options = {})
+        def new_column_definition(name, type, **options) # :nodoc:
           if type == :virtual
-            default = {:type => options[:type]}
-            if options[:as]
-              default[:as] = options[:as]
-            elsif options[:default]
-              warn "[DEPRECATION] virtual column `:default` option is deprecated.  Please use `:as` instead."
-              default[:as] = options[:default]
-            else
-              raise "No virtual column definition found."
-            end
-            options[:default] = default
+            raise "No virtual column definition found." unless options[:as]
+            type = options[:type]
           end
-          super(name, type, options)
-        end
-
-        private
-        def create_column_definition(name, type)
-          OracleEnhanced::ColumnDefinition.new name, type
+          super
         end
       end
 
       class AlterTable < ActiveRecord::ConnectionAdapters::AlterTable
-        def add_foreign_key(to_table, options)
-          @foreign_key_adds << OracleEnhanced::ForeignKeyDefinition.new(name, to_table, options)
-        end
       end
 
       class Table < ActiveRecord::ConnectionAdapters::Table
-        def foreign_key(to_table, options = {})
-          ActiveSupport::Deprecation.warn "`foreign_key` option will be deprecated. Please use `references` option"
-          to_table = to_table.to_s.pluralize if ActiveRecord::Base.pluralize_table_names
-          @base.add_foreign_key(@name, to_table, options)
-        end
-
-        def remove_foreign_key(options = {})
-          ActiveSupport::Deprecation.warn "`remove_foreign_key` option will be deprecated. Please use `remove_references` option"
-          @base.remove_foreign_key(@name, options)
-        end
+        include ActiveRecord::ConnectionAdapters::OracleEnhanced::ColumnMethods
       end
     end
   end

data/lib/active_record/connection_adapters/oracle_enhanced/schema_dumper.rb

@@ -4,199 +4,186 @@ module ActiveRecord #:nodoc:
       module SchemaDumper #:nodoc:
         private
 
-        def tables(stream)
-          return super unless @connection.respond_to?(:materialized_views)
-          # do not include materialized views in schema dump - they should be created separately after schema creation
-          sorted_tables = (@connection.data_sources - @connection.materialized_views).sort
-          sorted_tables.each do |tbl|
-            # add table prefix or suffix for schema_migrations
-            next if ignored? tbl
-            # change table name inspect method
-            tbl.extend TableInspect
-            table(tbl, stream)
-            # add primary key trigger if table has it
-            primary_key_trigger(tbl, stream)
-          end
-          # following table definitions
-          # add foreign keys if table has them
-          sorted_tables.each do |tbl|
-            next if ignored? tbl
-            foreign_keys(tbl, stream)
-          end
+          def tables(stream)
+            return super unless @connection.respond_to?(:materialized_views)
+            # do not include materialized views in schema dump - they should be created separately after schema creation
+            sorted_tables = (@connection.tables - @connection.materialized_views).sort
+            sorted_tables.each do |tbl|
+              # add table prefix or suffix for schema_migrations
+              next if ignored? tbl
+              # change table name inspect method
+              tbl.extend TableInspect
+              table(tbl, stream)
+              # add primary key trigger if table has it
+              primary_key_trigger(tbl, stream)
+            end
+            # following table definitions
+            # add foreign keys if table has them
+            sorted_tables.each do |tbl|
+              next if ignored? tbl
+              foreign_keys(tbl, stream)
+            end
 
-          # add synonyms in local schema
-          synonyms(stream)
-        end
+            # add synonyms in local schema
+            synonyms(stream)
+          end
 
-        def primary_key_trigger(table_name, stream)
-          if @connection.respond_to?(:has_primary_key_trigger?) && @connection.has_primary_key_trigger?(table_name)
-            pk, _pk_seq = @connection.pk_and_sequence_for(table_name)
-            stream.print "  add_primary_key_trigger #{table_name.inspect}"
-            stream.print ", primary_key: \"#{pk}\"" if pk != 'id'
-            stream.print "\n\n"
+          def primary_key_trigger(table_name, stream)
+            if @connection.respond_to?(:has_primary_key_trigger?) && @connection.has_primary_key_trigger?(table_name)
+              pk, _pk_seq = @connection.pk_and_sequence_for(table_name)
+              stream.print "  add_primary_key_trigger #{table_name.inspect}"
+              stream.print ", primary_key: \"#{pk}\"" if pk != "id"
+              stream.print "\n\n"
+            end
           end
-        end
-
-        def synonyms(stream)
-          if @connection.respond_to?(:synonyms)
-            syns = @connection.synonyms
-            syns.each do |syn|
-              next if ignored? syn.name
-              table_name = syn.table_name
-              table_name = "#{syn.table_owner}.#{table_name}" if syn.table_owner
-              table_name = "#{table_name}@#{syn.db_link}" if syn.db_link
-              stream.print "  add_synonym #{syn.name.inspect}, #{table_name.inspect}, force: true"
-              stream.puts
+
+          def synonyms(stream)
+            if @connection.respond_to?(:synonyms)
+              syns = @connection.synonyms
+              syns.each do |syn|
+                next if ignored? syn.name
+                table_name = syn.table_name
+                table_name = "#{syn.table_owner}.#{table_name}" if syn.table_owner
+                table_name = "#{table_name}@#{syn.db_link}" if syn.db_link
+                stream.print "  add_synonym #{syn.name.inspect}, #{table_name.inspect}, force: true"
+                stream.puts
+              end
+              stream.puts unless syns.empty?
             end
-            stream.puts unless syns.empty?
           end
-        end
-
-        def indexes(table, stream)
-          if (indexes = @connection.indexes(table)).any?
-            add_index_statements = indexes.map do |index|
-              case index.type
-              when nil
-                # use table.inspect as it will remove prefix and suffix
-                statement_parts = [ ('add_index ' + table.inspect) ]
-                statement_parts << index.columns.inspect
-                statement_parts << ('name: ' + index.name.inspect)
-                statement_parts << 'unique: true' if index.unique
-                statement_parts << 'tablespace: ' + index.tablespace.inspect if index.tablespace
-              when 'CTXSYS.CONTEXT'
-                if index.statement_parameters
-                  statement_parts = [ ('add_context_index ' + table.inspect) ]
-                  statement_parts << index.statement_parameters
+
+          def indexes(table, stream)
+            if (indexes = @connection.indexes(table)).any?
+              add_index_statements = indexes.map do |index|
+                case index.type
+                when nil
+                  # do nothing here. see indexes_in_create
+                  statement_parts = []
+                when "CTXSYS.CONTEXT"
+                  if index.statement_parameters
+                    statement_parts = [ ("add_context_index " + table.inspect) ]
+                    statement_parts << index.statement_parameters
+                  else
+                    statement_parts = [ ("add_context_index " + table.inspect) ]
+                    statement_parts << index.columns.inspect
+                    statement_parts << ("name: " + index.name.inspect)
+                  end
                 else
-                  statement_parts = [ ('add_context_index ' + table.inspect) ]
-                  statement_parts << index.columns.inspect
-                  statement_parts << ('name: ' + index.name.inspect)
+                  # unrecognized index type
+                  statement_parts = ["# unrecognized index #{index.name.inspect} with type #{index.type.inspect}"]
                 end
-              else
-                # unrecognized index type
-                statement_parts = ["# unrecognized index #{index.name.inspect} with type #{index.type.inspect}"]
+                "  " + statement_parts.join(", ")
               end
-              '  ' + statement_parts.join(', ')
-            end
 
-            stream.puts add_index_statements.sort.join("\n")
-            stream.puts
+              stream.puts add_index_statements.sort.join("\n")
+              stream.puts
+            end
           end
-        end
-
-        def table(table, stream)
-          return super unless @connection.respond_to?(:temporary_table?)
-          columns = @connection.columns(table)
-          begin
-            tbl = StringIO.new
-
-            # first dump primary key column
-            if @connection.respond_to?(:primary_keys)
-              pk = @connection.primary_keys(table)
-              pk = pk.first unless pk.size > 1
-            else
-              pk = @connection.primary_key(table)
+
+          def indexes_in_create(table, stream)
+            if (indexes = @connection.indexes(table)).any?
+              index_statements = indexes.map do |index|
+                "    t.index #{index_parts(index).join(', ')}" unless index.type == "CTXSYS.CONTEXT"
+              end
+              stream.puts index_statements.sort.join("\n")
             end
+          end
 
-            tbl.print "  create_table #{table.inspect}"
+          def index_parts(index)
+            index_parts = super
+            index_parts << "tablespace: #{index.tablespace.inspect}" if index.tablespace
+            index_parts
+          end
 
-            # addition to make temporary option work
-            tbl.print ", temporary: true" if @connection.temporary_table?(table)
+          def table(table, stream)
+            return super unless @connection.respond_to?(:temporary_table?)
+            columns = @connection.columns(table)
+            begin
+              tbl = StringIO.new
 
-            table_comments = @connection.table_comment(table)
-            unless table_comments.nil?
-              tbl.print ", comment: #{table_comments.inspect}"
-            end
-
-            case pk
-            when String
-              tbl.print ", primary_key: #{pk.inspect}" unless pk == 'id'
-              pkcol = columns.detect { |c| c.name == pk }
-              pkcolspec = @connection.column_spec_for_primary_key(pkcol)
-              if pkcolspec.present?
-                pkcolspec.each do |key, value|
-                  tbl.print ", #{key}: #{value}"
-                end
+              # first dump primary key column
+              if @connection.respond_to?(:primary_keys)
+                pk = @connection.primary_keys(table)
+                pk = pk.first unless pk.size > 1
+              else
+                pk = @connection.primary_key(table)
               end
-            when Array
-              tbl.print ", primary_key: #{pk.inspect}"
-            else
-              tbl.print ", id: false"
-            end
 
-            tbl.print ", force: :cascade"
-            tbl.puts " do |t|"
+              tbl.print "  create_table #{table.inspect}"
 
-            # then dump all non-primary key columns
-            column_specs = columns.map do |column|
-              raise StandardError, "Unknown type '#{column.sql_type}' for column '#{column.name}'" unless @connection.valid_type?(column.type)
-              next if column.name == pk
-              @connection.column_spec(column)
-            end.compact
+              # addition to make temporary option work
+              tbl.print ", temporary: true" if @connection.temporary_table?(table)
 
-            # find all migration keys used in this table
-            #
-            # TODO `& column_specs.map(&:keys).flatten` should be executed
-            # in migration_keys_with_oracle_enhanced
-            keys = @connection.migration_keys & column_specs.map(&:keys).flatten
+              case pk
+              when String
+                tbl.print ", primary_key: #{pk.inspect}" unless pk == "id"
+                pkcol = columns.detect { |c| c.name == pk }
+                pkcolspec = @connection.column_spec_for_primary_key(pkcol)
+                if pkcolspec.present?
+                  tbl.print ", #{format_colspec(pkcolspec)}"
+                end
+              when Array
+                tbl.print ", primary_key: #{pk.inspect}"
+              else
+                tbl.print ", id: false"
+              end
 
-            # 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 }
+              tbl.print ", force: :cascade"
 
-            # the string we're going to sprintf our values against, with standardized column widths
-            format_string = lengths.map{ |len| "%-#{len}s" }
+              table_comments = @connection.table_comment(table)
+              unless table_comments.blank?
+                tbl.print ", comment: #{table_comments.inspect}"
+              end
 
-            # find the max length for the 'type' column, which is special
-            type_length = column_specs.map{ |column| column[:type].length }.max
+              tbl.puts " do |t|"
 
-            # add column type definition to our format string
-            format_string.unshift "    t.%-#{type_length}s "
+              # then dump all non-primary key columns
+              columns.each do |column|
+                raise StandardError, "Unknown type '#{column.sql_type}' for column '#{column.name}'" unless @connection.valid_type?(column.type)
+                next if column.name == pk
+                type, colspec = @connection.column_spec(column)
+                tbl.print "    t.#{type} #{column.name.inspect}"
+                tbl.print ", #{format_colspec(colspec)}" if colspec.present?
+                tbl.puts
+              end
 
-            format_string *= ''
+              indexes_in_create(table, tbl)
 
-            # dirty hack to replace virtual_type: with type:
-            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*$/, '').gsub(/virtual_type:/, "type:"))
+              tbl.puts "  end"
               tbl.puts
-            end
 
-            tbl.puts "  end"
-            tbl.puts
+              indexes(table, tbl)
 
-            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
 
-            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
+            stream
           end
 
-          stream
-        end
-
-        def remove_prefix_and_suffix(table)
-          table.gsub(/^(#{ActiveRecord::Base.table_name_prefix})(.+)(#{ActiveRecord::Base.table_name_suffix})$/,  "\\2")
-        end
-
-        # remove table name prefix and suffix when doing #inspect (which is used in tables method)
-        module TableInspect #:nodoc:
-          def inspect
-            remove_prefix_and_suffix(self)
+          def remove_prefix_and_suffix(table)
+            table.gsub(/^(#{ActiveRecord::Base.table_name_prefix})(.+)(#{ActiveRecord::Base.table_name_suffix})$/,  "\\2")
           end
 
-          private
-          def remove_prefix_and_suffix(table_name)
-            if table_name =~ /\A#{ActiveRecord::Base.table_name_prefix.to_s.gsub('$','\$')}(.*)#{ActiveRecord::Base.table_name_suffix.to_s.gsub('$','\$')}\Z/
-              "\"#{$1}\""
-            else
-              "\"#{table_name}\""
+          # remove table name prefix and suffix when doing #inspect (which is used in tables method)
+          module TableInspect #:nodoc:
+            def inspect
+              remove_prefix_and_suffix(self)
             end
+
+            private
+              def remove_prefix_and_suffix(table_name)
+                if table_name =~ /\A#{ActiveRecord::Base.table_name_prefix.to_s.gsub('$', '\$')}(.*)#{ActiveRecord::Base.table_name_suffix.to_s.gsub('$', '\$')}\Z/
+                  "\"#{$1}\""
+                else
+                  "\"#{table_name}\""
+                end
+              end
           end
-        end
       end
     end
   end