Refactor ExistsSubqueryExpressionConverter

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

@@ -106,7 +106,7 @@ public static Optional<SqlNode> convert(final ExpressionSegment segment) {
             return Optional.of(ColumnConverter.convert((ColumnSegment) segment));
         }
         if (segment instanceof ExistsSubqueryExpression) {
-            return ExistsSubqueryExpressionConverter.convert((ExistsSubqueryExpression) segment);
+            return Optional.of(ExistsSubqueryExpressionConverter.convert((ExistsSubqueryExpression) segment));
         }
         if (segment instanceof SubqueryExpressionSegment) {
             return SubqueryExpressionConverter.convert((SubqueryExpressionSegment) segment);

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

@@ -27,7 +27,6 @@
 import org.apache.shardingsphere.sqlfederation.compiler.sql.ast.converter.statement.type.SelectStatementConverter;
 
 import java.util.Collections;
-import java.util.Optional;
 
 /**
  * Exists subquery expression converter.
@@ -41,12 +40,9 @@ public final class ExistsSubqueryExpressionConverter {
      * @param expression exists subquery expression
      * @return SQL node
      */
-    public static Optional<SqlNode> convert(final ExistsSubqueryExpression expression) {
-        if (null == expression) {
-            return Optional.empty();
-        }
-        SqlBasicCall sqlNode = new SqlBasicCall(SqlStdOperatorTable.EXISTS,
-                Collections.singletonList(new SelectStatementConverter().convert(expression.getSubquery().getSelect())), SqlParserPos.ZERO);
-        return expression.isNot() ? Optional.of(new SqlBasicCall(SqlStdOperatorTable.NOT, Collections.singletonList(sqlNode), SqlParserPos.ZERO)) : Optional.of(sqlNode);
+    public static SqlNode convert(final ExistsSubqueryExpression expression) {
+        SqlBasicCall sqlNode = new SqlBasicCall(
+                SqlStdOperatorTable.EXISTS, Collections.singletonList(new SelectStatementConverter().convert(expression.getSubquery().getSelect())), SqlParserPos.ZERO);
+        return expression.isNot() ? new SqlBasicCall(SqlStdOperatorTable.NOT, Collections.singletonList(sqlNode), SqlParserPos.ZERO) : sqlNode;
     }
 }

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

@@ -126,7 +126,7 @@ void assertConvertDelegatesToAllSupportedConverters() {
         SqlNode expectedExistsSubqueryNode = mock(SqlNode.class);
         SubquerySegment subquerySegment = new SubquerySegment(0, 0, new SelectStatement(databaseType), "sub");
         ExistsSubqueryExpression existsSubqueryExpression = new ExistsSubqueryExpression(0, 0, subquerySegment);
-        when(ExistsSubqueryExpressionConverter.convert(existsSubqueryExpression)).thenReturn(Optional.of(expectedExistsSubqueryNode));
+        when(ExistsSubqueryExpressionConverter.convert(existsSubqueryExpression)).thenReturn(expectedExistsSubqueryNode);
         SqlNode expectedSubqueryNode = mock(SqlNode.class);
         SubqueryExpressionSegment subqueryExpressionSegment = new SubqueryExpressionSegment(subquerySegment);
         when(SubqueryExpressionConverter.convert(subqueryExpressionSegment)).thenReturn(Optional.of(expectedSubqueryNode));

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

@@ -33,8 +33,6 @@
 
 import static org.hamcrest.CoreMatchers.is;
 import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.jupiter.api.Assertions.assertFalse;
-import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.mockConstruction;
@@ -44,20 +42,14 @@ class ExistsSubqueryExpressionConverterTest {
 
     private final DatabaseType databaseType = TypedSPILoader.getService(DatabaseType.class, "FIXTURE");
 
-    @Test
-    void assertConvertReturnsEmptyForNullExpression() {
-        assertFalse(ExistsSubqueryExpressionConverter.convert(null).isPresent());
-    }
-
     @Test
     void assertConvertExistsExpression() {
         SqlNode expected = mock(SqlNode.class);
         try (
                 MockedConstruction<SelectStatementConverter> ignored = mockConstruction(SelectStatementConverter.class,
                         (mock, context) -> when(mock.convert(any(SelectStatement.class))).thenReturn(expected))) {
             ExistsSubqueryExpression expression = new ExistsSubqueryExpression(0, 0, new SubquerySegment(0, 0, new SelectStatement(databaseType), "text"));
-            SqlBasicCall actual = (SqlBasicCall) ExistsSubqueryExpressionConverter.convert(expression).orElse(null);
-            assertNotNull(actual);
+            SqlBasicCall actual = (SqlBasicCall) ExistsSubqueryExpressionConverter.convert(expression);
             assertThat(actual.getOperator(), is(SqlStdOperatorTable.EXISTS));
             assertThat(actual.getOperandList(), is(Collections.singletonList(expected)));
         }
@@ -71,8 +63,7 @@ void assertConvertNotExistsExpression() {
                         (mock, context) -> when(mock.convert(any(SelectStatement.class))).thenReturn(expected))) {
             ExistsSubqueryExpression expression = new ExistsSubqueryExpression(0, 0, new SubquerySegment(0, 0, new SelectStatement(databaseType), "text"));
             expression.setNot(true);
-            SqlBasicCall actual = (SqlBasicCall) ExistsSubqueryExpressionConverter.convert(expression).orElse(null);
-            assertNotNull(actual);
+            SqlBasicCall actual = (SqlBasicCall) ExistsSubqueryExpressionConverter.convert(expression);
             assertThat(actual.getOperator(), is(SqlStdOperatorTable.NOT));
             SqlBasicCall existsCall = (SqlBasicCall) actual.getOperandList().get(0);
             assertThat(existsCall.getOperator(), is(SqlStdOperatorTable.EXISTS));