activerecord-jdbc-adapter 1.2.5 → 1.2.8

data/lib/arjdbc/derby/connection_methods.rb

@@ -2,7 +2,11 @@ module ActiveRecord
   class Base
     class << self
       def derby_connection(config)
-        require 'active_record/connection_adapters/jdbcderby_adapter'
+        begin
+          require 'jdbc/derby'
+          ::Jdbc::Derby.load_driver(:require) if defined?(::Jdbc::Derby.load_driver)
+        rescue LoadError # assuming driver.jar is on the class-path
+        end
 
         config[:url] ||= "jdbc:derby:#{config[:database]};create=true"
         config[:driver] ||= defined?(::Jdbc::Derby.driver_name) ? ::Jdbc::Derby.driver_name : 'org.apache.derby.jdbc.EmbeddedDriver'

data/lib/arjdbc/firebird/adapter.rb

@@ -1,25 +1,29 @@
-module ::ArJdbc
+require 'arjdbc/jdbc/serialized_attributes_helper'
+
+module ArJdbc
   module FireBird
 
+    @@_lob_callback_added = nil
+    
     def self.extended(mod)
-      unless @lob_callback_added
+      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]
-              if respond_to?(:unserializable_attribute?)
-                value = value.to_yaml if unserializable_attribute?(c.name, c)
-              else
-                value = value.to_yaml if value.is_a?(Hash)
-              end
+            self.class.columns.select { |c| c.sql_type =~ /blob/i }.each do |column|
+              value = ::ArJdbc::SerializedAttributesHelper.dump_column_value(self, column)
               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)
+              
+              connection.write_large_object(
+                column.type == :binary, column.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
+        @@_lob_callback_added = true
       end
     end
 
@@ -29,14 +33,18 @@ module ::ArJdbc
 
     def self.arel2_visitors(config)
       require 'arel/visitors/firebird'
-      {}.tap {|v| %w(firebird firebirdsql).each {|a| v[a] = ::Arel::Visitors::Firebird } }
-    end
-
-    def modify_types(tp)
-      tp[:primary_key] = 'INTEGER NOT NULL PRIMARY KEY'
-      tp[:string][:limit] = 252
-      tp[:integer][:limit] = nil
-      tp
+      {
+        'firebird' => ::Arel::Visitors::Firebird,
+        'firebirdsql' => ::Arel::Visitors::Firebird
+      }
+    end
+
+    def modify_types(types)
+      super(types)
+      types[:primary_key] = 'INTEGER NOT NULL PRIMARY KEY'
+      types[:string][:limit] = 252
+      types[:integer][:limit] = nil
+      types
     end
 
     def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = []) # :nodoc:

data/lib/arjdbc/h2/adapter.rb

@@ -8,24 +8,150 @@ module ArJdbc
       ::ActiveRecord::ConnectionAdapters::H2JdbcConnection
     end
 
-    def adapter_name #:nodoc:
-      'H2'
+    def self.column_selector
+      [ /\.h2\./i, lambda { |cfg, column| column.extend(::ArJdbc::H2::Column) } ]
+    end
+    
+    module Column
+      
+      private
+      
+      def extract_limit(sql_type)
+        limit = super
+        case @sql_type = sql_type.downcase
+        # NOTE: JDBC driver f*cks sql_type up with limits (just like HSQLDB) :
+        when /^tinyint/i       then @sql_type = 'tinyint'; limit = 1
+        when /^smallint|int2/i then @sql_type = 'smallint'; limit = 2
+        when /^bigint|int8/i   then @sql_type = 'bigint'; limit = 8
+        when /^int|int4/i      then @sql_type = 'int'; limit = 4
+        when /^double/i        then @sql_type = 'double'; limit = 8
+        when /^real/i          then @sql_type = 'real'; limit = 4
+        when /^date/i          then @sql_type = 'date'; limit = nil
+        when /^timestamp/i     then @sql_type = 'timestamp'; limit = nil
+        when /^time/i          then @sql_type = 'time'; limit = nil
+        when /^boolean/i       then @sql_type = 'boolean'; limit = nil
+        when /^binary|bytea/i; then @sql_type = 'binary'; limit = 2 * 1024 * 1024
+        when /blob|image|oid/i then @sql_type = 'blob'; limit = nil
+        when /clob|text/i      then @sql_type = 'clob'; limit = nil
+        # NOTE: use lower-case due SchemaDumper not handling it's decimal/integer
+        # optimization case-insensitively due : column.type == :integer && 
+        # [/^numeric/, /^decimal/].any? { |e| e.match(column.sql_type) }
+        when /^decimal\(65535,32767\)/i
+          @sql_type = 'decimal'; nil
+        end
+        limit
+      end
+      
+      def simplified_type(field_type)
+        case field_type
+        when /^bit|bool/i         then :boolean
+        when /^signed|year/i      then :integer
+        when /^real|double/i      then :float
+        when /^varchar/i          then :string
+        when /^binary|raw|bytea/i then :binary
+        when /^blob|image|oid/i   then :binary
+        else
+          super
+        end
+      end
+      
+      # Post process default value from JDBC into a Rails-friendly format (columns{-internal})
+      def default_value(value)
+        # H2 auto-generated key default value
+        return nil if value =~ /^\(NEXT VALUE FOR/i
+        # JDBC returns column default strings with actual single quotes around the value.
+        return $1 if value =~ /^'(.*)'$/
+        value
+      end
+      
+    end
+    
+    ADAPTER_NAME = 'H2' # :nodoc:
+    
+    def adapter_name # :nodoc:
+      ADAPTER_NAME
     end
 
     def self.arel2_visitors(config)
-      v = HSQLDB.arel2_visitors(config)
-      v.merge({}.tap {|v| %w(h2 jdbch2).each {|a| v[a] = ::Arel::Visitors::HSQLDB } })
+      visitors = HSQLDB.arel2_visitors(config)
+      visitors.merge({
+        'h2' => ::Arel::Visitors::HSQLDB,
+        'jdbch2' => ::Arel::Visitors::HSQLDB,
+      })
     end
-
-    def h2_adapter
+    
+    # #deprecated
+    def h2_adapter # :nodoc:
       true
     end
 
+    NATIVE_DATABASE_TYPES = {
+      :primary_key => "integer GENERATED BY DEFAULT AS IDENTITY(START WITH 0) PRIMARY KEY",
+      :boolean     => { :name => "boolean" },
+      :tinyint     => { :name => "tinyint", :limit => 1 },
+      :smallint    => { :name => "smallint", :limit => 2 },
+      :bigint      => { :name => "bigint", :limit => 8 },
+      :integer     => { :name => "int", :limit => 4 },
+      :decimal     => { :name => "decimal" },
+      :float       => { :name => "float", :limit => 8 },
+      :double      => { :name => "double", :limit => 8 },
+      :real        => { :name => "real", :limit => 4 },
+      :date        => { :name => "date" },
+      :time        => { :name => "time" },
+      :timestamp   => { :name => "timestamp" },
+      :binary      => { :name => "binary" },
+      :string      => { :name => "varchar", :limit => 255 },
+      :char        => { :name => "char" },
+      :blob        => { :name => "blob" },
+      :text        => { :name => "clob" },
+      :clob        => { :name => "clob" },
+      :uuid        => { :name => "uuid" },
+      :other       => { :name => "other" }, # java.lang.Object
+      :array       => { :name => "array" }, # java.lang.Object[]
+      :varchar_casesensitive => { :name => 'VARCHAR_CASESENSITIVE' },
+      :varchar_ignorecase => { :name => 'VARCHAR_IGNORECASE' },
+    }
+
+    def native_database_types
+      NATIVE_DATABASE_TYPES.dup
+    end
+    
+    def modify_types(types)
+      types
+    end
+    
+    def type_to_sql(type, limit = nil, precision = nil, scale = nil)
+      case type.to_sym
+      when :integer
+        case limit
+        when 1; 'tinyint'
+        when 2; 'smallint'
+        when nil, 3, 4; 'int'
+        when 5..8; 'bigint'
+        else raise(ActiveRecordError, "No integer type has byte size #{limit}")
+        end
+      when :float
+        case limit
+        when 1..4; 'real'
+        when 5..8; 'double'
+        else raise(ActiveRecordError, "No float type has byte size #{limit}")
+        end
+      when :binary
+        if limit && limit < 2 * 1024 * 1024
+          'binary'
+        else
+          'blob'
+        end
+      else
+        super
+      end
+    end
+    
     def tables
       @connection.tables(nil, h2_schema)
     end
 
-    def columns(table_name, name=nil)
+    def columns(table_name, name = nil)
       @connection.columns_internal(table_name.to_s, name, h2_schema)
     end
 
@@ -35,7 +161,35 @@ module ArJdbc
       change_column_null(table_name, column_name, options[:null], options[:default]) if options.key?(:null)
     end
 
+    def current_schema
+      execute('CALL SCHEMA()')[0].values[0]
+    end
+    
+    def quote(value, column = nil) # :nodoc:
+      case value
+      when String
+        if value.empty?
+          "''"
+        else
+          super
+        end
+      else
+        super
+      end
+    end
+    
+    # EXPLAIN support :
+    
+    def supports_explain?; true; end
+
+    def explain(arel, binds = [])
+      sql = "EXPLAIN #{to_sql(arel, binds)}"
+      raw_result  = execute(sql, "EXPLAIN", binds)
+      raw_result[0].values.join("\n") # [ "SELECT \n ..." ].to_s
+    end
+    
     private
+    
     def change_column_null(table_name, column_name, null, default = nil)
       if !null && !default.nil?
         execute("UPDATE #{table_name} SET #{column_name}=#{quote(default)} WHERE #{column_name} IS NULL")
@@ -50,5 +204,6 @@ module ArJdbc
     def h2_schema
       @config[:schema] || ''
     end
+    
   end
 end

data/lib/arjdbc/h2/connection_methods.rb

@@ -2,7 +2,11 @@ module ActiveRecord
   class Base
     class << self
       def h2_connection(config)
-        require 'active_record/connection_adapters/jdbch2_adapter'
+        begin
+          require 'jdbc/h2'
+          ::Jdbc::H2.load_driver(:require) if defined?(::Jdbc::H2.load_driver)
+        rescue LoadError # assuming driver.jar is on the class-path
+        end
 
         config[:url] ||= "jdbc:h2:#{config[:database]}"
         config[:driver] ||= defined?(::Jdbc::H2.driver_name) ? ::Jdbc::H2.driver_name : 'org.h2.Driver'

data/lib/arjdbc/hsqldb.rb

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

data/lib/arjdbc/hsqldb/adapter.rb

@@ -1,65 +1,105 @@
-module ::ArJdbc
+require 'arjdbc/hsqldb/explain_support'
+
+module ArJdbc
   module HSQLDB
+    include ExplainSupport
+    
     def self.column_selector
-      [/hsqldb|\.h2\./i, lambda {|cfg,col| col.extend(::ArJdbc::HSQLDB::Column)}]
+      [ /hsqldb/i, lambda { |cfg, column| column.extend(::ArJdbc::HSQLDB::Column) } ]
     end
 
     module Column
+      
       private
+
+      def extract_limit(sql_type)
+        limit = super
+        case @sql_type = sql_type.downcase
+        when /^tinyint/i     then @sql_type = 'tinyint'; limit = 1
+        when /^smallint/i    then @sql_type = 'smallint'; limit = 2
+        when /^bigint/i      then @sql_type = 'bigint'; limit = 8
+        when /^double/i      then @sql_type = 'double'; limit = 8
+        when /^real/i        then @sql_type = 'real'; limit = 8
+        # NOTE: once again we get incorrect "limits" from HypesSQL's JDBC 
+        # thus yet again we need to fix incorrectly detected limits :
+        when /^integer/i     then @sql_type = 'integer'; limit = 4
+        when /^float/i       then @sql_type = 'float';   limit = 8
+        when /^decimal/i     then @sql_type = 'decimal';
+        when /^datetime/i    then @sql_type = 'datetime'; limit = nil
+        when /^timestamp/i   then @sql_type = 'timestamp'; limit = nil
+        when /^time/i        then @sql_type = 'time'; limit = nil
+        when /^date/i        then @sql_type = 'date'; limit = nil
+        else
+          # HSQLDB appears to return "LONGVARCHAR(0)" for :text columns, 
+          # which for AR purposes should be interpreted as "no limit" :
+          limit = nil if sql_type =~ /\(0\)$/
+        end
+        limit
+      end
+      
       def simplified_type(field_type)
         case field_type
         when /longvarchar/i then :text
-        when /tinyint/i  then :boolean
-        when /real/i     then :float
+        when /int/i         then :integer # TINYINT, SMALLINT, BIGINT, INT
+        when /real|double/i then :float
+        when /bit/i         then :boolean
+        when /binary/i      then :binary # VARBINARY, LONGVARBINARY
         else
           super
         end
       end
-
-      # Override of ActiveRecord::ConnectionAdapters::Column
-      def extract_limit(sql_type)
-        # HSQLDB appears to return "LONGVARCHAR(0)" for :text columns, which
-        # for AR purposes should be interpreted as "no limit"
-        return nil if sql_type =~ /\(0\)/
-        super
-      end
-
+      
       # Post process default value from JDBC into a Rails-friendly format (columns{-internal})
       def default_value(value)
-        # H2 auto-generated key default value
-        return nil if value =~ /^\(NEXT VALUE FOR/i
-
-        # jdbc returns column default strings with actual single quotes around the value.
+        # JDBC returns column default strings with actual single quotes around the value.
         return $1 if value =~ /^'(.*)'$/
-
         value
       end
+      
     end
 
-    def adapter_name #:nodoc:
-      'Hsqldb'
+    ADAPTER_NAME = 'HSQLDB' # :nodoc:
+    
+    def adapter_name # :nodoc:
+      ADAPTER_NAME
     end
 
     def self.arel2_visitors(config)
       require 'arel/visitors/hsqldb'
-      {}.tap {|v| %w(hsqldb jdbchsqldb).each {|a| v[a] = ::Arel::Visitors::HSQLDB } }
-    end
-
-    def modify_types(tp)
-      tp[:primary_key] = "INTEGER GENERATED BY DEFAULT AS IDENTITY(START WITH 0) PRIMARY KEY"
-      tp[:integer][:limit] = nil
-      tp[:boolean][:limit] = nil
-      # set text and float limits so we don't see odd scales tacked on
-      # in migrations
-      tp[:boolean] = { :name => "tinyint" }
-      tp[:text][:limit] = nil
-      tp[:float][:limit] = 17 if defined?(::Jdbc::H2)
-      tp[:string][:limit] = 255
-      tp[:datetime] = { :name => "DATETIME" }
-      tp[:timestamp] = { :name => "DATETIME" }
-      tp[:time] = { :name => "TIME" }
-      tp[:date] = { :name => "DATE" }
-      tp
+      {
+        'hsqldb' => ::Arel::Visitors::HSQLDB,
+        'jdbchsqldb' => ::Arel::Visitors::HSQLDB,
+      }
+    end
+    
+    NATIVE_DATABASE_TYPES = {
+      :primary_key => "integer GENERATED BY DEFAULT AS IDENTITY(START WITH 0) PRIMARY KEY",
+      :string => { :name => "varchar", :limit => 255 },
+      :text => { :name => "clob" },
+      :binary => { :name => "blob" },
+      :boolean => { :name => "boolean" },
+      :integer => { :name => "integer", :limit => 4 },
+      :float => { :name => "float", :limit => 8 },
+      # NOTE: fix incorrectly detected limits :
+      :tinyint => { :name => "tinyint", :limit => 1 },
+      :smallint => { :name => "smallint", :limit => 2 },
+      :bigint => { :name => "bigint", :limit => 8 },
+      :double => { :name => "double", :limit => 8 },
+      :real => { :name => "real", :limit => 8 },
+    }
+    
+    def native_database_types
+      super.merge NATIVE_DATABASE_TYPES
+    end
+    
+    def modify_types(types)
+      super(types)
+      types[:primary_key] = NATIVE_DATABASE_TYPES[:primary_key]
+      types[:string] = NATIVE_DATABASE_TYPES[:string].dup
+      #types[:integer][:limit] = nil
+      #types[:boolean][:limit] = nil
+      types[:text][:limit] = nil
+      types
     end
 
     def quote(value, column = nil) # :nodoc:
@@ -67,22 +107,27 @@ module ::ArJdbc
 
       case value
       when String
-        if respond_to?(:h2_adapter) && value.empty?
-          "''"
-        elsif column && column.type == :binary
+        column_type = column && column.type
+        if column_type == :binary
           "X'#{value.unpack("H*")[0]}'"
-        elsif column && (column.type == :integer ||
-                         column.respond_to?(:primary) && column.primary && column.klass != String)
+        elsif column_type == :integer ||
+            column.respond_to?(:primary) && column.primary && column.klass != String
           value.to_i.to_s
         else
           "'#{quote_string(value)}'"
         end
+      when Time
+        if column && column.type == :time
+          "'#{value.strftime("%H:%M:%S")}'"
+        else
+          super
+        end
       else
         super
       end
     end
 
-    def quote_column_name(name) #:nodoc:
+    def quote_column_name(name) # :nodoc:
       name = name.to_s
       if name =~ /[-]/
         %Q{"#{name.upcase}"}
@@ -91,18 +136,6 @@ module ::ArJdbc
       end
     end
 
-    def quote_string(str)
-      str.gsub(/'/, "''")
-    end
-
-    def quoted_true
-      '1'
-    end
-
-    def quoted_false
-      '0'
-    end
-
     def add_column(table_name, column_name, type, options = {})
       add_column_sql = "ALTER TABLE #{quote_table_name(table_name)} ADD #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
       add_column_options!(add_column_sql, options)
@@ -139,8 +172,9 @@ module ::ArJdbc
 
     def _execute(sql, name = nil)
       result = super
-      ActiveRecord::ConnectionAdapters::JdbcConnection::insert?(sql) ? last_insert_id : result
+      self.class.insert?(sql) ? last_insert_id : result
     end
+    private :_execute
 
     def add_limit_offset!(sql, options) #:nodoc:
       if sql =~ /^select/i
@@ -154,14 +188,14 @@ module ::ArJdbc
       end
     end
 
-    # override to filter out system tables that otherwise end
-    # up in db/schema.rb during migrations.  JdbcConnection#tables
+    # filter out system tables (that otherwise end up in db/schema.rb)
+    # JdbcConnection#tables
     # now takes an optional block filter so we can screen out
     # rows corresponding to system tables.  HSQLDB names its
     # system tables SYSTEM.*, but H2 seems to name them without
     # any kind of convention
     def tables
-      @connection.tables.select {|row| row.to_s !~ /^system_/i }
+      @connection.tables.select { |row| row.to_s !~ /^system_/i }
     end
 
     def remove_index(table_name, options = {})
@@ -180,6 +214,7 @@ module ::ArJdbc
 
     def drop_database(name)
       execute("DROP ALL OBJECTS")
-    end    
+    end
+    
   end
 end