blob: faef096792694499d06650721e4d7ac7999e5bc9 (
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
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
|
require 'spec_helper'
module Arel
module Attributes
describe 'attribute' do
describe '#not_eq' do
it 'should create a NotEqual node' do
relation = Table.new(:users)
relation[:id].not_eq(10).should be_kind_of Nodes::NotEqual
end
it 'should generate != in sql' do
relation = Table.new(:users)
mgr = relation.project relation[:id]
mgr.where relation[:id].not_eq(10)
mgr.to_sql.should be_like %{
SELECT "users"."id" FROM "users" WHERE "users"."id" != 10
}
end
it 'should handle nil' do
relation = Table.new(:users)
mgr = relation.project relation[:id]
mgr.where relation[:id].not_eq(nil)
mgr.to_sql.should be_like %{
SELECT "users"."id" FROM "users" WHERE "users"."id" IS NOT NULL
}
end
end
describe '#gt' do
it 'should create a GreaterThan node' do
relation = Table.new(:users)
relation[:id].gt(10).should be_kind_of Nodes::GreaterThan
end
it 'should generate >= in sql' do
relation = Table.new(:users)
mgr = relation.project relation[:id]
mgr.where relation[:id].gt(10)
mgr.to_sql.should be_like %{
SELECT "users"."id" FROM "users" WHERE "users"."id" > 10
}
end
end
describe '#gteq' do
it 'should create a GreaterThanOrEqual node' do
relation = Table.new(:users)
relation[:id].gteq(10).should be_kind_of Nodes::GreaterThanOrEqual
end
it 'should generate >= in sql' do
relation = Table.new(:users)
mgr = relation.project relation[:id]
mgr.where relation[:id].gteq(10)
mgr.to_sql.should be_like %{
SELECT "users"."id" FROM "users" WHERE "users"."id" >= 10
}
end
end
describe '#average' do
it 'should create a AVG node' do
relation = Table.new(:users)
relation[:id].average.should be_kind_of Nodes::Avg
end
# FIXME: backwards compat. Is this really necessary?
it 'should set the alias to "avg_id"' do
relation = Table.new(:users)
mgr = relation.project relation[:id].average
mgr.to_sql.should be_like %{
SELECT AVG("users"."id") AS avg_id
FROM "users"
}
end
end
describe '#maximum' do
it 'should create a MAX node' do
relation = Table.new(:users)
relation[:id].maximum.should be_kind_of Nodes::Max
end
# FIXME: backwards compat. Is this really necessary?
it 'should set the alias to "max_id"' do
relation = Table.new(:users)
mgr = relation.project relation[:id].maximum
mgr.to_sql.should be_like %{
SELECT MAX("users"."id") AS max_id
FROM "users"
}
end
end
describe '#minimum' do
it 'should create a Min node' do
relation = Table.new(:users)
relation[:id].minimum.should be_kind_of Nodes::Min
end
end
describe '#sum' do
it 'should create a SUM node' do
relation = Table.new(:users)
relation[:id].sum.should be_kind_of Nodes::Sum
end
# FIXME: backwards compat. Is this really necessary?
it 'should set the alias to "sum_id"' do
relation = Table.new(:users)
mgr = relation.project relation[:id].sum
mgr.to_sql.should be_like %{
SELECT SUM("users"."id") AS sum_id
FROM "users"
}
end
end
describe '#count' do
it 'should return a count node' do
relation = Table.new(:users)
relation[:id].count.should be_kind_of Nodes::Count
end
it 'should take a distinct param' do
relation = Table.new(:users)
count = relation[:id].count(nil)
count.should be_kind_of Nodes::Count
count.distinct.should be_nil
end
end
describe '#eq' do
it 'should return an equality node' do
attribute = Attribute.new nil, nil, nil
equality = attribute.eq 1
check equality.left.should == attribute
check equality.right.should == 1
equality.should be_kind_of Nodes::Equality
end
end
describe '#in' do
it 'can be constructed with a list' do
end
it 'should return an in node' do
attribute = Attribute.new nil, nil, nil
node = Nodes::In.new attribute, [1,2,3]
check node.left.should == attribute
check node.right.should == [1, 2, 3]
end
end
end
describe 'equality' do
describe '#to_sql' do
it 'should produce sql' do
table = Table.new :users
condition = table['id'].eq 1
condition.to_sql.should == '"users"."id" = 1'
end
end
end
end
end
|
