pmacs-activerecord-oracle_enhanced-adapter 1.4.2.rc1

data/lib/active_record/connection_adapters/oracle_enhanced_schema_statements_ext.rb

@@ -0,0 +1,265 @@
+require 'digest/sha1'
+
+module ActiveRecord
+  module ConnectionAdapters
+    module OracleEnhancedSchemaStatementsExt
+      def supports_foreign_keys? #:nodoc:
+        true
+      end
+
+      # Create primary key trigger (so that you can skip primary key value in INSERT statement).
+      # By default trigger name will be "table_name_pkt", you can override the name with 
+      # :trigger_name option (but it is not recommended to override it as then this trigger will
+      # not be detected by ActiveRecord model and it will still do prefetching of sequence value).
+      #
+      #   add_primary_key_trigger :users
+      #
+      # You can also create primary key trigger using +create_table+ with :primary_key_trigger
+      # option:
+      #
+      #   create_table :users, :primary_key_trigger => true do |t|
+      #     # ...
+      #   end
+      #
+      def add_primary_key_trigger(table_name, options={})
+        # call the same private method that is used for create_table :primary_key_trigger => true
+        create_primary_key_trigger(table_name, options)
+      end
+
+      def table_definition_tablespace
+        # TODO: Support specifying an :index_tablespace option in create_table?
+        tablespace_sql = ''
+        if tablespace = default_tablespace_for(:index)
+          tablespace_sql << " USING INDEX TABLESPACE #{tablespace}"
+        end
+        tablespace_sql
+      end
+
+      # Adds a new foreign key to the +from_table+, referencing the primary key of +to_table+
+      # (syntax and partial implementation taken from http://github.com/matthuhiggins/foreigner)
+      #
+      # The foreign key will be named after the from and to tables unless you pass
+      # <tt>:name</tt> as an option.
+      #
+      # === Examples
+      # ==== Creating a foreign key
+      #  add_foreign_key(:comments, :posts)
+      # generates
+      #  ALTER TABLE comments ADD CONSTRAINT
+      #     comments_post_id_fk FOREIGN KEY (post_id) REFERENCES posts (id)
+      # 
+      # ==== Creating a named foreign key
+      #  add_foreign_key(:comments, :posts, :name => 'comments_belongs_to_posts')
+      # generates
+      #  ALTER TABLE comments ADD CONSTRAINT
+      #     comments_belongs_to_posts FOREIGN KEY (post_id) REFERENCES posts (id)
+      # 
+      # ==== Creating a cascading foreign_key on a custom column
+      #  add_foreign_key(:people, :people, :column => 'best_friend_id', :dependent => :nullify)
+      # generates
+      #  ALTER TABLE people ADD CONSTRAINT
+      #     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". 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 = {})
+        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:
+        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"
+        when :delete
+          sql << " ON DELETE CASCADE"
+        end
+        sql
+      end
+
+      # Remove the given foreign key from the table.
+      #
+      # ===== Examples
+      # ====== Remove the suppliers_company_id_fk in the suppliers table.
+      #   remove_foreign_key :suppliers, :companies
+      # ====== Remove the foreign key named accounts_branch_id_fk in the accounts table.
+      #   remove_foreign_key :accounts, :column => :branch_id
+      # ====== Remove the foreign key named party_foreign_key in the accounts table.
+      #   remove_foreign_key :accounts, :name => :party_foreign_key
+      def remove_foreign_key(from_table, options)
+        if Hash === options
+          constraint_name = foreign_key_constraint_name(from_table, options[:column], options)
+        else
+          constraint_name = foreign_key_constraint_name(from_table, "#{options.to_s.singularize}_id")
+        end
+        execute "ALTER TABLE #{quote_table_name(from_table)} DROP CONSTRAINT #{quote_column_name(constraint_name)}"
+      end
+
+      private
+
+      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
+        if constraint_name.length > OracleEnhancedAdapter::IDENTIFIER_MAX_LENGTH
+          constraint_name = 'c'+Digest::SHA1.hexdigest(original_name)[0,OracleEnhancedAdapter::IDENTIFIER_MAX_LENGTH-1]
+        end
+        @logger.warn "#{adapter_name} shortened foreign key constraint name #{original_name} to #{constraint_name}" if @logger
+        constraint_name
+      end
+      
+
+      public
+
+      # get table foreign keys for schema dump
+      def foreign_keys(table_name) #:nodoc:
+        (owner, desc_table_name, db_link) = @connection.describe(table_name)
+
+        fk_info = select_all(<<-SQL, 'Foreign Keys')
+          SELECT r.table_name to_table
+                ,rc.column_name references_column
+                ,cc.column_name
+                ,c.constraint_name name
+                ,c.delete_rule
+            FROM user_constraints#{db_link} c, user_cons_columns#{db_link} cc,
+                 user_constraints#{db_link} r, user_cons_columns#{db_link} rc
+           WHERE c.owner = '#{owner}'
+             AND c.table_name = '#{desc_table_name}'
+             AND c.constraint_type = 'R'
+             AND cc.owner = c.owner
+             AND cc.constraint_name = c.constraint_name
+             AND r.constraint_name = c.r_constraint_name
+             AND r.owner = c.owner
+             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|
+          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'
+            fks[name][:dependent] = :delete
+          when 'SET NULL'
+            fks[name][:dependent] = :nullify
+          end
+        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
+
+      # REFERENTIAL INTEGRITY ====================================
+
+      def disable_referential_integrity(&block) #:nodoc:
+        sql_constraints = <<-SQL
+        SELECT constraint_name, owner, table_name
+          FROM user_constraints
+          WHERE constraint_type = 'R'
+          AND status = 'ENABLED'
+        SQL
+        old_constraints = select_all(sql_constraints)
+        begin
+          old_constraints.each do |constraint|
+            execute "ALTER TABLE #{constraint["table_name"]} DISABLE CONSTRAINT #{constraint["constraint_name"]}"
+          end
+          yield
+        ensure
+          old_constraints.each do |constraint|
+            execute "ALTER TABLE #{constraint["table_name"]} ENABLE CONSTRAINT #{constraint["constraint_name"]}"
+          end
+        end
+      end
+
+      # Add synonym to existing table or view or sequence. Can be used to create local synonym to
+      # remote table in other schema or in other database
+      # Examples:
+      #
+      #   add_synonym :posts, "blog.posts"
+      #   add_synonym :posts_seq, "blog.posts_seq"
+      #   add_synonym :employees, "hr.employees@dblink", :force => true
+      #
+      def add_synonym(name, table_name, options = {})
+        sql = "CREATE"
+        if options[:force] == true
+          sql << " OR REPLACE"
+        end
+        sql << " SYNONYM #{quote_table_name(name)} FOR #{quote_table_name(table_name)}"
+        execute sql
+      end
+
+      # Remove existing synonym to table or view or sequence
+      # Example:
+      #
+      #   remove_synonym :posts, "blog.posts"
+      #
+      def remove_synonym(name)
+        execute "DROP SYNONYM #{quote_table_name(name)}"
+      end
+
+      # get synonyms for schema dump
+      def synonyms #:nodoc:
+        select_all("SELECT synonym_name, table_owner, table_name, db_link FROM all_synonyms WHERE owner = SYS_CONTEXT('userenv', 'current_schema')").collect do |row|
+          OracleEnhancedSynonymDefinition.new(oracle_downcase(row['synonym_name']),
+            oracle_downcase(row['table_owner']), oracle_downcase(row['table_name']), oracle_downcase(row['db_link']))
+        end
+      end
+
+    end
+  end
+end
+
+ActiveRecord::ConnectionAdapters::OracleEnhancedAdapter.class_eval do
+  include ActiveRecord::ConnectionAdapters::OracleEnhancedSchemaStatementsExt
+end

data/lib/active_record/connection_adapters/oracle_enhanced_structure_dump.rb

@@ -0,0 +1,294 @@
+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', 'current_schema') 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', 'current_schema')
+        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', 'current_schema')
+        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_or_expression(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', 'current_schema') 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', 'current_schema') 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', 'current_schema')
+                   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', 'current_schema') ").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', 'current_schema') 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', 'current_schema') 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
+        # add AS expression for virtual columns
+        if options[:as].present?
+          sql << " AS (#{options[:as]})"
+        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