ceph/src/arrow/java/vector/src/test/java/org/apache/arrow/vector/testing/TestValueVectorPopulator.java

   1 /*
   2  * Licensed to the Apache Software Foundation (ASF) under one or more
   3  * contributor license agreements.  See the NOTICE file distributed with
   4  * this work for additional information regarding copyright ownership.
   5  * The ASF licenses this file to You under the Apache License, Version 2.0
   6  * (the "License"); you may not use this file except in compliance with
   7  * 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, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 package org.apache.arrow.vector.testing;
  19
  20 import static junit.framework.TestCase.assertTrue;
  21 import static org.apache.arrow.vector.testing.ValueVectorDataPopulator.setVector;
  22
  23 import org.apache.arrow.memory.BufferAllocator;
  24 import org.apache.arrow.memory.RootAllocator;
  25 import org.apache.arrow.vector.BigIntVector;
  26 import org.apache.arrow.vector.BitVector;
  27 import org.apache.arrow.vector.DateDayVector;
  28 import org.apache.arrow.vector.DateMilliVector;
  29 import org.apache.arrow.vector.DecimalVector;
  30 import org.apache.arrow.vector.DurationVector;
  31 import org.apache.arrow.vector.FixedSizeBinaryVector;
  32 import org.apache.arrow.vector.Float4Vector;
  33 import org.apache.arrow.vector.Float8Vector;
  34 import org.apache.arrow.vector.IntVector;
  35 import org.apache.arrow.vector.IntervalYearVector;
  36 import org.apache.arrow.vector.SmallIntVector;
  37 import org.apache.arrow.vector.TimeMicroVector;
  38 import org.apache.arrow.vector.TimeMilliVector;
  39 import org.apache.arrow.vector.TimeNanoVector;
  40 import org.apache.arrow.vector.TimeSecVector;
  41 import org.apache.arrow.vector.TimeStampMicroVector;
  42 import org.apache.arrow.vector.TimeStampMilliVector;
  43 import org.apache.arrow.vector.TimeStampNanoVector;
  44 import org.apache.arrow.vector.TimeStampSecVector;
  45 import org.apache.arrow.vector.TinyIntVector;
  46 import org.apache.arrow.vector.UInt1Vector;
  47 import org.apache.arrow.vector.UInt2Vector;
  48 import org.apache.arrow.vector.UInt4Vector;
  49 import org.apache.arrow.vector.UInt8Vector;
  50 import org.apache.arrow.vector.VarBinaryVector;
  51 import org.apache.arrow.vector.VarCharVector;
  52 import org.apache.arrow.vector.compare.VectorEqualsVisitor;
  53 import org.apache.arrow.vector.testing.ValueVectorDataPopulator;
  54 import org.apache.arrow.vector.types.TimeUnit;
  55 import org.apache.arrow.vector.types.pojo.ArrowType;
  56 import org.apache.arrow.vector.types.pojo.FieldType;
  57 import org.junit.After;
  58 import org.junit.Before;
  59 import org.junit.Test;
  60
  61 public class TestValueVectorPopulator {
  62
  63   private BufferAllocator allocator;
  64
  65   @Before
  66   public void init() {
  67     allocator = new RootAllocator(Long.MAX_VALUE);
  68   }
  69
  70   @After
  71   public void terminate() throws Exception {
  72     allocator.close();
  73   }
  74
  75   @Test
  76   public void testPopulateBigIntVector() {
  77     try (final BigIntVector vector1 = new BigIntVector("vector", allocator);
  78          final BigIntVector vector2 = new BigIntVector("vector", allocator)) {
  79
  80       vector1.allocateNew(10);
  81       for (int i = 0; i < 10; i++) {
  82         if (i % 2 == 0) {
  83           vector1.setNull(i);
  84         } else {
  85           vector1.set(i, i);
  86         }
  87       }
  88       vector1.setValueCount(10);
  89
  90       setVector(vector2, null, 1L, null, 3L, null, 5L, null, 7L, null, 9L);
  91       assertTrue(VectorEqualsVisitor.vectorEquals(vector1, vector2));
  92     }
  93   }
  94
  95   @Test
  96   public void testPopulateBitVector() {
  97     try (final BitVector vector1 = new BitVector("vector", allocator);
  98          final BitVector vector2 = new BitVector("vector", allocator)) {
  99
 100       vector1.allocateNew(10);
 101       for (int i = 0; i < 10; i++) {
 102         if (i % 2 == 0) {
 103           vector1.setNull(i);
 104         } else {
 105           vector1.set(i, i > 5 ? 0 : 1);
 106         }
 107       }
 108       vector1.setValueCount(10);
 109
 110       setVector(vector2, null, 1, null, 1, null, 0, null, 0, null, 0);
 111       assertTrue(VectorEqualsVisitor.vectorEquals(vector1, vector2));
 112     }
 113   }
 114
 115   @Test
 116   public void testPopulateDateDayVector() {
 117     try (final DateDayVector vector1 = new DateDayVector("vector", allocator);
 118          final DateDayVector vector2 = new DateDayVector("vector", allocator)) {
 119
 120       vector1.allocateNew(10);
 121       for (int i = 0; i < 10; i++) {
 122         if (i % 2 == 0) {
 123           vector1.setNull(i);
 124         } else {
 125           vector1.set(i, i * 10);
 126         }
 127       }
 128       vector1.setValueCount(10);
 129
 130       setVector(vector2, null, 10, null, 30, null, 50, null, 70, null, 90);
 131       assertTrue(VectorEqualsVisitor.vectorEquals(vector1, vector2));
 132     }
 133   }
 134
 135   @Test
 136   public void testPopulateDateMilliVector() {
 137     try (final DateMilliVector vector1 = new DateMilliVector("vector", allocator);
 138          final DateMilliVector vector2 = new DateMilliVector("vector", allocator)) {
 139
 140       vector1.allocateNew(10);
 141       for (int i = 0; i < 10; i++) {
 142         if (i % 2 == 0) {
 143           vector1.setNull(i);
 144         } else {
 145           vector1.set(i, i * 1000);
 146         }
 147       }
 148       vector1.setValueCount(10);
 149
 150       setVector(vector2, null, 1000L, null, 3000L, null, 5000L, null, 7000L, null, 9000L);
 151       assertTrue(VectorEqualsVisitor.vectorEquals(vector1, vector2));
 152     }
 153   }
 154
 155   @Test
 156   public void testPopulateDecimalVector() {
 157     try (final DecimalVector vector1 = new DecimalVector("vector", allocator, 10, 3);
 158          final DecimalVector vector2 = new DecimalVector("vector", allocator, 10, 3)) {
 159
 160       vector1.allocateNew(10);
 161       for (int i = 0; i < 10; i++) {
 162         if (i % 2 == 0) {
 163           vector1.setNull(i);
 164         } else {
 165           vector1.set(i, i);
 166         }
 167       }
 168       vector1.setValueCount(10);
 169
 170       setVector(vector2, null, 1L, null, 3L, null, 5L, null, 7L, null, 9L);
 171       assertTrue(VectorEqualsVisitor.vectorEquals(vector1, vector2));
 172     }
 173   }
 174
 175   @Test
 176   public void testPopulateDurationVector() {
 177     final FieldType fieldType = FieldType.nullable(new ArrowType.Duration(TimeUnit.SECOND));
 178     try (final DurationVector vector1 = new DurationVector("vector", fieldType, allocator);
 179          final DurationVector vector2 = new DurationVector("vector", fieldType, allocator)) {
 180
 181       vector1.allocateNew(10);
 182       for (int i = 0; i < 10; i++) {
 183         if (i % 2 == 0) {
 184           vector1.setNull(i);
 185         } else {
 186           vector1.set(i, i);
 187         }
 188       }
 189       vector1.setValueCount(10);
 190
 191       setVector(vector2, null, 1L, null, 3L, null, 5L, null, 7L, null, 9L);
 192
 193       assertTrue(VectorEqualsVisitor.vectorEquals(vector1, vector2));
 194     }
 195   }
 196
 197   @Test
 198   public void testPopulateFixedSizeBinaryVector() {
 199     try (final FixedSizeBinaryVector vector1 = new FixedSizeBinaryVector("vector", allocator, 5);
 200          final FixedSizeBinaryVector vector2 = new FixedSizeBinaryVector("vector", allocator, 5)) {
 201
 202       vector1.allocateNew(10);
 203       for (int i = 0; i < 10; i++) {
 204         if (i % 2 == 0) {
 205           vector1.setNull(i);
 206         } else {
 207           vector1.set(i, ("test" + i).getBytes());
 208         }
 209       }
 210       vector1.setValueCount(10);
 211
 212       setVector(vector2, null, "test1".getBytes(), null, "test3".getBytes(), null, "test5".getBytes(), null,
 213           "test7".getBytes(), null, "test9".getBytes());
 214       assertTrue(VectorEqualsVisitor.vectorEquals(vector1, vector2));
 215     }
 216   }
 217
 218   @Test
 219   public void testPopulateFloat4Vector() {
 220     try (final Float4Vector vector1 = new Float4Vector("vector", allocator);
 221          final Float4Vector vector2 = new Float4Vector("vector", allocator)) {
 222
 223       vector1.allocateNew(10);
 224       for (int i = 0; i < 10; i++) {
 225         if (i % 2 == 0) {
 226           vector1.setNull(i);
 227         } else {
 228           vector1.set(i, i);
 229         }
 230       }
 231       vector1.setValueCount(10);
 232       setVector(vector2, null, 1f, null, 3f, null, 5f, null, 7f, null, 9f);
 233       assertTrue(VectorEqualsVisitor.vectorEquals(vector1, vector2));
 234     }
 235   }
 236
 237   @Test
 238   public void testPopulateFloat8Vector() {
 239     try (final Float8Vector vector1 = new Float8Vector("vector", allocator);
 240          final Float8Vector vector2 = new Float8Vector("vector", allocator)) {
 241
 242       vector1.allocateNew(10);
 243       for (int i = 0; i < 10; i++) {
 244         if (i % 2 == 0) {
 245           vector1.setNull(i);
 246         } else {
 247           vector1.set(i, i);
 248         }
 249       }
 250       vector1.setValueCount(10);
 251       setVector(vector2, null, 1d, null, 3d, null, 5d, null, 7d, null, 9d);
 252       assertTrue(VectorEqualsVisitor.vectorEquals(vector1, vector2));
 253     }
 254   }
 255
 256   @Test
 257   public void testPopulateIntVector() {
 258     try (final IntVector vector1 = new IntVector("vector", allocator);
 259          final IntVector vector2 = new IntVector("vector", allocator)) {
 260
 261       vector1.allocateNew(10);
 262       for (int i = 0; i < 10; i++) {
 263         if (i % 2 == 0) {
 264           vector1.setNull(i);
 265         } else {
 266           vector1.set(i, i);
 267         }
 268       }
 269       vector1.setValueCount(10);
 270
 271       ValueVectorDataPopulator.setVector(vector2, null, 1, null, 3, null, 5, null, 7, null, 9);
 272       assertTrue(VectorEqualsVisitor.vectorEquals(vector1, vector2));
 273     }
 274   }
 275
 276   @Test
 277   public void testPopulateSmallIntVector() {
 278     try (final SmallIntVector vector1 = new SmallIntVector("vector", allocator);
 279          final SmallIntVector vector2 = new SmallIntVector("vector", allocator)) {
 280
 281       vector1.allocateNew(10);
 282       for (int i = 0; i < 10; i++) {
 283         if (i % 2 == 0) {
 284           vector1.setNull(i);
 285         } else {
 286           vector1.set(i, i);
 287         }
 288       }
 289       vector1.setValueCount(10);
 290
 291       ValueVectorDataPopulator.setVector(vector2, null, (short) 1, null, (short) 3, null, (short) 5,
 292           null, (short) 7, null, (short) 9);
 293       assertTrue(VectorEqualsVisitor.vectorEquals(vector1, vector2));
 294     }
 295   }
 296
 297   @Test
 298   public void testPopulateIntervalDayVector() {
 299     try (final IntervalYearVector vector1 = new IntervalYearVector("vector", allocator);
 300          final IntervalYearVector vector2 = new IntervalYearVector("vector", allocator)) {
 301
 302       vector1.allocateNew(10);
 303       for (int i = 0; i < 10; i++) {
 304         if (i % 2 == 0) {
 305           vector1.setNull(i);
 306         } else {
 307           vector1.set(i, i);
 308         }
 309       }
 310       vector1.setValueCount(10);
 311
 312       ValueVectorDataPopulator.setVector(vector2, null, 1, null, 3, null, 5, null, 7, null, 9);
 313       assertTrue(VectorEqualsVisitor.vectorEquals(vector1, vector2));
 314     }
 315   }
 316
 317   @Test
 318   public void testPopulateTimeMicroVector() {
 319     try (final TimeMicroVector vector1 = new TimeMicroVector("vector", allocator);
 320          final TimeMicroVector vector2 = new TimeMicroVector("vector", allocator)) {
 321
 322       vector1.allocateNew(10);
 323       for (int i = 0; i < 10; i++) {
 324         if (i % 2 == 0) {
 325           vector1.setNull(i);
 326         } else {
 327           vector1.set(i, i * 10000);
 328         }
 329       }
 330       vector1.setValueCount(10);
 331       setVector(vector2, null, 10000L, null, 30000L, null, 50000L, null, 70000L, null, 90000L);
 332       assertTrue(VectorEqualsVisitor.vectorEquals(vector1, vector2));
 333     }
 334   }
 335
 336   @Test
 337   public void testPopulateTimeMilliVector() {
 338     try (final TimeMilliVector vector1 = new TimeMilliVector("vector", allocator);
 339         final TimeMilliVector vector2 = new TimeMilliVector("vector", allocator)) {
 340
 341       vector1.allocateNew(10);
 342       for (int i = 0; i < 10; i++) {
 343         if (i % 2 == 0) {
 344           vector1.setNull(i);
 345         } else {
 346           vector1.set(i, i * 100);
 347         }
 348       }
 349       vector1.setValueCount(10);
 350       setVector(vector2, null, 100, null, 300, null, 500, null, 700, null, 900);
 351       assertTrue(VectorEqualsVisitor.vectorEquals(vector1, vector2));
 352     }
 353   }
 354
 355   @Test
 356   public void testPopulateTimeNanoVector() {
 357     try (final TimeNanoVector vector1 = new TimeNanoVector("vector", allocator);
 358          final TimeNanoVector vector2 = new TimeNanoVector("vector", allocator)) {
 359
 360       vector1.allocateNew(10);
 361       for (int i = 0; i < 10; i++) {
 362         if (i % 2 == 0) {
 363           vector1.setNull(i);
 364         } else {
 365           vector1.set(i, i * 10000);
 366         }
 367       }
 368       vector1.setValueCount(10);
 369       setVector(vector2, null, 10000L, null, 30000L, null, 50000L, null, 70000L, null, 90000L);
 370       assertTrue(VectorEqualsVisitor.vectorEquals(vector1, vector2));
 371     }
 372   }
 373
 374   @Test
 375   public void testPopulateTimeSecVector() {
 376     try (final TimeSecVector vector1 = new TimeSecVector("vector", allocator);
 377          final TimeSecVector vector2 = new TimeSecVector("vector", allocator)) {
 378
 379       vector1.allocateNew(10);
 380       for (int i = 0; i < 10; i++) {
 381         if (i % 2 == 0) {
 382           vector1.setNull(i);
 383         } else {
 384           vector1.set(i, i * 100);
 385         }
 386       }
 387       vector1.setValueCount(10);
 388       setVector(vector2, null, 100, null, 300, null, 500, null, 700, null, 900);
 389       assertTrue(VectorEqualsVisitor.vectorEquals(vector1, vector2));
 390     }
 391   }
 392
 393   @Test
 394   public void testPopulateTimeStampMicroVector() {
 395     try (final TimeStampMicroVector vector1 = new TimeStampMicroVector("vector", allocator);
 396         final TimeStampMicroVector vector2 = new TimeStampMicroVector("vector", allocator)) {
 397
 398       vector1.allocateNew(10);
 399       for (int i = 0; i < 10; i++) {
 400         if (i % 2 == 0) {
 401           vector1.setNull(i);
 402         } else {
 403           vector1.set(i, i * 10000);
 404         }
 405       }
 406       vector1.setValueCount(10);
 407       setVector(vector2, null, 10000L, null, 30000L, null, 50000L, null, 70000L, null, 90000L);
 408       assertTrue(VectorEqualsVisitor.vectorEquals(vector1, vector2));
 409     }
 410   }
 411
 412   @Test
 413   public void testPopulateTimeStampMilliVector() {
 414     try (final TimeStampMilliVector vector1 = new TimeStampMilliVector("vector", allocator);
 415          final TimeStampMilliVector vector2 = new TimeStampMilliVector("vector", allocator)) {
 416
 417       vector1.allocateNew(10);
 418       for (int i = 0; i < 10; i++) {
 419         if (i % 2 == 0) {
 420           vector1.setNull(i);
 421         } else {
 422           vector1.set(i, i * 10000);
 423         }
 424       }
 425       vector1.setValueCount(10);
 426       setVector(vector2, null, 10000L, null, 30000L, null, 50000L, null, 70000L, null, 90000L);
 427       assertTrue(VectorEqualsVisitor.vectorEquals(vector1, vector2));
 428     }
 429   }
 430
 431   @Test
 432   public void testPopulateTimeStampNanoVector() {
 433     try (final TimeStampNanoVector vector1 = new TimeStampNanoVector("vector", allocator);
 434         final TimeStampNanoVector vector2 = new TimeStampNanoVector("vector", allocator)) {
 435
 436       vector1.allocateNew(10);
 437       for (int i = 0; i < 10; i++) {
 438         if (i % 2 == 0) {
 439           vector1.setNull(i);
 440         } else {
 441           vector1.set(i, i * 10000);
 442         }
 443       }
 444       vector1.setValueCount(10);
 445       setVector(vector2, null, 10000L, null, 30000L, null, 50000L, null, 70000L, null, 90000L);
 446       assertTrue(VectorEqualsVisitor.vectorEquals(vector1, vector2));
 447     }
 448   }
 449
 450   @Test
 451   public void testPopulateTimeStampSecVector() {
 452     try (final TimeStampSecVector vector1 = new TimeStampSecVector("vector", allocator);
 453          final TimeStampSecVector vector2 = new TimeStampSecVector("vector", allocator)) {
 454
 455       vector1.allocateNew(10);
 456       for (int i = 0; i < 10; i++) {
 457         if (i % 2 == 0) {
 458           vector1.setNull(i);
 459         } else {
 460           vector1.set(i, i * 100);
 461         }
 462       }
 463       vector1.setValueCount(10);
 464       setVector(vector2, null, 100L, null, 300L, null, 500L, null, 700L, null, 900L);
 465       assertTrue(VectorEqualsVisitor.vectorEquals(vector1, vector2));
 466     }
 467   }
 468
 469   @Test
 470   public void testPopulateTinyIntVector() {
 471     try (final TinyIntVector vector1 = new TinyIntVector("vector", allocator);
 472          final TinyIntVector vector2 = new TinyIntVector("vector", allocator)) {
 473
 474       vector1.allocateNew(10);
 475       for (int i = 0; i < 10; i++) {
 476         if (i % 2 == 0) {
 477           vector1.setNull(i);
 478         } else {
 479           vector1.set(i, i);
 480         }
 481       }
 482       vector1.setValueCount(10);
 483       setVector(vector2, null, (byte) 1, null, (byte) 3, null, (byte) 5, null, (byte) 7, null, (byte) 9);
 484       assertTrue(VectorEqualsVisitor.vectorEquals(vector1, vector2));
 485     }
 486   }
 487
 488   @Test
 489   public void testPopulateUInt1Vector() {
 490     try (final UInt1Vector vector1 = new UInt1Vector("vector", allocator);
 491          final UInt1Vector vector2 = new UInt1Vector("vector", allocator)) {
 492
 493       vector1.allocateNew(10);
 494       for (int i = 0; i < 10; i++) {
 495         if (i % 2 == 0) {
 496           vector1.setNull(i);
 497         } else {
 498           vector1.set(i, i);
 499         }
 500       }
 501       vector1.setValueCount(10);
 502       setVector(vector2, null, (byte) 1, null, (byte) 3, null, (byte) 5, null, (byte) 7, null, (byte) 9);
 503       assertTrue(VectorEqualsVisitor.vectorEquals(vector1, vector2));
 504     }
 505   }
 506
 507   @Test
 508   public void testPopulateUInt2Vector() {
 509     try (final UInt2Vector vector1 = new UInt2Vector("vector", allocator);
 510          final UInt2Vector vector2 = new UInt2Vector("vector", allocator)) {
 511
 512       vector1.allocateNew(10);
 513       for (int i = 0; i < 10; i++) {
 514         if (i % 2 == 0) {
 515           vector1.setNull(i);
 516         } else {
 517           vector1.set(i, i);
 518         }
 519       }
 520       vector1.setValueCount(10);
 521       setVector(vector2, null, (char) 1, null, (char) 3, null, (char) 5, null, (char) 7, null, (char) 9);
 522       assertTrue(VectorEqualsVisitor.vectorEquals(vector1, vector2));
 523     }
 524   }
 525
 526   @Test
 527   public void testPopulateUInt4Vector() {
 528     try (final UInt4Vector vector1 = new UInt4Vector("vector", allocator);
 529          final UInt4Vector vector2 = new UInt4Vector("vector", allocator)) {
 530
 531       vector1.allocateNew(10);
 532       for (int i = 0; i < 10; i++) {
 533         if (i % 2 == 0) {
 534           vector1.setNull(i);
 535         } else {
 536           vector1.set(i, i);
 537         }
 538       }
 539       vector1.setValueCount(10);
 540       setVector(vector2, null, 1, null, 3, null, 5, null, 7, null, 9);
 541       assertTrue(VectorEqualsVisitor.vectorEquals(vector1, vector2));
 542     }
 543   }
 544
 545   @Test
 546   public void testPopulateUInt8Vector() {
 547     try (final UInt8Vector vector1 = new UInt8Vector("vector", allocator);
 548         final UInt8Vector vector2 = new UInt8Vector("vector", allocator)) {
 549
 550       vector1.allocateNew(10);
 551       for (int i = 0; i < 10; i++) {
 552         if (i % 2 == 0) {
 553           vector1.setNull(i);
 554         } else {
 555           vector1.set(i, i);
 556         }
 557       }
 558       vector1.setValueCount(10);
 559       setVector(vector2, null, 1L, null, 3L, null, 5L, null, 7L, null, 9L);
 560       assertTrue(VectorEqualsVisitor.vectorEquals(vector1, vector2));
 561     }
 562   }
 563
 564   @Test
 565   public void testPopulateVarBinaryVector() {
 566     try (final VarBinaryVector vector1 = new VarBinaryVector("vector", allocator);
 567          final VarBinaryVector vector2 = new VarBinaryVector("vector", allocator)) {
 568
 569       vector1.allocateNew(10);
 570       for (int i = 0; i < 10; i++) {
 571         if (i % 2 == 0) {
 572           vector1.setNull(i);
 573         } else {
 574           vector1.set(i, ("test" + i).getBytes());
 575         }
 576       }
 577       vector1.setValueCount(10);
 578
 579       setVector(vector2, null, "test1".getBytes(), null, "test3".getBytes(), null, "test5".getBytes(), null,
 580           "test7".getBytes(), null, "test9".getBytes());
 581       assertTrue(VectorEqualsVisitor.vectorEquals(vector1, vector2));
 582     }
 583   }
 584
 585   @Test
 586   public void testPopulateVarCharVector() {
 587     try (final VarCharVector vector1 = new VarCharVector("vector", allocator);
 588          final VarCharVector vector2 = new VarCharVector("vector", allocator)) {
 589
 590       vector1.allocateNew(10);
 591       for (int i = 0; i < 10; i++) {
 592         if (i % 2 == 0) {
 593           vector1.setNull(i);
 594         } else {
 595           vector1.set(i, ("test" + i).getBytes());
 596         }
 597       }
 598       vector1.setValueCount(10);
 599
 600       setVector(vector2, null, "test1", null, "test3", null, "test5", null, "test7", null, "test9");
 601       assertTrue(VectorEqualsVisitor.vectorEquals(vector1, vector2));
 602     }
 603   }
 604 }