torque-postgresql 3.4.1 → 4.0.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c61aaf577483288d5c9a9af30704402529c86318cbdc312f567b643955c1443e
-  data.tar.gz: ccb9930f10cd48eb08448ecd99275fd7ca7ef54443fab81476c6b3a57c03e394
+  metadata.gz: 4a341f61802bc246d4004168a49fc5f67156b7dc3c962321a28e73fc8288e0db
+  data.tar.gz: ca658f344ed87f29b94eb1e115a13b4ef6d4d954c450b6f4e9892f7788b35e39
 SHA512:
-  metadata.gz: 34ed5cb4bb34b33de90020a7053378378b28ff0f45cc7a33e53084fa86c9069ab7694890fa0cac1ab19a85f5ee825cc317d3406cf8f98d4336ff416a2bae092b
-  data.tar.gz: 22771a0e4b1ce1486ae0ae6700c81cbbf84b227bb78b1a7163be2d2948b7161e822bb32dfdcc399c103348e2ab89f8cdda04112f988d303fd0735e178a605043
+  metadata.gz: 4e83150ee16db03f72e39d85c33932f38f43351501e673133e42f7df98208cacfe34e9eb0b505ede452fae872b770c5de9c8cdded5927b5d527fc9b6a7757dc7
+  data.tar.gz: 91c9b79d9698c720c5ed77a775f9758069ac41c5fd625c7870180e85a8f4ed16a4998c4b93ff8de04eb6e828b689046801b9a3e7c76efeef22dc0a91b9083797

data/lib/torque/postgresql/adapter/database_statements.rb

@@ -5,7 +5,7 @@ module Torque
     module Adapter
       module DatabaseStatements
 
-        EXTENDED_DATABASE_TYPES = %i(enum enum_set interval)
+        EXTENDED_DATABASE_TYPES = %i[enum enum_set interval]
 
         # Switch between dump mode or not
         def dump_mode!
@@ -48,8 +48,8 @@ module Torque
         def schema_exists?(name, filtered: true)
           return user_defined_schemas.include?(name.to_s) if filtered
 
-          query_value(<<-SQL) == 1
-            SELECT 1 FROM pg_catalog.pg_namespace WHERE nspname = '#{name}'
+          query_value(<<-SQL, "SCHEMA") == 1
+            SELECT 1 FROM pg_catalog.pg_namespace WHERE nspname = #{quote(name)}
           SQL
         end
 
@@ -59,96 +59,75 @@ module Torque
         end
         alias data_type_exists? type_exists?
 
-        # Configure the interval format
-        def configure_connection
-          super
-          execute("SET SESSION IntervalStyle TO 'iso_8601'", 'SCHEMA')
-        end
-
-        # Since enums create new types, type map needs to be rebooted to include
-        # the new ones, both normal and array one
-        def create_enum(name, *)
-          super
-
-          oid = query_value("SELECT #{quote(name)}::regtype::oid", "SCHEMA").to_i
-          load_additional_types([oid])
-        end
-
         # Change some of the types being mapped
         def initialize_type_map(m = type_map)
           super
-          m.register_type 'box',      OID::Box.new
-          m.register_type 'circle',   OID::Circle.new
-          m.register_type 'interval', OID::Interval.new
-          m.register_type 'line',     OID::Line.new
-          m.register_type 'segment',  OID::Segment.new
 
-          m.alias_type 'regclass', 'varchar'
+          if PostgreSQL.config.geometry.enabled
+            m.register_type 'box',      OID::Box.new
+            m.register_type 'circle',   OID::Circle.new
+            m.register_type 'line',     OID::Line.new
+            m.register_type 'segment',  OID::Segment.new
+          end
+
+          if PostgreSQL.config.interval.enabled
+            m.register_type 'interval', OID::Interval.new
+          end
         end
 
         # :nodoc:
         def load_additional_types(oids = nil)
+          type_map.alias_type 'regclass', 'varchar'
+          type_map.alias_type 'regconfig', 'varchar'
           super
           torque_load_additional_types(oids)
         end
 
         # Add the composite types to be loaded too.
         def torque_load_additional_types(oids = nil)
-          filter = ("AND     a.typelem::integer IN (%s)" % oids.join(', ')) if oids
-
-          query = <<-SQL
-            SELECT      a.typelem AS oid, t.typname, t.typelem,
-                        t.typdelim, t.typbasetype, t.typtype,
-                        t.typarray
-            FROM        pg_type t
-            INNER JOIN  pg_type a ON (a.oid = t.typarray)
-            LEFT JOIN   pg_catalog.pg_namespace n ON n.oid = t.typnamespace
-            WHERE       n.nspname NOT IN ('pg_catalog', 'information_schema')
-            AND     t.typtype IN ( 'e' )
-            #{filter}
-            AND     NOT EXISTS(
-                      SELECT 1 FROM pg_catalog.pg_type el
-                        WHERE el.oid = t.typelem AND el.typarray = t.oid
-                      )
-            AND     (t.typrelid = 0 OR (
-                      SELECT c.relkind = 'c' FROM pg_catalog.pg_class c
-                        WHERE c.oid = t.typrelid
-                      ))
+          return unless torque_load_additional_types?
+
+          # Types: (b)ase, (c)omposite, (d)omain, (e)num, (p)seudotype, (r)ange
+          # (m)ultirange
+
+          query = <<~SQL
+            SELECT t.oid, t.typname, t.typelem, t.typdelim, t.typinput,
+                   r.rngsubtype, t.typtype, t.typbasetype, t.typarray
+            FROM pg_type as t
+            LEFT JOIN pg_range as r ON oid = rngtypid
+            LEFT JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
+            WHERE n.nspname NOT IN ('pg_catalog', 'information_schema')
           SQL
 
-          execute_and_clear(query, 'SCHEMA', []) do |records|
-            records.each { |row| OID::Enum.create(row, type_map) }
+          if oids
+            query += " AND t.oid IN (%s)" % oids.join(", ")
+          else
+            query += " AND t.typtype IN ('e')"
           end
+
+          options = { allow_retry: true, materialize_transactions: false }
+          internal_execute(query, 'SCHEMA', **options).each do |row|
+            if row['typtype'] == 'e' && PostgreSQL.config.enum.enabled
+              OID::Enum.create(row, type_map)
+            end
+          end
+        end
+
+        def torque_load_additional_types?
+          PostgreSQL.config.enum.enabled
         end
 
         # Gets a list of user defined types.
         # You can even choose the +category+ filter
         def user_defined_types(*categories)
-          category_condition = categories.present? \
-            ? "AND t.typtype IN ('#{categories.join("', '")}')" \
-            : "AND t.typtype NOT IN ('b', 'd')"
-
-          select_all(<<-SQL, 'SCHEMA').rows.to_h
-            SELECT t.typname AS name,
-                   CASE t.typtype
-                     WHEN 'e' THEN 'enum'
-                     END     AS type
-            FROM pg_type t
-                   LEFT JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
+          categories = categories.compact.presence || %w[c e p r m]
+
+          query(<<-SQL, 'SCHEMA').to_h
+            SELECT t.typname, t.typtype
+            FROM pg_type as t
+            LEFT JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
             WHERE n.nspname NOT IN ('pg_catalog', 'information_schema')
-              #{category_condition}
-              AND NOT EXISTS(
-                SELECT 1
-                FROM pg_catalog.pg_type el
-                WHERE el.oid = t.typelem
-                  AND el.typarray = t.oid
-              )
-              AND (t.typrelid = 0 OR (
-              SELECT c.relkind = 'c'
-              FROM pg_catalog.pg_class c
-              WHERE c.oid = t.typrelid
-            ))
-            ORDER BY t.typtype DESC
+            AND t.typtype IN ('#{categories.join("', '")}')
           SQL
         end
 
@@ -195,20 +174,20 @@ module Torque
         # Get the list of columns, and their definition, but only from the
         # actual table, does not include columns that comes from inherited table
         def column_definitions(table_name)
-          local = 'AND a.attislocal' if @_dump_mode
-
-          query(<<-SQL, 'SCHEMA')
-            SELECT a.attname, format_type(a.atttypid, a.atttypmod),
-                    pg_get_expr(d.adbin, d.adrelid), a.attnotnull, a.atttypid, a.atttypmod,
-                    c.collname, col_description(a.attrelid, a.attnum) AS comment,
-                    #{supports_virtual_columns? ? 'attgenerated' : quote('')} as attgenerated
-              FROM pg_attribute a
-              LEFT JOIN pg_attrdef d ON a.attrelid = d.adrelid AND a.attnum = d.adnum
-              LEFT JOIN pg_type t ON a.atttypid = t.oid
-              LEFT JOIN pg_collation c ON a.attcollation = c.oid AND a.attcollation <> t.typcollation
-              WHERE a.attrelid = #{quote(quote_table_name(table_name))}::regclass
-                AND a.attnum > 0 AND NOT a.attisdropped #{local}
-              ORDER BY a.attnum
+          query(<<~SQL, "SCHEMA")
+              SELECT a.attname, format_type(a.atttypid, a.atttypmod),
+                     pg_get_expr(d.adbin, d.adrelid), a.attnotnull, a.atttypid, a.atttypmod,
+                     c.collname, col_description(a.attrelid, a.attnum) AS comment,
+                     #{supports_identity_columns? ? 'attidentity' : quote('')} AS identity,
+                     #{supports_virtual_columns? ? 'attgenerated' : quote('')} as attgenerated
+                FROM pg_attribute a
+                LEFT JOIN pg_attrdef d ON a.attrelid = d.adrelid AND a.attnum = d.adnum
+                LEFT JOIN pg_type t ON a.atttypid = t.oid
+                LEFT JOIN pg_collation c ON a.attcollation = c.oid AND a.attcollation <> t.typcollation
+               WHERE a.attrelid = #{quote(quote_table_name(table_name))}::regclass
+                 AND a.attnum > 0 AND NOT a.attisdropped
+                 #{'AND a.attislocal' if @_dump_mode}
+               ORDER BY a.attnum
           SQL
         end
 

data/lib/torque/postgresql/adapter/oid/array.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Torque
+  module PostgreSQL
+    module Adapter
+      module OID
+        module Array
+          def force_equality?(value)
+            PostgreSQL.config.predicate_builder.handle_array_attributes ? false : super
+          end
+        end
+
+        ::ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array.prepend(Array)
+      end
+    end
+  end
+end

data/lib/torque/postgresql/adapter/oid/line.rb

@@ -7,9 +7,7 @@ module Torque
       alias c= intercept=
 
       def a=(value)
-        self.slope = vertical? \
-          ? Float::INFINITY \
-          : Rational(value, b)
+        self.slope = vertical? ? Float::INFINITY : Rational(value, b)
       end
 
       def a
@@ -17,9 +15,7 @@ module Torque
       end
 
       def b=(value)
-        self.slope = value.zero? \
-          ? Float::INFINITY \
-          : Rational(a, value)
+        self.slope = value.zero? ? Float::INFINITY : Rational(a, value)
       end
 
       def b

data/lib/torque/postgresql/adapter/oid/range.rb

@@ -7,7 +7,7 @@ module Torque
         class Range < ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Range
           HASH_PICK = %i[from start end to].freeze
 
-          module Comparasion
+          module Comparison
             def <=>(other)
               return super unless other.acts_like?(:date) || other.acts_like?(:time)
               other = other.to_time if other.acts_like?(:date)
@@ -17,9 +17,9 @@ module Torque
 
           def cast_value(value)
             case value
-            when Array
+            when ::Array
               cast_custom(value[0], value[1])
-            when Hash
+            when ::Hash
               pieces = value.with_indifferent_access.values_at(*HASH_PICK)
               cast_custom(pieces[0] || pieces[1], pieces[2] || pieces[3])
             else
@@ -54,7 +54,7 @@ module Torque
         ::ActiveRecord::ConnectionAdapters::PostgreSQL::OID.send(:remove_const, :Range)
         ::ActiveRecord::ConnectionAdapters::PostgreSQL::OID.const_set(:Range, Range)
 
-        ::Float.prepend(Range::Comparasion)
+        ::Float.prepend(Range::Comparison)
       end
     end
   end

data/lib/torque/postgresql/adapter/oid.rb

@@ -1,24 +1,2 @@
-require_relative 'oid/box'
-require_relative 'oid/circle'
-require_relative 'oid/enum'
-require_relative 'oid/enum_set'
-require_relative 'oid/interval'
-require_relative 'oid/line'
+require_relative 'oid/array'
 require_relative 'oid/range'
-require_relative 'oid/segment'
-
-module Torque
-  module PostgreSQL
-    module Adapter
-      module OID
-      end
-
-      ActiveRecord::Type.register(:box,      OID::Box,      adapter: :postgresql)
-      ActiveRecord::Type.register(:circle,   OID::Circle,   adapter: :postgresql)
-      ActiveRecord::Type.register(:enum,     OID::Enum,     adapter: :postgresql)
-      ActiveRecord::Type.register(:enum_set, OID::EnumSet,  adapter: :postgresql)
-      ActiveRecord::Type.register(:line,     OID::Line,     adapter: :postgresql)
-      ActiveRecord::Type.register(:segment,  OID::Segment,  adapter: :postgresql)
-    end
-  end
-end

data/lib/torque/postgresql/adapter/quoting.rb

@@ -4,21 +4,27 @@ module Torque
   module PostgreSQL
     module Adapter
       module Quoting
+        QUOTED_TYPE_NAMES = Concurrent::Map.new
 
         Name = ActiveRecord::ConnectionAdapters::PostgreSQL::Name
         Column = ActiveRecord::ConnectionAdapters::PostgreSQL::Column
         ColumnDefinition = ActiveRecord::ConnectionAdapters::ColumnDefinition
+        Utils = ActiveRecord::ConnectionAdapters::PostgreSQL::Utils
 
         # Quotes type names for use in SQL queries.
-        def quote_type_name(string, schema = nil)
-          name_schema, table = string.to_s.scan(/[^".\s]+|"[^"]*"/)
-          if table.nil?
-            table = name_schema
-            name_schema = nil
+        def quote_type_name(name, *args)
+          QUOTED_TYPE_NAMES[args] ||= begin
+            name = name.to_s
+            args << 'public' if args.empty? && !name.include?('.')
+            quote_identifier_name(name, *args)
           end
+        end
 
-          schema = schema || name_schema || 'public'
-          Name.new(schema, table).quoted
+        # Make sure to support all sorts of different compositions of names
+        def quote_identifier_name(name, schema = nil)
+          name = Utils.extract_schema_qualified_name(name.to_s) unless name.is_a?(Name)
+          name.instance_variable_set(:@schema, Utils.unquote_identifier(schema.to_s)) if schema
+          name.quoted.freeze
         end
 
         def quote_default_expression(value, column)

data/lib/torque/postgresql/adapter/schema_creation.rb

@@ -3,39 +3,18 @@ module Torque
     module Adapter
       module SchemaCreation
 
-        # Redefine original table creation command to ensure PostgreSQL standard
-        def visit_TableDefinition(o)
-          create_sql = +"CREATE#{table_modifier_in_create(o)} TABLE "
-          create_sql << "IF NOT EXISTS " if o.if_not_exists
-          create_sql << "#{quote_table_name(o.name)} "
-
-          statements = o.columns.map { |c| accept c }
-          statements << accept(o.primary_keys) if o.primary_keys
-
-          if supports_indexes_in_create?
-            statements.concat(o.indexes.map { |c, o| index_in_create(o.name, c, o) })
-          end
-
-          if @conn.supports_foreign_keys?
-            statements.concat(o.foreign_keys.map { |fk| accept fk })
-          end
-
-          if respond_to?(:supports_check_constraints?) && supports_check_constraints?
-            statements.concat(o.check_constraints.map { |chk| accept chk })
-          end
-
-          create_sql << "(#{statements.join(', ')})" \
-            if statements.present? || o.inherits.present?
-
-          add_table_options!(create_sql, o)
-
+        # Inherits are now setup via table options, but keep the implementation
+        # supported by this gem
+        def add_table_options!(create_sql, o)
           if o.inherits.present?
+            # Make sure we always have parenthesis
+            create_sql << '()' unless create_sql[-1] == ')'
+
             tables = o.inherits.map(&method(:quote_table_name))
             create_sql << " INHERITS ( #{tables.join(' , ')} )"
           end
 
-          create_sql << " AS #{to_sql(o.as)}" if o.as
-          create_sql
+          super(create_sql, o)
         end
       end
 

data/lib/torque/postgresql/adapter/schema_definitions.rb

@@ -3,7 +3,26 @@
 module Torque
   module PostgreSQL
     module Adapter
+      module ColumnMethods
+
+        # Adds a search language column to the table. See +add_search_language+
+        def search_language(*names, **options)
+          raise ArgumentError, "Missing column name(s) for search_language" if names.empty?
+          names.each { |name| column(name, :regconfig, **options) }
+        end
+
+        # Add a search vector column to the table. See +add_search_vector+
+        def search_vector(*names, columns:, **options)
+          raise ArgumentError, "Missing column name(s) for search_vector" if names.empty?
+          options = Attributes::Builder.search_vector_options(columns: columns, **options)
+          names.each { |name| column(name, :virtual, **options) }
+        end
+
+      end
+
       module TableDefinition
+        include ColumnMethods
+
         attr_reader :inherits
 
         def initialize(*args, **options)
@@ -12,8 +31,25 @@ module Torque
           @inherits = Array.wrap(options.delete(:inherits)).flatten.compact \
             if options.key?(:inherits)
         end
+
+        def set_primary_key(tn, id, primary_key, *, **)
+          super unless @inherits.present? && primary_key.blank? && id == :primary_key
+        end
+
+        private
+
+          def create_column_definition(name, type, options)
+            if type == :enum_set
+              type = :enum
+              options ||= {}
+              options[:array] = true
+            end
+
+            super(name, type, options)
+          end
       end
 
+      ActiveRecord::ConnectionAdapters::PostgreSQL::Table.include ColumnMethods
       ActiveRecord::ConnectionAdapters::PostgreSQL::TableDefinition.include TableDefinition
     end
   end

data/lib/torque/postgresql/adapter/schema_dumper.rb

@@ -4,6 +4,14 @@ module Torque
   module PostgreSQL
     module Adapter
       module SchemaDumper
+        SEARCH_VECTOR_SCANNER = /
+          to_tsvector\(
+            ('[^']+'|[a-z][a-z0-9_]*)[^,]*,[^\(]*
+            \(?coalesce\(([a-z][a-z0-9_]*)[^\)]*\)\)?
+          (?:::[^\)]*\))?
+          (?:\s*,\s*'([A-D])')?
+        /ix
+
         def dump(stream) # :nodoc:
           @connection.dump_mode!
           super
@@ -12,16 +20,6 @@ module Torque
           stream
         end
 
-        def extensions(stream) # :nodoc:
-          super
-          user_defined_schemas(stream)
-        end
-
-        # Translate +:enum_set+ into +:enum+
-        def schema_type(column)
-          column.type == :enum_set ? :enum : super
-        end
-
         private
 
           def tables(stream) # :nodoc:
@@ -39,41 +37,46 @@ module Torque
 
           def dump_tables(stream)
             inherited_tables = @connection.inherited_tables
-            sorted_tables = (@connection.tables - @connection.views).sort_by do |table_name|
-              table_name.split(/(?:public)?\./).reverse
-            end
+            sorted_tables = (@connection.tables - @connection.views).filter_map do |table_name|
+              name_parts = table_name.split(/(?:public)?\./).reverse.compact_blank
+              next if ignored?(table_name) || ignored?(name_parts.join('.'))
+
+              [table_name, name_parts]
+            end.sort_by(&:last).to_h
+
+            postponed = []
 
             stream.puts "  # These are the common tables"
-            (sorted_tables - inherited_tables.keys).each do |table_name|
-              table(table_name, stream) unless ignored?(table_name)
+            sorted_tables.each do |table, (table_name, _)|
+              next postponed << table if inherited_tables.key?(table_name)
+
+              table(table, stream)
+              stream.puts # Ideally we would not do this in the last one
             end
 
-            if inherited_tables.present?
+            if postponed.present?
               stream.puts "  # These are tables that have inheritance"
-              inherited_tables.each do |table_name, inherits|
-                next if ignored?(table_name)
-
+              postponed.each do |table|
                 sub_stream = StringIO.new
-                table(table_name, sub_stream)
-
-                # Add the inherits setting
-                sub_stream.rewind
-                inherits.map! { |parent| parent.to_s.sub(/\Apublic\./, '') }
-                inherits = inherits.first if inherits.size === 1
-                inherits = ", inherits: #{inherits.inspect} do |t|"
-                table_dump = sub_stream.read.gsub(/ do \|t\|$/, inherits)
-
-                # Ensure bodyless definitions
-                table_dump.gsub!(/do \|t\|\n  end/, '')
-                stream.print table_dump
+                table(table, sub_stream)
+                stream.puts sub_stream.string.sub(/do \|t\|\n  end/, '')
+                stream.puts
               end
             end
 
-            # Dump foreign keys at the end to make sure all dependent tables exist.
+            # Fixes double new lines to single new lines
+            stream.pos -= 1
+
+            # dump foreign keys at the end to make sure all dependent tables exist.
             if @connection.supports_foreign_keys?
+              foreign_keys_stream = StringIO.new
               sorted_tables.each do |tbl|
-                foreign_keys(tbl, stream) unless ignored?(tbl)
+                foreign_keys(tbl, foreign_keys_stream)
               end
+
+              foreign_keys_string = foreign_keys_stream.string
+              stream.puts if foreign_keys_string.length > 0
+              stream.print foreign_keys_string
             end
           end
 
@@ -83,7 +86,8 @@ module Torque
           end
 
           # Dump user defined schemas
-          def user_defined_schemas(stream)
+          def schemas(stream)
+            return super if !PostgreSQL.config.schemas.enabled
             return if (list = (@connection.user_defined_schemas - ['public'])).empty?
 
             stream.puts "  # Custom schemas defined in this database."
@@ -91,6 +95,58 @@ module Torque
             stream.puts
           end
 
+          # Adjust the schema type for search vector
+          def schema_type_with_virtual(column)
+            column.virtual? && column.type == :tsvector ? :search_vector : super
+          end
+
+          # Adjust the schema type for search language
+          def schema_type(column)
+            column.sql_type == 'regconfig' ? :search_language : super
+          end
+
+          # Adjust table options to make the dump more readable
+          def prepare_column_options(column)
+            options = super
+            parse_search_vector_options(column, options) if column.type == :tsvector
+            options
+          end
+
+          # Parse the search vector operation into a readable format
+          def parse_search_vector_options(column, options)
+            settings = options[:as].scan(SEARCH_VECTOR_SCANNER)
+            return if settings.empty?
+
+            languages = settings.map(&:shift).uniq
+            return if languages.many?
+
+            language = languages.first
+            language = language[0] == "'" ? language[1..-2] : language.to_sym
+            columns = parse_search_vector_columns(settings)
+
+            options.except!(:as, :type)
+            options.merge!(language: language.inspect, columns: columns)
+          end
+
+          # Simplify the whole columns configuration to make it more manageable
+          def parse_search_vector_columns(settings)
+            return ":#{settings.first.first}" if settings.one?
+
+            settings = settings.sort_by(&:last)
+            weights = %w[A B C D]
+
+            columns = settings.each.with_index.reduce([]) do |acc, (setting, index)|
+              column, weight = setting
+              break if (weights[index] || 'D') != weight
+
+              acc << column
+              acc
+            end
+
+            return columns.map(&:to_sym).inspect if columns
+            settings.to_h.transform_values(&:inspect)
+          end
+
           def fx_functions_position
             return unless defined?(::Fx::SchemaDumper::Function)
             Fx.configuration.dump_functions_at_beginning_of_schema ? :beginning : :end

data/lib/torque/postgresql/adapter/schema_overrides.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Torque
+  module PostgreSQL
+    module Adapter
+      module SchemaOverrides
+        # This adds better support for handling the quotation of table names
+        def quote_table_name(name)
+          ActiveRecord::ConnectionAdapters::PostgreSQL::Quoting::QUOTED_TABLE_NAMES.then do |m|
+            m[name] ||= quote_identifier_name(name)
+          end
+        end
+
+        %i[
+          table_exists? indexes index_exists? columns column_exists? primary_key
+          create_table change_table add_column add_columns remove_columns remove_column
+          change_column change_column_default change_column_null rename_column
+          add_index remove_index rename_index index_name_exists? foreign_keys
+          add_timestamps remove_timestamps change_table_comment change_column_comment
+          bulk_change_table
+
+          rename_table add_foreign_key remove_foreign_key foreign_key_exists?
+        ].each do |method_name|
+          define_method(method_name) do |table_name, *args, **options, &block|
+            table_name = sanitize_name_with_schema(table_name, options)
+            super(table_name, *args, **options, &block)
+          end
+        end
+
+        def drop_table(*table_names, **options)
+          table_names = table_names.map { |name| sanitize_name_with_schema(name, options.dup) }
+          super(*table_names, **options)
+        end
+
+        private
+
+          def validate_table_length!(table_name)
+            super(table_name.to_s)
+          end
+      end
+
+      include SchemaOverrides
+    end
+  end
+end