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
18module 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    unit = Arrow::TimeUnit::SECOND
246    records = [
247      [Arrow::Time.new(unit, 60 * 10)], # 00:10:00
248      [nil],
249      [Arrow::Time.new(unit, 60 * 60 * 2 + 9)], # 02:00:09
250    ]
251    target = build({
252                     column: {
253                       type: :time32,
254                       unit: :second,
255                     }
256                   },
257                   records)
258    assert_equal(records, target.raw_records)
259  end
260
261  def test_time32_milli
262    unit = Arrow::TimeUnit::MILLI
263    records = [
264      [Arrow::Time.new(unit, (60 * 10) * 1000 + 123)], # 00:10:00.123
265      [nil],
266      [Arrow::Time.new(unit, (60 * 60 * 2 + 9) * 1000 + 987)], # 02:00:09.987
267    ]
268    target = build({
269                     column: {
270                       type: :time32,
271                       unit: :milli,
272                     }
273                   },
274                   records)
275    assert_equal(records, target.raw_records)
276  end
277
278  def test_time64_micro
279    unit = Arrow::TimeUnit::MICRO
280    records = [
281      # 00:10:00.123456
282      [Arrow::Time.new(unit, (60 * 10) * 1_000_000 + 123_456)],
283      [nil],
284      # 02:00:09.987654
285      [Arrow::Time.new(unit, (60 * 60 * 2 + 9) * 1_000_000 + 987_654)],
286    ]
287    target = build({
288                     column: {
289                       type: :time64,
290                       unit: :micro,
291                     }
292                   },
293                   records)
294    assert_equal(records, target.raw_records)
295  end
296
297  def test_time64_nano
298    unit = Arrow::TimeUnit::NANO
299    records = [
300      # 00:10:00.123456789
301      [Arrow::Time.new(unit, (60 * 10) * 1_000_000_000 + 123_456_789)],
302      [nil],
303      # 02:00:09.987654321
304      [Arrow::Time.new(unit, (60 * 60 * 2 + 9) * 1_000_000_000 + 987_654_321)],
305    ]
306    target = build({
307                     column: {
308                       type: :time64,
309                       unit: :nano,
310                     }
311                   },
312                   records)
313    assert_equal(records, target.raw_records)
314  end
315
316  def test_decimal128
317    records = [
318      [BigDecimal("92.92")],
319      [nil],
320      [BigDecimal("29.29")],
321    ]
322    target = build({
323                     column: {
324                       type: :decimal128,
325                       precision: 8,
326                       scale: 2,
327                     }
328                   },
329                   records)
330    assert_equal(records, target.raw_records)
331  end
332
333  def test_decimal256
334    records = [
335      [BigDecimal("92.92")],
336      [nil],
337      [BigDecimal("29.29")],
338    ]
339    target = build({
340                     column: {
341                       type: :decimal256,
342                       precision: 38,
343                       scale: 2,
344                     }
345                   },
346                   records)
347    assert_equal(records, target.raw_records)
348  end
349end
350
351class RawRecordsRecordBatchBasicArraysTest < Test::Unit::TestCase
352  include RawRecordsBasicArraysTests
353
354  def build(schema, records)
355    Arrow::RecordBatch.new(schema, records)
356  end
357end
358
359class RawRecordsTableBasicArraysTest < Test::Unit::TestCase
360  include RawRecordsBasicArraysTests
361
362  def build(schema, records)
363    Arrow::Table.new(schema, records)
364  end
365end
366