activerecord-oracle_enhanced-adapter 1.4.3 → 5.2.0

data/lib/active_record/connection_adapters/oracle_enhanced_schema_statements_ext.rb

@@ -1,258 +0,0 @@
-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
-
-      # 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
-
-        table_name = ActiveRecord::Migrator.proper_table_name(to_table)
-
-        sql = "FOREIGN KEY (#{columns_sql}) REFERENCES #{quote_table_name(table_name)}(#{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 user_synonyms").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

@@ -1,294 +0,0 @@
-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_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', '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} ORDER BY version")
-        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
-        # 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