mihaibudiu commented on code in PR #4942:
URL: https://github.com/apache/calcite/pull/4942#discussion_r3283113469
##########
core/src/main/java/org/apache/calcite/rex/RexBuilder.java:
##########
@@ -928,32 +924,26 @@ public RexNode makeCast(
case TIME:
final SqlTimeLiteral timeLiteral =
SqlParserUtil.parseTimeLiteral(value, pos);
- if (!isSubMillisecondLiteral(timeLiteral, value)) {
+ if (timeLiteral.getPrec() <= 0
Review Comment:
I understand what 0 means, but negative precisions are less clear.
There's "PRECISION_NOT_SPECIFIED", but I'd rather see an explicit check for
that if that's what you are looking for.
##########
core/src/main/java/org/apache/calcite/rex/RexBuilder.java:
##########
@@ -969,54 +959,31 @@ public RexNode makeCast(
return temporalLiteral;
}
- private static @Nullable String formatTemporalLiteral(RexLiteral literal) {
+ private @Nullable RexNode makeCastFromTemporalLiteralToCharacter(
+ RelDataType type,
+ RexLiteral literal) {
+ final String value;
switch (literal.getType().getSqlTypeName()) {
case TIME:
final TimeString time = literal.getValueAs(TimeString.class);
- return time == null || !hasSubMillisecondPrecision(time)
- ? null
- : time.toString(precision(literal.getType()));
+ if (time == null) {
+ return null;
+ }
+ value = time.toString(literal.getType().getPrecision());
+ break;
case TIMESTAMP:
final TimestampString timestamp =
literal.getValueAs(TimestampString.class);
- return timestamp == null || !hasSubMillisecondPrecision(timestamp)
- ? null
- : timestamp.toString(precision(literal.getType()));
+ if (timestamp == null || literal.getType().getPrecision() <= 3) {
Review Comment:
Why is 3 hardwired here?
##########
core/src/main/java/org/apache/calcite/rex/RexBuilder.java:
##########
@@ -969,54 +959,31 @@ public RexNode makeCast(
return temporalLiteral;
}
- private static @Nullable String formatTemporalLiteral(RexLiteral literal) {
+ private @Nullable RexNode makeCastFromTemporalLiteralToCharacter(
+ RelDataType type,
+ RexLiteral literal) {
+ final String value;
switch (literal.getType().getSqlTypeName()) {
case TIME:
final TimeString time = literal.getValueAs(TimeString.class);
- return time == null || !hasSubMillisecondPrecision(time)
- ? null
- : time.toString(precision(literal.getType()));
+ if (time == null) {
+ return null;
+ }
+ value = time.toString(literal.getType().getPrecision());
+ break;
case TIMESTAMP:
final TimestampString timestamp =
literal.getValueAs(TimestampString.class);
- return timestamp == null || !hasSubMillisecondPrecision(timestamp)
- ? null
- : timestamp.toString(precision(literal.getType()));
+ if (timestamp == null || literal.getType().getPrecision() <= 3) {
+ return null;
+ }
+ value = timestamp.toString(literal.getType().getPrecision());
+ break;
default:
return null;
}
- }
-
- private static boolean hasSubMillisecondPrecision(TimeString time) {
- return hasFractionPrecisionBeyond(time.toString(), 3);
- }
-
- private static boolean hasSubMillisecondPrecision(TimestampString timestamp)
{
- return hasFractionPrecisionBeyond(timestamp.toString(), 3);
- }
-
- private static boolean hasFractionPrecisionBeyond(String value, int
precision) {
- final int dot = value.indexOf('.');
- return dot >= 0 && value.length() - dot - 1 > precision;
- }
-
- private static boolean isSubMillisecondLiteral(
- SqlAbstractDateTimeLiteral literal,
- String value) {
- return literal.getPrec() > 3 && literal.toFormattedString().equals(value);
- }
-
- private static int precision(RelDataType type) {
- return type.getPrecision() < 0 ? 0 : type.getPrecision();
- }
-
- private static boolean fitsInCharacterType(RelDataType type, String value) {
- switch (type.getSqlTypeName()) {
- case CHAR:
- case VARCHAR:
- return SqlTypeUtil.comparePrecision(type.getPrecision(), value.length())
>= 0;
- default:
- return false;
- }
+ return SqlTypeUtil.comparePrecision(type.getPrecision(), value.length())
>= 0
Review Comment:
please add a comment explaining what happens here
##########
core/src/test/java/org/apache/calcite/rex/RexExecutorTest.java:
##########
@@ -160,6 +164,171 @@ protected void check(final Action action) {
});
}
+ @Test void testReduceTimeCastWithMicroseconds() {
+ checkHighPrecision((rexBuilder, executor) -> {
+ final RexNode cast =
+ rexBuilder.makeCast(
+ rexBuilder.getTypeFactory().createSqlType(SqlTypeName.TIME, 6),
+ rexBuilder.makeLiteral("12:34:56.123456"));
+
+ final RexNode reduced = reduce(rexBuilder, executor, cast).get(0);
+
+ assertThat(reduced, instanceOf(RexLiteral.class));
+ assertThat(
+ ((RexLiteral) reduced).getValueAs(TimeString.class).toString(6),
+ equalTo("12:34:56.123456"));
+ });
+ }
+
+ @Test void testReduceTimestampCastWithMicroseconds() {
+ checkHighPrecision((rexBuilder, executor) -> {
+ final RexNode cast =
+ rexBuilder.makeCast(
+ rexBuilder.getTypeFactory().createSqlType(SqlTypeName.TIMESTAMP,
6),
+ rexBuilder.makeLiteral("2020-01-01 12:34:56.123456"));
+
+ final RexNode reduced = reduce(rexBuilder, executor, cast).get(0);
+
+ assertThat(reduced, instanceOf(RexLiteral.class));
+ assertThat(
+ ((RexLiteral) reduced).getValueAs(TimestampString.class).toString(6),
+ equalTo("2020-01-01 12:34:56.123456"));
+ });
+ }
+
+ @Test void testReduceLiteralWithMicroseconds() {
+ checkHighPrecision((rexBuilder, executor) -> {
+ final RexLiteral timeLiteral =
+ rexBuilder.makeTimeLiteral(new TimeString("12:34:56.123456"), 6);
+ final RexLiteral timestampLiteral =
+ rexBuilder.makeTimestampLiteral(
+ new TimestampString("2020-01-01 12:34:56.123456"), 6);
+ final RexNode expression =
+ rexBuilder.makeCall(SqlStdOperatorTable.PLUS,
+ rexBuilder.makeExactLiteral(BigDecimal.TEN),
+ rexBuilder.makeExactLiteral(BigDecimal.ONE));
+
+ final List<RexNode> reducedValues =
+ reduce(rexBuilder, executor, timeLiteral, expression,
timestampLiteral);
+
+ assertThat(reducedValues, hasSize(3));
+ assertThat(
+ ((RexLiteral)
reducedValues.get(0)).getValueAs(TimeString.class).toString(6),
+ equalTo("12:34:56.123456"));
+ assertThat(((RexLiteral) reducedValues.get(1)).getValue2(),
equalTo(11L));
+ assertThat(
+ ((RexLiteral) reducedValues.get(2)).getValueAs(TimestampString.class)
+ .toString(6),
+ equalTo("2020-01-01 12:34:56.123456"));
+ });
+ }
+
+ @Test void testReduceTimeToVarcharWithMicroseconds() {
+ checkHighPrecision((rexBuilder, executor) -> {
+ final RelDataTypeFactory typeFactory = rexBuilder.getTypeFactory();
+ final RexNode castToTime =
+ rexBuilder.makeCast(typeFactory.createSqlType(SqlTypeName.TIME, 6),
+ rexBuilder.makeLiteral("12:34:56.123456"));
+ final RexNode castToVarchar =
+ rexBuilder.makeCast(typeFactory.createSqlType(SqlTypeName.VARCHAR,
30),
+ castToTime);
+
+ final RexNode reduced = reduce(rexBuilder, executor,
castToVarchar).get(0);
+
+ assertThat(reduced, instanceOf(RexLiteral.class));
+ assertThat(((RexLiteral) reduced).getValueAs(String.class),
+ equalTo("12:34:56.123456"));
+ });
+ }
+
+ @Test void testReduceTimeToVarcharWithMilliseconds() {
+ check((rexBuilder, executor) -> {
+ final RelDataTypeFactory typeFactory = rexBuilder.getTypeFactory();
+ final RexNode castToTime =
+ rexBuilder.makeCast(typeFactory.createSqlType(SqlTypeName.TIME, 3),
+ rexBuilder.makeLiteral("12:34:56.987654"));
+ final RexNode castToVarchar =
+ rexBuilder.makeCast(typeFactory.createSqlType(SqlTypeName.VARCHAR,
30),
+ castToTime);
+
+ final RexNode reduced = reduce(rexBuilder, executor,
castToVarchar).get(0);
+
+ assertThat(reduced, instanceOf(RexLiteral.class));
+ assertThat(((RexLiteral) reduced).getValueAs(String.class),
+ equalTo("12:34:56.987"));
+ });
+ }
+
+ @Test void testReduceTimeToVarcharWithZeroMilliseconds() {
+ check((rexBuilder, executor) -> {
+ final RelDataTypeFactory typeFactory = rexBuilder.getTypeFactory();
+ final RexNode castToTime =
+ rexBuilder.makeCast(typeFactory.createSqlType(SqlTypeName.TIME, 3),
+ rexBuilder.makeLiteral("12:34:56.000456"));
+ final RexNode castToVarchar =
+ rexBuilder.makeCast(typeFactory.createSqlType(SqlTypeName.VARCHAR,
30),
+ castToTime);
+
+ final RexNode reduced = reduce(rexBuilder, executor,
castToVarchar).get(0);
+
+ assertThat(reduced, instanceOf(RexLiteral.class));
+ assertThat(((RexLiteral) reduced).getValueAs(String.class),
+ equalTo("12:34:56.000"));
+ });
+ }
+
+ @Test void testReduceTimestampToVarcharWithMicroseconds() {
+ checkHighPrecision((rexBuilder, executor) -> {
+ final RelDataTypeFactory typeFactory = rexBuilder.getTypeFactory();
+ final RexNode castToTimestamp =
+ rexBuilder.makeCast(typeFactory.createSqlType(SqlTypeName.TIMESTAMP,
6),
+ rexBuilder.makeLiteral("2020-01-01 12:34:56.000456"));
+ final RexNode castToVarchar =
+ rexBuilder.makeCast(typeFactory.createSqlType(SqlTypeName.VARCHAR,
30),
+ castToTimestamp);
+
+ final RexNode reduced = reduce(rexBuilder, executor,
castToVarchar).get(0);
+
+ assertThat(reduced, instanceOf(RexLiteral.class));
+ assertThat(((RexLiteral) reduced).getValueAs(String.class),
+ equalTo("2020-01-01 12:34:56.000456"));
+ });
+ }
+
+ private static void checkHighPrecision(Action action) {
+ action.check(new RexBuilder(highPrecisionTemporalTypeFactory()),
executor());
+ }
+
+ private static List<RexNode> reduce(RexBuilder rexBuilder,
+ RexExecutorImpl executor, RexNode... nodes) {
+ final List<RexNode> reducedValues = new ArrayList<>();
+ executor.reduce(rexBuilder, ImmutableList.copyOf(nodes), reducedValues);
+ return reducedValues;
+ }
+
+ private static RelDataTypeFactory highPrecisionTemporalTypeFactory() {
+ return new JavaTypeFactoryImpl(
Review Comment:
Can you run tests with multiple precisions, checking for precisions 1..9 for
example in a loop?
##########
core/src/main/java/org/apache/calcite/rex/RexExecutorImpl.java:
##########
@@ -136,14 +137,32 @@ public static RexExecutable getExecutable(RexBuilder
rexBuilder, List<RexNode> e
@Override public void reduce(RexBuilder rexBuilder, List<RexNode> constExps,
List<RexNode> reducedValues) {
assert reducedValues.isEmpty();
+ final List<RexNode> exps = new ArrayList<>();
Review Comment:
This deserves a comment.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]
