{"id":130,"date":"2021-11-25T23:00:00","date_gmt":"2021-11-26T03:00:00","guid":{"rendered":"https:\/\/gerardomiranda.dev\/blog\/?p=130"},"modified":"2021-11-25T22:53:09","modified_gmt":"2021-11-26T02:53:09","slug":"manejando-grandes-cantidades-de-datos-en-ruby-on-rails","status":"publish","type":"post","link":"https:\/\/gerardomiranda.dev\/blog\/es\/manejando-grandes-cantidades-de-datos-en-ruby-on-rails\/","title":{"rendered":"Manejando grandes cantidades de datos en Ruby on Rails"},"content":{"rendered":"\n

El otro d\u00eda ten\u00eda una tarea para la que necesitaba generar 2,000,000 de registros en la base de datos antes de poder trabajar en ella. Quien hab\u00eda creado la tarea tuvo la amabilidad de dejarme un script para generar los datos. No le prest\u00e9 demasiada atenci\u00f3n y s\u00f3lo lo dej\u00e9 corriendo mientras completaba otras tareas. Mis otras tareas me llevaron todo el d\u00eda para completar y cuando fui a revisar el progreso del script me di cuenta que no iba ni por la mitad.<\/p>\n\n\n\n

Evidentemente el script no era eficiente en lo absoluto, asi que lo detuve y lo revis\u00e9. Lo primero que not\u00e9 es que estaba generando las instancias una por una, que dada la naturaleza de los objetos que estaba creando era inevitable. La verdadera causa de la ineficiencia era c\u00f3mo estaba guardando los registros en la base de datos, directamente con ActiveRecord.save.<\/p>\n\n\n\n

S\u00e9 de primera mano que el m\u00e9todo para guardar de ActiveRecord es muy poco eficiente para grandes cantidades de datos, pero no ten\u00eda idea de cu\u00e1nto. As\u00ed que despu\u00e9s de cambiar el script para utilizar la librer\u00eda activerecord-import<\/a>, tuve curiosidad de qu\u00e9 tan grande era la diferencia rendimiento con el ActiveRecord.save.<\/p>\n\n\n\n

<\/div>\n\n\n\n

Preparando las pruebas<\/h4>\n\n\n\n

Para eso primero necesitamos un modelo, lo mantendremos bastante simple porque no es necesario complicarnos dem\u00e1s.<\/p>\n\n\n

create_table :dummy_models<\/span> do<\/span> |t|<\/span>\n   t.string :dummy_text1<\/span>\n   t.string :dummy_text2<\/span>\n   t.string :dummy_text3<\/span>\n\n   t.timestamps\n end<\/span><\/code><\/span>Code language:<\/span> Ruby<\/span> (<\/span>ruby<\/span>)<\/span><\/small><\/pre>\n\n\n
def<\/span> self<\/span>.generate_record<\/span><\/span>\n    DummyModel.new(dummy_text1:<\/span> Faker::Lorem.word, dummy_text2:<\/span> Faker::Lorem.word, dummy_text3:<\/span> Faker::Lorem.word)\nend<\/span><\/code><\/span>Code language:<\/span> Ruby<\/span> (<\/span>ruby<\/span>)<\/span><\/small><\/pre>\n\n\n
Ahora vamos con los m\u00e9todos a comparar, primero utilizando ActiveRecord.save<\/p>\n\n\n
def<\/span> self<\/span>.with_active_record_create<\/span>(size)<\/span><\/span>\n    (1<\/span>..size).each do<\/span> |i|<\/span>\n        record = generate_record\n        record.save!\n    end<\/span> \nend<\/span><\/code><\/span>Code language:<\/span> Ruby<\/span> (<\/span>ruby<\/span>)<\/span><\/small><\/pre>\n\n\n
Seguimos con utilzando activerecord-import<\/p>\n\n\n
def<\/span> self<\/span>.with_active_record_import<\/span>(size)<\/span><\/span>\n    records = []\n    (1<\/span>..size).each do<\/span> |i|<\/span>\n        records << generate_record\n    end<\/span>\n    DummyModel.import(records)\nend<\/span><\/code><\/span>Code language:<\/span> Ruby<\/span> (<\/span>ruby<\/span>)<\/span><\/small><\/pre>\n\n\n
Yendo un poco mas lejos, utilizaremos un par de opciones que nos permite la librer\u00eda, primero para saltarnos las validaciones y adicionalmente para pasar las columnas en lugar de un objeto ActiveRecord. Para esto \u00faltimo primero generaremos el ActiveRecord correspondiente y extraeremos sus valores, para ver si la diferencia en rendimiento lo justifica.<\/p>\n\n\n
def<\/span> self<\/span>.with_active_record_import_without_validations<\/span>(size)<\/span><\/span>\n    records = []\n    (1<\/span>..size).each do<\/span> |i|<\/span>\n        records << generate_record\n    end<\/span>\n    DummyModel.import(records, validate:<\/span> false<\/span>)\nend<\/span>\n    \ndef<\/span> self<\/span>.with_active_record_import_columns_without_validations<\/span>(size)<\/span><\/span>\n    values = []\n    columns = ['dummy_text1'<\/span>, 'dummy_text2'<\/span>, 'dummy_text3'<\/span>]\n    (1<\/span>..size).each do<\/span> |i|<\/span>\n        record = generate_record\n        values << [record.dummy_text1, record.dummy_text2, record.dummy_text3]\n    end<\/span>\n    DummyModel.import(columns, values, validate:<\/span> false<\/span>)\nend<\/span><\/code><\/span>Code language:<\/span> Ruby<\/span> (<\/span>ruby<\/span>)<\/span><\/small><\/pre>\n\n\n
<\/div>\n\n\n\n
Comparando los tiempos<\/h4>\n\n\n\n
Listo, lo \u00fanico que queda es utilizar benchmarking para ver las diferencias. Comenzaremos pasando solo 1,000 registros.<\/p>\n\n\n
With<\/span> ActiveRecord<\/span> save<\/span>\n  2.444752<\/span>   0.297301<\/span>   2.742053<\/span> (  5.692380<\/span>)\nWith<\/span> ActiveRecord<\/span> import<\/span>\n  0.260530<\/span>   0.028553<\/span>   0.289083<\/span> (  0.325896<\/span>)\nWith<\/span> ActiveRecord<\/span> import<\/span> without<\/span> validations<\/span>\n  0.250810<\/span>   0.024476<\/span>   0.275286<\/span> (  0.289907<\/span>)\nWith<\/span> ActiveRecord<\/span> using<\/span> columns<\/span> without<\/span> validations<\/span>\n  0.223519<\/span>   0.028434<\/span>   0.251953<\/span> (  0.267757<\/span>)<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
Ya con esta cantidad de datos, la diferencia es abismal entre ActiveRecord.save y los m\u00e9todos de activerecord-import, con mas de 5 segundos de diferencia. A\u00fan as\u00ed creo que con cantidades de esta magnitud todav\u00eda se puede utilizar ActiveRecord.save sin mucha preocupaci\u00f3n.<\/p>\n\n\n\n
Entre los diferentes m\u00e9todos de activerecord-import casi no se puede apreciar diferencia. Vamos a intentar subiendo un poco la vara con 10,000 registros.<\/p>\n\n\n
With<\/span> ActiveRecord<\/span> save<\/span>\n 19.409276<\/span>   1.963945<\/span>  21.373221<\/span> ( 47.560994<\/span>)\nWith<\/span> ActiveRecord<\/span> import<\/span>\n  2.865762<\/span>   0.203885<\/span>   3.069647<\/span> (  3.313518<\/span>)\nWith<\/span> ActiveRecord<\/span> import<\/span> without<\/span> validations<\/span>\n  2.657060<\/span>   0.195326<\/span>   2.852386<\/span> (  2.983243<\/span>)\nWith<\/span> ActiveRecord<\/span> using<\/span> columns<\/span> without<\/span> validations<\/span>\n  2.423606<\/span>   0.217493<\/span>   2.641099<\/span> (  2.779699<\/span>)<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
Bueno con estos tiempos creo que ActiveRecord.save quedar\u00eda descartado para cantidades alrededor de los 10,000 registros. Pero los diferentes m\u00e9todos de activerecord-import a\u00fan se mantienen a poca distancia unos de otros a menos de 1 segundo.<\/p>\n\n\n\n
Hagamos trabajar un poco a nuestra PC y generemos 100,000 registros a ver qu\u00e9 sucede.<\/p>\n\n\n
With<\/span> ActiveRecord<\/span> save<\/span>\n207.721426<\/span>  20.519692<\/span> 228.241118<\/span> (503.432937<\/span>)\nWith<\/span> ActiveRecord<\/span> import<\/span>\n 27.889573<\/span>   2.115005<\/span>  30.004578<\/span> ( 32.025789<\/span>)\nWith<\/span> ActiveRecord<\/span> import<\/span> without<\/span> validations<\/span>\n 27.754645<\/span>   2.084204<\/span>  29.838849<\/span> ( 31.793397<\/span>)\nWith<\/span> ActiveRecord<\/span> using<\/span> columns<\/span> without<\/span> validations<\/span>\n 24.807959<\/span>   1.963377<\/span>  26.771336<\/span> ( 28.741473<\/span>)<\/code><\/span>Code language:<\/span> CSS<\/span> (<\/span>css<\/span>)<\/span><\/small><\/pre>\n\n\n
Definitivamente ActiveRecord.save queda descartado si quieres guardar 100,000+ registros, ahora entiendo por qu\u00e9 ese script no terminaba de ejecutar. En cuanto a los dem\u00e1s se puede ver que el m\u00e9todo para guardar directamente las columnas sin pasar  un objeto ActiveRecord fue mas r\u00e1pido que sus contrapartes por al menos 2 segundos. Esto no es nada del otro mundo pero hay que tomar en cuenta que primero creamos los objetos ActiveRecord y luego extrajimos los datos. Asi que en caso de que manejes millones de registros y si puedes no crear un objeto ActiveRecord antes, puede valer la pena optar por esta \u00faltima opci\u00f3n.<\/p>\n\n\n\n
Estas comparaciones me muestran que definitivamente cuando me encuentre desarrollando en Ruby on Rails, tengo que tener muy en cuenta la cantidad de datos con la que voy a trabajar. No sea que uno de estos d\u00edas uno de esos scripts se vaya a producci\u00f3n y la aplicaci\u00f3n se muera.<\/p>\n\n\n\n
El c\u00f3digo est\u00e1 disponible para que puedas verlo aqu\u00ed<\/a>.<\/p>\n","protected":false},"excerpt":{"rendered":"
S\u00e9 de primera mano que el m\u00e9todo para guardar de ActiveRecord es muy poco eficiente para grandes cantidades de datos, pero no ten\u00eda idea de cu\u00e1nto.<\/p>\n","protected":false},"author":1,"featured_media":165,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"om_disable_all_campaigns":false,"_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"footnotes":""},"categories":[28],"tags":[77,76,35],"class_list":["post-130","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-aprendizaje","tag-data","tag-ruby-on-rails","tag-web"],"aioseo_notices":[],"_links":{"self":[{"href":"https:\/\/gerardomiranda.dev\/blog\/wp-json\/wp\/v2\/posts\/130","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/gerardomiranda.dev\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/gerardomiranda.dev\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/gerardomiranda.dev\/blog\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/gerardomiranda.dev\/blog\/wp-json\/wp\/v2\/comments?post=130"}],"version-history":[{"count":22,"href":"https:\/\/gerardomiranda.dev\/blog\/wp-json\/wp\/v2\/posts\/130\/revisions"}],"predecessor-version":[{"id":167,"href":"https:\/\/gerardomiranda.dev\/blog\/wp-json\/wp\/v2\/posts\/130\/revisions\/167"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/gerardomiranda.dev\/blog\/wp-json\/wp\/v2\/media\/165"}],"wp:attachment":[{"href":"https:\/\/gerardomiranda.dev\/blog\/wp-json\/wp\/v2\/media?parent=130"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/gerardomiranda.dev\/blog\/wp-json\/wp\/v2\/categories?post=130"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/gerardomiranda.dev\/blog\/wp-json\/wp\/v2\/tags?post=130"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}
Lo siguiente ser\u00e1 el m\u00e9todo para generar los registros. Para generar el texto utilizaremos la gema Faker<\/a>. Para respetar el problema original en todos los casos vamos a generar los registros uno por uno.<\/p>\n\n\n