Inserimento di record in blocco nella tabella dei record attivi

Question

Ho scoperto che le mie istruzioni Model.create! richiedevano molto tempo per essere eseguite quando ho aggiunto un numero elevato di record contemporaneamente. Guardato a ActiveRecord-Import ma non ha funzionato con una serie di hash (che è quello che ho e che penso sia piuttosto comune). Come posso migliorare le prestazioni?

Answer 1

ho iniziato a correre in problemi con un gran numero di record (> 10000), così ho modificato il codice per lavorare in gruppi di 1000 record alla volta. Questo è il link per il nuovo codice:

https://gist.github.com/jackrg/76ade1724bd816292e4e

Answer 2

Grazie a Chris Heald @cheald per il suo article 2009, con mi ha mostrato che il modo migliore per andare era il comando di inserimento multi-riga.

Aggiunto il seguente codice al mio file initializers/active_record.rb, cambiato le mie chiamate Model.create!(...) a Model.import!(...) e via va. Un paio di avvertimenti:

1) Non convalida i dati.
2) Si utilizza la forma del comando SQL INSERT che si legge come ...

INSERT INTO <table> (field-1, field-2, ...) 
     VALUES (value-1-1, value-1-2, ...), (value-2-1, value-2-2, ...), ...` 

... che non può essere la sintassi corretta per tutti i database, ma funziona con Postgres. Non sarebbe difficile modificare il codice per la sintassi appropriata per la versione SQL.

Nel mio caso particolare, l'inserimento di record 19K + in una semplice tabella sulla mia macchina di sviluppo (MacBook Pro con 8 GB di RAM, Intel Core i5 e Intel SSD da 2,4 GHz andava da 223 secondi utilizzando 'model.create!' a 7,2 secondi utilizzando un 'model.import!'.

class ActiveRecord::Base 

    def self.import!(record_list) 
    raise ArgumentError "record_list not an Array of Hashes" unless record_list.is_a?(Array) && record_list.all? {|rec| rec.is_a? Hash } 
    key_list, value_list = convert_record_list(record_list)   
    sql = "INSERT INTO #{self.table_name} (#{key_list.join(", ")}) VALUES #{value_list.map {|rec| "(#{rec.join(", ")})" }.join(" ,")}" 
    self.connection.insert_sql(sql) 
    end 

    def self.convert_record_list(record_list) 
    key_list = record_list.map(&:keys).flatten.uniq.sort 

    value_list = record_list.map do |rec| 
     list = [] 
     key_list.each {|key| list << ActiveRecord::Base.connection.quote(rec[key]) } 
     list 
    end 

    return [key_list, value_list] 
    end 
end 

Answer 3

Utilizzare la gemma activerecord-import. Diciamo che si sta leggendo un file CSV e la generazione di un catalogo Product e si desidera inserire record in lotti di 1000:

batch,batch_size = [], 1_000 
CSV.foreach("/data/new_products.csv", :headers => true) do |row| 
    batch << Product.new(row) 

    if batch.size >= batch_size 
    Product.import batch 
    batch = [] 
    end 
end 
Product.import batch 

Answer 4

È inoltre possibile utilizzare il activerecord-insert_many gemma. Crea una serie di oggetti!

events = [{name: "Movie Night, time: "10:00"}, {name: "Tutoring", time: "7:00"}, ...] 

Event.insert_many(events) 

Answer 5

L'utilizzo di una transazione velocizza notevolmente gli inserimenti di grandi quantità!

Model.transaction do 
    many.times{ Model.create! } 
end 

Se più modelli sono coinvolti, fare un Model.transaction per ogni modello, che è influenzata:

Model1.transaction do 
    Model2.transaction do 
     many.times do 
      m1 = Model1.create! 
      m1.add_model2 
     end 
    end 
end