activerecord 7.1.5.2 → 8.1.2.1

data/lib/active_record/tasks/database_tasks.rb

@@ -45,7 +45,7 @@ module ActiveRecord
       # Example:
       #   ActiveRecord::Tasks::DatabaseTasks.structure_dump_flags = {
       #     mysql2: ['--no-defaults', '--skip-add-drop-table'],
-      #     postgres: '--no-tablespaces'
+      #     postgresql: '--no-tablespaces'
       #   }
       mattr_accessor :structure_dump_flags, instance_accessor: false
 
@@ -66,7 +66,7 @@ module ActiveRecord
         return if ENV["DISABLE_DATABASE_ENVIRONMENT_CHECK"]
 
         configs_for(env_name: environment).each do |db_config|
-          check_current_protected_environment!(db_config)
+          database_adapter_for(db_config).check_current_protected_environment!(db_config, migration_class)
         end
       end
 
@@ -125,11 +125,11 @@ module ActiveRecord
       end
 
       def create_all
-        each_local_configuration do |db_config|
-          with_temporary_connection(db_config) do
-            create(db_config)
-          end
-        end
+        db_config = migration_connection.pool.db_config
+
+        each_local_configuration { |db_config| create(db_config) }
+
+        migration_class.establish_connection(db_config)
       end
 
       def setup_initial_database_yaml # :nodoc:
@@ -147,8 +147,6 @@ module ActiveRecord
         return if database_configs.count == 1
 
         database_configs.each do |db_config|
-          next unless db_config.database_tasks?
-
           yield db_config.name
         end
       end
@@ -178,22 +176,9 @@ module ActiveRecord
         dump_db_configs = []
 
         each_current_configuration(env) do |db_config|
-          with_temporary_pool(db_config) do
-            begin
-              database_initialized = migration_connection.schema_migration.table_exists?
-            rescue ActiveRecord::NoDatabaseError
-              create(db_config)
-              retry
-            end
-
-            unless database_initialized
-              if File.exist?(schema_dump_path(db_config))
-                load_schema(db_config, ActiveRecord.schema_format, nil)
-              end
+          database_initialized = initialize_database(db_config)
 
-              seed = true
-            end
-          end
+          seed = true if database_initialized && db_config.seeds?
         end
 
         each_current_environment(env) do |environment|
@@ -253,13 +238,34 @@ module ActiveRecord
         end
       end
 
-      def migrate(version = nil)
+      def migrate_all
+        db_configs = ActiveRecord::Base.configurations.configs_for(env_name: ActiveRecord::Tasks::DatabaseTasks.env)
+        db_configs.each { |db_config| initialize_database(db_config) }
+
+        if db_configs.size == 1 && db_configs.first.primary?
+          ActiveRecord::Tasks::DatabaseTasks.migrate(skip_initialize: true)
+        else
+          mapped_versions = ActiveRecord::Tasks::DatabaseTasks.db_configs_with_versions
+
+          mapped_versions.sort.each do |version, db_configs|
+            db_configs.each do |db_config|
+              ActiveRecord::Tasks::DatabaseTasks.with_temporary_connection(db_config) do
+                ActiveRecord::Tasks::DatabaseTasks.migrate(version, skip_initialize: true)
+              end
+            end
+          end
+        end
+      end
+
+      def migrate(version = nil, skip_initialize: false)
         scope = ENV["SCOPE"]
         verbose_was, Migration.verbose = Migration.verbose, verbose?
 
         check_target_version
 
-        migration_connection.migration_context.migrate(target_version) do |migration|
+        initialize_database(migration_connection_pool.db_config) unless skip_initialize
+
+        migration_connection_pool.migration_context.migrate(target_version) do |migration|
           if version.blank?
             scope.blank? || scope == migration.scope
           else
@@ -269,7 +275,7 @@ module ActiveRecord
           Migration.write("No migrations ran. (using #{scope} scope)") if scope.present? && migrations_ran.empty?
         end
 
-        migration_connection.schema_cache.clear!
+        migration_connection_pool.schema_cache.clear!
       ensure
         Migration.verbose = verbose_was
       end
@@ -277,9 +283,9 @@ module ActiveRecord
       def db_configs_with_versions(environment = env) # :nodoc:
         db_configs_with_versions = Hash.new { |h, k| h[k] = [] }
 
-        with_temporary_connection_for_each(env: environment) do |conn|
-          db_config = conn.pool.db_config
-          versions_to_run = conn.migration_context.pending_migration_versions
+        with_temporary_pool_for_each(env: environment) do |pool|
+          db_config = pool.db_config
+          versions_to_run = pool.migration_context.pending_migration_versions
           target_version = ActiveRecord::Tasks::DatabaseTasks.target_version
 
           versions_to_run.each do |version|
@@ -292,15 +298,15 @@ module ActiveRecord
       end
 
       def migrate_status
-        unless migration_connection.schema_migration.table_exists?
+        unless migration_connection_pool.schema_migration.table_exists?
           Kernel.abort "Schema migrations table does not exist yet."
         end
 
         # output
-        puts "\ndatabase: #{migration_connection.pool.db_config.database}\n\n"
+        puts "\ndatabase: #{migration_connection_pool.db_config.database}\n\n"
         puts "#{'Status'.center(8)}  #{'Migration ID'.ljust(14)}  Migration Name"
         puts "-" * 50
-        migration_connection.migration_context.migrations_status.each do |status, version, name|
+        migration_connection_pool.migration_context.migrations_status.each do |status, version, name|
           puts "#{status.center(8)}  #{version.ljust(14)}  #{name}"
         end
         puts
@@ -365,7 +371,8 @@ module ActiveRecord
         database_adapter_for(db_config, *arguments).structure_load(filename, flags)
       end
 
-      def load_schema(db_config, format = ActiveRecord.schema_format, file = nil) # :nodoc:
+      def load_schema(db_config, format = db_config.schema_format, file = nil) # :nodoc:
+        format = format.to_sym
         file ||= schema_dump_path(db_config, format)
         return unless file
 
@@ -381,69 +388,87 @@ module ActiveRecord
           raise ArgumentError, "unknown format #{format.inspect}"
         end
 
-        migration_connection.internal_metadata.create_table_and_set_flags(db_config.env_name, schema_sha1(file))
+        migration_connection_pool.internal_metadata.create_table_and_set_flags(db_config.env_name, schema_sha1(file))
       ensure
         Migration.verbose = verbose_was
       end
 
-      def schema_up_to_date?(configuration, format = ActiveRecord.schema_format, file = nil)
+      def schema_up_to_date?(configuration, _ = nil, file = nil)
         db_config = resolve_configuration(configuration)
 
         file ||= schema_dump_path(db_config)
 
         return true unless file && File.exist?(file)
 
-        with_temporary_connection(db_config) do |connection|
-          return false unless connection.internal_metadata.enabled?
-          return false unless connection.internal_metadata.table_exists?
+        with_temporary_pool(db_config) do |pool|
+          internal_metadata = pool.internal_metadata
+          return false unless internal_metadata.enabled?
+          return false unless internal_metadata.table_exists?
 
-          connection.internal_metadata[:schema_sha1] == schema_sha1(file)
+          internal_metadata[:schema_sha1] == schema_sha1(file)
         end
       end
 
-      def reconstruct_from_schema(db_config, format = ActiveRecord.schema_format, file = nil) # :nodoc:
-        file ||= schema_dump_path(db_config, format)
+      def reconstruct_from_schema(db_config, file = nil) # :nodoc:
+        file ||= schema_dump_path(db_config, db_config.schema_format)
 
         check_schema_file(file) if file
 
         with_temporary_pool(db_config, clobber: true) do
-          if schema_up_to_date?(db_config, format, file)
-            truncate_tables(db_config)
+          if schema_up_to_date?(db_config, nil, file)
+            truncate_tables(db_config) unless ENV["SKIP_TEST_DATABASE_TRUNCATE"]
           else
             purge(db_config)
-            load_schema(db_config, format, file)
+            load_schema(db_config, db_config.schema_format, file)
           end
         rescue ActiveRecord::NoDatabaseError
           create(db_config)
-          load_schema(db_config, format, file)
+          load_schema(db_config, db_config.schema_format, file)
+        end
+      end
+
+      def dump_all
+        seen_schemas = []
+
+        ActiveRecord::Base.configurations.configs_for(env_name: ActiveRecord::Tasks::DatabaseTasks.env).each do |db_config|
+          schema_path = schema_dump_path(db_config, ENV["SCHEMA_FORMAT"] || db_config.schema_format)
+
+          next if seen_schemas.include?(schema_path)
+
+          ActiveRecord::Tasks::DatabaseTasks.dump_schema(db_config, ENV["SCHEMA_FORMAT"] || db_config.schema_format)
+          seen_schemas << schema_path
         end
       end
 
-      def dump_schema(db_config, format = ActiveRecord.schema_format) # :nodoc:
+      def dump_schema(db_config, format = db_config.schema_format) # :nodoc:
         return unless db_config.schema_dump
 
         require "active_record/schema_dumper"
         filename = schema_dump_path(db_config, format)
         return unless filename
 
-        FileUtils.mkdir_p(db_dir)
-        case format
-        when :ruby
-          File.open(filename, "w:utf-8") do |file|
-            ActiveRecord::SchemaDumper.dump(migration_connection, file)
-          end
-        when :sql
-          structure_dump(db_config, filename)
-          if migration_connection.schema_migration.table_exists?
-            File.open(filename, "a") do |f|
-              f.puts migration_connection.dump_schema_information
-              f.print "\n"
+        with_temporary_pool(db_config) do |pool|
+          FileUtils.mkdir_p(db_dir)
+          case format.to_sym
+          when :ruby
+            File.open(filename, "w:utf-8") do |file|
+              ActiveRecord::SchemaDumper.dump(pool, file)
+            end
+          when :sql
+            structure_dump(db_config, filename)
+            if pool.schema_migration.table_exists?
+              File.open(filename, "a") do |f|
+                pool.with_connection do |connection|
+                  f.puts connection.dump_schema_versions
+                end
+                f.print "\n"
+              end
             end
           end
         end
       end
 
-      def schema_dump_path(db_config, format = ActiveRecord.schema_format)
+      def schema_dump_path(db_config, format = db_config.schema_format)
         return ENV["SCHEMA"] if ENV["SCHEMA"]
 
         filename = db_config.schema_dump(format)
@@ -456,20 +481,16 @@ module ActiveRecord
         end
       end
 
-      def cache_dump_filename(db_config_name, schema_cache_path: nil)
-        filename = if ActiveRecord::Base.configurations.primary?(db_config_name)
-          "schema_cache.yml"
-        else
-          "#{db_config_name}_schema_cache.yml"
-        end
-
-        schema_cache_path || ENV["SCHEMA_CACHE"] || File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, filename)
+      def cache_dump_filename(db_config, schema_cache_path: nil)
+        schema_cache_path ||
+          db_config.schema_cache_path ||
+          db_config.default_schema_cache_path(ActiveRecord::Tasks::DatabaseTasks.db_dir)
       end
 
-      def load_schema_current(format = ActiveRecord.schema_format, file = nil, environment = env)
+      def load_schema_current(format = nil, file = nil, environment = env)
         each_current_configuration(environment) do |db_config|
           with_temporary_connection(db_config) do
-            load_schema(db_config, format, file)
+            load_schema(db_config, format || db_config.schema_format, file)
           end
         end
       end
@@ -495,29 +516,29 @@ module ActiveRecord
       # Dumps the schema cache in YAML format for the connection into the file
       #
       # ==== Examples
-      #   ActiveRecord::Tasks::DatabaseTasks.dump_schema_cache(ActiveRecord::Base.connection, "tmp/schema_dump.yaml")
-      def dump_schema_cache(conn, filename)
-        conn.schema_cache.dump_to(filename)
+      #   ActiveRecord::Tasks::DatabaseTasks.dump_schema_cache(ActiveRecord::Base.lease_connection, "tmp/schema_dump.yaml")
+      def dump_schema_cache(conn_or_pool, filename)
+        conn_or_pool.schema_cache.dump_to(filename)
       end
 
       def clear_schema_cache(filename)
         FileUtils.rm_f filename, verbose: false
       end
 
-      def with_temporary_connection_for_each(env: ActiveRecord::Tasks::DatabaseTasks.env, name: nil, clobber: false, &block) # :nodoc:
+      def with_temporary_pool_for_each(env: ActiveRecord::Tasks::DatabaseTasks.env, name: nil, clobber: false, &block) # :nodoc:
         if name
           db_config = ActiveRecord::Base.configurations.configs_for(env_name: env, name: name)
-          with_temporary_connection(db_config, clobber: clobber, &block)
+          with_temporary_pool(db_config, clobber: clobber, &block)
         else
           ActiveRecord::Base.configurations.configs_for(env_name: env, name: name).each do |db_config|
-            with_temporary_connection(db_config, clobber: clobber, &block)
+            with_temporary_pool(db_config, clobber: clobber, &block)
           end
         end
       end
 
-      def with_temporary_connection(db_config, clobber: false) # :nodoc:
+      def with_temporary_connection(db_config, clobber: false, &block) # :nodoc:
         with_temporary_pool(db_config, clobber: clobber) do |pool|
-          yield pool.connection
+          pool.with_connection(&block)
         end
       end
 
@@ -526,7 +547,11 @@ module ActiveRecord
       end
 
       def migration_connection # :nodoc:
-        migration_class.connection
+        migration_class.lease_connection
+      end
+
+      def migration_connection_pool # :nodoc:
+        migration_class.connection_pool
       end
 
       private
@@ -623,20 +648,23 @@ module ActiveRecord
           end
         end
 
-        def check_current_protected_environment!(db_config)
-          with_temporary_pool(db_config) do |pool|
-            connection = pool.connection
-            current = connection.migration_context.current_environment
-            stored  = connection.migration_context.last_stored_environment
-
-            if connection.migration_context.protected_environment?
-              raise ActiveRecord::ProtectedEnvironmentError.new(stored)
+        def initialize_database(db_config)
+          with_temporary_pool(db_config) do
+            begin
+              database_already_initialized = migration_connection_pool.schema_migration.table_exists?
+            rescue ActiveRecord::NoDatabaseError
+              create(db_config)
+              retry
             end
 
-            if stored && stored != current
-              raise ActiveRecord::EnvironmentMismatchError.new(current: current, stored: stored)
+            unless database_already_initialized
+              schema_dump_path = schema_dump_path(db_config)
+              if schema_dump_path && File.exist?(schema_dump_path)
+                load_schema(db_config)
+              end
             end
-          rescue ActiveRecord::NoDatabaseError
+
+            !database_already_initialized
           end
         end
     end

data/lib/active_record/tasks/mysql_database_tasks.rb

@@ -2,18 +2,7 @@
 
 module ActiveRecord
   module Tasks # :nodoc:
-    class MySQLDatabaseTasks # :nodoc:
-      ER_DB_CREATE_EXISTS = 1007
-
-      def self.using_database_configurations?
-        true
-      end
-
-      def initialize(db_config)
-        @db_config = db_config
-        @configuration_hash = db_config.configuration_hash
-      end
-
+    class MySQLDatabaseTasks < AbstractTasks # :nodoc:
       def create
         establish_connection(configuration_hash_without_database)
         connection.create_database(db_config.database, creation_options)
@@ -35,10 +24,6 @@ module ActiveRecord
         connection.charset
       end
 
-      def collation
-        connection.collation
-      end
-
       def structure_dump(filename, extra_flags)
         args = prepare_command_options
         args.concat(["--result-file", "#{filename}"])
@@ -55,7 +40,7 @@ module ActiveRecord
         args.concat([db_config.database.to_s])
         args.unshift(*extra_flags) if extra_flags
 
-        run_cmd("mysqldump", args, "dumping")
+        run_cmd("mysqldump", *args)
       end
 
       def structure_load(filename, extra_flags)
@@ -64,24 +49,10 @@ module ActiveRecord
         args.concat(["--database", db_config.database.to_s])
         args.unshift(*extra_flags) if extra_flags
 
-        run_cmd("mysql", args, "loading")
+        run_cmd("mysql", *args)
       end
 
       private
-        attr_reader :db_config, :configuration_hash
-
-        def connection
-          ActiveRecord::Base.connection
-        end
-
-        def establish_connection(config = db_config)
-          ActiveRecord::Base.establish_connection(config)
-        end
-
-        def configuration_hash_without_database
-          configuration_hash.merge(database: nil)
-        end
-
         def creation_options
           Hash.new.tap do |options|
             options[:charset]     = configuration_hash[:encoding]   if configuration_hash.include?(:encoding)
@@ -107,16 +78,6 @@ module ActiveRecord
 
           args
         end
-
-        def run_cmd(cmd, args, action)
-          fail run_cmd_error(cmd, args, action) unless Kernel.system(cmd, *args)
-        end
-
-        def run_cmd_error(cmd, args, action)
-          msg = +"failed to execute: `#{cmd}`\n"
-          msg << "Please check the output above for any errors and make sure that `#{cmd}` is installed in your PATH and has proper permissions.\n\n"
-          msg
-        end
     end
   end
 end

data/lib/active_record/tasks/postgresql_database_tasks.rb

@@ -4,20 +4,11 @@ require "tempfile"
 
 module ActiveRecord
   module Tasks # :nodoc:
-    class PostgreSQLDatabaseTasks # :nodoc:
+    class PostgreSQLDatabaseTasks < AbstractTasks # :nodoc:
       DEFAULT_ENCODING = ENV["CHARSET"] || "utf8"
       ON_ERROR_STOP_1 = "ON_ERROR_STOP=1"
       SQL_COMMENT_BEGIN = "--"
 
-      def self.using_database_configurations?
-        true
-      end
-
-      def initialize(db_config)
-        @db_config = db_config
-        @configuration_hash = db_config.configuration_hash
-      end
-
       def create(connection_already_established = false)
         establish_connection(public_schema_config) unless connection_already_established
         connection.create_database(db_config.database, configuration_hash.merge(encoding: encoding))
@@ -29,14 +20,6 @@ module ActiveRecord
         connection.drop_database(db_config.database)
       end
 
-      def charset
-        connection.encoding
-      end
-
-      def collation
-        connection.collation
-      end
-
       def purge
         ActiveRecord::Base.connection_handler.clear_active_connections!(:all)
         drop
@@ -72,29 +55,20 @@ module ActiveRecord
         end
 
         args << db_config.database
-        run_cmd("pg_dump", args, "dumping")
+        run_cmd("pg_dump", *args)
         remove_sql_header_comments(filename)
         File.open(filename, "a") { |f| f << "SET search_path TO #{connection.schema_search_path};\n\n" }
       end
 
       def structure_load(filename, extra_flags)
-        args = ["--set", ON_ERROR_STOP_1, "--quiet", "--no-psqlrc", "--output", File::NULL, "--file", filename]
+        args = ["--set", ON_ERROR_STOP_1, "--quiet", "--no-psqlrc", "--output", File::NULL]
         args.concat(Array(extra_flags)) if extra_flags
+        args.concat(["--file", filename])
         args << db_config.database
-        run_cmd("psql", args, "loading")
+        run_cmd("psql", *args)
       end
 
       private
-        attr_reader :db_config, :configuration_hash
-
-        def connection
-          ActiveRecord::Base.connection
-        end
-
-        def establish_connection(config = db_config)
-          ActiveRecord::Base.establish_connection(config)
-        end
-
         def encoding
           configuration_hash[:encoding] || DEFAULT_ENCODING
         end
@@ -116,15 +90,8 @@ module ActiveRecord
           end
         end
 
-        def run_cmd(cmd, args, action)
-          fail run_cmd_error(cmd, args, action) unless Kernel.system(psql_env, cmd, *args)
-        end
-
-        def run_cmd_error(cmd, args, action)
-          msg = +"failed to execute:\n"
-          msg << "#{cmd} #{args.join(' ')}\n\n"
-          msg << "Please check the output above for any errors and make sure that `#{cmd}` is installed in your PATH and has proper permissions.\n\n"
-          msg
+        def run_cmd(cmd, *args, **opts)
+          fail run_cmd_error(cmd, args) unless Kernel.system(psql_env, cmd, *args, **opts)
         end
 
         def remove_sql_header_comments(filename)
@@ -132,6 +99,13 @@ module ActiveRecord
           tempfile = Tempfile.open("uncommented_structure.sql")
           begin
             File.foreach(filename) do |line|
+              next if line.start_with?("\\restrict ")
+
+              if line.start_with?("\\unrestrict ")
+                removing_comments = true
+                next
+              end
+
               unless removing_comments && (line.start_with?(SQL_COMMENT_BEGIN) || line.blank?)
                 tempfile << line
                 removing_comments = false

data/lib/active_record/tasks/sqlite_database_tasks.rb

@@ -2,11 +2,7 @@
 
 module ActiveRecord
   module Tasks # :nodoc:
-    class SQLiteDatabaseTasks # :nodoc:
-      def self.using_database_configurations?
-        true
-      end
-
+    class SQLiteDatabaseTasks < AbstractTasks # :nodoc:
       def initialize(db_config, root = ActiveRecord::Tasks::DatabaseTasks.root)
         @db_config = db_config
         @root = root
@@ -37,10 +33,6 @@ module ActiveRecord
         connection.reconnect!
       end
 
-      def charset
-        connection.encoding
-      end
-
       def structure_dump(filename, extra_flags)
         args = []
         args.concat(Array(extra_flags)) if extra_flags
@@ -50,11 +42,12 @@ module ActiveRecord
         if ignore_tables.any?
           ignore_tables = connection.data_sources.select { |table| ignore_tables.any? { |pattern| pattern === table } }
           condition = ignore_tables.map { |table| connection.quote(table) }.join(", ")
-          args << "SELECT sql FROM sqlite_master WHERE tbl_name NOT IN (#{condition}) ORDER BY tbl_name, type DESC, name"
+          args << "SELECT sql || ';' FROM sqlite_master WHERE tbl_name NOT IN (#{condition}) ORDER BY tbl_name, type DESC, name"
         else
-          args << ".schema"
+          args << ".schema --nosys"
         end
-        run_cmd("sqlite3", args, filename)
+
+        run_cmd("sqlite3", *args, out: filename)
       end
 
       def structure_load(filename, extra_flags)
@@ -62,26 +55,22 @@ module ActiveRecord
         `sqlite3 #{flags} #{db_config.database} < "#{filename}"`
       end
 
-      private
-        attr_reader :db_config, :root
-
-        def connection
-          ActiveRecord::Base.connection
+      def check_current_protected_environment!(db_config, migration_class)
+        super
+      rescue ActiveRecord::StatementInvalid => e
+        case e.cause
+        when SQLite3::ReadOnlyException
+        else
+          raise e
         end
+      end
+
+      private
+        attr_reader :root
 
         def establish_connection(config = db_config)
           ActiveRecord::Base.establish_connection(config)
-        end
-
-        def run_cmd(cmd, args, out)
-          fail run_cmd_error(cmd, args) unless Kernel.system(cmd, *args, out: out)
-        end
-
-        def run_cmd_error(cmd, args)
-          msg = +"failed to execute:\n"
-          msg << "#{cmd} #{args.join(' ')}\n\n"
-          msg << "Please check the output above for any errors and make sure that `#{cmd}` is installed in your PATH and has proper permissions.\n\n"
-          msg
+          connection.connect!
         end
     end
   end

data/lib/active_record/test_databases.rb

@@ -4,17 +4,27 @@ require "active_support/testing/parallelization"
 
 module ActiveRecord
   module TestDatabases # :nodoc:
+    ActiveSupport::Testing::Parallelization.before_fork_hook do
+      if ActiveSupport.parallelize_test_databases
+        ActiveRecord::Base.connection_handler.clear_all_connections!
+      end
+    end
+
     ActiveSupport::Testing::Parallelization.after_fork_hook do |i|
-      create_and_load_schema(i, env_name: ActiveRecord::ConnectionHandling::DEFAULT_ENV.call)
+      if ActiveSupport.parallelize_test_databases
+        create_and_load_schema(i, env_name: ActiveRecord::ConnectionHandling::DEFAULT_ENV.call)
+      end
     end
 
     def self.create_and_load_schema(i, env_name:)
       old, ENV["VERBOSE"] = ENV["VERBOSE"], "false"
 
-      ActiveRecord::Base.configurations.configs_for(env_name: env_name).each do |db_config|
-        db_config._database = "#{db_config.database}-#{i}"
+      ActiveRecord::Base.configurations.configs_for(env_name: env_name, include_hidden: true).each do |db_config|
+        db_config._database = "#{db_config.database}_#{i}"
 
-        ActiveRecord::Tasks::DatabaseTasks.reconstruct_from_schema(db_config, ActiveRecord.schema_format, nil)
+        if db_config.database_tasks?
+          ActiveRecord::Tasks::DatabaseTasks.reconstruct_from_schema(db_config, nil)
+        end
       end
     ensure
       ActiveRecord::Base.establish_connection