arel_extensions 0.8.4 → 0.8.5

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 (34) hide show
  1. checksums.yaml +4 -4
  2. data/.travis.yml +15 -4
  3. data/.travis/oracle/download_ojdbc.js +116 -0
  4. data/.travis/setup_accounts.sh +9 -0
  5. data/README.md +15 -3
  6. data/arel_extensions.gemspec +1 -1
  7. data/gemfiles/rails4.gemfile +1 -2
  8. data/gemfiles/rails5.gemfile +3 -2
  9. data/init/postgresql.sql +10 -8
  10. data/lib/arel_extensions/date_duration.rb +9 -5
  11. data/lib/arel_extensions/math.rb +1 -1
  12. data/lib/arel_extensions/nodes.rb +1 -0
  13. data/lib/arel_extensions/nodes/abs.rb +2 -0
  14. data/lib/arel_extensions/nodes/date_diff.rb +17 -0
  15. data/lib/arel_extensions/nodes/find_in_set.rb +1 -9
  16. data/lib/arel_extensions/nodes/format.rb +12 -0
  17. data/lib/arel_extensions/nodes/function.rb +33 -2
  18. data/lib/arel_extensions/nodes/length.rb +2 -0
  19. data/lib/arel_extensions/nodes/rand.rb +2 -8
  20. data/lib/arel_extensions/version.rb +1 -1
  21. data/lib/arel_extensions/visitors/ibm_db.rb +1 -121
  22. data/lib/arel_extensions/visitors/mssql.rb +5 -85
  23. data/lib/arel_extensions/visitors/mysql.rb +9 -25
  24. data/lib/arel_extensions/visitors/oracle.rb +137 -122
  25. data/lib/arel_extensions/visitors/postgresql.rb +3 -12
  26. data/lib/arel_extensions/visitors/sqlite.rb +2 -11
  27. data/lib/arel_extensions/visitors/to_sql.rb +22 -0
  28. data/test/database.yml +4 -2
  29. data/test/support/alter_system_user_password.sql +2 -0
  30. data/test/support/create_oracle_enhanced_users.sql +29 -0
  31. data/test/visitors/test_to_sql.rb +2 -2
  32. data/test/with_ar/all_agnostic_test.rb +76 -63
  33. data/test/with_ar/insert_agnostic_test.rb +13 -7
  34. metadata +9 -2
data/lib/arel_extensions/nodes/length.rb CHANGED
@@ -1,6 +1,8 @@
1
1
  module ArelExtensions
2
2
  module Nodes
3
3
  class Length < Function
4
+ @@return_type = :integer
5
+
4
6
  end
5
7
  end
6
8
  end
data/lib/arel_extensions/nodes/rand.rb CHANGED
@@ -2,6 +2,8 @@ module ArelExtensions
2
2
  module Nodes
3
3
  class Rand < Function
4
4
 
5
+ @@return_type = :number
6
+
5
7
  def initialize(seed = nil)
6
8
  if seed && seed.length == 1
7
9
  super seed
@@ -10,14 +12,6 @@ module ArelExtensions
10
12
  end
11
13
  end
12
14
 
13
- def left
14
- @expressions.first
15
- end
16
-
17
- def right
18
- @expressions[1]
19
- end
20
-
21
15
  end
22
16
  end
23
17
  end
data/lib/arel_extensions/version.rb CHANGED
@@ -1,4 +1,4 @@
1
1
  # -*- encoding : utf-8 -*-
2
2
  module ArelExtensions
3
- VERSION = "0.8.4".freeze
3
+ VERSION = "0.8.5".freeze
4
4
  end
data/lib/arel_extensions/visitors/ibm_db.rb CHANGED
@@ -4,11 +4,7 @@ module ArelExtensions
4
4
 
5
5
  def visit_ArelExtensions_Nodes_Ceil o, collector
6
6
  collector << "CEILING("
7
- if((o.expr).is_a?(Arel::Attributes::Attribute))
8
7
  collector = visit o.expr, collector
9
- else
10
- collector <<"#{o.expr}"
11
- end
12
8
  collector << ")"
13
9
  collector
14
10
  end
@@ -35,28 +31,7 @@ module ArelExtensions
35
31
  end
36
32
 
37
33
 
38
- def visit_ArelExtensions_Nodes_Coalesce o, collector
39
- collector << "COALESCE("
40
- if(o.left.is_a?(Arel::Attributes::Attribute))
41
- collector = visit o.left, collector
42
- else
43
- collector << "#{o.left}"
44
- end
45
- o.other.each { |a|
46
- collector << ","
47
- if(a.is_a?(Arel::Attributes::Attribute))
48
- collector = visit a, collector
49
- else
50
- collector << "#{a}"
51
- end
52
- }
53
- collector << ")"
54
- collector
55
- end
56
-
57
-
58
34
  def visit_ArelExtensions_Nodes_DateDiff o, collector
59
-
60
35
  collector << "DAY("
61
36
  collector = visit o.left, collector
62
37
  collector<< ","
@@ -92,11 +67,8 @@ module ArelExtensions
92
67
  end
93
68
 
94
69
 
95
- def visit_ArelExtensions_Nodes_Findis o, collector
96
70
 
97
- end
98
-
99
- def visit_ArelExtensions_Nodes_Isnull o, collector
71
+ def visit_ArelExtensions_Nodes_IsNull o, collector
100
72
  collector << "COALESCE("
101
73
  collector = visit o.left, collector
102
74
  collector << ","
@@ -109,98 +81,6 @@ module ArelExtensions
109
81
  collector
110
82
  end
111
83
 
112
-
113
- def visit_ArelExtensions_Nodes_Replace o, collector
114
- collector << "REPLACE("
115
- collector = visit o.expr,collector
116
- collector << ","
117
- if(o.left.is_a?(Arel::Attributes::Attribute))
118
- collector = visit o.left, collector
119
- else
120
- collector << "'#{o.left}'"
121
- end
122
- collector << ","
123
- if(o.right.is_a?(Arel::Attributes::Attribute))
124
- collector = visit o.right, collector
125
- else
126
- collector << "'#{o.right}'"
127
- end
128
- collector <<")"
129
- collector
130
- end
131
-
132
-
133
-
134
- def visit_ArelExtensions_Nodes_Soundex o, collector
135
- collector << "SOUNDEX("
136
- if((o.expr).is_a?(Arel::Attributes::Attribute))
137
- collector = visit o.expr, collector
138
- else
139
- collector <<"'#{o.expr}'"
140
- end
141
- collector << ")"
142
- collector
143
- end
144
-
145
-
146
- def visit_Arel_Nodes_Regexp o , collector
147
- collector = visit o.left, collector
148
- collector << " REGEXP "
149
- collector << "'#{o.right}'"
150
- collector
151
- end
152
-
153
-
154
-
155
- def visit_Arel_Nodes_NotRegexp o , collector
156
- collector = visit o.left, collector
157
- collector << " NOT REGEXP "
158
- collector << "'#{o.right}'"
159
- collector
160
- end
161
-
162
-
163
- def visit_ArelExtensions_Nodes_Trim o , collector
164
- collector << "TRIM("
165
- collector = visit o.left, collector
166
- collector << ","
167
- if(o.right.is_a?(Arel::Attributes::Attribute))
168
- collector = visit o.right, collector
169
- else
170
- collector << "'#{o.right}'"
171
- end
172
- collector << ")"
173
- collector
174
- end
175
-
176
- def visit_ArelExtensions_Nodes_Ltrim o , collector
177
- collector << "LTRIM("
178
- collector = visit o.left, collector
179
- collector << ","
180
- if(o.right.is_a?(Arel::Attributes::Attribute))
181
- collector = visit o.right, collector
182
- else
183
- collector << "'#{o.right}'"
184
- end
185
- collector << ")"
186
- collector
187
- end
188
-
189
-
190
- def visit_ArelExtensions_Nodes_Rtrim o , collector
191
- collector << "RTRIM("
192
- collector = visit o.left, collector
193
- collector << ","
194
- if(o.right.is_a?(Arel::Attributes::Attribute))
195
- collector = visit o.right, collector
196
- else
197
- collector << "'#{o.right}'"
198
- end
199
- collector << ")"
200
- collector
201
- end
202
-
203
-
204
84
  end
205
85
  end
206
86
  end
data/lib/arel_extensions/visitors/mssql.rb CHANGED
@@ -29,30 +29,10 @@ module ArelExtensions
29
29
  end
30
30
  end
31
31
 
32
- def visit_ArelExtensions_Nodes_Coalesce o, collector
33
- collector << "COALESCE("
34
- if(o.left.is_a?(Arel::Attributes::Attribute))
35
- collector = visit o.left, collector
36
- else
37
- collector << "#{o.left}"
38
- end
39
- o.other.each { |a|
40
- collector << ","
41
- if(a.is_a?(Arel::Attributes::Attribute))
42
- collector = visit a, collector
43
- else
44
- collector << "#{a}"
45
- end
46
- }
47
- collector << ")"
48
- collector
49
- end
50
-
51
32
  def visit_ArelExtensions_Nodes_DateDiff o, collector
52
-
53
- collector << "DATEDIFF(day,"
54
- collector = visit o.left, collector
55
- collector<< ","
33
+ collector << "DATEDIFF(day,"
34
+ collector = visit o.left, collector
35
+ collector<< ","
56
36
  if(o.right.is_a?(Arel::Attributes::Attribute))
57
37
  collector = visit o.right, collector
58
38
  else
@@ -85,11 +65,6 @@ module ArelExtensions
85
65
  collector
86
66
  end
87
67
 
88
-
89
- def visit_ArelExtensions_Nodes_Findis o,collector
90
- end
91
-
92
-
93
68
  def visit_ArelExtensions_Nodes_Length o, collector
94
69
  collector << "LEN("
95
70
  collector = visit o.expr, collector
@@ -100,18 +75,14 @@ module ArelExtensions
100
75
 
101
76
  def visit_ArelExtensions_Nodes_Locate o, collector
102
77
  collector << "CHARINDEX("
103
- if(o.val.is_a?(Arel::Attributes::Attribute))
104
- collector = visit o.val, collector
105
- else
106
- collector << "'#{o.val}'"
107
- end
78
+ collector = visit o.val, collector
108
79
  collector << ","
109
80
  collector = visit o.expr, collector
110
81
  collector << ")"
111
82
  collector
112
83
  end
113
84
 
114
- def visit_ArelExtensions_Nodes_Isnull o, collector
85
+ def visit_ArelExtensions_Nodes_IsNull o, collector
115
86
  collector << "ISNULL("
116
87
  collector = visit o.left, collector
117
88
  collector << ","
@@ -157,57 +128,6 @@ module ArelExtensions
157
128
  collector
158
129
  end
159
130
 
160
- def visit_ArelExtensions_Nodes_Soundex o, collector
161
- collector << "SOUNDEX("
162
- if((o.expr).is_a?(Arel::Attributes::Attribute))
163
- collector = visit o.expr, collector
164
- else
165
- collector << "'#{o.expr}'"
166
- end
167
- collector << ")"
168
- collector
169
- end
170
-
171
- def visit_ArelExtensions_Nodes_Trim o , collector
172
- collector << "TRIM("
173
- collector = visit o.left, collector
174
- collector << ","
175
- if(o.right.is_a?(Arel::Attributes::Attribute))
176
- collector = visit o.right, collector
177
- else
178
- collector << "'#{o.right}'"
179
- end
180
- collector << ")"
181
- collector
182
- end
183
-
184
- def visit_ArelExtensions_Nodes_Ltrim o , collector
185
- collector << "LTRIM("
186
- collector = visit o.left, collector
187
- collector << ","
188
- if(o.right.is_a?(Arel::Attributes::Attribute))
189
- collector = visit o.right, collector
190
- else
191
- collector << "'#{o.right}'"
192
- end
193
- collector << ")"
194
- collector
195
- end
196
-
197
-
198
- def visit_ArelExtensions_Nodes_Rtrim o , collector
199
- collector << "RTRIM("
200
- collector = visit o.left, collector
201
- collector << ","
202
- if(o.right.is_a?(Arel::Attributes::Attribute))
203
- collector = visit o.right, collector
204
- else
205
- collector << "'#{o.right}'"
206
- end
207
- collector << ")"
208
- collector
209
- end
210
-
211
131
  end
212
132
  end
213
133
  end
data/lib/arel_extensions/visitors/mysql.rb CHANGED
@@ -1,6 +1,7 @@
1
1
  module ArelExtensions
2
2
  module Visitors
3
3
  Arel::Visitors::MySQL.class_eval do
4
+ Arel::Visitors::MySQL::DATE_MAPPING = {'d' => 'DAY', 'm' => 'MONTH', 'w' => 'WEEK', 'y' => 'YEAR', 'wd' => 'WEEKDAY'}
4
5
 
5
6
  #String functions
6
7
  def visit_ArelExtensions_Nodes_IMatches o, collector # insensitive on ASCII
@@ -94,23 +95,18 @@ module ArelExtensions
94
95
 
95
96
 
96
97
  def visit_ArelExtensions_Nodes_Duration o, collector
97
- #visit left for period
98
- if o.left == "d"
99
- collector << "DAY("
100
- elsif(o.left == "m")
101
- collector << "MONTH("
102
- elsif (o.left == "w")
103
- collector << "WEEK("
104
- elsif (o.left == "y")
105
- collector << "YEAR("
98
+ if o.left == 'wd'
99
+ collector << "(WEEKDAY("
100
+ collector = visit o.right, collector
101
+ collector << ") + 1) % 7"
102
+ else
103
+ collector << "#{Arel::Visitors::MySQL::DATE_MAPPING[o.left]}("
104
+ collector = visit o.right, collector
105
+ collector << ")"
106
106
  end
107
- #visit right
108
- collector = visit o.right, collector
109
- collector << ")"
110
107
  collector
111
108
  end
112
109
 
113
- #****************************************************************#
114
110
 
115
111
  def visit_ArelExtensions_Nodes_IsNull o, collector
116
112
  collector << "ISNULL("
@@ -123,18 +119,6 @@ module ArelExtensions
123
119
  collector
124
120
  end
125
121
 
126
-
127
- def visit_ArelExtensions_Nodes_Replace o, collector
128
- collector << "REPLACE("
129
- o.expressions.each_with_index { |arg, i|
130
- collector << Arel::Visitors::MySQL::COMMA unless i == 0
131
- collector = visit arg, collector
132
- }
133
- collector << ")"
134
- collector
135
- end
136
-
137
-
138
122
  def visit_ArelExtensions_Nodes_Wday o, collector
139
123
  collector << "(WEEKDAY("
140
124
  collector = visit o.date, collector
data/lib/arel_extensions/visitors/oracle.rb CHANGED
@@ -1,6 +1,17 @@
1
1
  module ArelExtensions
2
2
  module Visitors
3
3
  Arel::Visitors::Oracle.class_eval do
4
+ Arel::Visitors::Oracle::DATE_MAPPING = {'d' => 'DAY', 'm' => 'MONTH', 'w' => 'IW', 'y' => 'YEAR', 'wd' => 'D'}
5
+
6
+ def visit_ArelExtensions_Nodes_Concat o, collector
7
+ collector << '('
8
+ o.expressions.each_with_index { |arg, i|
9
+ collector = visit o.convert_to_string_node(arg), collector
10
+ collector << ' || ' unless i == o.expressions.length - 1
11
+ }
12
+ collector << ')'
13
+ collector
14
+ end
4
15
 
5
16
  def visit_ArelExtensions_Nodes_IMatches o, collector
6
17
  collector = visit o.left.lower, collector
@@ -27,170 +38,174 @@ module ArelExtensions
27
38
  end
28
39
 
29
40
  def visit_ArelExtensions_Nodes_GroupConcat o, collector
30
- collector << "LISTAGG("
41
+ collector << "(LISTAGG("
31
42
  collector = visit o.left, collector
32
43
  if o.right
33
44
  collector << Arel::Visitors::Oracle::COMMA
34
45
  collector = visit o.right, collector
35
46
  end
36
- collector << ")"
47
+ collector << ") WITHIN GROUP (ORDER BY "
48
+ collector = visit o.left, collector
49
+ collector << "))"
37
50
  collector
38
51
  end
39
52
 
40
53
  def visit_ArelExtensions_Nodes_Coalesce o, collector
41
54
  collector << "COALESCE("
42
- collector = visit o.left, collector
43
- o.other.each { |a|
44
- collector << Arel::Visitors::Oracle::COMMA
45
- collector = visit a, collector
55
+ o.expressions.each_with_index { |arg, i|
56
+ collector << Arel::Visitors::Oracle::COMMA unless i == 0
57
+ collector = visit arg, collector
46
58
  }
47
59
  collector << ")"
48
60
  collector
49
61
  end
50
62
 
51
- def visit_ArelExtensions_Nodes_DateDiff o, collector
52
- collector << '('
53
- collector = visit o.left, collector
54
- collector << " - "
55
- collector = visit o.right, collector
56
- collector << ')'
57
- collector
58
- end
59
-
63
+ def visit_ArelExtensions_Nodes_DateDiff o, collector
64
+ collector << '('
65
+ collector = visit o.left, collector
66
+ collector << " - "
67
+ collector = visit o.right, collector
68
+ collector << ')'
69
+ collector
70
+ end
60
71
 
61
- def visit_ArelExtensions_Nodes_Duration o, collector
62
- #visit left for period
63
- if(o.left == "d")
64
- collector << "DAY("
65
- elsif(o.left == "m")
66
- collector << "MONTH("
67
- elsif (o.left == "w")
68
- collector << "WEEK"
69
- elsif (o.left == "y")
70
- collector << "YEAR("
71
- end
72
- #visit right
73
- collector = visit o.right, collector
74
- collector << ")"
75
- collector
76
- end
72
+ def visit_ArelExtensions_Nodes_Duration o, collector
73
+ case o.left
74
+ when 'wd', 'w'
75
+ collector << "TO_CHAR("
76
+ collector = visit o.right, collector
77
+ collector << Arel::Visitors::Oracle::COMMA
78
+ collector = visit Arel::Nodes.build_quoted(Arel::Visitors::Oracle::DATE_MAPPING[o.left]), collector
79
+ else
80
+ collector << "EXTRACT(#{Arel::Visitors::Oracle::DATE_MAPPING[o.left]} FROM "
81
+ collector = visit o.right, collector
82
+ end
83
+ collector << ")"
84
+ collector
85
+ end
77
86
 
78
87
 
79
- def visit_ArelExtensions_Nodes_Length o, collector
80
- collector << "LENGTH("
81
- collector = visit o.expr, collector
82
- collector << ")"
83
- collector
84
- end
88
+ def visit_ArelExtensions_Nodes_Length o, collector
89
+ collector << "LENGTH("
90
+ collector = visit o.expr, collector
91
+ collector << ")"
92
+ collector
93
+ end
85
94
 
86
95
 
87
- def visit_ArelExtensions_Nodes_IsNull o, collector
88
- collector << "NVL("
89
- collector = visit o.left, collector
90
- collector << Arel::Visitors::Oracle::COMMA
91
- collector = visit Arel::Nodes.build_quoted(true), collector
92
- collector << ")"
93
- collector
94
- end
96
+ def visit_ArelExtensions_Nodes_IsNull o, collector
97
+ collector = visit o.left, collector
98
+ collector << ' IS NULL'
99
+ collector
100
+ end
95
101
 
96
- def visit_ArelExtensions_Nodes_Rand o, collector
97
- collector << "dbms_random.value("
98
- if(o.left != nil && o.right != nil)
99
- collector << "'#{o.left}'"
100
- collector << Arel::Visitors::Oracle::COMMA
101
- collector << "'#{o.right}'"
102
- end
103
- collector << ")"
104
- collector
105
- end
102
+ def visit_ArelExtensions_Nodes_Rand o, collector
103
+ collector << "DBMS_RANDOM.VALUE("
104
+ if(o.left != nil && o.right != nil)
105
+ collector = visit o.left, collector
106
+ collector << Arel::Visitors::Oracle::COMMA
107
+ collector = visit o.right, collector
108
+ end
109
+ collector << ")"
110
+ collector
111
+ end
106
112
 
107
- def visit_ArelExtensions_Nodes_Replace o, collector
108
- collector << "REPLACE("
109
- collector = visit o.expr,collector
110
- collector << Arel::Visitors::Oracle::COMMA
111
- collector = visit o.left, collector
112
- collector << Arel::Visitors::Oracle::COMMA
113
- collector = visit o.right, collector
114
- collector << ")"
115
- collector
116
- end
113
+ def visit_Arel_Nodes_Regexp o, collector
114
+ collector << " REGEXP_LIKE("
115
+ collector = visit o.left, collector
116
+ collector << Arel::Visitors::Oracle::COMMA
117
+ collector = visit o.right, collector
118
+ collector << ')'
119
+ collector
120
+ end
117
121
 
118
- def visit_Arel_Nodes_Regexp o, collector
119
- collector << " REGEXP_LIKE("
120
- collector = visit o.left, collector
121
- collector << Arel::Visitors::Oracle::COMMA
122
- collector = visit o.right, collector
123
- collector << ')'
124
- collector
125
- end
122
+ def visit_Arel_Nodes_NotRegexp o, collector
123
+ collector << " NOT REGEXP_LIKE("
124
+ collector = visit o.left, collector
125
+ collector << Arel::Visitors::Oracle::COMMA
126
+ collector = visit o.right, collector
127
+ collector << ')'
128
+ collector
129
+ end
126
130
 
131
+ def visit_ArelExtensions_Nodes_Soundex o, collector
132
+ collector << "SOUNDEX("
133
+ collector = visit o.expr, collector
134
+ collector << ")"
135
+ collector
136
+ end
127
137
 
128
- def visit_Arel_Nodes_NotRegexp o, collector
129
- collector << " NOT REGEXP_LIKE("
130
- collector = visit o.left, collector
131
- collector << Arel::Visitors::Oracle::COMMA
132
- collector = visit o.right, collector
133
- collector << ')'
134
- collector
135
- end
138
+ def visit_ArelExtensions_Nodes_Locate o, collector
139
+ collector << "INSTR("
140
+ o.expressions.each_with_index { |arg, i|
141
+ collector << Arel::Visitors::Oracle::COMMA unless i == 0
142
+ collector = visit arg, collector
143
+ }
144
+ collector << ")"
145
+ collector
146
+ end
136
147
 
137
- def visit_ArelExtensions_Nodes_Soundex o, collector
138
- collector << "SOUNDEX("
139
- if((o.expr).is_a?(Arel::Attributes::Attribute))
140
- collector = visit o.expr, collector
141
- else
142
- collector << "'#{o.expr}'"
148
+ def visit_ArelExtensions_Nodes_Trim o , collector
149
+ collector << 'TRIM(' # BOTH
150
+ collector = visit o.right, collector
151
+ collector << ' FROM '
152
+ collector = visit o.left, collector
153
+ collector << ")"
154
+ collector
143
155
  end
144
- collector << ")"
145
- collector
146
- end
147
156
 
148
- def visit_ArelExtensions_Nodes_Trim o , collector
149
- collector << 'TRIM("BOTH"'
150
- collector = visit o.left, collector
151
- collector << ","
152
- if(o.right.is_a?(Arel::Attributes::Attribute))
157
+ def visit_ArelExtensions_Nodes_Ltrim o, collector
158
+ collector << 'TRIM(LEADING '
153
159
  collector = visit o.right, collector
154
- else
155
- collector << "'#{o.right}'"
160
+ collector << ' FROM '
161
+ collector = visit o.left, collector
162
+ collector << ")"
163
+ collector
156
164
  end
157
- collector << ")"
158
- collector
159
- end
160
165
 
161
- def visit_ArelExtensions_Nodes_Ltrim o , collector
162
- collector << 'TRIM("LEADING",'
163
- collector = visit o.left, collector
164
- collector << ","
165
- if(o.right.is_a?(Arel::Attributes::Attribute))
166
+ def visit_ArelExtensions_Nodes_Rtrim o, collector
167
+ collector << 'TRIM(TRAILING '
166
168
  collector = visit o.right, collector
167
- else
168
- collector << "'#{o.right}'"
169
+ collector << ' FROM '
170
+ collector = visit o.left, collector
171
+ collector << ")"
172
+ collector
169
173
  end
170
- collector << ")"
171
- collector
172
- end
173
174
 
175
+ def visit_ArelExtensions_Nodes_DateAdd o, collector
176
+ collector << '('
177
+ collector = visit o.left, collector
178
+ collector << (o.right.value >= 0 ? ' + ' : ' - ')
179
+ collector = visit o.oracle_value(o.right), collector
180
+ collector << ')'
181
+ collector
182
+ end
174
183
 
175
- def visit_ArelExtensions_Nodes_Rtrim o , collector
176
- collector << 'TRIM("TRAILING",'
177
- collector = visit o.left, collector
178
- collector << ","
179
- if(o.right.is_a?(Arel::Attributes::Attribute))
180
- collector = visit o.right, collector
181
- else
182
- collector << "'#{o.right}'"
184
+ def visit_ArelExtensions_Nodes_Format o, collector
185
+ case o.col_type
186
+ when :date, :datetime
187
+ collector << "TO_CHAR("
188
+ collector = visit o.left, collector
189
+ collector << Arel::Visitors::Oracle::COMMA unless i == 0
190
+ collector = visit o.right, collector
191
+ collector << ")"
192
+ when :integer, :float, :decimal
193
+ collector << "FORMAT("
194
+ collector = visit o.left, collector
195
+ collector << Arel::Visitors::Oracle::COMMA unless i == 0
196
+ collector = visit o.right, collector
197
+ collector << ")"
198
+ else
199
+ collector = visit o.left, collector
200
+ end
201
+ collector
183
202
  end
184
- collector << ")"
185
- collector
186
- end
187
203
 
188
204
  def visit_ArelExtensions_InsertManager_BulkValues o, collector
189
205
  table = collector.value.sub(/\AINSERT INTO/, '')
190
206
  into = " INTO#{table}"
191
207
  collector = Arel::Collectors::SQLString.new
192
208
  collector << "INSERT ALL\n"
193
- # row_nb = o.left.length
194
209
  o.left.each_with_index do |row, idx|
195
210
  collector << "#{into} VALUES ("
196
211
  v = Arel::Nodes::Values.new(row, o.cols)