aboutsummaryrefslogtreecommitdiffstats
path: root/lib/active_relation/primitives/attribute.rb
blob: 8d40a4141f72ec7325209bae6a5830869cf1c2e3 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
module ActiveRelation
  class Attribute
    attr_reader :relation, :name, :alias

    def initialize(relation, name, aliaz = nil)
      @relation, @name, @alias = relation, name, aliaz
    end

    module Transformations
      def as(aliaz = nil)
        Attribute.new(relation, name, aliaz)
      end
    
      def substitute(new_relation)
        Attribute.new(new_relation, name, @alias)
      end

      def qualify
        self.as(qualified_name)
      end
      
      def to_attribute
        self
      end
    end
    include Transformations
    
    def qualified_name
      "#{relation.name}.#{name}"
    end

    def ==(other)
      self.class == other.class and relation == other.relation and name == other.name and @alias == other.alias
    end

    module Predications
      def equals(other)
        Equality.new(self, other)
      end

      def less_than(other)
        LessThan.new(self, other)
      end

      def less_than_or_equal_to(other)
        LessThanOrEqualTo.new(self, other)
      end

      def greater_than(other)
        GreaterThan.new(self, other)
      end

      def greater_than_or_equal_to(other)
        GreaterThanOrEqualTo.new(self, other)
      end

      def matches(regexp)
        Match.new(self, regexp)
      end
    end
    include Predications
    
    module Expressions
      def count
        Expression.new(self, "COUNT")
      end
      
      def sum
        Expression.new(self, "SUM")
      end
      
      def maximum
        Expression.new(self, "MAX")
      end
      
      def minimum
        Expression.new(self, "MIN")
      end
      
      def average
        Expression.new(self, "AVG")
      end
    end
    include Expressions

    def to_sql(strategy = Sql::Predicate.new)
      strategy.attribute relation.name, name, self.alias
    end
  end
end