activerecord-oracle_enhanced-adapter 1.3.0 → 1.3.1

data/lib/active_record/connection_adapters/oracle_enhanced_schema_statements_ext.rb

@@ -52,31 +52,51 @@ module ActiveRecord
       #     people_best_friend_id_fk FOREIGN KEY (best_friend_id) REFERENCES people (id)
       #     ON DELETE SET NULL
       # 
+      # ==== Creating a composite foreign key
+      #  add_foreign_key(:comments, :posts, :columns => ['post_id', 'author_id'], :name => 'comments_post_fk')
+      # generates
+      #  ALTER TABLE comments ADD CONSTRAINT
+      #     comments_post_fk FOREIGN KEY (post_id, author_id) REFERENCES posts (post_id, author_id)
+      #       
       # === Supported options
       # [:column]
       #   Specify the column name on the from_table that references the to_table. By default this is guessed
       #   to be the singular name of the to_table with "_id" suffixed. So a to_table of :posts will use "post_id"
       #   as the default <tt>:column</tt>.
+      # [:columns]
+      #   An array of column names when defining composite foreign keys. An alias of <tt>:column</tt> provided for improved readability.
       # [:primary_key]
       #   Specify the column name on the to_table that is referenced by this foreign key. By default this is
-      #   assumed to be "id".
+      #   assumed to be "id". Ignored when defining composite foreign keys.
       # [:name]
       #   Specify the name of the foreign key constraint. This defaults to use from_table and foreign key column.
       # [:dependent]
       #   If set to <tt>:delete</tt>, the associated records in from_table are deleted when records in to_table table are deleted.
       #   If set to <tt>:nullify</tt>, the foreign key column is set to +NULL+.
       def add_foreign_key(from_table, to_table, options = {})
-        column = options[:column] || "#{to_table.to_s.singularize}_id"
-        constraint_name = foreign_key_constraint_name(from_table, column, options)
+        columns = options[:column] || options[:columns] || "#{to_table.to_s.singularize}_id"
+        constraint_name = foreign_key_constraint_name(from_table, columns, options)
         sql = "ALTER TABLE #{quote_table_name(from_table)} ADD CONSTRAINT #{quote_column_name(constraint_name)} "
         sql << foreign_key_definition(to_table, options)
         execute sql
       end
 
       def foreign_key_definition(to_table, options = {}) #:nodoc:
-        column = options[:column] || "#{to_table.to_s.singularize}_id"
-        primary_key = options[:primary_key] || "id"
-        sql = "FOREIGN KEY (#{quote_column_name(column)}) REFERENCES #{quote_table_name(to_table)}(#{primary_key})"
+        columns = Array(options[:column] || options[:columns])
+        
+        if columns.size > 1
+          # composite foreign key
+          columns_sql = columns.map {|c| quote_column_name(c)}.join(',')
+          references = options[:references] || columns
+          references_sql = references.map {|c| quote_column_name(c)}.join(',')
+        else
+          columns_sql = quote_column_name(columns.first || "#{to_table.to_s.singularize}_id")
+          references = options[:references] ? options[:references].first : nil
+          references_sql = quote_column_name(options[:primary_key] || references || "id")
+        end
+        
+        sql = "FOREIGN KEY (#{columns_sql}) REFERENCES #{quote_table_name(to_table)}(#{references_sql})"
+        
         case options[:dependent]
         when :nullify
           sql << " ON DELETE SET NULL"
@@ -106,9 +126,12 @@ module ActiveRecord
 
       private
 
-      def foreign_key_constraint_name(table_name, column, options = {})
-        constraint_name = original_name = options[:name] || "#{table_name}_#{column}_fk"
+      def foreign_key_constraint_name(table_name, columns, options = {})
+        columns = Array(columns)
+        constraint_name = original_name = options[:name] || "#{table_name}_#{columns.join('_')}_fk"
+        
         return constraint_name if constraint_name.length <= OracleEnhancedAdapter::IDENTIFIER_MAX_LENGTH
+        
         # leave just first three letters from each word
         constraint_name = constraint_name.split('_').map{|w| w[0,3]}.join('_')
         # generate unique name using hash function
@@ -128,7 +151,7 @@ module ActiveRecord
 
         fk_info = select_all(<<-SQL, 'Foreign Keys')
           SELECT r.table_name to_table
-                ,rc.column_name primary_key
+                ,rc.column_name references_column
                 ,cc.column_name
                 ,c.constraint_name name
                 ,c.delete_rule
@@ -144,18 +167,27 @@ module ActiveRecord
              AND rc.owner = r.owner
              AND rc.constraint_name = r.constraint_name
              AND rc.position = cc.position
+          ORDER BY name, to_table, column_name, references_column
         SQL
 
+        fks = {}
+
         fk_info.map do |row|
-          options = {:column => oracle_downcase(row['column_name']), :name => oracle_downcase(row['name']),
-            :primary_key => oracle_downcase(row['primary_key'])}
+          name = oracle_downcase(row['name'])
+          fks[name] ||= { :columns => [], :to_table => oracle_downcase(row['to_table']), :references => [] }
+          fks[name][:columns] << oracle_downcase(row['column_name'])
+          fks[name][:references] << oracle_downcase(row['references_column'])
           case row['delete_rule']
           when 'CASCADE'
-            options[:dependent] = :delete
+            fks[name][:dependent] = :delete
           when 'SET NULL'
-            options[:dependent] = :nullify
+            fks[name][:dependent] = :nullify
           end
-          OracleEnhancedForeignKeyDefinition.new(table_name, oracle_downcase(row['to_table']), options)
+        end
+        
+        fks.map do |k, v|
+          options = {:name => k, :columns => v[:columns], :references => v[:references], :dependent => v[:dependent]}
+          OracleEnhancedForeignKeyDefinition.new(table_name, v[:to_table], options)
         end
       end
 

data/lib/active_record/connection_adapters/oracle_enhanced_structure_dump.rb

@@ -0,0 +1,290 @@
+module ActiveRecord #:nodoc:
+  module ConnectionAdapters #:nodoc:
+    module OracleEnhancedStructureDump #:nodoc:
+
+      # Statements separator used in structure dump to allow loading of structure dump also with SQL*Plus
+      STATEMENT_TOKEN = "\n\n/\n\n"
+
+      def structure_dump #:nodoc:
+        structure = select_values("select sequence_name from user_sequences order by 1").map do |seq|
+          "CREATE SEQUENCE \"#{seq}\""
+        end
+        select_values("select table_name from all_tables t
+                    where owner = sys_context('userenv','session_user') and secondary='N'
+                      and not exists (select mv.mview_name from all_mviews mv where mv.owner = t.owner and mv.mview_name = t.table_name)
+                      and not exists (select mvl.log_table from all_mview_logs mvl where mvl.log_owner = t.owner and mvl.log_table = t.table_name)
+                    order by 1").each do |table_name|
+          virtual_columns = virtual_columns_for(table_name)
+          ddl = "CREATE#{ ' GLOBAL TEMPORARY' if temporary_table?(table_name)} TABLE \"#{table_name}\" (\n"
+          cols = select_all(%Q{
+            select column_name, data_type, data_length, char_used, char_length, data_precision, data_scale, data_default, nullable
+            from user_tab_columns
+            where table_name = '#{table_name}'
+            order by column_id
+          }).map do |row|
+            if(v = virtual_columns.find {|col| col['column_name'] == row['column_name']})
+              structure_dump_virtual_column(row, v['data_default'])
+            else
+              structure_dump_column(row)
+            end
+          end
+          ddl << cols.join(",\n ")
+          ddl << structure_dump_primary_key(table_name)
+          ddl << "\n)"
+          structure << ddl
+          structure << structure_dump_indexes(table_name)
+          structure << structure_dump_unique_keys(table_name)
+        end
+
+        join_with_statement_token(structure) << structure_dump_fk_constraints
+      end
+
+      def structure_dump_column(column) #:nodoc:
+        col = "\"#{column['column_name']}\" #{column['data_type']}"
+        if column['data_type'] =='NUMBER' and !column['data_precision'].nil?
+          col << "(#{column['data_precision'].to_i}"
+          col << ",#{column['data_scale'].to_i}" if !column['data_scale'].nil?
+          col << ')'
+        elsif column['data_type'].include?('CHAR')
+          length = column['char_used'] == 'C' ? column['char_length'].to_i : column['data_length'].to_i
+          col <<  "(#{length})"
+        end
+        col << " DEFAULT #{column['data_default']}" if !column['data_default'].nil?
+        col << ' NOT NULL' if column['nullable'] == 'N'
+        col
+      end
+
+      def structure_dump_virtual_column(column, data_default) #:nodoc:
+        data_default = data_default.gsub(/"/, '')
+        col = "\"#{column['column_name']}\" #{column['data_type']}"
+        if column['data_type'] =='NUMBER' and !column['data_precision'].nil?
+          col << "(#{column['data_precision'].to_i}"
+          col << ",#{column['data_scale'].to_i}" if !column['data_scale'].nil?
+          col << ')'
+        elsif column['data_type'].include?('CHAR')
+          length = column['char_used'] == 'C' ? column['char_length'].to_i : column['data_length'].to_i
+          col <<  "(#{length})"
+        end
+        col << " GENERATED ALWAYS AS (#{data_default}) VIRTUAL"
+      end
+
+      def structure_dump_primary_key(table) #:nodoc:
+        opts = {:name => '', :cols => []}
+        pks = select_all(<<-SQL, "Primary Keys") 
+          select a.constraint_name, a.column_name, a.position
+            from user_cons_columns a 
+            join user_constraints c  
+              on a.constraint_name = c.constraint_name 
+           where c.table_name = '#{table.upcase}' 
+             and c.constraint_type = 'P'
+             and c.owner = sys_context('userenv', 'session_user')
+        SQL
+        pks.each do |row|
+          opts[:name] = row['constraint_name']
+          opts[:cols][row['position']-1] = row['column_name']
+        end
+        opts[:cols].length > 0 ? ",\n CONSTRAINT #{opts[:name]} PRIMARY KEY (#{opts[:cols].join(',')})" : ''
+      end
+
+      def structure_dump_unique_keys(table) #:nodoc:
+        keys = {}
+        uks = select_all(<<-SQL, "Primary Keys") 
+          select a.constraint_name, a.column_name, a.position
+            from user_cons_columns a 
+            join user_constraints c  
+              on a.constraint_name = c.constraint_name 
+           where c.table_name = '#{table.upcase}' 
+             and c.constraint_type = 'U'
+             and c.owner = sys_context('userenv', 'session_user')
+        SQL
+        uks.each do |uk|
+          keys[uk['constraint_name']] ||= []
+          keys[uk['constraint_name']][uk['position']-1] = uk['column_name']
+        end
+        keys.map do |k,v|
+          "ALTER TABLE #{table.upcase} ADD CONSTRAINT #{k} UNIQUE (#{v.join(',')})"
+        end
+      end
+
+      def structure_dump_indexes(table_name) #:nodoc:
+        indexes(table_name).map do |options|
+          column_names = options[:columns]
+          options = {:name => options[:name], :unique => options[:unique]}
+          index_name   = index_name(table_name, :column => column_names)
+          if Hash === options # legacy support, since this param was a string
+            index_type = options[:unique] ? "UNIQUE" : ""
+            index_name = options[:name] || index_name
+          else
+            index_type = options
+          end
+          quoted_column_names = column_names.map { |e| quote_column_name(e) }.join(", ")
+          "CREATE #{index_type} INDEX #{quote_column_name(index_name)} ON #{quote_table_name(table_name)} (#{quoted_column_names})"
+        end
+      end
+
+      def structure_dump_fk_constraints #:nodoc:
+        fks = select_all("select table_name from all_tables where owner = sys_context('userenv','session_user') order by 1").map do |table|
+          if respond_to?(:foreign_keys) && (foreign_keys = foreign_keys(table["table_name"])).any?
+            foreign_keys.map do |fk|
+              sql = "ALTER TABLE #{quote_table_name(fk.from_table)} ADD CONSTRAINT #{quote_column_name(fk.options[:name])} "
+              sql << "#{foreign_key_definition(fk.to_table, fk.options)}"
+            end
+          end
+        end.flatten.compact
+        join_with_statement_token(fks)
+      end
+
+      def dump_schema_information #:nodoc:
+        sm_table = ActiveRecord::Migrator.schema_migrations_table_name
+        migrated = select_values("SELECT version FROM #{sm_table}")
+        join_with_statement_token(migrated.map{|v| "INSERT INTO #{sm_table} (version) VALUES ('#{v}')" })
+      end
+
+      # Extract all stored procedures, packages, synonyms and views.
+      def structure_dump_db_stored_code #:nodoc:
+        structure = []
+        select_all("select distinct name, type
+                     from all_source
+                    where type in ('PROCEDURE', 'PACKAGE', 'PACKAGE BODY', 'FUNCTION', 'TRIGGER', 'TYPE')
+                      and name not like 'BIN$%'
+                      and  owner = sys_context('userenv','session_user') order by type").each do |source|
+          ddl = "CREATE OR REPLACE   \n"
+          lines = select_all(%Q{
+                  select text
+                    from all_source
+                   where name = '#{source['name']}'
+                     and type = '#{source['type']}'
+                     and owner = sys_context('userenv','session_user')
+                   order by line 
+                }).map do |row|
+            ddl << row['text']
+          end
+          ddl << ";" unless ddl.strip[-1,1] == ";"
+          structure << ddl
+        end
+
+        # export views 
+        select_all("select view_name, text from user_views").each do |view|
+          structure << "CREATE OR REPLACE VIEW #{view['view_name']} AS\n #{view['text']}"
+        end
+
+        # export synonyms
+        select_all("select owner, synonym_name, table_name, table_owner 
+                      from all_synonyms  
+                     where owner = sys_context('userenv','session_user') ").each do |synonym|
+          structure << "CREATE OR REPLACE #{synonym['owner'] == 'PUBLIC' ? 'PUBLIC' : '' } SYNONYM #{synonym['synonym_name']}"
+          structure << " FOR #{synonym['table_owner']}.#{synonym['table_name']}"
+        end
+
+        join_with_statement_token(structure)
+      end
+
+      def structure_drop #:nodoc:
+        statements = select_values("select sequence_name from user_sequences order by 1").map do |seq|
+          "DROP SEQUENCE \"#{seq}\""
+        end
+        select_values("select table_name from all_tables t
+                    where owner = sys_context('userenv','session_user') and secondary='N'
+                      and not exists (select mv.mview_name from all_mviews mv where mv.owner = t.owner and mv.mview_name = t.table_name)
+                      and not exists (select mvl.log_table from all_mview_logs mvl where mvl.log_owner = t.owner and mvl.log_table = t.table_name)
+                    order by 1").each do |table|
+          statements << "DROP TABLE \"#{table}\" CASCADE CONSTRAINTS"
+        end
+        join_with_statement_token(statements)
+      end
+
+      def temp_table_drop #:nodoc:
+        join_with_statement_token(select_values(
+                  "select table_name from all_tables
+                    where owner = sys_context('userenv','session_user') and secondary='N' and temporary = 'Y' order by 1").map do |table|
+          "DROP TABLE \"#{table}\" CASCADE CONSTRAINTS"
+        end)
+      end
+
+      def full_drop(preserve_tables=false) #:nodoc:
+        s = preserve_tables ? [] : [structure_drop]
+        s << temp_table_drop if preserve_tables
+        s << drop_sql_for_feature("view")
+        s << drop_sql_for_feature("materialized view")
+        s << drop_sql_for_feature("synonym")
+        s << drop_sql_for_feature("type")
+        s << drop_sql_for_object("package")
+        s << drop_sql_for_object("function")
+        s << drop_sql_for_object("procedure")
+        s.join
+      end
+
+      def add_column_options!(sql, options) #:nodoc:
+        type = options[:type] || ((column = options[:column]) && column.type)
+        type = type && type.to_sym
+        # handle case of defaults for CLOB columns, which would otherwise get "quoted" incorrectly
+        if options_include_default?(options)
+          if type == :text
+            sql << " DEFAULT #{quote(options[:default])}"
+          else
+            # from abstract adapter
+            sql << " DEFAULT #{quote(options[:default], options[:column])}"
+          end
+        end
+        # must explicitly add NULL or NOT NULL to allow change_column to work on migrations
+        if options[:null] == false
+          sql << " NOT NULL"
+        elsif options[:null] == true
+          sql << " NULL" unless type == :primary_key
+        end
+      end
+
+      def execute_structure_dump(string)
+        string.split(STATEMENT_TOKEN).each do |ddl|
+          ddl.chop! if ddl.last == ";"
+          execute(ddl) unless ddl.blank?
+        end
+      end
+
+      private
+
+      # virtual columns are an 11g feature.  This returns [] if feature is not 
+      # present or none are found.
+      # return [{'column_name' => 'FOOS', 'data_default' => '...'}, ...]
+      def virtual_columns_for(table)
+        begin
+          select_all <<-SQL
+            select column_name, data_default 
+              from user_tab_cols 
+             where virtual_column='YES' 
+               and table_name='#{table.upcase}'
+          SQL
+        # feature not supported previous to 11g
+        rescue ActiveRecord::StatementInvalid => e
+          []
+        end
+      end
+
+      def drop_sql_for_feature(type)
+        short_type = type == 'materialized view' ? 'mview' : type
+        join_with_statement_token(
+        select_values("select #{short_type}_name from user_#{short_type.tableize}").map do |name|
+          "DROP #{type.upcase} \"#{name}\""
+        end)
+      end
+
+      def drop_sql_for_object(type)
+        join_with_statement_token(
+        select_values("select object_name from user_objects where object_type = '#{type.upcase}'").map do |name|
+          "DROP #{type.upcase} \"#{name}\""
+        end)
+      end
+
+      def join_with_statement_token(array)
+        string = array.join(STATEMENT_TOKEN)
+        string << STATEMENT_TOKEN unless string.blank?
+        string
+      end
+
+    end
+  end
+end
+
+ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.class_eval do
+  include ActiveRecord::ConnectionAdapters::OracleEnhancedStructureDump
+end

data/lib/active_record/connection_adapters/oracle_enhanced_tasks.rb

@@ -1,12 +1,17 @@
-# implementation idea taken from JDBC adapter
-if defined?(Rake.application) && Rake.application &&
-    ActiveRecord::Base.configurations[defined?(Rails.env) ? Rails.env : RAILS_ENV]['adapter'] == 'oracle_enhanced'
-  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)
+# Used just for Rails 2.x
+# In Rails 3.x rake tasks are loaded using railtie
+if ActiveRecord::VERSION::MAJOR == 2
+
+  if defined?(Rake.application) && Rake.application &&
+      ActiveRecord::Base.configurations[defined?(Rails.env) ? Rails.env : RAILS_ENV]['adapter'] == 'oracle_enhanced'
+    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
+
 end

data/lib/activerecord-oracle_enhanced-adapter.rb

@@ -0,0 +1,25 @@
+# define railtie which will be executed in Rails 3
+if defined?(::Rails::Railtie)
+
+  module ActiveRecord
+    module ConnectionAdapters
+      class OracleEnhancedRailtie < ::Rails::Railtie
+        rake_tasks do
+          load 'active_record/connection_adapters/oracle_enhanced.rake'
+        end
+
+        ActiveSupport.on_load(:active_record) do
+          require 'active_record/connection_adapters/oracle_enhanced_adapter'
+
+          # Cache column descriptions between requests in test and production environments
+          if Rails.env.test? || Rails.env.production?
+            ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.cache_columns = true
+          end
+
+        end
+
+      end
+    end
+  end
+
+end