activerecord-jdbc-adapter 51.8-java → 52.0-java

data/lib/arjdbc/sqlite3/connection_methods.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 ArJdbc::ConnectionMethods.module_eval do
   def sqlite3_connection(config)
-    config = config.deep_dup
     config[:adapter_spec] ||= ::ArJdbc::SQLite3
     config[:adapter_class] = ActiveRecord::ConnectionAdapters::SQLite3Adapter unless config.key?(:adapter_class)
 

data/lib/arjdbc/tasks/database_tasks.rb

@@ -1,32 +1,52 @@
 module ArJdbc
   module Tasks
 
-    def self.register_tasks(pattern, task)
-      ActiveRecord::Tasks::DatabaseTasks.register_task(pattern, task)
-    end
+    if defined? ActiveRecord::Tasks::DatabaseTasks # AR-4.x
+
+      def self.register_tasks(pattern, task)
+        ActiveRecord::Tasks::DatabaseTasks.register_task(pattern, task)
+      end
+
+      # support adapter: mariadb (as if it were mysql)
+      register_tasks(/mariadb/, ActiveRecord::Tasks::MySQLDatabaseTasks)
+
+    else
 
-    # support adapter: mariadb (as if it were mysql)
-    register_tasks(/mariadb/, ActiveRecord::Tasks::MySQLDatabaseTasks)
+      @@tasks = {}
+
+      def self.register_tasks(pattern, task)
+        @@tasks[pattern] = task
+      end
+
+      def self.tasks_instance(config)
+        adapter = config['adapter']
+        key = @@tasks.keys.detect { |pattern| adapter[pattern] }
+        ( @@tasks[key] || JdbcDatabaseTasks ).new(config)
+      end
+
+    end
 
     require 'arjdbc/tasks/jdbc_database_tasks'
-    #require 'arjdbc/tasks/db2_database_tasks'
-    #require 'arjdbc/tasks/derby_database_tasks'
-    #require 'arjdbc/tasks/h2_database_tasks'
-    #require 'arjdbc/tasks/hsqldb_database_tasks'
-    #require 'arjdbc/tasks/mssql_database_tasks'
+    require 'arjdbc/tasks/db2_database_tasks'
+    require 'arjdbc/tasks/derby_database_tasks'
+    require 'arjdbc/tasks/h2_database_tasks'
+    require 'arjdbc/tasks/hsqldb_database_tasks'
+    require 'arjdbc/tasks/mssql_database_tasks'
 
     # re-invent built-in (but deprecated on 4.0) tasks :
-    #register_tasks(/sqlserver/, MSSQLDatabaseTasks)
-    #register_tasks(/mssql/, MSSQLDatabaseTasks) # (built-in) alias
+    register_tasks(/sqlserver/, MSSQLDatabaseTasks)
+    register_tasks(/mssql/, MSSQLDatabaseTasks) # (built-in) alias
     # tasks for custom (JDBC) adapters :
-    #register_tasks(/db2/, DB2DatabaseTasks)
-    #register_tasks(/derby/, DerbyDatabaseTasks)
-    #register_tasks(/h2/, H2DatabaseTasks)
-    #register_tasks(/hsqldb/, HSQLDBDatabaseTasks)
+    register_tasks(/db2/, DB2DatabaseTasks)
+    register_tasks(/derby/, DerbyDatabaseTasks)
+    register_tasks(/h2/, H2DatabaseTasks)
+    register_tasks(/hsqldb/, HSQLDBDatabaseTasks)
     # (default) generic JDBC task :
     register_tasks(/^jdbc$/, JdbcDatabaseTasks)
 
     # NOTE: no need to register "built-in" adapters such as MySQL
+    # - on 4.0 these are registered and will be instantiated
+    # - while on 2.3/3.x we keep the AR built-in task behavior
 
   end
 end

data/lib/arjdbc/tasks/databases.rake

@@ -1,48 +1,91 @@
-require 'arjdbc/tasks/database_tasks'
+raise "ArJdbc needs rake 0.9.x or newer" unless Rake.const_defined?(:VERSION)
 
-module ActiveRecord::Tasks
+Rake::DSL.module_eval do
 
-  DatabaseTasks.module_eval do
+  def redefine_task(*args, &block)
+    if Hash === args.first
+      task_name = args.first.keys[0]
+      old_prereqs = false # leave as specified
+    else
+      task_name = args.first; old_prereqs = []
+      # args[0] = { task_name => old_prereqs }
+    end
 
-    # @override patched to adapt jdbc configuration
-    def each_current_configuration(environment)
-      environments = [environment]
-      environments << 'test' if environment == 'development'
+    full_name = Rake::Task.scope_name(Rake.application.current_scope, task_name)
 
-      configurations = ActiveRecord::Base.configurations.values_at(*environments)
-      configurations.compact.each do |config|
-        yield adapt_jdbc_config(config) unless config['database'].blank?
-      end
+    if old_task = Rake.application.lookup(task_name)
+      old_comment = old_task.full_comment
+      old_prereqs = old_task.prerequisites.dup if old_prereqs
+      old_actions = old_task.actions.dup
+      old_actions.shift # remove the main 'action' block - we're redefining it
+      # old_task.clear_prerequisites if old_prereqs
+      # old_task.clear_actions
+      # remove the (old) task instance from the application :
+      Rake.application.send(:instance_variable_get, :@tasks)[full_name.to_s] = nil
+    else
+      # raise "could not find rake task with (full) name '#{full_name}'"
     end
 
-    # @override patched to adapt jdbc configuration
-    def each_local_configuration
-      ActiveRecord::Base.configurations.each_value do |config|
-        next unless config['database']
+    new_task = task(*args, &block)
+    new_task.comment = old_comment if old_comment
+    new_task.actions.concat(old_actions) if old_actions
+    new_task.prerequisites.concat(old_prereqs) if old_prereqs
+    new_task
+  end
 
-        if local_database?(config)
-          yield adapt_jdbc_config(config)
-        else
-          $stderr.puts "This task only modifies local databases. #{config['database']} is on a remote host."
-        end
-      end
-    end
+end
 
-    private
+namespace :db do
 
-    def adapt_jdbc_config(config)
-      return config unless config['adapter']
-      config.merge 'adapter' => config['adapter'].sub(/^jdbc/, '')
-    end
+  def rails_env
+    defined?(Rails.env) ? Rails.env : ( RAILS_ENV || 'development' )
+  end
 
+  if defined? adapt_jdbc_config
+    ArJdbc.warn "double loading #{__FILE__} please delete lib/tasks/jdbc.rake if present!"
   end
 
-  MySQLDatabaseTasks.class_eval do
+  def adapt_jdbc_config(config)
+    return config unless config['adapter']
+    config.merge 'adapter' => config['adapter'].sub(/^jdbc/, '')
+  end
 
-    def error_class
-      ActiveRecord::JDBCError
+  if defined? ActiveRecord::Tasks::DatabaseTasks # 4.0
+
+    def current_config(options = {})
+      ActiveRecord::Tasks::DatabaseTasks.current_config(options)
     end
 
-  end if const_defined?(:MySQLDatabaseTasks)
+  else # 3.x / 2.3
+
+    def current_config(options = {}) # not on 2.3
+      options = { :env => rails_env }.merge! options
+      if options[:config]
+        @current_config = options[:config]
+      else
+        @current_config ||= ENV['DATABASE_URL'] ?
+          database_url_config : ActiveRecord::Base.configurations[options[:env]]
+      end
+    end
+
+    def database_url_config(url = ENV['DATABASE_URL'])
+      # NOTE: ActiveRecord::ConnectionAdapters::ConnectionSpecification::Resolver
+      # since AR 4.0 that is handled by DatabaseTasks - only care about 2.3/3.x :
+      unless defined? ActiveRecord::Base::ConnectionSpecification::Resolver
+        raise "DATABASE_URL not supported on ActiveRecord #{ActiveRecord::VERSION::STRING}"
+      end
+      resolver = ActiveRecord::Base::ConnectionSpecification::Resolver.new(url, {})
+      resolver.spec.config.stringify_keys
+    end
+
+  end
+
+end
+
+require 'arjdbc/tasks/database_tasks'
 
-end
+if defined? ActiveRecord::Tasks::DatabaseTasks # 4.0
+  load File.expand_path('databases4.rake', File.dirname(__FILE__))
+else # 3.x / 2.3
+  load File.expand_path('databases3.rake', File.dirname(__FILE__))
+end

data/lib/arjdbc/tasks/databases3.rake

@@ -0,0 +1,215 @@
+module ArJdbc
+  module Tasks
+    class << self
+
+      # API similar to ActiveRecord::Tasks::DatabaseTasks on AR 4.0
+
+      def create(config)
+        tasks_instance(config).create
+      end
+
+      def drop(config)
+        tasks_instance(config).drop
+      end
+
+      def purge(config)
+        tasks_instance(config).purge
+      end
+
+      def charset(config)
+        tasks_instance(config).charset
+      end
+
+      def collation(config)
+        tasks_instance(config).collation
+      end
+
+      def structure_dump(config, filename)
+        tasks_instance(config).structure_dump(filename)
+      end
+
+      def structure_load(config, filename)
+        tasks_instance(config).structure_load(filename)
+      end
+
+    end
+  end
+end
+
+namespace :db do
+
+  class << self
+    alias_method :_rails_create_database, :create_database
+    alias_method :_rails_drop_database,   :drop_database
+  end
+
+  def create_database(config)
+    case config['adapter']
+    when /mysql2/
+      unless defined? Mysql2::Error
+        # NOTE: fake it for create_database(config)
+        Object.const_set :Mysql2, Module.new
+        Mysql2.const_set :Error, ActiveRecord::JDBCError
+        ActiveRecord::JDBCError.class_eval do
+          def error; self end # Mysql2::Error#error
+        end
+      end
+      _rails_create_database adapt_jdbc_config(config)
+    when /mysql/
+      unless defined? Mysql::Error
+        # NOTE: fake it for create_database(config)
+        Object.const_set :Mysql, Module.new
+        Mysql.const_set :Error, ActiveRecord::JDBCError
+        ActiveRecord::JDBCError.class_eval do
+          def error; self end # Mysql::Error#error
+        end
+      end
+      _rails_create_database adapt_jdbc_config(config)
+    when /postgresql|sqlite/
+      _rails_create_database adapt_jdbc_config(config)
+    else
+      ArJdbc::Tasks.create(config)
+    end
+  end
+
+  def drop_database(config)
+    case config['adapter']
+    when /mysql|postgresql|sqlite/
+      _rails_drop_database adapt_jdbc_config(config)
+    else
+      ArJdbc::Tasks.drop(config)
+    end
+  end
+
+  redefine_task :charset do # available on 2.3
+    ArJdbc::Tasks.charset ActiveRecord::Base.configurations[rails_env]
+  end
+
+  redefine_task :collation do # available on 2.3
+    ArJdbc::Tasks.collation ActiveRecord::Base.configurations[rails_env]
+  end
+
+  namespace :structure do
+
+    redefine_task :dump do
+      config = ActiveRecord::Base.configurations[rails_env] # current_config
+      filename = structure_sql
+
+      case config['adapter']
+      when /mysql/
+        ActiveRecord::Base.establish_connection(config)
+        File.open(filename, 'w:utf-8') { |f| f << ActiveRecord::Base.connection.structure_dump }
+      when /postgresql/
+        ActiveRecord::Base.establish_connection(config)
+
+        ENV['PGHOST'] = config['host'] if config['host']
+        ENV['PGPORT'] = config['port'].to_s if config['port']
+        ENV['PGPASSWORD'] = config['password'].to_s if config['password']
+        ENV['PGUSER'] = config['username'].to_s if config['username']
+
+        require 'shellwords'
+        search_path = config['schema_search_path']
+        unless search_path.blank?
+          search_path = search_path.split(",").map{ |part| "--schema=#{Shellwords.escape(part.strip)}" }.join(" ")
+        end
+        sh "pg_dump -i -s -x -O -f #{Shellwords.escape(filename)} #{search_path} #{Shellwords.escape(config['database'])}"
+
+        File.open(filename, 'a') { |f| f << "SET search_path TO #{ActiveRecord::Base.connection.schema_search_path};\n\n" }
+      when /sqlite/
+        dbfile = config['database']
+        sh "sqlite3 #{dbfile} .schema > #{filename}"
+      else
+        ActiveRecord::Base.establish_connection(config)
+        ArJdbc::Tasks.structure_dump(config, filename)
+      end
+
+      if ActiveRecord::Base.connection.supports_migrations?
+        File.open(filename, 'a') { |f| f << ActiveRecord::Base.connection.dump_schema_information }
+      end
+
+    end
+
+    redefine_task :load do
+      config = current_config
+      filename = structure_sql
+
+      case config['adapter']
+      when /mysql/
+        ActiveRecord::Base.establish_connection(config)
+        ActiveRecord::Base.connection.execute('SET foreign_key_checks = 0')
+        IO.read(filename).split("\n\n").each do |table|
+          ActiveRecord::Base.connection.execute(table)
+        end
+      when /postgresql/
+        ENV['PGHOST'] = config['host'] if config['host']
+        ENV['PGPORT'] = config['port'].to_s if config['port']
+        ENV['PGPASSWORD'] = config['password'].to_s if config['password']
+        ENV['PGUSER'] = config['username'].to_s if config['username']
+
+        `psql -f "#{filename}" #{config['database']}`
+      when /sqlite/
+        dbfile = config['database']
+        `sqlite3 #{dbfile} < "#{filename}"`
+      else
+        ArJdbc::Tasks.structure_load(config, filename)
+      end
+    end
+
+    def structure_sql
+      ENV['DB_STRUCTURE'] ||= begin
+        root = defined?(Rails.root) ? Rails.root : ( RAILS_ROOT rescue nil )
+        if ActiveRecord::VERSION::STRING > '3.2'
+          root ? File.join(root, "db", "structure.sql") : File.join("db", "structure.sql")
+        else
+          root ? File.join(root, "db/#{rails_env}_structure.sql") : "db/#{rails_env}_structure.sql"
+        end
+      end
+    end
+
+  end
+
+  namespace :test do
+
+    # desc "Recreate the test database from an existent structure.sql file"
+    redefine_task :load_structure => 'db:test:purge' do # not on 2.3
+      begin
+        current_config(:config => ActiveRecord::Base.configurations['test'])
+        Rake::Task["db:structure:load"].invoke
+      ensure
+        current_config(:config => nil)
+      end
+    end
+
+    # desc "Recreate the test database from a fresh structure.sql file"
+    redefine_task :clone_structure => [ "db:structure:dump", "db:test:load_structure" ]
+    # same as on 3.2 - but this task gets changed on 2.3 by depending on :load_structure
+
+    # desc "Empty the test database"
+    redefine_task :purge do
+      config = ActiveRecord::Base.configurations['test']
+      case config['adapter']
+      when /mysql/
+        ActiveRecord::Base.establish_connection(:test)
+        options = mysql_creation_options(config) rescue config
+        ActiveRecord::Base.connection.recreate_database(config['database'], options)
+      when /postgresql/
+        ActiveRecord::Base.clear_active_connections!
+        # drop_database(config) :
+        ActiveRecord::Base.establish_connection(config.merge('database' => 'postgres', 'schema_search_path' => 'public'))
+        ActiveRecord::Base.connection.drop_database config['database']
+        # create_database(config) :
+        encoding = config[:encoding] || ENV['CHARSET'] || 'utf8'
+        ActiveRecord::Base.connection.create_database(config['database'], config.merge('encoding' => encoding))
+      when /sqlite/
+        dbfile = config['database']
+        File.delete(dbfile) if File.exist?(dbfile)
+      else
+        ArJdbc::Tasks.purge(config)
+      end
+    end
+    # only does (:purge => :environment) on AR < 3.2
+    task :purge => :load_config if Rake::Task.task_defined?(:load_config)
+
+  end
+
+end

data/lib/arjdbc/tasks/databases4.rake

@@ -0,0 +1,39 @@
+module ActiveRecord::Tasks
+
+  DatabaseTasks.module_eval do
+    
+    # patched to adapt jdbc configuration
+    def each_current_configuration(environment)
+      environments = [environment]
+      environments << 'test' if environment == 'development'
+
+      configurations = ActiveRecord::Base.configurations.values_at(*environments)
+      configurations.compact.each do |config|
+        yield adapt_jdbc_config(config) unless config['database'].blank?
+      end
+    end
+
+    # patched to adapt jdbc configuration
+    def each_local_configuration
+      ActiveRecord::Base.configurations.each_value do |config|
+        next unless config['database']
+
+        if local_database?(config)
+          yield adapt_jdbc_config(config)
+        else
+          $stderr.puts "This task only modifies local databases. #{config['database']} is on a remote host."
+        end
+      end
+    end
+
+  end
+
+  MySQLDatabaseTasks.class_eval do
+
+    def error_class
+      ActiveRecord::JDBCError
+    end
+
+  end
+  
+end