Refactor ExtractArgExpressionConverter

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);
@@ -139,7 +139,7 @@ public static Optional<SqlNode> convert(final ExpressionSegment segment) {
             return TypeCastExpressionConverter.convert((TypeCastExpression) segment);
         }
         if (segment instanceof ExtractArgExpression) {
-            return ExtractArgExpressionConverter.convert((ExtractArgExpression) segment);
+            return Optional.of(ExtractArgExpressionConverter.convert((ExtractArgExpression) segment));
         }
         if (segment instanceof MatchAgainstExpression) {
             return MatchExpressionConverter.convert((MatchAgainstExpression) 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/main/java/org/apache/shardingsphere/sqlfederation/compiler/sql/ast/converter/segment/expression/impl/ExtractArgExpressionConverter.java

@@ -20,12 +20,9 @@
 import lombok.AccessLevel;
 import lombok.NoArgsConstructor;
 import org.apache.calcite.sql.SqlIdentifier;
-import org.apache.calcite.sql.SqlNode;
 import org.apache.calcite.sql.parser.SqlParserPos;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.ExtractArgExpression;
 
-import java.util.Optional;
-
 /**
  * Extract arg expression converter.
  */
@@ -38,10 +35,7 @@ public final class ExtractArgExpressionConverter {
      * @param expression extract arg expression
      * @return SQL node
      */
-    public static Optional<SqlNode> convert(final ExtractArgExpression expression) {
-        if (null == expression) {
-            return Optional.empty();
-        }
-        return Optional.of(new SqlIdentifier(expression.getText(), SqlParserPos.ZERO));
+    public static SqlIdentifier convert(final ExtractArgExpression expression) {
+        return new SqlIdentifier(expression.getText(), SqlParserPos.ZERO);
     }
 }

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));
@@ -160,9 +160,9 @@ void assertConvertDelegatesToAllSupportedConverters() {
         SqlNode expectedTypeCastNode = mock(SqlNode.class);
         TypeCastExpression typeCastExpression = new TypeCastExpression(0, 0, "text", literalSegment, "int");
         when(TypeCastExpressionConverter.convert(typeCastExpression)).thenReturn(Optional.of(expectedTypeCastNode));
-        SqlNode expectedExtractNode = mock(SqlNode.class);
+        SqlIdentifier expectedExtractNode = mock(SqlIdentifier.class);
         ExtractArgExpression extractArgExpression = new ExtractArgExpression(0, 0, "extract");
-        when(ExtractArgExpressionConverter.convert(extractArgExpression)).thenReturn(Optional.of(expectedExtractNode));
+        when(ExtractArgExpressionConverter.convert(extractArgExpression)).thenReturn(expectedExtractNode);
         SqlNode expectedMatchNode = mock(SqlNode.class);
         MatchAgainstExpression matchAgainstExpression = new MatchAgainstExpression(0, 0, literalSegment, "search", "text");
         when(MatchExpressionConverter.convert(matchAgainstExpression)).thenReturn(Optional.of(expectedMatchNode));

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));

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

@@ -17,26 +17,16 @@
 
 package org.apache.shardingsphere.sqlfederation.compiler.sql.ast.converter.segment.expression.impl;
 
-import org.apache.calcite.sql.SqlIdentifier;
 import org.apache.shardingsphere.sql.parser.statement.core.segment.dml.expr.ExtractArgExpression;
 import org.junit.jupiter.api.Test;
 
 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;
 
 class ExtractArgExpressionConverterTest {
 
-    @Test
-    void assertConvertReturnsEmptyForNullExpression() {
-        assertFalse(ExtractArgExpressionConverter.convert(null).isPresent());
-    }
-
     @Test
     void assertConvertExtractArgExpression() {
-        SqlIdentifier actual = (SqlIdentifier) ExtractArgExpressionConverter.convert(new ExtractArgExpression(0, 0, "DAY")).orElse(null);
-        assertNotNull(actual);
-        assertThat(actual.getSimple(), is("DAY"));
+        assertThat(ExtractArgExpressionConverter.convert(new ExtractArgExpression(0, 0, "DAY")).getSimple(), is("DAY"));
     }
 }