DEV Community: Beth Haubert

Query Fun

Beth Haubert — Wed, 18 Jul 2018 15:37:44 +0000

Right now we're preparing to move our customers' sites to our new platform, which means scheduling upgrades and repointing DNS. To make it easier on everyone, we're building a platform upgrade dashboard that lists all of a customer's site upgrades by status. For each of the three different statuses, there is a section where the sites within those sections are listed alphabetically. I'm in charge of writing the query.

Here's an imaginary customer's sites:

{
    :id => 129,
    :name => "Shart Attack",
    :owner_id => 1
},
{
    :id => 234,
    :name => "Fart of Gold",
    :owner_id => 1
},
{
    :id => 245,
    :name => "Farty McFly",
    :owner_id => 1
},
{
    :id => 312,
    :name => "Fart Corner",
    :owner_id => 1
}

And here is a list of PlatformUpgrades::SiteUpgrade objects

{
    :id => 1,
    :site_id => 234,
    :status => "scheduled"
},
{
    :id => 2,
    :site_id => 129,
    :status => "unscheduled"
},
{
    :id => 3,
    :site_id => 245,
    :status => "upgraded"
},
{
    :id => 4,
    :site_id => 312,
    :status => "scheduled"
}

So I want to return the PlatformUpgrades::SiteUpgrade objects in the correct order based on their status and site name. I ended up creating a new class to set up and run the query.

I also got to use a bit of Arel directly for the first time. It's a library to help manage SQL for Ruby. In fact, it's the framework that ActiveRecord is built on.

You'll see I initialized the class with a user and scope. Currently this query is only being used in one place, so I set the default scope to all PlatformUpgrades::SiteUpgrades. I also made a custom ordering method.

module PlatformUpgrades
    # Gathers SiteUpgrades for a user and orders them correctly (unscheduled, scheduled, upgraded)
    #
    # Examples:
    #
    #   PlatformUpgrades::SiteUpgradeQuery.new(user: user)
    #
    class OrderedSiteUpgradeQuery < Query
        # Public: Instantiates a new query.
        #
        # user - The user who owns the sites associated with the site upgrades.
        #        Include sites where they are collaborators or members
        # scope - The scope from which we base the query.
        def initialize(user:, scope: PlatformUpgrades::SiteUpgrade.all)
            @user = user
            @scope = scope
        end

                # Public: Runs a query
        #
        # Returns: An ActiveRecord::Relation 
        def find
            scope.joins(:site)
                 .where(sites: { id: user.all_sites.select(:id) })
                 .order(order_by_status)
                 .order(sites[:name].asc)
        end

        private

        attr_reader :user
        attr_reader :scope

        table_alias sites: Site, upgrades: PlatformUpgrades::SiteUpgrade

        def order_by_status
            Arel::Nodes::Case
                .new(upgrades[:status])
                .when("unscheduled").then(0)
                .when("scheduled").then(1)
                .else(2)
        end
    end
end

So now when I run PlatformUpgrades::SiteUpgradeQuery.new(user: User.find(1)).find I get my PlatformUpgrades:SiteUpgrade Objects back in the correct order:

{
    :id => 2,
    :site_id => 129,
    :status => "unscheduled"
},
{
    :id => 4,
    :site_id => 312,
    :status => "scheduled"
},
{
    :id => 1,
    :site_id => 234,
    :status => "scheduled"
},
{
    :id => 3,
    :site_id => 245,
    :status => "upgraded"
}

💥each_with_object💥

Beth Haubert — Tue, 17 Jul 2018 19:14:23 +0000

I've been wrestling with a slightly nasty refactor story recently. The following is my first iteration of a method that loops through a hash of @nameservers and for each one assigns the host to an instance variable in the class, then loops through each IP in the info hash and adds the output from a private method in the @results hash.
That's a lot of looping. 💩

def check
    @results = {}
    @nameservers.each do |host, info|
      @host = host
      info[:ips].each do |nameserver_ip|
        @results[nameserver_ip] = ip_check(nameserver_ip)
      end
    end

    @results
+end

@nameservers is a hash that looks something like this:

{
            "Google" => {
        :country => "USA",
            :ips => [
            [0] "8.8.8.8",
            [1] "8.8.4.4"
        ]
    },
           "OpenDNS" => {
        :country => "USA",
            :ips => [
            [0] "208.67.222.222",
            [1] "208.67.220.220"
        ]
    },
         "Fortalnet" => {
        :country => "Brazil",
            :ips => [
            [0] "189.90.16.20",
            [1] "189.90.16.21"
        ]
    },
    "Probe Networks" => {
        :country => "Germany",
            :ips => [
            [0] "82.96.64.2",
            [1] "82.96.65.2"
        ]
    }
}

What's the best way to simplify that method? Well, another dev turned me on to the each_with_object method. Instead of defining and returning the @results hash explicitly, it can be incorporated into one of the loops. How it works?

            def check
                @nameservers.each_with_object({}) do |(host, info), results|
                    info[:ips].each do |nameserver_ip|
                        results[nameserver_ip] = ip_check(host, nameserver_ip)
                    end
                end
            end

When you call each_with_object on @nameservers I'm passing an empty hash as the argument. (It doesn't need to be an empty hash. It can be a pre-existing hash or even an array). Inside the block you pass the object or objects to loop over, in this case host and info, and then the variable name you want to assign the object you passed in as an argument. So my hash will be returned as results.
The second loop in my method remained almost exactly the same, except that I decided to pass host through to my private ip_check method as well so that the state wasn't leaking into the rest of the object.

And voila. Just what I needed.

A new (to me) Enumerable method

Beth Haubert — Tue, 03 Apr 2018 19:44:53 +0000

So I was helping one of our front-end devs on a view the other day and he needed a collection of objects to be in a very specific order. The problem was that it required a very ugly and somewhat confusing query:

@in_progress = migration_request_group.current_migration_requests.sort_by { |x|
 x.in_progress_in_group? ? 0 : 1 }.sort_by { |x| x.pending? ? 0 : 1 }

It first sorts the current_migration_requests so that if the request currently being looped over is in_progress_in_group?, it gets moved to the first position in the array, otherwise it's moved to the second position. And then it checks if that request is pending. If so, it get's moved into the first position. If you're just looking at the code for the first time, it's not easy to understand at all.

I knew there had to be a better way. I just didn't know what that better way was...

Fortunately, I'm on a team of seasoned Ruby developers who helped me out. It turns out there's this method called partition that's actually been around a while.

pending, rest = migration_request_group.current_migration_requests.partition(&:pending?)
in_progress, rest = rest.partition(&:in_progress_in_group?)
@in_progress = pending + in_progress + rest

Here's how it works:
There are two arrays: pending and rest. The first one, pending, will store any objects that the block finds true, while rest will store the rest of the objects. Then I do another partition block where I take that existing rest array and split it into two more arrays: in_progress and, again, rest.
Then I combine the arrays in the required order. It may take up three lines of code instead of one, but I believe it's much clearer.