ceph/src/arrow/ruby/red-arrow/test/values/test-list-array.rb

   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 ValuesListArrayTests
  19   def build_data_type(type)
  20     field_description = {
  21       name: :element,
  22     }
  23     if type.is_a?(Hash)
  24       field_description = field_description.merge(type)
  25     else
  26       field_description[:type] = type
  27     end
  28     Arrow::ListDataType.new(field: field_description)
  29   end
  30
  31   def build_array(type, values)
  32     Arrow::ListArray.new(build_data_type(type), values)
  33   end
  34
  35   def test_null
  36     values = [
  37       [nil, nil, nil],
  38       nil,
  39     ]
  40     target = build(:null, values)
  41     assert_equal(values, target.values)
  42   end
  43
  44   def test_boolean
  45     values = [
  46       [true, nil, false],
  47       nil,
  48     ]
  49     target = build(:boolean, values)
  50     assert_equal(values, target.values)
  51   end
  52
  53   def test_int8
  54     values = [
  55       [-(2 ** 7), nil, (2 ** 7) - 1],
  56       nil,
  57     ]
  58     target = build(:int8, values)
  59     assert_equal(values, target.values)
  60   end
  61
  62   def test_uint8
  63     values = [
  64       [0, nil, (2 ** 8) - 1],
  65       nil,
  66     ]
  67     target = build(:uint8, values)
  68     assert_equal(values, target.values)
  69   end
  70
  71   def test_int16
  72     values = [
  73       [-(2 ** 15), nil, (2 ** 15) - 1],
  74       nil,
  75     ]
  76     target = build(:int16, values)
  77     assert_equal(values, target.values)
  78   end
  79
  80   def test_uint16
  81     values = [
  82       [0, nil, (2 ** 16) - 1],
  83       nil,
  84     ]
  85     target = build(:uint16, values)
  86     assert_equal(values, target.values)
  87   end
  88
  89   def test_int32
  90     values = [
  91       [-(2 ** 31), nil, (2 ** 31) - 1],
  92       nil,
  93     ]
  94     target = build(:int32, values)
  95     assert_equal(values, target.values)
  96   end
  97
  98   def test_uint32
  99     values = [
 100       [0, nil, (2 ** 32) - 1],
 101       nil,
 102     ]
 103     target = build(:uint32, values)
 104     assert_equal(values, target.values)
 105   end
 106
 107   def test_int64
 108     values = [
 109       [-(2 ** 63), nil, (2 ** 63) - 1],
 110       nil,
 111     ]
 112     target = build(:int64, values)
 113     assert_equal(values, target.values)
 114   end
 115
 116   def test_uint64
 117     values = [
 118       [0, nil, (2 ** 64) - 1],
 119       nil,
 120     ]
 121     target = build(:uint64, values)
 122     assert_equal(values, target.values)
 123   end
 124
 125   def test_float
 126     values = [
 127       [-1.0, nil, 1.0],
 128       nil,
 129     ]
 130     target = build(:float, values)
 131     assert_equal(values, target.values)
 132   end
 133
 134   def test_double
 135     values = [
 136       [-1.0, nil, 1.0],
 137       nil,
 138     ]
 139     target = build(:double, values)
 140     assert_equal(values, target.values)
 141   end
 142
 143   def test_binary
 144     values = [
 145       ["\x00".b, nil, "\xff".b],
 146       nil,
 147     ]
 148     target = build(:binary, values)
 149     assert_equal(values, target.values)
 150   end
 151
 152   def test_string
 153     values = [
 154       [
 155         "Ruby",
 156         nil,
 157         "\u3042", # U+3042 HIRAGANA LETTER A
 158       ],
 159       nil,
 160     ]
 161     target = build(:string, values)
 162     assert_equal(values, target.values)
 163   end
 164
 165   def test_date32
 166     values = [
 167       [
 168         Date.new(1960, 1, 1),
 169         nil,
 170         Date.new(2017, 8, 23),
 171       ],
 172       nil,
 173     ]
 174     target = build(:date32, values)
 175     assert_equal(values, target.values)
 176   end
 177
 178   def test_date64
 179     values = [
 180       [
 181         DateTime.new(1960, 1, 1, 2, 9, 30),
 182         nil,
 183         DateTime.new(2017, 8, 23, 14, 57, 2),
 184       ],
 185       nil,
 186     ]
 187     target = build(:date64, values)
 188     assert_equal(values, target.values)
 189   end
 190
 191   def test_timestamp_second
 192     values = [
 193       [
 194         Time.parse("1960-01-01T02:09:30Z"),
 195         nil,
 196         Time.parse("2017-08-23T14:57:02Z"),
 197       ],
 198       nil,
 199     ]
 200     target = build({
 201                      type: :timestamp,
 202                      unit: :second,
 203                    },
 204                    values)
 205     assert_equal(values, target.values)
 206   end
 207
 208   def test_timestamp_milli
 209     values = [
 210       [
 211         Time.parse("1960-01-01T02:09:30.123Z"),
 212         nil,
 213         Time.parse("2017-08-23T14:57:02.987Z"),
 214       ],
 215       nil,
 216     ]
 217     target = build({
 218                      type: :timestamp,
 219                      unit: :milli,
 220                    },
 221                    values)
 222     assert_equal(values, target.values)
 223   end
 224
 225   def test_timestamp_micro
 226     values = [
 227       [
 228         Time.parse("1960-01-01T02:09:30.123456Z"),
 229         nil,
 230         Time.parse("2017-08-23T14:57:02.987654Z"),
 231       ],
 232       nil,
 233     ]
 234     target = build({
 235                      type: :timestamp,
 236                      unit: :micro,
 237                    },
 238                    values)
 239     assert_equal(values, target.values)
 240   end
 241
 242   def test_timestamp_nano
 243     values = [
 244       [
 245         Time.parse("1960-01-01T02:09:30.123456789Z"),
 246         nil,
 247         Time.parse("2017-08-23T14:57:02.987654321Z"),
 248       ],
 249       nil,
 250     ]
 251     target = build({
 252                      type: :timestamp,
 253                      unit: :nano,
 254                    },
 255                    values)
 256     assert_equal(values, target.values)
 257   end
 258
 259   def test_time32_second
 260     unit = Arrow::TimeUnit::SECOND
 261     values = [
 262       [
 263         # 00:10:00
 264         Arrow::Time.new(unit, 60 * 10),
 265         nil,
 266         # 02:00:09
 267         Arrow::Time.new(unit, 60 * 60 * 2 + 9),
 268       ],
 269       nil,
 270     ]
 271     target = build({
 272                      type: :time32,
 273                      unit: :second,
 274                    },
 275                    values)
 276     assert_equal(values, target.values)
 277   end
 278
 279   def test_time32_milli
 280     unit = Arrow::TimeUnit::MILLI
 281     values = [
 282       [
 283         # 00:10:00.123
 284         Arrow::Time.new(unit, (60 * 10) * 1000 + 123),
 285         nil,
 286         # 02:00:09.987
 287         Arrow::Time.new(unit, (60 * 60 * 2 + 9) * 1000 + 987),
 288       ],
 289       nil,
 290     ]
 291     target = build({
 292                      type: :time32,
 293                      unit: :milli,
 294                    },
 295                    values)
 296     assert_equal(values, target.values)
 297   end
 298
 299   def test_time64_micro
 300     unit = Arrow::TimeUnit::MICRO
 301     values = [
 302       [
 303         # 00:10:00.123456
 304         Arrow::Time.new(unit, (60 * 10) * 1_000_000 + 123_456),
 305         nil,
 306         # 02:00:09.987654
 307         Arrow::Time.new(unit, (60 * 60 * 2 + 9) * 1_000_000 + 987_654),
 308       ],
 309       nil,
 310     ]
 311     target = build({
 312                      type: :time64,
 313                      unit: :micro,
 314                    },
 315                    values)
 316     assert_equal(values, target.values)
 317   end
 318
 319   def test_time64_nano
 320     unit = Arrow::TimeUnit::NANO
 321     values = [
 322       [
 323         # 00:10:00.123456789
 324         Arrow::Time.new(unit, (60 * 10) * 1_000_000_000 + 123_456_789),
 325         nil,
 326         # 02:00:09.987654321
 327         Arrow::Time.new(unit, (60 * 60 * 2 + 9) * 1_000_000_000 + 987_654_321),
 328       ],
 329       nil,
 330     ]
 331     target = build({
 332                      type: :time64,
 333                      unit: :nano,
 334                    },
 335                    values)
 336     assert_equal(values, target.values)
 337   end
 338
 339   def test_decimal128
 340     values = [
 341       [
 342         BigDecimal("92.92"),
 343         nil,
 344         BigDecimal("29.29"),
 345       ],
 346       nil,
 347     ]
 348     target = build({
 349                      type: :decimal128,
 350                      precision: 8,
 351                      scale: 2,
 352                    },
 353                    values)
 354     assert_equal(values, target.values)
 355   end
 356
 357   def test_decimal256
 358     values = [
 359       [
 360         BigDecimal("92.92"),
 361         nil,
 362         BigDecimal("29.29"),
 363       ],
 364       nil,
 365     ]
 366     target = build({
 367                      type: :decimal256,
 368                      precision: 38,
 369                      scale: 2,
 370                    },
 371                    values)
 372     assert_equal(values, target.values)
 373   end
 374
 375   def test_list
 376     values = [
 377       [
 378         [
 379           true,
 380           nil,
 381         ],
 382         nil,
 383         [
 384           nil,
 385           false,
 386         ],
 387       ],
 388       nil,
 389     ]
 390     target = build({
 391                      type: :list,
 392                      field: {
 393                        name: :sub_element,
 394                        type: :boolean,
 395                      },
 396                    },
 397                    values)
 398     assert_equal(values, target.values)
 399   end
 400
 401   def test_struct
 402     values = [
 403       [
 404         {"field" => true},
 405         nil,
 406         {"field" => nil},
 407       ],
 408       nil,
 409     ]
 410     target = build({
 411                      type: :struct,
 412                      fields: [
 413                        {
 414                          name: :field,
 415                          type: :boolean,
 416                        },
 417                      ],
 418                    },
 419                    values)
 420     assert_equal(values, target.values)
 421   end
 422
 423   def test_map
 424     values = [
 425       [
 426         {"key1" => true, "key2" => nil},
 427         nil,
 428       ],
 429       nil,
 430     ]
 431     target = build({
 432                      type: :map,
 433                      key: :string,
 434                      item: :boolean,
 435                    },
 436                    values)
 437     assert_equal(values, target.values)
 438   end
 439
 440   def test_sparse
 441     omit("Need to add support for SparseUnionArrayBuilder")
 442     values = [
 443       [
 444         {"field1" => true},
 445         nil,
 446         {"field2" => nil},
 447       ],
 448       nil,
 449     ]
 450     target = build({
 451                      type: :sparse_union,
 452                      fields: [
 453                        {
 454                          name: :field1,
 455                          type: :boolean,
 456                        },
 457                        {
 458                          name: :field2,
 459                          type: :uint8,
 460                        },
 461                      ],
 462                      type_codes: [0, 1],
 463                    },
 464                    values)
 465     assert_equal(values, target.values)
 466   end
 467
 468   def test_dense
 469     omit("Need to add support for DenseUnionArrayBuilder")
 470     values = [
 471       [
 472         {"field1" => true},
 473         nil,
 474         {"field2" => nil},
 475       ],
 476       nil,
 477     ]
 478     target = build({
 479                      type: :dense_union,
 480                      fields: [
 481                        {
 482                          name: :field1,
 483                          type: :boolean,
 484                        },
 485                        {
 486                          name: :field2,
 487                          type: :uint8,
 488                        },
 489                      ],
 490                      type_codes: [0, 1],
 491                    },
 492                    values)
 493     assert_equal(values, target.values)
 494   end
 495
 496   def test_dictionary
 497     omit("Need to add support for DictionaryArrayBuilder")
 498     values = [
 499       [
 500         "Ruby",
 501         nil,
 502         "GLib",
 503       ],
 504       nil,
 505     ]
 506     dictionary = Arrow::StringArray.new(["GLib", "Ruby"])
 507     target = build({
 508                      type: :dictionary,
 509                      index_data_type: :int8,
 510                      dictionary: dictionary,
 511                      ordered: true,
 512                    },
 513                    values)
 514     assert_equal(values, target.values)
 515   end
 516 end
 517
 518 class ValuesArrayListArrayTest < Test::Unit::TestCase
 519   include ValuesListArrayTests
 520
 521   def build(type, values)
 522     build_array(type, values)
 523   end
 524 end
 525
 526 class ValuesChunkedArrayListArrayTest < Test::Unit::TestCase
 527   include ValuesListArrayTests
 528
 529   def build(type, values)
 530     Arrow::ChunkedArray.new([build_array(type, values)])
 531   end
 532 end