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

data/lib/arjdbc/derby/connection_methods.rb

@@ -7,16 +7,11 @@ ArJdbc::ConnectionMethods.module_eval do
     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'
+    config[:driver] ||= defined?(::Jdbc::Derby.driver_name) ?
+      ::Jdbc::Derby.driver_name : 'org.apache.derby.jdbc.EmbeddedDriver'
     config[:adapter_spec] ||= ::ArJdbc::Derby
-    config[:connection_alive_sql] ||= 'SELECT 1 FROM SYS.SYSSCHEMAS FETCH FIRST 1 ROWS ONLY' # FROM clause is mandatory
-    
-    connection = embedded_driver(config)
-    md = connection.jdbc_connection.meta_data
-    if md.database_major_version < 10 || (md.database_major_version == 10 && md.database_minor_version < 5)
-      raise ::ActiveRecord::ConnectionFailed, "Derby adapter requires Derby 10.5 or later"
-    end
-    connection
+
+    embedded_driver(config)
   end
   alias_method :jdbcderby_connection, :derby_connection
 end

data/lib/arjdbc/firebird.rb

@@ -1,2 +1,3 @@
 require 'arjdbc'
 require 'arjdbc/firebird/adapter'
+require 'arjdbc/firebird/connection_methods'

data/lib/arjdbc/firebird/adapter.rb

@@ -1,58 +1,162 @@
-require 'arjdbc/jdbc/serialized_attributes_helper'
-
 module ArJdbc
-  module FireBird
-
-    @@_lob_callback_added = nil
-    
-    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 |column|
-              value = ::ArJdbc::SerializedAttributesHelper.dump_column_value(self, column)
-              next if value.nil?
-              
-              connection.write_large_object(
-                column.type == :binary, column.name, 
-                self.class.table_name, self.class.primary_key, 
-                quote_value(id), value
-              )
-            end
+  module Firebird
+
+    # @private
+    def self.extended(adapter); initialize!; end
+
+    # @private
+    @@_initialized = nil
+
+    # @private
+    def self.initialize!
+      return if @@_initialized; @@_initialized = true
+
+      require 'arjdbc/jdbc/serialized_attributes_helper'
+      ActiveRecord::Base.class_eval do
+        def after_save_with_firebird_blob
+          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?
+
+            self.class.connection.update_lob_value(self, column, value)
           end
         end
+      end
+      ActiveRecord::Base.after_save :after_save_with_firebird_blob
+    end
+
+    # @see ActiveRecord::ConnectionAdapters::JdbcColumn#column_types
+    def self.column_selector
+      [ /firebird/i, lambda { |cfg, column| column.extend(Column) } ]
+    end
+
+    # @see ActiveRecord::ConnectionAdapters::JdbcColumn
+    module Column
+
+      def simplified_type(field_type)
+        case field_type
+        when /timestamp/i  then :datetime
+        else super
+        end
+      end
 
-        ActiveRecord::Base.after_save :after_save_with_firebird_blob
-        @@_lob_callback_added = true
+      def default_value(value)
+        return nil unless value
+        if value =~ /^\s*DEFAULT\s+(.*)\s*$/i
+          return $1 unless $1.upcase == 'NULL'
+        end
       end
+
+    end
+
+    # @see ArJdbc::ArelHelper::ClassMethods#arel_visitor_type
+    def self.arel_visitor_type(config = nil)
+      require 'arel/visitors/firebird'; ::Arel::Visitors::Firebird
     end
 
+    # @deprecated no longer used
+    def self.arel2_visitors(config = nil)
+      { 'firebird' => arel_visitor_type, 'firebirdsql' => arel_visitor_type }
+    end
+
+    # @@emulate_booleans = true
+
+    # Boolean emulation can be disabled using :
+    #
+    #   ArJdbc::FireBird.emulate_booleans = false
+    #
+    # def self.emulate_booleans; @@emulate_booleans; end
+    # def self.emulate_booleans=(emulate); @@emulate_booleans = emulate; end
+
+    ADAPTER_NAME = 'Firebird'.freeze
+
     def adapter_name
-      'Firebird'
+      ADAPTER_NAME
     end
 
-    def self.arel2_visitors(config)
-      require 'arel/visitors/firebird'
-      {
-        'firebird' => ::Arel::Visitors::Firebird,
-        'firebirdsql' => ::Arel::Visitors::Firebird
-      }
+    NATIVE_DATABASE_TYPES = {
+      :primary_key => "integer not null primary key",
+      :string => { :name => "varchar", :limit => 255 },
+      :text => { :name => "blob sub_type text" },
+      :integer => { :name => "integer" },
+      :float => { :name => "float" },
+      :decimal => { :name => "decimal" },
+      :datetime => { :name => "timestamp" },
+      :timestamp => { :name => "timestamp" },
+      :time => { :name => "time" },
+      :date => { :name => "date" },
+      :binary => { :name => "blob" },
+      :boolean => { :name => 'smallint' }
+    }
+
+    def native_database_types
+      super.merge(NATIVE_DATABASE_TYPES)
     end
 
     def modify_types(types)
       super(types)
-      types[:primary_key] = 'INTEGER NOT NULL PRIMARY KEY'
-      types[:string][:limit] = 252
-      types[:integer][:limit] = nil
+      NATIVE_DATABASE_TYPES.each do |key, value|
+        types[key] = value.dup
+      end
       types
     end
 
-    def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = []) # :nodoc:
+    def type_to_sql(type, limit = nil, precision = nil, scale = nil)
+      case type
+      when :integer
+        case limit
+          when nil  then 'integer'
+          when 1..2 then 'smallint'
+          when 3..4 then 'integer'
+          when 5..8 then 'bigint'
+          else raise(ActiveRecordError, "No integer type has byte size #{limit}. "<<
+                                        "Use a NUMERIC with PRECISION 0 instead.")
+        end
+      when :float
+        if limit.nil? || limit <= 4
+          'float'
+        else
+          'double precision'
+        end
+      else super
+      end
+    end
+
+    # Does this adapter support migrations?
+    def supports_migrations?
+      true
+    end
+
+    # Can this adapter determine the primary key for tables not attached
+    # to an Active Record class, such as join tables?
+    def supports_primary_key?
+      true
+    end
+
+    # Does this adapter support using DISTINCT within COUNT?
+    def supports_count_distinct?
+      true
+    end
+
+    # Does this adapter support DDL rollbacks in transactions? That is, would
+    # CREATE TABLE or ALTER TABLE get rolled back by a transaction? PostgreSQL,
+    # SQL Server, and others support this. MySQL and others do not.
+    def supports_ddl_transactions?
+      false
+    end
+
+    # Does this adapter restrict the number of IDs you can use in a list.
+    # Oracle has a limit of 1000.
+    def ids_in_list_limit
+      1499
+    end
+
+    def insert(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil, binds = [])
       execute(sql, name, binds)
       id_value
     end
 
-    def add_limit_offset!(sql, options) # :nodoc:
+    def add_limit_offset!(sql, options)
       if options[:limit]
         limit_string = "FIRST #{options[:limit]}"
         limit_string << " SKIP #{options[:offset]}" if options[:offset]
@@ -60,34 +164,44 @@ module ArJdbc
       end
     end
 
+    # Should primary key values be selected from their corresponding
+    # sequence before the insert statement? If true, next_sequence_value
+    # is called before each insert to set the record's primary key.
+    # This is false for all adapters but Firebird.
     def prefetch_primary_key?(table_name = nil)
       true
     end
 
-    def default_sequence_name(table_name, primary_key) # :nodoc:
+    def default_sequence_name(table_name, column=nil)
       "#{table_name}_seq"
     end
 
+    # Set the sequence to the max value of the table's column.
+    def reset_sequence!(table, column, sequence = nil)
+      max_id = select_value("SELECT max(#{column}) FROM #{table}")
+      execute("ALTER SEQUENCE #{default_sequence_name(table, column)} RESTART WITH #{max_id}")
+    end
+
     def next_sequence_value(sequence_name)
       select_one("SELECT GEN_ID(#{sequence_name}, 1 ) FROM RDB$DATABASE;")["gen_id"]
     end
 
-    def create_table(name, options = {}) #:nodoc:
+    def create_table(name, options = {})
       super(name, options)
       execute "CREATE GENERATOR #{name}_seq"
     end
 
-    def rename_table(name, new_name) #:nodoc:
+    def rename_table(name, new_name)
       execute "RENAME #{name} TO #{new_name}"
       execute "UPDATE RDB$GENERATORS SET RDB$GENERATOR_NAME='#{new_name}_seq' WHERE RDB$GENERATOR_NAME='#{name}_seq'" rescue nil
     end
 
-    def drop_table(name, options = {}) #:nodoc:
+    def drop_table(name, options = {})
       super(name)
       execute "DROP GENERATOR #{name}_seq" rescue nil
     end
 
-    def change_column(table_name, column_name, type, options = {}) #:nodoc:
+    def change_column(table_name, column_name, type, options = {})
       execute "ALTER TABLE #{table_name} ALTER  #{column_name} TYPE #{type_to_sql(type, options[:limit])}"
     end
 
@@ -95,54 +209,78 @@ module ArJdbc
       execute "ALTER TABLE #{table_name} ALTER  #{column_name} TO #{new_column_name}"
     end
 
-    def remove_index(table_name, options) #:nodoc:
+    def remove_index(table_name, options)
       execute "DROP INDEX #{index_name(table_name, options)}"
     end
 
-    def quote(value, column = nil) # :nodoc:
+    # @override
+    def quote(value, column = nil)
       return value.quoted_id if value.respond_to?(:quoted_id)
 
+      type = column && column.type
       # 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)
+      return "NULL" if type == :binary || type == :text
 
-      if [Time, DateTime].include?(value.class)
-        "CAST('#{value.strftime("%Y-%m-%d %H:%M:%S")}' AS TIMESTAMP)"
+      case value
+      when String, ActiveSupport::Multibyte::Chars
+        value = value.to_s
+        if type == :integer
+          value.to_i.to_s
+        elsif type == :float
+          value.to_f.to_s
+        else
+          "'#{quote_string(value)}'"
+        end
+      when NilClass then "NULL"
+      when TrueClass then (type == :integer ? '1' : quoted_true)
+      when FalseClass then (type == :integer ? '0' : quoted_false)
+      when Float, Fixnum, Bignum then value.to_s
+      # BigDecimals need to be output in a non-normalized form and quoted.
+      when BigDecimal then value.to_s('F')
+      when Symbol then "'#{quote_string(value.to_s)}'"
       else
-        if column && column.type == :primary_key
-          return value.to_s
+        if type == :time && value.acts_like?(:time)
+          return "'#{value.strftime("%H:%M:%S")}'"
+        end
+        if type == :date && value.acts_like?(:date)
+          return "'#{value.strftime("%Y-%m-%d")}'"
         end
         super
       end
     end
 
-    def quote_string(string) # :nodoc:
-      string.gsub(/'/, "''")
-    end
+    # @override
+    def quoted_date(value)
+      if value.acts_like?(:time) && value.respond_to?(:usec)
+        usec = sprintf "%04d", (value.usec / 100.0).round
+        value = ::ActiveRecord::Base.default_timezone == :utc ? value.getutc : value.getlocal
+        "#{value.strftime("%Y-%m-%d %H:%M:%S")}.#{usec}"
+      else
+        super
+      end
+    end if ::ActiveRecord::VERSION::MAJOR >= 3
 
-    def quote_column_name(column_name) # :nodoc:
-      %Q("#{ar_to_fb_case(column_name)}")
+    # @override
+    def quote_string(string)
+      string.gsub(/'/, "''")
     end
 
-    def quoted_true # :nodoc:
+    # @override
+    def quoted_true
       quote(1)
     end
 
-    def quoted_false # :nodoc:
+    # @override
+    def quoted_false
       quote(0)
     end
 
-    private
-
-    # Maps uppercase Firebird column names to lowercase for ActiveRecord;
-    # mixed-case columns retain their original case.
-    def fb_to_ar_case(column_name)
-      column_name =~ /[[:lower:]]/ ? column_name : column_name.to_s.downcase
+    # @override
+    def quote_column_name(column_name)
+      column_name = column_name.to_s
+      %Q("#{column_name =~ /[[:upper:]]/ ? column_name : column_name.upcase}")
     end
 
-    # Maps lowercase ActiveRecord column names to uppercase for Fierbird;
-    # mixed-case columns retain their original case.
-    def ar_to_fb_case(column_name)
-      column_name =~ /[[:upper:]]/ ? column_name : column_name.to_s.upcase
-    end
   end
+  FireBird = Firebird
 end

data/lib/arjdbc/firebird/connection_methods.rb

@@ -0,0 +1,20 @@
+ArJdbc::ConnectionMethods.module_eval do
+  def firebird_connection(config)
+    begin
+      require 'jdbc/firebird'
+      ::Jdbc::Firebird.load_driver(:require)
+    rescue LoadError # assuming driver.jar is on the class-path
+    end
+
+    config[:host] ||= 'localhost'
+    config[:port] ||= 3050
+    config[:url] ||= begin
+      "jdbc:firebirdsql://#{config[:host]}:#{config[:port]}/#{config[:database]}"
+    end
+    config[:driver] ||= ::Jdbc::Firebird.driver_name
+    config[:adapter_spec] ||= ::ArJdbc::Firebird
+
+    jdbc_connection(config)
+  end
+  # alias_method :jdbcfirebird_connection, :firebird_connection
+end

data/lib/arjdbc/h2/adapter.rb

@@ -5,14 +5,17 @@ module ArJdbc
   module H2
     include HSQLDB
 
+    # @see ActiveRecord::ConnectionAdapters::JdbcAdapter#jdbc_connection_class
     def self.jdbc_connection_class
       ::ActiveRecord::ConnectionAdapters::H2JdbcConnection
     end
 
+    # @see ActiveRecord::ConnectionAdapters::JdbcColumn#column_types
     def self.column_selector
-      [ /\.h2\./i, lambda { |cfg, column| column.extend(::ArJdbc::H2::Column) } ]
+      [ /\.h2\./i, lambda { |config, column| column.extend(Column) } ]
     end
 
+    # @see ActiveRecord::ConnectionAdapters::JdbcColumn
     module Column
 
       private
@@ -49,7 +52,9 @@ module ArJdbc
         when /^signed|year/i      then :integer
         when /^real|double/i      then :float
         when /^varchar/i          then :string
+        when /^longvarchar/i      then :text
         when /^binary|raw|bytea/i then :binary
+        when /varbinary/i         then :binary # longvarbinary, varbinary
         when /^blob|image|oid/i   then :binary
         else
           super
@@ -67,60 +72,63 @@ module ArJdbc
 
     end
 
-    ADAPTER_NAME = 'H2' # :nodoc:
-
-    def adapter_name # :nodoc:
-      ADAPTER_NAME
+    # @see ActiveRecord::ConnectionAdapters::Jdbc::ArelSupport
+    def self.arel_visitor_type(config = nil)
+      HSQLDB.arel_visitor_type(config)
     end
 
-    def self.arel2_visitors(config)
-      visitors = HSQLDB.arel2_visitors(config)
-      visitors.merge({
-        'h2' => ::Arel::Visitors::HSQLDB,
-        'jdbch2' => ::Arel::Visitors::HSQLDB,
-      })
+    ADAPTER_NAME = 'H2'.freeze
+
+    # @override
+    def adapter_name
+      ADAPTER_NAME
     end
 
-    # #deprecated
-    def h2_adapter # :nodoc:
+    # @deprecated no longer used. only here for backwards compatibility with 1.2
+    def h2_adapter
       true
     end
 
     NATIVE_DATABASE_TYPES = {
+      # "integer GENERATED BY DEFAULT AS IDENTITY(START WITH 0) PRIMARY KEY"
       :primary_key => "bigint identity",
       :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" },
+      :decimal     => { :name => "decimal" }, # :limit => 2147483647
+      :numeric     => { :name => "numeric" }, # :limit => 2147483647
       :float       => { :name => "float", :limit => 8 },
       :double      => { :name => "double", :limit => 8 },
-      :real        => { :name => "real", :limit => 4 },
+      :real        => { :name => "real", :limit => 4 }, # :limit => 8
       :date        => { :name => "date" },
       :time        => { :name => "time" },
       :timestamp   => { :name => "timestamp" },
+      :datetime    => { :name => "timestamp" },
       :binary      => { :name => "binary" },
       :string      => { :name => "varchar", :limit => 255 },
-      :char        => { :name => "char" },
+      :char        => { :name => "char" }, # :limit => 2147483647
       :blob        => { :name => "blob" },
       :text        => { :name => "clob" },
       :clob        => { :name => "clob" },
-      :uuid        => { :name => "uuid" },
+      :uuid        => { :name => "uuid" }, # :limit => 2147483647
       :other       => { :name => "other" }, # java.lang.Object
       :array       => { :name => "array" }, # java.lang.Object[]
-      :varchar_casesensitive => { :name => 'VARCHAR_CASESENSITIVE' },
-      :varchar_ignorecase => { :name => 'VARCHAR_IGNORECASE' },
+      # NOTE: would be great if AR allowed as to refactor as :
+      #   t.column :string, :ignorecase => true
+      :varchar_casesensitive => { :name => 'varchar_casesensitive' },
+      :varchar_ignorecase => { :name => 'varchar_ignorecase' },
+      # :identity : { :name=>"identity", :limit => 19 }
+      # :result_set : { :name=>"result_set" }
     }
 
+    # @override
     def native_database_types
-      NATIVE_DATABASE_TYPES.dup
-    end
-
-    def modify_types(types)
-      types
+      NATIVE_DATABASE_TYPES
     end
 
+    # @override
     def type_to_sql(type, limit = nil, precision = nil, scale = nil)
       case type.to_sym
       when :integer
@@ -148,19 +156,23 @@ module ArJdbc
       end
     end
 
+    # @override
     def empty_insert_statement_value
       "VALUES ()"
     end
-    
+
+    # @override
     def tables
       @connection.tables(nil, h2_schema)
     end
 
+    # @override
     def columns(table_name, name = nil)
       @connection.columns_internal(table_name.to_s, nil, h2_schema)
     end
 
-    def change_column(table_name, column_name, type, options = {}) #:nodoc:
+    # @override
+    def change_column(table_name, column_name, type, options = {})
       execute "ALTER TABLE #{table_name} ALTER COLUMN #{column_name} #{type_to_sql(type, options[:limit])}"
       change_column_default(table_name, column_name, options[:default]) if options_include_default?(options)
       change_column_null(table_name, column_name, options[:null], options[:default]) if options.key?(:null)
@@ -170,7 +182,8 @@ module ArJdbc
       execute('CALL SCHEMA()')[0].values[0]
     end
 
-    def quote(value, column = nil) # :nodoc:
+    # @override
+    def quote(value, column = nil)
       case value
       when String
         if value.empty?
@@ -185,16 +198,19 @@ module ArJdbc
 
     # EXPLAIN support :
 
+    # @override
     def supports_explain?; true; end
 
+    # @override
     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
-    
+
+    # @override
     def structure_dump
-      execute('SCRIPT SIMPLE').map do |result| 
+      execute('SCRIPT SIMPLE').map do |result|
         # [ { 'script' => SQL }, { 'script' ... }, ... ]
         case sql = result.first[1] # ['script']
         when /CREATE USER IF NOT EXISTS SA/i then nil
@@ -203,22 +219,26 @@ module ArJdbc
       end.compact.join("\n\n")
     end
 
+    # @see #structure_dump
     def structure_load(dump)
       dump.each_line("\n\n") { |ddl| execute(ddl) }
     end
-    
+
     def shutdown
       execute 'SHUTDOWN COMPACT'
     end
-    
-    def recreate_database(name = nil, options = {}) # :nodoc:
+
+    # @private
+    def recreate_database(name = nil, options = {})
       drop_database(name)
       create_database(name, options)
     end
-    
-    def create_database(name = nil, options = {}); end # :nodoc:
-    
-    def drop_database(name = nil) # :nodoc:
+
+    # @private
+    def create_database(name = nil, options = {}); end
+
+    # @private
+    def drop_database(name = nil)
       execute('DROP ALL OBJECTS')
     end