activerecord-jdbc-adapter 1.0.0.beta1-java → 1.0.0.beta2-java

data/lib/arjdbc/derby/adapter.rb

@@ -215,6 +215,29 @@ module ::ArJdbc
       super
     end
 
+    # SELECT DISTINCT clause for a given set of columns and a given ORDER BY clause.
+    #
+    # Derby requires the ORDER BY columns in the select list for distinct queries, and
+    # requires that the ORDER BY include the distinct column.
+    #
+    #   distinct("posts.id", "posts.created_at desc")
+    #
+    # Based on distinct method for PostgreSQL Adapter
+    def distinct(columns, order_by)
+      return "DISTINCT #{columns}" if order_by.blank?
+
+      # construct a clean list of column names from the ORDER BY clause, removing
+      # any asc/desc modifiers
+      order_columns = order_by.split(',').collect { |s| s.split.first }
+      order_columns.delete_if(&:blank?)
+      order_columns = order_columns.zip((0...order_columns.size).to_a).map { |s,i| "#{s} AS alias_#{i}" }
+
+      # return a DISTINCT clause that's distinct on the columns we want but includes
+      # all the required columns for the ORDER BY to work properly
+      sql = "DISTINCT #{columns}, #{order_columns * ', '}"
+      sql
+    end
+
     # I don't think this method is ever called ??? (stepheneb)
     def create_column(name, refid, colno)
       stmt = COLUMN_TYPE_STMT % [refid, strip_quotes(name)]
@@ -400,7 +423,11 @@ module ::ArJdbc
     private
     # Derby appears to define schemas using the username
     def derby_schema
-      @config[:username].to_s
+      if @config.has_key?(:schema)
+        config[:schema]
+      else
+        (@config[:username] && @config[:username].to_s) || ''
+      end
     end
   end
 end

data/lib/arjdbc/derby/connection_methods.rb

@@ -5,7 +5,7 @@ module ActiveRecord
         config[:url] ||= "jdbc:derby:#{config[:database]};create=true"
         config[:driver] ||= "org.apache.derby.jdbc.EmbeddedDriver"
         conn = embedded_driver(config)
-        md = conn.raw_connection.connection.meta_data
+        md = conn.jdbc_connection.meta_data
         if md.database_major_version < 10 || md.database_minor_version < 5
           raise ::ActiveRecord::ConnectionFailed, "Derby adapter requires Derby 10.5 or later"
         end

data/lib/arjdbc/discover.rb

@@ -28,7 +28,7 @@ module ::ArJdbc
   end
 
   extension :DB2 do |name, config|
-    if name =~ /db2/i && config[:url] !~ /^jdbc:derby:net:/
+    if name =~ /(db2|as400)/i && config[:url] !~ /^jdbc:derby:net:/
       require 'arjdbc/db2'
       true
     end

data/lib/arjdbc/firebird/adapter.rb

@@ -1,5 +1,28 @@
 module ::ArJdbc
   module FireBird
+
+    def self.extended(mod)
+      unless @lob_callback_added
+        ActiveRecord::Base.class_eval do
+          def after_save_with_firebird_blob
+            self.class.columns.select { |c| c.sql_type =~ /blob/i }.each do |c|
+              value = self[c.name]
+              value = value.to_yaml if unserializable_attribute?(c.name, c)
+              next if value.nil?
+              connection.write_large_object(c.type == :binary, c.name, self.class.table_name, self.class.primary_key, quote_value(id), value)
+            end
+          end
+        end
+
+        ActiveRecord::Base.after_save :after_save_with_firebird_blob
+        @lob_callback_added = true
+      end
+    end
+
+    def adapter_name
+      'Firebird'
+    end
+
     def modify_types(tp)
       tp[:primary_key] = 'INTEGER NOT NULL PRIMARY KEY'
       tp[:string][:limit] = 252
@@ -62,6 +85,9 @@ module ::ArJdbc
     def quote(value, column = nil) # :nodoc:
       return value.quoted_id if value.respond_to?(:quoted_id)
 
+      # BLOBs are updated separately by an after_save trigger.
+      return value.nil? ? "NULL" : "'#{quote_string(value[0..1])}'" if column && [:binary, :text].include?(column.type)
+
       if [Time, DateTime].include?(value.class)
         "CAST('#{value.strftime("%Y-%m-%d %H:%M:%S")}' AS TIMESTAMP)"
       else

data/lib/arjdbc/h2/adapter.rb

@@ -11,5 +11,18 @@ module ArJdbc
     def h2_adapter
       true
     end
+
+    def tables
+      @connection.tables(nil, h2_schema)
+    end
+
+    def columns(table_name, name=nil)
+      @connection.columns_internal(table_name.to_s, name, h2_schema)
+    end
+
+    private
+    def h2_schema
+      @config[:schema] || ''
+    end
   end
 end

data/lib/arjdbc/hsqldb/adapter.rb

@@ -143,12 +143,14 @@ module ::ArJdbc
     end
 
     def add_limit_offset!(sql, options) #:nodoc:
-      offset = options[:offset] || 0
-      bef = sql[7..-1]
-      if limit = options[:limit]
-        sql.replace "select limit #{offset} #{limit} #{bef}"
-      elsif offset > 0
-        sql.replace "select limit #{offset} 0 #{bef}"
+      if sql =~ /^select/i
+        offset = options[:offset] || 0
+        bef = sql[7..-1]
+        if limit = options[:limit]
+          sql.replace "SELECT LIMIT #{offset} #{limit} #{bef}"
+        elsif offset > 0
+          sql.replace "SELECT LIMIT #{offset} 0 #{bef}"
+        end
       end
     end
 

data/lib/arjdbc/informix/adapter.rb

@@ -36,6 +36,10 @@ module ::ArJdbc
         lambda { |cfg, column| column.extend(::ArJdbc::Informix::Column) } ]
     end
 
+    def self.jdbc_connection_class
+      ::ActiveRecord::ConnectionAdapters::InformixJdbcConnection
+    end
+
     module Column
     private
       # TODO: Test all Informix column types.

data/lib/arjdbc/jdbc/adapter.rb

@@ -46,13 +46,35 @@ module ActiveRecord
         ActiveRecord::ConnectionAdapters::JdbcColumn
       end
 
+      # Retrieve the raw java.sql.Connection object.
+      def jdbc_connection
+        raw_connection.connection
+      end
+
       # Locate specialized adapter specification if one exists based on config data
       def adapter_spec(config)
-        dialect = (config[:dialect] || config[:driver]).to_s
-        ::ArJdbc.constants.map { |name| ::ArJdbc.const_get name }.each do |constant|
-          if constant.respond_to? :adapter_matcher
-            spec = constant.adapter_matcher(dialect, config)
-            return spec if spec
+        2.times do
+          dialect = (config[:dialect] || config[:driver]).to_s
+          ::ArJdbc.constants.map { |name| ::ArJdbc.const_get name }.each do |constant|
+            if constant.respond_to? :adapter_matcher
+              spec = constant.adapter_matcher(dialect, config)
+              return spec if spec
+            end
+          end
+
+          # If nothing matches and we're using jndi, try to automatically detect the database.
+          break unless config[:jndi] and !config[:dialect]
+          begin
+            conn = Java::javax.naming.InitialContext.new.lookup(config[:jndi]).getConnection
+            config[:dialect] = conn.getMetaData.getClass.getName.downcase
+
+            # Derby-specific hack
+            if ::ArJdbc::Derby.adapter_matcher(config[:dialect], config)
+              # Needed to set the correct database schema name
+              config[:username] ||= conn.getMetaData.getUserName
+            end
+          rescue
+            conn.close
           end
         end
         nil

data/lib/arjdbc/jdbc/connection.rb

@@ -1,6 +1,76 @@
 module ActiveRecord
   module ConnectionAdapters
     class JdbcConnection
+      module ConfigHelper
+        attr_reader :config
+
+        def config=(config)
+          @config = config.symbolize_keys!
+        end
+
+        def configure_connection
+          config[:retry_count] ||= 5
+          config[:connection_alive_sql] ||= "select 1"
+          @jndi_connection = false
+          @connection = nil
+          if config[:jndi]
+            begin
+              configure_jndi
+            rescue => e
+              warn "JNDI data source unavailable: #{e.message}; trying straight JDBC"
+              configure_jdbc
+            end
+          else
+            configure_jdbc
+          end
+        end
+
+        def configure_jndi
+          jndi = config[:jndi].to_s
+          ctx = javax.naming.InitialContext.new
+          ds = ctx.lookup(jndi)
+          @connection_factory = JdbcConnectionFactory.impl do
+            ds.connection
+          end
+          unless config[:driver]
+            config[:driver] = connection.meta_data.connection.java_class.name
+          end
+          @jndi_connection = true
+        end
+
+        def configure_url
+          url = config[:url].to_s
+          if Hash === config[:options]
+            options = ''
+            config[:options].each do |k,v|
+              options << '&' unless options.empty?
+              options << "#{k}=#{v}"
+            end
+            url = url['?'] ? "#{url}&#{options}" : "#{url}?#{options}" unless options.empty?
+            config[:url] = url
+            config[:options] = nil
+          end
+          url
+        end
+
+        def configure_jdbc
+          unless config[:driver] && config[:url]
+            raise ::ActiveRecord::ConnectionNotEstablished, "jdbc adapter requires driver class and url"
+          end
+
+          driver = config[:driver].to_s
+          user   = config[:username].to_s
+          pass   = config[:password].to_s
+          url    = configure_url
+
+          jdbc_driver = JdbcDriver.new(driver)
+          jdbc_driver.load
+          @connection_factory = JdbcConnectionFactory.impl do
+            jdbc_driver.connection(url, user, pass)
+          end
+        end
+      end
+
       attr_reader :adapter, :connection_factory
 
       # @native_database_types - setup properly by adapter= versus set_native_database_types.
@@ -12,26 +82,15 @@ module ActiveRecord
       # then this is used as a base to be tweaked by each adapter to create @native_database_types
 
       def initialize(config)
-        @config = config.symbolize_keys!
-        @config[:retry_count] ||= 5
-        @config[:connection_alive_sql] ||= "select 1"
-        @jndi_connection = false
-        @connection = nil
-        if @config[:jndi]
-          begin
-            configure_jndi
-          rescue => e
-            warn "JNDI data source unavailable: #{e.message}; trying straight JDBC"
-            configure_jdbc
-          end
-        else
-          configure_jdbc
-        end
+        self.config = config
+        configure_connection
         connection # force the connection to load
         set_native_database_types
         @stmts = {}
+      rescue ::ActiveRecord::ActiveRecordError
+        raise
       rescue Exception => e
-        raise "The driver encountered an error: #{e}"
+        raise "The driver encountered an unknown error: #{e}"
       end
 
       def adapter=(adapter)
@@ -63,35 +122,7 @@ module ActiveRecord
       end
 
       private
-      def configure_jndi
-        jndi = @config[:jndi].to_s
-        ctx = javax.naming.InitialContext.new
-        ds = ctx.lookup(jndi)
-        @connection_factory = JdbcConnectionFactory.impl do
-          ds.connection
-        end
-        unless @config[:driver]
-          @config[:driver] = connection.meta_data.connection.java_class.name
-        end
-        @jndi_connection = true
-      end
-
-      def configure_jdbc
-        driver = @config[:driver].to_s
-        user   = @config[:username].to_s
-        pass   = @config[:password].to_s
-        url    = @config[:url].to_s
-
-        unless driver && url
-          raise ::ActiveRecord::ConnectionFailed, "jdbc adapter requires driver class and url"
-        end
-
-        jdbc_driver = JdbcDriver.new(driver)
-        jdbc_driver.load
-        @connection_factory = JdbcConnectionFactory.impl do
-          jdbc_driver.connection(url, user, pass)
-        end
-      end
+      include ConfigHelper
     end
   end
 end

data/lib/arjdbc/jdbc/jdbc.rake

@@ -20,7 +20,7 @@ def rails_env
 end
 
 namespace :db do
-  redefine_task :create => :environment do
+  redefine_task :create => :rails_env do
     create_database(ActiveRecord::Base.configurations[rails_env])
   end
   task :create => :load_config if Rake.application.lookup(:load_config)
@@ -28,9 +28,7 @@ namespace :db do
   redefine_task :drop => :environment do
     config = ActiveRecord::Base.configurations[rails_env]
     begin
-      ActiveRecord::Base.establish_connection(config)
-      db = ActiveRecord::Base.connection.database_name
-      ActiveRecord::Base.connection.drop_database(db)
+      ActiveRecord::Base.connection.drop_database(find_database_name(config))
     rescue
       drop_database(config.merge('adapter' => config['adapter'].sub(/^jdbc/, '')))
     end
@@ -38,7 +36,7 @@ namespace :db do
   task :drop => :load_config if Rake.application.lookup(:load_config)
 
   namespace :create do
-    task :all => :environment
+    task :all => :rails_env
   end
 
   namespace :drop do
@@ -50,6 +48,24 @@ namespace :db do
     alias_method :previous_drop_database, :drop_database
   end
 
+  def find_database_name(config)
+    if config['adapter'] =~ /postgresql/i
+      config = config.dup
+      if config['url']
+        db = config['url'][/\/([^\/]*)$/, 1]
+        config['url'][/\/([^\/]*)$/, 1] = 'postgres' if db
+      else
+        db = config['database']
+        config['database'] = 'postgres'
+      end
+      ActiveRecord::Base.establish_connection(config)
+    else
+      ActiveRecord::Base.establish_connection(config)
+      db = ActiveRecord::Base.connection.database_name
+    end
+    db
+  end
+
   def create_database(config)
     begin
       ActiveRecord::Base.establish_connection(config)
@@ -102,21 +118,7 @@ namespace :db do
 
     redefine_task :purge => :environment do
       abcs = ActiveRecord::Base.configurations
-      config = abcs['test'].dup
-      if config['adapter'] =~ /postgresql/i
-        if config['url']
-          db = config['url'][/\/([^\/]*)$/, 1]
-          config['url'][/\/([^\/]*)$/, 1] = 'postgres' if db
-        else
-          db = config['database']
-          config['database'] = 'postgres'
-        end
-        ActiveRecord::Base.establish_connection(config)
-      else
-        ActiveRecord::Base.establish_connection(config)
-        db = ActiveRecord::Base.connection.database_name
-      end
-      ActiveRecord::Base.connection.recreate_database(db)
+      ActiveRecord::Base.connection.recreate_database(find_database_name(abcs['test']))
     end
   end
 end

data/lib/arjdbc/jdbc/type_converter.rb

@@ -20,6 +20,7 @@ module ActiveRecord
                           lambda {|r| r['type_name'] =~ /varying/i}],
         :text        => [ lambda {|r| [Jdbc::Types::LONGVARCHAR, Jdbc::Types::CLOB].include?(r['data_type'].to_i)},
                           lambda {|r| r['type_name'] =~ /^text$/i},     # For Informix
+                          lambda {|r| r['type_name'] =~ /sub_type 1$/i}, # For FireBird
                           lambda {|r| r['type_name'] =~ /^(text|clob)$/i},
                           lambda {|r| r['type_name'] =~ /^character large object$/i},
                           lambda {|r| r['sql_data_type'] == 2005}],
@@ -83,7 +84,7 @@ module ActiveRecord
           name = row['type_name'].downcase
           k = name.to_sym
           type_map[k] = { :name => name }
-          type_map[k][:limit] = row['precision'].to_i if row['precision']
+          set_limit_to_nonzero_precision(type_map[k], row)
         end
 
         AR_TO_JDBC_TYPES.keys.each do |k|
@@ -91,7 +92,7 @@ module ActiveRecord
           type_map[k] = { :name => typerow['type_name'].downcase }
           case k
           when :integer, :string, :decimal
-            type_map[k][:limit] = typerow['precision'] && typerow['precision'].to_i
+            set_limit_to_nonzero_precision(type_map[k], typerow)
           when :boolean
             type_map[k][:limit] = 1
           end
@@ -114,6 +115,12 @@ module ActiveRecord
         end
         raise "unable to choose type for #{ar_type} from:\n#{types.collect{|t| t['type_name']}.inspect}"
       end
+
+      def set_limit_to_nonzero_precision(map, row)
+        if row['precision'] && row['precision'].to_i > 0
+          map[:limit] = row['precision'].to_i
+        end
+      end
     end
   end
 end