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