activerecord 6.1.7.7 → 7.0.0.alpha1

data/lib/active_record/scoping/default.rb

@@ -2,6 +2,15 @@
 
 module ActiveRecord
   module Scoping
+    class DefaultScope # :nodoc:
+      attr_reader :scope, :all_queries
+
+      def initialize(scope, all_queries = nil)
+        @scope = scope
+        @all_queries = all_queries
+      end
+    end
+
     module Default
       extend ActiveSupport::Concern
 
@@ -30,8 +39,8 @@ module ActiveRecord
         #   Post.unscoped {
         #     Post.limit(10) # Fires "SELECT * FROM posts LIMIT 10"
         #   }
-        def unscoped
-          block_given? ? relation.scoping { yield } : relation
+        def unscoped(&block)
+          block_given? ? relation.scoping(&block) : relation
         end
 
         # Are there attributes associated with this scope?
@@ -39,10 +48,21 @@ module ActiveRecord
           super || default_scopes.any? || respond_to?(:default_scope)
         end
 
-        def before_remove_const #:nodoc:
+        def before_remove_const # :nodoc:
           self.current_scope = nil
         end
 
+        # Checks if the model has any default scopes. If all_queries
+        # is set to true, the method will check if there are any
+        # default_scopes for the model  where +all_queries+ is true.
+        def default_scopes?(all_queries: false)
+          if all_queries
+            self.default_scopes.any?(&:all_queries)
+          else
+            self.default_scopes.any?
+          end
+        end
+
         private
           # Use this macro in your model to set a default scope for all operations on
           # the model.
@@ -54,11 +74,26 @@ module ActiveRecord
           #   Article.all # => SELECT * FROM articles WHERE published = true
           #
           # The #default_scope is also applied while creating/building a record.
-          # It is not applied while updating a record.
+          # It is not applied while updating or deleting a record.
           #
           #   Article.new.published    # => true
           #   Article.create.published # => true
           #
+          # To apply a #default_scope when updating or deleting a record, add
+          # <tt>all_queries: true</tt>:
+          #
+          #   class Article < ActiveRecord::Base
+          #     default_scope { where(blog_id: 1) }, all_queries: true
+          #   end
+          #
+          # Applying a default scope to all queries will ensure that records
+          # are always queried by the additional conditions. Note that only
+          # where clauses apply, as it does not make sense to add order to
+          # queries that return a single object by primary key.
+          #
+          #   Article.find(1).destroy
+          #   => DELETE ... FROM `articles` where ID = 1 AND blog_id = 1;
+          #
           # (You can also pass any object which responds to +call+ to the
           # +default_scope+ macro, and it will be called when building the
           # default scope.)
@@ -85,7 +120,7 @@ module ActiveRecord
           #       # Should return a scope, you can call 'super' here etc.
           #     end
           #   end
-          def default_scope(scope = nil, &block) # :doc:
+          def default_scope(scope = nil, all_queries: nil, &block) # :doc:
             scope = block if block_given?
 
             if scope.is_a?(Relation) || !scope.respond_to?(:call)
@@ -96,10 +131,12 @@ module ActiveRecord
                 "self.default_scope.)"
             end
 
-            self.default_scopes += [scope]
+            default_scope = DefaultScope.new(scope, all_queries)
+
+            self.default_scopes += [default_scope]
           end
 
-          def build_default_scope(relation = relation())
+          def build_default_scope(relation = relation(), all_queries: nil)
             return if abstract_class?
 
             if default_scope_override.nil?
@@ -113,20 +150,32 @@ module ActiveRecord
               end
             elsif default_scopes.any?
               evaluate_default_scope do
-                default_scopes.inject(relation) do |default_scope, scope|
-                  scope = scope.respond_to?(:to_proc) ? scope : scope.method(:call)
-                  default_scope.instance_exec(&scope) || default_scope
+                default_scopes.inject(relation) do |default_scope, scope_obj|
+                  if execute_scope?(all_queries, scope_obj)
+                    scope = scope_obj.scope.respond_to?(:to_proc) ? scope_obj.scope : scope_obj.scope.method(:call)
+
+                    default_scope.instance_exec(&scope) || default_scope
+                  end
                 end
               end
             end
           end
 
+          # If all_queries is nil, only execute on select and insert queries.
+          #
+          # If all_queries is true, check if the default_scope object has
+          # all_queries set, then execute on all queries; select, insert, update
+          # and delete.
+          def execute_scope?(all_queries, default_scope_obj)
+            all_queries.nil? || all_queries && default_scope_obj.all_queries
+          end
+
           def ignore_default_scope?
-            ScopeRegistry.value_for(:ignore_default_scope, base_class)
+            ScopeRegistry.ignore_default_scope(base_class)
           end
 
           def ignore_default_scope=(ignore)
-            ScopeRegistry.set_value_for(:ignore_default_scope, base_class, ignore)
+            ScopeRegistry.set_ignore_default_scope(base_class, ignore)
           end
 
           # The ignore_default_scope flag is used to prevent an infinite recursion

data/lib/active_record/scoping/named.rb

@@ -42,8 +42,8 @@ module ActiveRecord
         end
 
         # Returns a scope for the model with default scopes.
-        def default_scoped(scope = relation)
-          build_default_scope(scope) || scope
+        def default_scoped(scope = relation, all_queries: nil)
+          build_default_scope(scope, all_queries: all_queries) || scope
         end
 
         def default_extensions # :nodoc:
@@ -168,7 +168,6 @@ module ActiveRecord
               "an instance method with the same name."
           end
 
-          valid_scope_name?(name)
           extension = Module.new(&block) if block
 
           if body.respond_to?(:to_proc)
@@ -184,7 +183,7 @@ module ActiveRecord
               scope
             end
           end
-          singleton_class.send(:ruby2_keywords, name) if respond_to?(:ruby2_keywords, true)
+          singleton_class.send(:ruby2_keywords, name)
 
           generate_relation_method(name)
         end
@@ -193,13 +192,6 @@ module ActiveRecord
           def singleton_method_added(name)
             generate_relation_method(name) if Kernel.respond_to?(name) && !ActiveRecord::Relation.method_defined?(name)
           end
-
-          def valid_scope_name?(name)
-            if respond_to?(name, true) && logger
-              logger.warn "Creating scope :#{name}. " \
-                "Overwriting existing method #{self.name}.#{name}."
-            end
-          end
       end
     end
   end

data/lib/active_record/scoping.rb

@@ -24,11 +24,23 @@ module ActiveRecord
       end
 
       def current_scope(skip_inherited_scope = false)
-        ScopeRegistry.value_for(:current_scope, self, skip_inherited_scope)
+        ScopeRegistry.current_scope(self, skip_inherited_scope)
       end
 
       def current_scope=(scope)
-        ScopeRegistry.set_value_for(:current_scope, self, scope)
+        ScopeRegistry.set_current_scope(self, scope)
+      end
+
+      def global_current_scope(skip_inherited_scope = false)
+        ScopeRegistry.global_current_scope(self, skip_inherited_scope)
+      end
+
+      def global_current_scope=(scope)
+        ScopeRegistry.set_global_current_scope(self, scope)
+      end
+
+      def scope_registry
+        ScopeRegistry.instance
       end
     end
 
@@ -69,37 +81,43 @@ module ActiveRecord
     class ScopeRegistry # :nodoc:
       extend ActiveSupport::PerThreadRegistry
 
-      VALID_SCOPE_TYPES = [:current_scope, :ignore_default_scope]
+      VALID_SCOPE_TYPES = [:current_scope, :ignore_default_scope, :global_current_scope]
 
       def initialize
-        @registry = Hash.new { |hash, key| hash[key] = {} }
+        @current_scope        = {}
+        @ignore_default_scope = {}
+        @global_current_scope = {}
       end
 
-      # Obtains the value for a given +scope_type+ and +model+.
-      def value_for(scope_type, model, skip_inherited_scope = false)
-        raise_invalid_scope_type!(scope_type)
-        return @registry[scope_type][model.name] if skip_inherited_scope
-        klass = model
-        base = model.base_class
-        while klass <= base
-          value = @registry[scope_type][klass.name]
-          return value if value
-          klass = klass.superclass
+      VALID_SCOPE_TYPES.each do |type|
+        class_eval <<-eorb, __FILE__, __LINE__
+        def #{type}(model, skip_inherited_scope = false)
+          value_for(@#{type}, model, skip_inherited_scope)
         end
-      end
 
-      # Sets the +value+ for a given +scope_type+ and +model+.
-      def set_value_for(scope_type, model, value)
-        raise_invalid_scope_type!(scope_type)
-        @registry[scope_type][model.name] = value
+        def set_#{type}(model, value)
+          set_value_for(@#{type}, model, value)
+        end
+        eorb
       end
 
       private
-        def raise_invalid_scope_type!(scope_type)
-          if !VALID_SCOPE_TYPES.include?(scope_type)
-            raise ArgumentError, "Invalid scope type '#{scope_type}' sent to the registry. Scope types must be included in VALID_SCOPE_TYPES"
+        # Obtains the value for a given +scope_type+ and +model+.
+        def value_for(scope_type, model, skip_inherited_scope = false)
+          return scope_type[model.name] if skip_inherited_scope
+          klass = model
+          base = model.base_class
+          while klass <= base
+            value = scope_type[klass.name]
+            return value if value
+            klass = klass.superclass
           end
         end
+
+        # Sets the +value+ for a given +scope_type+ and +model+.
+        def set_value_for(scope_type, model, value)
+          scope_type[model.name] = value
+        end
     end
   end
 end

data/lib/active_record/serialization.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module ActiveRecord #:nodoc:
+module ActiveRecord # :nodoc:
   # = Active Record \Serialization
   module Serialization
     extend ActiveSupport::Concern

data/lib/active_record/signed_id.rb

@@ -10,7 +10,7 @@ module ActiveRecord
       # :singleton-method:
       # Set the secret used for the signed id verifier instance when using Active Record outside of Rails.
       # Within Rails, this is automatically set using the Rails application key generator.
-      mattr_accessor :signed_id_verifier_secret, instance_writer: false
+      class_attribute :signed_id_verifier_secret, instance_writer: false
     end
 
     module ClassMethods

data/lib/active_record/store.rb

@@ -268,7 +268,7 @@ module ActiveRecord
         end
 
         def dump(obj)
-          @coder.dump as_regular_hash(obj)
+          @coder.dump self.class.as_indifferent_hash(obj)
         end
 
         def load(yaml)
@@ -285,11 +285,6 @@ module ActiveRecord
             ActiveSupport::HashWithIndifferentAccess.new
           end
         end
-
-        private
-          def as_regular_hash(obj)
-            obj.respond_to?(:to_hash) ? obj.to_hash : {}
-          end
       end
   end
 end

data/lib/active_record/tasks/database_tasks.rb

@@ -39,11 +39,18 @@ module ActiveRecord
       ##
       # :singleton-method:
       # Extra flags passed to database CLI tool (mysqldump/pg_dump) when calling db:schema:dump
+      # It can be used as a string/array (the typical case) or a hash (when you use multiple adapters)
+      # Example:
+      #   ActiveRecord::Tasks::DatabaseTasks.structure_dump_flags = {
+      #     mysql2: ['--no-defaults', '--skip-add-drop-table'],
+      #     postgres: '--no-tablespaces'
+      #   }
       mattr_accessor :structure_dump_flags, instance_accessor: false
 
       ##
       # :singleton-method:
       # Extra flags passed to database CLI tool when calling db:schema:load
+      # It can be used as a string/array (the typical case) or a hash (when you use multiple adapters)
       mattr_accessor :structure_load_flags, instance_accessor: false
 
       extend self
@@ -123,7 +130,7 @@ module ActiveRecord
           env_name = options[:env] || env
           name = options[:spec] || "primary"
 
-          @current_config ||= ActiveRecord::Base.configurations.configs_for(env_name: env_name, name: name)&.configuration_hash
+          @current_config ||= configs_for(env_name: env_name, name: name)&.configuration_hash
         end
       end
       deprecate :current_config
@@ -154,7 +161,7 @@ module ActiveRecord
         begin
           Rails.application.config.load_database_yaml
         rescue
-          unless ActiveRecord::Base.suppress_multiple_database_warning
+          unless ActiveRecord.suppress_multiple_database_warning
             $stderr.puts "Rails couldn't infer whether you are using multiple databases from your database.yml and can't generate the tasks for the non-primary databases. If you'd like to use this feature, please simplify your ERB."
           end
 
@@ -171,12 +178,14 @@ 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
 
       def raise_for_multi_db(environment = env, command:)
-        db_configs = ActiveRecord::Base.configurations.configs_for(env_name: environment)
+        db_configs = configs_for(env_name: environment)
 
         if db_configs.count > 1
           dbs_list = []
@@ -194,6 +203,39 @@ module ActiveRecord
         ActiveRecord::Base.establish_connection(environment.to_sym)
       end
 
+      def prepare_all
+        seed = false
+
+        configs_for(env_name: env).each do |db_config|
+          ActiveRecord::Base.establish_connection(db_config)
+
+          # Skipped when no database
+          migrate
+
+          if ActiveRecord.dump_schema_after_migration
+            dump_schema(db_config, ActiveRecord.schema_format)
+          end
+        rescue ActiveRecord::NoDatabaseError
+          config_name = db_config.name
+          create_current(db_config.env_name, config_name)
+
+          if File.exist?(dump_filename(config_name))
+            load_schema(
+              db_config,
+              ActiveRecord.schema_format,
+              nil
+            )
+          else
+            migrate
+          end
+
+          seed = true
+        end
+
+        ActiveRecord::Base.establish_connection
+        load_seed if seed
+      end
+
       def drop(configuration, *arguments)
         db_config = resolve_configuration(configuration)
         database_adapter_for(db_config, *arguments).drop
@@ -223,19 +265,21 @@ module ActiveRecord
       private :truncate_tables
 
       def truncate_all(environment = env)
-        ActiveRecord::Base.configurations.configs_for(env_name: environment).each do |db_config|
+        configs_for(env_name: environment).each do |db_config|
           truncate_tables(db_config)
         end
       end
 
-      def migrate
+      def migrate(version = nil)
         check_target_version
 
         scope = ENV["SCOPE"]
         verbose_was, Migration.verbose = Migration.verbose, verbose?
 
-        Base.connection.migration_context.migrate(target_version) do |migration|
+        Base.connection.migration_context.migrate(target_version || version) do |migration|
           scope.blank? || scope == migration.scope
+        end.tap do |migrations_ran|
+          Migration.write("No migrations ran. (using #{scope} scope)") if scope.present? && migrations_ran.empty?
         end
 
         ActiveRecord::Base.clear_cache!
@@ -243,6 +287,23 @@ module ActiveRecord
         Migration.verbose = verbose_was
       end
 
+      def db_configs_with_versions(db_configs) # :nodoc:
+        db_configs_with_versions = Hash.new { |h, k| h[k] = [] }
+
+        db_configs.each do |db_config|
+          ActiveRecord::Base.establish_connection(db_config)
+          versions_to_run = ActiveRecord::Base.connection.migration_context.pending_migration_versions
+          target_version = ActiveRecord::Tasks::DatabaseTasks.target_version
+
+          versions_to_run.each do |version|
+            next if target_version && target_version != version
+            db_configs_with_versions[version] << db_config
+          end
+        end
+
+        db_configs_with_versions
+      end
+
       def migrate_status
         unless ActiveRecord::Base.connection.schema_migration.table_exists?
           Kernel.abort "Schema migrations table does not exist yet."
@@ -269,7 +330,7 @@ module ActiveRecord
       end
 
       def charset_current(env_name = env, db_name = name)
-        db_config = ActiveRecord::Base.configurations.configs_for(env_name: env_name, name: db_name)
+        db_config = configs_for(env_name: env_name, name: db_name)
         charset(db_config)
       end
 
@@ -279,7 +340,7 @@ module ActiveRecord
       end
 
       def collation_current(env_name = env, db_name = name)
-        db_config = ActiveRecord::Base.configurations.configs_for(env_name: env_name, name: db_name)
+        db_config = configs_for(env_name: env_name, name: db_name)
         collation(db_config)
       end
 
@@ -305,16 +366,18 @@ module ActiveRecord
       def structure_dump(configuration, *arguments)
         db_config = resolve_configuration(configuration)
         filename = arguments.delete_at(0)
-        database_adapter_for(db_config, *arguments).structure_dump(filename, structure_dump_flags)
+        flags = structure_dump_flags_for(db_config.adapter)
+        database_adapter_for(db_config, *arguments).structure_dump(filename, flags)
       end
 
       def structure_load(configuration, *arguments)
         db_config = resolve_configuration(configuration)
         filename = arguments.delete_at(0)
-        database_adapter_for(db_config, *arguments).structure_load(filename, structure_load_flags)
+        flags = structure_load_flags_for(db_config.adapter)
+        database_adapter_for(db_config, *arguments).structure_load(filename, flags)
       end
 
-      def load_schema(db_config, format = ActiveRecord::Base.schema_format, file = nil) # :nodoc:
+      def load_schema(db_config, format = ActiveRecord.schema_format, file = nil) # :nodoc:
         file ||= dump_filename(db_config.name, format)
 
         verbose_was, Migration.verbose = Migration.verbose, verbose? && ENV["VERBOSE"]
@@ -336,7 +399,7 @@ module ActiveRecord
         Migration.verbose = verbose_was
       end
 
-      def schema_up_to_date?(configuration, format = ActiveRecord::Base.schema_format, file = nil, environment = nil, name = nil)
+      def schema_up_to_date?(configuration, format = ActiveRecord.schema_format, file = nil, environment = nil, name = nil)
         db_config = resolve_configuration(configuration)
 
         if environment || name
@@ -357,7 +420,7 @@ module ActiveRecord
         ActiveRecord::InternalMetadata[:schema_sha1] == schema_sha1(file)
       end
 
-      def reconstruct_from_schema(db_config, format = ActiveRecord::Base.schema_format, file = nil) # :nodoc:
+      def reconstruct_from_schema(db_config, format = ActiveRecord.schema_format, file = nil) # :nodoc:
         file ||= dump_filename(db_config.name, format)
 
         check_schema_file(file)
@@ -375,7 +438,7 @@ module ActiveRecord
         load_schema(db_config, format, file)
       end
 
-      def dump_schema(db_config, format = ActiveRecord::Base.schema_format) # :nodoc:
+      def dump_schema(db_config, format = ActiveRecord.schema_format) # :nodoc:
         require "active_record/schema_dumper"
         filename = dump_filename(db_config.name, format)
         connection = ActiveRecord::Base.connection
@@ -397,11 +460,12 @@ module ActiveRecord
         end
       end
 
-      def schema_file(format = ActiveRecord::Base.schema_format)
+      def schema_file(format = ActiveRecord.schema_format)
         File.join(db_dir, schema_file_type(format))
       end
+      deprecate :schema_file
 
-      def schema_file_type(format = ActiveRecord::Base.schema_format)
+      def schema_file_type(format = ActiveRecord.schema_format)
         case format
         when :ruby
           "schema.rb"
@@ -410,7 +474,7 @@ module ActiveRecord
         end
       end
 
-      def dump_filename(db_config_name, format = ActiveRecord::Base.schema_format)
+      def dump_filename(db_config_name, format = ActiveRecord.schema_format)
         filename = if ActiveRecord::Base.configurations.primary?(db_config_name)
           schema_file_type(format)
         else
@@ -430,7 +494,7 @@ module ActiveRecord
         schema_cache_path || ENV["SCHEMA_CACHE"] || File.join(ActiveRecord::Tasks::DatabaseTasks.db_dir, filename)
       end
 
-      def load_schema_current(format = ActiveRecord::Base.schema_format, file = nil, environment = env)
+      def load_schema_current(format = ActiveRecord.schema_format, file = nil, environment = env)
         each_current_configuration(environment) do |db_config|
           load_schema(db_config, format, file)
         end
@@ -468,6 +532,10 @@ module ActiveRecord
       end
 
       private
+        def configs_for(**options)
+          Base.configurations.configs_for(**options)
+        end
+
         def resolve_configuration(configuration)
           Base.configurations.resolve(configuration)
         end
@@ -488,7 +556,7 @@ module ActiveRecord
         end
 
         def class_for_adapter(adapter)
-          _key, task = @tasks.each_pair.detect { |pattern, _task| adapter[pattern] }
+          _key, task = @tasks.reverse_each.detect { |pattern, _task| adapter[pattern] }
           unless task
             raise DatabaseNotSupported, "Rake tasks not supported by '#{adapter}' adapter"
           end
@@ -500,7 +568,7 @@ module ActiveRecord
           environments << "test" if environment == "development" && !ENV["SKIP_TEST_DATABASE"] && !ENV["DATABASE_URL"]
 
           environments.each do |env|
-            ActiveRecord::Base.configurations.configs_for(env_name: env).each do |db_config|
+            configs_for(env_name: env).each do |db_config|
               next if name && name != db_config.name
 
               yield db_config
@@ -509,7 +577,7 @@ module ActiveRecord
         end
 
         def each_local_configuration
-          ActiveRecord::Base.configurations.configs_for.each do |db_config|
+          configs_for.each do |db_config|
             next unless db_config.database
 
             if local_database?(db_config)
@@ -526,7 +594,23 @@ module ActiveRecord
         end
 
         def schema_sha1(file)
-          Digest::SHA1.hexdigest(File.read(file))
+          OpenSSL::Digest::SHA1.hexdigest(File.read(file))
+        end
+
+        def structure_dump_flags_for(adapter)
+          if structure_dump_flags.is_a?(Hash)
+            structure_dump_flags[adapter.to_sym]
+          else
+            structure_dump_flags
+          end
+        end
+
+        def structure_load_flags_for(adapter)
+          if structure_load_flags.is_a?(Hash)
+            structure_load_flags[adapter.to_sym]
+          else
+            structure_load_flags
+          end
         end
     end
   end

data/lib/active_record/tasks/mysql_database_tasks.rb

@@ -94,7 +94,7 @@ module ActiveRecord
             sslcapath: "--ssl-capath",
             sslcipher: "--ssl-cipher",
             sslkey:    "--ssl-key"
-          }.map { |opt, arg| "#{arg}=#{configuration_hash[opt]}" if configuration_hash[opt] }.compact
+          }.filter_map { |opt, arg| "#{arg}=#{configuration_hash[opt]}" if configuration_hash[opt] }
 
           args
         end

data/lib/active_record/tasks/postgresql_database_tasks.rb

@@ -47,16 +47,14 @@ module ActiveRecord
       end
 
       def structure_dump(filename, extra_flags)
-        set_psql_env
-
         search_path = \
-          case ActiveRecord::Base.dump_schemas
+          case ActiveRecord.dump_schemas
           when :schema_search_path
             configuration_hash[:schema_search_path]
           when :all
             nil
           when String
-            ActiveRecord::Base.dump_schemas
+            ActiveRecord.dump_schemas
           end
 
         args = ["--schema-only", "--no-privileges", "--no-owner", "--file", filename]
@@ -79,7 +77,6 @@ module ActiveRecord
       end
 
       def structure_load(filename, extra_flags)
-        set_psql_env
         args = ["--set", ON_ERROR_STOP_1, "--quiet", "--no-psqlrc", "--file", filename]
         args.concat(Array(extra_flags)) if extra_flags
         args << db_config.database
@@ -100,15 +97,21 @@ module ActiveRecord
           )
         end
 
-        def set_psql_env
-          ENV["PGHOST"]     = db_config.host                     if db_config.host
-          ENV["PGPORT"]     = configuration_hash[:port].to_s     if configuration_hash[:port]
-          ENV["PGPASSWORD"] = configuration_hash[:password].to_s if configuration_hash[:password]
-          ENV["PGUSER"]     = configuration_hash[:username].to_s if configuration_hash[:username]
+        def psql_env
+          {}.tap do |env|
+            env["PGHOST"]         = db_config.host                        if db_config.host
+            env["PGPORT"]         = configuration_hash[:port].to_s        if configuration_hash[:port]
+            env["PGPASSWORD"]     = configuration_hash[:password].to_s    if configuration_hash[:password]
+            env["PGUSER"]         = configuration_hash[:username].to_s    if configuration_hash[:username]
+            env["PGSSLMODE"]      = configuration_hash[:sslmode].to_s     if configuration_hash[:sslmode]
+            env["PGSSLCERT"]      = configuration_hash[:sslcert].to_s     if configuration_hash[:sslcert]
+            env["PGSSLKEY"]       = configuration_hash[:sslkey].to_s      if configuration_hash[:sslkey]
+            env["PGSSLROOTCERT"]  = configuration_hash[:sslrootcert].to_s if configuration_hash[:sslrootcert]
+          end
         end
 
         def run_cmd(cmd, args, action)
-          fail run_cmd_error(cmd, args, action) unless Kernel.system(cmd, *args)
+          fail run_cmd_error(cmd, args, action) unless Kernel.system(psql_env, cmd, *args)
         end
 
         def run_cmd_error(cmd, args, action)