activerecord-jdbc-adapter 1.0.3-java → 50.1-java

data/lib/arjdbc/jdbc/missing_functionality_helper.rb

@@ -1,87 +0,0 @@
-module ArJdbc
-  module MissingFunctionalityHelper
-    #Taken from SQLite adapter
-
-    def alter_table(table_name, options = {}) #:nodoc:
-      table_name = table_name.to_s.downcase
-      altered_table_name = "altered_#{table_name}"
-      caller = lambda {|definition| yield definition if block_given?}
-
-      transaction do
-        # A temporary table might improve performance here, but
-        # it doesn't seem to maintain indices across the whole move.
-        move_table(table_name, altered_table_name,
-          options)
-        move_table(altered_table_name, table_name, &caller)
-      end
-    end
-
-    def move_table(from, to, options = {}, &block) #:nodoc:
-      copy_table(from, to, options, &block)
-      drop_table(from)
-    end
-
-    def copy_table(from, to, options = {}) #:nodoc:
-      options = options.merge(:id => (!columns(from).detect{|c| c.name == 'id'}.nil? && 'id' == primary_key(from).to_s))
-      create_table(to, options) do |definition|
-        @definition = definition
-        columns(from).each do |column|
-          column_name = options[:rename] ?
-            (options[:rename][column.name] ||
-             options[:rename][column.name.to_sym] ||
-             column.name) : column.name
-
-          @definition.column(column_name, column.type,
-            :limit => column.limit, :default => column.default,
-            :null => column.null)
-        end
-        @definition.primary_key(primary_key(from)) if primary_key(from)
-        yield @definition if block_given?
-      end
-
-      copy_table_indexes(from, to, options[:rename] || {})
-      copy_table_contents(from, to,
-        @definition.columns.map {|column| column.name},
-        options[:rename] || {})
-    end
-
-    def copy_table_indexes(from, to, rename = {}) #:nodoc:
-      indexes(from).each do |index|
-        name = index.name.downcase
-        if to == "altered_#{from}"
-          name = "temp_#{name}"
-        elsif from == "altered_#{to}"
-          name = name[5..-1]
-        end
-
-        to_column_names = columns(to).map(&:name)
-        columns = index.columns.map {|c| rename[c] || c }.select do |column|
-          to_column_names.include?(column)
-        end
-
-        unless columns.empty?
-          # index name can't be the same
-          opts = { :name => name.gsub(/(_?)(#{from})_/, "\\1#{to}_") }
-          opts[:unique] = true if index.unique
-          add_index(to, columns, opts)
-        end
-      end
-    end
-
-    def copy_table_contents(from, to, columns, rename = {}) #:nodoc:
-      column_mappings = Hash[*columns.map {|name| [name, name]}.flatten]
-      rename.inject(column_mappings) {|map, a| map[a.last] = a.first; map}
-      from_columns = columns(from).collect {|col| col.name}
-      columns = columns.find_all{|col| from_columns.include?(column_mappings[col])}
-      quoted_columns = columns.map { |col| quote_column_name(col) } * ','
-
-      quoted_to = quote_table_name(to)
-      execute("SELECT * FROM #{quote_table_name(from)}").each do |row|
-        sql = "INSERT INTO #{quoted_to} (#{quoted_columns}) VALUES ("
-        sql << columns.map {|col| quote row[column_mappings[col]]} * ', '
-        sql << ')'
-        execute sql
-      end
-    end
-  end
-end

data/lib/arjdbc/jdbc/quoted_primary_key.rb

@@ -1,28 +0,0 @@
-module ArJdbc
-  module QuotedPrimaryKeyExtension
-    def self.extended(base)
-      #       Rails 3 method           Rails 2 method
-      meth = [:arel_attributes_values, :attributes_with_quotes].detect do |m|
-        base.private_instance_methods.include?(m.to_s)
-      end
-      pk_hash_key = "self.class.primary_key"
-      pk_hash_value = '"?"'
-      if meth == :arel_attributes_values
-        pk_hash_key = "self.class.arel_table[#{pk_hash_key}]"
-        pk_hash_value = "Arel::SqlLiteral.new(#{pk_hash_value})"
-      end
-      if meth
-        base.module_eval <<-PK, __FILE__, __LINE__
-          alias :#{meth}_pre_pk :#{meth}
-          def #{meth}(include_primary_key = true, *args) #:nodoc:
-            aq = #{meth}_pre_pk(include_primary_key, *args)
-            if connection.is_a?(ArJdbc::Oracle) || connection.is_a?(ArJdbc::Mimer)
-              aq[#{pk_hash_key}] = #{pk_hash_value} if include_primary_key && aq[#{pk_hash_key}].nil?
-            end
-            aq
-          end
-        PK
-      end
-    end
-  end
-end

data/lib/arjdbc/jdbc/require_driver.rb

@@ -1,16 +0,0 @@
-module Kernel
-  # load a JDBC driver library/gem, failing silently. If failed, trust
-  # that the driver jar is already present through some other means
-  def jdbc_require_driver(path, gem_name = nil)
-    gem_name ||= path.sub('/', '-')
-    2.times do
-      begin
-        require path
-        break
-      rescue LoadError
-        require 'rubygems'
-        begin; gem gem_name; rescue LoadError; end
-      end
-    end
-  end
-end

data/lib/arjdbc/mimer.rb

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

data/lib/arjdbc/mimer/adapter.rb

@@ -1,142 +0,0 @@
-module ArJdbc
-  module Mimer
-    def self.extended(mod)
-      require 'arjdbc/jdbc/quoted_primary_key'
-      ActiveRecord::Base.extend ArJdbc::QuotedPrimaryKeyExtension
-    end
-
-    def modify_types(tp)
-      tp[:primary_key] = "INTEGER NOT NULL PRIMARY KEY"
-      tp[:boolean][:limit] = nil
-      tp[:string][:limit] = 255
-      tp[:binary] = {:name => "BINARY VARYING", :limit => 4096}
-      tp[:text] = {:name => "VARCHAR", :limit => 4096}
-      tp[:datetime] = { :name => "TIMESTAMP" }
-      tp[:timestamp] = { :name => "TIMESTAMP" }
-      tp[:time] = { :name => "TIMESTAMP" }
-      tp[:date] = { :name => "TIMESTAMP" }
-      tp
-    end
-
-    def default_sequence_name(table, column) #:nodoc:
-      "#{table}_seq"
-    end
-
-    def create_table(name, options = {}) #:nodoc:
-      super(name, options)
-      execute "CREATE SEQUENCE #{name}_seq" unless options[:id] == false
-    end
-
-    def drop_table(name, options = {}) #:nodoc:
-      super(name) rescue nil
-      execute "DROP SEQUENCE #{name}_seq" rescue nil
-    end
-
-    def change_column(table_name, column_name, type, options = {}) #:nodoc:
-      execute "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} #{type_to_sql(type, options[:limit])}"
-    end
-
-    def change_column_default(table_name, column_name, default) #:nodoc:
-      execute "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} SET DEFAULT #{quote(default)}"
-    end
-
-    def remove_index(table_name, options = {}) #:nodoc:
-      execute "DROP INDEX #{index_name(table_name, options)}"
-    end
-
-    def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil) #:nodoc:
-      if pk.nil? # Who called us? What does the sql look like? No idea!
-        execute sql, name
-      elsif id_value # Pre-assigned id
-        log(sql, name) { @connection.execute_insert sql,pk }
-      else # Assume the sql contains a bind-variable for the id
-        id_value = select_one("SELECT NEXT_VALUE OF #{sequence_name} AS val FROM MIMER.ONEROW")['val']
-        log(sql, name) {
-          execute_prepared_insert(sql,id_value)
-        }
-      end
-      id_value
-    end
-
-    def execute_prepared_insert(sql, id)
-      @stmts ||= {}
-      @stmts[sql] ||= @connection.ps(sql)
-      stmt = @stmts[sql]
-      stmt.setLong(1,id)
-      stmt.executeUpdate
-      id
-    end
-
-    def quote(value, column = nil) #:nodoc:
-      return value.quoted_id if value.respond_to?(:quoted_id)
-
-      if String === value && column && column.type == :binary
-        return "X'#{quote_string(value.unpack("C*").collect {|v| v.to_s(16)}.join)}'"
-      end
-      case value
-      when String
-        %Q{'#{quote_string(value)}'}
-      when NilClass
-        'NULL'
-      when TrueClass
-        '1'
-      when FalseClass
-        '0'
-      when Numeric
-        value.to_s
-      when Date, Time
-        %Q{TIMESTAMP '#{value.strftime("%Y-%m-%d %H:%M:%S")}'}
-      else
-        %Q{'#{quote_string(value.to_yaml)}'}
-      end
-    end
-
-    def quoted_true
-      '1'
-    end
-
-    def quoted_false
-      '0'
-    end
-
-    def add_limit_offset!(sql, options) # :nodoc:
-      @limit = options[:limit]
-      @offset = options[:offset]
-    end
-
-    def select_all(sql, name = nil)
-      @offset ||= 0
-      if !@limit || @limit == -1
-        range = @offset..-1
-      else
-        range = @offset...(@offset+@limit)
-      end
-      select(sql, name)[range]
-    ensure
-      @limit = @offset = nil
-    end
-
-    def select_one(sql, name = nil)
-      @offset ||= 0
-      select(sql, name)[@offset]
-    ensure
-      @limit = @offset = nil
-    end
-
-    def _execute(sql, name = nil)
-        if sql =~ /^select/i
-          @offset ||= 0
-          if !@limit || @limit == -1
-            range = @offset..-1
-          else
-            range = @offset...(@offset+@limit)
-          end
-          @connection.execute_query(sql)[range]
-        else
-          @connection.execute_update(sql)
-        end
-    ensure
-      @limit = @offset = nil
-    end
-  end
-end

data/lib/arjdbc/mssql/tsql_helper.rb

@@ -1,61 +0,0 @@
-# Common methods for handling TSQL databases.
-module TSqlMethods
-
-  def modify_types(tp) #:nodoc:
-    tp[:primary_key] = "int NOT NULL IDENTITY(1, 1) PRIMARY KEY"
-    tp[:integer][:limit] = nil
-    tp[:boolean] = {:name => "bit"}
-    tp[:binary] = { :name => "image"}
-    tp
-  end
-
-  def type_to_sql(type, limit = nil, precision = nil, scale = nil) #:nodoc:
-    limit = nil if %w(text binary).include? type.to_s
-    return 'uniqueidentifier' if (type.to_s == 'uniqueidentifier')
-    return super unless type.to_s == 'integer'
-
-    if limit.nil? || limit == 4
-      'int'
-    elsif limit == 2
-      'smallint'
-    elsif limit == 1
-      'tinyint'
-    else
-      'bigint'
-    end
-  end
-
-  def add_limit_offset!(sql, options)
-    if options[:limit] and options[:offset]
-      total_rows = select_all("SELECT count(*) as TotalRows from (#{sql.gsub(/\bSELECT(\s+DISTINCT)?\b/i, "SELECT\\1 TOP 1000000000")}) tally")[0]["TotalRows"].to_i
-      if (options[:limit] + options[:offset]) >= total_rows
-        options[:limit] = (total_rows - options[:offset] >= 0) ? (total_rows - options[:offset]) : 0
-      end
-      sql.sub!(/^\s*SELECT(\s+DISTINCT)?/i, "SELECT * FROM (SELECT TOP #{options[:limit]} * FROM (SELECT\\1 TOP #{options[:limit] + options[:offset]} ")
-      sql << ") AS tmp1"
-      if options[:order]
-        options[:order] = options[:order].split(',').map do |field|
-          parts = field.split(" ")
-          tc = parts[0]
-          if sql =~ /\.\[/ and tc =~ /\./ # if column quoting used in query
-            tc.gsub!(/\./, '\\.\\[')
-            tc << '\\]'
-          end
-          if sql =~ /#{tc} AS (t\d_r\d\d?)/
-              parts[0] = $1
-          elsif parts[0] =~ /\w+\.(\w+)/
-            parts[0] = $1
-          end
-          parts.join(' ')
-        end.join(', ')
-        sql << " ORDER BY #{change_order_direction(options[:order])}) AS tmp2 ORDER BY #{options[:order]}"
-      else
-        sql << " ) AS tmp2"
-      end
-    elsif sql !~ /^\s*SELECT (@@|COUNT\()/i
-      sql.sub!(/^\s*SELECT(\s+DISTINCT)?/i) do
-        "SELECT#{$1} TOP #{options[:limit]}"
-      end unless options[:limit].nil?
-    end
-  end
-end

data/lib/arjdbc/oracle.rb

@@ -1,3 +0,0 @@
-require 'arjdbc/jdbc'
-require 'arjdbc/oracle/connection_methods'
-require 'arjdbc/oracle/adapter'

data/lib/arjdbc/oracle/connection_methods.rb

@@ -1,11 +0,0 @@
-class ActiveRecord::Base
-  class << self
-    def oracle_connection(config)
-      config[:port] ||= 1521
-      config[:url] ||= "jdbc:oracle:thin:@#{config[:host]}:#{config[:port]}:#{config[:database]}"
-      config[:driver] ||= "oracle.jdbc.driver.OracleDriver"
-      jdbc_connection(config)
-    end
-  end
-end
-

data/lib/pg.rb

@@ -1,4 +0,0 @@
-# Stub library for postgresql -- allows Rails to load
-# postgresql_adapter without error Other than postgres-pr, there's no
-# other way to use PostgreSQL on JRuby anyway, right? If you've
-# installed ar-jdbc you probably want to use that to connect to pg.

data/rakelib/package.rake

@@ -1,92 +0,0 @@
-MANIFEST = FileList["History.txt", "Manifest.txt", "README.txt",
-  "Rakefile", "LICENSE.txt", "lib/**/*.rb", "lib/arjdbc/jdbc/adapter_java.jar", "test/**/*.rb",
-   "lib/**/*.rake", "src/**/*.java", "rakelib/*.rake", "rails_generators/**/*"]
-
-file "Manifest.txt" => :manifest
-task :manifest do
-  File.open("Manifest.txt", "w") {|f| MANIFEST.each {|n| f << "#{n}\n"} }
-end
-Rake::Task['manifest'].invoke # Always regen manifest, so Hoe has up-to-date list of files
-
-require File.dirname(__FILE__) + "/../lib/arjdbc/version"
-begin
-  require 'hoe'
-  Hoe.plugin :gemcutter
-  hoe = Hoe.spec("activerecord-jdbc-adapter") do |p|
-    p.version = ArJdbc::Version::VERSION
-    p.spec_extras[:platform] = Gem::Platform.new("java")
-    p.spec_extras[:files] = MANIFEST
-    p.rubyforge_name = "jruby-extras"
-    p.url = "http://jruby-extras.rubyforge.org/activerecord-jdbc-adapter"
-    p.author = "Nick Sieger, Ola Bini and JRuby contributors"
-    p.email = "nick@nicksieger.com, ola.bini@gmail.com"
-    p.summary = "JDBC adapter for ActiveRecord, for use within JRuby on Rails."
-    p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
-    p.description = p.paragraphs_of('README.txt', 0...1).join("\n\n")
-  end
-  hoe.spec.rdoc_options += ["-SHN", "-f", "darkfish"]
-
-  task :gemspec do
-    File.open("#{hoe.name}.gemspec", "w") {|f| f << hoe.spec.to_ruby }
-  end
-  task :package => :gemspec
-rescue LoadError => le
-  puts le.to_s, *le.backtrace
-  puts "Problem loading Hoe; please check the error above to ensure that Hoe is installed correctly"
-rescue => e
-  puts "ignoring error while loading Hoe: #{e.to_s}"
-end
-
-def rake(*args)
-  ruby "-S", "rake", *args
-end
-
-%w(test package install_gem release clean).each do |task|
-  desc "Run rake #{task} on all available adapters and drivers"
-  task "all:#{task}" => task
-  task "adapters:#{task}" => task
-end
-
-(Dir["drivers/*/Rakefile"] + Dir["adapters/*/Rakefile"]).each do |rakefile|
-  dir = File.dirname(rakefile)
-  prefix = dir.sub(%r{/}, ':')
-  tasks = %w(package install_gem debug_gem clean gemspec)
-  tasks << "test" if File.directory?(File.join(dir, "test"))
-  tasks.each do |task|
-    desc "Run rake #{task} on #{dir}"
-    task "#{prefix}:#{task}" do
-      Dir.chdir(dir) do
-        rake task
-      end
-    end
-
-    task "#{File.dirname(dir)}:#{task}" => "#{prefix}:#{task}"
-    task "all:#{task}" => "#{prefix}:#{task}"
-  end
-
-  # Copy all generated gems to the top-level pkg directory for convenience
-  task "#{prefix}:package" do
-    FileList["#{dir}/pkg/*.gem"].each {|gem| cp gem, "pkg"}
-  end
-
-  desc "Run rake release on #{dir}"
-  task "#{prefix}:release" do
-    Dir.chdir(dir) do
-      version = nil
-      if dir =~ /adapters/
-        version = ENV['VERSION']
-      else
-        Dir["lib/**/*.rb"].each do |file|
-          version ||= File.open(file) {|f| f.read =~ /VERSION = "([^"]+)"/ && $1}
-        end
-      end
-      rake "release", "VERSION=#{version}"
-    end
-  end
-  # Only release adapters synchronously with main release. Drivers are versioned
-  # according to their JDBC driver versions.
-  if dir =~ /adapters/
-    task "adapters:release" => "#{prefix}:release"
-    task "all:release" => "#{prefix}:release"
-  end
-end