unclebilly-activerecord-oracle_enhanced-adapter 1.2.4

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

@@ -0,0 +1,177 @@
+module ActiveRecord
+  module ConnectionAdapters
+    class OracleEnhancedForeignKeyDefinition < Struct.new(:from_table, :to_table, :options) #:nodoc:
+    end
+
+    class OracleEnhancedSynonymDefinition < Struct.new(:name, :table_owner, :table_name, :db_link) #:nodoc:
+    end
+
+    class OracleEnhancedIndexDefinition < Struct.new(:table, :name, :unique, :tablespace, :columns)
+    end
+
+    class OracleEnhancedColumnDefinition < ColumnDefinition
+      def to_sql
+        return super unless type==:virtual
+        #virtual column syntax
+        "#{base.quote_column_name(name)} AS (#{default})"
+      end
+      alias to_s :to_sql
+    end
+
+    module OracleEnhancedSchemaDefinitions #:nodoc:
+      def self.included(base)
+        base::TableDefinition.class_eval do
+          include OracleEnhancedTableDefinition
+        end
+        
+        # Available starting from ActiveRecord 2.1
+        base::Table.class_eval do
+          include OracleEnhancedTable
+        end if defined?(base::Table)
+      end
+    end
+  
+    module OracleEnhancedTableDefinition
+      class ForeignKey < Struct.new(:base, :to_table, :options) #:nodoc:
+        def to_sql
+          base.foreign_key_definition(to_table, options)
+        end
+        alias to_s :to_sql
+      end
+
+      def self.included(base) #:nodoc:
+        base.class_eval do
+          alias_method_chain :references, :foreign_keys
+          alias_method_chain :to_sql, :foreign_keys
+        end
+      end
+    
+      # Adds a :foreign_key option to TableDefinition.references.
+      # If :foreign_key is true, a foreign key constraint is added to the table.
+      # You can also specify a hash, which is passed as foreign key options.
+      # 
+      # ===== Examples
+      # ====== Add goat_id column and a foreign key to the goats table.
+      #  t.references(:goat, :foreign_key => true)
+      # ====== Add goat_id column and a cascading foreign key to the goats table.
+      #  t.references(:goat, :foreign_key => {:dependent => :delete})
+      # 
+      # Note: No foreign key is created if :polymorphic => true is used.
+      # Note: If no name is specified, the database driver creates one for you!
+      def references_with_foreign_keys(*args)
+        options = args.extract_options!
+        fk_options = options.delete(:foreign_key)
+
+        if fk_options && !options[:polymorphic]
+          fk_options = {} if fk_options == true
+          args.each { |to_table| foreign_key(to_table, fk_options) }
+        end
+
+        references_without_foreign_keys(*(args << options))
+      end
+  
+      # Defines a foreign key for the table. +to_table+ can be a single Symbol, or
+      # an Array of Symbols. See SchemaStatements#add_foreign_key
+      #
+      # ===== Examples
+      # ====== Creating a simple foreign key
+      #  t.foreign_key(:people)
+      # ====== Defining the column
+      #  t.foreign_key(:people, :column => :sender_id)
+      # ====== Creating a named foreign key
+      #  t.foreign_key(:people, :column => :sender_id, :name => 'sender_foreign_key')
+      # ====== Defining the column of the +to_table+.
+      #  t.foreign_key(:people, :column => :sender_id, :primary_key => :person_id)
+      def foreign_key(to_table, options = {})
+        if @base.respond_to?(:supports_foreign_keys?) && @base.supports_foreign_keys?
+          to_table = to_table.to_s.pluralize if ActiveRecord::Base.pluralize_table_names
+          foreign_keys << ForeignKey.new(@base, to_table, options)
+        else
+          raise ArgumentError, "this ActiveRecord adapter is not supporting foreign_key definition"
+        end
+      end
+    
+      def to_sql_with_foreign_keys #:nodoc:
+        sql = to_sql_without_foreign_keys
+        sql << ', ' << (foreign_keys * ', ') unless foreign_keys.blank?
+        sql
+      end
+    
+      private
+        def foreign_keys
+          @foreign_keys ||= []
+        end
+    end
+
+    module OracleEnhancedTable
+      def self.included(base) #:nodoc:
+        base.class_eval do
+          alias_method_chain :references, :foreign_keys
+        end
+      end
+
+      # Adds a new foreign key to the table. +to_table+ can be a single Symbol, or
+      # an Array of Symbols. See SchemaStatements#add_foreign_key
+      #
+      # ===== Examples
+      # ====== Creating a simple foreign key
+      #  t.foreign_key(:people)
+      # ====== Defining the column
+      #  t.foreign_key(:people, :column => :sender_id)
+      # ====== Creating a named foreign key
+      #  t.foreign_key(:people, :column => :sender_id, :name => 'sender_foreign_key')
+      # ====== Defining the column of the +to_table+.
+      #  t.foreign_key(:people, :column => :sender_id, :primary_key => :person_id)
+      def foreign_key(to_table, options = {})
+        if @base.respond_to?(:supports_foreign_keys?) && @base.supports_foreign_keys?
+          to_table = to_table.to_s.pluralize if ActiveRecord::Base.pluralize_table_names
+          @base.add_foreign_key(@table_name, to_table, options)
+        else
+          raise ArgumentError, "this ActiveRecord adapter is not supporting foreign_key definition"
+        end
+      end
+  
+      # Remove the given foreign key from the table.
+      #
+      # ===== Examples
+      # ====== Remove the suppliers_company_id_fk in the suppliers table.
+      #   t.remove_foreign_key :companies
+      # ====== Remove the foreign key named accounts_branch_id_fk in the accounts table.
+      #   remove_foreign_key :column => :branch_id
+      # ====== Remove the foreign key named party_foreign_key in the accounts table.
+      #   remove_index :name => :party_foreign_key
+      def remove_foreign_key(options = {})
+        @base.remove_foreign_key(@table_name, options)
+      end
+    
+      # Adds a :foreign_key option to TableDefinition.references.
+      # If :foreign_key is true, a foreign key constraint is added to the table.
+      # You can also specify a hash, which is passed as foreign key options.
+      # 
+      # ===== Examples
+      # ====== Add goat_id column and a foreign key to the goats table.
+      #  t.references(:goat, :foreign_key => true)
+      # ====== Add goat_id column and a cascading foreign key to the goats table.
+      #  t.references(:goat, :foreign_key => {:dependent => :delete})
+      # 
+      # Note: No foreign key is created if :polymorphic => true is used.
+      def references_with_foreign_keys(*args)
+        options = args.extract_options!
+        polymorphic = options[:polymorphic]
+        fk_options = options.delete(:foreign_key)
+
+        references_without_foreign_keys(*(args << options))
+        # references_without_foreign_keys adds {:type => :integer}
+        args.extract_options!
+        if fk_options && !polymorphic
+          fk_options = {} if fk_options == true
+          args.each { |to_table| foreign_key(to_table, fk_options) }
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::ConnectionAdapters.class_eval do
+  include ActiveRecord::ConnectionAdapters::OracleEnhancedSchemaDefinitions
+end

data/lib/active_record/connection_adapters/oracle_enhanced_schema_dumper.rb

@@ -0,0 +1,214 @@
+module ActiveRecord #:nodoc:
+  module ConnectionAdapters #:nodoc:
+    module OracleEnhancedSchemaDumper #:nodoc:
+
+      def self.included(base) #:nodoc:
+        base.class_eval do
+          private
+          alias_method_chain :tables, :oracle_enhanced
+          alias_method_chain :indexes, :oracle_enhanced
+        end
+      end
+
+      private
+      
+      def tables_with_oracle_enhanced(stream)
+        sorted_tables = @connection.tables.sort
+        sorted_tables.each do |tbl|
+          # add table prefix or suffix for schema_migrations
+          next if [ActiveRecord::Migrator.proper_table_name('schema_migrations'), ignore_tables].flatten.any? do |ignored|
+            case ignored
+            when String; tbl == ignored
+            when Regexp; tbl =~ ignored
+            else
+              raise StandardError, 'ActiveRecord::SchemaDumper.ignore_tables accepts an array of String and / or Regexp values.'
+            end
+          end
+          # change table name inspect method
+          tbl.extend TableInspect
+          oracle_enhanced_table(tbl, stream)
+          # add primary key trigger if table has it
+          primary_key_trigger(tbl, stream)
+        end
+        sorted_tables.each do |tbl|
+          # add foreign keys if table has them
+          foreign_keys(tbl, 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"
+        end
+      end
+
+      def foreign_keys(table_name, stream)
+        if @connection.respond_to?(:foreign_keys) && (foreign_keys = @connection.foreign_keys(table_name)).any?
+          add_foreign_key_statements = foreign_keys.map do |foreign_key|
+            statement_parts = [ ('add_foreign_key ' + foreign_key.from_table.inspect) ]
+            statement_parts << foreign_key.to_table.inspect
+            statement_parts << (':name => ' + foreign_key.options[:name].inspect)
+            
+            if foreign_key.options[:column] != "#{foreign_key.to_table.singularize}_id"
+              statement_parts << (':column => ' + foreign_key.options[:column].inspect)
+            end
+            if foreign_key.options[:primary_key] != 'id'
+              statement_parts << (':primary_key => ' + foreign_key.options[:primary_key].inspect)
+            end
+            unless foreign_key.options[:dependent].blank?
+              statement_parts << (':dependent => ' + foreign_key.options[:dependent].inspect)
+            end
+
+            '  ' + statement_parts.join(', ')
+          end
+
+          stream.puts add_foreign_key_statements.sort.join("\n")
+          stream.puts
+        end
+      end
+
+      def synonyms(stream)
+        if @connection.respond_to?(:synonyms)
+          syns = @connection.synonyms
+          syns.each do |syn|
+            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
+      end
+
+      def indexes_with_oracle_enhanced(table, stream)
+        if (indexes = @connection.indexes(table)).any?
+          add_index_statements = indexes.map do |index|
+            # use table.inspect as it will remove prefix and suffix
+            statment_parts = [ ('add_index ' + table.inspect) ]
+            statment_parts << index.columns.inspect
+            statment_parts << (':name => ' + index.name.inspect)
+            statment_parts << ':unique => true' if index.unique
+            statment_parts << ':tablespace => ' + index.tablespace.inspect
+
+            '  ' + statment_parts.join(', ')
+          end
+
+          stream.puts add_index_statements.sort.join("\n")
+          stream.puts
+        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)
+          
+          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.virtual? ? 'virtual' : 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]   = column.default.inspect if column.virtual?
+            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
+          remove_prefix_and_suffix(self)
+        end
+        
+        private
+        def remove_prefix_and_suffix(table_name)
+          if table_name =~ /\A#{ActiveRecord::Base.table_name_prefix}(.*)#{ActiveRecord::Base.table_name_suffix}\Z/
+            "\"#{$1}\""
+          else
+            "\"#{table_name}\""
+          end
+        end
+      end
+
+    end
+  end
+end
+
+ActiveRecord::SchemaDumper.class_eval do
+  include ActiveRecord::ConnectionAdapters::OracleEnhancedSchemaDumper
+end