activerecord-jdbc-adapter 1.3.0.beta1 → 1.3.0.beta2

data/lib/arjdbc/postgresql/column_cast.rb

@@ -8,8 +8,8 @@ module ArJdbc
           return string unless String === string
 
           case string
-          when 'infinity'; 1.0 / 0.0
-          when '-infinity'; -1.0 / 0.0
+          when  'infinity' then  1.0 / 0.0
+          when '-infinity' then -1.0 / 0.0
           when / BC$/
             super("-" + string.sub(/ BC$/, ""))
           else
@@ -19,9 +19,7 @@ module ArJdbc
 
         def hstore_to_string(object)
           if Hash === object
-            object.map { |k,v|
-              "#{escape_hstore(k)}=>#{escape_hstore(v)}"
-            }.join ','
+            object.map { |k,v| "#{escape_hstore(k)}=>#{escape_hstore(v)}" }.join(',')
           else
             object
           end

data/lib/arjdbc/postgresql/connection_methods.rb

@@ -6,17 +6,17 @@ ArJdbc::ConnectionMethods.module_eval do
     rescue LoadError # assuming driver.jar is on the class-path
     end
 
-    config[:username] ||= Java::JavaLang::System.get_property("user.name")
     config[:host] ||= "localhost"
     config[:port] ||= 5432
+    config[:username] ||= Java::JavaLang::System.get_property("user.name")
     config[:url] ||= "jdbc:postgresql://#{config[:host]}:#{config[:port]}/#{config[:database]}"
     config[:url] << config[:pg_params] if config[:pg_params]
     config[:driver] ||= defined?(::Jdbc::Postgres.driver_name) ? ::Jdbc::Postgres.driver_name : 'org.postgresql.Driver'
-    config[:adapter_class] = ActiveRecord::ConnectionAdapters::PostgreSQLAdapter
-    config[:adapter_spec] = ::ArJdbc::PostgreSQL
-    conn = jdbc_connection(config)
-    conn.execute("SET SEARCH_PATH TO #{config[:schema_search_path]}") if config[:schema_search_path]
-    conn
+    config[:adapter_spec] ||= ::ArJdbc::PostgreSQL
+    config[:adapter_class] = ActiveRecord::ConnectionAdapters::PostgreSQLAdapter unless config.key?(:adapter_class)
+    # config[:connection_alive_sql] ||= 'SELECT 1'
+    
+    jdbc_connection(config)
   end
   alias_method :jdbcpostgresql_connection, :postgresql_connection
 end

data/lib/arjdbc/railtie.rb

@@ -3,7 +3,9 @@ require 'rails/railtie'
 module ArJdbc
   class Railtie < ::Rails::Railtie
     rake_tasks do
-      load File.expand_path('jdbc/rake_tasks.rb', File.dirname(__FILE__))
+      if defined? ActiveRecord::Railtie # only if AR being used
+        load File.expand_path('tasks.rb', File.dirname(__FILE__))
+      end
     end
   end
 end

data/lib/arjdbc/sqlite3/adapter.rb

@@ -1,7 +1,9 @@
+ArJdbc.load_java_part :SQLite3
+
 require 'arjdbc/jdbc/missing_functionality_helper'
 require 'arjdbc/sqlite3/explain_support'
 
-module ::ArJdbc
+module ArJdbc
   module SQLite3
     
     def self.column_selector
@@ -86,14 +88,21 @@ module ::ArJdbc
       
     end
 
-    def self.arel2_visitors(config)
-      {
-        'sqlite3' => ::Arel::Visitors::SQLite,
-        'jdbcsqlite3' => ::Arel::Visitors::SQLite
-      }
+    def self.arel2_visitors(config = nil)
+      { 'sqlite3' => ::Arel::Visitors::SQLite, 'jdbcsqlite3' => ::Arel::Visitors::SQLite }
     end
     
-    ADAPTER_NAME = 'SQLite'
+    def new_visitor(config = nil)
+      visitor = ::Arel::Visitors::SQLite
+      ( prepared_statements? ? visitor : bind_substitution(visitor) ).new(self)
+    end if defined? ::Arel::Visitors::SQLite
+    
+    # @see #bind_substitution
+    class BindSubstitution < Arel::Visitors::SQLite # :nodoc:
+      include Arel::Visitors::BindVisitor
+    end if defined? Arel::Visitors::BindVisitor
+    
+    ADAPTER_NAME = 'SQLite'.freeze
     
     def adapter_name # :nodoc:
       ADAPTER_NAME
@@ -200,6 +209,10 @@ module ::ArJdbc
       end
     end
 
+    def quote_table_name_for_assignment(table, attr)
+      quote_column_name(attr)
+    end if ::ActiveRecord::VERSION::MAJOR > 3
+    
     def quote_column_name(name) # :nodoc:
       %Q("#{name.to_s.gsub('"', '""')}") # "' kludge for emacs font-lock
     end
@@ -235,22 +248,6 @@ module ::ArJdbc
       table_name && tables(nil, table_name).any?
     end
     
-    IndexDefinition = ::ActiveRecord::ConnectionAdapters::IndexDefinition # :nodoc:
-    
-    def indexes(table_name, name = nil)
-      result = select_rows("SELECT name, sql FROM sqlite_master" <<
-      " WHERE tbl_name = #{quote_table_name(table_name)} AND type = 'index'", name)
-
-      result.map do |row|
-        name, index_sql = row[0], row[1]
-        unique = !! (index_sql =~ /unique/i)
-        columns = index_sql.match(/\((.*)\)/)[1].gsub(/,/,' ').split.map do |col|
-          match = /^"(.+)"$/.match(col); match ? match[1] : col
-        end
-        IndexDefinition.new(table_name, name, unique, columns)
-      end
-    end
-    
     # Returns 62. SQLite supports index names up to 64
     # characters. The rest is used by rails internally to perform
     # temporary rename operations
@@ -270,7 +267,15 @@ module ::ArJdbc
       execute("RELEASE SAVEPOINT #{current_savepoint_name}")
     end
     
-    def recreate_database(name, options = {})
+    def recreate_database(name = nil, options = {}) # :nodoc:
+      drop_database(name)
+      create_database(name, options)
+    end
+    
+    def create_database(name = nil, options = {}) # :nodoc:
+    end
+
+    def drop_database(name = nil) # :nodoc:
       tables.each { |table| drop_table(table) }
     end
     
@@ -308,7 +313,7 @@ module ::ArJdbc
       raise e
     end
 
-    def jdbc_columns(table_name, name = nil) # :nodoc:
+    def columns(table_name, name = nil) # :nodoc:
       klass = ::ActiveRecord::ConnectionAdapters::SQLite3Column
       table_structure(table_name).map do |field|
         klass.new(field['name'], field['dflt_value'], field['type'], field['notnull'] == 0)
@@ -345,6 +350,16 @@ module ::ArJdbc
       end
     end
 
+    if ActiveRecord::VERSION::MAJOR >= 4
+      
+    def remove_column(table_name, column_name, type = nil, options = {}) #:nodoc:
+      alter_table(table_name) do |definition|
+        definition.remove_column column_name
+      end
+    end
+      
+    else
+      
     def remove_column(table_name, *column_names) #:nodoc:
       if column_names.empty?
         raise ArgumentError.new(
@@ -359,7 +374,9 @@ module ::ArJdbc
       end
     end
     alias :remove_columns :remove_column
-
+    
+    end
+    
     def change_column_default(table_name, column_name, default) #:nodoc:
       alter_table(table_name) do |definition|
         definition[column_name].default = default
@@ -410,6 +427,10 @@ module ::ArJdbc
       "DEFAULT VALUES"
     end
     
+    def encoding
+      select_value 'PRAGMA encoding'
+    end
+    
     protected
     
     include ArJdbc::MissingFunctionalityHelper
@@ -442,9 +463,10 @@ module ::ArJdbc
 end
 
 module ActiveRecord::ConnectionAdapters
-  remove_const(:SQLite3Adapter) if const_defined?(:SQLite3Adapter)
-  remove_const(:SQLiteAdapter) if const_defined?(:SQLiteAdapter)
 
+  # NOTE: SQLite3Column exists in native adapter since AR 4.0
+  remove_const(:SQLite3Column) if const_defined?(:SQLite3Column)
+  
   class SQLite3Column < JdbcColumn
     include ArJdbc::SQLite3::Column
 
@@ -467,7 +489,9 @@ module ActiveRecord::ConnectionAdapters
       value
     end
   end
-
+  
+  remove_const(:SQLite3Adapter) if const_defined?(:SQLite3Adapter)
+  
   class SQLite3Adapter < JdbcAdapter
     include ArJdbc::SQLite3
     include ArJdbc::SQLite3::ExplainSupport
@@ -477,24 +501,17 @@ module ActiveRecord::ConnectionAdapters
     end
 
     def jdbc_column_class
-      ActiveRecord::ConnectionAdapters::SQLite3Column
+      ::ActiveRecord::ConnectionAdapters::SQLite3Column
     end
-
-    alias_chained_method :columns, :query_cache, :jdbc_columns
     
   end
 
-  SQLiteAdapter = SQLite3Adapter
-end
-
-# Don't need to load native sqlite3 adapter
-$LOADED_FEATURES << 'active_record/connection_adapters/sqlite_adapter.rb'
-$LOADED_FEATURES << 'active_record/connection_adapters/sqlite3_adapter.rb'
+  if ActiveRecord::VERSION::MAJOR <= 3
+    remove_const(:SQLiteColumn) if const_defined?(:SQLiteColumn)
+    SQLiteColumn = SQLite3Column
+    
+    remove_const(:SQLiteAdapter) if const_defined?(:SQLiteAdapter)
 
-# Fake out sqlite3/version driver for AR tests
-$LOADED_FEATURES << 'sqlite3/version.rb'
-module SQLite3
-  module Version
-    VERSION = '1.2.6' # query_cache_test.rb requires SQLite3::Version::VERSION > '1.2.5'
+    SQLiteAdapter = SQLite3Adapter
   end
 end

data/lib/arjdbc/sqlite3/connection_methods.rb

@@ -11,23 +11,23 @@ ArJdbc::ConnectionMethods.module_eval do
     database = '' if database == ':memory:'
     config[:url] ||= "jdbc:sqlite:#{database}"
     config[:driver] ||= defined?(::Jdbc::SQLite3.driver_name) ? ::Jdbc::SQLite3.driver_name : 'org.sqlite.JDBC'
-    config[:adapter_class] = ActiveRecord::ConnectionAdapters::SQLite3Adapter
-    config[:adapter_spec] = ::ArJdbc::SQLite3
+    config[:adapter_spec] ||= ::ArJdbc::SQLite3
+    config[:adapter_class] = ActiveRecord::ConnectionAdapters::SQLite3Adapter unless config.key?(:adapter_class)
+    config[:connection_alive_sql] ||= 'SELECT 1'
+    
     jdbc_connection(config)
   end
   alias_method :jdbcsqlite3_connection, :sqlite3_connection
 
   private
+  
   def parse_sqlite3_config!(config)
     config[:database] ||= config[:dbfile]
- 
-    # Allow database path relative to RAILS_ROOT, but only if
-    # the database path is not the special path that tells
-    # Sqlite to build a database only in memory.
-    rails_root_defined = defined?(Rails.root) || Object.const_defined?(:RAILS_ROOT)
-    if rails_root_defined && ':memory:' != config[:database]
+    # Allow database path relative to RAILS_ROOT :
+    if config[:database] != ':memory:' && defined?(Rails.root) || Object.const_defined?(:RAILS_ROOT)
       rails_root = defined?(Rails.root) ? Rails.root : RAILS_ROOT
-      config[:database] = File.expand_path(config[:database], rails_root)
+      config[:database] = File.expand_path(config[:database], rails_root.to_s)
     end
   end
+  
 end

data/lib/arjdbc/sybase.rb

@@ -1,2 +1,2 @@
 require 'arjdbc'
-require 'arjdbc/sybase/adapter.rb'
+require 'arjdbc/sybase/adapter'

data/lib/arjdbc/tasks.rb

@@ -0,0 +1,13 @@
+if defined?(Rake.application) && Rake.application
+  skip = ENV["SKIP_AR_JDBC_RAKE_REDEFINES"] # jruby -J-Darjdc.tasks.skip=true -S rake ...
+  if ! Java::JavaLang::Boolean.getBoolean('arjdbc.tasks.skip') || ! ( skip && skip != 'false' )
+    databases_rake = File.expand_path('tasks/databases.rake', File.dirname(__FILE__))
+    if Rake.application.lookup("db:create")
+      load databases_rake # load the override tasks now
+    else # rails tasks not loaded yet; load as an import
+      Rake.application.add_import(databases_rake)
+    end
+  end
+else
+  warn "ArJdbc: could not load rake tasks - rake not loaded ..."
+end

data/lib/arjdbc/tasks/database_tasks.rb

@@ -0,0 +1,50 @@
+module ArJdbc
+  module Tasks
+    
+    if defined? ActiveRecord::Tasks::DatabaseTasks # AR-4.x
+    
+      def self.register_tasks(pattern, task)
+        ActiveRecord::Tasks::DatabaseTasks.register_task(pattern, task)
+      end
+      
+    else
+      
+      @@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/oracle_database_tasks'
+    
+    # re-invent built-in (but deprecated on 4.0) tasks :
+    register_tasks(/(mssql|sqlserver)/i, MSSQLDatabaseTasks)
+    register_tasks(/(oci|oracle)/i, OracleDatabaseTasks)
+    # tasks for custom (JDBC) adapters :
+    register_tasks(/db2/i, DB2DatabaseTasks)
+    register_tasks(/derby/i, DerbyDatabaseTasks)
+    register_tasks(/h2/i, H2DatabaseTasks)
+    register_tasks(/hsqldb/i, HSQLDBDatabaseTasks)
+    # (default) generic JDBC task :
+    register_tasks(/^jdbc$/i, 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

@@ -0,0 +1,89 @@
+raise "ArJdbc needs rake 0.9.x or newer" unless Rake.const_defined?(:VERSION)
+
+Rake::DSL.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
+    
+    full_name = Rake::Task.scope_name(Rake.application.current_scope, task_name)
+    
+    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
+    
+    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
+  
+end
+
+namespace :db do
+
+  def rails_env
+    defined?(Rails.env) ? Rails.env : ( RAILS_ENV || 'development' )
+  end
+  
+  def adapt_jdbc_config(config)
+    return config unless config['adapter']
+    config.merge 'adapter' => config['adapter'].sub(/^jdbc/, '')
+  end
+  
+  if defined? ActiveRecord::Tasks::DatabaseTasks # 4.0
+    
+    def current_config(options = {})
+      ActiveRecord::Tasks::DatabaseTasks.current_config(options)
+    end
+    
+  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 ||= 
+          if ENV['DATABASE_URL']
+            database_url_config
+          else
+            ActiveRecord::Base.configurations[options[:env]]
+          end
+      end
+    end
+
+    def database_url_config(url = ENV['DATABASE_URL'])
+      unless defined? ActiveRecord::Base::ConnectionSpecification::Resolver
+        raise "ENV['DATABASE_URL'] not support on AR #{ActiveRecord::VERSION::STRING}"
+      end
+      @database_url_config ||=
+        ActiveRecord::Base::ConnectionSpecification::Resolver.new(url, {}).spec.config.stringify_keys
+    end
+    
+  end
+  
+end
+
+require 'arjdbc/tasks/database_tasks'
+
+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,203 @@
+# NOTE: fake these for create_database(config)
+module Mysql
+  Error = ActiveRecord::JDBCError unless const_defined?(:Error)
+end
+module Mysql2
+  Error = ActiveRecord::JDBCError unless const_defined?(:Error)
+end
+
+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 /mysql|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
+        `pg_dump -i -s -x -O -f #{Shellwords.escape(filename)} #{search_path} #{Shellwords.escape(config['database'])}`
+        raise 'Error dumping database' if $?.exitstatus == 1
+        
+        File.open(filename, 'a') { |f| f << "SET search_path TO #{ActiveRecord::Base.connection.schema_search_path};\n\n" }
+      when /sqlite/
+        dbfile = config['database']
+        `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 = ActiveRecord::Base.configurations[rails_env] # 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["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