arel_extensions 0.8.3 → 0.8.4

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 (38) hide show
  1. checksums.yaml +4 -4
  2. data/.travis/oracle/download.js +116 -0
  3. data/.travis/oracle/download.sh +16 -0
  4. data/.travis/oracle/install.sh +32 -0
  5. data/.travis.yml +72 -69
  6. data/Rakefile +29 -4
  7. data/arel_extensions.gemspec +1 -1
  8. data/functions.html +21 -12
  9. data/gemfiles/rails4.gemfile +11 -3
  10. data/gemfiles/rails5.gemfile +8 -4
  11. data/lib/arel_extensions/math.rb +2 -2
  12. data/lib/arel_extensions/math_functions.rb +1 -1
  13. data/lib/arel_extensions/nodes/concat.rb +16 -0
  14. data/lib/arel_extensions/nodes/date_diff.rb +37 -25
  15. data/lib/arel_extensions/nodes/function.rb +30 -0
  16. data/lib/arel_extensions/nodes/is_null.rb +6 -0
  17. data/lib/arel_extensions/nodes/replace.rb +8 -26
  18. data/lib/arel_extensions/nodes/round.rb +6 -6
  19. data/lib/arel_extensions/nodes.rb +1 -1
  20. data/lib/arel_extensions/null_functions.rb +2 -2
  21. data/lib/arel_extensions/string_functions.rb +5 -1
  22. data/lib/arel_extensions/version.rb +1 -1
  23. data/lib/arel_extensions/visitors/mysql.rb +89 -113
  24. data/lib/arel_extensions/visitors/oracle.rb +28 -65
  25. data/lib/arel_extensions/visitors/postgresql.rb +82 -121
  26. data/lib/arel_extensions/visitors/sqlite.rb +60 -55
  27. data/lib/arel_extensions/visitors/to_sql.rb +30 -5
  28. data/test/database.yml +15 -3
  29. data/test/real_db_test.rb +0 -1
  30. data/test/visitors/test_bulk_insert_sqlite.rb +2 -1
  31. data/test/visitors/test_oracle.rb +2 -2
  32. data/test/visitors/test_to_sql.rb +3 -4
  33. data/test/with_ar/all_agnostic_test.rb +294 -0
  34. data/test/with_ar/insert_agnostic_test.rb +52 -0
  35. data/test/with_ar/test_bulk_sqlite.rb +3 -2
  36. metadata +10 -5
  37. data/lib/arel_extensions/nodes/isnull.rb +0 -30
  38. data/test/with_ar/test_string_postgresql.rb +0 -81
@@ -2,102 +2,22 @@ module ArelExtensions
2
2
  module Visitors
3
3
  Arel::Visitors::PostgreSQL.class_eval do
4
4
 
5
- def visit_ArelExtensions_Nodes_DateDiff o, collector
6
-
7
- collector = visit o.left, collector
8
- collector << " -"
9
- if(o.right.is_a?(Arel::Attributes::Attribute))
10
- collector = visit o.left, collector
11
- else
12
- collector << " date '#{o.right}'"
13
- end
14
- collector
15
- end
16
-
17
-
18
- def visit_ArelExtensions_Nodes_Duration o, collector
19
- #visit left for period
20
- if o.left == "d"
21
- collector << "EXTRACT(DAY FROM"
22
- elsif o.left == "m"
23
- collector << "EXTRACT(MONTH FROM "
24
- elsif (o.left == "w")
25
- collector << "EXTRACT(WEEK FROM"
26
- elsif (o.left == "y")
27
- collector << "EXTRACT(YEAR FROM"
28
- end
29
- #visit right
30
- if(o.right.is_a?(Arel::Attributes::Attribute))
31
- collector = visit o.right, collector
32
- else
33
- collector << o.right
34
- end
35
- collector << ")"
36
- collector
37
- end
38
-
39
- def visit_ArelExtensions_Nodes_Locate o, collector
40
- collector << "position("
41
- if(o.val.is_a?(Arel::Attributes::Attribute))
42
- collector = visit o.val, collector
43
- else
44
- collector << "'#{o.val}'"
45
- end
46
- collector << " IN "
47
- collector = visit o.expr, collector
48
- collector << ")"
49
- collector
50
- end
51
-
52
- def visit_ArelExtensions_Nodes_Isnull o, collector
53
- collector << "coalesce("
54
- collector = visit o.left, collector
55
- collector << ","
56
- if(o.right.is_a?(Arel::Attributes::Attribute))
57
- collector = visit o.right, collector
58
- else
59
- collector << "'#{o.right}'"
60
- end
61
- collector << ")"
62
- collector
63
- end
64
-
65
5
  def visit_ArelExtensions_Nodes_Rand o, collector
66
- collector << "random("
6
+ collector << "RANDOM("
67
7
  if(o.left != nil && o.right != nil)
68
- collector << "'#{o.left}'"
69
- collector << ","
70
- collector << "'#{o.right}'"
8
+ collector = visit o.left, collector
9
+ collector << Arel::Visitors::PostgreSQL::COMMA
10
+ collector = isit o.right, collector
71
11
  end
72
12
  collector << ")"
73
13
  collector
74
14
  end
75
15
 
76
- def visit_ArelExtensions_Nodes_Replace o, collector
77
- collector << "REPLACE("
78
- collector = visit o.expr,collector
79
- collector << ","
80
- if(o.left.is_a?(Arel::Attributes::Attribute))
81
- collector = visit o.left, collector
82
- else
83
- collector << "'#{o.left}'"
84
- end
85
- collector << ","
86
- if(o.right.is_a?(Arel::Attributes::Attribute))
87
- collector = visit o.right, collector
88
- else
89
- collector << "'#{o.right}'"
90
- end
91
- collector << ")"
92
- collector
93
- end
94
-
95
-
96
16
  remove_method(:visit_Arel_Nodes_Regexp) rescue nil
97
17
  def visit_Arel_Nodes_Regexp o, collector
98
18
  collector = visit o.left, collector
99
19
  collector << " ~ "
100
- collector << "'#{o.right}'"
20
+ collector = visit o.right, collector
101
21
  collector
102
22
  end
103
23
 
@@ -105,72 +25,113 @@ module ArelExtensions
105
25
  def visit_Arel_Nodes_NotRegexp o, collector
106
26
  collector = visit o.left, collector
107
27
  collector << " !~ "
108
- collector << o.right
28
+ collector = visit o.right, collector
109
29
  collector
110
30
  end
111
31
 
112
- def visit_ArelExtensions_Nodes_Sum o, collector
113
- collector << "sum("
114
- if((o.expr).is_a?(Arel::Attributes::Attribute))
115
- collector = visit o.expr, collector
116
- else
117
- collector << "'#{o.expr}'"
118
- end
32
+ def visit_ArelExtensions_Nodes_GroupConcat o, collector
33
+ collector << "array_to_string(array_agg("
34
+ collector = visit o.left, collector
35
+ collector << ")"
36
+ if o.right
37
+ collector << Arel::Visitors::PostgreSQL::COMMA
38
+ collector = visit o.right, collector
39
+ else
40
+ collector << Arel::Visitors::PostgreSQL::COMMA
41
+ collector = visit Arel::Nodes.build_quoted(' '), collector
42
+ end
119
43
  collector << ")"
120
44
  collector
121
45
  end
122
46
 
123
- def visit_ArelExtensions_Nodes_Trim o , collector
47
+ def visit_ArelExtensions_Nodes_Trim o, collector
124
48
  collector << 'TRIM(BOTH '
125
- if(o.right.is_a?(Arel::Attributes::Attribute))
126
- collector = visit o.right, collector
127
- else
128
- collector << "'#{o.right}'"
129
- end
49
+ collector = visit o.right, collector
130
50
  collector << " FROM "
131
51
  collector = visit o.left, collector
132
-
133
52
  collector << ")"
134
53
  collector
135
54
  end
136
55
 
137
- def visit_ArelExtensions_Nodes_Ltrim o , collector
56
+ def visit_ArelExtensions_Nodes_Ltrim o, collector
138
57
  collector << 'TRIM(LEADING '
139
- if(o.right.is_a?(Arel::Attributes::Attribute))
140
- collector = visit o.right, collector
141
- else
142
- collector << "'#{o.right}'"
143
- end
58
+ collector = visit o.right, collector
144
59
  collector << " FROM "
145
60
  collector = visit o.left, collector
146
-
147
61
  collector << ")"
148
62
  collector
149
63
  end
150
64
 
151
-
152
- def visit_ArelExtensions_Nodes_Rtrim o , collector
153
- collector << 'TRIM(TRAILING '
154
- if(o.right.is_a?(Arel::Attributes::Attribute))
155
- collector = visit o.right, collector
156
- else
157
- collector << "'#{o.right}'"
158
- end
65
+ def visit_ArelExtensions_Nodes_Rtrim o, collector
66
+ collector << 'TRIM(TRAILING '
67
+ collector = visit o.right, collector
159
68
  collector << " FROM "
160
69
  collector = visit o.left, collector
70
+ collector << ")"
71
+ collector
72
+ end
73
+
74
+ def visit_ArelExtensions_Nodes_DateAdd o, collector
75
+ collector = visit o.left, collector
76
+ collector << (o.right.value >= 0 ? ' + ' : ' - ')
77
+ collector = visit o.postgresql_value(o.right), collector
78
+ collector
79
+ end
161
80
 
81
+ def visit_ArelExtensions_Nodes_DateDiff o, collector
82
+ collector << "DATE_PART('day'"
83
+ collector << Arel::Visitors::PostgreSQL::COMMA
84
+ collector = visit o.left, collector
85
+ collector << (o.date_type == :date ? '::date' : '::timestamp')
86
+ collector << " - "
87
+ collector = visit o.right, collector
88
+ collector << (o.date_type == :date ? '::date' : '::timestamp')
162
89
  collector << ")"
163
90
  collector
164
91
  end
165
92
 
93
+ def visit_ArelExtensions_Nodes_Duration o, collector
94
+ #visit left for period
95
+ if o.left == "d"
96
+ collector << "EXTRACT(DAY FROM"
97
+ elsif o.left == "m"
98
+ collector << "EXTRACT(MONTH FROM "
99
+ elsif (o.left == "w")
100
+ collector << "EXTRACT(WEEK FROM"
101
+ elsif (o.left == "y")
102
+ collector << "EXTRACT(YEAR FROM"
103
+ end
104
+ #visit right
105
+ collector = visit o.right, collector
106
+ collector << ")"
107
+ collector
108
+ end
109
+
110
+ def visit_ArelExtensions_Nodes_Locate o, collector
111
+ collector << "POSITION("
112
+ collector = visit o.right, collector
113
+ collector << " IN "
114
+ collector = visit o.left, collector
115
+ collector << ")"
116
+ collector
117
+ end
118
+
119
+ def visit_ArelExtensions_Nodes_IsNull o, collector
120
+ collector = visit o.left, collector
121
+ collector << ' IS NULL'
122
+ collector
123
+ end
124
+
125
+ def visit_ArelExtensions_Nodes_Sum o, collector
126
+ collector << "sum("
127
+ collector = visit o.expr, collector
128
+ collector << ")"
129
+ collector
130
+ end
166
131
 
167
132
  def visit_ArelExtensions_Nodes_Wday o, collector
168
- collector << "date_part('dow', "
169
- if((o.date).is_a?(Arel::Attributes::Attribute))
170
- collector = visit o.date, collector
171
- else
172
- collector << "'#{o.date}'"
173
- end
133
+ collector << "DATE_PART('dow', "
134
+ collector = visit o.date, collector
174
135
  collector << ")"
175
136
  collector
176
137
  end
@@ -2,11 +2,36 @@ module ArelExtensions
2
2
  module Visitors
3
3
  Arel::Visitors::SQLite.class_eval do
4
4
 
5
+ #String functions
6
+ def visit_ArelExtensions_Nodes_IMatches o, collector # insensitive on ASCII
7
+ collector = visit o.left, collector
8
+ collector << ' LIKE '
9
+ collector = visit o.right, collector
10
+ if o.escape
11
+ collector << ' ESCAPE '
12
+ visit o.escape, collector
13
+ else
14
+ collector
15
+ end
16
+ end
17
+
18
+ def visit_ArelExtensions_Nodes_IDoesNotMatch o, collector
19
+ collector = visit o.left.lower, collector
20
+ collector << ' NOT LIKE '
21
+ collector = visit o.right.lower(o.right), collector
22
+ if o.escape
23
+ collector << ' ESCAPE '
24
+ visit o.escape, collector
25
+ else
26
+ collector
27
+ end
28
+ end
29
+
5
30
  # Date operations
6
31
  def visit_ArelExtensions_Nodes_DateAdd o, collector
7
32
  collector << "date("
8
33
  collector = visit o.expressions.first, collector
9
- collector << Arel::Visitors::ToSql::COMMA
34
+ collector << Arel::Visitors::SQLite::COMMA
10
35
  collector = visit o.sqlite_value, collector
11
36
  collector << ")"
12
37
  collector
@@ -21,7 +46,6 @@ module ArelExtensions
21
46
  collector
22
47
  end
23
48
 
24
-
25
49
  def visit_ArelExtensions_Nodes_Duration o, collector
26
50
  #visit left for period
27
51
  if(o.left == "d")
@@ -34,11 +58,7 @@ module ArelExtensions
34
58
  collector << "strftime('%Y',"
35
59
  end
36
60
  #visit right
37
- if(o.right.is_a?(Arel::Attributes::Attribute))
38
- collector = visit o.right, collector
39
- else
40
- collector << "#{o.right}"
41
- end
61
+ collector = visit o.right, collector
42
62
  collector << ")"
43
63
  collector
44
64
  end
@@ -47,59 +67,24 @@ module ArelExtensions
47
67
  def visit_ArelExtensions_Nodes_Locate o, collector
48
68
  collector << "instr("
49
69
  collector = visit o.expr, collector
50
- collector << ","
51
- if(o.val.is_a?(Arel::Attributes::Attribute))
52
- collector = visit o.val, collector
53
- else
54
- collector << "'#{o.val}'"
55
- end
70
+ collector << Arel::Visitors::SQLite::COMMA
71
+ collector = visit o.val, collector
56
72
  collector << ")"
57
73
  collector
58
74
  end
59
75
 
60
- def visit_ArelExtensions_Nodes_Isnull o, collector
61
- collector << "ifnull("
76
+ def visit_ArelExtensions_Nodes_IsNull o, collector
62
77
  collector = visit o.left, collector
63
- collector << ","
64
- if(o.right.is_a?(Arel::Attributes::Attribute))
65
- collector = visit o.right, collector
66
- else
67
- collector << "'#{o.right}'"
68
- end
69
- collector << ")"
78
+ collector << ' IS NULL'
70
79
  collector
71
80
  end
72
81
 
73
82
  def visit_ArelExtensions_Nodes_Rand o, collector
74
83
  collector << "RANDOM("
75
- if(o.left != nil && o.right != nil)
76
- if(o.left.is_a?(Arel::Attributes::Attribute))
77
- collector = visit o.left, collector
78
- else
79
- collector << "'#{o.left}'"
80
- end
81
- collector << ","
82
- collector << "'#{o.right}'"
83
- end
84
- collector << ")"
85
- collector
86
- end
87
-
88
-
89
- def visit_ArelExtensions_Nodes_Replace o, collector
90
- collector << "REPLACE("
91
- collector = visit o.expr,collector
92
- collector << ","
93
- if(o.left.is_a?(Arel::Attributes::Attribute))
84
+ if o.left != nil && o.right != nil
94
85
  collector = visit o.left, collector
95
- else
96
- collector << "'#{o.left}'"
97
- end
98
- collector << ","
99
- if(o.right.is_a?(Arel::Attributes::Attribute))
86
+ collector << Arel::Visitors::SQLite::COMMA
100
87
  collector = visit o.right, collector
101
- else
102
- collector << "'#{o.right}'"
103
88
  end
104
89
  collector << ")"
105
90
  collector
@@ -107,28 +92,48 @@ module ArelExtensions
107
92
 
108
93
  def visit_Arel_Nodes_Regexp o, collector
109
94
  collector = visit o.left, collector
110
- collector << " REGEXP '#{o.right}'"
95
+ collector << " REGEXP"
96
+ collector = visit o.right, collector
111
97
  collector
112
98
  end
113
99
 
114
100
  def visit_Arel_Nodes_NotRegexp o, collector
115
101
  collector = visit o.left, collector
116
102
  collector << " NOT REGEXP "
117
- collector << "'#{o.right}'"
103
+ collector = visit o.right, collector
118
104
  collector
119
105
  end
120
106
 
121
107
  def visit_ArelExtensions_Nodes_Wday o, collector
122
108
  collector << "strftime('%w',"
123
- if((o.date).is_a?(Arel::Attributes::Attribute))
124
- collector = visit o.date, collector
125
- else
126
- collector << "'#{o.date}'"
127
- end
109
+ collector = visit o.date, collector
128
110
  collector << ")"
129
111
  collector
130
112
  end
131
113
 
114
+ def visit_ArelExtensions_InsertManager_BulkValues o, collector
115
+ o.left.each_with_index do |row, idx|
116
+ collector << 'SELECT '
117
+ v = Arel::Nodes::Values.new(row, o.cols)
118
+ len = v.expressions.length - 1
119
+ v.expressions.zip(v.columns).each_with_index { |(value, attr), i|
120
+ case value
121
+ when Arel::Nodes::SqlLiteral, Arel::Nodes::BindParam
122
+ collector = visit value.as(attr.name), collector
123
+ else
124
+ collector << quote(value, attr && column_for(attr)).to_s
125
+ if idx == 0
126
+ collector << " AS "
127
+ collector << quote(attr.name)
128
+ end
129
+ end
130
+ collector << Arel::Visitors::SQLite::COMMA unless i == len
131
+ }
132
+ collector << ' UNION ALL ' unless idx == o.left.length - 1
133
+ end
134
+ collector
135
+ end
136
+
132
137
  end
133
138
  end
134
139
  end
@@ -53,7 +53,6 @@ module ArelExtensions
53
53
  collector
54
54
  end
55
55
 
56
-
57
56
  # String functions
58
57
  def visit_ArelExtensions_Nodes_Concat o, collector
59
58
  o.expressions.each_with_index { |arg, i|
@@ -63,15 +62,35 @@ module ArelExtensions
63
62
  collector
64
63
  end
65
64
 
65
+ def visit_ArelExtensions_Nodes_GroupConcat o, collector
66
+ collector << "GROUP_CONCAT("
67
+ collector = visit o.left, collector
68
+ if o.right
69
+ collector << Arel::Visitors::ToSql::COMMA
70
+ collector = visit o.right, collector
71
+ end
72
+ collector << ")"
73
+ collector
74
+ end
75
+
66
76
  def visit_ArelExtensions_Nodes_Length o, collector
67
77
  collector << "LENGTH("
68
- collector = visit o.expr, collector
78
+ collector = visit o.left, collector
69
79
  collector << ")"
70
80
  collector
71
81
  end
72
82
 
73
83
  def visit_ArelExtensions_Nodes_Locate o, collector
74
84
  collector << "LOCATE("
85
+ collector = visit o.right, collector
86
+ collector << Arel::Visitors::ToSql::COMMA
87
+ collector = visit o.left, collector
88
+ collector << ")"
89
+ collector
90
+ end
91
+
92
+ def visit_ArelExtensions_Nodes_Replace o, collector
93
+ collector << "REPLACE("
75
94
  o.expressions.each_with_index { |arg, i|
76
95
  collector << Arel::Visitors::ToSql::COMMA unless i == 0
77
96
  collector = visit arg, collector
@@ -206,10 +225,16 @@ module ArelExtensions
206
225
  collector = infix_value o, collector, ' NOT ILIKE '
207
226
  if o.escape
208
227
  collector << ' ESCAPE '
209
- visit o.escape, collector
210
- else
211
- collector
228
+ collector = visit o.escape, collector
212
229
  end
230
+ collector
231
+ end
232
+
233
+ def visit_ArelExtensions_Nodes_IsNull o, collector
234
+ collector << "ISNULL("
235
+ collector = visit o.left, collector
236
+ collector << ")"
237
+ collector
213
238
  end
214
239
 
215
240
  # Date operations
data/test/database.yml CHANGED
@@ -16,11 +16,23 @@ jdbc-mysql:
16
16
  database: arext_test
17
17
  username: travis
18
18
  encoding: utf8
19
- postgres:
19
+ postgresql:
20
20
  adapter: postgresql
21
21
  database: arext_test
22
22
  username: postgres
23
- jdbc-postgres:
23
+ jdbc-postgresql:
24
24
  adapter: jdbcpostgresql
25
25
  database: arext_test
26
- username: postgres
26
+ username: postgres
27
+ oracle:
28
+ adapter: oracle_enhanced
29
+ database: xe
30
+ username: travis
31
+ jdbc-oracle:
32
+ adapter: oracle_enhanced
33
+ database: xe
34
+ username: travis
35
+ ibm_db:
36
+ adapter: ibm_db
37
+ username: travis
38
+ database: arext_test
data/test/real_db_test.rb CHANGED
@@ -47,7 +47,6 @@ class User < ActiveRecord::Base
47
47
 
48
48
  end
49
49
 
50
-
51
50
  class ListTest < Minitest::Test
52
51
 
53
52
  def setup
@@ -8,6 +8,7 @@ module ArelExtensions
8
8
  @conn = FakeRecord::Base.new
9
9
  @visitor = Arel::Visitors::SQLite.new @conn.connection
10
10
  @table = Arel::Table.new(:users)
11
+ Arel::Table.engine = @conn
11
12
  @cols = ['id', 'name', 'comments', 'created_at']
12
13
  @data = [
13
14
  [23, 'nom1', "sdfdsfdsfsdf", '2016-01-01'],
@@ -27,7 +28,7 @@ module ArelExtensions
27
28
  insert_manager = Arel::VERSION.to_i > 6 ? Arel::InsertManager.new().into(@table) : Arel::InsertManager.new(@conn).into(@table)
28
29
  insert_manager.bulk_insert(@cols, @data)
29
30
  sql = compile(insert_manager.ast)
30
- sql.must_be_like %Q[INSERT INTO "users" ("id", "name", "comments", "created_at") VALUES (23, 'nom1', 'sdfdsfdsfsdf', '2016-01-01'), (25, 'nom2', 'sdfdsfdsfsdf', '2016-01-01')]
31
+ sql.must_be_like %Q[INSERT INTO "users" ("id", "name", "comments", "created_at") SELECT 23 AS 'id', 'nom1' AS 'name', 'sdfdsfdsfsdf' AS 'comments', '2016-01-01' AS 'created_at' UNION ALL SELECT 25, 'nom2', 'sdfdsfdsfsdf', '2016-01-01']
31
32
  end
32
33
 
33
34
  end
@@ -76,13 +76,13 @@ module ArelExtensions
76
76
  it "should diff between time values" do
77
77
  d2 = Time.new(2015,6,1)
78
78
  d1 = DateTime.new(2015,6,2)
79
- sql = compile(ArelExtensions::Nodes::DateDiff.new(d1,d2))
79
+ sql = compile(ArelExtensions::Nodes::DateDiff.new([d1,d2]))
80
80
  sql.must_match("'2015-06-02' - '2015-06-01'")
81
81
  end
82
82
 
83
83
  it "should diff between time values and time col" do
84
84
  d1 = DateTime.new(2015,6,2)
85
- sql = compile(ArelExtensions::Nodes::DateDiff.new(d1, @table[:updated_at]))
85
+ sql = compile(ArelExtensions::Nodes::DateDiff.new([d1, @table[:updated_at]]))
86
86
  sql.must_match %{'2015-06-02' - "users"."updated_at"}
87
87
  end
88
88
 
@@ -23,7 +23,6 @@ module ArelExtensions
23
23
  end
24
24
 
25
25
  # Math Functions
26
-
27
26
  it "should not break Arel functions" do
28
27
  compile(@price + 42).must_be_like %{("products"."price" + 42)}
29
28
  end
@@ -51,7 +50,7 @@ module ArelExtensions
51
50
  compile(c + 'test' + ' chain').must_be_like %{"users"."name" || 'test' || ' chain'}
52
51
  compile(c.length).must_be_like %{LENGTH("users"."name")}
53
52
  compile(c.length.round + 42).must_be_like %{(ROUND(LENGTH("users"."name")) + 42)}
54
- compile(c.locate('test')).must_be_like %{LOCATE("users"."name", 'test')}
53
+ compile(c.locate('test')).must_be_like %{LOCATE('test', "users"."name")}
55
54
  compile(c & 42).must_be_like %{FIND_IN_SET(42, "users"."name")}
56
55
 
57
56
  compile((c >= 'test').as('new_name')).must_be_like %{("users"."name" >= 'test') AS new_name}
@@ -118,13 +117,13 @@ module ArelExtensions
118
117
  it "should diff between time values" do
119
118
  d2 = Time.new(2015,6,1)
120
119
  d1 = DateTime.new(2015,6,2)
121
- sql = compile(ArelExtensions::Nodes::DateDiff.new(d1,d2))
120
+ sql = compile(ArelExtensions::Nodes::DateDiff.new([d1, d2]))
122
121
  sql.must_match("DATEDIFF('2015-06-02', '2015-06-01')")
123
122
  end
124
123
 
125
124
  it "should diff between time values and time col" do
126
125
  d1 = DateTime.new(2015,6,2)
127
- sql = compile(ArelExtensions::Nodes::DateDiff.new(d1, @table[:updated_at]))
126
+ sql = compile(ArelExtensions::Nodes::DateDiff.new([d1, @table[:updated_at]]))
128
127
  sql.must_match %{DATEDIFF('2015-06-02', "users"."updated_at")}
129
128
  end
130
129