Skip to content

Commit 9147dfe

Browse files
yuancuyuancu
committed
Eliminate convertRelDataTypeToSqlTypeName API, replacing it with ExprType comparision
Signed-off-by: Yuanchun Shen <yuanchu@amazon.com>
1 parent 6a5e668 commit 9147dfe

18 files changed

Lines changed: 103 additions & 142 deletions

‎core/src/main/java/org/opensearch/sql/calcite/utils/OpenSearchTypeFactory.java‎

Lines changed: 0 additions & 24 deletions
Original file line numberDiff line numberDiff line change
@@ -48,7 +48,6 @@
4848
import org.opensearch.sql.calcite.type.ExprBinaryType;
4949
import org.opensearch.sql.calcite.type.ExprDateType;
5050
import org.opensearch.sql.calcite.type.ExprIPType;
51-
import org.opensearch.sql.calcite.type.ExprSqlType;
5251
import org.opensearch.sql.calcite.type.ExprTimeStampType;
5352
import org.opensearch.sql.calcite.type.ExprTimeType;
5453
import org.opensearch.sql.data.model.ExprValue;
@@ -68,29 +67,6 @@ private OpenSearchTypeFactory(RelDataTypeSystem typeSystem) {
6867
super(typeSystem);
6968
}
7069

71-
/**
72-
* Convert a RelDataType to SqlTypeName. It differs from RelDataType.getSqlTypeName() in that it
73-
* converts a date/time-related UDT to the corresponding SqlTypeName.
74-
*
75-
* @param type RelDataType, which can be a UDT
76-
* @return SqlTypeName
77-
*/
78-
public static SqlTypeName convertRelDataTypeToSqlTypeName(RelDataType type) {
79-
if (type instanceof ExprSqlType exprSqlType) {
80-
return switch (exprSqlType.getUdt()) {
81-
case EXPR_DATE -> SqlTypeName.DATE;
82-
case EXPR_TIME -> SqlTypeName.TIME;
83-
case EXPR_TIMESTAMP -> SqlTypeName.TIMESTAMP;
84-
default -> type.getSqlTypeName();
85-
};
86-
}
87-
return type.getSqlTypeName();
88-
}
89-
90-
public static RelDataType convertSqlTypeToRelDataType(SqlTypeName sqlTypeName) {
91-
return convertExprTypeToRelDataType(convertSqlTypeNameToExprType(sqlTypeName));
92-
}
93-
9470
@Getter
9571
public enum ExprUDT {
9672
EXPR_DATE(DATE),

‎core/src/main/java/org/opensearch/sql/calcite/utils/PPLReturnTypes.java‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -8,8 +8,8 @@
88
import org.apache.calcite.rel.type.RelDataType;
99
import org.apache.calcite.sql.type.ReturnTypes;
1010
import org.apache.calcite.sql.type.SqlReturnTypeInference;
11-
import org.apache.calcite.sql.type.SqlTypeName;
1211
import org.apache.calcite.sql.type.SqlTypeTransforms;
12+
import org.opensearch.sql.data.type.ExprCoreType;
1313

1414
/**
1515
* Return types used in PPL. This class complements the {@link
@@ -31,8 +31,8 @@ private PPLReturnTypes() {}
3131
public static SqlReturnTypeInference TIME_APPLY_RETURN_TYPE =
3232
opBinding -> {
3333
RelDataType temporalType = opBinding.getOperandType(0);
34-
if (OpenSearchTypeFactory.convertRelDataTypeToSqlTypeName(temporalType)
35-
== SqlTypeName.TIME) {
34+
if (ExprCoreType.TIME.equals(
35+
OpenSearchTypeFactory.convertRelDataTypeToExprType(temporalType))) {
3636
return UserDefinedFunctionUtils.NULLABLE_TIME_UDT;
3737
}
3838
return UserDefinedFunctionUtils.NULLABLE_TIMESTAMP_UDT;

‎core/src/main/java/org/opensearch/sql/calcite/utils/UserDefinedFunctionUtils.java‎

Lines changed: 9 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -41,7 +41,8 @@
4141
import org.apache.calcite.tools.RelBuilder;
4242
import org.apache.calcite.util.Optionality;
4343
import org.opensearch.sql.calcite.udf.UserDefinedAggFunction;
44-
import org.opensearch.sql.calcite.utils.datetime.DateTimeApplyUtils;
44+
import org.opensearch.sql.data.model.ExprValueUtils;
45+
import org.opensearch.sql.data.type.ExprType;
4546
import org.opensearch.sql.executor.QueryType;
4647
import org.opensearch.sql.expression.function.FunctionProperties;
4748
import org.opensearch.sql.expression.function.ImplementorUDF;
@@ -111,9 +112,9 @@ public static String formatTimestampWithoutUnnecessaryNanos(LocalDateTime localD
111112
return base;
112113
}
113114

114-
public static SqlTypeName transferDateRelatedTimeName(RexNode candidate) {
115+
public static ExprType transferDateRelatedTimeName(RexNode candidate) {
115116
RelDataType type = candidate.getType();
116-
return OpenSearchTypeFactory.convertRelDataTypeToSqlTypeName(type);
117+
return OpenSearchTypeFactory.convertRelDataTypeToExprType(type);
117118
}
118119

119120
// TODO: pass the function properties directly to the UDF instead of string
@@ -149,18 +150,18 @@ public static List<Expression> addTypeAndContext(
149150
*/
150151
public static List<Expression> convertToExprValues(
151152
List<Expression> operands, List<RelDataType> types) {
152-
List<SqlTypeName> sqlTypeNames =
153-
types.stream().map(OpenSearchTypeFactory::convertRelDataTypeToSqlTypeName).toList();
153+
List<ExprType> exprTypes =
154+
types.stream().map(OpenSearchTypeFactory::convertRelDataTypeToExprType).toList();
154155
List<Expression> exprValues = new ArrayList<>();
155156
for (int i = 0; i < operands.size(); i++) {
156157
Expression operand = Expressions.convert_(operands.get(i), Object.class);
157158
exprValues.add(
158159
i,
159160
Expressions.call(
160-
DateTimeApplyUtils.class,
161-
"transferInputToExprValue",
161+
ExprValueUtils.class,
162+
"fromObjectValue",
162163
operand,
163-
Expressions.constant(sqlTypeNames.get(i))));
164+
Expressions.constant(exprTypes.get(i))));
164165
}
165166
return exprValues;
166167
}

‎core/src/main/java/org/opensearch/sql/calcite/utils/datetime/DateTimeApplyUtils.java‎

Lines changed: 5 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -5,44 +5,32 @@
55

66
package org.opensearch.sql.calcite.utils.datetime;
77

8-
import static org.opensearch.sql.calcite.utils.OpenSearchTypeFactory.convertSqlTypeNameToExprType;
98
import static org.opensearch.sql.data.model.ExprValueUtils.fromObjectValue;
109

1110
import java.time.Duration;
12-
import java.time.Instant;
1311
import java.time.Period;
1412
import java.time.temporal.TemporalAmount;
1513
import java.util.Objects;
1614
import org.apache.calcite.avatica.util.TimeUnit;
17-
import org.apache.calcite.sql.type.SqlTypeName;
1815
import org.opensearch.sql.data.model.ExprTimeValue;
1916
import org.opensearch.sql.data.model.ExprTimestampValue;
2017
import org.opensearch.sql.data.model.ExprValue;
2118
import org.opensearch.sql.data.type.ExprCoreType;
19+
import org.opensearch.sql.data.type.ExprType;
2220
import org.opensearch.sql.exception.SemanticCheckException;
2321
import org.opensearch.sql.expression.function.FunctionProperties;
2422

2523
public final class DateTimeApplyUtils {
2624
private DateTimeApplyUtils() {}
2725

28-
public static Instant applyInterval(Instant base, Duration interval, boolean isAdd) {
29-
return isAdd ? base.plus(interval) : base.minus(interval);
30-
}
31-
32-
public static ExprValue transferInputToExprValue(Object candidate, SqlTypeName sqlTypeName) {
33-
return fromObjectValue(candidate, convertSqlTypeNameToExprType(sqlTypeName));
34-
}
35-
3626
public static ExprValue transferInputToExprTimestampValue(
37-
Object candidate, SqlTypeName sqlTypeName, FunctionProperties properties) {
38-
if (Objects.requireNonNull(sqlTypeName) == SqlTypeName.TIME) {
39-
ExprTimeValue timeValue =
40-
(ExprTimeValue) fromObjectValue(candidate, convertSqlTypeNameToExprType(sqlTypeName));
27+
Object candidate, ExprType typeName, FunctionProperties properties) {
28+
if (Objects.requireNonNull(typeName) == ExprCoreType.TIME) {
29+
ExprTimeValue timeValue = (ExprTimeValue) fromObjectValue(candidate, typeName);
4130
return new ExprTimestampValue(timeValue.timestampValue(properties));
4231
}
4332
try {
44-
return new ExprTimestampValue(
45-
fromObjectValue(candidate, convertSqlTypeNameToExprType(sqlTypeName)).timestampValue());
33+
return new ExprTimestampValue(fromObjectValue(candidate, typeName).timestampValue());
4634
} catch (SemanticCheckException e) {
4735
// If the candidate is a String and does not contain a colon, it means
4836
// it ought to be a date but in a malformed format. We rethrow the exception
@@ -85,9 +73,4 @@ public static TemporalAmount convertToTemporalAmount(long number, TimeUnit unit)
8573
"No mapping defined for Calcite TimeUnit: " + unit);
8674
};
8775
}
88-
89-
public static ExprValue transferTimeToTimestamp(
90-
ExprValue candidate, FunctionProperties functionProperties) {
91-
return new ExprTimestampValue(((ExprTimeValue) candidate).timestampValue(functionProperties));
92-
}
9376
}

‎core/src/main/java/org/opensearch/sql/expression/function/udf/datetime/AddSubDateFunction.java‎

Lines changed: 8 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -23,13 +23,14 @@
2323
import org.apache.calcite.rex.RexCall;
2424
import org.apache.calcite.sql.type.SqlReturnTypeInference;
2525
import org.apache.calcite.sql.type.SqlTypeFamily;
26-
import org.apache.calcite.sql.type.SqlTypeName;
2726
import org.opensearch.sql.calcite.utils.OpenSearchTypeFactory;
2827
import org.opensearch.sql.calcite.utils.UserDefinedFunctionUtils;
2928
import org.opensearch.sql.calcite.utils.datetime.DateTimeApplyUtils;
3029
import org.opensearch.sql.data.model.ExprDateValue;
3130
import org.opensearch.sql.data.model.ExprTimestampValue;
3231
import org.opensearch.sql.data.model.ExprValue;
32+
import org.opensearch.sql.data.model.ExprValueUtils;
33+
import org.opensearch.sql.data.type.ExprCoreType;
3334
import org.opensearch.sql.expression.function.FunctionProperties;
3435
import org.opensearch.sql.expression.function.ImplementorUDF;
3536

@@ -59,7 +60,7 @@ public SqlReturnTypeInference getReturnTypeInference() {
5960
return opBinding -> {
6061
RelDataType temporalType = opBinding.getOperandType(0);
6162
RelDataType temporalDeltaType = opBinding.getOperandType(1);
62-
if (OpenSearchTypeFactory.convertRelDataTypeToSqlTypeName(temporalType) == SqlTypeName.DATE
63+
if (OpenSearchTypeFactory.convertRelDataTypeToExprType(temporalType) == ExprCoreType.DATE
6364
&& SqlTypeFamily.NUMERIC.contains(temporalDeltaType)) {
6465
return NULLABLE_DATE_UDT;
6566
} else {
@@ -82,20 +83,20 @@ public Expression implement(
8283

8384
Expression base =
8485
Expressions.call(
85-
DateTimeApplyUtils.class,
86-
"transferInputToExprValue",
86+
ExprValueUtils.class,
87+
"fromObjectValue",
8788
temporal,
8889
Expressions.constant(
89-
OpenSearchTypeFactory.convertRelDataTypeToSqlTypeName(temporalType)));
90+
OpenSearchTypeFactory.convertRelDataTypeToExprType(temporalType)));
9091

9192
Expression properties =
9293
Expressions.call(
9394
UserDefinedFunctionUtils.class, "restoreFunctionProperties", translator.getRoot());
9495

9596
if (SqlTypeFamily.NUMERIC.contains(temporalDeltaType)) {
9697
String applyDaysFuncName;
97-
if (SqlTypeName.DATE.equals(
98-
OpenSearchTypeFactory.convertRelDataTypeToSqlTypeName(temporalType))) {
98+
if (ExprCoreType.DATE.equals(
99+
OpenSearchTypeFactory.convertRelDataTypeToExprType(temporalType))) {
99100
applyDaysFuncName = isAdd ? "dateAddDaysOnDate" : "dateSubDaysOnDate";
100101
} else {
101102
applyDaysFuncName = isAdd ? "dateAddDaysOnTimestamp" : "dateSubDaysOnTimestamp";

‎core/src/main/java/org/opensearch/sql/expression/function/udf/datetime/DateAddSubFunction.java‎

Lines changed: 4 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -20,6 +20,7 @@
2020
import org.opensearch.sql.calcite.utils.PPLReturnTypes;
2121
import org.opensearch.sql.calcite.utils.UserDefinedFunctionUtils;
2222
import org.opensearch.sql.calcite.utils.datetime.DateTimeApplyUtils;
23+
import org.opensearch.sql.data.model.ExprValueUtils;
2324
import org.opensearch.sql.expression.function.ImplementorUDF;
2425

2526
/**
@@ -64,11 +65,11 @@ public Expression implement(
6465

6566
Expression base =
6667
Expressions.call(
67-
DateTimeApplyUtils.class,
68-
"transferInputToExprValue",
68+
ExprValueUtils.class,
69+
"fromObjectValue",
6970
temporal,
7071
Expressions.constant(
71-
OpenSearchTypeFactory.convertRelDataTypeToSqlTypeName(temporalType)));
72+
OpenSearchTypeFactory.convertRelDataTypeToExprType(temporalType)));
7273

7374
Expression properties =
7475
Expressions.call(

‎core/src/main/java/org/opensearch/sql/expression/function/udf/datetime/DatePartFunction.java‎

Lines changed: 6 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -20,15 +20,14 @@
2020
import org.apache.calcite.linq4j.tree.Expressions;
2121
import org.apache.calcite.rex.RexCall;
2222
import org.apache.calcite.sql.type.SqlReturnTypeInference;
23-
import org.apache.calcite.sql.type.SqlTypeFamily;
24-
import org.apache.calcite.sql.type.SqlTypeName;
2523
import org.opensearch.sql.calcite.utils.OpenSearchTypeFactory;
2624
import org.opensearch.sql.calcite.utils.PPLReturnTypes;
2725
import org.opensearch.sql.calcite.utils.UserDefinedFunctionUtils;
2826
import org.opensearch.sql.calcite.utils.datetime.DateTimeApplyUtils;
2927
import org.opensearch.sql.data.model.ExprStringValue;
3028
import org.opensearch.sql.data.model.ExprValue;
3129
import org.opensearch.sql.data.type.ExprCoreType;
30+
import org.opensearch.sql.data.type.ExprType;
3231
import org.opensearch.sql.expression.datetime.DateTimeFunctions;
3332
import org.opensearch.sql.expression.function.FunctionProperties;
3433
import org.opensearch.sql.expression.function.ImplementorUDF;
@@ -81,8 +80,8 @@ public Expression implement(
8180

8281
Expression unit = Expressions.constant(timeUnit.name());
8382
Expression datetime = translatedOperands.getFirst();
84-
SqlTypeName datetimeType =
85-
OpenSearchTypeFactory.convertRelDataTypeToSqlTypeName(
83+
ExprType datetimeType =
84+
OpenSearchTypeFactory.convertRelDataTypeToExprType(
8685
call.getOperands().getFirst().getType());
8786

8887
return Expressions.call(
@@ -95,20 +94,19 @@ public Expression implement(
9594
}
9695

9796
public static int datePart(
98-
String part, Object datetime, SqlTypeName datetimeType, DataContext propertyContext) {
97+
String part, Object datetime, ExprType datetimeType, DataContext propertyContext) {
9998
FunctionProperties properties =
10099
UserDefinedFunctionUtils.restoreFunctionProperties(propertyContext);
101100

102101
// This throws errors when date_part expects a date but gets a time, or vice versa.
103-
if (SqlTypeFamily.STRING.equals(datetimeType.getFamily())
104-
|| SqlTypeFamily.CHARACTER.equals(datetimeType.getFamily())) {
102+
if (ExprCoreType.STRING.isCompatible(datetimeType)) {
105103
ensureDatetimeParsable(part, datetime.toString());
106104
}
107105

108106
ExprValue candidate =
109107
DateTimeApplyUtils.transferInputToExprTimestampValue(datetime, datetimeType, properties);
110108

111-
if (datetimeType == SqlTypeName.TIME) {
109+
if (datetimeType == ExprCoreType.TIME) {
112110
return DateTimeFunctions.exprExtractForTime(
113111
properties, new ExprStringValue(part), candidate)
114112
.integerValue();

‎core/src/main/java/org/opensearch/sql/expression/function/udf/datetime/ExtractFunction.java‎

Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -14,12 +14,13 @@
1414
import org.apache.calcite.rex.RexCall;
1515
import org.apache.calcite.sql.type.ReturnTypes;
1616
import org.apache.calcite.sql.type.SqlReturnTypeInference;
17-
import org.apache.calcite.sql.type.SqlTypeName;
1817
import org.opensearch.sql.calcite.utils.OpenSearchTypeFactory;
1918
import org.opensearch.sql.calcite.utils.UserDefinedFunctionUtils;
20-
import org.opensearch.sql.calcite.utils.datetime.DateTimeApplyUtils;
2119
import org.opensearch.sql.data.model.ExprStringValue;
2220
import org.opensearch.sql.data.model.ExprValue;
21+
import org.opensearch.sql.data.model.ExprValueUtils;
22+
import org.opensearch.sql.data.type.ExprCoreType;
23+
import org.opensearch.sql.data.type.ExprType;
2324
import org.opensearch.sql.expression.datetime.DateTimeFunctions;
2425
import org.opensearch.sql.expression.function.FunctionProperties;
2526
import org.opensearch.sql.expression.function.ImplementorUDF;
@@ -50,24 +51,23 @@ public Expression implement(
5051
RexToLixTranslator translator, RexCall call, List<Expression> translatedOperands) {
5152
Expression unit = translatedOperands.get(0);
5253
Expression datetime = translatedOperands.get(1);
53-
SqlTypeName datetimeType =
54-
OpenSearchTypeFactory.convertRelDataTypeToSqlTypeName(
55-
call.getOperands().get(1).getType());
54+
ExprType datetimeType =
55+
OpenSearchTypeFactory.convertRelDataTypeToExprType(call.getOperands().get(1).getType());
5656

5757
Expression functionProperties =
5858
Expressions.call(
5959
UserDefinedFunctionUtils.class, "restoreFunctionProperties", translator.getRoot());
6060

6161
Expression exprDatetimeValue =
6262
Expressions.call(
63-
DateTimeApplyUtils.class,
64-
"transferInputToExprValue",
63+
ExprValueUtils.class,
64+
"fromObjectValue",
6565
datetime,
6666
Expressions.constant(datetimeType));
6767

6868
Expression part = Expressions.new_(ExprStringValue.class, unit);
6969

70-
if (SqlTypeName.TIME.equals(datetimeType)) {
70+
if (ExprCoreType.TIME.equals(datetimeType)) {
7171
return Expressions.call(
7272
ExtractImplementor.class,
7373
"extractForTime",

‎core/src/main/java/org/opensearch/sql/expression/function/udf/datetime/FormatFunction.java‎

Lines changed: 8 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -22,9 +22,11 @@
2222
import org.opensearch.sql.calcite.utils.OpenSearchTypeFactory;
2323
import org.opensearch.sql.calcite.utils.PPLReturnTypes;
2424
import org.opensearch.sql.calcite.utils.UserDefinedFunctionUtils;
25-
import org.opensearch.sql.calcite.utils.datetime.DateTimeApplyUtils;
2625
import org.opensearch.sql.data.model.ExprStringValue;
2726
import org.opensearch.sql.data.model.ExprValue;
27+
import org.opensearch.sql.data.model.ExprValueUtils;
28+
import org.opensearch.sql.data.type.ExprCoreType;
29+
import org.opensearch.sql.data.type.ExprType;
2830
import org.opensearch.sql.expression.function.FunctionProperties;
2931
import org.opensearch.sql.expression.function.ImplementorUDF;
3032

@@ -59,24 +61,24 @@ public static class DataFormatImplementor implements NotNullImplementor {
5961
@Override
6062
public Expression implement(
6163
RexToLixTranslator translator, RexCall call, List<Expression> translatedOperands) {
62-
SqlTypeName type =
63-
OpenSearchTypeFactory.convertRelDataTypeToSqlTypeName(
64+
ExprType type =
65+
OpenSearchTypeFactory.convertRelDataTypeToExprType(
6466
call.getOperands().getFirst().getType());
6567
Expression functionProperties =
6668
Expressions.call(
6769
UserDefinedFunctionUtils.class, "restoreFunctionProperties", translator.getRoot());
6870
Expression datetime =
6971
Expressions.call(
70-
DateTimeApplyUtils.class,
71-
"transferInputToExprValue",
72+
ExprValueUtils.class,
73+
"fromObjectValue",
7274
translatedOperands.get(0),
7375
Expressions.constant(type));
7476
Expression format = Expressions.new_(ExprStringValue.class, translatedOperands.get(1));
7577

7678
if (SqlTypeName.TIME.equals(functionType)) {
7779
return Expressions.call(DataFormatImplementor.class, "timeFormat", datetime, format);
7880
} else {
79-
if (SqlTypeName.TIME.equals(type)) {
81+
if (ExprCoreType.TIME.equals(type)) {
8082
return Expressions.call(
8183
DataFormatImplementor.class,
8284
"dateFormatForTime",

0 commit comments

Comments
 (0)