activerecord 5.1.0.beta1 → 5.1.0.rc1

data/lib/active_record/connection_adapters/abstract_adapter.rb

@@ -154,8 +154,8 @@ module ActiveRecord
         Arel::Visitors::ToSql.new(self)
       end
 
-      def valid_type?(type)
-        false
+      def valid_type?(type) # :nodoc:
+        !native_database_types[type].nil?
       end
 
       def schema_creation
@@ -232,10 +232,10 @@ module ActiveRecord
         self.class::ADAPTER_NAME
       end
 
-      # Does this adapter support migrations?
-      def supports_migrations?
-        false
+      def supports_migrations? # :nodoc:
+        true
       end
+      deprecate :supports_migrations?
 
       def supports_primary_key? # :nodoc:
         true
@@ -439,6 +439,9 @@ module ActiveRecord
       # This is done under the hood by calling #active?. If the connection
       # is no longer active, then this method will reconnect to the database.
       def verify!(*ignored)
+        if ignored.size > 0
+          ActiveSupport::Deprecation.warn("Passing arguments to #verify method of the connection has no effect and has been deprecated. Please remove all arguments from the #verify method call.")
+        end
         reconnect! unless active?
       end
 

data/lib/active_record/connection_adapters/abstract_mysql_adapter.rb

@@ -6,6 +6,7 @@ require "active_record/connection_adapters/mysql/quoting"
 require "active_record/connection_adapters/mysql/schema_creation"
 require "active_record/connection_adapters/mysql/schema_definitions"
 require "active_record/connection_adapters/mysql/schema_dumper"
+require "active_record/connection_adapters/mysql/schema_statements"
 require "active_record/connection_adapters/mysql/type_metadata"
 
 require "active_support/core_ext/string/strip"
@@ -15,6 +16,7 @@ module ActiveRecord
     class AbstractMysqlAdapter < AbstractAdapter
       include MySQL::Quoting
       include MySQL::ColumnDumper
+      include MySQL::SchemaStatements
 
       def update_table_definition(table_name, base) # :nodoc:
         MySQL::Table.new(table_name, base)
@@ -89,11 +91,6 @@ module ActiveRecord
         /mariadb/i.match?(full_version)
       end
 
-      # Returns true, since this connection adapter supports migrations.
-      def supports_migrations?
-        true
-      end
-
       def supports_bulk_alter? #:nodoc:
         true
       end
@@ -315,57 +312,6 @@ module ActiveRecord
         show_variable "collation_database"
       end
 
-      def tables # :nodoc:
-        sql = "SELECT table_name FROM information_schema.tables WHERE table_type = 'BASE TABLE'"
-        sql << " AND table_schema = #{quote(@config[:database])}"
-
-        select_values(sql, "SCHEMA")
-      end
-
-      def views # :nodoc:
-        select_values("SHOW FULL TABLES WHERE table_type = 'VIEW'", "SCHEMA")
-      end
-
-      def data_sources # :nodoc:
-        sql = "SELECT table_name FROM information_schema.tables "
-        sql << "WHERE table_schema = #{quote(@config[:database])}"
-
-        select_values(sql, "SCHEMA")
-      end
-
-      def table_exists?(table_name) # :nodoc:
-        return false unless table_name.present?
-
-        schema, name = extract_schema_qualified_name(table_name)
-
-        sql = "SELECT table_name FROM information_schema.tables WHERE table_type = 'BASE TABLE'"
-        sql << " AND table_schema = #{quote(schema)} AND table_name = #{quote(name)}"
-
-        select_values(sql, "SCHEMA").any?
-      end
-
-      def data_source_exists?(table_name) # :nodoc:
-        return false unless table_name.present?
-
-        schema, name = extract_schema_qualified_name(table_name)
-
-        sql = "SELECT table_name FROM information_schema.tables "
-        sql << "WHERE table_schema = #{quote(schema)} AND table_name = #{quote(name)}"
-
-        select_values(sql, "SCHEMA").any?
-      end
-
-      def view_exists?(view_name) # :nodoc:
-        return false unless view_name.present?
-
-        schema, name = extract_schema_qualified_name(view_name)
-
-        sql = "SELECT table_name FROM information_schema.tables WHERE table_type = 'VIEW'"
-        sql << " AND table_schema = #{quote(schema)} AND table_name = #{quote(name)}"
-
-        select_values(sql, "SCHEMA").any?
-      end
-
       def truncate(table_name, name = nil)
         execute "TRUNCATE TABLE #{quote_table_name(table_name)}", name
       end
@@ -411,13 +357,13 @@ module ActiveRecord
       end
 
       def table_comment(table_name) # :nodoc:
-        schema, name = extract_schema_qualified_name(table_name)
+        scope = quoted_scope(table_name)
 
         select_value(<<-SQL.strip_heredoc, "SCHEMA")
           SELECT table_comment
           FROM information_schema.tables
-          WHERE table_schema = #{quote(schema)}
-            AND table_name = #{quote(name)}
+          WHERE table_schema = #{scope[:schema]}
+            AND table_name = #{scope[:name]}
         SQL
       end
 
@@ -517,7 +463,7 @@ module ActiveRecord
       def foreign_keys(table_name)
         raise ArgumentError unless table_name.present?
 
-        schema, name = extract_schema_qualified_name(table_name)
+        scope = quoted_scope(table_name)
 
         fk_info = select_all(<<-SQL.strip_heredoc, "SCHEMA")
           SELECT fk.referenced_table_name AS 'to_table',
@@ -530,9 +476,9 @@ module ActiveRecord
           JOIN information_schema.referential_constraints rc
           USING (constraint_schema, constraint_name)
           WHERE fk.referenced_column_name IS NOT NULL
-            AND fk.table_schema = #{quote(schema)}
-            AND fk.table_name = #{quote(name)}
-            AND rc.table_name = #{quote(name)}
+            AND fk.table_schema = #{scope[:schema]}
+            AND fk.table_name = #{scope[:name]}
+            AND rc.table_name = #{scope[:name]}
         SQL
 
         fk_info.map do |row|
@@ -604,14 +550,14 @@ module ActiveRecord
       def primary_keys(table_name) # :nodoc:
         raise ArgumentError unless table_name.present?
 
-        schema, name = extract_schema_qualified_name(table_name)
+        scope = quoted_scope(table_name)
 
         select_values(<<-SQL.strip_heredoc, "SCHEMA")
           SELECT column_name
           FROM information_schema.key_column_usage
           WHERE constraint_name = 'PRIMARY'
-            AND table_schema = #{quote(schema)}
-            AND table_name = #{quote(name)}
+            AND table_schema = #{scope[:schema]}
+            AND table_name = #{scope[:name]}
           ORDER BY ordinal_position
         SQL
       end
@@ -648,10 +594,6 @@ module ActiveRecord
         self.class.type_cast_config_to_boolean(@config.fetch(:strict, true))
       end
 
-      def valid_type?(type)
-        !native_database_types[type].nil?
-      end
-
       def default_index_type?(index) # :nodoc:
         index.using == :btree || super
       end
@@ -786,11 +728,11 @@ module ActiveRecord
         def change_column_sql(table_name, column_name, type, options = {})
           column = column_for(table_name, column_name)
 
-          unless options_include_default?(options)
+          unless options.key?(:default)
             options[:default] = column.default
           end
 
-          unless options.has_key?(:null)
+          unless options.key?(:null)
             options[:null] = column.null
           end
 
@@ -870,9 +812,9 @@ module ActiveRecord
           variables["sql_auto_is_null"] = 0
 
           # Increase timeout so the server doesn't disconnect us.
-          wait_timeout = @config[:wait_timeout]
+          wait_timeout = self.class.type_cast_config_to_integer(@config[:wait_timeout])
           wait_timeout = 2147483 unless wait_timeout.is_a?(Integer)
-          variables["wait_timeout"] = self.class.type_cast_config_to_integer(wait_timeout)
+          variables["wait_timeout"] = wait_timeout
 
           defaults = [":default", :default].to_set
 
@@ -949,12 +891,6 @@ module ActiveRecord
           )
         end
 
-        def extract_schema_qualified_name(string) # :nodoc:
-          schema, name = string.to_s.scan(/[^`.\s]+|`[^`]*`/)
-          schema, name = @config[:database], schema unless name
-          [schema, name]
-        end
-
         def integer_to_sql(limit) # :nodoc:
           case limit
           when 1; "tinyint"

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

@@ -0,0 +1,33 @@
+module ActiveRecord
+  module ConnectionAdapters
+    module MySQL
+      module SchemaStatements # :nodoc:
+        private
+          def data_source_sql(name = nil, type: nil)
+            scope = quoted_scope(name, type: type)
+
+            sql = "SELECT table_name FROM information_schema.tables"
+            sql << " WHERE table_schema = #{scope[:schema]}"
+            sql << " AND table_name = #{scope[:name]}" if scope[:name]
+            sql << " AND table_type = #{scope[:type]}" if scope[:type]
+            sql
+          end
+
+          def quoted_scope(name = nil, type: nil)
+            schema, name = extract_schema_qualified_name(name)
+            scope = {}
+            scope[:schema] = schema ? quote(schema) : "database()"
+            scope[:name] = quote(name) if name
+            scope[:type] = quote(type) if type
+            scope
+          end
+
+          def extract_schema_qualified_name(string)
+            schema, name = string.to_s.scan(/[^`.\s]+|`[^`]*`/)
+            schema, name = nil, schema unless name
+            [schema, name]
+          end
+      end
+    end
+  end
+end

data/lib/active_record/connection_adapters/mysql/type_metadata.rb

@@ -2,6 +2,8 @@ module ActiveRecord
   module ConnectionAdapters
     module MySQL
       class TypeMetadata < DelegateClass(SqlTypeMetadata) # :nodoc:
+        undef to_yaml if method_defined?(:to_yaml)
+
         attr_reader :extra
 
         def initialize(type_metadata, extra: "")

data/lib/active_record/connection_adapters/postgresql/oid/array.rb

@@ -23,7 +23,7 @@ module ActiveRecord
             when ::String
               type_cast_array(@pg_decoder.decode(value), :deserialize)
             when Data
-              deserialize(value.values)
+              type_cast_array(value.values, :deserialize)
             else
               super
             end

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

@@ -54,81 +54,13 @@ module ActiveRecord
           execute "DROP DATABASE IF EXISTS #{quote_table_name(name)}"
         end
 
-        # Returns the list of all tables in the schema search path.
-        def tables
-          select_values("SELECT tablename FROM pg_tables WHERE schemaname = ANY(current_schemas(false))", "SCHEMA")
-        end
-
-        def data_sources # :nodoc
-          select_values(<<-SQL, "SCHEMA")
-            SELECT c.relname
-            FROM pg_class c
-            LEFT JOIN pg_namespace n ON n.oid = c.relnamespace
-            WHERE c.relkind IN ('r','v','m') -- (r)elation/table, (v)iew, (m)aterialized view
-            AND n.nspname = ANY (current_schemas(false))
-          SQL
-        end
-
-        def views # :nodoc:
-          select_values(<<-SQL, "SCHEMA")
-            SELECT c.relname
-            FROM pg_class c
-            LEFT JOIN pg_namespace n ON n.oid = c.relnamespace
-            WHERE c.relkind IN ('v','m') -- (v)iew, (m)aterialized view
-            AND n.nspname = ANY (current_schemas(false))
-          SQL
-        end
-
-        # Returns true if table exists.
-        # If the schema is not specified as part of +name+ then it will only find tables within
-        # the current schema search path (regardless of permissions to access tables in other schemas)
-        def table_exists?(name)
-          name = Utils.extract_schema_qualified_name(name.to_s)
-          return false unless name.identifier
-
-          select_values(<<-SQL, "SCHEMA").any?
-            SELECT tablename
-            FROM pg_tables
-            WHERE tablename = #{quote(name.identifier)}
-            AND schemaname = #{name.schema ? quote(name.schema) : "ANY (current_schemas(false))"}
-          SQL
-        end
-
-        def data_source_exists?(name) # :nodoc:
-          name = Utils.extract_schema_qualified_name(name.to_s)
-          return false unless name.identifier
-
-          select_values(<<-SQL, "SCHEMA").any?
-            SELECT c.relname
-            FROM pg_class c
-            LEFT JOIN pg_namespace n ON n.oid = c.relnamespace
-            WHERE c.relkind IN ('r','v','m') -- (r)elation/table, (v)iew, (m)aterialized view
-            AND c.relname = #{quote(name.identifier)}
-            AND n.nspname = #{name.schema ? quote(name.schema) : "ANY (current_schemas(false))"}
-          SQL
-        end
-
-        def view_exists?(view_name) # :nodoc:
-          name = Utils.extract_schema_qualified_name(view_name.to_s)
-          return false unless name.identifier
-
-          select_values(<<-SQL, "SCHEMA").any?
-            SELECT c.relname
-            FROM pg_class c
-            LEFT JOIN pg_namespace n ON n.oid = c.relnamespace
-            WHERE c.relkind IN ('v','m') -- (v)iew, (m)aterialized view
-            AND c.relname = #{quote(name.identifier)}
-            AND n.nspname = #{name.schema ? quote(name.schema) : "ANY (current_schemas(false))"}
-          SQL
-        end
-
         def drop_table(table_name, options = {}) # :nodoc:
           execute "DROP TABLE#{' IF EXISTS' if options[:if_exists]} #{quote_table_name(table_name)}#{' CASCADE' if options[:force] == :cascade}"
         end
 
         # Returns true if schema exists.
         def schema_exists?(name)
-          select_value("SELECT COUNT(*) FROM pg_namespace WHERE nspname = '#{name}'", "SCHEMA").to_i > 0
+          select_value("SELECT COUNT(*) FROM pg_namespace WHERE nspname = #{quote(name)}", "SCHEMA").to_i > 0
         end
 
         # Verifies existence of an index with a given name.
@@ -138,8 +70,8 @@ module ActiveRecord
               Passing default to #index_name_exists? is deprecated without replacement.
             MSG
           end
-          table = Utils.extract_schema_qualified_name(table_name.to_s)
-          index = Utils.extract_schema_qualified_name(index_name.to_s)
+          table = quoted_scope(table_name)
+          index = quoted_scope(index_name)
 
           select_value(<<-SQL, "SCHEMA").to_i > 0
             SELECT COUNT(*)
@@ -148,9 +80,9 @@ module ActiveRecord
             INNER JOIN pg_class i ON d.indexrelid = i.oid
             LEFT JOIN pg_namespace n ON n.oid = i.relnamespace
             WHERE i.relkind = 'i'
-              AND i.relname = '#{index.identifier}'
-              AND t.relname = '#{table.identifier}'
-              AND n.nspname = #{index.schema ? "'#{index.schema}'" : 'ANY (current_schemas(false))'}
+              AND i.relname = #{index[:name]}
+              AND t.relname = #{table[:name]}
+              AND n.nspname = #{index[:schema]}
           SQL
         end
 
@@ -162,7 +94,7 @@ module ActiveRecord
             MSG
           end
 
-          table = Utils.extract_schema_qualified_name(table_name.to_s)
+          scope = quoted_scope(table_name)
 
           result = query(<<-SQL, "SCHEMA")
             SELECT distinct i.relname, d.indisunique, d.indkey, pg_get_indexdef(d.indexrelid), t.oid,
@@ -176,8 +108,8 @@ module ActiveRecord
             LEFT JOIN pg_namespace n ON n.oid = i.relnamespace
             WHERE i.relkind = 'i'
               AND d.indisprimary = 'f'
-              AND t.relname = '#{table.identifier}'
-              AND n.nspname = #{table.schema ? "'#{table.schema}'" : 'ANY (current_schemas(false))'}
+              AND t.relname = #{scope[:name]}
+              AND n.nspname = #{scope[:schema]}
             ORDER BY i.relname
           SQL
 
@@ -239,22 +171,22 @@ module ActiveRecord
 
         # Returns a comment stored in database for given table
         def table_comment(table_name) # :nodoc:
-          name = Utils.extract_schema_qualified_name(table_name.to_s)
-          if name.identifier
+          scope = quoted_scope(table_name, type: "BASE TABLE")
+          if scope[:name]
             select_value(<<-SQL.strip_heredoc, "SCHEMA")
               SELECT pg_catalog.obj_description(c.oid, 'pg_class')
               FROM pg_catalog.pg_class c
                 LEFT JOIN pg_namespace n ON n.oid = c.relnamespace
-              WHERE c.relname = #{quote(name.identifier)}
-                AND c.relkind IN ('r') -- (r)elation/table
-                AND n.nspname = #{name.schema ? quote(name.schema) : 'ANY (current_schemas(false))'}
+              WHERE c.relname = #{scope[:name]}
+                AND c.relkind IN (#{scope[:type]})
+                AND n.nspname = #{scope[:schema]}
             SQL
           end
         end
 
         # Returns the current database name.
         def current_database
-          select_value("select current_database()", "SCHEMA")
+          select_value("SELECT current_database()", "SCHEMA")
         end
 
         # Returns the current schema name.
@@ -430,17 +362,15 @@ module ActiveRecord
         end
 
         def primary_keys(table_name) # :nodoc:
-          name = Utils.extract_schema_qualified_name(table_name.to_s)
+          scope = quoted_scope(table_name)
           select_values(<<-SQL.strip_heredoc, "SCHEMA")
             SELECT column_name
               FROM information_schema.key_column_usage kcu
               JOIN information_schema.table_constraints tc
-                ON kcu.table_name = tc.table_name
-               AND kcu.table_schema = tc.table_schema
-               AND kcu.constraint_name = tc.constraint_name
+             USING (table_schema, table_name, constraint_name)
              WHERE constraint_type = 'PRIMARY KEY'
-               AND kcu.table_name = #{quote(name.identifier)}
-               AND kcu.table_schema = #{name.schema ? quote(name.schema) : "ANY (current_schemas(false))"}
+               AND kcu.table_name = #{scope[:name]}
+               AND kcu.table_schema = #{scope[:schema]}
              ORDER BY kcu.ordinal_position
           SQL
         end
@@ -489,7 +419,7 @@ module ActiveRecord
           end
           execute sql
 
-          change_column_default(table_name, column_name, options[:default]) if options_include_default?(options)
+          change_column_default(table_name, column_name, options[:default]) if options.key?(:default)
           change_column_null(table_name, column_name, options[:null], options[:default]) if options.key?(:null)
           change_column_comment(table_name, column_name, options[:comment]) if options.key?(:comment)
         end
@@ -579,6 +509,7 @@ module ActiveRecord
         end
 
         def foreign_keys(table_name)
+          scope = quoted_scope(table_name)
           fk_info = select_all(<<-SQL.strip_heredoc, "SCHEMA")
             SELECT t2.oid::regclass::text AS to_table, a1.attname AS column, a2.attname AS primary_key, c.conname AS name, c.confupdtype AS on_update, c.confdeltype AS on_delete
             FROM pg_constraint c
@@ -588,8 +519,8 @@ module ActiveRecord
             JOIN pg_attribute a2 ON a2.attnum = c.confkey[1] AND a2.attrelid = t2.oid
             JOIN pg_namespace t3 ON c.connamespace = t3.oid
             WHERE c.contype = 'f'
-              AND t1.relname = #{quote(table_name)}
-              AND t3.nspname = ANY (current_schemas(false))
+              AND t1.relname = #{scope[:name]}
+              AND t3.nspname = #{scope[:schema]}
             ORDER BY c.conname
           SQL
 
@@ -615,10 +546,6 @@ module ActiveRecord
           end
         end
 
-        def index_name_length
-          63
-        end
-
         # Maps logical Rails types to PostgreSQL-specific data types.
         def type_to_sql(type, limit: nil, precision: nil, scale: nil, array: nil, **) # :nodoc:
           sql = \
@@ -677,6 +604,39 @@ module ActiveRecord
           )
           PostgreSQLTypeMetadata.new(simple_type, oid: oid, fmod: fmod)
         end
+
+        private
+          def data_source_sql(name = nil, type: nil)
+            scope = quoted_scope(name, type: type)
+            scope[:type] ||= "'r','v','m'" # (r)elation/table, (v)iew, (m)aterialized view
+
+            sql = "SELECT c.relname FROM pg_class c LEFT JOIN pg_namespace n ON n.oid = c.relnamespace"
+            sql << " WHERE n.nspname = #{scope[:schema]}"
+            sql << " AND c.relname = #{scope[:name]}" if scope[:name]
+            sql << " AND c.relkind IN (#{scope[:type]})"
+            sql
+          end
+
+          def quoted_scope(name = nil, type: nil)
+            schema, name = extract_schema_qualified_name(name)
+            type = \
+              case type
+              when "BASE TABLE"
+                "'r'"
+              when "VIEW"
+                "'v','m'"
+              end
+            scope = {}
+            scope[:schema] = schema ? quote(schema) : "ANY (current_schemas(false))"
+            scope[:name] = quote(name) if name
+            scope[:type] = type if type
+            scope
+          end
+
+          def extract_schema_qualified_name(string)
+            name = Utils.extract_schema_qualified_name(string.to_s)
+            [name.schema, name.identifier]
+          end
       end
     end
   end