Class: SimpleQuery::AggregationClause

Inherits:
Object
  • Object
show all
Defined in:
lib/simple_query/clauses/aggregation_clause.rb

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(table) ⇒ AggregationClause

Returns a new instance of AggregationClause.



7
8
9
10
 
# File 'lib/simple_query/clauses/aggregation_clause.rb', line 7

def initialize(table)
  @table = table
  @aggregations = []
end

Instance Attribute Details

#aggregations ⇒ Object (readonly)

Returns the value of attribute aggregations.



5
6
7
 
# File 'lib/simple_query/clauses/aggregation_clause.rb', line 5

def aggregations
  @aggregations
end

Instance Method Details

#avg(column, alias_name: nil) ⇒ Object

Raises:

  • (ArgumentError) 


28
29
30
31
32
33
34
35
 
# File 'lib/simple_query/clauses/aggregation_clause.rb', line 28

def avg(column, alias_name: nil)
  raise ArgumentError, "Column is required for AVG aggregation" if column.nil?

  column_expr = resolve_column(column)
  alias_name ||= "avg_#{sanitize_alias(column)}"

  add_aggregation("AVG", column_expr, alias_name)
end

#clear ⇒ Object 



124
125
126
 
# File 'lib/simple_query/clauses/aggregation_clause.rb', line 124

def clear
  @aggregations.clear
end

#count(column = nil, alias_name: nil) ⇒ Object 



12
13
14
15
16
17
 
# File 'lib/simple_query/clauses/aggregation_clause.rb', line 12

def count(column = nil, alias_name: nil)
  column_expr = column ? resolve_column(column) : "*"
  alias_name ||= column ? "count_#{sanitize_alias(column)}" : "count"

  add_aggregation("COUNT", column_expr, alias_name)
end

#custom(expression, alias_name) ⇒ Object 



55
56
57
58
59
60
61
62
63
64
65
 
# File 'lib/simple_query/clauses/aggregation_clause.rb', line 55

def custom(expression, alias_name)
  if expression.nil? || alias_name.nil?
    raise ArgumentError,
          "Expression and alias are required for custom aggregation"
  end

  @aggregations << {
    expression: expression,
    alias: alias_name
  }
end

#empty? ⇒ Boolean

Returns:

  • (Boolean) 


120
121
122
 
# File 'lib/simple_query/clauses/aggregation_clause.rb', line 120

def empty?
  @aggregations.empty?
end

#group_concat(column, separator: ",", alias_name: nil) ⇒ Object

Group concatenation (database-specific)

Raises:

  • (ArgumentError) 


87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
# File 'lib/simple_query/clauses/aggregation_clause.rb', line 87

def group_concat(column, separator: ",", alias_name: nil)
  raise ArgumentError, "Column is required for GROUP_CONCAT aggregation" if column.nil?

  column_expr = resolve_column(column)
  alias_name ||= "group_concat_#{sanitize_alias(column)}"

  # Use database-specific group concatenation
  adapter = ActiveRecord::Base.connection.adapter_name.downcase

  expression = case adapter
               when /mysql/
                 "GROUP_CONCAT(#{column_expr} SEPARATOR '#{separator}')"
               when /postgres/
                 "STRING_AGG(#{column_expr}::text, '#{separator}')"
               when /sqlite/
                 "GROUP_CONCAT(#{column_expr}, '#{separator}')"
               else
                 # Fallback for other databases
                 "GROUP_CONCAT(#{column_expr})"
               end

  @aggregations << {
    expression: expression,
    alias: alias_name
  }
end

#max(column, alias_name: nil) ⇒ Object

Raises:

  • (ArgumentError) 


46
47
48
49
50
51
52
53
 
# File 'lib/simple_query/clauses/aggregation_clause.rb', line 46

def max(column, alias_name: nil)
  raise ArgumentError, "Column is required for MAX aggregation" if column.nil?

  column_expr = resolve_column(column)
  alias_name ||= "max_#{sanitize_alias(column)}"

  add_aggregation("MAX", column_expr, alias_name)
end

#min(column, alias_name: nil) ⇒ Object

Raises:

  • (ArgumentError) 


37
38
39
40
41
42
43
44
 
# File 'lib/simple_query/clauses/aggregation_clause.rb', line 37

def min(column, alias_name: nil)
  raise ArgumentError, "Column is required for MIN aggregation" if column.nil?

  column_expr = resolve_column(column)
  alias_name ||= "min_#{sanitize_alias(column)}"

  add_aggregation("MIN", column_expr, alias_name)
end

#stddev(column, alias_name: nil) ⇒ Object

Raises:

  • (ArgumentError) 


77
78
79
80
81
82
83
84
 
# File 'lib/simple_query/clauses/aggregation_clause.rb', line 77

def stddev(column, alias_name: nil)
  raise ArgumentError, "Column is required for STDDEV aggregation" if column.nil?

  column_expr = resolve_column(column)
  alias_name ||= "stddev_#{sanitize_alias(column)}"

  add_aggregation("STDDEV", column_expr, alias_name)
end

#sum(column, alias_name: nil) ⇒ Object

Raises:

  • (ArgumentError) 


19
20
21
22
23
24
25
26
 
# File 'lib/simple_query/clauses/aggregation_clause.rb', line 19

def sum(column, alias_name: nil)
  raise ArgumentError, "Column is required for SUM aggregation" if column.nil?

  column_expr = resolve_column(column)
  alias_name ||= "sum_#{sanitize_alias(column)}"

  add_aggregation("SUM", column_expr, alias_name)
end

#to_arel_expressions ⇒ Object 



114
115
116
117
118
 
# File 'lib/simple_query/clauses/aggregation_clause.rb', line 114

def to_arel_expressions
  @aggregations.map do |agg|
    Arel.sql("#{agg[:expression]} AS #{agg[:alias]}")
  end
end

#variance(column, alias_name: nil) ⇒ Object

Statistical functions

Raises:

  • (ArgumentError) 


68
69
70
71
72
73
74
75
 
# File 'lib/simple_query/clauses/aggregation_clause.rb', line 68

def variance(column, alias_name: nil)
  raise ArgumentError, "Column is required for VARIANCE aggregation" if column.nil?

  column_expr = resolve_column(column)
  alias_name ||= "variance_#{sanitize_alias(column)}"

  add_aggregation("VARIANCE", column_expr, alias_name)
end