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
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
|
require 'set'
module Arel
class TypecastError < StandardError ; end
class Attribute
attributes :relation, :name, :alias, :ancestor
deriving :==
delegate :engine, :christener, :to => :relation
def initialize(relation, name, options = {})
@relation, @name, @alias, @ancestor = relation, name, options[:alias], options[:ancestor]
end
def named?(hypothetical_name)
(@alias || name).to_s == hypothetical_name.to_s
end
def aggregation?
false
end
def inspect
"<Attribute #{name}>"
end
module Transformations
def self.included(klass)
klass.send :alias_method, :eql?, :==
end
def hash
@hash ||= history.size + name.hash + relation.hash
end
def as(aliaz = nil)
Attribute.new(relation, name, :alias => aliaz, :ancestor => self)
end
def bind(new_relation)
relation == new_relation ? self : Attribute.new(new_relation, name, :alias => @alias, :ancestor => self)
end
def to_attribute(relation)
bind(relation)
end
end
include Transformations
module Congruence
def history
@history ||= [self] + (ancestor ? ancestor.history : [])
end
def join?
relation.join?
end
def root
history.last
end
def original_relation
@original_relation ||= original_attribute.relation
end
def original_attribute
@original_attribute ||= history.detect { |a| !a.join? }
end
def find_correlate_in(relation)
relation[self] || self
end
def descends_from?(other)
history.include?(other)
end
def /(other)
other ? (history & other.history).size : 0
end
end
include Congruence
module Predications
def eq(other)
Predicates::Equality.new(self, other)
end
def lt(other)
Predicates::LessThan.new(self, other)
end
def lteq(other)
Predicates::LessThanOrEqualTo.new(self, other)
end
def gt(other)
Predicates::GreaterThan.new(self, other)
end
def gteq(other)
Predicates::GreaterThanOrEqualTo.new(self, other)
end
def matches(regexp)
Predicates::Match.new(self, regexp)
end
def in(array)
Predicates::In.new(self, array)
end
end
include Predications
module Expressions
def count(distinct = false)
distinct ? Distinct.new(self).count : Count.new(self)
end
def sum
Sum.new(self)
end
def maximum
Maximum.new(self)
end
def minimum
Minimum.new(self)
end
def average
Average.new(self)
end
end
include Expressions
module Orderings
def asc
Ascending.new(self)
end
def desc
Descending.new(self)
end
alias_method :to_ordering, :asc
end
include Orderings
module Types
def type_cast(value)
if root == self
raise NotImplementedError, "#type_cast should be implemented in a subclass."
else
root.type_cast(value)
end
end
def type_cast_to_numeric(value, method)
return unless value
if value.respond_to?(:to_str)
if value.to_str =~ /\A(-?(?:0|[1-9]\d*)(?:\.\d+)?|(?:\.\d+))\z/
$1.send(method)
else
value
end
elsif value.respond_to?(method)
value.send(method)
else
raise typecast_error(value)
end
end
def typecast_error(value)
raise TypecastError, "could not typecast #{value.inspect} to #{self.class.name.split('::').last}"
end
end
include Types
end
end
|
