activerecord-oracle_enhanced-adapter 1.4.3 → 5.2.0

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module ConnectionAdapters
+    module OracleEnhanced
+      module ColumnMethods
+        def primary_key(name, type = :primary_key, **options)
+          # This is a placeholder for future :auto_increment support
+          super
+        end
+
+        [
+          :raw,
+          :timestamptz,
+          :timestampltz,
+          :ntext
+        ].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
+
+      class SynonymDefinition < Struct.new(:name, :table_owner, :table_name, :db_link) #:nodoc:
+      end
+
+      class IndexDefinition < ActiveRecord::ConnectionAdapters::IndexDefinition
+        attr_accessor :parameters, :statement_parameters, :tablespace
+
+        def initialize(table, name, unique, columns, orders, type, parameters, statement_parameters, tablespace)
+          @parameters = parameters
+          @statement_parameters = statement_parameters
+          @tablespace = tablespace
+          super(table, name, unique, columns, orders: orders, type: type)
+        end
+      end
+
+      class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
+        include OracleEnhanced::ColumnMethods
+
+        attr_accessor :tablespace, :organization
+        def initialize(name, temporary = false, options = nil, as = nil, tablespace = nil, organization = nil, comment: nil)
+          @tablespace = tablespace
+          @organization = organization
+          super(name, temporary, options, as, comment: comment)
+        end
+
+        def new_column_definition(name, type, **options) # :nodoc:
+          if type == :virtual
+            raise "No virtual column definition found." unless options[:as]
+            type = options[:type]
+          end
+          super
+        end
+      end
+
+      class AlterTable < ActiveRecord::ConnectionAdapters::AlterTable
+      end
+
+      class Table < ActiveRecord::ConnectionAdapters::Table
+        include OracleEnhanced::ColumnMethods
+      end
+    end
+  end
+end

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

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+module ActiveRecord #:nodoc:
+  module ConnectionAdapters #:nodoc:
+    module OracleEnhanced #:nodoc:
+      class SchemaDumper < ConnectionAdapters::SchemaDumper #:nodoc:
+        private
+
+          def tables(stream)
+            # 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
+              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
+
+          def primary_key_trigger(table_name, stream)
+            if @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 synonyms(stream)
+            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
+
+          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 " + remove_prefix_and_suffix(table).inspect) ]
+                    statement_parts << index.statement_parameters
+                  else
+                    statement_parts = [ ("add_context_index " + remove_prefix_and_suffix(table).inspect) ]
+                    statement_parts << index.columns.inspect
+                    statement_parts << ("name: " + index.name.inspect)
+                  end
+                else
+                  # unrecognized index type
+                  statement_parts = ["# unrecognized index #{index.name.inspect} with type #{index.type.inspect}"]
+                end
+                "  " + statement_parts.join(", ") unless statement_parts.empty?
+              end.compact
+
+              return if add_index_statements.empty?
+
+              stream.puts add_index_statements.sort.join("\n")
+              stream.puts
+            end
+          end
+
+          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
+
+          def index_parts(index)
+            index_parts = super
+            index_parts << "tablespace: #{index.tablespace.inspect}" if index.tablespace
+            index_parts
+          end
+
+          def table(table, stream)
+            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)
+              end
+
+              tbl.print "  create_table #{remove_prefix_and_suffix(table).inspect}"
+
+              # addition to make temporary option work
+              tbl.print ", temporary: true" if @connection.temporary_table?(table)
+
+              case pk
+              when String
+                tbl.print ", primary_key: #{pk.inspect}" unless pk == "id"
+                pkcol = columns.detect { |c| c.name == pk }
+                pkcolspec = 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
+
+              table_options = @connection.table_options(table)
+              if table_options.present?
+                tbl.print ", #{format_options(table_options)}"
+              end
+
+              tbl.puts ", force: :cascade do |t|"
+
+              # 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 = column_spec(column)
+                tbl.print "    t.#{type} #{column.name.inspect}"
+                tbl.print ", #{format_colspec(colspec)}" if colspec.present?
+                tbl.puts
+              end
+
+              indexes_in_create(table, tbl)
+
+              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
+          end
+
+          def prepare_column_options(column)
+            spec = super
+
+            if @connection.supports_virtual_columns? && column.virtual?
+              spec[:as] = extract_expression_for_virtual_column(column)
+              spec = { type: schema_type(column).inspect }.merge!(spec) unless column.type == :decimal
+            end
+
+            spec
+          end
+
+          def default_primary_key?(column)
+            schema_type(column) == :integer
+          end
+
+          def extract_expression_for_virtual_column(column)
+            column_name = column.name
+            table_name = column.table_name
+            @connection.select_value(<<-SQL.strip.gsub(/\s+/, " "), "Table comment", [bind_string("table_name", table_name.upcase), bind_string("column_name", column_name.upcase)]).inspect
+              select data_default from all_tab_columns
+              where owner = SYS_CONTEXT('userenv', 'session_user')
+              and table_name = :table_name
+              and column_name = :column_name
+            SQL
+          end
+
+          def bind_string(name, value)
+            ActiveRecord::Relation::QueryAttribute.new(name, value, Type::OracleEnhanced::String.new)
+          end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,709 @@
+# frozen_string_literal: true
+
+require "digest/sha1"
+
+module ActiveRecord
+  module ConnectionAdapters
+    module OracleEnhanced
+      module SchemaStatements
+        # SCHEMA STATEMENTS ========================================
+        #
+        # see: abstract/schema_statements.rb
+
+        def tables #:nodoc:
+          select_values(<<-SQL.strip.gsub(/\s+/, " "), "tables")
+          SELECT DECODE(table_name, UPPER(table_name), LOWER(table_name), table_name)
+          FROM all_tables
+          WHERE owner = SYS_CONTEXT('userenv', 'current_schema')
+          AND secondary = 'N'
+        SQL
+        end
+
+        def data_sources
+          super | synonyms.map(&:name)
+        end
+
+        def table_exists?(table_name)
+          table_name = table_name.to_s
+          if table_name.include?("@")
+            # db link is not table
+            false
+          else
+            default_owner = current_schema
+          end
+          real_name = OracleEnhanced::Quoting.valid_table_name?(table_name) ?
+            table_name.upcase : table_name
+          if real_name.include?(".")
+            table_owner, table_name = real_name.split(".")
+          else
+            table_owner, table_name = default_owner, real_name
+          end
+
+          select_values(<<-SQL.strip.gsub(/\s+/, " "), "table exists", [bind_string("owner", table_owner), bind_string("table_name", table_name)]).any?
+          SELECT owner, table_name
+          FROM all_tables
+          WHERE owner = :owner
+          AND table_name = :table_name
+        SQL
+        end
+
+        def data_source_exists?(table_name)
+          (_owner, table_name, _db_link) = @connection.describe(table_name)
+          true
+        rescue
+          false
+        end
+
+        def views # :nodoc:
+          select_values(<<-SQL.strip.gsub(/\s+/, " "), "views")
+            SELECT LOWER(view_name) FROM all_views WHERE owner = SYS_CONTEXT('userenv', 'current_schema')
+          SQL
+        end
+
+        def materialized_views #:nodoc:
+          select_values(<<-SQL.strip.gsub(/\s+/, " "), "materialized views")
+            SELECT LOWER(mview_name) FROM all_mviews WHERE owner = SYS_CONTEXT('userenv', 'current_schema')
+          SQL
+        end
+
+        # get synonyms for schema dump
+        def synonyms
+          result = select_all(<<-SQL.strip.gsub(/\s+/, " "), "synonyms")
+          SELECT synonym_name, table_owner, table_name, db_link
+          FROM all_synonyms where owner = SYS_CONTEXT('userenv', 'session_user')
+        SQL
+
+          result.collect do |row|
+             OracleEnhanced::SynonymDefinition.new(oracle_downcase(row["synonym_name"]),
+             oracle_downcase(row["table_owner"]), oracle_downcase(row["table_name"]), oracle_downcase(row["db_link"]))
+           end
+        end
+
+        def indexes(table_name) #:nodoc:
+          (owner, table_name, db_link) = @connection.describe(table_name)
+          default_tablespace_name = default_tablespace
+
+          result = select_all(<<-SQL.strip.gsub(/\s+/, " "), "indexes", [bind_string("owner", owner), bind_string("owner", owner)])
+            SELECT LOWER(i.table_name) AS table_name, LOWER(i.index_name) AS index_name, i.uniqueness,
+              i.index_type, i.ityp_owner, i.ityp_name, i.parameters,
+              LOWER(i.tablespace_name) AS tablespace_name,
+              LOWER(c.column_name) AS column_name, e.column_expression,
+              atc.virtual_column
+            FROM all_indexes#{db_link} i
+              JOIN all_ind_columns#{db_link} c ON c.index_name = i.index_name AND c.index_owner = i.owner
+              LEFT OUTER JOIN all_ind_expressions#{db_link} e ON e.index_name = i.index_name AND
+                e.index_owner = i.owner AND e.column_position = c.column_position
+              LEFT OUTER JOIN all_tab_cols#{db_link} atc ON i.table_name = atc.table_name AND
+                c.column_name = atc.column_name AND i.owner = atc.owner AND atc.hidden_column = 'NO'
+            WHERE i.owner = :owner
+               AND i.table_owner = :owner
+               AND NOT EXISTS (SELECT uc.index_name FROM all_constraints uc
+                WHERE uc.index_name = i.index_name AND uc.owner = i.owner AND uc.constraint_type = 'P')
+            ORDER BY i.index_name, c.column_position
+          SQL
+
+          current_index = nil
+          all_schema_indexes = []
+
+          result.each do |row|
+            # have to keep track of indexes because above query returns dups
+            # there is probably a better query we could figure out
+            if current_index != row["index_name"]
+              statement_parameters = nil
+              if row["index_type"] == "DOMAIN" && row["ityp_owner"] == "CTXSYS" && row["ityp_name"] == "CONTEXT"
+                procedure_name = default_datastore_procedure(row["index_name"])
+                source = select_values(<<-SQL.strip.gsub(/\s+/, " "), "procedure", [bind_string("owner", owner), bind_string("procedure_name", procedure_name.upcase)]).join
+                  SELECT text
+                  FROM all_source#{db_link}
+                  WHERE owner = :owner
+                    AND name = :procedure_name
+                  ORDER BY line
+                SQL
+                if source =~ /-- add_context_index_parameters (.+)\n/
+                  statement_parameters = $1
+                end
+              end
+              all_schema_indexes << OracleEnhanced::IndexDefinition.new(
+                row["table_name"],
+                row["index_name"],
+                row["uniqueness"] == "UNIQUE",
+                [],
+                {},
+                row["index_type"] == "DOMAIN" ? "#{row['ityp_owner']}.#{row['ityp_name']}" : nil,
+                row["parameters"],
+                statement_parameters,
+                row["tablespace_name"] == default_tablespace_name ? nil : row["tablespace_name"])
+              current_index = row["index_name"]
+            end
+
+            # Functional index columns and virtual columns both get stored as column expressions,
+            # but re-creating a virtual column index as an expression (instead of using the virtual column's name)
+            # results in a ORA-54018 error.  Thus, we only want the column expression value returned
+            # when the column is not virtual.
+            if row["column_expression"] && row["virtual_column"] != "YES"
+              all_schema_indexes.last.columns << row["column_expression"]
+            else
+              all_schema_indexes.last.columns << row["column_name"].downcase
+            end
+          end
+
+          # Return the indexes just for the requested table, since AR is structured that way
+          table_name = table_name.downcase
+          all_schema_indexes.select { |i| i.table == table_name }
+        end
+
+        # Additional options for +create_table+ method in migration files.
+        #
+        # You can specify individual starting value in table creation migration file, e.g.:
+        #
+        #   create_table :users, :sequence_start_value => 100 do |t|
+        #     # ...
+        #   end
+        #
+        # You can also specify other sequence definition additional parameters, e.g.:
+        #
+        #   create_table :users, :sequence_start_value => “100 NOCACHE INCREMENT BY 10” do |t|
+        #     # ...
+        #   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).
+        # Example:
+        #
+        #   create_table :users, :primary_key_trigger => true do |t|
+        #     # ...
+        #   end
+        #
+        # It is possible to add table and column comments in table creation migration files:
+        #
+        #   create_table :employees, :comment => “Employees and contractors” do |t|
+        #     t.string      :first_name, :comment => “Given name”
+        #     t.string      :last_name, :comment => “Surname”
+        #   end
+
+        def create_table(table_name, comment: nil, **options)
+          create_sequence = options[:id] != false
+          td = create_table_definition table_name, options[:temporary], options[:options], options[:as], options[:tablespace], options[:organization], comment: comment
+
+          if options[:id] != false && !options[:as]
+            pk = options.fetch(:primary_key) do
+              Base.get_primary_key table_name.to_s.singularize
+            end
+
+            if pk.is_a?(Array)
+              td.primary_keys pk
+            else
+              td.primary_key pk, options.fetch(:id, :primary_key), options
+            end
+          end
+
+          # store that primary key was defined in create_table block
+          unless create_sequence
+            class << td
+              attr_accessor :create_sequence
+              def primary_key(*args)
+                self.create_sequence = true
+                super(*args)
+              end
+            end
+          end
+
+          yield td if block_given?
+          create_sequence = create_sequence || td.create_sequence
+
+          if options[:force] && data_source_exists?(table_name)
+            drop_table(table_name, options)
+          end
+
+          execute schema_creation.accept td
+
+          create_sequence_and_trigger(table_name, options) if create_sequence
+
+          if supports_comments? && !supports_comments_in_create?
+            change_table_comment(table_name, comment) if comment
+            td.columns.each do |column|
+              change_column_comment(table_name, column.name, column.comment) if column.comment.present?
+            end
+          end
+          td.indexes.each { |c, o| add_index table_name, c, o }
+
+          rebuild_primary_key_index_to_default_tablespace(table_name, options)
+        end
+
+        def rename_table(table_name, new_name) #:nodoc:
+          if new_name.to_s.length > table_name_length
+            raise ArgumentError, "New table name '#{new_name}' is too long; the limit is #{table_name_length} characters"
+          end
+          execute "RENAME #{quote_table_name(table_name)} TO #{quote_table_name(new_name)}"
+          execute "RENAME #{quote_table_name("#{table_name}_seq")} TO #{default_sequence_name(new_name)}" rescue nil
+
+          rename_table_indexes(table_name, new_name)
+        end
+
+        def drop_table(table_name, options = {}) #:nodoc:
+          execute "DROP TABLE #{quote_table_name(table_name)}#{' CASCADE CONSTRAINTS' if options[:force] == :cascade}"
+          seq_name = options[:sequence_name] || default_sequence_name(table_name)
+          execute "DROP SEQUENCE #{quote_table_name(seq_name)}" rescue nil
+        rescue ActiveRecord::StatementInvalid => e
+          raise e unless options[:if_exists]
+        end
+
+        def insert_versions_sql(versions) # :nodoc:
+          sm_table = quote_table_name(ActiveRecord::SchemaMigration.table_name)
+
+          if supports_multi_insert?
+            versions.inject("INSERT ALL\n".dup) { |sql, version|
+              sql << "INTO #{sm_table} (version) VALUES (#{quote(version)})\n"
+            } << "SELECT * FROM DUAL\n"
+          else
+            if versions.is_a?(Array)
+              # called from ActiveRecord::Base.connection#dump_schema_information
+              versions.map { |version|
+                "INSERT INTO #{sm_table} (version) VALUES (#{quote(version)})"
+              }.join("\n\n/\n\n")
+            else
+              # called from ActiveRecord::Base.connection#assume_migrated_upto_version
+              "INSERT INTO #{sm_table} (version) VALUES (#{quote(versions)})"
+            end
+          end
+        end
+
+        def add_index(table_name, column_name, options = {}) #:nodoc:
+          index_name, index_type, quoted_column_names, tablespace, index_options = add_index_options(table_name, column_name, options)
+          execute "CREATE #{index_type} INDEX #{quote_column_name(index_name)} ON #{quote_table_name(table_name)} (#{quoted_column_names})#{tablespace} #{index_options}"
+          if index_type == "UNIQUE"
+            unless quoted_column_names =~ /\(.*\)/
+              execute "ALTER TABLE #{quote_table_name(table_name)} ADD CONSTRAINT #{quote_column_name(index_name)} #{index_type} (#{quoted_column_names})"
+            end
+          end
+        end
+
+        def add_index_options(table_name, column_name, comment: nil, **options) #:nodoc:
+          column_names = Array(column_name)
+          index_name   = index_name(table_name, column: column_names)
+
+          options.assert_valid_keys(:unique, :order, :name, :where, :length, :internal, :tablespace, :options, :using)
+
+          index_type = options[:unique] ? "UNIQUE" : ""
+          index_name = options[:name].to_s if options.key?(:name)
+          tablespace = tablespace_for(:index, options[:tablespace])
+          max_index_length = options.fetch(:internal, false) ? index_name_length : allowed_index_name_length
+          # TODO: This option is used for NOLOGGING, needs better argumetn name
+          index_options = options[:options]
+
+          if index_name.to_s.length > max_index_length
+            raise ArgumentError, "Index name '#{index_name}' on table '#{table_name}' is too long; the limit is #{max_index_length} characters"
+          end
+          if table_exists?(table_name) && index_name_exists?(table_name, index_name)
+            raise ArgumentError, "Index name '#{index_name}' on table '#{table_name}' already exists"
+          end
+
+          quoted_column_names = column_names.map { |e| quote_column_name_or_expression(e) }.join(", ")
+          [index_name, index_type, quoted_column_names, tablespace, index_options]
+        end
+
+        # Remove the given index from the table.
+        # Gives warning if index does not exist
+        def remove_index(table_name, options = {}) #:nodoc:
+          index_name = index_name_for_remove(table_name, options)
+          # TODO: It should execute only when index_type == "UNIQUE"
+          execute "ALTER TABLE #{quote_table_name(table_name)} DROP CONSTRAINT #{quote_column_name(index_name)}" rescue nil
+          execute "DROP INDEX #{quote_column_name(index_name)}"
+        end
+
+        # returned shortened index name if default is too large
+        def index_name(table_name, options) #:nodoc:
+          default_name = super(table_name, options).to_s
+          # sometimes options can be String or Array with column names
+          options = {} unless options.is_a?(Hash)
+          identifier_max_length = options[:identifier_max_length] || index_name_length
+          return default_name if default_name.length <= identifier_max_length
+
+          # remove 'index', 'on' and 'and' keywords
+          shortened_name = "i_#{table_name}_#{Array(options[:column]) * '_'}"
+
+          # leave just first three letters from each word
+          if shortened_name.length > identifier_max_length
+            shortened_name = shortened_name.split("_").map { |w| w[0, 3] }.join("_")
+          end
+          # generate unique name using hash function
+          if shortened_name.length > identifier_max_length
+            shortened_name = "i" + Digest::SHA1.hexdigest(default_name)[0, identifier_max_length - 1]
+          end
+          @logger.warn "#{adapter_name} shortened default index name #{default_name} to #{shortened_name}" if @logger
+          shortened_name
+        end
+
+        # Verify the existence of an index with a given name.
+        #
+        # The default argument is returned if the underlying implementation does not define the indexes method,
+        # as there's no way to determine the correct answer in that case.
+        #
+        # Will always query database and not index cache.
+        def index_name_exists?(table_name, index_name)
+          (owner, table_name, db_link) = @connection.describe(table_name)
+          result = select_value(<<-SQL.strip.gsub(/\s+/, " "), "index name exists")
+            SELECT 1 FROM all_indexes#{db_link} i
+            WHERE i.owner = '#{owner}'
+               AND i.table_owner = '#{owner}'
+               AND i.table_name = '#{table_name}'
+               AND i.index_name = '#{index_name.to_s.upcase}'
+          SQL
+          result == 1
+        end
+
+        def rename_index(table_name, old_name, new_name) #:nodoc:
+          validate_index_length!(table_name, new_name)
+          execute "ALTER INDEX #{quote_column_name(old_name)} rename to #{quote_column_name(new_name)}"
+        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".dup
+          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
+
+        def add_reference(table_name, *args)
+          OracleEnhanced::ReferenceDefinition.new(*args).add_to(update_table_definition(table_name, self))
+        end
+
+        def add_column(table_name, column_name, type, options = {}) #:nodoc:
+          type = aliased_types(type.to_s, type)
+          at = create_alter_table table_name
+          at.add_column(column_name, type, options)
+          add_column_sql = schema_creation.accept at
+          add_column_sql << tablespace_for((type_to_sql(type).downcase.to_sym), nil, table_name, column_name)
+          execute add_column_sql
+          create_sequence_and_trigger(table_name, options) if type && type.to_sym == :primary_key
+          change_column_comment(table_name, column_name, options[:comment]) if options.key?(:comment)
+        end
+
+        def aliased_types(name, fallback)
+          fallback
+        end
+
+        def change_column_default(table_name, column_name, default_or_changes) #:nodoc:
+          default = extract_new_default_value(default_or_changes)
+          execute "ALTER TABLE #{quote_table_name(table_name)} MODIFY #{quote_column_name(column_name)} DEFAULT #{quote(default)}"
+        end
+
+        def change_column_null(table_name, column_name, null, default = nil) #:nodoc:
+          column = column_for(table_name, column_name)
+
+          unless null || default.nil?
+            execute("UPDATE #{quote_table_name(table_name)} SET #{quote_column_name(column_name)}=#{quote(default)} WHERE #{quote_column_name(column_name)} IS NULL")
+          end
+
+          change_column table_name, column_name, column.sql_type, null: null
+        end
+
+        def change_column(table_name, column_name, type, options = {}) #:nodoc:
+          column = column_for(table_name, column_name)
+
+          # remove :null option if its value is the same as current column definition
+          # otherwise Oracle will raise error
+          if options.has_key?(:null) && options[:null] == column.null
+            options[:null] = nil
+          end
+          if type.to_sym == :virtual
+            type = options[:type]
+          end
+
+          td = create_table_definition(table_name)
+          cd = td.new_column_definition(column.name, type, options)
+          change_column_stmt = schema_creation.accept cd
+          change_column_stmt << tablespace_for((type_to_sql(type).downcase.to_sym), nil, options[:table_name], options[:column_name]) if type
+          change_column_sql = "ALTER TABLE #{quote_table_name(table_name)} MODIFY #{change_column_stmt}"
+          execute(change_column_sql)
+
+          change_column_comment(table_name, column_name, options[:comment]) if options.key?(:comment)
+        end
+
+        def rename_column(table_name, column_name, new_column_name) #:nodoc:
+          execute "ALTER TABLE #{quote_table_name(table_name)} RENAME COLUMN #{quote_column_name(column_name)} to #{quote_column_name(new_column_name)}"
+          rename_column_indexes(table_name, column_name, new_column_name)
+        end
+
+        def remove_column(table_name, column_name, type = nil, options = {}) #:nodoc:
+          execute "ALTER TABLE #{quote_table_name(table_name)} DROP COLUMN #{quote_column_name(column_name)} CASCADE CONSTRAINTS"
+        end
+
+        def change_table_comment(table_name, comment)
+          clear_cache!
+          if comment.nil?
+            execute "COMMENT ON TABLE #{quote_table_name(table_name)} IS ''"
+          else
+            execute "COMMENT ON TABLE #{quote_table_name(table_name)} IS #{quote(comment)}"
+          end
+        end
+
+        def change_column_comment(table_name, column_name, comment) #:nodoc:
+          clear_cache!
+          execute "COMMENT ON COLUMN #{quote_table_name(table_name)}.#{quote_column_name(column_name)} IS '#{comment}'"
+        end
+
+        def table_comment(table_name) #:nodoc:
+          (owner, table_name, db_link) = @connection.describe(table_name)
+          select_value(<<-SQL.strip.gsub(/\s+/, " "), "Table comment", [bind_string("owner", owner), bind_string("table_name", table_name)])
+            SELECT comments FROM all_tab_comments#{db_link}
+            WHERE owner = :owner
+              AND table_name = :table_name
+          SQL
+        end
+
+        def table_options(table_name) # :nodoc:
+          if comment = table_comment(table_name)
+            { comment: comment }
+          end
+        end
+
+        def column_comment(table_name, column_name) #:nodoc:
+          # TODO: it  does not exist in Abstract adapter
+          (owner, table_name, db_link) = @connection.describe(table_name)
+          select_value(<<-SQL.strip.gsub(/\s+/, " "), "Column comment", [bind_string("owner", owner), bind_string("table_name", table_name), bind_string("column_name", column_name.upcase)])
+            SELECT comments FROM all_col_comments#{db_link}
+            WHERE owner = :owner
+              AND table_name = :table_name
+              AND column_name = :column_name
+          SQL
+        end
+
+        # Maps logical Rails types to Oracle-specific data types.
+        def type_to_sql(type, limit: nil, precision: nil, scale: nil, **) #:nodoc:
+          # Ignore options for :text, :ntext and :binary columns
+          return super(type) if ["text", "ntext", "binary"].include?(type.to_s)
+
+          super
+        end
+
+        def tablespace(table_name)
+          select_value(<<-SQL.strip.gsub(/\s+/, " "), "tablespace")
+            SELECT tablespace_name
+            FROM all_tables
+            WHERE table_name='#{table_name.to_s.upcase}'
+            AND owner = SYS_CONTEXT('userenv', 'session_user')
+          SQL
+        end
+
+        # 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.strip.gsub(/\s+/, " "), "Foreign Keys", [bind_string("owner", owner), bind_string("desc_table_name", desc_table_name)])
+            SELECT r.table_name to_table
+                  ,rc.column_name references_column
+                  ,cc.column_name
+                  ,c.constraint_name name
+                  ,c.delete_rule
+              FROM all_constraints#{db_link} c, all_cons_columns#{db_link} cc,
+                   all_constraints#{db_link} r, all_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
+
+          fk_info.map do |row|
+            options = {
+              column: oracle_downcase(row["column_name"]),
+              name: oracle_downcase(row["name"]),
+              primary_key: oracle_downcase(row["references_column"])
+            }
+            options[:on_delete] = extract_foreign_key_action(row["delete_rule"])
+            ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.new(oracle_downcase(table_name), oracle_downcase(row["to_table"]), options)
+          end
+        end
+
+        def extract_foreign_key_action(specifier) # :nodoc:
+          case specifier
+          when "CASCADE"; :cascade
+          when "SET NULL"; :nullify
+          end
+        end
+
+        # REFERENTIAL INTEGRITY ====================================
+
+        def disable_referential_integrity(&block) #:nodoc:
+          old_constraints = select_all(<<-SQL.strip.gsub(/\s+/, " "), "Foreign Keys to disable and enable")
+          SELECT constraint_name, owner, table_name
+            FROM all_constraints
+            WHERE constraint_type = 'R'
+            AND status = 'ENABLED'
+            AND owner = SYS_CONTEXT('userenv', 'session_user')
+          SQL
+          begin
+            old_constraints.each do |constraint|
+              execute "ALTER TABLE #{quote_table_name(constraint["table_name"])} DISABLE CONSTRAINT #{quote_table_name(constraint["constraint_name"])}"
+            end
+            yield
+          ensure
+            old_constraints.each do |constraint|
+              execute "ALTER TABLE #{quote_table_name(constraint["table_name"])} ENABLE CONSTRAINT #{quote_table_name(constraint["constraint_name"])}"
+            end
+          end
+        end
+
+        def create_alter_table(name)
+          OracleEnhanced::AlterTable.new create_table_definition(name, false, {})
+        end
+
+        def update_table_definition(table_name, base)
+          OracleEnhanced::Table.new(table_name, base)
+        end
+
+        def create_schema_dumper(options)
+          OracleEnhanced::SchemaDumper.create(self, options)
+        end
+
+        private
+
+          def schema_creation
+            OracleEnhanced::SchemaCreation.new self
+          end
+
+          def create_table_definition(*args)
+            OracleEnhanced::TableDefinition.new(*args)
+          end
+
+          def new_column_from_field(table_name, field)
+            limit, scale = field["limit"], field["scale"]
+            if limit || scale
+              field["sql_type"] += "(#{(limit || 38).to_i}" + ((scale = scale.to_i) > 0 ? ",#{scale})" : ")")
+            end
+
+            if field["sql_type_owner"]
+              field["sql_type"] = field["sql_type_owner"] + "." + field["sql_type"]
+            end
+
+            is_virtual = field["virtual_column"] == "YES"
+
+            # clean up odd default spacing from Oracle
+            if field["data_default"] && !is_virtual
+              field["data_default"].sub!(/^(.*?)\s*$/, '\1')
+
+              # If a default contains a newline these cleanup regexes need to
+              # match newlines.
+              field["data_default"].sub!(/^'(.*)'$/m, '\1')
+              field["data_default"] = nil if field["data_default"] =~ /^(null|empty_[bc]lob\(\))$/i
+              # TODO: Needs better fix to fallback "N" to false
+              field["data_default"] = false if (field["data_default"] == "N" && OracleEnhancedAdapter.emulate_booleans_from_strings)
+            end
+
+            type_metadata = fetch_type_metadata(field["sql_type"], is_virtual)
+            default_value = extract_value_from_default(field["data_default"])
+            default_value = nil if is_virtual
+            OracleEnhanced::Column.new(oracle_downcase(field["name"]),
+                             default_value,
+                             type_metadata,
+                             field["nullable"] == "Y",
+                             table_name,
+                             field["column_comment"]
+                      )
+          end
+
+          def fetch_type_metadata(sql_type, virtual = nil)
+            OracleEnhanced::TypeMetadata.new(super(sql_type), virtual: virtual)
+          end
+
+          def tablespace_for(obj_type, tablespace_option, table_name = nil, column_name = nil)
+            tablespace_sql = "".dup
+            if tablespace = (tablespace_option || default_tablespace_for(obj_type))
+              if [:blob, :clob, :nclob].include?(obj_type.to_sym)
+                tablespace_sql << " LOB (#{quote_column_name(column_name)}) STORE AS #{column_name.to_s[0..10]}_#{table_name.to_s[0..14]}_ls (TABLESPACE #{tablespace})"
+              else
+                tablespace_sql << " TABLESPACE #{tablespace}"
+              end
+            end
+            tablespace_sql
+          end
+
+          def default_tablespace_for(type)
+            (default_tablespaces[type] || default_tablespaces[native_database_types[type][:name]]) rescue nil
+          end
+
+          def column_for(table_name, column_name)
+            unless column = columns(table_name).find { |c| c.name == column_name.to_s }
+              raise "No such column: #{table_name}.#{column_name}"
+            end
+            column
+          end
+
+          def create_sequence_and_trigger(table_name, options)
+            seq_name = options[:sequence_name] || default_sequence_name(table_name)
+            seq_start_value = options[:sequence_start_value] || default_sequence_start_value
+            execute "CREATE SEQUENCE #{quote_table_name(seq_name)} START WITH #{seq_start_value}"
+
+            create_primary_key_trigger(table_name, options) if options[:primary_key_trigger]
+          end
+
+          def create_primary_key_trigger(table_name, options)
+            seq_name = options[:sequence_name] || default_sequence_name(table_name)
+            trigger_name = options[:trigger_name] || default_trigger_name(table_name)
+            primary_key = options[:primary_key] || Base.get_primary_key(table_name.to_s.singularize)
+            execute <<-SQL
+            CREATE OR REPLACE TRIGGER #{quote_table_name(trigger_name)}
+            BEFORE INSERT ON #{quote_table_name(table_name)} FOR EACH ROW
+            BEGIN
+              IF inserting THEN
+                IF :new.#{quote_column_name(primary_key)} IS NULL THEN
+                  SELECT #{quote_table_name(seq_name)}.NEXTVAL INTO :new.#{quote_column_name(primary_key)} FROM dual;
+                END IF;
+              END IF;
+            END;
+          SQL
+          end
+
+          def default_trigger_name(table_name)
+            # truncate table name if necessary to fit in max length of identifier
+            "#{table_name.to_s[0, table_name_length - 4]}_pkt"
+          end
+
+          def rebuild_primary_key_index_to_default_tablespace(table_name, options)
+            tablespace = default_tablespace_for(:index)
+
+            return unless tablespace
+
+            index_name = select_value(<<-SQL.strip.gsub(/\s+/, " "), "Index name for primary key",  [bind_string("table_name", table_name.upcase)])
+              SELECT index_name FROM all_constraints
+                  WHERE table_name = :table_name
+                  AND constraint_type = 'P'
+                  AND owner = SYS_CONTEXT('userenv', 'current_schema')
+            SQL
+
+            return unless index_name
+
+            execute("ALTER INDEX #{quote_column_name(index_name)} REBUILD TABLESPACE #{tablespace}")
+          end
+      end
+    end
+  end
+end