activerecord-jdbc-adapter 1.3.13 → 1.3.14

data/lib/arjdbc/db2/adapter.rb

@@ -187,28 +187,30 @@ module ArJdbc
       select_value("SELECT NEXT VALUE FOR #{sequence_name} FROM sysibm.sysdummy1")
     end
 
-    def create_table(name, options = {})
+    def create_table(name, options = {}, &block)
       if zos?
-        zos_create_table(name, options)
+        zos_create_table(name, options, &block)
       else
-        super(name, options)
+        super
       end
     end
 
     def zos_create_table(name, options = {})
-      # NOTE: this won't work for 4.0 - need to pass different initialize args :
-      table_definition = TableDefinition.new(self)
+      table_definition = new_table_definition TableDefinition, name, options[:temporary], options[:options], options[:as]
+
       unless options[:id] == false
         table_definition.primary_key(options[:primary_key] || primary_key(name))
       end
 
-      yield table_definition
+      yield table_definition if block_given?
 
       # Clobs in DB2 Host have to be created after the Table with an auxiliary Table.
-      # First: Save them for later in Array "clobs"
-      clobs = table_definition.columns.select { |x| x.type.to_s == "text" }
-      # Second: and delete them from the original Colums-Array
-      table_definition.columns.delete_if { |x| x.type.to_s == "text" }
+      clob_columns = []
+      table_definition.columns.delete_if do |column|
+        if column.type && column.type.to_sym == :text
+          clob_columns << column; true
+        end
+      end
 
       drop_table(name, options) if options[:force] && table_exists?(name)
 
@@ -217,11 +219,8 @@ module ArJdbc
       create_sql << table_definition.to_sql
       create_sql << ") #{options[:options]}"
       if @config[:database] && @config[:tablespace]
-        in_db_table_space = " IN #{@config[:database]}.#{@config[:tablespace]}"
-      else
-        in_db_table_space = ''
+        create_sql << " IN #{@config[:database]}.#{@config[:tablespace]}"
       end
-      create_sql << in_db_table_space
 
       execute create_sql
 
@@ -232,14 +231,12 @@ module ArJdbc
       #primary_column = options[:id] == true ? 'id' : options[:primary_key]
       #add_index(name, (primary_column || 'id').to_s, :unique => true)
 
-      clobs.each do |clob_column|
+      clob_columns.each do |clob_column|
         column_name = clob_column.name.to_s
-        execute "ALTER TABLE #{name + ' ADD COLUMN ' + column_name + ' clob'}"
-        clob_table_name = name + '_' + column_name + '_CD_'
+        execute "ALTER TABLE #{name} ADD COLUMN #{column_name} clob"
+        clob_table_name = "#{name}_#{column_name}_CD_"
         if @config[:database] && @config[:lob_tablespaces]
           in_lob_table_space = " IN #{@config[:database]}.#{@config[:lob_tablespaces][name.split(".")[1]]}"
-        else
-          in_lob_table_space = ''
         end
         execute "CREATE AUXILIARY TABLE #{clob_table_name} #{in_lob_table_space} STORES #{name} COLUMN #{column_name}"
         execute "CREATE UNIQUE INDEX #{clob_table_name} ON #{clob_table_name};"
@@ -350,6 +347,14 @@ module ArJdbc
       super(type, limit, precision, scale)
     end
 
+    # @private
+    VALUES_DEFAULT = 'VALUES ( DEFAULT )' # NOTE: Arel::Visitors::DB2 uses this
+
+    # @override
+    def empty_insert_statement_value
+      VALUES_DEFAULT # won't work as DB2 needs to know the column count
+    end
+
     def add_column(table_name, column_name, type, options = {})
       # The keyword COLUMN allows to use reserved names for columns (ex: date)
       add_column_sql = "ALTER TABLE #{quote_table_name(table_name)} ADD COLUMN #{quote_column_name(column_name)} #{type_to_sql(type, options[:limit], options[:precision], options[:scale])}"
@@ -393,7 +398,7 @@ module ArJdbc
 
       limit = limit.to_i
       if offset
-        replace_limit_offset_with_ordering(sql, limit, offset)
+        replace_limit_offset_with_ordering!(sql, limit, offset)
       else
         if limit == 1
           sql << " FETCH FIRST ROW ONLY"
@@ -404,42 +409,48 @@ module ArJdbc
       end
     end
 
-    # @private only used from {Arel::Visitors::DB2}
-    def replace_limit_offset_for_arel!( query, sql )
-      replace_limit_offset_with_ordering sql, query.limit.value, query.offset && query.offset.value, query.orders
-    end
-
-    def replace_limit_offset_with_ordering( sql, limit, offset, orders=[] )
-      sql.sub!(/SELECT/i, "SELECT B.* FROM (SELECT A.*, row_number() over (#{build_ordering(orders)}) AS internal$rownum FROM (SELECT")
+    # @private used from {Arel::Visitors::DB2}
+    def replace_limit_offset_with_ordering!(sql, limit, offset, orders = nil)
+      over_order_by = nil # NOTE: orders matching got reverted as it was not complete and there were no case covering it ...
+      sql.sub!(/SELECT/i, "SELECT B.* FROM (SELECT A.*, row_number() OVER (#{over_order_by}) AS internal$rownum FROM (SELECT")
       sql << ") A ) B WHERE B.internal$rownum > #{offset} AND B.internal$rownum <= #{limit + offset}"
       sql
     end
-    private :replace_limit_offset_with_ordering
-
-    def build_ordering( orders )
-      return '' unless orders.size > 0
-      # need to remove the library/table names from the orderings because we are not really ordering by them anymore
-      # we are actually ordering by the results of a query where the result set has the same column names
-      orders = orders.map do |o|
-        # need to keep in mind that the order clause could be wrapped in a function
-        matches = /(?:\w+\(|\s)*(\S+)(?:\)|\s)*/.match(o)
-        o = o.gsub( matches[1], matches[1].split('.').last ) if matches
-        o
-      end
-      "ORDER BY " + orders.join( ', ')
-    end
-    private :build_ordering
 
     # @deprecated seems not sued nor tested ?!
     def runstats_for_table(tablename, priority = 10)
       @connection.execute_update "call sysproc.admin_cmd('RUNSTATS ON TABLE #{tablename} WITH DISTRIBUTION AND DETAILED INDEXES ALL UTIL_IMPACT_PRIORITY #{priority}')"
     end
 
-    def select(sql, name, binds)
-      # DB2 does not like "= NULL", "!= NULL", or "<> NULL".
-      exec_query(to_sql(sql.gsub(/(!=|<>)\s*null/i, "IS NOT NULL").gsub(/=\s*null/i, "IS NULL"), binds), name, binds)
+    if ::ActiveRecord::VERSION::MAJOR >= 4
+
+    def select(sql, name = nil, binds = [])
+      exec_query(to_sql(suble_null_test(sql), binds), name, binds)
+    end
+
+    else
+
+    def select(sql, name = nil, binds = [])
+      exec_query_raw(to_sql(suble_null_test(sql), binds), name, binds)
+    end
+
     end
 
+    # @private
+    IS_NOT_NULL = /(!=|<>)\s*NULL/i
+    # @private
+    IS_NULL = /=\s*NULL/i
+
+    def suble_null_test(sql)
+      return sql unless sql.is_a?(String)
+      # DB2 does not like "= NULL", "!= NULL", or "<> NULL" :
+      sql = sql.dup
+      sql.gsub! IS_NOT_NULL, 'IS NOT NULL'
+      sql.gsub! IS_NULL, 'IS NULL'
+      sql
+    end
+    private :suble_null_test
+
     def add_index(table_name, column_name, options = {})
       if ! zos? || ( table_name.to_s == ActiveRecord::Migrator.schema_migrations_table_name.to_s )
         column_name = column_name.to_s if column_name.is_a?(Symbol)
@@ -654,14 +665,14 @@ module ArJdbc
     def db2_schema
       @db2_schema = false unless defined? @db2_schema
       return @db2_schema if @db2_schema != false
+      schema = config[:schema]
       @db2_schema =
-        if config[:schema].present?
-          config[:schema]
-        elsif config[:jndi].present?
+        if schema then schema
+        elsif config[:jndi] || config[:data_source]
           nil # let JNDI worry about schema
         else
           # LUW implementation uses schema name of username by default
-          config[:username].presence || ENV['USER']
+          config[:username] || ENV['USER']
         end
     end
 
@@ -681,4 +692,4 @@ module ActiveRecord::ConnectionAdapters
     include ::ArJdbc::DB2::Column
   end
 
-end
+end

data/lib/arjdbc/derby/adapter.rb

@@ -248,7 +248,7 @@ module ArJdbc
 
     # @override
     def empty_insert_statement_value
-      'VALUES ( DEFAULT )' # won't work as Derby does need to know the columns count
+      ::Arel::Visitors::Derby::VALUES_DEFAULT # Derby needs to know the columns
     end
 
     # Set the sequence to the max value of the table's column.

data/lib/arjdbc/jdbc/type_cast.rb

@@ -104,9 +104,10 @@ module ActiveRecord::ConnectionAdapters
             return nil unless time
 
             time -= offset
-            Base.default_timezone == :utc ? time : time.getlocal
+            ActiveRecord::Base.default_timezone == :utc ? time : time.getlocal
           else
-            Time.public_send(Base.default_timezone, year, mon, mday, hour, min, sec, microsec) rescue nil
+            timezone = ActiveRecord::Base.default_timezone
+            Time.public_send(timezone, year, mon, mday, hour, min, sec, microsec) rescue nil
           end
         end
 

data/lib/arjdbc/mysql/adapter.rb

@@ -390,6 +390,76 @@ module ArJdbc
       columns
     end
 
+    if defined? ::ActiveRecord::ConnectionAdapters::AbstractAdapter::SchemaCreation
+
+    class SchemaCreation < ::ActiveRecord::ConnectionAdapters::AbstractAdapter::SchemaCreation
+
+      # @private
+      def visit_AddColumn(o)
+        add_column_position!(super, column_options(o))
+      end
+
+      # @private re-defined since AR 4.1
+      def visit_ChangeColumnDefinition(o)
+        column = o.column
+        options = o.options
+        sql_type = type_to_sql(o.type, options[:limit], options[:precision], options[:scale])
+        change_column_sql = "CHANGE #{quote_column_name(column.name)} #{quote_column_name(options[:name])} #{sql_type}"
+        add_column_options!(change_column_sql, options.merge(:column => column))
+        add_column_position!(change_column_sql, options)
+      end
+
+      # @private since AR 4.2
+      def visit_DropForeignKey(name)
+        "DROP FOREIGN KEY #{name}"
+      end
+
+      # @private since AR 4.2
+      def visit_TableDefinition(o)
+        name = o.name
+        create_sql = "CREATE#{' TEMPORARY' if o.temporary} TABLE #{quote_table_name(name)} "
+
+        statements = o.columns.map { |c| accept c }
+        statements.concat(o.indexes.map { |column_name, options| index_in_create(name, column_name, options) })
+
+        create_sql << "(#{statements.join(', ')}) " if statements.present?
+        create_sql << "#{o.options}"
+        create_sql << " AS #{@conn.to_sql(o.as)}" if o.as
+        create_sql
+      end if AR42
+
+      private
+
+      def add_column_position!(sql, options)
+        if options[:first]
+          sql << " FIRST"
+        elsif options[:after]
+          sql << " AFTER #{quote_column_name(options[:after])}"
+        end
+        sql
+      end
+
+      def column_options(o)
+        column_options = {}
+        column_options[:null] = o.null unless o.null.nil?
+        column_options[:default] = o.default unless o.default.nil?
+        column_options[:column] = o
+        column_options[:first] = o.first
+        column_options[:after] = o.after
+        column_options
+      end
+
+      def index_in_create(table_name, column_name, options)
+        index_name, index_type, index_columns, index_options, index_algorithm, index_using = @conn.add_index_options(table_name, column_name, options)
+        "#{index_type} INDEX #{quote_column_name(index_name)} #{index_using} (#{index_columns})#{index_options} #{index_algorithm}"
+      end
+
+    end
+
+    def schema_creation; SchemaCreation.new self end
+
+    end
+
     # @private
     def recreate_database(name, options = {})
       drop_database(name)
@@ -417,7 +487,7 @@ module ArJdbc
 
     # @override
     def create_table(name, options = {})
-      super(name, {:options => "ENGINE=InnoDB DEFAULT CHARSET=utf8"}.merge(options))
+      super(name, { :options => "ENGINE=InnoDB" }.merge(options))
     end
 
     def drop_table(table_name, options = {})
@@ -572,7 +642,7 @@ module ArJdbc
         when 0..0xfff; "varbinary(#{limit})"
         when nil; "blob"
         when 0x1000..0xffffffff; "blob(#{limit})"
-        else raise(ActiveRecordError, "No binary type has character length #{limit}")
+        else raise ActiveRecord::ActiveRecordError, "No binary type has character length #{limit}"
         end
       when 'integer'
         case limit
@@ -581,7 +651,7 @@ module ArJdbc
         when 3; 'mediumint'
         when nil, 4, 11; 'int(11)' # compatibility with MySQL default
         when 5..8; 'bigint'
-        else raise(ActiveRecordError, "No integer type has byte size #{limit}")
+        else raise ActiveRecord::ActiveRecordError, "No integer type has byte size #{limit}"
         end
       when 'text'
         case limit
@@ -589,7 +659,7 @@ module ArJdbc
         when nil, 0x100..0xffff; 'text'
         when 0x10000..0xffffff; 'mediumtext'
         when 0x1000000..0xffffffff; 'longtext'
-        else raise(ActiveRecordError, "No text type has character length #{limit}")
+        else raise ActiveRecord::ActiveRecordError, "No text type has character length #{limit}"
         end
       else
         super
@@ -602,6 +672,7 @@ module ArJdbc
     end
 
     protected
+
     def quoted_columns_for_index(column_names, options = {})
       length = options[:length] if options.is_a?(Hash)
 

data/lib/arjdbc/mysql/bulk_change_table.rb

@@ -2,10 +2,14 @@ module ArJdbc
   module MySQL
     module BulkChangeTable
 
+      # @private
+      AR41 = ActiveRecord::VERSION::STRING >= '4.1'
+
+      # @private
+      ChangeColumnDefinition = ActiveRecord::ConnectionAdapters::ChangeColumnDefinition if AR41
+
       # @override
-      def supports_bulk_alter?
-        true
-      end
+      def supports_bulk_alter?; true end
 
       def bulk_change_table(table_name, operations)
         sqls = operations.map do |command, args|
@@ -30,7 +34,13 @@ module ArJdbc
         add_column_options!(add_column_sql, options)
         add_column_position!(add_column_sql, options)
         add_column_sql
-      end
+      end unless AR41
+
+      def add_column_sql(table_name, column_name, type, options = {})
+        td = create_table_definition table_name, options[:temporary], options[:options]
+        cd = td.new_column_definition(column_name, type, options)
+        schema_creation.visit_AddColumn cd
+      end if AR41
 
       def change_column_sql(table_name, column_name, type, options = {})
         column = column_for(table_name, column_name)
@@ -47,7 +57,22 @@ module ArJdbc
         add_column_options!(change_column_sql, options)
         add_column_position!(change_column_sql, options)
         change_column_sql
-      end
+      end unless AR41
+
+      def change_column_sql(table_name, column_name, type, options = {})
+        column = column_for(table_name, column_name)
+
+        unless options_include_default?(options)
+          options[:default] = column.default
+        end
+
+        unless options.has_key?(:null)
+          options[:null] = column.null
+        end
+
+        options[:name] = column.name
+        schema_creation.accept ChangeColumnDefinition.new column, type, options
+      end if AR41
 
       def rename_column_sql(table_name, column_name, new_column_name)
         options = {}
@@ -64,7 +89,22 @@ module ArJdbc
         rename_column_sql = "CHANGE #{quote_column_name(column_name)} #{quote_column_name(new_column_name)} #{current_type}"
         add_column_options!(rename_column_sql, options)
         rename_column_sql
-      end
+      end unless AR41
+
+      def rename_column_sql(table_name, column_name, new_column_name)
+        options = { :name => new_column_name }
+
+        if column = columns(table_name).find { |c| c.name == column_name.to_s }
+          options[:default] = column.default
+          options[:null] = column.null
+          options[:auto_increment] = (column.extra == "auto_increment")
+        else
+          raise ActiveRecordError, "No such column: #{table_name}.#{column_name}"
+        end
+
+        current_type = select_one("SHOW COLUMNS FROM #{quote_table_name(table_name)} LIKE '#{column_name}'", 'SCHEMA')["Type"]
+        schema_creation.accept ChangeColumnDefinition.new column, current_type, options
+      end if AR41
 
       def remove_column_sql(table_name, column_name, type = nil, options = {})
         "DROP #{quote_column_name(column_name)}"
@@ -84,8 +124,8 @@ module ArJdbc
         "DROP INDEX #{index_name}"
       end
 
-      def add_timestamps_sql(table_name)
-        [add_column_sql(table_name, :created_at, :datetime), add_column_sql(table_name, :updated_at, :datetime)]
+      def add_timestamps_sql(table_name, options = {})
+        [add_column_sql(table_name, :created_at, :datetime, options), add_column_sql(table_name, :updated_at, :datetime, options)]
       end
 
       def remove_timestamps_sql(table_name)

data/lib/arjdbc/oracle/adapter.rb

@@ -140,6 +140,7 @@ module ArJdbc
     def table_name_length;  IDENTIFIER_LENGTH; end
     def index_name_length;  IDENTIFIER_LENGTH; end
     def column_name_length; IDENTIFIER_LENGTH; end
+    def sequence_name_length; IDENTIFIER_LENGTH end
 
     def default_sequence_name(table_name, column = nil)
       # TODO: remove schema prefix if present (before truncating)

data/lib/arjdbc/oracle/column.rb

@@ -17,7 +17,7 @@ module ArJdbc
       def primary=(value)
         super
         @type = :integer if value && @sql_type =~ /^NUMBER$/i
-      end
+      end if ::ActiveRecord::VERSION::STRING < '4.2'
 
       def type_cast(value)
         return nil if value.nil?

data/lib/arjdbc/postgresql/adapter.rb

@@ -988,7 +988,10 @@ module ArJdbc
       pk, seq = pk_and_sequence_for(new_name)
       if seq == "#{table_name}_#{pk}_seq"
         new_seq = "#{new_name}_#{pk}_seq"
+        idx = "#{table_name}_pkey"
+        new_idx = "#{new_name}_pkey"
         execute "ALTER TABLE #{quote_table_name(seq)} RENAME TO #{quote_table_name(new_seq)}"
+        execute "ALTER INDEX #{quote_table_name(idx)} RENAME TO #{quote_table_name(new_idx)}"
       end
       rename_table_indexes(table_name, new_name) if respond_to?(:rename_table_indexes) # AR-4.0 SchemaStatements
     end