activerecord-jdbc-adapter 1.2.5 → 1.2.8

data/lib/arjdbc/db2/connection_methods.rb

@@ -0,0 +1,18 @@
+class ActiveRecord::Base
+  class << self
+    def db2_connection(config)
+      config[:url] ||= begin
+        if config[:host] # Type 4 URL: jdbc:db2://server:port/database
+          config[:port] ||= 50000
+          "jdbc:db2://#{config[:host]}:#{config[:port]}/#{config[:database]}"
+        else # Type 2 URL: jdbc:db2:database
+          "jdbc:db2:#{config[:database]}"
+        end
+      end
+      config[:driver] ||= ::ArJdbc::DB2::DRIVER_NAME
+      config[:adapter_spec] = ::ArJdbc::DB2
+      jdbc_connection(config)
+    end
+    alias_method :jdbcdb2_connection, :db2_connection
+  end
+end

data/lib/arjdbc/derby/active_record_patch.rb

@@ -0,0 +1,12 @@
+# Needed because Rails is broken wrt to quoting of some values. 
+# Most databases are nice about it, but not Derby. 
+# The real issue is that you can't compare a CHAR value to a NUMBER column.
+ActiveRecord::Associations::ClassMethods.module_eval do
+  private
+  def select_limited_ids_list(options, join_dependency)
+    connection.select_all(
+      construct_finder_sql_for_association_limiting(options, join_dependency),
+      "#{name} Load IDs For Limited Eager Loading"
+    ).collect { |row| connection.quote(row[primary_key], columns_hash[primary_key]) }.join(", ")
+  end
+end

data/lib/arjdbc/derby/adapter.rb

@@ -1,51 +1,57 @@
 require 'arjdbc/jdbc/missing_functionality_helper'
 
-module ::ArJdbc
+module ArJdbc
   module Derby
-    def self.column_selector
-      [/derby/i, lambda {|cfg,col| col.extend(::ArJdbc::Derby::Column)}]
-    end
-
-    def self.monkey_rails
-      unless defined?(@already_monkeyd)
-        # Needed because Rails is broken wrt to quoting of
-        # some values. Most databases are nice about it,
-        # but not Derby. The real issue is that you can't
-        # compare a CHAR value to a NUMBER column.
-        ::ActiveRecord::Associations::ClassMethods.module_eval do
-          private
-
-          def select_limited_ids_list(options, join_dependency)
-            connection.select_all(
-                                  construct_finder_sql_for_association_limiting(options, join_dependency),
-                                  "#{name} Load IDs For Limited Eager Loading"
-                                  ).collect { |row| connection.quote(row[primary_key], columns_hash[primary_key]) }.join(", ")
-          end
-        end
-
-        @already_monkeyd = true
-      end
-    end
 
     def self.extended(adapter)
-      monkey_rails
+      require 'arjdbc/derby/active_record_patch'
       adapter.configure_connection
     end
 
     def self.included(*args)
-      monkey_rails
+      require 'arjdbc/derby/active_record_patch'
     end
 
+    def self.column_selector
+      [ /derby/i, lambda { |cfg, column| column.extend(::ArJdbc::Derby::Column) } ]
+    end
+    
     def configure_connection
-      execute("SET ISOLATION = SERIALIZABLE")   # This must be done or SELECT...FOR UPDATE won't work how we expect
+      execute("SET ISOLATION = SERIALIZABLE")
+      # must be done or SELECT...FOR UPDATE won't work how we expect
     end
 
     module Column
+      
+      private
+
+      def extract_limit(sql_type)
+        case @sql_type = sql_type.downcase
+        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 # DOUBLE PRECISION
+        when /^real/i        then @sql_type = 'real'; limit = 4
+        when /^integer/i     then @sql_type = 'integer'; limit = 4
+        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
+          limit = super
+          # handle maximum length for a VARCHAR string :
+          limit = 32672 if ! limit && @sql_type.index('varchar') == 0
+        end
+        limit
+      end
+      
       def simplified_type(field_type)
         case field_type
-        when /smallint/i  then :boolean
-        when /real/i      then :float
-        when /^timestamp/i then :datetime
+        when /^smallint/i    then :boolean
+        when /^bigint|int/i  then :integer
+        when /^real|double/i then :float
+        when /^dec/i         then # DEC is a DECIMAL alias
+          extract_scale(field_type) == 0 ? :integer : :decimal
+        when /^timestamp/i   then :datetime
         else
           super
         end
@@ -53,20 +59,26 @@ module ::ArJdbc
 
       # Post process default value from JDBC into a Rails-friendly format (columns{-internal})
       def default_value(value)
-        # 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 =~ /^'(.*)'$/
         return nil if value == "GENERATED_BY_DEFAULT"
         value
       end
+      
     end
 
-    def adapter_name #:nodoc:
-      'Derby'
+    ADAPTER_NAME = 'Derby'
+    
+    def adapter_name # :nodoc:
+      ADAPTER_NAME
     end
 
     def self.arel2_visitors(config)
       require 'arel/visitors/derby'
-      {}.tap {|v| %w(derby jdbcderby).each {|a| v[a] = ::Arel::Visitors::Derby } }
+      {
+        'derby' => ::Arel::Visitors::Derby,
+        'jdbcderby' => ::Arel::Visitors::Derby,
+      }
     end
 
     include ArJdbc::MissingFunctionalityHelper
@@ -75,28 +87,50 @@ module ::ArJdbc
       128
     end
 
-    # Convert the specified column type to a SQL string.
-    # In Derby, the following cannot specify a limit:
-    # - integer
-    # - boolean (smallint)
-    # - datetime (timestamp)
-    # - date
-    def type_to_sql(type, limit = nil, precision = nil, scale = nil) #:nodoc:
-      return super unless [:integer, :boolean, :timestamp, :datetime, :date].include? type
-
-      native = native_database_types[type.to_s.downcase.to_sym]
-      native.is_a?(Hash) ? native[:name] : native
+    NATIVE_DATABASE_TYPES = {
+      :primary_key => "int GENERATED BY DEFAULT AS identity NOT NULL PRIMARY KEY",
+      :string => { :name => "varchar", :limit => 255 },
+      :text => { :name => "clob" }, # 2,147,483,647
+      :binary => { :name => "blob" }, # 2,147,483,647
+      :float => { :name => "float", :limit => 8 }, # DOUBLE PRECISION
+      :decimal => { :name => "decimal", :precision => 5, :scale => 0 }, # defaults
+      :numeric => { :name => "decimal", :precision => 5, :scale => 0 }, # defaults
+      :integer => { :name => "integer", :limit => 4 },
+      :smallint => { :name => "smallint", :limit => 2 },
+      :bigint => { :name => "bigint", :limit => 8 },
+      :real => { :name => "real", :limit => 4 },
+      :double => { :name => "double", :limit => 8 },
+      :date => { :name => "date" },
+      :time => { :name => "time" },
+      :datetime => { :name => "timestamp" },
+      :timestamp => { :name => "timestamp" },
+      :boolean => { :name => "smallint" },
+    }
+    
+    def native_database_types
+      super.merge NATIVE_DATABASE_TYPES
+    end
+    
+    def modify_types(types)
+      super(types)
+      types[:primary_key] = NATIVE_DATABASE_TYPES[:primary_key]
+      [ :string, :float, :decimal, :numeric, :integer, 
+        :smallint, :bigint, :real, :double ].each do |type|
+        types[type] = NATIVE_DATABASE_TYPES[type].dup
+      end
+      types[:boolean] = NATIVE_DATABASE_TYPES[:boolean].dup
+      types
     end
+    
+    # in Derby, the following cannot specify a limit :
+    NO_LIMIT_TYPES = [ :integer, :boolean, :timestamp, :datetime, :date, :time ] # :nodoc:
+    
+    # Convert the specified column type to a SQL string.
+    def type_to_sql(type, limit = nil, precision = nil, scale = nil) # :nodoc:
+      return super unless NO_LIMIT_TYPES.include?(t = type.to_s.downcase.to_sym)
 
-    def modify_types(tp)
-      tp[:primary_key] = "int generated by default as identity NOT NULL PRIMARY KEY"
-      tp[:string][:limit] = 256
-      tp[:integer][:limit] = nil
-      tp[:boolean] = {:name => "smallint"}
-      tp[:datetime] = {:name => "timestamp", :limit => nil}
-      tp[:timestamp][:limit] = nil
-      tp[:date][:limit] = nil
-      tp
+      native_type = NATIVE_DATABASE_TYPES[t]
+      native_type.is_a?(Hash) ? native_type[:name] : native_type
     end
 
     # Override default -- fix case where ActiveRecord passes :default => nil, :null => true
@@ -106,10 +140,6 @@ module ::ArJdbc
       super
     end
 
-    def classes_for_table_name(table)
-      ActiveRecord::Base.send(:subclasses).select {|klass| klass.table_name == table}
-    end
-
     # Set the sequence to the max value of the table's column.
     def reset_sequence!(table, column, sequence = nil)
       mpk = select_value("SELECT MAX(#{quote_column_name(column)}) FROM #{quote_table_name(table)}")
@@ -125,6 +155,11 @@ module ::ArJdbc
       end
     end
 
+    def classes_for_table_name(table)
+      ActiveRecord::Base.send(:subclasses).select { |klass| klass.table_name == table }
+    end
+    private :classes_for_table_name
+    
     def remove_index(table_name, options) #:nodoc:
       execute "DROP INDEX #{index_name(table_name, options)}"
     end
@@ -133,44 +168,6 @@ module ::ArJdbc
       execute "RENAME TABLE #{quote_table_name(name)} TO #{quote_table_name(new_name)}"
     end
 
-    AUTO_INC_STMT2 = "SELECT AUTOINCREMENTSTART, AUTOINCREMENTINC, COLUMNNAME, REFERENCEID, COLUMNDEFAULT FROM SYS.SYSCOLUMNS WHERE REFERENCEID = (SELECT T.TABLEID FROM SYS.SYSTABLES T WHERE T.TABLENAME = '%s') AND COLUMNNAME = '%s'"
-
-    def add_quotes(name)
-      return name unless name
-      %Q{"#{name}"}
-    end
-
-    def strip_quotes(str)
-      return str unless str
-      return str unless /^(["']).*\1$/ =~ str
-      str[1..-2]
-    end
-
-    def expand_double_quotes(name)
-      return name unless name && name['"']
-      name.gsub(/"/,'""')
-    end
-
-    def auto_increment_stmt(tname, cname)
-      stmt = AUTO_INC_STMT2 % [tname, strip_quotes(cname)]
-      data = execute(stmt).first
-      if data
-        start = data['autoincrementstart']
-        if start
-          coldef = ""
-          coldef << " GENERATED " << (data['columndefault'].nil? ? "ALWAYS" : "BY DEFAULT ")
-          coldef << "AS IDENTITY (START WITH "
-          coldef << start
-          coldef << ", INCREMENT BY "
-          coldef << data['autoincrementinc']
-          coldef << ")"
-          return coldef
-        end
-      end
-      ""
-    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)
@@ -178,16 +175,18 @@ module ::ArJdbc
     end
 
     def execute(sql, name = nil, binds = [])
-      sql = extract_sql(sql)
+      sql = to_sql(sql)
       if sql =~ /\A\s*(UPDATE|INSERT)/i
-        i = sql =~ /\swhere\s/im
-        if i
-          sql[i..-1] = sql[i..-1].gsub(/!=\s*NULL/, 'IS NOT NULL').gsub(/=\sNULL/i, 'IS NULL')
+        if ( i = sql =~ /\sWHERE\s/im )
+          where_part = sql[i..-1]; sql = sql.dup
+          where_part.gsub!(/!=\s*NULL/, 'IS NOT NULL')
+          where_part.gsub!(/=\sNULL/i, 'IS NULL')
+          sql[i..-1] = where_part
         end
       else
-        sql.gsub!(/= NULL/i, 'IS NULL')
+        sql = sql.gsub(/=\sNULL/i, 'IS NULL')
       end
-      super
+      super(sql, name, binds)
     end
 
     # SELECT DISTINCT clause for a given set of columns and a given ORDER BY clause.
@@ -212,42 +211,38 @@ module ::ArJdbc
       sql
     end
 
-    SIZEABLE = %w(VARCHAR CLOB BLOB)
+    SIZEABLE = %w(VARCHAR CLOB BLOB) # :nodoc:
 
-    def structure_dump #:nodoc:
-      definition=""
-      rs = @connection.connection.meta_data.getTables(nil,nil,nil,["TABLE"].to_java(:string))
-      while rs.next
-        tname = rs.getString(3)
-        definition << "CREATE TABLE #{tname} (\n"
-        rs2 = @connection.connection.meta_data.getColumns(nil,nil,tname,nil)
+    def structure_dump # :nodoc:
+      definition = ""
+      meta_data = @connection.connection.meta_data
+      tables_rs = meta_data.getTables(nil, nil, nil, ["TABLE"].to_java(:string))
+      while tables_rs.next
+        table_name = tables_rs.getString(3)
+        definition << "CREATE TABLE #{table_name} (\n"
+        columns_rs = meta_data.getColumns(nil, nil, table_name, nil)
         first_col = true
-        while rs2.next
-          col_name = add_quotes(rs2.getString(4));
-          default = ""
-          d1 = rs2.getString(13)
+        while columns_rs.next
+          column_name = add_quotes(columns_rs.getString(4));
+          default = ''
+          d1 = columns_rs.getString(13)
           if d1 =~ /^GENERATED_/
-            default = auto_increment_stmt(tname, col_name)
+            default = auto_increment_stmt(table_name, column_name)
           elsif d1
             default = " DEFAULT #{d1}"
           end
 
-          type = rs2.getString(6)
-          col_size = rs2.getString(7)
-          nulling = (rs2.getString(18) == 'NO' ? " NOT NULL" : "")
-          create_col_string = add_quotes(expand_double_quotes(strip_quotes(col_name))) +
-            " " +
-            type +
-            (SIZEABLE.include?(type) ? "(#{col_size})" : "") +
-            nulling +
-            default
-          if !first_col
-            create_col_string = ",\n #{create_col_string}"
-          else
-            create_col_string = " #{create_col_string}"
-          end
-
-          definition << create_col_string
+          type = columns_rs.getString(6)
+          column_size = columns_rs.getString(7)
+          nulling = (columns_rs.getString(18) == 'NO' ? " NOT NULL" : "")
+          create_column = add_quotes(expand_double_quotes(strip_quotes(column_name)))
+          create_column << " #{type}"
+          create_column << ( SIZEABLE.include?(type) ? "(#{column_size})" : "" )
+          create_column << nulling
+          create_column << default
+          
+          create_column = first_col ? " #{create_column}" : ",\n #{create_column}"
+          definition << create_column
 
           first_col = false
         end
@@ -255,10 +250,35 @@ module ::ArJdbc
       end
       definition
     end
-
-    def remove_column(table_name, column_name)
-      execute "ALTER TABLE #{quote_table_name(table_name)} DROP COLUMN #{quote_column_name(column_name)} RESTRICT"
+    
+    def remove_column(table_name, *column_names) # :nodoc:
+      for column_name in column_names.flatten
+        execute "ALTER TABLE #{quote_table_name(table_name)} DROP COLUMN #{quote_column_name(column_name)} RESTRICT"
+      end
     end
+    
+    AUTO_INC_STMT2 = "" + 
+    "SELECT AUTOINCREMENTSTART, AUTOINCREMENTINC, COLUMNNAME, REFERENCEID, COLUMNDEFAULT " + 
+    "FROM SYS.SYSCOLUMNS WHERE REFERENCEID = " + 
+    "(SELECT T.TABLEID FROM SYS.SYSTABLES T WHERE T.TABLENAME = '%s') AND COLUMNNAME = '%s'"
+    
+    def auto_increment_stmt(tname, cname)
+      stmt = AUTO_INC_STMT2 % [ tname, strip_quotes(cname) ]
+      if data = execute(stmt).first
+        if start = data['autoincrementstart']
+          coldef = ""
+          coldef << " GENERATED " << (data['columndefault'].nil? ? "ALWAYS" : "BY DEFAULT ")
+          coldef << "AS IDENTITY (START WITH "
+          coldef << start
+          coldef << ", INCREMENT BY "
+          coldef << data['autoincrementinc']
+          coldef << ")"
+          return coldef
+        end
+      end
+      ""
+    end
+    private :auto_increment_stmt
 
     # Notes about changing in Derby:
     #    http://db.apache.org/derby/docs/10.2/ref/rrefsqlj81859.html#rrefsqlj81859__rrefsqlj37860)
@@ -266,8 +286,8 @@ module ::ArJdbc
     # We support changing columns using the strategy outlined in:
     #    https://issues.apache.org/jira/browse/DERBY-1515
     #
-    # This feature has not made it into a formal release and is not in Java 6.  We will
-    # need to conditionally support this somehow (supposed to arrive for 10.3.0.0)
+    # This feature has not made it into a formal release and is not in Java 6.
+    # We will need to conditionally support this (supposed to arrive for 10.3.0.0).
     def change_column(table_name, column_name, type, options = {})
       # null/not nulling is easy, handle that separately
       if options.include?(:null)
@@ -307,7 +327,7 @@ module ::ArJdbc
       @connection.primary_keys table_name.to_s.upcase
     end
 
-    def columns(table_name, name=nil)
+    def columns(table_name, name = nil)
       @connection.columns_internal(table_name.to_s, name, derby_schema)
     end
 
@@ -316,43 +336,45 @@ module ::ArJdbc
     end
 
     def recreate_database(db_name, options = {})
-      tables.each do |t|
-        drop_table t
-      end
+      tables.each { |table| drop_table table }
     end
 
-    def quote_column_name(name) #:nodoc:
+    def quote_column_name(name) # :nodoc:
       %Q{"#{name.to_s.upcase.gsub(/\"/, '""')}"}
     end
 
-    def quoted_true
-      '1'
+    def add_limit_offset!(sql, options) # :nodoc:
+      sql << " OFFSET #{options[:offset]} ROWS" if options[:offset]
+      # ROWS/ROW and FIRST/NEXT mean the same
+      sql << " FETCH FIRST #{options[:limit]} ROWS ONLY" if options[:limit]
     end
 
-    def quoted_false
-      '0'
+    private
+    
+    def add_quotes(name)
+      return name unless name
+      %Q{"#{name}"}
     end
 
-    def add_limit_offset!(sql, options) #:nodoc:
-      if options[:offset]
-        sql << " OFFSET #{options[:offset]} ROWS"
-      end
-      if options[:limit]
-        #ROWS/ROW and FIRST/NEXT mean the same
-        sql << " FETCH FIRST #{options[:limit]} ROWS ONLY"
-      end
+    def strip_quotes(str)
+      return str unless str
+      return str unless /^(["']).*\1$/ =~ str
+      str[1..-2]
     end
 
-    private
+    def expand_double_quotes(name)
+      return name unless name && name['"']
+      name.gsub('"', '""')
+    end
+    
     # Derby appears to define schemas using the username
     def derby_schema
       if @config.has_key?(:schema)
-        config[:schema]
+        @config[:schema]
       else
         (@config[:username] && @config[:username].to_s) || ''
       end
     end
+    
   end
 end
-
-