activerecord-jdbc-adapter 0.9.1 → 0.9.2

data/lib/jdbc_adapter/missing_functionality_helper.rb

@@ -8,7 +8,10 @@ module JdbcSpec
       caller = lambda {|definition| yield definition if block_given?}
 
       transaction do
-        move_table(table_name, altered_table_name, options)
+        # 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
@@ -19,28 +22,30 @@ module JdbcSpec
     end
 
     def copy_table(from, to, options = {}) #:nodoc:
-      create_table(to, options) do |@definition|
+      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
-          column_name = column_name.to_s
-          @definition.column(column_name, column.type, 
-                             :limit => column.limit, :default => column.default,
-                             :null => column.null)
+            (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))
+        @definition.primary_key(primary_key(from)) if primary_key(from)
         yield @definition if block_given?
       end
-      
-      copy_table_indexes(from, to, options)
-      copy_table_contents(from, to, 
-                          @definition.columns, 
-                          options[:rename] || {})
+
+      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, options={}) #:nodoc:
+    def copy_table_indexes(from, to, rename = {}) #:nodoc:
       indexes(from).each do |index|
         name = index.name.downcase
         if to == "altered_#{from}"
@@ -48,31 +53,32 @@ module JdbcSpec
         elsif from == "altered_#{to}"
           name = name[5..-1]
         end
-        
-        # index name can't be the same
-        opts = { :name => name.gsub(/_(#{from})_/, "_#{to}_") }
-        opts[:unique] = true if index.unique
-        if options[:rename]
-          new_columns = index.columns.map {|column_name|
-            (options[:rename][column_name] ||
-             options[:rename][column_name.to_sym] ||
-             column_name)
-          }
-        else
-          new_columns = index.columns
+
+        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
-        add_index(to, new_columns, opts)
       end
     end
     
     def copy_table_contents(from, to, columns, rename = {}) #:nodoc:
-      column_mappings = Hash[*columns.map {|col| [col.name, col.name]}.flatten]
+      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.name])}
-      execute("SELECT * FROM #{from}").each do |row|
-        sql = "INSERT INTO #{to} ("+columns.map(&:name)*','+") VALUES ("            
-        sql << columns.map {|col| quote(row[column_mappings[col.name]],col)} * ', '
+      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

data/lib/jdbc_adapter/rake_tasks.rb

@@ -1,6 +1,6 @@
 if defined?(Rake.application) && Rake.application && ENV["SKIP_AR_JDBC_RAKE_REDEFINES"].nil?
   jdbc_rakefile = File.dirname(__FILE__) + "/jdbc.rake"
-  if Rake.application.lookup("environment")
+  if Rake.application.lookup("db:create")
     # rails tasks already defined; load the override tasks now
     load jdbc_rakefile
   else

data/lib/jdbc_adapter/tsql_helper.rb

@@ -10,6 +10,7 @@ module TSqlMethods
   end
 
   def type_to_sql(type, limit = nil, precision = nil, scale = nil) #:nodoc:
+    return 'uniqueidentifier' if (type.to_s == 'uniqueidentifier')
     return super unless type.to_s == 'integer'
     
     if limit.nil? || limit == 4

data/lib/jdbc_adapter/version.rb

@@ -1,5 +1,5 @@
 module JdbcAdapter
   module Version
-    VERSION = "0.9.1"
+    VERSION = "0.9.2"
   end
 end

data/lib/pg.rb

@@ -0,0 +1,4 @@
+# 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/rails_generators/jdbc_generator.rb

@@ -0,0 +1,15 @@
+class JdbcGenerator < Rails::Generator::Base
+  def manifest
+    record do |m|
+      m.directory 'config/initializers'
+      m.template 'jdbc.rb', File.join('config', 'initializers', 'jdbc.rb')
+      m.directory 'lib/tasks'
+      m.template 'jdbc.rake', File.join('lib', 'tasks', 'jdbc.rake')
+    end
+  end
+
+  protected
+  def banner
+    "Usage: #{$0} jdbc\nGenerate JDBC bootstrapping files for your Rails application."
+  end
+end

data/rails_generators/templates/jdbc.rake

@@ -0,0 +1,8 @@
+# This file was generated by the "jdbc" generator, which is provided
+# by the activerecord-jdbc-adapter gem.
+#
+# This file allows you to use Rails' various db:* tasks with JDBC.
+if defined?(JRUBY_VERSION)
+  require 'jdbc_adapter'
+  require 'jdbc_adapter/rake_tasks'
+end

data/rails_generators/templates/jdbc.rb

@@ -0,0 +1,7 @@
+# This file was generated by the "jdbc" generator, which is provided
+# by the activerecord-jdbc-adapter gem.
+#
+# This file allows the JDBC drivers to be hooked into ActiveRecord
+# such that you don't have to change anything else in your Rails
+# application.
+require 'jdbc_adapter' if defined?(JRUBY_VERSION)

data/rakelib/compile.rake

@@ -0,0 +1,23 @@
+def java_classpath_arg # myriad of ways to discover JRuby classpath
+  begin
+    cpath  = Java::java.lang.System.getProperty('java.class.path').split(File::PATH_SEPARATOR)
+    cpath += Java::java.lang.System.getProperty('sun.boot.class.path').split(File::PATH_SEPARATOR)
+    jruby_cpath = cpath.compact.join(File::PATH_SEPARATOR)
+  rescue => e
+  end
+  unless jruby_cpath
+    jruby_cpath = ENV['JRUBY_PARENT_CLASSPATH'] || ENV['JRUBY_HOME'] &&
+      FileList["#{ENV['JRUBY_HOME']}/lib/*.jar"].join(File::PATH_SEPARATOR)
+  end
+  jruby_cpath ? "-cp \"#{jruby_cpath}\"" : ""
+end
+
+desc "Compile the native Java code."
+task :java_compile do
+  pkg_classes = File.join(*%w(pkg classes))
+  jar_name = File.join(*%w(lib jdbc_adapter jdbc_adapter_internal.jar))
+  mkdir_p pkg_classes
+  sh "javac -target 1.5 -source 1.5 -d pkg/classes #{java_classpath_arg} #{FileList['src/java/**/*.java'].join(' ')}"
+  sh "jar cf #{jar_name} -C #{pkg_classes} ."
+end
+file "lib/jdbc_adapter/jdbc_adapter_internal.jar" => :java_compile

data/rakelib/package.rake

@@ -0,0 +1,85 @@
+MANIFEST = FileList["History.txt", "Manifest.txt", "README.txt",
+  "Rakefile", "LICENSE.txt", "lib/**/*.rb", "lib/jdbc_adapter/jdbc_adapter_internal.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/jdbc_adapter/version"
+begin
+  require 'hoe'
+  hoe = Hoe.spec("activerecord-jdbc-adapter") do |p|
+    p.version = JdbcAdapter::Version::VERSION
+    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.files = MANIFEST
+  hoe.spec.dependencies.delete_if { |dep| dep.name == "hoe" }
+
+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
+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)
+  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

data/rakelib/rails.rake

@@ -0,0 +1,41 @@
+namespace :rails do
+  def _adapter(n)
+    case n
+    when /postgres/
+      'postgresql'
+    else
+      n
+    end
+  end
+
+  def _driver(n)
+    case n
+    when /postgres/
+      'postgres'
+    else
+      n
+    end
+  end
+
+  def _target(n)
+    case n
+    when /postgres/
+      'test_jdbcpostgresql'
+    else
+      "test_jdbc#{n}"
+    end
+  end
+
+  task :test => "java_compile" do
+    driver = ENV['DRIVER']
+    raise "need a DRIVER" unless driver
+    activerecord = ENV['RAILS']
+    raise "need location of RAILS source code" unless activerecord
+    activerecord = File.join(activerecord, 'activerecord') unless activerecord =~ /activerecord$/
+    ar_jdbc = File.expand_path(File.dirname(__FILE__) + '/..')
+    rubylib = "#{ar_jdbc}/lib:#{ar_jdbc}/drivers/#{_driver(driver)}/lib:#{ar_jdbc}/adapters/#{_adapter(driver)}/lib"
+    Dir.chdir(activerecord) do
+      rake "RUBYLIB=#{rubylib}", "#{_target(driver)}"
+    end
+  end
+end

data/rakelib/test.rake

@@ -0,0 +1,71 @@
+require File.dirname(__FILE__) + '/../test/helper'
+if defined?(JRUBY_VERSION)
+  databases = [:test_mysql, :test_jdbc, :test_derby, :test_hsqldb, :test_h2, :test_sqlite3]
+  if find_executable?("psql") && `psql -c '\\l'` && $?.exitstatus == 0
+    databases << :test_postgres
+  end
+  task :test => databases
+else
+  task :test => [:test_mysql]
+end
+
+FileList['drivers/*'].each do |d|
+  next unless File.directory?(d)
+  driver = File.basename(d)
+  Rake::TestTask.new("test_#{driver}") do |t|
+    files = FileList["test/#{driver}*test.rb"]
+    if driver == "derby"
+      files << 'test/activerecord/connection_adapters/type_conversion_test.rb'
+    end
+    t.test_files = files
+    t.libs = []
+    if defined?(JRUBY_VERSION)
+      t.ruby_opts << "-rjdbc/#{driver}"
+      t.libs << "lib" << "#{d}/lib"
+      t.libs.push *FileList["adapters/#{driver}*/lib"]
+    end
+    t.libs << "test"
+    t.verbose = true
+  end
+end
+
+Rake::TestTask.new(:test_jdbc) do |t|
+  t.test_files = FileList['test/generic_jdbc_connection_test.rb', 'test/jndi_callbacks_test.rb']
+  t.libs << 'test' << 'drivers/mysql/lib'
+end
+
+Rake::TestTask.new(:test_jndi) do |t|
+  t.test_files = FileList['test/jndi_test.rb']
+  t.libs << 'test' << 'drivers/derby/lib'
+end
+
+task :test_postgresql => [:test_postgres]
+task :test_pgsql => [:test_postgres]
+
+# Ensure driver for these DBs is on your classpath
+%w(oracle db2 cachedb mssql informix).each do |d|
+  Rake::TestTask.new("test_#{d}") do |t|
+    t.test_files = FileList["test/#{d}_simple_test.rb"]
+    t.libs = []
+    t.libs << 'lib' if defined?(JRUBY_VERSION)
+    t.libs << 'test'
+  end
+end
+
+# Tests for JDBC adapters that don't require a database.
+Rake::TestTask.new(:test_jdbc_adapters) do | t |
+  t.test_files = FileList[ 'test/jdbc_adapter/jdbc_sybase_test.rb' ]
+  t.libs << 'test'
+end
+
+# Ensure that the jTDS driver is in your classpath before launching rake
+Rake::TestTask.new(:test_sybase_jtds) do |t|
+  t.test_files = FileList['test/sybase_jtds_simple_test.rb']
+  t.libs << 'test' 
+end
+
+# Ensure that the jConnect driver is in your classpath before launching rake
+Rake::TestTask.new(:test_sybase_jconnect) do |t|
+  t.test_files = FileList['test/sybase_jconnect_simple_test.rb']
+  t.libs << 'test' 
+end

data/src/java/jdbc_adapter/JdbcAdapterInternalService.java

@@ -41,6 +41,7 @@ public class JdbcAdapterInternalService implements BasicLibraryService {
     public boolean basicLoad(final Ruby runtime) throws IOException {
         RubyClass jdbcConnection = RubyJdbcConnection.createJdbcConnectionClass(runtime);
         PostgresRubyJdbcConnection.createPostgresJdbcConnectionClass(runtime, jdbcConnection);
+        MssqlRubyJdbcConnection.createMssqlJdbcConnectionClass(runtime, jdbcConnection);
         Sqlite3RubyJdbcConnection.createSqlite3JdbcConnectionClass(runtime, jdbcConnection);
         RubyModule jdbcSpec = runtime.getOrCreateModule("JdbcSpec");
 

data/src/java/jdbc_adapter/JdbcDerbySpec.java

@@ -274,55 +274,20 @@ public class JdbcDerbySpec {
         }
     }
 
-    @JRubyMethod(name = "add_limit_offset!", required = 2)
-    public static IRubyObject add_limit_offset(IRubyObject recv, IRubyObject sql, IRubyObject options) {
-        IRubyObject limit = rubyApi.callMethod(options, "[]", recv.getRuntime().newSymbol("limit"));
-        rubyApi.setInstanceVariable(recv, "@limit",limit);
-        IRubyObject offset = rubyApi.callMethod(options, "[]", recv.getRuntime().newSymbol("offset"));
-        return rubyApi.setInstanceVariable(recv, "@offset",offset);
-    }
-
     @JRubyMethod(name = "_execute", required = 1, optional = 1)
     public static IRubyObject _execute(ThreadContext context, IRubyObject recv, IRubyObject[] args) throws SQLException, java.io.IOException {
         Ruby runtime = recv.getRuntime();
-        try {
-            // TODO: Ouch....this looks fragile
-            RubyJdbcConnection conn = (RubyJdbcConnection) rubyApi.getInstanceVariable(recv, "@connection");
-            String sql = args[0].toString().trim().toLowerCase();
-            if (sql.charAt(0) == '(') {
-                sql = sql.substring(1).trim();
-            }
-            if (sql.startsWith("insert")) {
-                return conn.execute_insert(context, args[0]);
-            } else if (sql.startsWith("select") || sql.startsWith("show")) {
-                IRubyObject offset = rubyApi.getInstanceVariable(recv, "@offset");
-                if(offset == null || offset.isNil()) {
-                    offset = RubyFixnum.zero(runtime);
-                }
-                IRubyObject limit = rubyApi.getInstanceVariable(recv, "@limit");
-                IRubyObject range;
-                IRubyObject max;
-                if (limit == null || limit.isNil() || RubyNumeric.fix2int(limit) == -1) {
-                    range = RubyRange.newRange(runtime, context, offset, runtime.newFixnum(-1), false);
-                    max = RubyFixnum.zero(runtime);
-                } else {
-                    IRubyObject v1 = rubyApi.callMethod(offset, "+", limit);
-                    range = RubyRange.newRange(runtime, context, offset, v1, true);
-                    max = rubyApi.callMethod(v1, "+", RubyFixnum.one(runtime));
-                }
-                IRubyObject result = conn.execute_query(context, args[0], max);
-                IRubyObject ret = rubyApi.callMethod(result, "[]", range);
-                if (ret.isNil()) {
-                    return runtime.newArray();
-                } else {
-                    return ret;
-                }
-            } else {
-                return conn.execute_update(context, args[0]);
-            }
-        } finally {
-            rubyApi.setInstanceVariable(recv, "@limit", runtime.getNil());
-            rubyApi.setInstanceVariable(recv, "@offset", runtime.getNil());
+        RubyJdbcConnection conn = (RubyJdbcConnection) rubyApi.getInstanceVariable(recv, "@connection");
+        String sql = args[0].toString().trim().toLowerCase();
+        if (sql.charAt(0) == '(') {
+            sql = sql.substring(1).trim();
+        }
+        if (sql.startsWith("insert")) {
+            return conn.execute_insert(context, args[0]);
+        } else if (sql.startsWith("select") || sql.startsWith("show")) {
+            return conn.execute_query(context, args[0]);
+        } else {
+            return conn.execute_update(context, args[0]);
         }
     }
 }