twalthr commented on a change in pull request #11694: 
[FLINK-17064][table-planner] Improve literals conversion in ExpressionConverter
URL: https://github.com/apache/flink/pull/11694#discussion_r408054597
 
 

 ##########
 File path: 
flink-table/flink-table-planner-blink/src/main/java/org/apache/flink/table/planner/expressions/converter/ExpressionConverter.java
 ##########
 @@ -108,93 +106,78 @@ public RexNode visit(ValueLiteralExpression 
valueLiteral) {
                LogicalType type = 
fromDataTypeToLogicalType(valueLiteral.getOutputDataType());
                RexBuilder rexBuilder = relBuilder.getRexBuilder();
                FlinkTypeFactory typeFactory = (FlinkTypeFactory) 
relBuilder.getTypeFactory();
+
+               RelDataType relDataType = 
typeFactory.createFieldTypeFromLogicalType(type);
+
                if (valueLiteral.isNull()) {
-                       return relBuilder.getRexBuilder()
-                                       .makeCast(
-                                                       
typeFactory.createFieldTypeFromLogicalType(type),
-                                                       
relBuilder.getRexBuilder().constantNull());
+                       return rexBuilder.makeNullLiteral(relDataType);
                }
 
+               Object value = null;
                switch (type.getTypeRoot()) {
                        case DECIMAL:
-                               DecimalType dt = (DecimalType) type;
-                               BigDecimal bigDecimal = 
extractValue(valueLiteral, BigDecimal.class);
-                               RelDataType decType = 
relBuilder.getTypeFactory().createSqlType(SqlTypeName.DECIMAL,
-                                               dt.getPrecision(), 
dt.getScale());
-                               return 
relBuilder.getRexBuilder().makeExactLiteral(bigDecimal, decType);
                        case TINYINT:
-                               return relBuilder.getRexBuilder().makeLiteral(
-                                               extractValue(valueLiteral, 
Object.class),
-                                               
typeFactory.createSqlType(SqlTypeName.TINYINT),
-                                               true);
                        case SMALLINT:
-                               return relBuilder.getRexBuilder().makeLiteral(
-                                               extractValue(valueLiteral, 
Object.class),
-                                               
typeFactory.createSqlType(SqlTypeName.SMALLINT),
-                                               true);
                        case INTEGER:
-                               return relBuilder.getRexBuilder().makeLiteral(
-                                               extractValue(valueLiteral, 
Object.class),
-                                               
typeFactory.createSqlType(SqlTypeName.INTEGER),
-                                               true);
                        case BIGINT:
-                               // create BIGINT literals for long type
-                               BigDecimal bigint = extractValue(valueLiteral, 
BigDecimal.class);
-                               return 
relBuilder.getRexBuilder().makeBigintLiteral(bigint);
                        case FLOAT:
-                               //Float/Double type should be liked as java 
type here.
-                               return 
relBuilder.getRexBuilder().makeApproxLiteral(
-                                               extractValue(valueLiteral, 
BigDecimal.class),
-                                               
relBuilder.getTypeFactory().createSqlType(SqlTypeName.FLOAT));
                        case DOUBLE:
-                               //Float/Double type should be liked as java 
type here.
-                               return rexBuilder.makeApproxLiteral(
-                                               extractValue(valueLiteral, 
BigDecimal.class),
-                                               
relBuilder.getTypeFactory().createSqlType(SqlTypeName.DOUBLE));
+                               value = extractValue(valueLiteral, 
BigDecimal.class);
+                               break;
+                       case VARCHAR:
+                       case CHAR:
+                               value = extractValue(valueLiteral, 
String.class);
+                               break;
+                       case BINARY:
+                       case VARBINARY:
+                               value = new 
ByteString(extractValue(valueLiteral, byte[].class));
+                               break;
+                       case INTERVAL_YEAR_MONTH:
+                               // convert to total months
+                               value = 
BigDecimal.valueOf(extractValue(valueLiteral, Integer.class));
+                               break;
+                       case INTERVAL_DAY_TIME:
+                               // convert to total millis
+                               value = 
BigDecimal.valueOf(extractValue(valueLiteral, Long.class));
+                               break;
                        case DATE:
-                               return 
relBuilder.getRexBuilder().makeDateLiteral(DateString.fromCalendarFields(
-                                               
valueAsCalendar(extractValue(valueLiteral, java.sql.Date.class))));
+                               value = 
DateString.fromCalendarFields(valueAsCalendar(extractValue(valueLiteral, 
LocalDate.class)));
+                               break;
                        case TIME_WITHOUT_TIME_ZONE:
-                               return 
relBuilder.getRexBuilder().makeTimeLiteral(TimeString.fromCalendarFields(
-                                               
valueAsCalendar(extractValue(valueLiteral, java.sql.Time.class))), 0);
+                               // TODO type factory strips the precision, for 
literals we can be more lenient already
+                               TimeType timeType = (TimeType) type;
+                               relDataType = 
typeFactory.createSqlType(SqlTypeName.TIME, timeType.getPrecision());
+                               int millisOfDay = extractValue(valueLiteral, 
LocalTime.class).get(ChronoField.MILLI_OF_DAY);
 
 Review comment:
   same here: let's integrate the logic into `ValueLiteralExpression` to match 
with `TimeType`:
   ```
    * <p>A conversion from and to {@code int} describes the number of 
milliseconds of the day. A
    * conversion from and to {@code long} describes the number of nanoseconds 
of the day.
   ```

----------------------------------------------------------------
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.
 
For queries about this service, please contact Infrastructure at:
us...@infra.apache.org


With regards,
Apache Git Services

Reply via email to