composite_primary_keys 14.0.3 → 14.0.9

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (52) hide show
  1. checksums.yaml +4 -4
  2. data/History.rdoc +49 -0
  3. data/README.rdoc +182 -182
  4. data/Rakefile +1 -1
  5. data/lib/composite_primary_keys/associations/association.rb +2 -2
  6. data/lib/composite_primary_keys/associations/association_scope.rb +1 -1
  7. data/lib/composite_primary_keys/associations/collection_association.rb +10 -3
  8. data/lib/composite_primary_keys/associations/has_many_through_association.rb +19 -0
  9. data/lib/composite_primary_keys/associations/preloader/association.rb +52 -68
  10. data/lib/composite_primary_keys/autosave_association.rb +1 -1
  11. data/lib/composite_primary_keys/composite_arrays.rb +2 -0
  12. data/lib/composite_primary_keys/composite_predicates.rb +121 -71
  13. data/lib/composite_primary_keys/connection_adapters/abstract/database_statements.rb +1 -2
  14. data/lib/composite_primary_keys/nested_attributes.rb +2 -2
  15. data/lib/composite_primary_keys/persistence.rb +96 -96
  16. data/lib/composite_primary_keys/relation/calculations.rb +110 -110
  17. data/lib/composite_primary_keys/relation/query_methods.rb +14 -16
  18. data/lib/composite_primary_keys/relation.rb +4 -2
  19. data/lib/composite_primary_keys/validations/uniqueness.rb +10 -2
  20. data/lib/composite_primary_keys/version.rb +1 -1
  21. data/lib/composite_primary_keys.rb +117 -119
  22. data/scripts/console.rb +2 -2
  23. data/tasks/databases/trilogy.rake +23 -0
  24. data/test/abstract_unit.rb +124 -118
  25. data/test/connections/databases.ci.yml +10 -0
  26. data/test/fixtures/admin.rb +4 -0
  27. data/test/fixtures/comments.yml +6 -0
  28. data/test/fixtures/db_definitions/db2-create-tables.sql +34 -0
  29. data/test/fixtures/db_definitions/db2-drop-tables.sql +7 -1
  30. data/test/fixtures/db_definitions/mysql.sql +23 -0
  31. data/test/fixtures/db_definitions/oracle.drop.sql +4 -0
  32. data/test/fixtures/db_definitions/oracle.sql +21 -0
  33. data/test/fixtures/db_definitions/postgresql.sql +23 -0
  34. data/test/fixtures/db_definitions/sqlite.sql +21 -0
  35. data/test/fixtures/db_definitions/sqlserver.sql +23 -0
  36. data/test/fixtures/department.rb +20 -16
  37. data/test/fixtures/moderator.rb +4 -0
  38. data/test/fixtures/room.rb +4 -1
  39. data/test/fixtures/room_assignment.rb +6 -2
  40. data/test/fixtures/staff_room.rb +6 -0
  41. data/test/fixtures/staff_room_key.rb +6 -0
  42. data/test/fixtures/user.rb +3 -0
  43. data/test/fixtures/user_with_polymorphic_name.rb +9 -0
  44. data/test/test_associations.rb +403 -372
  45. data/test/test_composite_arrays.rb +6 -0
  46. data/test/test_create.rb +219 -218
  47. data/test/test_has_one_through.rb +30 -0
  48. data/test/test_nested_attributes.rb +23 -0
  49. data/test/test_polymorphic.rb +6 -0
  50. data/test/test_predicates.rb +130 -60
  51. metadata +13 -6
  52. data/lib/composite_primary_keys/associations/through_association.rb +0 -24
@@ -1,71 +1,121 @@
1
- module CompositePrimaryKeys
2
- module Predicates
3
- # Similar to module_function, but does not make instance methods private.
4
- # https://idiosyncratic-ruby.com/8-self-improvement.html
5
- extend self
6
-
7
- def cpk_and_predicate(predicates)
8
- if predicates.length == 1
9
- predicates.first
10
- else
11
- Arel::Nodes::And.new(predicates)
12
- end
13
- end
14
-
15
- def cpk_or_predicate(predicates, group = true)
16
- if predicates.length <= 1
17
- predicates.first
18
- else
19
- split_point = predicates.length / 2
20
- predicates_first_half = predicates[0...split_point]
21
- predicates_second_half = predicates[split_point..-1]
22
-
23
- or_predicate = ::Arel::Nodes::Or.new(cpk_or_predicate(predicates_first_half, false),
24
- cpk_or_predicate(predicates_second_half, false))
25
-
26
- if group
27
- ::Arel::Nodes::Grouping.new(or_predicate)
28
- else
29
- or_predicate
30
- end
31
- end
32
- end
33
-
34
- def cpk_id_predicate(table, keys, values)
35
- # We zip on values then keys in case values are not provided for each key field
36
- eq_predicates = values.zip(keys).map do |value, key|
37
- table[key].eq(value)
38
- end
39
- cpk_and_predicate(eq_predicates)
40
- end
41
-
42
- def cpk_join_predicate(table1, key1, table2, key2)
43
- key1_fields = Array(key1).map {|key| table1[key]}
44
- key2_fields = Array(key2).map {|key| table2[key]}
45
-
46
- eq_predicates = key1_fields.zip(key2_fields).map do |key_field1, key_field2|
47
- key_field2 = Arel::Nodes::Quoted.new(key_field2) unless Arel::Attributes::Attribute === key_field2
48
- key_field1.eq(key_field2)
49
- end
50
- cpk_and_predicate(eq_predicates)
51
- end
52
-
53
- def cpk_in_predicate(table, primary_keys, ids)
54
- and_predicates = ids.map do |id|
55
- cpk_id_predicate(table, primary_keys, id)
56
- end
57
- cpk_or_predicate(and_predicates)
58
- end
59
- end
60
- end
61
-
62
- ActiveRecord::Associations::AssociationScope.send(:include, CompositePrimaryKeys::Predicates)
63
- ActiveRecord::Associations::JoinDependency::JoinAssociation.send(:include, CompositePrimaryKeys::Predicates)
64
- ActiveRecord::Associations::Preloader::Association.send(:include, CompositePrimaryKeys::Predicates)
65
- ActiveRecord::Associations::Preloader::Association::LoaderQuery.send(:include, CompositePrimaryKeys::Predicates)
66
- ActiveRecord::Associations::HasManyAssociation.send(:include, CompositePrimaryKeys::Predicates)
67
- ActiveRecord::Associations::HasManyThroughAssociation.send(:include, CompositePrimaryKeys::Predicates)
68
- ActiveRecord::Base.send(:extend, CompositePrimaryKeys::Predicates)
69
- ActiveRecord::Reflection::AbstractReflection.send(:include, CompositePrimaryKeys::Predicates)
70
- ActiveRecord::Relation.send(:include, CompositePrimaryKeys::Predicates)
71
- ActiveRecord::PredicateBuilder.send(:extend, CompositePrimaryKeys::Predicates)
1
+ module CompositePrimaryKeys
2
+ module Predicates
3
+ # Similar to module_function, but does not make instance methods private.
4
+ # https://idiosyncratic-ruby.com/8-self-improvement.html
5
+ extend self
6
+
7
+ def cpk_and_predicate(predicates)
8
+ if predicates.length == 1
9
+ predicates.first
10
+ else
11
+ Arel::Nodes::And.new(predicates)
12
+ end
13
+ end
14
+
15
+ def cpk_or_predicate(predicates, group = true)
16
+ if predicates.length <= 1
17
+ predicates.first
18
+ else
19
+ split_point = predicates.length / 2
20
+ predicates_first_half = predicates[0...split_point]
21
+ predicates_second_half = predicates[split_point..-1]
22
+
23
+ or_predicate = ::Arel::Nodes::Or.new(cpk_or_predicate(predicates_first_half, false),
24
+ cpk_or_predicate(predicates_second_half, false))
25
+
26
+ if group
27
+ ::Arel::Nodes::Grouping.new(or_predicate)
28
+ else
29
+ or_predicate
30
+ end
31
+ end
32
+ end
33
+
34
+ def cpk_id_predicate(table, keys, values)
35
+ # We zip on values then keys in case values are not provided for each key field
36
+ eq_predicates = values.zip(keys).map do |value, key|
37
+ table[key].eq(value)
38
+ end
39
+ cpk_and_predicate(eq_predicates)
40
+ end
41
+
42
+ def cpk_join_predicate(table1, key1, table2, key2)
43
+ key1_fields = Array(key1).map {|key| table1[key]}
44
+ key2_fields = Array(key2).map {|key| table2[key]}
45
+
46
+ eq_predicates = key1_fields.zip(key2_fields).map do |key_field1, key_field2|
47
+ key_field2 = Arel::Nodes::Quoted.new(key_field2) unless Arel::Attributes::Attribute === key_field2
48
+ key_field1.eq(key_field2)
49
+ end
50
+ cpk_and_predicate(eq_predicates)
51
+ end
52
+
53
+ def cpk_in_predicate(table, primary_keys, ids)
54
+ if primary_keys.length == 2
55
+ cpk_in_predicate_with_grouped_keys(table, primary_keys, ids)
56
+ else
57
+ cpk_in_predicate_with_non_grouped_keys(table, primary_keys, ids)
58
+ end
59
+ end
60
+
61
+ def cpk_in_predicate_with_non_grouped_keys(table, primary_keys, ids)
62
+ and_predicates = ids.map do |id|
63
+ cpk_id_predicate(table, primary_keys, id)
64
+ end
65
+
66
+ cpk_or_predicate(and_predicates)
67
+ end
68
+
69
+ def cpk_in_predicate_with_grouped_keys(table, primary_keys, ids)
70
+ keys_by_first_column_name = Hash.new { |hash, key| hash[key] = [] }
71
+ keys_by_second_column_name = Hash.new { |hash, key| hash[key] = [] }
72
+
73
+ ids.map.each do |first_key_part, second_key_part|
74
+ keys_by_first_column_name[first_key_part] << second_key_part
75
+ keys_by_second_column_name[second_key_part] << first_key_part
76
+ end
77
+
78
+ low_cardinality_column_name, high_cardinality_column_name, groups = \
79
+ if keys_by_first_column_name.size <= keys_by_second_column_name.size
80
+ [primary_keys.first, primary_keys.second, keys_by_first_column_name]
81
+ else
82
+ [primary_keys.second, primary_keys.first, keys_by_second_column_name]
83
+ end
84
+
85
+ and_predicates = groups.map do |low_cardinality_value, high_cardinality_values|
86
+ non_nil_high_cardinality_values = high_cardinality_values.compact
87
+ in_clause = table[high_cardinality_column_name].in(non_nil_high_cardinality_values)
88
+ inclusion_clauses = if non_nil_high_cardinality_values.size != high_cardinality_values.size
89
+ Arel::Nodes::Grouping.new(
90
+ Arel::Nodes::Or.new(
91
+ in_clause,
92
+ table[high_cardinality_column_name].eq(nil)
93
+ )
94
+ )
95
+ else
96
+ in_clause
97
+ end
98
+
99
+ Arel::Nodes::And.new(
100
+ [
101
+ table[low_cardinality_column_name].eq(low_cardinality_value),
102
+ inclusion_clauses
103
+ ]
104
+ )
105
+ end
106
+
107
+ cpk_or_predicate(and_predicates)
108
+ end
109
+ end
110
+ end
111
+
112
+ ActiveRecord::Associations::AssociationScope.send(:include, CompositePrimaryKeys::Predicates)
113
+ ActiveRecord::Associations::JoinDependency::JoinAssociation.send(:include, CompositePrimaryKeys::Predicates)
114
+ ActiveRecord::Associations::Preloader::Association.send(:include, CompositePrimaryKeys::Predicates)
115
+ ActiveRecord::Associations::Preloader::Association::LoaderQuery.send(:include, CompositePrimaryKeys::Predicates)
116
+ ActiveRecord::Associations::HasManyAssociation.send(:include, CompositePrimaryKeys::Predicates)
117
+ ActiveRecord::Associations::HasManyThroughAssociation.send(:include, CompositePrimaryKeys::Predicates)
118
+ ActiveRecord::Base.send(:extend, CompositePrimaryKeys::Predicates)
119
+ ActiveRecord::Reflection::AbstractReflection.send(:include, CompositePrimaryKeys::Predicates)
120
+ ActiveRecord::Relation.send(:include, CompositePrimaryKeys::Predicates)
121
+ ActiveRecord::PredicateBuilder.send(:extend, CompositePrimaryKeys::Predicates)
@@ -6,8 +6,7 @@ module ActiveRecord
6
6
  value = exec_insert(sql, name, binds, pk, sequence_name)
7
7
 
8
8
  return id_value if id_value
9
-
10
- if pk.is_a?(Array) && !value.empty?
9
+ if pk.is_a?(Array) && value.respond_to?(:empty?) && !value.empty?
11
10
  # This is a CPK model and the query result is not empty. Thus we can figure out the new ids for each
12
11
  # auto incremented field
13
12
  pk.map {|key| value.first[key]}
@@ -61,12 +61,12 @@ module ActiveRecord
61
61
  unless reject_new_record?(association_name, attributes)
62
62
  association.reader.build(attributes.except(*UNASSIGNABLE_KEYS))
63
63
  end
64
- elsif existing_record = existing_records.detect { |record| record.id.to_s == attributes["id"].to_s }
64
+ elsif existing_record = cpk_detect_record(attributes['id'], existing_records)
65
65
  unless call_reject_if(association_name, attributes)
66
66
  # Make sure we are operating on the actual object which is in the association's
67
67
  # proxy_target array (either by finding it, or adding it if not found)
68
68
  # Take into account that the proxy_target may have changed due to callbacks
69
- target_record = association.target.detect { |record| record.id.to_s == attributes["id"].to_s }
69
+ target_record = cpk_detect_record(attributes['id'], association.target)
70
70
  if target_record
71
71
  existing_record = target_record
72
72
  else
@@ -1,96 +1,96 @@
1
- module ActiveRecord
2
- module Persistence
3
- module ClassMethods
4
- def delete(id_or_array)
5
- # CPK
6
- if self.composite?
7
- id_or_array = if id_or_array.is_a?(CompositePrimaryKeys::CompositeKeys)
8
- [id_or_array]
9
- else
10
- Array(id_or_array)
11
- end
12
-
13
- # Delete should return the number of deleted records
14
- id_or_array.map do |id|
15
- # Is the passed in id actually a record?
16
- id = id.kind_of?(::ActiveRecord::Base) ? id.id : id
17
- delete_by(cpk_id_predicate(self.arel_table, self.primary_key, id))
18
- end.sum
19
- else
20
- delete_by(primary_key => id_or_array)
21
- end
22
- end
23
-
24
- def _update_record(values, constraints) # :nodoc:
25
- # CPK
26
- if self.composite? && constraints[primary_key]
27
- primary_key_values = constraints.delete(primary_key)
28
- primary_key.each_with_index do |key, i|
29
- constraints[key] = primary_key_values[i]
30
- end
31
- end
32
-
33
- constraints = constraints.map { |name, value| predicate_builder[name, value] }
34
-
35
- default_constraint = build_default_constraint
36
- constraints << default_constraint if default_constraint
37
-
38
- if current_scope = self.global_current_scope
39
- constraints << current_scope.where_clause.ast
40
- end
41
-
42
- um = Arel::UpdateManager.new(arel_table)
43
- um.set(values.transform_keys { |name| arel_table[name] })
44
- um.wheres = constraints
45
-
46
- connection.update(um, "#{self} Update")
47
- end
48
-
49
- def _delete_record(constraints) # :nodoc:
50
- # CPK
51
- if self.composite? && constraints[primary_key]
52
- primary_key_values = constraints.delete(primary_key)
53
- primary_key.each_with_index do |key, i|
54
- constraints[key] = primary_key_values[i]
55
- end
56
- end
57
-
58
- constraints = constraints.map { |name, value| predicate_builder[name, value] }
59
-
60
- default_constraint = build_default_constraint
61
- constraints << default_constraint if default_constraint
62
-
63
- if current_scope = self.global_current_scope
64
- constraints << current_scope.where_clause.ast
65
- end
66
-
67
- dm = Arel::DeleteManager.new(arel_table)
68
- dm.wheres = constraints
69
-
70
- connection.delete(dm, "#{self} Destroy")
71
- end
72
- end
73
-
74
- def _create_record(attribute_names = self.attribute_names)
75
- attribute_names = attributes_for_create(attribute_names)
76
-
77
- new_id = self.class._insert_record(
78
- attributes_with_values(attribute_names)
79
- )
80
-
81
- # CPK
82
- if self.composite?
83
- self.id = self.id.zip(Array(new_id)).map {|id1, id2| id2.nil? ? id1 : id2}
84
- else
85
- self.id ||= new_id if self.class.primary_key
86
- end
87
-
88
- @new_record = false
89
- @previously_new_record = true
90
-
91
- yield(self) if block_given?
92
-
93
- id
94
- end
95
- end
96
- end
1
+ module ActiveRecord
2
+ module Persistence
3
+ module ClassMethods
4
+ def delete(id_or_array)
5
+ # CPK
6
+ if self.composite?
7
+ id_or_array = if id_or_array.is_a?(CompositePrimaryKeys::CompositeKeys)
8
+ [id_or_array]
9
+ else
10
+ Array(id_or_array)
11
+ end
12
+
13
+ # Delete should return the number of deleted records
14
+ id_or_array.map do |id|
15
+ # Is the passed in id actually a record?
16
+ id = id.kind_of?(::ActiveRecord::Base) ? id.id : id
17
+ delete_by(cpk_id_predicate(self.arel_table, self.primary_key, id))
18
+ end.sum
19
+ else
20
+ delete_by(primary_key => id_or_array)
21
+ end
22
+ end
23
+
24
+ def _update_record(values, constraints) # :nodoc:
25
+ # CPK
26
+ if self.composite? && constraints[primary_key]
27
+ primary_key_values = constraints.delete(primary_key)
28
+ primary_key.each_with_index do |key, i|
29
+ constraints[key] = primary_key_values[i]
30
+ end
31
+ end
32
+
33
+ constraints = constraints.map { |name, value| predicate_builder[name, value] }
34
+
35
+ default_constraint = build_default_constraint
36
+ constraints << default_constraint if default_constraint
37
+
38
+ if current_scope = self.global_current_scope
39
+ constraints << current_scope.where_clause.ast
40
+ end
41
+
42
+ um = Arel::UpdateManager.new(arel_table)
43
+ um.set(values.transform_keys { |name| arel_table[name] })
44
+ um.wheres = constraints
45
+
46
+ connection.update(um, "#{self} Update")
47
+ end
48
+
49
+ def _delete_record(constraints) # :nodoc:
50
+ # CPK
51
+ if self.composite? && constraints[primary_key]
52
+ primary_key_values = constraints.delete(primary_key)
53
+ primary_key.each_with_index do |key, i|
54
+ constraints[key] = primary_key_values[i]
55
+ end
56
+ end
57
+
58
+ constraints = constraints.map { |name, value| predicate_builder[name, value] }
59
+
60
+ default_constraint = build_default_constraint
61
+ constraints << default_constraint if default_constraint
62
+
63
+ if current_scope = self.global_current_scope
64
+ constraints << current_scope.where_clause.ast
65
+ end
66
+
67
+ dm = Arel::DeleteManager.new(arel_table)
68
+ dm.wheres = constraints
69
+
70
+ connection.delete(dm, "#{self} Destroy")
71
+ end
72
+ end
73
+
74
+ def _create_record(attribute_names = self.attribute_names)
75
+ attribute_names = attributes_for_create(attribute_names)
76
+
77
+ new_id = self.class._insert_record(
78
+ attributes_with_values(attribute_names)
79
+ )
80
+
81
+ # CPK
82
+ if self.composite?
83
+ self.id = self.id.zip(Array(new_id)).map {|id1, id2| id2.nil? ? id1 : id2}
84
+ else
85
+ self.id ||= new_id if self.class.primary_key
86
+ end
87
+
88
+ @new_record = false
89
+ @previously_new_record = true
90
+
91
+ yield(self) if block_given?
92
+
93
+ id
94
+ end
95
+ end
96
+ end
@@ -1,110 +1,110 @@
1
- module CompositePrimaryKeys
2
- module ActiveRecord
3
- module Calculations
4
- def aggregate_column(column_name)
5
- # CPK
6
- if column_name.kind_of?(Array)
7
- # Note: Test don't seem to run this code?
8
- column_name.map do |column|
9
- @klass.arel_table[column]
10
- end
11
- elsif @klass.has_attribute?(column_name) || @klass.attribute_alias?(column_name)
12
- @klass.arel_table[column_name]
13
- else
14
- Arel.sql(column_name == :all ? "*" : column_name.to_s)
15
- end
16
- end
17
-
18
- def execute_simple_calculation(operation, column_name, distinct) #:nodoc:
19
- column_alias = column_name
20
-
21
- # CPK
22
- # if operation == "count" && (column_name == :all && distinct || has_limit_or_offset?)
23
- # # Shortcut when limit is zero.
24
- # return 0 if limit_value == 0
25
- #
26
- # query_builder = build_count_subquery(spawn, column_name, distinct)
27
- if operation == "count"
28
- relation = unscope(:order)
29
- query_builder = build_count_subquery(spawn, column_name, distinct)
30
- else
31
- # PostgreSQL doesn't like ORDER BY when there are no GROUP BY
32
- relation = unscope(:order).distinct!(false)
33
-
34
- column = aggregate_column(column_name)
35
- select_value = operation_over_aggregate_column(column, operation, distinct)
36
- select_value.distinct = true if operation == "sum" && distinct
37
-
38
- relation.select_values = [select_value]
39
-
40
- query_builder = relation.arel
41
- end
42
-
43
- result = skip_query_cache_if_necessary { @klass.connection.select_all(query_builder) }
44
-
45
- if operation != "count"
46
- type = column.try(:type_caster) ||
47
- lookup_cast_type_from_join_dependencies(column_name.to_s) || ::ActiveRecord::Type.default_value
48
- type = type.subtype if ::ActiveRecord::Enum::EnumType === type
49
- end
50
-
51
- type_cast_calculated_value(result.cast_values.first, operation, type) do |value|
52
- type = column.try(:type_caster) ||
53
- # CPK
54
- # lookup_cast_type_from_join_dependencies(column_name.to_s) || Type.default_value
55
- lookup_cast_type_from_join_dependencies(column_name.to_s) || ::ActiveRecord::Type.default_value
56
- type.deserialize(value)
57
- end
58
- end
59
-
60
- def build_count_subquery(relation, column_name, distinct)
61
- if column_name == :all
62
- column_alias = Arel.star
63
- # CPK
64
- # relation.select_values = [ Arel.sql(FinderMethods::ONE_AS_ONE) ] unless distinct
65
- relation.select_values = [ Arel.sql(::ActiveRecord::FinderMethods::ONE_AS_ONE) ] unless distinct
66
- elsif column_name.is_a?(Array)
67
- column_alias = Arel.star
68
- relation.select_values = column_name.map do |column|
69
- Arel::Attribute.new(@klass.unscoped.table, column)
70
- end
71
- else
72
- column_alias = Arel.sql("count_column")
73
- relation.select_values = [ aggregate_column(column_name).as(column_alias) ]
74
- end
75
-
76
- subquery_alias = Arel.sql("subquery_for_count")
77
- select_value = operation_over_aggregate_column(column_alias, "count", false)
78
-
79
- relation.build_subquery(subquery_alias, select_value)
80
- end
81
-
82
- def calculate(operation, column_name)
83
- if has_include?(column_name)
84
- relation = apply_join_dependency
85
-
86
- if operation.to_s.downcase == "count"
87
- unless distinct_value || distinct_select?(column_name || select_for_count)
88
- relation.distinct!
89
- # CPK
90
- # relation.select_values = [ klass.primary_key || table[Arel.star] ]
91
- if klass.primary_key.present? && klass.primary_key.is_a?(Array)
92
- relation.select_values = klass.primary_key.map do |k|
93
- "#{connection.quote_table_name(klass.table_name)}.#{connection.quote_column_name(k)}"
94
- end
95
- else
96
- relation.select_values = [ klass.primary_key || table[Arel.star] ]
97
- end
98
- end
99
- # PostgreSQL: ORDER BY expressions must appear in SELECT list when using DISTINCT
100
- relation.order_values = [] if group_values.empty?
101
- end
102
-
103
- relation.calculate(operation, column_name)
104
- else
105
- perform_calculation(operation, column_name)
106
- end
107
- end
108
- end
109
- end
110
- end
1
+ module CompositePrimaryKeys
2
+ module ActiveRecord
3
+ module Calculations
4
+ def aggregate_column(column_name)
5
+ # CPK
6
+ if column_name.kind_of?(Array)
7
+ # Note: Test don't seem to run this code?
8
+ column_name.map do |column|
9
+ @klass.arel_table[column]
10
+ end
11
+ elsif @klass.has_attribute?(column_name) || @klass.attribute_alias?(column_name)
12
+ @klass.arel_table[column_name]
13
+ else
14
+ Arel.sql(column_name == :all ? "*" : column_name.to_s)
15
+ end
16
+ end
17
+
18
+ def execute_simple_calculation(operation, column_name, distinct) #:nodoc:
19
+ column_alias = column_name
20
+
21
+ # CPK
22
+ # if operation == "count" && (column_name == :all && distinct || has_limit_or_offset?)
23
+ # # Shortcut when limit is zero.
24
+ # return 0 if limit_value == 0
25
+ #
26
+ # query_builder = build_count_subquery(spawn, column_name, distinct)
27
+ if operation == "count"
28
+ relation = unscope(:order)
29
+ query_builder = build_count_subquery(spawn, column_name, distinct)
30
+ else
31
+ # PostgreSQL doesn't like ORDER BY when there are no GROUP BY
32
+ relation = unscope(:order).distinct!(false)
33
+
34
+ column = aggregate_column(column_name)
35
+ select_value = operation_over_aggregate_column(column, operation, distinct)
36
+ select_value.distinct = true if operation == "sum" && distinct
37
+
38
+ relation.select_values = [select_value]
39
+
40
+ query_builder = relation.arel
41
+ end
42
+
43
+ result = skip_query_cache_if_necessary { @klass.connection.select_all(query_builder) }
44
+
45
+ if operation != "count"
46
+ type = column.try(:type_caster) ||
47
+ lookup_cast_type_from_join_dependencies(column_name.to_s) || ::ActiveRecord::Type.default_value
48
+ type = type.subtype if ::ActiveRecord::Enum::EnumType === type
49
+ end
50
+
51
+ type_cast_calculated_value(result.cast_values.first, operation, type) do |value|
52
+ type = column.try(:type_caster) ||
53
+ # CPK
54
+ # lookup_cast_type_from_join_dependencies(column_name.to_s) || Type.default_value
55
+ lookup_cast_type_from_join_dependencies(column_name.to_s) || ::ActiveRecord::Type.default_value
56
+ type.deserialize(value)
57
+ end
58
+ end
59
+
60
+ def build_count_subquery(relation, column_name, distinct)
61
+ if column_name == :all
62
+ column_alias = Arel.star
63
+ # CPK
64
+ # relation.select_values = [ Arel.sql(FinderMethods::ONE_AS_ONE) ] unless distinct
65
+ relation.select_values = [ Arel.sql(::ActiveRecord::FinderMethods::ONE_AS_ONE) ] unless distinct
66
+ elsif column_name.is_a?(Array)
67
+ column_alias = Arel.star
68
+ relation.select_values = column_name.map do |column|
69
+ Arel::Attribute.new(@klass.unscoped.table, column)
70
+ end
71
+ else
72
+ column_alias = Arel.sql("count_column")
73
+ relation.select_values = [ aggregate_column(column_name).as(column_alias) ]
74
+ end
75
+
76
+ subquery_alias = Arel.sql("subquery_for_count")
77
+ select_value = operation_over_aggregate_column(column_alias, "count", false)
78
+
79
+ relation.build_subquery(subquery_alias, select_value)
80
+ end
81
+
82
+ def calculate(operation, column_name)
83
+ if has_include?(column_name)
84
+ relation = apply_join_dependency
85
+
86
+ if operation.to_s.downcase == "count"
87
+ unless distinct_value || distinct_select?(column_name || select_for_count)
88
+ relation.distinct!
89
+ # CPK
90
+ # relation.select_values = [ klass.primary_key || table[Arel.star] ]
91
+ if klass.primary_key.present? && klass.primary_key.is_a?(Array)
92
+ relation.select_values = klass.primary_key.map do |k|
93
+ "#{connection.quote_table_name(klass.table_name)}.#{connection.quote_column_name(k)}"
94
+ end
95
+ else
96
+ relation.select_values = [ klass.primary_key || table[Arel.star] ]
97
+ end
98
+ end
99
+ # PostgreSQL: ORDER BY expressions must appear in SELECT list when using DISTINCT
100
+ relation.order_values = [] if group_values.empty?
101
+ end
102
+
103
+ relation.calculate(operation, column_name)
104
+ else
105
+ perform_calculation(operation, column_name)
106
+ end
107
+ end
108
+ end
109
+ end
110
+ end