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

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

data/lib/arjdbc/tasks/db2_database_tasks.rb

@@ -0,0 +1,104 @@
+require 'arjdbc/tasks/jdbc_database_tasks'
+
+module ArJdbc
+  module Tasks
+    class DB2DatabaseTasks < JdbcDatabaseTasks
+
+      def create
+        raise "AR-JDBC adapter 'DB2' does not support create_database"
+      end
+      
+      def purge
+        establish_connection(config)
+        connection.recreate_database
+      end
+      
+      # NOTE: does not work correctly (on non AS400) due driver meta data issue
+      # 
+      # also try db2move e.g. `db2move SAMPLE EXPORT -sn db2inst` 
+      # - where SAMPLE is the database name
+      # - and -sn specified schema name
+      # 
+      
+      def structure_dump(filename)
+        establish_connection(config)
+        dump = File.open(filename, "w:utf-8")
+        
+        schema_name = connection.schema.upcase if connection.schema
+        meta_data = connection.jdbc_connection.meta_data
+        tables_rs = meta_data.getTables(nil, schema_name, nil, ["TABLE"].to_java(:String))
+        
+        have_scale = ArJdbc::DB2::HAVE_SCALE
+        have_precision = ArJdbc::DB2::HAVE_LIMIT + ArJdbc::DB2::HAVE_LIMIT
+        
+        while tables_rs.next
+          table_name = tables_rs.getString('TABLE_NAME')
+          dump << "CREATE TABLE #{connection.quote_table_name(table_name)} (\n"
+          
+          cols_rs = meta_data.getColumns(nil, schema_name, table_name, nil)
+          begin
+            first_col = true
+            while cols_rs.next
+              column_name = cols_rs.getString(4)
+              default = cols_rs.getString(13)
+              default = default.empty? ? "" : " DEFAULT #{default}" if default
+              type = cols_rs.getString(6)
+              precision, scale = cols_rs.getString(7), cols_rs.getString(9)
+              column_size = ""
+              if scale && have_scale.include?(type)
+                column_size = "(#{precision},#{scale})"
+              elsif precision && have_precision.include?(type)
+                column_size = "(#{precision})"
+              end
+              nulling = ( cols_rs.getString(18) == 'NO' ? " NOT NULL" : nil )
+              autoinc = ( cols_rs.getString(23) == 'YES' ? " GENERATED ALWAYS AS IDENTITY" : nil )
+              
+              create_column = connection.quote_column_name(column_name)
+              create_column << " #{type}"
+              create_column << column_size
+              create_column << nulling.to_s
+              create_column << default.to_s
+              create_column << autoinc.to_s
+              
+              create_column = first_col ? "  #{create_column}" : ",\n  #{create_column}"
+              dump << create_column
+
+              first_col = false
+            end
+          ensure
+            cols_rs.close
+          end
+
+          dump << "\n);\n\n"
+
+          pk_rs = meta_data.getPrimaryKeys(nil, schema_name, table_name)
+          primary_keys = {}
+          begin
+            while pk_rs.next
+              name = pk_rs.getString(6)
+              primary_keys[name] ||= []
+              primary_keys[name] << pk_rs.getString(4)
+            end
+          ensure
+            pk_rs.close
+          end
+          primary_keys.each do |name, cols|
+            dump << "ALTER TABLE #{connection.quote_table_name(table_name)}\n"
+            dump << "  ADD CONSTRAINT #{name}\n"
+            dump << "    PRIMARY KEY (#{cols.join(', ')});\n\n"
+          end
+        end
+        
+        dump.close
+      end
+      
+      def structure_load(filename)
+        establish_connection(config)
+        IO.read(filename).split(/;\n*/m).each do |ddl| 
+          connection.execute ddl.sub(/;$/, '')
+        end
+      end
+      
+    end
+  end
+end

data/lib/arjdbc/tasks/derby_database_tasks.rb

@@ -0,0 +1,95 @@
+require 'arjdbc/tasks/jdbc_database_tasks'
+
+module ArJdbc
+  module Tasks
+    class DerbyDatabaseTasks < JdbcDatabaseTasks
+
+      def create
+        establish_connection(config)
+        ActiveRecord::Base.connection
+      end
+      
+      def drop
+        db_dir = expand_path(config['database'])
+        if File.exist?(db_dir)
+          FileUtils.rm_r(db_dir)
+          FileUtils.rmdir(db_dir) rescue nil
+        end
+      end
+      
+      SIZEABLE = %w( VARCHAR CLOB BLOB )
+
+      def structure_dump(filename)
+        establish_connection(config)
+        dump = File.open(filename, "w:utf-8")
+        
+        meta_data = connection.jdbc_connection.meta_data
+        tables_rs = meta_data.getTables(nil, nil, nil, ["TABLE"].to_java(:String))
+        
+        while tables_rs.next
+          table_name = tables_rs.getString('TABLE_NAME') # getString(3)
+          dump << "CREATE TABLE #{connection.quote_table_name(table_name)} (\n"
+          
+          columns_rs = meta_data.getColumns(nil, nil, table_name, nil)
+          first_col = true
+          while columns_rs.next
+            column_name = columns_rs.getString(4)
+            default = columns_rs.getString(13)
+            if default =~ /^GENERATED_/
+              default = column_auto_increment_def(table_name, column_name)
+            elsif default
+              default = " DEFAULT #{default}"
+            end
+            type = columns_rs.getString(6)
+            column_size = columns_rs.getString(7)
+            nulling = ( columns_rs.getString(18) == 'NO' ? " NOT NULL" : nil )
+            
+            create_column = connection.quote_column_name(column_name)
+            create_column << " #{type}"
+            create_column << ( SIZEABLE.include?(type) ? "(#{column_size})" : "" )
+            create_column << nulling.to_s
+            create_column << default.to_s
+
+            create_column = first_col ? " #{create_column}" : ",\n #{create_column}"
+            dump << create_column
+
+            first_col = false
+          end
+          dump << "\n);\n\n"
+        end
+        
+        dump.close
+      end
+      
+      def structure_load(filename)
+        establish_connection(config)
+        IO.read(filename).split(/;\n*/m).each { |ddl| connection.execute(ddl) }
+      end
+      
+      private
+
+      AUTO_INCREMENT_SQL = '' <<
+      "SELECT AUTOINCREMENTSTART, AUTOINCREMENTINC, COLUMNNAME, REFERENCEID, COLUMNDEFAULT " <<
+      "FROM SYS.SYSCOLUMNS WHERE REFERENCEID = " <<
+      "(SELECT T.TABLEID FROM SYS.SYSTABLES T WHERE T.TABLENAME = '%s') AND COLUMNNAME = '%s'"
+
+      def column_auto_increment_def(table_name, column_name)
+        sql = AUTO_INCREMENT_SQL % [ table_name, column_name ]
+        if data = connection.execute(sql).first
+          if start = data['autoincrementstart']
+            ai_def = ' GENERATED '
+            ai_def << ( data['columndefault'].nil? ? "ALWAYS" : "BY DEFAULT " )
+            ai_def << "AS IDENTITY (START WITH "
+            ai_def << start.to_s
+            ai_def << ", INCREMENT BY "
+            ai_def << data['autoincrementinc'].to_s
+            ai_def << ")"
+            return ai_def
+          end
+        end
+        ''
+      end
+      
+    end
+  end
+end

data/lib/arjdbc/tasks/h2_database_tasks.rb

@@ -0,0 +1,29 @@
+require 'arjdbc/tasks/hsqldb_database_tasks'
+
+module ArJdbc
+  module Tasks
+    class H2DatabaseTasks < HSQLDBDatabaseTasks
+      
+      protected
+      
+      # @override
+      def do_drop_database(config)
+        # ActiveRecord::JDBCError: org.h2.jdbc.JdbcSQLException: 
+        # Database is already closed (to disable automatic closing at VM 
+        # shutdown, add ";DB_CLOSE_ON_EXIT=FALSE" to the db URL) [90121-170]: 
+        # SHUTDOWN COMPACT
+        # 
+        # connection.shutdown
+        connection.drop_database config['database']
+      end
+      
+      # @override
+      def delete_database_files(config)
+        return unless db_base = database_base_name(config)
+        db_files = [ "#{db_base}.h2.db", "#{db_base}.lock.db", "#{db_base}.trace.db" ]
+        db_files.each { |file| File.delete(file) if File.exist?(file) }
+      end
+      
+    end
+  end
+end

data/lib/arjdbc/tasks/hsqldb_database_tasks.rb

@@ -0,0 +1,70 @@
+require 'arjdbc/tasks/jdbc_database_tasks'
+
+module ArJdbc
+  module Tasks
+    class HSQLDBDatabaseTasks < JdbcDatabaseTasks
+
+      def create
+        establish_connection(config)
+        ActiveRecord::Base.connection
+      end
+      
+      def drop
+        error = nil
+        begin
+          establish_connection(config)
+          do_drop_database(config)
+        rescue => e
+          error = e
+          raise error
+        ensure
+          begin
+            keep_db_files = ENV['KEEP_DB_FILES'] && ENV['KEEP_DB_FILES'] != 'false'
+            delete_database_files(config) unless keep_db_files
+          rescue => e
+            raise e unless error
+          end
+        end
+      end
+      alias :purge :drop
+      
+      protected
+      
+      def do_drop_database(config)
+        connection.drop_database config['database']
+        connection.shutdown
+      end
+      
+      def delete_database_files(config)
+        return unless db_base = database_base_name(config)
+        Dir.glob("#{db_base}.*").each do |file|
+          # test.hsqldb.tmp (dir)
+          # test.hsqldb.lck
+          # test.hsqldb.lobs
+          # test.hsqldb.script
+          # test.hsqldb.properties
+          if File.directory?(file)
+            FileUtils.rm_r(file)
+            FileUtils.rmdir(file)
+          else
+            FileUtils.rm(file)
+          end
+        end
+        if File.exist?(db_base)
+          FileUtils.rm_r(db_base)
+          FileUtils.rmdir(db_base)
+        end
+      end
+      
+      private
+      
+      def database_base_name(config)
+        db = config['database']
+        db[0, 4] == 'mem:' ? nil : begin
+          expand_path db[0, 4] == 'file:' ? db[4..-1] : db
+        end
+      end
+      
+    end
+  end
+end

data/lib/arjdbc/tasks/jdbc_database_tasks.rb

@@ -0,0 +1,122 @@
+module ArJdbc
+  module Tasks
+    # Sharing task related code between AR 3.x and 4.x
+    # 
+    # @note this class needs to conform to the API available since AR 4.0
+    # mostly to be usable with ActiveRecord::Tasks::DatabaseTasks module
+    class JdbcDatabaseTasks
+      
+      attr_reader :configuration
+      alias_method :config, :configuration
+      
+      def initialize(configuration)
+        @configuration = configuration
+      end
+      
+      delegate :connection, :establish_connection, :to => ActiveRecord::Base
+
+      def create
+        begin
+          establish_connection(config)
+          ActiveRecord::Base.connection
+          if defined? ActiveRecord::Tasks::DatabaseAlreadyExists
+            raise ActiveRecord::Tasks::DatabaseAlreadyExists # AR-4.x
+          end # silence on AR < 4.0
+        rescue #=> error # database does not exists :
+          url = config['url']
+          url = $1 if url && url =~ /^(.*(?<!\/)\/)(?=\w)/
+          
+          establish_connection(config.merge('database' => nil, 'url' => url))
+          
+          unless connection.respond_to?(:create_database)
+            raise "AR-JDBC adapter '#{adapter_with_spec}' does not support create_database"
+          end
+          connection.create_database(config['database'], config)
+          
+          establish_connection(config)
+        end
+      end
+
+      def drop
+        establish_connection(config)
+        unless ActiveRecord::Base.connection.respond_to?(:drop_database)
+          raise "AR-JDBC adapter '#{adapter_with_spec}' does not support drop_database"
+        end
+        connection.drop_database config['database']
+      end
+
+      def purge
+        establish_connection(config) # :test
+        unless ActiveRecord::Base.connection.respond_to?(:recreate_database)
+          raise "AR-JDBC adapter '#{adapter_with_spec}' does not support recreate_database (purge)"
+        end
+        db_name = ActiveRecord::Base.connection.database_name
+        ActiveRecord::Base.connection.recreate_database(db_name, config)
+      end
+
+      def charset
+        establish_connection(config)
+        if connection.respond_to?(:charset)
+          puts connection.charset
+        elsif connection.respond_to?(:encoding)
+          puts connection.encoding
+        else
+          raise "AR-JDBC adapter '#{adapter_with_spec}' does not support charset/encoding"
+        end
+      end
+
+      def collation
+        establish_connection(config)
+        if connection.respond_to?(:collation)
+          puts connection.collation
+        else
+          raise "AR-JDBC adapter '#{adapter_with_spec}' does not support collation"
+        end
+      end
+      
+      def structure_dump(filename)
+        establish_connection(config)
+        if connection.respond_to?(:structure_dump)
+          File.open(filename, "w:utf-8") { |f| f << connection.structure_dump }
+        else
+          raise "AR-JDBC adapter '#{adapter_with_spec}' does not support structure_dump"
+        end
+      end
+
+      def structure_load(filename)
+        establish_connection(config)
+        if connection.respond_to?(:structure_load)
+          connection.structure_load IO.read(filename)
+        else
+          #IO.read(filename).split(/;\n*/m).each do |ddl|
+          #  connection.execute(ddl)
+          #end
+          raise "AR-JDBC adapter '#{adapter_with_spec}' does not support structure_load"
+        end
+      end
+      
+      private
+      
+      def adapter_with_spec
+        adapter, spec = config['adapter'], config['adapter_spec']
+        spec ? "#{adapter} (#{spec})" : adapter
+      end
+      
+      protected
+      
+      def expand_path(path)
+        require 'pathname'
+        path = Pathname.new path
+        return path.to_s if path.absolute?
+        rails_root ? File.join(rails_root, path) : File.expand_path(path)
+      end
+      
+      private
+      
+      def rails_root
+        defined?(Rails.root) ? Rails.root : ( RAILS_ROOT )
+      end
+      
+    end
+  end
+end