Skip to content

Commit 1a5780f

Browse files
yuancuyuancu
committed
Unit test serialize map and array types
Signed-off-by: Yuanchun Shen <yuanchu@amazon.com>
1 parent 9f3a054 commit 1a5780f

1 file changed

Lines changed: 203 additions & 31 deletions

File tree

‎opensearch/src/test/java/org/opensearch/sql/opensearch/storage/serde/ExtendedRelJsonTest.java‎

Lines changed: 203 additions & 31 deletions
Original file line numberDiff line numberDiff line change
@@ -6,8 +6,10 @@
66
package org.opensearch.sql.opensearch.storage.serde;
77

88
import static org.junit.jupiter.api.Assertions.assertEquals;
9+
import static org.junit.jupiter.api.Assertions.assertInstanceOf;
910

1011
import java.util.Map;
12+
import java.util.Objects;
1113
import org.apache.calcite.rel.type.RelDataType;
1214
import org.apache.calcite.rel.type.RelDataTypeField;
1315
import org.apache.calcite.sql.type.SqlTypeName;
@@ -17,14 +19,13 @@
1719

1820
public class ExtendedRelJsonTest {
1921
private final ExtendedRelJson relJson = ExtendedRelJson.create(new JsonBuilder());
22+
private final OpenSearchTypeFactory typeFactory = OpenSearchTypeFactory.TYPE_FACTORY;
2023

2124
@Test
2225
void testSerializeSqlType() {
23-
RelDataType varcharType = OpenSearchTypeFactory.TYPE_FACTORY.createSqlType(SqlTypeName.VARCHAR);
24-
RelDataType integerType =
25-
OpenSearchTypeFactory.TYPE_FACTORY.createSqlType(SqlTypeName.INTEGER, true);
26-
RelDataType decimalType =
27-
OpenSearchTypeFactory.TYPE_FACTORY.createSqlType(SqlTypeName.DECIMAL, 4, 4);
26+
RelDataType varcharType = typeFactory.createSqlType(SqlTypeName.VARCHAR);
27+
RelDataType integerType = typeFactory.createSqlType(SqlTypeName.INTEGER, true);
28+
RelDataType decimalType = typeFactory.createSqlType(SqlTypeName.DECIMAL, 4, 4);
2829

2930
assertEquals(
3031
Map.of("type", "VARCHAR", "nullable", false, "precision", -1), relJson.toJson(varcharType));
@@ -36,12 +37,9 @@ void testSerializeSqlType() {
3637

3738
@Test
3839
void testSerializeUDT() {
39-
RelDataType dateType =
40-
OpenSearchTypeFactory.TYPE_FACTORY.createUDT(OpenSearchTypeFactory.ExprUDT.EXPR_DATE);
41-
RelDataType timeType =
42-
OpenSearchTypeFactory.TYPE_FACTORY.createUDT(OpenSearchTypeFactory.ExprUDT.EXPR_TIME, true);
43-
RelDataType timestampType =
44-
OpenSearchTypeFactory.TYPE_FACTORY.createUDT(OpenSearchTypeFactory.ExprUDT.EXPR_TIMESTAMP);
40+
RelDataType dateType = typeFactory.createUDT(OpenSearchTypeFactory.ExprUDT.EXPR_DATE);
41+
RelDataType timeType = typeFactory.createUDT(OpenSearchTypeFactory.ExprUDT.EXPR_TIME, true);
42+
RelDataType timestampType = typeFactory.createUDT(OpenSearchTypeFactory.ExprUDT.EXPR_TIMESTAMP);
4543

4644
assertEquals(
4745
Map.of("udt", "EXPR_DATE", "type", "VARCHAR", "nullable", false, "precision", -1),
@@ -59,31 +57,26 @@ void testDeserializeSqlType() {
5957
Map<String, Object> serializedDecimal =
6058
Map.of("type", "DECIMAL", "nullable", false, "precision", 4, "scale", 4);
6159
assertEquals(
62-
OpenSearchTypeFactory.TYPE_FACTORY.createSqlType(SqlTypeName.DECIMAL, 4, 4),
63-
relJson.toType(OpenSearchTypeFactory.TYPE_FACTORY, serializedDecimal));
60+
typeFactory.createSqlType(SqlTypeName.DECIMAL, 4, 4),
61+
relJson.toType(typeFactory, serializedDecimal));
6462
}
6563

6664
@Test
6765
void testDeserializeUDT() {
6866
Map<String, Object> serializedTimestamp =
6967
Map.of("udt", "EXPR_TIMESTAMP", "type", "VARCHAR", "nullable", true, "precision", -1);
7068
assertEquals(
71-
OpenSearchTypeFactory.TYPE_FACTORY
72-
.createUDT(OpenSearchTypeFactory.ExprUDT.EXPR_TIMESTAMP, true)
73-
.toString(),
74-
relJson.toType(OpenSearchTypeFactory.TYPE_FACTORY, serializedTimestamp).toString());
69+
typeFactory.createUDT(OpenSearchTypeFactory.ExprUDT.EXPR_TIMESTAMP, true).toString(),
70+
relJson.toType(typeFactory, serializedTimestamp).toString());
7571
}
7672

7773
@Test
7874
void testSerializeRelDataTypeField() {
7975
RelDataType structType =
80-
OpenSearchTypeFactory.TYPE_FACTORY
76+
typeFactory
8177
.builder()
82-
.add("name", OpenSearchTypeFactory.TYPE_FACTORY.createSqlType(SqlTypeName.VARCHAR))
83-
.add(
84-
"timestamp",
85-
OpenSearchTypeFactory.TYPE_FACTORY.createUDT(
86-
OpenSearchTypeFactory.ExprUDT.EXPR_TIMESTAMP))
78+
.add("name", typeFactory.createSqlType(SqlTypeName.VARCHAR))
79+
.add("timestamp", typeFactory.createUDT(OpenSearchTypeFactory.ExprUDT.EXPR_TIMESTAMP))
8780
.build();
8881

8982
RelDataTypeField nameField = structType.getFieldList().get(0);
@@ -115,13 +108,10 @@ void testSerializeRelDataTypeField() {
115108
@Test
116109
void testDeserializeRelDataTypeField() {
117110
RelDataType expectedType =
118-
OpenSearchTypeFactory.TYPE_FACTORY
111+
typeFactory
119112
.builder()
120-
.add("name", OpenSearchTypeFactory.TYPE_FACTORY.createSqlType(SqlTypeName.VARCHAR))
121-
.add(
122-
"timestamp",
123-
OpenSearchTypeFactory.TYPE_FACTORY.createUDT(
124-
OpenSearchTypeFactory.ExprUDT.EXPR_TIMESTAMP))
113+
.add("name", typeFactory.createSqlType(SqlTypeName.VARCHAR))
114+
.add("timestamp", typeFactory.createUDT(OpenSearchTypeFactory.ExprUDT.EXPR_TIMESTAMP))
125115
.build();
126116

127117
Map<String, Object> nameFieldMap =
@@ -146,8 +136,190 @@ void testDeserializeRelDataTypeField() {
146136
"struct",
147137
"nullable",
148138
false);
149-
RelDataType resultType = relJson.toType(OpenSearchTypeFactory.TYPE_FACTORY, structMap);
139+
RelDataType resultType = relJson.toType(typeFactory, structMap);
150140

151-
assertEquals(resultType.toString(), expectedType.toString());
141+
assertEquals(resultType, expectedType);
142+
}
143+
144+
@SuppressWarnings("unchecked")
145+
@Test
146+
void testSerializeArrayTypes() {
147+
RelDataType stringArrayType =
148+
typeFactory.createArrayType(typeFactory.createSqlType(SqlTypeName.VARCHAR), -1);
149+
150+
RelDataType timestampArrayType =
151+
typeFactory.createArrayType(
152+
typeFactory.createUDT(OpenSearchTypeFactory.ExprUDT.EXPR_TIMESTAMP), -1);
153+
154+
RelDataType ipArrayType =
155+
typeFactory.createArrayType(
156+
typeFactory.createUDT(OpenSearchTypeFactory.ExprUDT.EXPR_IP), -1);
157+
158+
assertEquals(
159+
Map.of(
160+
"type",
161+
"ARRAY",
162+
"nullable",
163+
false,
164+
"component",
165+
Map.of("type", "VARCHAR", "nullable", false, "precision", -1)),
166+
relJson.toJson(stringArrayType));
167+
168+
assertEquals(
169+
Map.of(
170+
"type",
171+
"ARRAY",
172+
"nullable",
173+
false,
174+
"component",
175+
Map.of("udt", "EXPR_TIMESTAMP", "type", "VARCHAR", "nullable", false, "precision", -1)),
176+
relJson.toJson(timestampArrayType));
177+
178+
Object serializedIpArray = relJson.toJson(ipArrayType);
179+
Map<String, Object> serializedMap = (Map<String, Object>) serializedIpArray;
180+
assertEquals("ARRAY", serializedMap.get("type"));
181+
assertEquals(false, serializedMap.get("nullable"));
182+
assertInstanceOf(Map.class, serializedMap.get("component"));
183+
Map<String, Object> componentMap = (Map<String, Object>) serializedMap.get("component");
184+
assertEquals("EXPR_IP", componentMap.get("udt"));
185+
}
186+
187+
@Test
188+
void testDeserializeArrayTypes() {
189+
Map<String, Object> serializedTimestampArray =
190+
Map.of(
191+
"type",
192+
"ARRAY",
193+
"nullable",
194+
false,
195+
"component",
196+
Map.of("udt", "EXPR_TIMESTAMP", "type", "VARCHAR", "nullable", false, "precision", -1));
197+
198+
RelDataType expectedTimestampArray =
199+
typeFactory.createArrayType(
200+
typeFactory.createUDT(OpenSearchTypeFactory.ExprUDT.EXPR_TIMESTAMP), -1);
201+
202+
RelDataType deserializedType = relJson.toType(typeFactory, serializedTimestampArray);
203+
assertEquals(expectedTimestampArray, deserializedType);
204+
205+
assertEquals(
206+
typeFactory.createUDT(OpenSearchTypeFactory.ExprUDT.EXPR_TIMESTAMP),
207+
deserializedType.getComponentType());
208+
}
209+
210+
@SuppressWarnings("unchecked")
211+
@Test
212+
void testSerializeMapTypes() {
213+
RelDataType regularMapType =
214+
typeFactory.createMapType(
215+
typeFactory.createSqlType(SqlTypeName.VARCHAR),
216+
typeFactory.createSqlType(SqlTypeName.INTEGER),
217+
false);
218+
219+
RelDataType mapWithUdtValueType =
220+
typeFactory.createMapType(
221+
typeFactory.createSqlType(SqlTypeName.VARCHAR),
222+
typeFactory.createUDT(OpenSearchTypeFactory.ExprUDT.EXPR_TIMESTAMP),
223+
true);
224+
225+
RelDataType complexMapType =
226+
typeFactory.createMapType(
227+
typeFactory.createUDT(OpenSearchTypeFactory.ExprUDT.EXPR_IP),
228+
typeFactory.createUDT(OpenSearchTypeFactory.ExprUDT.EXPR_TIMESTAMP),
229+
false);
230+
231+
Map<String, Object> expectedRegularMap =
232+
Map.of(
233+
"type",
234+
"MAP",
235+
"nullable",
236+
false,
237+
"key",
238+
Map.of("type", "VARCHAR", "nullable", false, "precision", -1),
239+
"value",
240+
Map.of("type", "INTEGER", "nullable", false));
241+
assertEquals(expectedRegularMap, relJson.toJson(regularMapType));
242+
243+
Map<String, Object> expectedUdtValueMap =
244+
Map.of(
245+
"type",
246+
"MAP",
247+
"nullable",
248+
true,
249+
"key",
250+
Map.of("type", "VARCHAR", "nullable", false, "precision", -1),
251+
"value",
252+
Map.of("udt", "EXPR_TIMESTAMP", "type", "VARCHAR", "nullable", false, "precision", -1));
253+
assertEquals(expectedUdtValueMap, relJson.toJson(mapWithUdtValueType));
254+
255+
Object serializedComplexMap = relJson.toJson(complexMapType);
256+
assertInstanceOf(Map.class, serializedComplexMap);
257+
Map<String, Object> serializedMap = (Map<String, Object>) serializedComplexMap;
258+
259+
assertEquals("MAP", serializedMap.get("type"));
260+
assertEquals(false, serializedMap.get("nullable"));
261+
262+
assertInstanceOf(Map.class, serializedMap.get("key"));
263+
Map<String, Object> keyMap = (Map<String, Object>) serializedMap.get("key");
264+
assertEquals("EXPR_IP", keyMap.get("udt"));
265+
266+
assertInstanceOf(Map.class, serializedMap.get("value"));
267+
Map<String, Object> valueMap = (Map<String, Object>) serializedMap.get("value");
268+
assertEquals("EXPR_TIMESTAMP", valueMap.get("udt"));
269+
assertEquals("VARCHAR", valueMap.get("type"));
270+
}
271+
272+
@Test
273+
void testDeserializeMapTypes() {
274+
Map<String, Object> serializedComplexMap =
275+
Map.of(
276+
"type",
277+
"MAP",
278+
"nullable",
279+
false,
280+
"key",
281+
Map.of("udt", "EXPR_IP", "type", "VARCHAR", "nullable", false, "precision", -1),
282+
"value",
283+
Map.of("udt", "EXPR_TIMESTAMP", "type", "VARCHAR", "nullable", false, "precision", -1));
284+
285+
RelDataType expectedComplexMap =
286+
typeFactory.createMapType(
287+
typeFactory.createUDT(OpenSearchTypeFactory.ExprUDT.EXPR_IP),
288+
typeFactory.createUDT(OpenSearchTypeFactory.ExprUDT.EXPR_TIMESTAMP),
289+
false);
290+
291+
RelDataType deserializedType = relJson.toType(typeFactory, serializedComplexMap);
292+
assertEquals(expectedComplexMap, deserializedType);
293+
294+
assertEquals(
295+
typeFactory.createUDT(OpenSearchTypeFactory.ExprUDT.EXPR_IP),
296+
deserializedType.getKeyType());
297+
assertEquals(
298+
typeFactory.createUDT(OpenSearchTypeFactory.ExprUDT.EXPR_TIMESTAMP),
299+
deserializedType.getValueType());
300+
}
301+
302+
@Test
303+
void testSerializeAndDeserializeNestedStructure() {
304+
RelDataType innerMapType =
305+
typeFactory.createMapType(
306+
typeFactory.createSqlType(SqlTypeName.VARCHAR),
307+
typeFactory.createUDT(OpenSearchTypeFactory.ExprUDT.EXPR_TIMESTAMP),
308+
false);
309+
RelDataType complexType = typeFactory.createArrayType(innerMapType, -1);
310+
311+
Object serialized = relJson.toJson(complexType);
312+
RelDataType deserialized = relJson.toType(typeFactory, serialized);
313+
314+
assertEquals(complexType, deserialized);
315+
316+
assertEquals(
317+
SqlTypeName.MAP, Objects.requireNonNull(deserialized.getComponentType()).getSqlTypeName());
318+
assertEquals(
319+
SqlTypeName.VARCHAR,
320+
Objects.requireNonNull(deserialized.getComponentType().getKeyType()).getSqlTypeName());
321+
assertEquals(
322+
typeFactory.createUDT(OpenSearchTypeFactory.ExprUDT.EXPR_TIMESTAMP),
323+
deserialized.getComponentType().getValueType());
152324
}
153325
}

0 commit comments

Comments
 (0)