Optimize Role model/dataset

app/controllers/v3/roles_controller.rb

@@ -54,14 +54,14 @@ def show
     decorators << IncludeRoleOrganizationDecorator if IncludeRoleOrganizationDecorator.match?(message.include)
     decorators << IncludeRoleSpaceDecorator if IncludeRoleSpaceDecorator.match?(message.include)
 
-    role = readable_roles.first(guid: hashed_params[:guid])
+    role = readable_roles.where(guid: hashed_params[:guid]).first
     resource_not_found!(:role) unless role
 
     render status: :ok, json: Presenters::V3::RolePresenter.new(role, decorators: decorators)
   end
 
   def destroy
-    role = readable_roles.first(guid: hashed_params[:guid])
+    role = readable_roles.where(guid: hashed_params[:guid]).first
     resource_not_found!(:role) unless role
 
     if role.for_space?
@@ -147,7 +147,11 @@ def readable_roles
     if permission_queryer.can_read_globally?
       Role
     else
-      Role.where(space_id: visible_space_ids).or(organization_id: visible_org_ids)
+      # This rather complex filter should be applied to the overall Role dataset and is thus using the (virtual row)
+      # block syntax.
+      readable_by_space = { space_id: visible_space_ids }
+      readable_by_org = { organization_id: visible_org_ids }
+      Role.where { Sequel.|(readable_by_space, readable_by_org) }
     end
   end
 

app/fetchers/base_list_fetcher.rb

@@ -23,16 +23,16 @@ def advanced_filtering(message, dataset, klass)
             values.map do |operator, given_timestamp|
               if operator == RelationalOperators::LESS_THAN_COMPARATOR
                 normalized_timestamp = Time.parse(given_timestamp).utc
-                dataset = dataset.where { Sequel.qualify(klass.table_name, filter) < normalized_timestamp }
+                dataset = dataset.where(Sequel.qualify(klass.table_name, filter) < normalized_timestamp)
               elsif operator == RelationalOperators::LESS_THAN_OR_EQUAL_COMPARATOR
                 normalized_timestamp = (Time.parse(given_timestamp).utc + 0.999999).utc
-                dataset = dataset.where { Sequel.qualify(klass.table_name, filter) <= normalized_timestamp }
+                dataset = dataset.where(Sequel.qualify(klass.table_name, filter) <= normalized_timestamp)
               elsif operator == RelationalOperators::GREATER_THAN_COMPARATOR
                 normalized_timestamp = (Time.parse(given_timestamp).utc + 0.999999).utc
-                dataset = dataset.where { Sequel.qualify(klass.table_name, filter) > normalized_timestamp }
+                dataset = dataset.where(Sequel.qualify(klass.table_name, filter) > normalized_timestamp)
               elsif operator == RelationalOperators::GREATER_THAN_OR_EQUAL_COMPARATOR
                 normalized_timestamp = Time.parse(given_timestamp).utc
-                dataset = dataset.where { Sequel.qualify(klass.table_name, filter) >= normalized_timestamp }
+                dataset = dataset.where(Sequel.qualify(klass.table_name, filter) >= normalized_timestamp)
               end
             end
           else

app/fetchers/role_list_fetcher.rb

@@ -5,8 +5,8 @@
 module VCAP::CloudController
   class RoleListFetcher < BaseListFetcher
     class << self
-      def fetch(message, readable_users_dataset, eager_loaded_associations: [])
-        filter(message, readable_users_dataset).eager(eager_loaded_associations)
+      def fetch(message, readable_roles, eager_loaded_associations: [])
+        filter(message, readable_roles).eager(eager_loaded_associations)
       end
 
       private

app/models/runtime/pollable_job_model.rb

@@ -32,7 +32,7 @@ def resource_exists?
                 Sequel::Model(ActiveSupport::Inflector.pluralize(resource_type).to_sym)
               end
 
-      !!model.find(guid: resource_guid)
+      !!model.where(guid: resource_guid).first
     end
 
     def self.find_by_delayed_job(delayed_job)