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

data/lib/arjdbc/sqlite3/explain_support.rb

@@ -1,4 +1,4 @@
-module ::ArJdbc
+module ArJdbc
   module SQLite3
     module ExplainSupport
       def supports_explain?

data/lib/arjdbc/tasks/oracle/enhanced_structure_dump.rb

@@ -73,7 +73,7 @@ module ActiveRecord #:nodoc:
 
       def structure_dump_primary_key(table) #:nodoc:
         opts = {:name => '', :cols => []}
-        pks = select_all(<<-SQL, "Primary Keys") 
+        pks = select_all(<<-SQL, "Primary Keys")
           SELECT a.constraint_name, a.column_name, a.position
             FROM user_cons_columns a
             JOIN user_constraints c
@@ -91,7 +91,7 @@ module ActiveRecord #:nodoc:
 
       def structure_dump_unique_keys(table) #:nodoc:
         keys = {}
-        uks = select_all(<<-SQL, "Primary Keys") 
+        uks = select_all(<<-SQL, "Primary Keys")
           SELECT a.constraint_name, a.column_name, a.position
             FROM user_cons_columns a
             JOIN user_constraints c
@@ -152,21 +152,21 @@ module ActiveRecord #:nodoc:
                       AND name NOT LIKE 'BIN$%'
                       AND owner = SYS_CONTEXT('userenv', 'session_user') ORDER BY type").each do |source|
           ddl = "CREATE OR REPLACE   \n"
-          lines = select_all(%Q{
+          select_all(%Q{
                   SELECT text
                     FROM all_source
                    WHERE name = '#{source['name']}'
                      AND type = '#{source['type']}'
                      AND owner = SYS_CONTEXT('userenv', 'session_user')
                    ORDER BY line
-                }).map do |row|
+                }).each do |row|
             ddl << row['text']
           end
-          ddl << ";" unless ddl.strip[-1,1] == ";"
+          ddl << ";" unless ddl.strip[-1,1] == ';'
           structure << ddl
         end
 
-        # export views 
+        # export views
         select_all("SELECT view_name, text FROM user_views").each do |view|
           structure << "CREATE OR REPLACE VIEW #{view['view_name']} AS\n #{view['text']}"
         end
@@ -243,14 +243,14 @@ module ActiveRecord #:nodoc:
 
       def execute_structure_dump(string)
         string.split(STATEMENT_TOKEN).each do |ddl|
-          ddl.chop! if ddl[-1] == ';'
+          ddl.chop! if ddl[-1,1] == ';'
           execute(ddl) unless ddl.blank?
         end
       end
 
       private
 
-      # virtual columns are an 11g feature.  This returns [] if feature is not 
+      # virtual columns are an 11g feature.  This returns [] if feature is not
       # present or none are found.
       # return [{'column_name' => 'FOOS', 'data_default' => '...'}, ...]
       def virtual_columns_for(table)

data/lib/arjdbc/util/quoted_cache.rb

@@ -0,0 +1,60 @@
+module ArJdbc
+  module Util
+    # Caches table and column name (quoted) outcomes.
+    # Uses {ThreadSafe::Cache} as a concurrent lock free (on JRuby) cache backend.
+    # The thread_safe gem is a dependency since ActiveSupport 4.0, when using
+    # ActiveRecord <= 3.2 one should add `gem 'thread_safe'` into the *Gemfile*
+    # as it is not forced (currently) as an explicit gem dependency.
+    #
+    # Caching can also be disabled by setting the *arjdbc.quoted_cache.disabled*
+    # system property = 'true'.
+    module QuotedCache
+
+      # @private
+      DISABLED = Java::JavaLang::Boolean.getBoolean('arjdbc.quoted_cache.disabled')
+
+      def self.included(base)
+        # the thread_safe gem is an ActiveSupport dependency (since 4.0) :
+        begin; require 'thread_safe'; rescue LoadError; end unless DISABLED
+        if ! DISABLED && defined? ThreadSafe::Cache
+          base.const_set :QUOTED_TABLE_NAMES, ThreadSafe::Cache.new
+          base.const_set :QUOTED_COLUMN_NAMES, ThreadSafe::Cache.new
+        else
+          base.const_set :QUOTED_TABLE_NAMES, nil
+          base.const_set :QUOTED_COLUMN_NAMES, nil
+        end
+      end
+
+      # Caches quoted table names, the cache is stored in the class'
+      # `QUOTED_TABLE_NAMES` constant.
+      # @return [String]
+      def quote_table_name(name)
+        if cache = self.class::QUOTED_TABLE_NAMES
+          unless quoted = cache[name]
+            quoted = super
+            cache.put_if_absent name, quoted.freeze
+          end
+          quoted
+        else
+          super
+        end
+      end
+
+      # Caches quoted table names, the cache is stored in the class'
+      # `QUOTED_COLUMN_NAMES` constant.
+      # @return [String]
+      def quote_column_name(name)
+        if cache = self.class::QUOTED_COLUMN_NAMES
+          unless quoted = cache[name]
+            quoted = super
+            cache.put_if_absent name, quoted.freeze
+          end
+          quoted
+        else
+          super
+        end
+      end
+
+    end
+  end
+end

data/lib/arjdbc/util/table_copier.rb

@@ -0,0 +1,110 @@
+module ArJdbc
+  module Util
+    module TableCopier
+
+      # taken from SQLite adapter, code loosely based on http://git.io/P7tFQA
+
+      # Performs changes for table by first copying (and preserving contents)
+      # into another (temporary) table, than alters and copies all data back.
+      def alter_table(table_name, options = {})
+        table_name = table_name.to_s.downcase
+        altered_table_name = "a#{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
+
+      # Move a table into another while preserving all content.
+      # @see #copy_table
+      def move_table(from, to, options = {}, &block)
+        copy_table(from, to, options, &block)
+        drop_table(from)
+      end
+
+      # @see #copy_table_contents
+      # @see #copy_table_indexes
+      def copy_table(from, to, options = {})
+        from_primary_key = primary_key(from)
+        create_table(to, options.merge(:id => false)) do |definition|
+          @definition = definition
+          @definition.primary_key(from_primary_key) if from_primary_key.present?
+          columns(from).each do |column|
+            column_name = options[:rename] ?
+              (options[:rename][column.name] ||
+               options[:rename][column.name.to_sym] ||
+               column.name) : column.name
+
+            next if column_name == from_primary_key
+
+            @definition.column(column_name, column.type,
+              :limit => column.limit, :default => column.default,
+              :precision => column.precision, :scale => column.scale,
+              :null => column.null)
+          end
+          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
+
+      # Copies indexes for a given table.
+      def copy_table_indexes(from, to, rename = {})
+        indexes(from).each do |index|
+          name = index.name.downcase
+          if to == "a#{from}"
+            name = "t#{name}"
+          elsif from == "a#{to}"
+            name = name[1..-1]
+          end
+
+          to_column_names = columns(to).map(&:name)
+          columns = index.columns.map { |column| rename[column] || column }
+          columns = columns.select { |column| to_column_names.include?(column) }
+
+          unless columns.empty?
+            # index name can't be the same
+            opts = { :name => name.gsub(/(^|_)(#{from})_/, "\\1#{to}_"), :internal => true }
+            opts[:unique] = true if index.unique
+            add_index(to, columns, opts)
+          end
+        end
+      end
+
+      # Copies the content of a table into another.
+      def copy_table_contents(from, to, columns, rename = {})
+        column_mappings = Hash[ columns.map { |name| [name, name] } ]
+        rename.each { |a| column_mappings[a.last] = a.first }
+        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)
+
+        raw_column_mappings = Hash[ columns(from).map { |c| [c.name, c] } ]
+
+        execute("SELECT * FROM #{quote_table_name(from)}", 'Copy Table').each do |row|
+          sql = "INSERT INTO #{quoted_to} (#{quoted_columns}) VALUES ("
+
+          column_values = columns.map do |col|
+            quote(row[column_mappings[col]], raw_column_mappings[col])
+          end
+
+          sql << column_values * ', '
+          sql << ')'
+          exec_insert sql, 'Copy Table', []
+        end
+      end
+
+    end
+  end
+  # @private @deprecated backwards compatibility
+  MissingFunctionalityHelper = Util::TableCopier
+end

data/lib/arjdbc/version.rb

@@ -1,9 +1,8 @@
 module ArJdbc
-  VERSION = "1.3.0.beta2"
-  module Version # :nodoc:
-    VERSION = ArJdbc::VERSION # :nodoc: 1.2.x compatibility
+  VERSION = "1.3.0.rc1"
+  # @deprecated
+  module Version
+    # @private 1.2.x compatibility
+    VERSION = ArJdbc::VERSION
   end
-end
-# Compatibility with older versions of ar-jdbc for other extensions out there
-JdbcAdapter = ArJdbc # :nodoc:
-JdbcSpec = ArJdbc # :nodoc:
+end

data/pom.xml

@@ -11,6 +11,10 @@
   </description>
   <url>http://github.com/jruby/activerecord-jdbc-adapter/wiki</url>
 
+  <properties>
+    <jruby.version>1.6.8</jruby.version>
+  </properties>
+
   <issueManagement>
     <system>GitHub</system>
     <url>http://github.com/jruby/activerecord-jdbc-adapter/issues</url>
@@ -28,14 +32,47 @@
       <url>http://www.opensource.org/licenses/bsd-license.php</url>
       <distribution>repo</distribution>
     </license>
+    <license>
+      <name>MIT License</name>
+      <url>http://www.opensource.org/licenses/mit-license.php</url>
+      <distribution>repo</distribution>
+    </license>
   </licenses>
+  <!--
+  <repositories>
+    <repository>
+      <id>codehaus</id>
+      <name>Codehaus Repository</name>
+      <releases>
+        <enabled>true</enabled>
+      </releases>
+      <snapshots>
+        <enabled>false</enabled>
+      </snapshots>
+      <url>http://repository.codehaus.org</url>
+    </repository>
+  </repositories>-->
+
+  <developers>
+    <developer>
+      <id>nicksieger</id>
+      <name>Nick Sieger</name>
+      <email>nicksieger@gmail.com</email>
+    </developer>
+    <developer>
+      <id>kares</id>
+      <name>Karol Bucek</name>
+      <email>self@kares.org</email>
+    </developer>
+  </developers>
 
   <dependencies>
     <dependency>
       <groupId>org.jruby</groupId>
       <artifactId>jruby-complete</artifactId>
-      <version>1.6.8</version>
+      <version>${jruby.version}</version>
     </dependency>
+
     <!-- e.g.
     mvn install:install-file -DgroupId=org.postgresql -DartifactId=pgjdbc -Dversion=9.2-1002 -Dpackaging=jar -Dfile=./jdbc-postgres/lib/postgresql-9.2-1002.jdbc4.jar
     -->
@@ -47,18 +84,35 @@
   </dependencies>
 
   <build>
-    <outputDirectory>pkg/classes</outputDirectory>
+      
     <sourceDirectory>src/java</sourceDirectory>
+    <resources>
+        <resource>
+            <directory>lib</directory>
+        </resource>
+    </resources>
+    <!--
+    <testSourceDirectory>test/java</testSourceDirectory>-->
+    <testResources>
+        <testResource>
+            <directory>test</directory>
+        </testResource>
+    </testResources>
+
+    <outputDirectory>pkg/classes</outputDirectory>
+
     <plugins>
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-compiler-plugin</artifactId>
+        <version>2.5.1</version>
         <configuration>
           <source>1.6</source>
           <target>1.6</target>
         </configuration>
       </plugin>
     </plugins>
+
   </build>
 
 </project>

data/rakelib/02-test.rake

@@ -14,118 +14,107 @@ else
   task :test => [ :test_mysql ]
 end
 
-def set_compat_version(task)
+def set_test_task_compat_version(task)
   task.ruby_opts << '-v' if RUBY_VERSION =~ /1\.8/
   if defined?(JRUBY_VERSION)
     task.ruby_opts << "--#{RUBY_VERSION[/^(\d+\.\d+)/, 1]}"
   end
 end
 
-%w(derby h2 hsqldb mysql sqlite3 postgres mssql oracle db2 as400 informix sybase).each do 
-  |adapter| task "test_#{adapter}_pre" do
-    unless (ENV['BUNDLE_GEMFILE'] rescue '') =~ /gemfiles\/.*?\.gemfile/
-      appraisals = []; Appraisal::File.each { |file| appraisals << file.name }
-      puts "Specify AR version with `rake appraisal:{version} test_#{adapter}'" + 
-           " where version=(#{appraisals.join('|')})"
-    end
-  end  
+def set_task_description(task, desc)
+  unless task.is_a?(Rake::Task)
+    task = task.name if task.is_a?(Rake::TestTask)
+    task = Rake::Task[task]
+  end
+  # reset the desc set-up by TestTask :
+  task.instance_variable_set(:@full_comment, nil)
+  task.add_description(desc)
+end
+
+task 'test_appraisal_hint' do
+  next if File.exists?('.disable-appraisal-hint')
+  unless (ENV['BUNDLE_GEMFILE'] rescue '') =~ /gemfiles\/.*?\.gemfile/
+    appraisals = []; Appraisal::File.each { |file| appraisals << file.name }
+    puts "HINT: specify AR version with `rake appraisal:{version} test_{adapter}'" +
+         " where version=(#{appraisals.join('|')}) (`touch .disable-appraisal-hint' to disable)"
+  end
 end
 
 Rake::TestTask.class_eval { attr_reader :test_files }
 
-def declare_test_task_for(adapter, options = {}, &block)
-  driver = options[:driver] || adapter
+def test_task_for(adapter, options = {})
+  desc = options[:desc] || options[:comment] ||
+    "Run tests against #{options[:database_name] || adapter}"
+  adapter = adapter.to_s.downcase
+  driver = options.key?(:driver) ? options[:driver] : adapter
   prereqs = options[:prereqs] || []
-  prereqs = [ prereqs ].flatten
-  prereqs << "test_#{adapter}_pre"
-  Rake::TestTask.new("test_#{adapter}" => prereqs) do |task|
-    files = FileList["test/#{adapter}*_test.rb"]
-    files += FileList["test/db/#{adapter}/*_test.rb"]
-    #task_name = task.name.keys.first.to_s
-    #files.unshift "test/db/#{task_name.sub('test_','')}.rb"
-    task.test_files = files
-    task.libs = []
+  unless prereqs.frozen?
+    prereqs = [ prereqs ].flatten; prereqs << 'test_appraisal_hint'
+  end
+  name = options[:name] || "test_#{adapter}"
+  test_task = Rake::TestTask.new(name => prereqs) do |test_task|
+    files = options[:files] || begin
+      FileList["test/#{adapter}*_test.rb"] +
+        FileList["test/db/#{adapter}/*_test.rb"]
+    end
+    test_task.test_files = files
+    test_task.libs = []
     if defined?(JRUBY_VERSION)
-      task.libs << "lib" << "jdbc-#{driver}/lib"
-      task.libs.push *FileList["activerecord-jdbc#{adapter}*/lib"]
+      test_task.libs << 'lib'
+      test_task.libs << "jdbc-#{driver}/lib" if driver && File.exists?("jdbc-#{driver}/lib")
+      test_task.libs.push *FileList["activerecord-jdbc#{adapter}*/lib"]
     end
-    task.libs << "test"
-    set_compat_version(task)
-    task.verbose = true if $VERBOSE    
-    yield(task) if block_given?
+    test_task.libs << 'test'
+    set_test_task_compat_version test_task
+    test_task.verbose = true if $VERBOSE
+    yield(test_task) if block_given?
   end
+  set_task_description name, desc
+  test_task
 end
 
-declare_test_task_for :derby
-declare_test_task_for :h2
-declare_test_task_for :hsqldb
-declare_test_task_for :mssql, :driver => :jtds
-declare_test_task_for :mysql, :prereqs => "db:mysql"
-declare_test_task_for :postgres, :prereqs => "db:postgres"
-task :test_postgresql => :test_postgres # alias
-task :test_pgsql => :test_postgres # alias
-declare_test_task_for :sqlite3
+test_task_for :Derby, :desc => 'Run tests against (embedded) DerbyDB'
+test_task_for :H2, :desc => 'Run tests against H2 database engine'
+test_task_for :HSQLDB, :desc => 'Run tests against HyperSQL (Java) database'
+test_task_for :MSSQL, :driver => :jtds, :database_name => 'MS-SQL (SQLServer)'
+test_task_for :MySQL, :prereqs => 'db:mysql'
+test_task_for :PostgreSQL, :prereqs => 'db:postgresql', :driver => 'postgres'
+task :test_postgres => :test_postgresql # alias
+task :test_pgsql => :test_postgresql # alias
+test_task_for :SQLite3
+test_task_for :FireBird
 
 # ensure driver for these DBs is on your class-path
-[ :oracle, :db2, :informix, :cachedb ].each do |adapter|
-  Rake::TestTask.new("test_#{adapter}") do |task|
-    test_files = FileList["test/#{adapter}*_test.rb"]
-    test_files += FileList["test/db/#{adapter}/*_test.rb"]
-    task.test_files = test_files
-    task.libs = []
-    task.libs << 'lib' if defined?(JRUBY_VERSION)
-    task.libs << 'test'
-    set_compat_version(task)
-  end
+[ :Oracle, :DB2, :Informix, :CacheDB ].each do |adapter|
+  test_task_for adapter, :desc => "Run tests against #{adapter} (ensure driver is on class-path)"
 end
 
-Rake::TestTask.new(:test_as400) do |task|
-  test_files = FileList["test/db2*_test.rb"]
-  test_files += FileList["test/db/db2/*_test.rb"]
-  task.test_files = test_files
-  task.libs = []
-  task.libs << 'lib' if defined?(JRUBY_VERSION)
-  task.libs << 'test'
-  set_compat_version(task)
-end
+#test_task_for :MSSQL, :name => 'test_sqlserver', :driver => nil, :database_name => 'MS-SQL using SQLJDBC'
 
-Rake::TestTask.new(:test_jdbc) do |task|
-  task.test_files = FileList['test/*jdbc_*test.rb']
-  task.libs << 'test' << 'jdbc-mysql/lib' << 'jdbc-derby/lib'
-  set_compat_version(task)
-end
+test_task_for :AS400, :desc => "Run tests against AS400 (DB2) (ensure driver is on class-path)",
+  :files => FileList["test/db2*_test.rb"] + FileList["test/db/db2/*_test.rb"]
 
-Rake::TestTask.new(:test_jndi => 'tomcat-jndi:check') do |task|
-  task.test_files = FileList['test/*jndi_*test.rb']
-  task.libs << 'test' << 'jdbc-derby/lib'
-  set_compat_version(task)
+test_task_for 'JDBC', :desc => 'Run tests against plain JDBC adapter (uses MySQL and Derby)',
+  :files => FileList['test/*jdbc_*test.rb'] do |test_task|
+  test_task.libs << 'jdbc-mysql/lib' << 'jdbc-derby/lib'
 end
 
-# tests for JDBC adapters that don't require a database :
-Rake::TestTask.new(:test_jdbc_adapters) do |task|
-  task.test_files = FileList[ 'test/jdbc_adapter/jdbc_sybase_test.rb' ]
-  task.libs << 'test'
-  set_compat_version(task)
+test_task_for 'JNDI', :desc => 'Run tests against a JNDI connection (uses Derby)',
+  :prereqs => 'tomcat-jndi:check',
+  :files => FileList['test/*jndi_*test.rb'] do |test_task|
+  test_task.libs << 'jdbc-derby/lib'
 end
 
-# ensure that the jTDS driver is in your class-path
-Rake::TestTask.new(:test_sybase_jtds) do |task|
-  task.test_files = FileList['test/sybase_jtds_simple_test.rb']
-  task.libs << 'test'
-  set_compat_version(task)
-end
-
-# ensure that the jConnect driver is in your class-path
-Rake::TestTask.new(:test_sybase_jconnect) do |task|
-  task.test_files = FileList['test/sybase_jconnect_simple_test.rb']
-  task.libs << 'test'
-  set_compat_version(task)
-end
+# TODO Sybase testing is currently broken, please fix it if you're on Sybase :
+#test_task_for :Sybase, :desc => "Run tests against Sybase (using jTDS driver)"
+#task :test_sybase_jtds => :test_sybase # alias
+#test_task_for :Sybase, :name => 'sybase_jconnect',
+#  :desc => "Run tests against Sybase (ensure jConnect driver is on class-path)"
 
 Rake::TraceOutput.module_eval do
 
   # NOTE: avoid TypeError: String can't be coerced into Fixnum
-  # due this method gettings a strings == [ 1 ] argument ...
+  # due this method getting some strings == [ 1 ] argument ...
   def trace_on(out, *strings)
     sep = $\ || "\n"
     if strings.empty?
@@ -138,5 +127,5 @@ Rake::TraceOutput.module_eval do
     end
     out.print(output)
   end
-  
+
 end