activerecord-jdbc-alt-adapter 50.3.0-java

data/lib/arjdbc/sqlite3/connection_methods.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+ArJdbc::ConnectionMethods.module_eval do
+  def sqlite3_connection(config)
+    config[:adapter_spec] ||= ::ArJdbc::SQLite3
+    config[:adapter_class] = ActiveRecord::ConnectionAdapters::SQLite3Adapter unless config.key?(:adapter_class)
+
+    return jndi_connection(config) if jndi_config?(config)
+
+    begin
+      require 'jdbc/sqlite3'
+      ::Jdbc::SQLite3.load_driver(:require) if defined?(::Jdbc::SQLite3.load_driver)
+    rescue LoadError # assuming driver.jar is on the class-path
+    end
+    config[:driver] ||= 'org.sqlite.JDBC'
+
+    begin
+      parse_sqlite3_config!(config)
+    rescue Errno::ENOENT => error
+      if error.message.include?('No such file or directory')
+        raise ActiveRecord::NoDatabaseError
+      else
+        raise
+      end
+    end
+
+    database = config[:database] # NOTE: "jdbc:sqlite::memory:" syntax is supported
+    config[:url] ||= "jdbc:sqlite:#{database == ':memory:' ? '' : database}"
+    config[:connection_alive_sql] ||= 'SELECT 1'
+
+    timeout = config[:timeout]
+    if timeout && timeout.to_s !~ /\A\d+\Z/
+      raise TypeError.new "Timeout must be nil or a number (got: #{timeout})."
+    end
+
+    options = ( config[:properties] ||= {} )
+    options['busy_timeout'] ||= timeout unless timeout.nil?
+
+    jdbc_connection(config)
+  # rescue ActiveRecord::JDBCError => error
+  #   if error.message =~ /path to .*? does not exist/ # path to '/foo/xxx/bar.db': '/foo/xxx' does not exist
+  #     raise ActiveRecord::NoDatabaseError
+  #   else
+  #     raise
+  #   end
+  end
+  alias_method :jdbcsqlite3_connection, :sqlite3_connection
+
+  private
+
+  def parse_sqlite3_config!(config)
+    database = ( config[:database] ||= config[:dbfile] )
+    if ':memory:' != database
+      config[:database] = File.expand_path(database, Rails.root) if defined?(Rails.root)
+      dirname = File.dirname(database)
+      Dir.mkdir(dirname) unless File.directory?(dirname)
+    end
+  end
+
+end

data/lib/arjdbc/sybase.rb

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

data/lib/arjdbc/sybase/adapter.rb

@@ -0,0 +1,47 @@
+module ArJdbc
+  module Sybase
+    def add_limit_offset!(sql, options) # :nodoc:
+      @limit = options[:limit]
+      @offset = options[:offset]
+      if use_temp_table?
+        # Use temp table to hack offset with Sybase
+        sql.sub!(/ FROM /i, ' INTO #artemp FROM ')
+      elsif zero_limit?
+        # "SET ROWCOUNT 0" turns off limits, so we havesy
+        # to use a cheap trick.
+        if sql =~ /WHERE/i
+          sql.sub!(/WHERE/i, 'WHERE 1 = 2 AND ')
+        elsif sql =~ /ORDER\s+BY/i
+          sql.sub!(/ORDER\s+BY/i, 'WHERE 1 = 2 ORDER BY')
+        else
+          sql << 'WHERE 1 = 2'
+        end
+      end
+    end
+
+    # If limit is not set at all, we can ignore offset;
+    # if limit *is* set but offset is zero, use normal select
+    # with simple SET ROWCOUNT.  Thus, only use the temp table
+    # if limit is set and offset > 0.
+    def use_temp_table?
+      !@limit.nil? && !@offset.nil? && @offset > 0
+    end
+
+    def zero_limit?
+      !@limit.nil? && @limit == 0
+    end
+
+    def modify_types(types) # :nodoc:
+      super(types)
+      types[:primary_key] = "NUMERIC(22,0) IDENTITY PRIMARY KEY"
+      types[:integer][:limit] = nil
+      types[:boolean] = {:name => "bit"}
+      types[:binary] = {:name => "image"}
+      types
+    end
+
+    def remove_index(table_name, options = {})
+      execute "DROP INDEX #{table_name}.#{index_name(table_name, options)}"
+    end
+  end
+end

data/lib/arjdbc/tasks.rb

@@ -0,0 +1,13 @@
+if defined?(Rake.application) && Rake.application
+  skip = ENV["SKIP_AR_JDBC_RAKE_REDEFINES"] # jruby -J-Darjdbc.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,31 @@
+module ArJdbc
+  module Tasks
+
+    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)
+
+    require 'arjdbc/tasks/jdbc_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'
+
+    # re-invent built-in (but deprecated on 4.0) tasks :
+    # tasks for custom (JDBC) adapters :
+    #register_tasks(/db2/, DB2DatabaseTasks)
+    #register_tasks(/derby/, DerbyDatabaseTasks)
+    #register_tasks(/h2/, H2DatabaseTasks)
+    #register_tasks(/hsqldb/, HSQLDBDatabaseTasks)
+    # (default) generic JDBC task :
+    register_tasks(/^jdbc$/, JdbcDatabaseTasks)
+    register_tasks(/sqlserver/, MSSQLDatabaseTasks)
+
+    # NOTE: no need to register "built-in" adapters such as MySQL
+
+  end
+end

data/lib/arjdbc/tasks/databases.rake

@@ -0,0 +1,48 @@
+require 'arjdbc/tasks/database_tasks'
+
+module ActiveRecord::Tasks
+
+  DatabaseTasks.module_eval do
+
+    # @override 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
+
+    # @override 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
+
+    private
+
+    def adapt_jdbc_config(config)
+      return config unless config['adapter']
+      config.merge 'adapter' => config['adapter'].sub(/^jdbc/, '')
+    end
+
+  end
+
+  MySQLDatabaseTasks.class_eval do
+
+    def error_class
+      ActiveRecord::JDBCError
+    end
+
+  end if const_defined?(:MySQLDatabaseTasks)
+
+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 |constraint_name, cols|
+            dump << "ALTER TABLE #{connection.quote_table_name(table_name)}\n"
+            dump << "  ADD CONSTRAINT #{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 resolve_database(config, true)
+        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,31 @@
+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 resolve_database(config)
+      end
+
+      # @override
+      def delete_database_files(config)
+        return unless db_base = database_base_name(config)
+        for suffix in [ '.h2,db', '.mv.db', '.lock.db', '.trace.db' ]
+          db_file = "#{db_base}#{suffix}"
+          File.delete(db_file) if File.exist?(db_file)
+        end
+      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 resolve_database(config)
+        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 = resolve_database(config, true)
+        db[0, 4] == 'mem:' ? nil : begin
+          expand_path db[0, 5] == 'file:' ? db[5..-1] : db
+        end
+      end
+
+    end
+  end
+end