RolifyCommunity / rolify / 671

pending completion

Build # 671

Build Type

Pull #500

travis-ci

Committed by

web-flow

Commit Message

significantly optimize #without_role

Imagine a big production application with millions of users.

The previous version generates 3 queries for `User.without_role(:admin)`:
1) For `user.all` in [`#all_except`](https://github.com/RolifyCommunity/rolify/blob/<a class=hub.com/RolifyCommunity/rolify/commit/<a class="double-link" href="https://git"><a class=hub.com/RolifyCommunity/rolify/commit/522c0d7d84a70dd3576b569edf19f9f6cb118a61">522c0d7d8/lib/rolify/adapters/active_record/role_adapter.rb#L83):
```sql
SELECT "users".* FROM "users"
```
2) For `self.with_role(role_name, resource)` in [`#without_role`](https://github.com/RolifyCommunity/rolify/blob/522c0d7d84a70dd3576b569edf19f9f6cb118a61/lib/rolify/finders.rb#L8):
```sql
SELECT "users".* FROM "users" INNER JOIN "users_roles" ON "users_roles"."user_id" = "users"."id" INNER JOIN "roles" ON "roles"."id" = "users_roles"."role_id" WHERE (((roles.name = 'admin') AND (roles.resource_type IS NULL) AND (roles.resource_id IS NULL)))
```
3) For `user.where(prime_key => (user.all - excluded_obj).map(&prime_key))` in [`#all_except`](https://github.com/RolifyCommunity/rolify/blob/522c0d7d84a70dd3576b569edf19f9f6cb118a61/lib/rolify/adapters/active_record/role_adapter.rb#L83):
```sql
SELECT "users".* FROM "users" WHERE "users"."id" IN (1, 2, ..., N)
```
where `N` is a number of users without the `admin` role.

While a number of values in the `IN` clause for the third query can be huge there is even a worse problem. First, `user.all - excluded_obj` creates an `Array` of users and then `(user.all - excluded_obj).map(&prime_key)` calls a primary key method on every object in this array.

From tests
---

Before (3 queries):
```sql
SELECT "customers".* FROM "customers"
SELECT "customers".* FROM "customers" INNER JOIN "customers_privileges" ON "customers_privileges"."customer_id" = "customers"."id" INNER JOIN "privileges" ON "privileges"."id" = "customers_privileges"."privilege_id" WHERE (((privileges.name = 'admin') AND (privileges.resource_type IS NULL) AND (privileges.resource_id IS NULL)))
SELECT "customers".* FROM "customers" WHERE "customers"."id" IN (2, 3, 4)
... (continued)

Pull Request Pull Request #500: Significantly optimize #without_role

Run Details

3 of 3 new or added lines in 2 files covered. (100.0%)

1767 of 1892 relevant lines covered (93.39%)

567.53 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

76.81

/lib/rolify/adapters/mongoid/role_adapter.rb

require 'rolify/adapters/base'

module Rolify
  module Adapter
    class RoleAdapter < RoleAdapterBase
      def where(relation, *args)
        conditions = build_conditions(relation, args)
        relation.any_of(*conditions)
      end

      def where_strict(relation, args)
        return relation.where(:name => args[:name]) if args[:resource].blank?
        resource = if args[:resource].is_a?(Class)
                     {class: args[:resource].to_s, id: nil}
                   else
                     {class: args[:resource].class.name, id: args[:resource].id}
                   end

        relation.where(:name => args[:name], :resource_type => resource[:class], :resource_id => resource[:id])
      end

      def find_cached(relation, args)
        resource_id = (args[:resource].nil? || args[:resource].is_a?(Class) || args[:resource] == :any) ? nil : args[:resource].id
        resource_type = args[:resource].is_a?(Class) ? args[:resource].to_s : args[:resource].class.name

        return relation.find_all { |role| role.name == args[:name].to_s } if args[:resource] == :any

        relation.find_all do |role|
          (role.name == args[:name].to_s && role.resource_type == nil && role.resource_id == nil) ||
          (role.name == args[:name].to_s && role.resource_type == resource_type && role.resource_id == nil) ||
          (role.name == args[:name].to_s && role.resource_type == resource_type && role.resource_id == resource_id)
        end
      end

      def find_cached_strict(relation, args)
        resource_id = (args[:resource].nil? || args[:resource].is_a?(Class)) ? nil : args[:resource].id
        resource_type = args[:resource].is_a?(Class) ? args[:resource].to_s : args[:resource].class.name

        relation.find_all do |role|
          role.resource_id == resource_id && role.resource_type == resource_type && role.name == args[:name].to_s
        end
      end

      def find_or_create_by(role_name, resource_type = nil, resource_id = nil)
        self.role_class.find_or_create_by(:name => role_name,
                                          :resource_type => resource_type,
                                          :resource_id => resource_id)
      end

      def add(relation, role)
        relation.roles << role
      end

      def remove(relation, role_name, resource = nil)
        #roles = { :name => role_name }
        #roles.merge!({:resource_type => (resource.is_a?(Class) ? resource.to_s : resource.class.name)}) if resource
        #roles.merge!({ :resource_id => resource.id }) if resource && !resource.is_a?(Class)
        #roles_to_remove = relation.roles.where(roles)
        #roles_to_remove.each do |role|
        #  # Deletion in n-n relations is unreliable. Sometimes it works, sometimes not.
        #  # So, this does not work all the time: `relation.roles.delete(role)`
        #  # @see http://stackoverflow.com/questions/9132596/rails3-mongoid-many-to-many-relation-and-delete-operation
        #  # We instead remove ids from the Role object and the relation object.
        #  relation.role_ids.delete(role.id)
        #  role.send((user_class.to_s.underscore + '_ids').to_sym).delete(relation.id)
        #
        #  role.destroy if role.send(user_class.to_s.tableize.to_sym).empty?
        #end
        cond = { :name => role_name }
        cond[:resource_type] = (resource.is_a?(Class) ? resource.to_s : resource.class.name) if resource
        cond[:resource_id] = resource.id if resource && !resource.is_a?(Class)
        roles = relation.roles.where(cond)
        roles.each do |role|
          relation.roles.delete(role)
          role.send(ActiveSupport::Inflector.demodulize(user_class).tableize.to_sym).delete(relation)
          if Rolify.remove_role_if_empty && role.send(ActiveSupport::Inflector.demodulize(user_class).tableize.to_sym).empty?
            role.destroy
          end
        end if roles
        roles
      end

      def exists?(relation, column)
        relation.where(column.to_sym.ne => nil)
      end

      def scope(relation, conditions)
        roles = where(role_class, conditions).map { |role| role.id }
        return [] if roles.size.zero?
        query = relation.any_in(:role_ids => roles)
        query
      end

      def all_except(user, excluded_obj)
        user.not_in(_id: excluded_obj.to_a)
      end

      private

      def build_conditions(relation, args)
        conditions = []
        args.each do |arg|
          if arg.is_a? Hash
            query = build_query(arg[:name], arg[:resource])
          elsif arg.is_a?(String) || arg.is_a?(Symbol)
            query = build_query(arg)
          else
            raise ArgumentError, "Invalid argument type: only hash or string or symbol allowed"
          end
          conditions += query
        end
        conditions
      end

      def build_query(role, resource = nil)
        return [{ :name => role }] if resource == :any
        query = [{ :name => role, :resource_type => nil, :resource_id => nil }]
        if resource
          query << { :name => role, :resource_type => (resource.is_a?(Class) ? resource.to_s : resource.class.name), :resource_id => nil }
          if !resource.is_a? Class
            query << { :name => role, :resource_type => resource.class.name, :resource_id => resource.id }
          end
        end
        query
      end
    end
  end
end

1	require 'rolify/adapters/base'	6✔
2
3	module Rolify	6✔
4	module Adapter	6✔
5	class RoleAdapter < RoleAdapterBase	6✔
6	def where(relation, *args)	6✔
7	conditions = build_conditions(relation, args)	18✔
8	relation.any_of(*conditions)	18✔
9	end
10
11	def where_strict(relation, args)	6✔
12	return relation.where(:name => args[:name]) if args[:resource].blank?	24✔
13	resource = if args[:resource].is_a?(Class)	24✔
14	{class: args[:resource].to_s, id: nil}	12✔
15	else
16	{class: args[:resource].class.name, id: args[:resource].id}	12✔
17	end
18
19	relation.where(:name => args[:name], :resource_type => resource[:class], :resource_id => resource[:id])	24✔
20	end
21
22	def find_cached(relation, args)	6✔
23	resource_id = (args[:resource].nil? \|\| args[:resource].is_a?(Class) \|\| args[:resource] == :any) ? nil : args[:resource].id	6✔
24	resource_type = args[:resource].is_a?(Class) ? args[:resource].to_s : args[:resource].class.name	6✔
25
26	return relation.find_all { \|role\| role.name == args[:name].to_s } if args[:resource] == :any	18✔
27
28	relation.find_all do \|role\|	×
29	(role.name == args[:name].to_s && role.resource_type == nil && role.resource_id == nil) \|\|	×
30	(role.name == args[:name].to_s && role.resource_type == resource_type && role.resource_id == nil) \|\|	×
31	(role.name == args[:name].to_s && role.resource_type == resource_type && role.resource_id == resource_id)	×
32	end
33	end
34
35	def find_cached_strict(relation, args)	6✔
36	resource_id = (args[:resource].nil? \|\| args[:resource].is_a?(Class)) ? nil : args[:resource].id	24✔
37	resource_type = args[:resource].is_a?(Class) ? args[:resource].to_s : args[:resource].class.name	24✔
38
39	relation.find_all do \|role\|	24✔
40	role.resource_id == resource_id && role.resource_type == resource_type && role.name == args[:name].to_s	36✔
41	end
42	end
43
44	def find_or_create_by(role_name, resource_type = nil, resource_id = nil)	6✔
45	self.role_class.find_or_create_by(:name => role_name,	4,674✔
46	:resource_type => resource_type,
47	:resource_id => resource_id)
48	end
49
50	def add(relation, role)	6✔
51	relation.roles << role	138✔
52	end
53
54	def remove(relation, role_name, resource = nil)	6✔
55	#roles = { :name => role_name }
56	#roles.merge!({:resource_type => (resource.is_a?(Class) ? resource.to_s : resource.class.name)}) if resource
57	#roles.merge!({ :resource_id => resource.id }) if resource && !resource.is_a?(Class)
58	#roles_to_remove = relation.roles.where(roles)
59	#roles_to_remove.each do \|role\|
60	# # Deletion in n-n relations is unreliable. Sometimes it works, sometimes not.
61	# # So, this does not work all the time: `relation.roles.delete(role)`
62	# # @see http://stackoverflow.com/questions/9132596/rails3-mongoid-many-to-many-relation-and-delete-operation
63	# # We instead remove ids from the Role object and the relation object.
64	# relation.role_ids.delete(role.id)
65	# role.send((user_class.to_s.underscore + '_ids').to_sym).delete(relation.id)
66	#
67	# role.destroy if role.send(user_class.to_s.tableize.to_sym).empty?
68	#end
69	cond = { :name => role_name }	12✔
70	cond[:resource_type] = (resource.is_a?(Class) ? resource.to_s : resource.class.name) if resource	12✔
71	cond[:resource_id] = resource.id if resource && !resource.is_a?(Class)	12✔
72	roles = relation.roles.where(cond)	12✔
73	roles.each do \|role\|
74	relation.roles.delete(role)	18✔
75	role.send(ActiveSupport::Inflector.demodulize(user_class).tableize.to_sym).delete(relation)	18✔
76	if Rolify.remove_role_if_empty && role.send(ActiveSupport::Inflector.demodulize(user_class).tableize.to_sym).empty?	18✔
77	role.destroy	18✔
78	end
79	end if roles	12✔
80	roles	12✔
81	end
82
83	def exists?(relation, column)	6✔
84	relation.where(column.to_sym.ne => nil)	×
85	end
86
87	def scope(relation, conditions)	6✔
88	roles = where(role_class, conditions).map { \|role\| role.id }	×
89	return [] if roles.size.zero?	×
90	query = relation.any_in(:role_ids => roles)	×
91	query	×
92	end
93
94	def all_except(user, excluded_obj)	6✔
95	user.not_in(_id: excluded_obj.to_a)	×
96	end
97
98	private	6✔
99
100	def build_conditions(relation, args)	6✔
101	conditions = []	18✔
102	args.each do \|arg\|	18✔
103	if arg.is_a? Hash	18✔
104	query = build_query(arg[:name], arg[:resource])	18✔
105	elsif arg.is_a?(String) \|\| arg.is_a?(Symbol)	×
106	query = build_query(arg)	×
107	else
108	raise ArgumentError, "Invalid argument type: only hash or string or symbol allowed"	×
109	end
110	conditions += query	18✔
111	end
112	conditions	18✔
113	end
114
115	def build_query(role, resource = nil)	6✔
116	return [{ :name => role }] if resource == :any	18✔
117	query = [{ :name => role, :resource_type => nil, :resource_id => nil }]	12✔
118	if resource	12✔
119	query << { :name => role, :resource_type => (resource.is_a?(Class) ? resource.to_s : resource.class.name), :resource_id => nil }	×
120	if !resource.is_a? Class	×
121	query << { :name => role, :resource_type => resource.class.name, :resource_id => resource.id }	×
122	end
123	end
124	query	12✔
125	end
126	end
127	end
128	end

RolifyCommunity / rolify / 671

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous