Refactor Converter

kernel/sql-federation/compiler/src/main/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/expression/ExpressionConverter.java

@@ -109,16 +109,16 @@ public static Optional<SqlNode> convert(final ExpressionSegment segment) {
             return Optional.of(ExistsSubqueryExpressionConverter.convert((ExistsSubqueryExpression) segment));
         }
         if (segment instanceof SubqueryExpressionSegment) {
-            return SubqueryExpressionConverter.convert((SubqueryExpressionSegment) segment);
+            return Optional.of(SubqueryExpressionConverter.convert((SubqueryExpressionSegment) segment));
         }
         if (segment instanceof InExpression) {
-            return InExpressionConverter.convert((InExpression) segment);
+            return Optional.of(InExpressionConverter.convert((InExpression) segment));
         }
         if (segment instanceof BetweenExpression) {
             return Optional.of(BetweenExpressionConverter.convert((BetweenExpression) segment));
         }
         if (segment instanceof ParameterMarkerExpressionSegment) {
-            return ParameterMarkerExpressionConverter.convert((ParameterMarkerExpressionSegment) segment);
+            return Optional.of(ParameterMarkerExpressionConverter.convert((ParameterMarkerExpressionSegment) segment));
         }
         if (segment instanceof FunctionSegment) {
             return FunctionConverter.convert((FunctionSegment) segment);
@@ -133,7 +133,7 @@ public static Optional<SqlNode> convert(final ExpressionSegment segment) {
             return Optional.of(CaseWhenExpressionConverter.convert((CaseWhenExpression) segment));
         }
         if (segment instanceof NotExpression) {
-            return NotExpressionConverter.convert((NotExpression) segment);
+            return Optional.of(NotExpressionConverter.convert((NotExpression) segment));
         }
         if (segment instanceof TypeCastExpression) {
             return TypeCastExpressionConverter.convert((TypeCastExpression) segment);
@@ -142,25 +142,25 @@ public static Optional<SqlNode> convert(final ExpressionSegment segment) {
             return Optional.of(ExtractArgExpressionConverter.convert((ExtractArgExpression) segment));
         }
         if (segment instanceof MatchAgainstExpression) {
-            return MatchExpressionConverter.convert((MatchAgainstExpression) segment);
+            return Optional.of(MatchExpressionConverter.convert((MatchAgainstExpression) segment));
         }
         if (segment instanceof CollateExpression) {
             return Optional.of(CollateExpressionConverter.convert((CollateExpression) segment));
         }
         if (segment instanceof RowExpression) {
-            return RowExpressionConverter.convert((RowExpression) segment);
+            return Optional.of(RowExpressionConverter.convert((RowExpression) segment));
         }
         if (segment instanceof VariableSegment) {
-            return VariableSegmentConverter.convert((VariableSegment) segment);
+            return Optional.of(VariableSegmentConverter.convert((VariableSegment) segment));
         }
         if (segment instanceof UnaryOperationExpression) {
-            return UnaryOperationExpressionConverter.convert((UnaryOperationExpression) segment);
+            return Optional.of(UnaryOperationExpressionConverter.convert((UnaryOperationExpression) segment));
         }
         if (segment instanceof IntervalExpression) {
-            return IntervalExpressionConverter.convert((IntervalExpression) segment);
+            return Optional.of(IntervalExpressionConverter.convert((IntervalExpression) segment));
         }
         if (segment instanceof QuantifySubqueryExpression) {
-            return QuantifySubqueryExpressionConverter.convert((QuantifySubqueryExpression) segment);
+            return Optional.of(QuantifySubqueryExpressionConverter.convert((QuantifySubqueryExpression) segment));
         }
         throw new UnsupportedSQLOperationException("unsupported TableSegment type: " + segment.getClass());
     }

kernel/sql-federation/compiler/src/main/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/expression/impl/FunctionConverter.java

@@ -62,10 +62,10 @@ public static Optional<SqlNode> convert(final FunctionSegment segment) {
             return Optional.of(functionName);
         }
         if ("TRIM".equalsIgnoreCase(functionName.getSimple())) {
-            return TrimFunctionConverter.convert(segment);
+            return Optional.of(TrimFunctionConverter.convert(segment));
         }
         if ("OVER".equalsIgnoreCase(functionName.getSimple())) {
-            return WindowFunctionConverter.convert(segment);
+            return Optional.of(WindowFunctionConverter.convert(segment));
         }
         List<SqlOperator> functions = new LinkedList<>();
         SqlStdOperatorTable.instance().lookupOperatorOverloads(functionName, null, SqlSyntax.FUNCTION, functions, SqlNameMatchers.withCaseSensitive(false));

kernel/sql-federation/compiler/src/main/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/expression/impl/InExpressionConverter.java

@@ -30,7 +30,6 @@
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.LinkedList;
-import java.util.Optional;
 
 /**
  * In expression converter.
@@ -44,14 +43,11 @@ public final class InExpressionConverter {
      * @param expression in expression
      * @return SQL node
      */
-    public static Optional<SqlNode> convert(final InExpression expression) {
-        if (null == expression) {
-            return Optional.empty();
-        }
+    public static SqlBasicCall convert(final InExpression expression) {
         Collection<SqlNode> sqlNodes = new LinkedList<>();
         ExpressionConverter.convert(expression.getLeft()).ifPresent(sqlNodes::add);
         ExpressionConverter.convert(expression.getRight())
                 .ifPresent(optional -> sqlNodes.add(optional instanceof SqlBasicCall ? new SqlNodeList(((SqlBasicCall) optional).getOperandList(), SqlParserPos.ZERO) : optional));
-        return Optional.of(new SqlBasicCall(expression.isNot() ? SqlStdOperatorTable.NOT_IN : SqlStdOperatorTable.IN, new ArrayList<>(sqlNodes), SqlParserPos.ZERO));
+        return new SqlBasicCall(expression.isNot() ? SqlStdOperatorTable.NOT_IN : SqlStdOperatorTable.IN, new ArrayList<>(sqlNodes), SqlParserPos.ZERO);
     }
 }

kernel/sql-federation/compiler/src/main/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/expression/impl/IntervalExpressionConverter.java

@@ -31,7 +31,6 @@
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Optional;
 
 /**
  * Interval expression converter.
@@ -45,13 +44,12 @@ public final class IntervalExpressionConverter {
      * @param segment unary operation expression
      * @return SQL node
      */
-    public static Optional<SqlNode> convert(final IntervalExpression segment) {
+    public static SqlBasicCall convert(final IntervalExpression segment) {
         TimeUnit timeUnit = getTimeUnit(segment.getIntervalUnit());
         List<SqlNode> sqlNodes = new ArrayList<>();
         ExpressionConverter.convert(segment.getValue()).ifPresent(sqlNodes::add);
         sqlNodes.add(new SqlIntervalQualifier(timeUnit, timeUnit, SqlParserPos.ZERO));
-        SqlBasicCall result = new SqlBasicCall(SQLExtensionOperatorTable.INTERVAL_OPERATOR, sqlNodes, SqlParserPos.ZERO);
-        return Optional.of(result);
+        return new SqlBasicCall(SQLExtensionOperatorTable.INTERVAL_OPERATOR, sqlNodes, SqlParserPos.ZERO);
     }
 
     private static TimeUnit getTimeUnit(final IntervalUnit unit) {

kernel/sql-federation/compiler/src/main/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/expression/impl/LiteralExpressionConverter.java

@@ -87,7 +87,7 @@ public static Optional<SqlNode> convert(final LiteralExpressionSegment segment)
             return Optional.of(new SqlIntervalQualifier(TimeUnit.valueOf(literalValue.toUpperCase()), null, SqlParserPos.ZERO));
         }
         if (segment.getLiterals() instanceof Number) {
-            return convertNumber(segment, literalValue);
+            return Optional.of(convertNumber(segment, literalValue));
         }
         if (segment.getLiterals() instanceof String) {
             return Optional.of(SqlLiteral.createCharString(literalValue, SqlParserPos.ZERO));
@@ -96,10 +96,10 @@ public static Optional<SqlNode> convert(final LiteralExpressionSegment segment)
             return Optional.of(SqlLiteral.createBoolean(Boolean.parseBoolean(literalValue), SqlParserPos.ZERO));
         }
         if (segment.getLiterals() instanceof Calendar) {
-            return convertCalendar(segment);
+            return Optional.of(convertCalendar(segment));
         }
         if (segment.getLiterals() instanceof Date) {
-            return convertDate(segment, literalValue);
+            return Optional.of(convertDate(segment, literalValue));
         }
         if (segment.getLiterals() instanceof LocalDate) {
             return Optional.of(SqlLiteral.createDate(DateString.fromDaysSinceEpoch((int) ((LocalDate) segment.getLiterals()).toEpochDay()), SqlParserPos.ZERO));
@@ -122,33 +122,31 @@ public static Optional<SqlNode> convert(final LiteralExpressionSegment segment)
         return Optional.empty();
     }
 
-    private static Optional<SqlNode> convertNumber(final LiteralExpressionSegment segment, final String literalValue) {
-        if (segment.getLiterals() instanceof BigDecimal || segment.getLiterals() instanceof BigInteger) {
-            return Optional.of(SqlLiteral.createApproxNumeric(literalValue, SqlParserPos.ZERO));
-        }
-        return Optional.of(SqlLiteral.createExactNumeric(literalValue, SqlParserPos.ZERO));
+    private static SqlNode convertNumber(final LiteralExpressionSegment segment, final String literalValue) {
+        return segment.getLiterals() instanceof BigDecimal || segment.getLiterals() instanceof BigInteger
+                ? SqlLiteral.createApproxNumeric(literalValue, SqlParserPos.ZERO)
+                : SqlLiteral.createExactNumeric(literalValue, SqlParserPos.ZERO);
     }
 
-    private static Optional<SqlNode> convertCalendar(final LiteralExpressionSegment segment) {
+    private static SqlNode convertCalendar(final LiteralExpressionSegment segment) {
         Calendar calendar = (Calendar) segment.getLiterals();
-        if (hasTimePart(calendar)) {
-            return Optional.of(SqlLiteral.createTimestamp(SqlTypeName.TIMESTAMP, TimestampString.fromCalendarFields(calendar), 1, SqlParserPos.ZERO));
-        }
-        return Optional.of(SqlLiteral.createDate(DateString.fromCalendarFields(calendar), SqlParserPos.ZERO));
+        return hasTimePart(calendar)
+                ? SqlLiteral.createTimestamp(SqlTypeName.TIMESTAMP, TimestampString.fromCalendarFields(calendar), 1, SqlParserPos.ZERO)
+                : SqlLiteral.createDate(DateString.fromCalendarFields(calendar), SqlParserPos.ZERO);
     }
 
     private static boolean hasTimePart(final Calendar calendar) {
         return 0 != calendar.get(Calendar.HOUR_OF_DAY) || 0 != calendar.get(Calendar.MINUTE) || 0 != calendar.get(Calendar.SECOND) || 0 != calendar.get(Calendar.MILLISECOND);
     }
 
-    private static Optional<SqlNode> convertDate(final LiteralExpressionSegment segment, final String literalValue) {
+    private static SqlNode convertDate(final LiteralExpressionSegment segment, final String literalValue) {
         if (segment.getLiterals() instanceof Timestamp) {
             Timestamp timestamp = (Timestamp) segment.getLiterals();
-            return Optional.of(SqlLiteral.createTimestamp(SqlTypeName.TIMESTAMP, TimestampString.fromMillisSinceEpoch(timestamp.getTime()), 1, SqlParserPos.ZERO));
+            return SqlLiteral.createTimestamp(SqlTypeName.TIMESTAMP, TimestampString.fromMillisSinceEpoch(timestamp.getTime()), 1, SqlParserPos.ZERO);
         }
         if (segment.getLiterals() instanceof Time) {
-            return Optional.of(SqlLiteral.createTime(new TimeString(literalValue), 1, SqlParserPos.ZERO));
+            return SqlLiteral.createTime(new TimeString(literalValue), 1, SqlParserPos.ZERO);
         }
-        return Optional.of(SqlLiteral.createDate(new DateString(literalValue), SqlParserPos.ZERO));
+        return SqlLiteral.createDate(new DateString(literalValue), SqlParserPos.ZERO);
     }
 }

kernel/sql-federation/compiler/src/main/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/expression/impl/MatchExpressionConverter.java

@@ -25,15 +25,14 @@
 import org.apache.calcite.sql.SqlNode;
 import org.apache.calcite.sql.parser.SqlParserPos;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.column.ColumnSegment;
-import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.match.MatchAgainstExpression;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.OwnerSegment;
+import org.apache.shardingsphere.sql.parser.statement.core.segment.generic.match.MatchAgainstExpression;
 import org.apache.shardingsphere.sqlfederation.compiler.sql.ast.converter.operator.common.SQLExtensionOperatorTable;
 import org.apache.shardingsphere.sqlfederation.compiler.sql.ast.converter.segment.expression.ExpressionConverter;
 
 import java.util.ArrayList;
 import java.util.LinkedList;
 import java.util.List;
-import java.util.Optional;
 
 /**
  * Match expression converter.
@@ -47,7 +46,7 @@ public final class MatchExpressionConverter {
      * @param segment match against expression
      * @return SQL node
      */
-    public static Optional<SqlNode> convert(final MatchAgainstExpression segment) {
+    public static SqlBasicCall convert(final MatchAgainstExpression segment) {
         List<SqlNode> sqlNodes = new LinkedList<>();
         List<String> names = new ArrayList<>();
         for (ColumnSegment each : segment.getColumns()) {
@@ -60,7 +59,7 @@ public static Optional<SqlNode> convert(final MatchAgainstExpression segment) {
         ExpressionConverter.convert(segment.getExpr()).ifPresent(sqlNodes::add);
         SqlNode searchModifier = SqlLiteral.createCharString(segment.getSearchModifier(), SqlParserPos.ZERO);
         sqlNodes.add(searchModifier);
-        return Optional.of(new SqlBasicCall(SQLExtensionOperatorTable.MATCH_AGAINST, sqlNodes, SqlParserPos.ZERO));
+        return new SqlBasicCall(SQLExtensionOperatorTable.MATCH_AGAINST, sqlNodes, SqlParserPos.ZERO);
     }
 
     private static void addOwnerNames(final List<String> names, final OwnerSegment owner) {

kernel/sql-federation/compiler/src/main/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/expression/impl/NotExpressionConverter.java

@@ -28,7 +28,6 @@
 
 import java.util.LinkedList;
 import java.util.List;
-import java.util.Optional;
 
 /**
  * Not expression converter.
@@ -42,13 +41,10 @@ public final class NotExpressionConverter {
      * @param segment not expression
      * @return SQL node
      */
-    public static Optional<SqlNode> convert(final NotExpression segment) {
+    public static SqlBasicCall convert(final NotExpression segment) {
         SqlNode expression = ExpressionConverter.convert(segment.getExpression()).orElseThrow(IllegalStateException::new);
         List<SqlNode> sqlNodes = new LinkedList<>();
         sqlNodes.add(expression);
-        if (segment.getNotSign().equals(true)) {
-            return Optional.of(new SqlBasicCall(SQLExtensionOperatorTable.NOT_SIGN, sqlNodes, SqlParserPos.ZERO));
-        }
-        return Optional.of(new SqlBasicCall(SQLExtensionOperatorTable.NOT, sqlNodes, SqlParserPos.ZERO));
+        return new SqlBasicCall(segment.getNotSign() ? SQLExtensionOperatorTable.NOT_SIGN : SQLExtensionOperatorTable.NOT, sqlNodes, SqlParserPos.ZERO);
     }
 }

kernel/sql-federation/compiler/src/main/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/expression/impl/ParameterMarkerExpressionConverter.java

@@ -20,12 +20,9 @@
 import lombok.AccessLevel;
 import lombok.NoArgsConstructor;
 import org.apache.calcite.sql.SqlDynamicParam;
-import org.apache.calcite.sql.SqlNode;
 import org.apache.calcite.sql.parser.SqlParserPos;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.simple.ParameterMarkerExpressionSegment;
 
-import java.util.Optional;
-
 /**
  * Parameter marker expression converter.
  */
@@ -38,7 +35,7 @@ public final class ParameterMarkerExpressionConverter {
      * @param segment parameter marker expression segment
      * @return SQL node
      */
-    public static Optional<SqlNode> convert(final ParameterMarkerExpressionSegment segment) {
-        return Optional.of(new SqlDynamicParam(segment.getParameterMarkerIndex(), SqlParserPos.ZERO));
+    public static SqlDynamicParam convert(final ParameterMarkerExpressionSegment segment) {
+        return new SqlDynamicParam(segment.getParameterMarkerIndex(), SqlParserPos.ZERO);
     }
 }

kernel/sql-federation/compiler/src/main/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/expression/impl/QuantifySubqueryExpressionConverter.java

@@ -23,8 +23,6 @@
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.QuantifySubqueryExpression;
 import org.apache.shardingsphere.sqlfederation.compiler.sql.ast.converter.statement.type.SelectStatementConverter;
 
-import java.util.Optional;
-
 /**
  * Quantify subquery expression converter.
  */
@@ -37,7 +35,7 @@ public final class QuantifySubqueryExpressionConverter {
      * @param expression quantify subquery expression
      * @return SQL node
      */
-    public static Optional<SqlNode> convert(final QuantifySubqueryExpression expression) {
-        return null == expression ? Optional.empty() : Optional.of(new SelectStatementConverter().convert(expression.getSubquery().getSelect()));
+    public static SqlNode convert(final QuantifySubqueryExpression expression) {
+        return new SelectStatementConverter().convert(expression.getSubquery().getSelect());
     }
 }

kernel/sql-federation/compiler/src/main/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/expression/impl/RowExpressionConverter.java

@@ -28,7 +28,6 @@
 
 import java.util.ArrayList;
 import java.util.List;
-import java.util.Optional;
 
 /**
  * Row expression converter.
@@ -42,11 +41,11 @@ public final class RowExpressionConverter {
      * @param segment row expression
      * @return SQL node
      */
-    public static Optional<SqlNode> convert(final RowExpression segment) {
+    public static SqlNode convert(final RowExpression segment) {
         List<SqlNode> sqlNodes = new ArrayList<>(segment.getItems().size());
         for (ExpressionSegment each : segment.getItems()) {
             ExpressionConverter.convert(each).ifPresent(sqlNodes::add);
         }
-        return Optional.of(SqlStdOperatorTable.ROW.createCall(SqlParserPos.ZERO, sqlNodes));
+        return SqlStdOperatorTable.ROW.createCall(SqlParserPos.ZERO, sqlNodes);
     }
 }

kernel/sql-federation/compiler/src/main/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/expression/impl/SubqueryExpressionConverter.java

@@ -23,8 +23,6 @@
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.subquery.SubqueryExpressionSegment;
 import org.apache.shardingsphere.sqlfederation.compiler.sql.ast.converter.statement.type.SelectStatementConverter;
 
-import java.util.Optional;
-
 /**
  * Subquery expression converter.
  */
@@ -37,7 +35,7 @@ public final class SubqueryExpressionConverter {
      * @param expression subquery expression segment
      * @return SQL node
      */
-    public static Optional<SqlNode> convert(final SubqueryExpressionSegment expression) {
-        return null == expression ? Optional.empty() : Optional.of(new SelectStatementConverter().convert(expression.getSubquery().getSelect()));
+    public static SqlNode convert(final SubqueryExpressionSegment expression) {
+        return new SelectStatementConverter().convert(expression.getSubquery().getSelect());
     }
 }

kernel/sql-federation/compiler/src/main/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/expression/impl/TrimFunctionConverter.java

@@ -36,7 +36,6 @@
 import java.util.Collection;
 import java.util.LinkedList;
 import java.util.List;
-import java.util.Optional;
 
 /**
  * Trim function converter.
@@ -50,11 +49,11 @@ public final class TrimFunctionConverter {
      * @param segment function segment
      * @return SQL node
      */
-    public static Optional<SqlNode> convert(final FunctionSegment segment) {
+    public static SqlBasicCall convert(final FunctionSegment segment) {
         SqlIdentifier functionName = new SqlIdentifier(segment.getFunctionName(), SqlParserPos.ZERO);
         List<SqlOperator> functions = new LinkedList<>();
         SqlStdOperatorTable.instance().lookupOperatorOverloads(functionName, null, SqlSyntax.FUNCTION, functions, SqlNameMatchers.withCaseSensitive(false));
-        return Optional.of(new SqlBasicCall(functions.iterator().next(), getTrimFunctionParameters(segment.getParameters()), SqlParserPos.ZERO));
+        return new SqlBasicCall(functions.iterator().next(), getTrimFunctionParameters(segment.getParameters()), SqlParserPos.ZERO);
     }
 
     private static List<SqlNode> getTrimFunctionParameters(final Collection<ExpressionSegment> sqlSegments) {