MONGOID-5391 - Support Criteria#pluck_each method

[johnnyshields]

Resolves MONGOID-5391

This PR extracts out some code into Mongoid::Contextual::Mongo::PluckEnumerator. This class is used for both #pluck and #pluck_each (#pluck is simply pluck_each(fields).to_a.) There has been no change to the logic of #pluck; all existing #pluck cases pass without modification.

[johnnyshields]

This feature works brilliantly. So fast! 🚀

[johnnyshields]

This is ready for review.

[johnnyshields]

@neilshweky please review this PR, think it will be useful for your work on tally to sync up our implementations. It also moves some code you wrote in an earlier PR.

[neilshweky]

Your implementation of normalized_field_names differs slightly to the one I had previously.

Can you add a test in which we pluck both a localized field, and it's _transaltions hash?

For example:

Dictionary.pluck(:description, :description_translations)

and verify that this new implementation correctly returns

[["t", {"en" => "t", "de" => "u" }]]

for current locale being :en

[johnnyshields]

@neilshweky this test is already in this PR - criteria_spec.rb line 2619 for both #pluck and #pluck_each, legacy and non-legacy cases (I copied all the tests you wrote for #pluck.)

          it 'returns both' do
            expect(plucked_translations_both.first).to eq([{"de"=>"deutsch-text", "en"=>"english-text"}, "deutsch-text"])
          end

Github collapses the diff for criteria_spec.rb because it is large so you may have missed it.

[neilshweky]

Okay great!

[neilshweky]

Can you please answer my comments regarding the noramlzied_field_names and add a test?

[johnnyshields]

@neilshweky I responded.

[johnnyshields]

@p-mongo this PR is ready for review

[p-mongo]

This is an optimization for a narrow use case that does not need to exist in Mongoid. To iterate result set in batches you should use the normal .where etc. calls that Mongoid provides.

[johnnyshields]

@p-mongo #pluck_each(*fields) greatly reduces the number of object allocations when iterating over large data sets vs. the current alternative (.only(*fields).each). I am seeing it speed up my in-Ruby-memory data analysis jobs by ~10x or more. I'm already using this technique in production in dozens of reports in my app, so I don't consider it a narrow use case at all--many users will benefit.

(I made this PR to "scratch a real-world itch" re: performance of standard queries)

Given the benefit, this refactor has a pretty low "complexity" cost; extracting out PluckEnumerator actually makes the code simpler (less code in the mixin, more code encapsulated in a class.)

[p-mongo]

To not construct Mongoid model instances when issuing queries from Mongoid we have https://jira.mongodb.org/browse/MONGOID-5411. If your object allocations are coming from somewhere else please elaborate.

[johnnyshields]

@p-mongo I believe MONGOID-5411 and this PR serve similar, but slightly different purposes.

Suppose I have a model User with 100 different fields and some embeds (in the below examples "addresses" will be an embedded field.)

In MONGOID-5411, I'm assuming it adds a criteria modifier (lets call it .as_hashes) which causes the result to be returned as hashes rather than Mongoid::Document instances. Presumably this will work with .only and .each, so I can do:

User.where(name: "Ryan").only(:name, :rank, :addresses).as_hashes.each {|result| puts result }
#=> [ { name: "Ryan", rank: "Private", addresses: [{ street: "Elm Street", city: "Springwood" }] },
#     { name: "Ryan", rank: "Captain", addresses: [] },
#     { name: "Ryan", rank: "Major", addresses: [{ street: "Evergreen Terrace", city: "Springfield" }] } ]

(Please correct me if this is not how you're intending MONGOID-5411 to work)

#pluck_each, like #pluck, can actually do even fewer allocations, especially when working with embedded docs where you can use dot-notation path traversal:

User.where(name: "Ryan").pluck_each(:name, :rank, "addresses.street") {|result| puts result }
#=> [ "Ryan", "Private", ["Elm Street"] ] },
#     "Ryan", "Captain", [] },
#     "Ryan", "Major", ["Evergreen Terrace"] ]

Array creation is about twice the speed of Hash creation with lower memory footprint. #pluck_each is almost certainly to be lighter-weight than MONGOID-5411.

In summary, I think both #pluck_each and MONGOID-5411 are useful and not mutually exclusive. It's good for users to have a choose here, just like pluck vs. only today.

[p-mongo]

1. only supports dot notation.
2. pluck takes the hashes as they come out of the driver and takes values/makes arrays out of them. It is more expensive than returning the hashes as they are.

[johnnyshields]

@p-mongo that sounds reasonable. If MONGOID-5411:

• supports each (batch iteration with GETMORE)
• supports only (trims docs) including dot-notation
• is faster/more memory efficient in cases above than #pluck_each

Then there wouldn't be any need for this PR.

(I do think the refactor here makes the code cleaner regardless for #pluck)

[p-mongo]

Closing per the above comments. I extracted pluck-related changes to #5399.

[johnnyshields]

Fine to close. I do think this is still useful to have (syntax is more terse than what is being proposed in MONGOID-5411) but can revisit later.