red-arrow 0.13.0 → 0.14.0

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.

Potentially problematic release.


This version of red-arrow might be problematic. Click here for more details.

@@ -16,7 +16,7 @@
16
16
  # under the License.
17
17
 
18
18
  module Arrow
19
- VERSION = "0.13.0"
19
+ VERSION = "0.14.0"
20
20
 
21
21
  module Version
22
22
  numbers, TAG = VERSION.split("-")
@@ -0,0 +1,340 @@
1
+ # Licensed to the Apache Software Foundation (ASF) under one
2
+ # or more contributor license agreements. See the NOTICE file
3
+ # distributed with this work for additional information
4
+ # regarding copyright ownership. The ASF licenses this file
5
+ # to you under the Apache License, Version 2.0 (the
6
+ # "License"); you may not use this file except in compliance
7
+ # with the License. You may obtain a copy of the License at
8
+ #
9
+ # http://www.apache.org/licenses/LICENSE-2.0
10
+ #
11
+ # Unless required by applicable law or agreed to in writing,
12
+ # software distributed under the License is distributed on an
13
+ # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
14
+ # KIND, either express or implied. See the License for the
15
+ # specific language governing permissions and limitations
16
+ # under the License.
17
+
18
+ module RawRecordsBasicArraysTests
19
+ def test_null
20
+ records = [
21
+ [nil],
22
+ [nil],
23
+ [nil],
24
+ [nil],
25
+ ]
26
+ target = build({column: :null}, records)
27
+ assert_equal(records, target.raw_records)
28
+ end
29
+
30
+ def test_boolean
31
+ records = [
32
+ [true],
33
+ [nil],
34
+ [false],
35
+ ]
36
+ target = build({column: :boolean}, records)
37
+ assert_equal(records, target.raw_records)
38
+ end
39
+
40
+ def test_int8
41
+ records = [
42
+ [-(2 ** 7)],
43
+ [nil],
44
+ [(2 ** 7) - 1],
45
+ ]
46
+ target = build({column: :int8}, records)
47
+ assert_equal(records, target.raw_records)
48
+ end
49
+
50
+ def test_uint8
51
+ records = [
52
+ [0],
53
+ [nil],
54
+ [(2 ** 8) - 1],
55
+ ]
56
+ target = build({column: :uint8}, records)
57
+ assert_equal(records, target.raw_records)
58
+ end
59
+
60
+ def test_int16
61
+ records = [
62
+ [-(2 ** 15)],
63
+ [nil],
64
+ [(2 ** 15) - 1],
65
+ ]
66
+ target = build({column: :int16}, records)
67
+ assert_equal(records, target.raw_records)
68
+ end
69
+
70
+ def test_uint16
71
+ records = [
72
+ [0],
73
+ [nil],
74
+ [(2 ** 16) - 1],
75
+ ]
76
+ target = build({column: :uint16}, records)
77
+ assert_equal(records, target.raw_records)
78
+ end
79
+
80
+ def test_int32
81
+ records = [
82
+ [-(2 ** 31)],
83
+ [nil],
84
+ [(2 ** 31) - 1],
85
+ ]
86
+ target = build({column: :int32}, records)
87
+ assert_equal(records, target.raw_records)
88
+ end
89
+
90
+ def test_uint32
91
+ records = [
92
+ [0],
93
+ [nil],
94
+ [(2 ** 32) - 1],
95
+ ]
96
+ target = build({column: :uint32}, records)
97
+ assert_equal(records, target.raw_records)
98
+ end
99
+
100
+ def test_int64
101
+ records = [
102
+ [-(2 ** 63)],
103
+ [nil],
104
+ [(2 ** 63) - 1],
105
+ ]
106
+ target = build({column: :int64}, records)
107
+ assert_equal(records, target.raw_records)
108
+ end
109
+
110
+ def test_uint64
111
+ records = [
112
+ [0],
113
+ [nil],
114
+ [(2 ** 64) - 1],
115
+ ]
116
+ target = build({column: :uint64}, records)
117
+ assert_equal(records, target.raw_records)
118
+ end
119
+
120
+ def test_float
121
+ records = [
122
+ [-1.0],
123
+ [nil],
124
+ [1.0],
125
+ ]
126
+ target = build({column: :float}, records)
127
+ assert_equal(records, target.raw_records)
128
+ end
129
+
130
+ def test_double
131
+ records = [
132
+ [-1.0],
133
+ [nil],
134
+ [1.0],
135
+ ]
136
+ target = build({column: :double}, records)
137
+ assert_equal(records, target.raw_records)
138
+ end
139
+
140
+ def test_binary
141
+ records = [
142
+ ["\x00".b],
143
+ [nil],
144
+ ["\xff".b],
145
+ ]
146
+ target = build({column: :binary}, records)
147
+ assert_equal(records, target.raw_records)
148
+ end
149
+
150
+ def test_tring
151
+ records = [
152
+ ["Ruby"],
153
+ [nil],
154
+ ["\u3042"], # U+3042 HIRAGANA LETTER A
155
+ ]
156
+ target = build({column: :string}, records)
157
+ assert_equal(records, target.raw_records)
158
+ end
159
+
160
+ def test_date32
161
+ records = [
162
+ [Date.new(1960, 1, 1)],
163
+ [nil],
164
+ [Date.new(2017, 8, 23)],
165
+ ]
166
+ target = build({column: :date32}, records)
167
+ assert_equal(records, target.raw_records)
168
+ end
169
+
170
+ def test_date64
171
+ records = [
172
+ [DateTime.new(1960, 1, 1, 2, 9, 30)],
173
+ [nil],
174
+ [DateTime.new(2017, 8, 23, 14, 57, 2)],
175
+ ]
176
+ target = build({column: :date64}, records)
177
+ assert_equal(records, target.raw_records)
178
+ end
179
+
180
+ def test_timestamp_second
181
+ records = [
182
+ [Time.parse("1960-01-01T02:09:30Z")],
183
+ [nil],
184
+ [Time.parse("2017-08-23T14:57:02Z")],
185
+ ]
186
+ target = build({
187
+ column: {
188
+ type: :timestamp,
189
+ unit: :second,
190
+ }
191
+ },
192
+ records)
193
+ assert_equal(records, target.raw_records)
194
+ end
195
+
196
+ def test_timestamp_milli
197
+ records = [
198
+ [Time.parse("1960-01-01T02:09:30.123Z")],
199
+ [nil],
200
+ [Time.parse("2017-08-23T14:57:02.987Z")],
201
+ ]
202
+ target = build({
203
+ column: {
204
+ type: :timestamp,
205
+ unit: :milli,
206
+ }
207
+ },
208
+ records)
209
+ assert_equal(records, target.raw_records)
210
+ end
211
+
212
+ def test_timestamp_micro
213
+ records = [
214
+ [Time.parse("1960-01-01T02:09:30.123456Z")],
215
+ [nil],
216
+ [Time.parse("2017-08-23T14:57:02.987654Z")],
217
+ ]
218
+ target = build({
219
+ column: {
220
+ type: :timestamp,
221
+ unit: :micro,
222
+ }
223
+ },
224
+ records)
225
+ assert_equal(records, target.raw_records)
226
+ end
227
+
228
+ def test_timestamp_nano
229
+ records = [
230
+ [Time.parse("1960-01-01T02:09:30.123456789Z")],
231
+ [nil],
232
+ [Time.parse("2017-08-23T14:57:02.987654321Z")],
233
+ ]
234
+ target = build({
235
+ column: {
236
+ type: :timestamp,
237
+ unit: :nano,
238
+ }
239
+ },
240
+ records)
241
+ assert_equal(records, target.raw_records)
242
+ end
243
+
244
+ def test_time32_second
245
+ records = [
246
+ [60 * 10], # 00:10:00
247
+ [nil],
248
+ [60 * 60 * 2 + 9], # 02:00:09
249
+ ]
250
+ target = build({
251
+ column: {
252
+ type: :time32,
253
+ unit: :second,
254
+ }
255
+ },
256
+ records)
257
+ assert_equal(records, target.raw_records)
258
+ end
259
+
260
+ def test_time32_milli
261
+ records = [
262
+ [(60 * 10) * 1000 + 123], # 00:10:00.123
263
+ [nil],
264
+ [(60 * 60 * 2 + 9) * 1000 + 987], # 02:00:09.987
265
+ ]
266
+ target = build({
267
+ column: {
268
+ type: :time32,
269
+ unit: :milli,
270
+ }
271
+ },
272
+ records)
273
+ assert_equal(records, target.raw_records)
274
+ end
275
+
276
+ def test_time64_micro
277
+ records = [
278
+ [(60 * 10) * 1_000_000 + 123_456], # 00:10:00.123456
279
+ [nil],
280
+ [(60 * 60 * 2 + 9) * 1_000_000 + 987_654], # 02:00:09.987654
281
+ ]
282
+ target = build({
283
+ column: {
284
+ type: :time64,
285
+ unit: :micro,
286
+ }
287
+ },
288
+ records)
289
+ assert_equal(records, target.raw_records)
290
+ end
291
+
292
+ def test_time64_nano
293
+ records = [
294
+ [(60 * 10) * 1_000_000_000 + 123_456_789], # 00:10:00.123456789
295
+ [nil],
296
+ [(60 * 60 * 2 + 9) * 1_000_000_000 + 987_654_321], # 02:00:09.987654321
297
+ ]
298
+ target = build({
299
+ column: {
300
+ type: :time64,
301
+ unit: :nano,
302
+ }
303
+ },
304
+ records)
305
+ assert_equal(records, target.raw_records)
306
+ end
307
+
308
+ def test_decimal128
309
+ records = [
310
+ [BigDecimal("92.92")],
311
+ [nil],
312
+ [BigDecimal("29.29")],
313
+ ]
314
+ target = build({
315
+ column: {
316
+ type: :decimal128,
317
+ precision: 8,
318
+ scale: 2,
319
+ }
320
+ },
321
+ records)
322
+ assert_equal(records, target.raw_records)
323
+ end
324
+ end
325
+
326
+ class RawRecordsRecordBatchBasicArraysTest < Test::Unit::TestCase
327
+ include RawRecordsBasicArraysTests
328
+
329
+ def build(schema, records)
330
+ Arrow::RecordBatch.new(schema, records)
331
+ end
332
+ end
333
+
334
+ class RawRecordsTableBasicArraysTest < Test::Unit::TestCase
335
+ include RawRecordsBasicArraysTests
336
+
337
+ def build(schema, records)
338
+ Arrow::Table.new(schema, records)
339
+ end
340
+ end
@@ -0,0 +1,492 @@
1
+ # Licensed to the Apache Software Foundation (ASF) under one
2
+ # or more contributor license agreements. See the NOTICE file
3
+ # distributed with this work for additional information
4
+ # regarding copyright ownership. The ASF licenses this file
5
+ # to you under the Apache License, Version 2.0 (the
6
+ # "License"); you may not use this file except in compliance
7
+ # with the License. You may obtain a copy of the License at
8
+ #
9
+ # http://www.apache.org/licenses/LICENSE-2.0
10
+ #
11
+ # Unless required by applicable law or agreed to in writing,
12
+ # software distributed under the License is distributed on an
13
+ # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
14
+ # KIND, either express or implied. See the License for the
15
+ # specific language governing permissions and limitations
16
+ # under the License.
17
+
18
+ module RawRecordsDenseUnionArrayTests
19
+ def build_schema(type, type_codes)
20
+ field_description = {}
21
+ if type.is_a?(Hash)
22
+ field_description = field_description.merge(type)
23
+ else
24
+ field_description[:type] = type
25
+ end
26
+ {
27
+ column: {
28
+ type: :dense_union,
29
+ fields: [
30
+ field_description.merge(name: "0"),
31
+ field_description.merge(name: "1"),
32
+ ],
33
+ type_codes: type_codes,
34
+ },
35
+ }
36
+ end
37
+
38
+ # TODO: Use Arrow::RecordBatch.new(build_schema(type, type_codes), records)
39
+ def build_record_batch(type, records)
40
+ type_codes = [0, 1]
41
+ schema = Arrow::Schema.new(build_schema(type, type_codes))
42
+ type_ids = []
43
+ offsets = []
44
+ arrays = schema.fields[0].data_type.fields.collect do |field|
45
+ sub_schema = Arrow::Schema.new([field])
46
+ sub_records = []
47
+ records.each do |record|
48
+ column = record[0]
49
+ next if column.nil?
50
+ next unless column.key?(field.name)
51
+ sub_records << [column[field.name]]
52
+ end
53
+ sub_record_batch = Arrow::RecordBatch.new(sub_schema,
54
+ sub_records)
55
+ sub_record_batch.columns[0]
56
+ end
57
+ records.each do |record|
58
+ column = record[0]
59
+ if column.nil?
60
+ type_ids << nil
61
+ offsets << 0
62
+ elsif column.key?("0")
63
+ type_id = type_codes[0]
64
+ type_ids << type_id
65
+ offsets << (type_ids.count(type_id) - 1)
66
+ elsif column.key?("1")
67
+ type_id = type_codes[1]
68
+ type_ids << type_id
69
+ offsets << (type_ids.count(type_id) - 1)
70
+ end
71
+ end
72
+ union_array = Arrow::DenseUnionArray.new(schema.fields[0].data_type,
73
+ Arrow::Int8Array.new(type_ids),
74
+ Arrow::Int32Array.new(offsets),
75
+ arrays)
76
+ schema = Arrow::Schema.new(column: union_array.value_data_type)
77
+ Arrow::RecordBatch.new(schema,
78
+ records.size,
79
+ [union_array])
80
+ end
81
+
82
+ def test_null
83
+ records = [
84
+ [{"0" => nil}],
85
+ [nil],
86
+ ]
87
+ target = build(:null, records)
88
+ assert_equal(records, target.raw_records)
89
+ end
90
+
91
+ def test_boolean
92
+ records = [
93
+ [{"0" => true}],
94
+ [nil],
95
+ [{"1" => nil}],
96
+ ]
97
+ target = build(:boolean, records)
98
+ assert_equal(records, target.raw_records)
99
+ end
100
+
101
+ def test_int8
102
+ records = [
103
+ [{"0" => -(2 ** 7)}],
104
+ [nil],
105
+ [{"1" => nil}],
106
+ ]
107
+ target = build(:int8, records)
108
+ assert_equal(records, target.raw_records)
109
+ end
110
+
111
+ def test_uint8
112
+ records = [
113
+ [{"0" => (2 ** 8) - 1}],
114
+ [nil],
115
+ [{"1" => nil}],
116
+ ]
117
+ target = build(:uint8, records)
118
+ assert_equal(records, target.raw_records)
119
+ end
120
+
121
+ def test_int16
122
+ records = [
123
+ [{"0" => -(2 ** 15)}],
124
+ [nil],
125
+ [{"1" => nil}],
126
+ ]
127
+ target = build(:int16, records)
128
+ assert_equal(records, target.raw_records)
129
+ end
130
+
131
+ def test_uint16
132
+ records = [
133
+ [{"0" => (2 ** 16) - 1}],
134
+ [nil],
135
+ [{"1" => nil}],
136
+ ]
137
+ target = build(:uint16, records)
138
+ assert_equal(records, target.raw_records)
139
+ end
140
+
141
+ def test_int32
142
+ records = [
143
+ [{"0" => -(2 ** 31)}],
144
+ [nil],
145
+ [{"1" => nil}],
146
+ ]
147
+ target = build(:int32, records)
148
+ assert_equal(records, target.raw_records)
149
+ end
150
+
151
+ def test_uint32
152
+ records = [
153
+ [{"0" => (2 ** 32) - 1}],
154
+ [nil],
155
+ [{"1" => nil}],
156
+ ]
157
+ target = build(:uint32, records)
158
+ assert_equal(records, target.raw_records)
159
+ end
160
+
161
+ def test_int64
162
+ records = [
163
+ [{"0" => -(2 ** 63)}],
164
+ [nil],
165
+ [{"1" => nil}],
166
+ ]
167
+ target = build(:int64, records)
168
+ assert_equal(records, target.raw_records)
169
+ end
170
+
171
+ def test_uint64
172
+ records = [
173
+ [{"0" => (2 ** 64) - 1}],
174
+ [nil],
175
+ [{"1" => nil}],
176
+ ]
177
+ target = build(:uint64, records)
178
+ assert_equal(records, target.raw_records)
179
+ end
180
+
181
+ def test_float
182
+ records = [
183
+ [{"0" => -1.0}],
184
+ [nil],
185
+ [{"1" => nil}],
186
+ ]
187
+ target = build(:float, records)
188
+ assert_equal(records, target.raw_records)
189
+ end
190
+
191
+ def test_double
192
+ records = [
193
+ [{"0" => -1.0}],
194
+ [nil],
195
+ [{"1" => nil}],
196
+ ]
197
+ target = build(:double, records)
198
+ assert_equal(records, target.raw_records)
199
+ end
200
+
201
+ def test_binary
202
+ records = [
203
+ [{"0" => "\xff".b}],
204
+ [nil],
205
+ [{"1" => nil}],
206
+ ]
207
+ target = build(:binary, records)
208
+ assert_equal(records, target.raw_records)
209
+ end
210
+
211
+ def test_string
212
+ records = [
213
+ [{"0" => "Ruby"}],
214
+ [nil],
215
+ [{"1" => nil}],
216
+ ]
217
+ target = build(:string, records)
218
+ assert_equal(records, target.raw_records)
219
+ end
220
+
221
+ def test_date32
222
+ records = [
223
+ [{"0" => Date.new(1960, 1, 1)}],
224
+ [nil],
225
+ [{"1" => nil}],
226
+ ]
227
+ target = build(:date32, records)
228
+ assert_equal(records, target.raw_records)
229
+ end
230
+
231
+ def test_date64
232
+ records = [
233
+ [{"0" => DateTime.new(1960, 1, 1, 2, 9, 30)}],
234
+ [nil],
235
+ [{"1" => nil}],
236
+ ]
237
+ target = build(:date64, records)
238
+ assert_equal(records, target.raw_records)
239
+ end
240
+
241
+ def test_timestamp_second
242
+ records = [
243
+ [{"0" => Time.parse("1960-01-01T02:09:30Z")}],
244
+ [nil],
245
+ [{"1" => nil}],
246
+ ]
247
+ target = build({
248
+ type: :timestamp,
249
+ unit: :second,
250
+ },
251
+ records)
252
+ assert_equal(records, target.raw_records)
253
+ end
254
+
255
+ def test_timestamp_milli
256
+ records = [
257
+ [{"0" => Time.parse("1960-01-01T02:09:30.123Z")}],
258
+ [nil],
259
+ [{"1" => nil}],
260
+ ]
261
+ target = build({
262
+ type: :timestamp,
263
+ unit: :milli,
264
+ },
265
+ records)
266
+ assert_equal(records, target.raw_records)
267
+ end
268
+
269
+ def test_timestamp_micro
270
+ records = [
271
+ [{"0" => Time.parse("1960-01-01T02:09:30.123456Z")}],
272
+ [nil],
273
+ [{"1" => nil}],
274
+ ]
275
+ target = build({
276
+ type: :timestamp,
277
+ unit: :micro,
278
+ },
279
+ records)
280
+ assert_equal(records, target.raw_records)
281
+ end
282
+
283
+ def test_timestamp_nano
284
+ records = [
285
+ [{"0" => Time.parse("1960-01-01T02:09:30.123456789Z")}],
286
+ [nil],
287
+ [{"1" => nil}],
288
+ ]
289
+ target = build({
290
+ type: :timestamp,
291
+ unit: :nano,
292
+ },
293
+ records)
294
+ assert_equal(records, target.raw_records)
295
+ end
296
+
297
+ def test_time32_second
298
+ records = [
299
+ [{"0" => 60 * 10}], # 00:10:00
300
+ [nil],
301
+ [{"1" => nil}],
302
+ ]
303
+ target = build({
304
+ type: :time32,
305
+ unit: :second,
306
+ },
307
+ records)
308
+ assert_equal(records, target.raw_records)
309
+ end
310
+
311
+ def test_time32_milli
312
+ records = [
313
+ [{"0" => (60 * 10) * 1000 + 123}], # 00:10:00.123
314
+ [nil],
315
+ [{"1" => nil}],
316
+ ]
317
+ target = build({
318
+ type: :time32,
319
+ unit: :milli,
320
+ },
321
+ records)
322
+ assert_equal(records, target.raw_records)
323
+ end
324
+
325
+ def test_time64_micro
326
+ records = [
327
+ [{"0" => (60 * 10) * 1_000_000 + 123_456}], # 00:10:00.123456
328
+ [nil],
329
+ [{"1" => nil}],
330
+ ]
331
+ target = build({
332
+ type: :time64,
333
+ unit: :micro,
334
+ },
335
+ records)
336
+ assert_equal(records, target.raw_records)
337
+ end
338
+
339
+ def test_time64_nano
340
+ records = [
341
+ # 00:10:00.123456789
342
+ [{"0" => (60 * 10) * 1_000_000_000 + 123_456_789}],
343
+ [nil],
344
+ [{"1" => nil}],
345
+ ]
346
+ target = build({
347
+ type: :time64,
348
+ unit: :nano,
349
+ },
350
+ records)
351
+ assert_equal(records, target.raw_records)
352
+ end
353
+
354
+ def test_decimal128
355
+ records = [
356
+ [{"0" => BigDecimal("92.92")}],
357
+ [nil],
358
+ [{"1" => nil}],
359
+ ]
360
+ target = build({
361
+ type: :decimal128,
362
+ precision: 8,
363
+ scale: 2,
364
+ },
365
+ records)
366
+ assert_equal(records, target.raw_records)
367
+ end
368
+
369
+ def test_list
370
+ records = [
371
+ [{"0" => [true, nil, false]}],
372
+ [nil],
373
+ [{"1" => nil}],
374
+ ]
375
+ target = build({
376
+ type: :list,
377
+ field: {
378
+ name: :sub_element,
379
+ type: :boolean,
380
+ },
381
+ },
382
+ records)
383
+ assert_equal(records, target.raw_records)
384
+ end
385
+
386
+ def test_struct
387
+ records = [
388
+ [{"0" => {"sub_field" => true}}],
389
+ [nil],
390
+ [{"1" => nil}],
391
+ [{"0" => {"sub_field" => nil}}],
392
+ ]
393
+ target = build({
394
+ type: :struct,
395
+ fields: [
396
+ {
397
+ name: :sub_field,
398
+ type: :boolean,
399
+ },
400
+ ],
401
+ },
402
+ records)
403
+ assert_equal(records, target.raw_records)
404
+ end
405
+
406
+ def test_sparse_union
407
+ omit("Need to add support for SparseUnionArrayBuilder")
408
+ records = [
409
+ [{"0" => {"field1" => true}}],
410
+ [nil],
411
+ [{"1" => nil}],
412
+ [{"0" => {"field2" => nil}}],
413
+ ]
414
+ target = build({
415
+ type: :sparse_union,
416
+ fields: [
417
+ {
418
+ name: :field1,
419
+ type: :boolean,
420
+ },
421
+ {
422
+ name: :field2,
423
+ type: :uint8,
424
+ },
425
+ ],
426
+ type_codes: [0, 1],
427
+ },
428
+ records)
429
+ assert_equal(records, target.raw_records)
430
+ end
431
+
432
+ def test_dense_union
433
+ omit("Need to add support for DenseUnionArrayBuilder")
434
+ records = [
435
+ [{"0" => {"field1" => true}}],
436
+ [nil],
437
+ [{"1" => nil}],
438
+ [{"0" => {"field2" => nil}}],
439
+ ]
440
+ target = build({
441
+ type: :dense_union,
442
+ fields: [
443
+ {
444
+ name: :field1,
445
+ type: :boolean,
446
+ },
447
+ {
448
+ name: :field2,
449
+ type: :uint8,
450
+ },
451
+ ],
452
+ type_codes: [0, 1],
453
+ },
454
+ records)
455
+ assert_equal(records, target.raw_records)
456
+ end
457
+
458
+ def test_dictionary
459
+ omit("Need to add support for DictionaryArrayBuilder")
460
+ records = [
461
+ [{"0" => "Ruby"}],
462
+ [nil],
463
+ [{"1" => nil}],
464
+ [{"0" => "GLib"}],
465
+ ]
466
+ dictionary = Arrow::StringArray.new(["GLib", "Ruby"])
467
+ target = build({
468
+ type: :dictionary,
469
+ index_data_type: :int8,
470
+ dictionary: dictionary,
471
+ ordered: true,
472
+ },
473
+ records)
474
+ assert_equal(records, target.raw_records)
475
+ end
476
+ end
477
+
478
+ class RawRecordsRecordBatchDenseUnionArrayTest < Test::Unit::TestCase
479
+ include RawRecordsDenseUnionArrayTests
480
+
481
+ def build(type, records)
482
+ build_record_batch(type, records)
483
+ end
484
+ end
485
+
486
+ class RawRecordsTableDenseUnionArrayTest < Test::Unit::TestCase
487
+ include RawRecordsDenseUnionArrayTests
488
+
489
+ def build(type, records)
490
+ build_record_batch(type, records).to_table
491
+ end
492
+ end