class ActiveRecord::Base

def add_special_rails_stamps( column_names, array_of_attributes, options )
  AREXT_RAILS_COLUMNS[:create].each_pair do |key, blk|
    if self.column_names.include?(key)
      value = blk.call
      if index=column_names.index(key)
         # replace every instance of the array of attributes with our value
         array_of_attributes.each{ |arr| arr[index] = value }
      else
        column_names << key
        array_of_attributes.each { |arr| arr << value }
      end
    end
  end
  AREXT_RAILS_COLUMNS[:update].each_pair do |key, blk|
    if self.column_names.include?(key)
      value = blk.call
      if index=column_names.index(key)
         # replace every instance of the array of attributes with our value
         array_of_attributes.each{ |arr| arr[index] = value }
      else
        column_names << key
        array_of_attributes.each { |arr| arr << value }
      end
      
      if options[:on_duplicate_key_update]
        options[:on_duplicate_key_update] << key.to_sym if options[:on_duplicate_key_update].is_a?(Array)
        options[:on_duplicate_key_update][key.to_sym] = key.to_sym if options[:on_duplicate_key_update].is_a?(Hash)
      else
        options[:on_duplicate_key_update] = [ key.to_sym ]
      end
    end
  end
end

def establish_connection_with_activerecord_import(*args)
  establish_connection_without_activerecord_import(*args)
  ActiveSupport.run_load_hooks(:active_record_connection_established, connection)
end

def import( *args )
  options = { :validate=>true, :timestamps=>true }
  options.merge!( args.pop ) if args.last.is_a? Hash
  
  # assume array of model objects
  if args.last.is_a?( Array ) and args.last.first.is_a? ActiveRecord::Base
    if args.length == 2
      models = args.last
      column_names = args.first
    else
      models = args.first
      column_names = self.column_names.dup
    end
    
    array_of_attributes  = []
    models.each do |model|
      # this next line breaks sqlite.so with a segmentation fault
      # if model.new_record? || options[:on_duplicate_key_update]
        attributes = []
        column_names.each do |name| 
          attributes << model.send( "#{name}_before_type_cast" ) 
        end
        array_of_attributes << attributes
      # end
    end
    # supports 2-element array and array
  elsif args.size == 2 and args.first.is_a?( Array ) and args.last.is_a?( Array )
    column_names, array_of_attributes = args
  else
    raise ArgumentError.new( "Invalid arguments!" )
  end
  # Force the primary key col into the insert if it's not
  # on the list and we are using a sequence and stuff a nil
  # value for it into each row so the sequencer will fire later
  if !column_names.include?(primary_key) && sequence_name && connection.prefetch_primary_key?
     column_names << primary_key
     array_of_attributes.each { |a| a << nil }
  end
  is_validating = options.delete( :validate )
  # dup the passed in array so we don't modify it unintentionally
  array_of_attributes = array_of_attributes.dup
  # record timestamps unless disabled in ActiveRecord::Base
  if record_timestamps && options.delete( :timestamps )
     add_special_rails_stamps column_names, array_of_attributes, options
  end
  return_obj = if is_validating
    import_with_validations( column_names, array_of_attributes, options )
  else
    num_inserts = import_without_validations_or_callbacks( column_names, array_of_attributes, options )
    OpenStruct.new :failed_instances=>[], :num_inserts=>num_inserts
  end
  if options[:synchronize]
    synchronize( options[:synchronize] )
  end
  return_obj.num_inserts = 0 if return_obj.num_inserts.nil?
  return_obj
end

def import_from_table( options ) # :nodoc:
end

def import_with_validations( column_names, array_of_attributes, options={} )
  failed_instances = []

  # create instances for each of our column/value sets
  arr = validations_array_for_column_names_and_attributes( column_names, array_of_attributes )    
  # keep track of the instance and the position it is currently at. if this fails
  # validation we'll use the index to remove it from the array_of_attributes
  arr.each_with_index do |hsh,i|
    instance = new( hsh )
    if not instance.valid?
      array_of_attributes[ i ] = nil
      failed_instances << instance
    end    
  end
  array_of_attributes.compact!
  
  num_inserts = array_of_attributes.empty? ? 0 : import_without_validations_or_callbacks( column_names, array_of_attributes, options )
  OpenStruct.new :failed_instances=>failed_instances, :num_inserts => num_inserts
end

def import_without_validations_or_callbacks( column_names, array_of_attributes, options={} )
  escaped_column_names = quote_column_names( column_names )
  columns = []
  array_of_attributes.first.each_with_index { |arr,i| columns << columns_hash[ column_names[i] ] }
  
  if not supports_import?
    columns_sql = "(" + escaped_column_names.join( ',' ) + ")"
    insert_statements, values = [], []
    number_inserted = 0
    array_of_attributes.each do |arr|
      my_values = []
      arr.each_with_index do |val,j|
        if !sequence_name.blank? && column_names[j] == primary_key && val.nil?
           my_values << connection.next_value_for_sequence(sequence_name)
        else
           my_values << connection.quote( val, columns[j] )
        end
      end
      insert_statements << "INSERT INTO #{quoted_table_name} #{columns_sql} VALUES(" + my_values.join( ',' ) + ")"
      connection.execute( insert_statements.last )
      number_inserted += 1
    end
  else
    # generate the sql
    insert_sql = connection.multiple_value_sets_insert_sql( quoted_table_name, escaped_column_names, options )
    values_sql = connection.values_sql_for_column_names_and_attributes( columns, array_of_attributes )
    post_sql_statements = connection.post_sql_statements( quoted_table_name, options )
    
    # perform the inserts
    number_inserted = connection.insert_many( [ insert_sql, post_sql_statements ].flatten, 
                                              values_sql,
                                              "#{self.class.name} Create Many Without Validations Or Callbacks" )
  end
  number_inserted
end

def quote_column_names( names ) 
  names.map{ |name| connection.quote_column_name( name ) }
end

def supports_import?
  connection.supports_import?
rescue NoMethodError
  false
end

def supports_on_duplicate_key_update?
  connection.supports_on_duplicate_key_update?
rescue NoMethodError
  false
end

def validations_array_for_column_names_and_attributes( column_names, array_of_attributes ) # :nodoc:
  arr = []
  array_of_attributes.each do |attributes|
    c = 0
    hsh = attributes.inject( {} ){|hsh,attr| hsh[ column_names[c] ] = attr ; c+=1 ; hsh }
    arr << hsh
  end
  arr
end