fix failed cases

Author: XuQianJin-Stars

fluss-client/pom.xml

@@ -113,14 +113,6 @@
                                     <include>*:*</include>
                                 </includes>
                             </artifactSet>
-                            <filters>
-                                <filter>
-                                    <artifact>*</artifact>
-                                    <excludes>
-                                        <exclude>LICENSE*</exclude>
-                                    </excludes>
-                                </filter>
-                            </filters>
                         </configuration>
                     </execution>
                 </executions>

fluss-client/src/test/java/org/apache/fluss/client/table/scanner/log/DefaultCompletedFetchTest.java

@@ -227,21 +227,32 @@ void testComplexTypeFetch() throws Exception {
                         new Object[] {
                             1,
                             new String[] {"a", "b"},
-                            new Object[] {new int[] {1, 2}, new int[] {3, 4}}
+                            new Object[] {new int[] {1, 2}, new int[] {3, 4}},
+                            new Object[] {10, new Object[] {20, "nested"}, "row1"}
                         },
                         new Object[] {
-                            2, new String[] {"c", null}, new Object[] {null, new int[] {3, 4}}
+                            2,
+                            new String[] {"c", null},
+                            new Object[] {null, new int[] {3, 4}},
+                            new Object[] {30, new Object[] {40, "test"}, "row2"}
                         },
                         new Object[] {
                             3,
                             new String[] {"e", "f"},
-                            new Object[] {new int[] {5, 6, 7}, new int[] {8}}
+                            new Object[] {new int[] {5, 6, 7}, new int[] {8}},
+                            new Object[] {50, new Object[] {60, "value"}, "row3"}
                         });
         Schema schema =
                 Schema.newBuilder()
                         .column("a", DataTypes.INT())
                         .column("b", DataTypes.ARRAY(DataTypes.STRING()))
                         .column("c", DataTypes.ARRAY(DataTypes.ARRAY(DataTypes.INT())))
+                        .column(
+                                "d",
+                                DataTypes.ROW(
+                                        DataTypes.INT(),
+                                        DataTypes.ROW(DataTypes.INT(), DataTypes.STRING()),
+                                        DataTypes.STRING()))
                         .build();
         TableInfo tableInfo =
                 TableInfo.of(
@@ -299,6 +310,17 @@ void testComplexTypeFetch() throws Exception {
                     .isEqualTo(Arrays.deepToString((Object[]) complexData.get(i)[1]));
             assertThat(row.getArray(2).toString())
                     .isEqualTo(Arrays.deepToString((Object[]) complexData.get(i)[2]));
+            InternalRow nestedRow = row.getRow(3, 3);
+            assertThat(nestedRow).isNotNull();
+            assertThat(nestedRow.getInt(0)).isEqualTo(((Object[]) complexData.get(i)[3])[0]);
+            InternalRow deeplyNestedRow = nestedRow.getRow(1, 2);
+            assertThat(deeplyNestedRow).isNotNull();
+            assertThat(deeplyNestedRow.getInt(0))
+                    .isEqualTo(((Object[]) ((Object[]) complexData.get(i)[3])[1])[0]);
+            assertThat(deeplyNestedRow.getString(1).toString())
+                    .isEqualTo(((Object[]) ((Object[]) complexData.get(i)[3])[1])[1]);
+            assertThat(nestedRow.getString(2).toString())
+                    .isEqualTo(((Object[]) complexData.get(i)[3])[2]);
         }
     }
 

fluss-common/src/test/java/org/apache/fluss/row/TestInternalRowGenerator.java

@@ -63,9 +63,15 @@ public static RowType createAllRowType() {
                 new DataField("f17", DataTypes.TIMESTAMP_LTZ(1)),
                 new DataField("f18", DataTypes.TIMESTAMP_LTZ(5)),
                 new DataField("f19", DataTypes.ARRAY(DataTypes.INT())),
-                // TODO: Add Map and Row fields in Issue #1973
                 new DataField(
                         "f20",
+                        DataTypes.ARRAY(DataTypes.FLOAT().copy(false))), // vector embedding type
+                new DataField(
+                        "f21",
+                        DataTypes.ARRAY(DataTypes.ARRAY(DataTypes.STRING()))), // nested array
+                // TODO: Add Map and Row fields in Issue #1973
+                new DataField(
+                        "f22",
                         DataTypes.ROW(
                                 new DataField("u1", DataTypes.INT()),
                                 new DataField(
@@ -123,6 +129,17 @@ public static IndexedRow genIndexedRowForAllType() {
         GenericArray array1 = GenericArray.of(1, 2, 3, 4, 5, -11, null, 444, 102234);
         setRandomNull(writers[19], writer, 19, rnd, array1);
 
+        GenericArray array2 =
+                GenericArray.of(0.1f, 1.1f, -0.5f, 6.6f, Float.MAX_VALUE, Float.MIN_VALUE);
+        setRandomNull(writers[20], writer, 20, rnd, array2);
+
+        GenericArray array3 =
+                GenericArray.of(
+                        GenericArray.of(fromString("a"), null, fromString("c")),
+                        null,
+                        GenericArray.of(fromString("hello"), fromString("world")));
+        setRandomNull(writers[21], writer, 21, rnd, array3);
+
         // TODO: Map type support will be added in Issue #1973
         // Map<Object, Object> javaMap = new HashMap<>();
         // javaMap.put(0, null);
@@ -131,9 +148,9 @@ public static IndexedRow genIndexedRowForAllType() {
         // GenericMap map = new GenericMap(javaMap);
         // setRandomNull(writers[20], writer, 20, rnd, map);
 
-        GenericRow innerRow = GenericRow.of(20);
+        GenericRow innerRow = GenericRow.of(22);
         GenericRow genericRow = GenericRow.of(123, innerRow, BinaryString.fromString("Test"));
-        setRandomNull(writers[20], writer, 20, rnd, genericRow);
+        setRandomNull(writers[22], writer, 22, rnd, genericRow);
 
         IndexedRow row = new IndexedRow(dataTypes);
         row.pointTo(writer.segment(), 0, writer.position());

fluss-common/src/test/java/org/apache/fluss/row/array/AlignedArrayTest.java

@@ -0,0 +1,56 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.fluss.row.array;
+
+import org.apache.fluss.row.BinaryArray;
+
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/** Test for {@link AlignedArray}. */
+class AlignedArrayTest {
+
+    @Test
+    void testCreateNestedArrayInstance() {
+        AlignedArray array = new AlignedArray();
+        BinaryArray nested = array.createNestedArrayInstance();
+        assertThat(nested).isInstanceOf(AlignedArray.class);
+        assertThat(nested).isNotSameAs(array);
+    }
+
+    @Test
+    void testCreateNestedArrayInstanceMultipleTimes() {
+        AlignedArray array = new AlignedArray();
+        BinaryArray nested1 = array.createNestedArrayInstance();
+        BinaryArray nested2 = array.createNestedArrayInstance();
+
+        assertThat(nested1).isInstanceOf(AlignedArray.class);
+        assertThat(nested2).isInstanceOf(AlignedArray.class);
+        assertThat(nested1).isNotSameAs(nested2);
+    }
+
+    @Test
+    void testSerializable() {
+        AlignedArray array = new AlignedArray();
+        assertThat(array).isInstanceOf(java.io.Serializable.class);
+    }
+}
+

fluss-common/src/test/java/org/apache/fluss/row/array/CompactedArrayTest.java

@@ -0,0 +1,85 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.fluss.row.array;
+
+import org.apache.fluss.row.BinaryArray;
+import org.apache.fluss.types.ArrayType;
+import org.apache.fluss.types.DataTypes;
+import org.apache.fluss.types.RowType;
+
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+/** Test for {@link CompactedArray}. */
+class CompactedArrayTest {
+
+    @Test
+    void testCreateNestedArrayInstanceWithArrayType() {
+        ArrayType innerArrayType = DataTypes.ARRAY(DataTypes.INT());
+        CompactedArray array = new CompactedArray(innerArrayType);
+
+        BinaryArray nestedArray = array.createNestedArrayInstance();
+        assertThat(nestedArray).isInstanceOf(CompactedArray.class);
+    }
+
+    @Test
+    void testCreateNestedArrayInstanceWithNonArrayTypeThrowsException() {
+        CompactedArray array = new CompactedArray(DataTypes.INT());
+
+        assertThatThrownBy(() -> array.createNestedArrayInstance())
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessageContaining("Can not get nested array from Array of type");
+    }
+
+    @Test
+    void testNestedArrayCreation() {
+        ArrayType nestedArrayType = DataTypes.ARRAY(DataTypes.ARRAY(DataTypes.STRING()));
+        CompactedArray outerArray = new CompactedArray(nestedArrayType);
+
+        BinaryArray innerArray = outerArray.createNestedArrayInstance();
+        assertThat(innerArray).isInstanceOf(CompactedArray.class);
+
+        CompactedArray innerCompactedArray = (CompactedArray) innerArray;
+        BinaryArray innerInnerArray = innerCompactedArray.createNestedArrayInstance();
+        assertThat(innerInnerArray).isInstanceOf(CompactedArray.class);
+    }
+
+    @Test
+    void testConstructorWithRowType() {
+        RowType rowType = RowType.of(DataTypes.INT(), DataTypes.STRING());
+        CompactedArray array = new CompactedArray(rowType);
+        assertThat(array).isNotNull();
+    }
+
+    @Test
+    void testConstructorWithPrimitiveType() {
+        CompactedArray array = new CompactedArray(DataTypes.INT());
+        assertThat(array).isNotNull();
+    }
+
+    @Test
+    void testSerializable() {
+        CompactedArray array = new CompactedArray(DataTypes.INT());
+        assertThat(array).isInstanceOf(java.io.Serializable.class);
+    }
+}
+

fluss-common/src/test/java/org/apache/fluss/row/array/IndexedArrayTest.java

@@ -0,0 +1,85 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package org.apache.fluss.row.array;
+
+import org.apache.fluss.row.BinaryArray;
+import org.apache.fluss.types.ArrayType;
+import org.apache.fluss.types.DataTypes;
+import org.apache.fluss.types.RowType;
+
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+/** Test for {@link IndexedArray}. */
+class IndexedArrayTest {
+
+    @Test
+    void testCreateNestedArrayInstanceWithArrayType() {
+        ArrayType innerArrayType = DataTypes.ARRAY(DataTypes.INT());
+        IndexedArray array = new IndexedArray(innerArrayType);
+
+        BinaryArray nestedArray = array.createNestedArrayInstance();
+        assertThat(nestedArray).isInstanceOf(IndexedArray.class);
+    }
+
+    @Test
+    void testCreateNestedArrayInstanceWithNonArrayTypeThrowsException() {
+        IndexedArray array = new IndexedArray(DataTypes.INT());
+
+        assertThatThrownBy(() -> array.createNestedArrayInstance())
+                .isInstanceOf(IllegalArgumentException.class)
+                .hasMessageContaining("Can not get nested array from Array of type");
+    }
+
+    @Test
+    void testNestedArrayCreation() {
+        ArrayType nestedArrayType = DataTypes.ARRAY(DataTypes.ARRAY(DataTypes.STRING()));
+        IndexedArray outerArray = new IndexedArray(nestedArrayType);
+
+        BinaryArray innerArray = outerArray.createNestedArrayInstance();
+        assertThat(innerArray).isInstanceOf(IndexedArray.class);
+
+        IndexedArray innerIndexedArray = (IndexedArray) innerArray;
+        BinaryArray innerInnerArray = innerIndexedArray.createNestedArrayInstance();
+        assertThat(innerInnerArray).isInstanceOf(IndexedArray.class);
+    }
+
+    @Test
+    void testConstructorWithRowType() {
+        RowType rowType = RowType.of(DataTypes.INT(), DataTypes.STRING());
+        IndexedArray array = new IndexedArray(rowType);
+        assertThat(array).isNotNull();
+    }
+
+    @Test
+    void testConstructorWithPrimitiveType() {
+        IndexedArray array = new IndexedArray(DataTypes.INT());
+        assertThat(array).isNotNull();
+    }
+
+    @Test
+    void testSerializable() {
+        IndexedArray array = new IndexedArray(DataTypes.INT());
+        assertThat(array).isInstanceOf(java.io.Serializable.class);
+    }
+}
+