Question

I currently have the following controller method in a Rails app:

def index
  @entries = []
  @entries << QuickPost.where(:user_id.in => current_user.followees.map(&:ff_id) << current_user.id)
  @entries << Infographic.where(:user_id.in => current_user.followees.map(&:ff_id) << current_user.id)
  @entries.flatten!.sort!{ |a,b| b.created_at <=> a.created_at }

  @entries = Kaminari.paginate_array(@entries).page(params[:page]).per(10)
end

I realise this is terribly inefficient so I’m looking for a better way to achieve the same goal but I’m new to MongoDB and wondering what the best solution would be.

Is there a way to make a sorted limit() query or a MapReduce function in MongoDB across two collections? I’m guessing there isn’t but it would certainly save a lot of effort in this case!

I’m currently thinking I have two options:

1. Create a master ‘StreamEntry’ type model and have both Infographic and QuickPost inherit from that so that both data types are stored on the same collection. The issue with this is that I have existing data and I don’t know how to move it from the old collections to the new.
2. Create a separate Stream/ActivityStream model using something like Streama (https://github.com/christospappas/streama). The issues I can see here is that it would require a fair bit of upfront work and due to privacy settings and editing/removal of items the stream would need to be rebuilt often.

Are there options I have overlooked? Am I over-engineering with the above options? What sort of best practices are there for this type of situation?

Any info would be greatly appreciated, I’m really liking MongoDB so far and want to avoid falling into pitfalls like this in the future. Thanks.

Answer 1

The inherit solution is fine, but when the inherited models are close.
For example :

class Post < BasePost
  field :body, type: String
end
class QuickPost < BasePost
end
class BasePost
  field :title, type: String
  field :created_at, type: Time
end

But when the models grows, or are too different, your second solution is better.

class Activity
  include Mongoid::Document

  paginates_per 20

  field :occurred_at, :type => Time, :default => nil
  validates_presence_of :occurred_at

  belongs_to :user
  belongs_to :quick_post
  belongs_to :infographic

  default_scope desc(:occurred_at)
end

and for example :

class QuickPost
  include Mongoid::Document
  has_one :activity, :dependent => :destroy
end

The dependant destroy make the activity destroyed when the QuickPost is destroyed. You can use has_many and adapt.

And to create the activities, you can create an observer :

class ActivityObserver < Mongoid::Observer
  observe :quick_post, :infographic

  def after_save(record)
    if record.is_a? QuickPost
      if record.new_record?
        activity = record.build_activity
        activity.user = record.user
        # stuff when it is new
      else
        activity = record.activity
      end
      activity.occurred_at = record.occurred_at
      # common stuff
      activity.save
    end
  end
end