compare struct child names and add UT

Author: tianchen92

java/vector/src/main/java/org/apache/arrow/vector/ValueVector.java

@@ -282,7 +282,7 @@ default boolean equals(ValueVector target) {
     if (this == target) {
       return true;
     }
-    if (target == null || this.getMinorType() != target.getMinorType()) {
+    if (target == null || !this.getField().getType().equals(target.getField().getType())) {
       return false;
     }
 

java/vector/src/main/java/org/apache/arrow/vector/complex/NonNullableStructVector.java

@@ -307,9 +307,14 @@ public boolean equals(int index, ValueVector to, int toIndex) {
       return false;
     }
     NonNullableStructVector that = (NonNullableStructVector) to;
+
     List<ValueVector> leftChildrens = new ArrayList<>();
     List<ValueVector> rightChildrens = new ArrayList<>();
 
+    if (!getChildFieldNames().equals(that.getChildFieldNames())) {
+      return false;
+    }
+
     for (String child : getChildFieldNames()) {
       ValueVector v = getChild(child);
       if (v != null) {

java/vector/src/main/java/org/apache/arrow/vector/complex/StructVector.java

@@ -488,6 +488,51 @@ public int hashCode(int index) {
     }
   }
 
+  @Override
+  public boolean equals(int index, ValueVector to, int toIndex) {
+    if (to == null) {
+      return false;
+    }
+    if (!this.getField().getType().equals(to.getField().getType())) {
+      return false;
+    }
+    StructVector that = (StructVector) to;
+    if (this.isSet(index) != that.isSet(toIndex)) {
+      return false;
+    }
+    List<ValueVector> leftChildrens = new ArrayList<>();
+    List<ValueVector> rightChildrens = new ArrayList<>();
+
+    if (!getChildFieldNames().equals(that.getChildFieldNames())) {
+      return false;
+    }
+
+    for (String child : getChildFieldNames()) {
+      ValueVector v = getChild(child);
+      if (v != null) {
+        leftChildrens.add(v);
+      }
+    }
+
+    for (String child : that.getChildFieldNames()) {
+      ValueVector v = that.getChild(child);
+      if (v != null) {
+        rightChildrens.add(v);
+      }
+    }
+
+    if (leftChildrens.size() != rightChildrens.size()) {
+      return false;
+    }
+
+    for (int i = 0; i < leftChildrens.size(); i++) {
+      if (!leftChildrens.get(i).equals(index, rightChildrens.get(i), toIndex)) {
+        return false;
+      }
+    }
+    return true;
+  }
+
   @Override
   public void get(int index, ComplexHolder holder) {
     holder.isSet = isSet(index);

java/vector/src/test/java/org/apache/arrow/vector/TestValueVector.java

@@ -2254,6 +2254,25 @@ public void testGetNullFromVariableWidthVector() {
     }
   }
 
+  @Test
+  public void testIntVectorEqualsWithNull() {
+    try (final IntVector vector1 = new IntVector("v1", allocator);
+        final IntVector vector2 = new IntVector("v2", allocator)) {
+
+      vector1.allocateNew(2);
+      vector1.setValueCount(2);
+      vector2.allocateNew(2);
+      vector2.setValueCount(2);
+
+      vector1.setSafe(0, 1);
+      vector1.setSafe(1, 2);
+
+      vector2.setSafe(0, 1);
+
+      assertFalse(vector1.equals(vector2));
+    }
+  }
+
   @Test
   public void testIntVectorEquals() {
     try (final IntVector vector1 = new IntVector("v1", allocator);
@@ -2309,6 +2328,25 @@ public void testDecimalVectorEquals() {
     }
   }
 
+  @Test
+  public void testVarcharVectorEuqalsWithNull() {
+    try (final VarCharVector vector1 = new VarCharVector("v1", allocator);
+        final VarCharVector vector2 = new VarCharVector("v2", allocator)) {
+
+      vector1.allocateNew();
+      vector2.allocateNew();
+
+      // set some values
+      vector1.setSafe(0, STR1, 0, STR1.length);
+      vector1.setSafe(1, STR2, 0, STR2.length);
+      vector1.setValueCount(2);
+
+      vector2.setSafe(0, STR1, 0, STR1.length);
+      vector2.setValueCount(2);
+      assertFalse(vector1.equals(vector2));
+    }
+  }
+
   @Test
   public void testVarcharVectorEquals() {
     try (final VarCharVector vector1 = new VarCharVector("v1", allocator);
@@ -2359,6 +2397,32 @@ public void testVarBinaryVectorEquals() {
     }
   }
 
+  @Test
+  public void testListVectorEqualsWithNull() {
+    try (final ListVector vector1 = ListVector.empty("v1", allocator);
+        final ListVector vector2 = ListVector.empty("v2", allocator);) {
+
+      UnionListWriter writer1 = vector1.getWriter();
+      writer1.allocate();
+
+      //set some values
+      writeListVector(writer1, new int[] {1, 2});
+      writeListVector(writer1, new int[] {3, 4});
+      writeListVector(writer1, new int[] {});
+      writer1.setValueCount(3);
+
+      UnionListWriter writer2 = vector2.getWriter();
+      writer2.allocate();
+
+      //set some values
+      writeListVector(writer2, new int[] {1, 2});
+      writeListVector(writer2, new int[] {3, 4});
+      writer2.setValueCount(3);
+
+      assertFalse(vector1.equals(vector2));
+    }
+  }
+
   @Test
   public void testListVectorEquals() {
     try (final ListVector vector1 = ListVector.empty("v1", allocator);
@@ -2389,6 +2453,35 @@ public void testListVectorEquals() {
     }
   }
 
+  @Test
+  public void testStructVectorEqualsWithNull() {
+
+    try (final StructVector vector1 = StructVector.empty("v1", allocator);
+        final StructVector vector2 = StructVector.empty("v2", allocator);) {
+      vector1.addOrGet("f0", FieldType.nullable(new ArrowType.Int(32, true)), IntVector.class);
+      vector1.addOrGet("f1", FieldType.nullable(new ArrowType.Int(64, true)), BigIntVector.class);
+      vector2.addOrGet("f0", FieldType.nullable(new ArrowType.Int(32, true)), IntVector.class);
+      vector2.addOrGet("f1", FieldType.nullable(new ArrowType.Int(64, true)), BigIntVector.class);
+
+      NullableStructWriter writer1 = vector1.getWriter();
+      writer1.allocate();
+
+      writeStructVector(writer1, 1, 10L);
+      writeStructVector(writer1, 2, 20L);
+      writeStructVector(writer1, 3, 30L);
+      writer1.setValueCount(3);
+
+      NullableStructWriter writer2 = vector2.getWriter();
+      writer2.allocate();
+
+      writeStructVector(writer2, 1, 10L);
+      writeStructVector(writer2, 3, 30L);
+      writer2.setValueCount(3);
+
+      assertFalse(vector1.equals(vector2));
+    }
+  }
+
   @Test
   public void testStructVectorEquals() {
     try (final StructVector vector1 = StructVector.empty("v1", allocator);
@@ -2421,6 +2514,32 @@ public void testStructVectorEquals() {
     }
   }
 
+  @Test
+  public void testStructVectorEqualsWithDiffChild() {
+    try (final StructVector vector1 = StructVector.empty("v1", allocator);
+        final StructVector vector2 = StructVector.empty("v2", allocator);) {
+      vector1.addOrGet("f0", FieldType.nullable(new ArrowType.Int(32, true)), IntVector.class);
+      vector1.addOrGet("f1", FieldType.nullable(new ArrowType.Int(64, true)), BigIntVector.class);
+      vector2.addOrGet("f0", FieldType.nullable(new ArrowType.Int(32, true)), IntVector.class);
+      vector2.addOrGet("f10", FieldType.nullable(new ArrowType.Int(64, true)), BigIntVector.class);
+
+      NullableStructWriter writer1 = vector1.getWriter();
+      writer1.allocate();
+
+      writeStructVector(writer1, 1, 10L);
+      writeStructVector(writer1, 2, 20L);
+      writer1.setValueCount(2);
+
+      NullableStructWriter writer2 = vector2.getWriter();
+      writer2.allocate();
+
+      writeStructVector(writer2, 1, 10L);
+      writeStructVector(writer2, 2, 20L);
+      writer2.setValueCount(2);
+      assertFalse(vector1.equals(vector2));
+    }
+  }
+
   @Test
   public void testUnionVectorEquals() {
     try (final UnionVector vector1 = new UnionVector("v1", allocator, null);