activerecord-jdbc-adapter-ficoh 1.3.21-java

data/lib/arjdbc/sqlite3/connection_methods.rb

@@ -0,0 +1,36 @@
+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)
+
+    ArJdbc.load_driver(:SQLite3) unless config[:load_driver] == false
+    config[:driver] ||= 'org.sqlite.JDBC'
+    parse_sqlite3_config!(config)
+    database = config[:database] # NOTE: "jdbc:sqlite::memory:" syntax is supported
+    config[:url] ||= "jdbc:sqlite:#{database == ':memory:' ? '' : database}"
+    config[:connection_alive_sql] ||= 'SELECT 1'
+
+    options = ( config[:properties] ||= {} )
+    # NOTE: configuring from JDBC properties not supported on 3.7.2 :
+    options['busy_timeout'] ||= config[:timeout] if config.key?(:timeout)
+
+    jdbc_connection(config)
+  end
+  alias_method :jdbcsqlite3_connection, :sqlite3_connection
+
+  private
+
+  def parse_sqlite3_config!(config)
+    database = ( config[:database] ||= config[:dbfile] ) # allow Rails relative path :
+    if database != ':memory:' && defined?(Rails.root) || Object.const_defined?(:RAILS_ROOT)
+      rails_root = defined?(Rails.root) ? Rails.root : RAILS_ROOT
+      config[:database] = File.expand_path(database, rails_root.to_s)
+      dirname = File.dirname(config[:database])
+      Dir.mkdir(dirname) unless File.directory?(dirname)
+    end
+  end
+
+end

data/lib/arjdbc/sqlite3/explain_support.rb

@@ -0,0 +1,29 @@
+module ArJdbc
+  module SQLite3
+    module ExplainSupport
+      def supports_explain?
+        true
+      end
+
+      def explain(arel, binds = [])
+        sql = "EXPLAIN QUERY PLAN #{to_sql(arel, binds)}"
+        result  = exec_query(sql, "EXPLAIN", binds)
+        ExplainPrettyPrinter.new.pp result
+      end
+
+      class ExplainPrettyPrinter # :nodoc:
+        # Pretty prints the result of a EXPLAIN QUERY PLAN in a way that resembles
+        # the output of the SQLite shell:
+        #
+        # 0|0|0|SEARCH TABLE users USING INTEGER PRIMARY KEY (rowid=?) (~1 rows)
+        # 0|1|1|SCAN TABLE posts (~100000 rows)
+        #
+        def pp(result)
+          result.rows.map do |row|
+            row.join('|')
+          end.join("\n") + "\n"
+        end
+      end
+    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,66 @@
+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
+
+      register_tasks(/mariadb/, ActiveRecord::Tasks::MySQLDatabaseTasks)
+
+      # patch-in lazy (auto) loading with AR registered tasks :
+      module ActiveRecord::Tasks::DatabaseTasks
+        def class_for_adapter(adapter)
+          unless key = @tasks.keys.detect { |pattern| adapter[pattern] }
+            raise DatabaseNotSupported, "Rake tasks not supported by '#{adapter}' adapter"
+          end
+          tasks = @tasks[key] || JdbcDatabaseTasks
+          tasks = ArJdbc::Tasks.const_get(tasks) unless tasks.is_a?(Module)
+          tasks
+        end
+      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 = @@tasks[key] || JdbcDatabaseTasks
+        tasks = const_get(tasks) unless tasks.is_a?(Module)
+        tasks.new(config)
+      end
+
+    end
+
+    autoload :JdbcDatabaseTasks, 'arjdbc/tasks/jdbc_database_tasks'
+    autoload :DB2DatabaseTasks, 'arjdbc/tasks/db2_database_tasks'
+    autoload :DerbyDatabaseTasks, 'arjdbc/tasks/derby_database_tasks'
+    autoload :H2DatabaseTasks, 'arjdbc/tasks/h2_database_tasks'
+    autoload :HSQLDBDatabaseTasks, 'arjdbc/tasks/hsqldb_database_tasks'
+    autoload :MSSQLDatabaseTasks, 'arjdbc/tasks/mssql_database_tasks'
+    autoload :OracleDatabaseTasks, 'arjdbc/tasks/oracle_database_tasks'
+
+    # re-invent built-in (but deprecated on 4.0) tasks :
+    register_tasks(/sqlserver/, :MSSQLDatabaseTasks)
+    register_tasks(/(oci|oracle)/, :OracleDatabaseTasks)
+    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)
+    # (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

@@ -0,0 +1,91 @@
+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
+
+  if defined? adapt_jdbc_config
+    warn "double loading #{__FILE__} please delete lib/tasks/jdbc.rake if present!"
+  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 ||= 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'
+
+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,239 @@
+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)
+    when /mariadb/ # fake mariadb as mysql for Rails
+      config = config.update('adapter' => 'mysql')
+      config['driver'] ||= 'org.mariadb.jdbc.Driver'
+      _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)
+    when /mariadb/ # fake mariadb as mysql for Rails
+      config = config.update('adapter' => 'mysql')
+      config['driver'] ||= 'org.mariadb.jdbc.Driver'
+      _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|mariadb/
+        args = _prepare_mysql_options('mysqldump', config)
+        args.concat(["--result-file", "#{filename}"])
+        args.concat(["--no-data"])
+        args.concat(["#{config['database']}"])
+        unless Kernel.system(*args)
+          puts "Could not dump the database structure. "\
+          "Make sure `mysqldump` is in your PATH and check the command output for warnings."
+        end
+      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|mariadb/
+        args = _prepare_mysql_options('mysql', config)
+        args.concat(['--execute', %{SET FOREIGN_KEY_CHECKS = 0; SOURCE #{filename}; SET FOREIGN_KEY_CHECKS = 1}])
+        args.concat(["--database", "#{config['database']}"])
+        Kernel.system(*args)
+      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
+
+    def _prepare_mysql_options(command, config)
+      args = [ command ]
+      args.concat(['--user', config['username']]) if config['username']
+      args << "--password=#{config['password']}" if config['password']
+      args.concat(['--default-character-set', config['encoding']]) if config['encoding']
+      config.slice('host', 'port', 'socket').each do |k, v|
+        args.concat([ "--#{k}", v.to_s ]) if v
+      end
+      args
+    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|mariadb/
+        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