#active_record

Postgres allows to use the row's own fields into an UPDATE, e.g.,

UPDATE test SET value=(value+1) WHERE id = 1;

This also works for merging some new data into a JSONB column, e.g.,

UPDATE test SET data=(data||'{"c":3}') WHERE id = 1;

Until ActiveRecord supports this natively, one could (unelegantly) write a method similar to the following into a model to perform the merge in place when needed

Keeping my promise, I will try to explain has_many :through with my naive understanding.

A typical use of has_many through is a many to many relation. Let’s use a basic example between students, enrollment, and courses. A student would have many courses. A course would also have many students. A join table is the go to solution for this type of situation.

enrollments is the joint table that will house two foreign keys, student_id and course_id. The SQL query to look for all enrolled courses of a student would probably look like this

SELECT   * FROM   courses JOIN   enrollments ON courses.id = course_id JOIN   students ON student_id = students.id

In ActiveRecord model level, we will have these codes.

class Student < ActiveRecord::Base   has_many(     :enrollments,     class_name: ‘Enrollment’,     foreign_key: :student_id   )

  has_many(     :enrolled_courses,     through: :enrollments,     source: :course   ) end

class Enrollment < ActiveRecord::Base   belongs_to(     :student,     class_name: ‘Student’,     foreign_key: :student_id   )

  belongs_to(     :course,     class_name: ‘Course’,     foreign_key: :course_id   ) end

class Course < ActiveRecord::Base   has_many(    :enrollments,    class_name: ‘Enrollment’,    foreign_key: :course_id   )  

  has_many(      :enrolled_students,      through: :enrollments,      source: :student   ) end

For the convenience of explanation and to prevent Active Record getting lost (which it actually won’t in such a simple case), I am writing everything down instead of relying on rails magic here.

Let’s focus on the two has_many through that I bolded above. If you have trouble understanding the other has_many and belongs_to, refer to my previous post. I have specified how AR should look for the courses from student and vice versa. 

What would happen here is, AR will look at the :through, and following its instruction and go to the Enrollment model. Then look for the source that I specified in the belongs_to method call within the Enrollment model. And it will look for the :source that it belongs_to. Refer to the chart below. Then the course will follow the specified class_name, using the foreign_key, and go look for the courses table by stepping through the Course model.

For course looking for all the enrolled students is just the other way around. With this setup, I will be able to do some_student.enrolled_courses, and some_course.enrolled_students.

Some time ago, I discovered we can use the scope to set default values in a new model.

For instance:

class Product scope :published, -> { where(published: true) } scope :not_published, -> { where(published: false) } end Product.new #=> #<Product id: nil, published: nil> Product.published #=> #<ActiveRecord::Relation []> Product.published.new #=> #<Product id: nil, published: true> Product.not_published.new #=> #<Product id: nil, published: false>

As you can see, the published attribute takes the value used in the scope.

In einem Projekt habe ich vor kurzem ein cooles Oracle-Feature einsetzen wollen: reguläre Ausdrücke. Wie ich jüngst lernte, unterstützt Oracle tatsächlich anständige reguläre Ausdrücke. Die Funktion, die ähnlich wie sed funktioniert, heißt "regexp_replace".

Doch das mühsam im SQL Developer zusammengebaute Statement wollte  aber nicht aus der Rails-Anwendung funktionieren. Als Beispiel kann folgendes Statement dienen:

select regexp_replace(to_char(sysdate, 'dd.mm.yyyy'),           '^([0-9]+)\.([0-9]+)\.([0-9]+)$',           'Tag: \1, Monat: \2, Jahr: \3') from dual;

In der Rails Console:

> rails c

Loading development environment (Rails 4.0.0)

2.0.0p247 :001 > stmt = "select regexp_replace(to_char(sysdate, 'dd.mm.yyyy'), '^([0-9]+)\.([0-9]+)\.([0-9]+)$', 'Tag: \1, Monat: \2, Jahr: \3') from dual"

=> "select regexp_replace(to_char(sysdate, 'dd.mm.yyyy'), '^([0-9]+).([0-9]+).([0-9]+)$', 'Tag: \u0001, Monat: \u0002, Jahr: \u0003') from dual"

2.0.0p247 :002 >

Das Problem ist, dass die Referenzen auf die Klammer-Terme (gibt es dafür einen anständigen Ausdruck?) \1, \2, \3 als Escape-Sequenzen interpretiert werden. Führt man das Statement aus, kommt erwartungsgemäß Müll heraus:

2.0.0p247 :021 > result = ActiveRecord::Base.connection.select_one(stmt)

   (18.7ms)  select regexp_replace(to_char(sysdate, 'dd.mm.yyyy'), '^([0-9]+).([0-9]+).([0-9]+)$', 'Tag: , Monat: , Jahr: ') from dual

=> {"regexp_replace(to_char(sysdate"=>"Tag: \u0001, Monat: \u0002, Jahr: \u0003"}

2.0.0p247 :022 >

Die Backslashes sind alle verschwunden, was sich für den regulären Ausdruck nicht so gut macht.

Erstaunlicherweise ist die Lösung tatsächlich die naheliegende:

2.0.0p247 :022 > stmt2 = "select regexp_replace(to_char(sysdate, 'dd.mm.yyyy'), '^([0-9]+)\\.([0-9]+)\\.([0-9]+)$', 'Tag: \\1, Monat: \\2, Jahr: \\3') from dual"

=> "select regexp_replace(to_char(sysdate, 'dd.mm.yyyy'), '^([0-9]+)\\.([0-9]+)\\.([0-9]+)$', 'Tag: \\1, Monat: \\2, Jahr: \\3') from dual"

2.0.0p247 :023 > result2 = ActiveRecord::Base.connection.select_one(stmt2)                                                             (5.6ms)  select regexp_replace(to_char(sysdate, 'dd.mm.yyyy'), '^([0-9]+)\.([0-9]+)\.([0-9]+)$', 'Tag: \1, Monat: \2, Jahr: \3') from dual

=> {"regexp_replace(to_char(sysdate,'dd.mm.yyyy'),'^([0-9]+)\\.([0-9]+)\\.([0-9]+)$','tag:\\1,monat:\\2,jahr:\\3')"=>"Tag: 19, Monat: 12, Jahr: 2013"}

2.0.0p247 :024 > result2.values

=> ["Tag: 19, Monat: 12, Jahr: 2013"]

Obwohl die String-Darstellung das Statements doppelte \ zeigt, kommt in der Datenbank nur einer an und das erwartete Ergebnis kommt zurück.

If you’re using some BLOB data in ActiveRecord (e.g. user pictures stored in DB), then you may have noticed that the Rails logging simply prints the INSERT/UPDATE SQL containing the raw binary content. Now for me (at least in development env) this is pretty useless and besides my terminal seems to be getting crazy out of it. As usual I thought someone must have done it before and found this post. It’s pretty outdated since it targets Rails 1.x, so I decided to make it work with Rails 2.x and here’s what I got : // <![CDATA[ embedGist('173245.js'); // ]]> Put this monkey-patch into a file named trim_blob_logging.rb into your RAILS_ROOT/lib directory. Then require 'trim_blob_logging' in environments/development.rb. Now, instead of being bloated with binary bits, your blob log entries should look similar to this one:

INSERT INTO db_files (data) VALUES(x'ffd8ffe000104a464946000101010048... (14133 bytes)')

class User < ActiveRecord::Base has_many :blogs has_many :articles, through: :blogs has_many :taggings, through: :articles end

というモデルがあったとして、

user = User.find 1 user.taggings.build name: 'ruby'

としようとすると、

ActiveRecord::HasManyThroughNestedAssociationsAreReadonly

という例外が発生する。

I was thinking to try identity map in production. I had some negative feedback and actually comments on the net was not so positive. A lot of notes that its not production ready, because of association issues and so on. Here you can find more

But I want to speed up just read action While reading source code, I found that it has method :use which accepts block as parameter. So I’ve created around filter to use IdentityMap for particular action

around_filter :with_identity_map, :only => :index def with_identity_map ActiveRecord::IdentityMap.use do yield end end

Thats all. Results was positive. It decreased page load by two times from 1600 ms to 800ms. Which is still unacceptable. It looks like quick hack to fix not “perfect code”

Few weeks everything was ok. But after some changes IdentityMap starts conflicting with caching.

Errors was like “has_many association returns nil”. I disabled identity map. And then we refactored code as a result of refactorign page load downs to ~200 ms.