for #660: refactor assert condition

sharding-core/src/main/java/io/shardingjdbc/core/parsing/parser/context/condition/Condition.java

@@ -46,14 +46,13 @@ import java.util.Map.Entry;
  * @author zhangliang
  */
 @RequiredArgsConstructor(access = AccessLevel.PRIVATE)
+@Getter
 @EqualsAndHashCode
 @ToString
 public final class Condition {
     
-    @Getter
     private final Column column;
     
-    @Getter
     private final ShardingOperator operator;
     
     private final Map<Integer, Comparable<?>> positionValueMap = new LinkedHashMap<>();
@@ -96,7 +95,7 @@ public final class Condition {
      * @param parameters parameters
      * @return sharding value
      */
-    public ShardingValue getShardingValue(final List<Object> parameters) {
+    public ShardingValue getShardingValue(final List<?> parameters) {
         List<Comparable<?>> conditionValues = getValues(parameters);
         switch (operator) {
             case EQUAL:
@@ -109,7 +108,7 @@ public final class Condition {
         }
     }
     
-    private List<Comparable<?>> getValues(final List<Object> parameters) {
+    private List<Comparable<?>> getValues(final List<?> parameters) {
         List<Comparable<?>> result = new LinkedList<>(positionValueMap.values());
         for (Entry<Integer, Integer> entry : positionIndexMap.entrySet()) {
             Object parameter = parameters.get(entry.getValue());

sharding-core/src/test/java/io/shardingjdbc/core/parsing/integrate/asserts/ParserAssertHelper.java

@@ -18,9 +18,6 @@
 package io.shardingjdbc.core.parsing.integrate.asserts;
 
 import io.shardingjdbc.core.constant.DatabaseType;
-import io.shardingjdbc.core.constant.ShardingOperator;
-import io.shardingjdbc.core.parsing.integrate.jaxb.condition.ConditionAssert;
-import io.shardingjdbc.core.parsing.integrate.jaxb.condition.Value;
 import io.shardingjdbc.core.parsing.integrate.jaxb.limit.LimitAssert;
 import io.shardingjdbc.core.parsing.integrate.jaxb.token.GeneratedKeyTokenAssert;
 import io.shardingjdbc.core.parsing.integrate.jaxb.token.IndexTokenAssert;
@@ -32,16 +29,9 @@ import io.shardingjdbc.core.parsing.integrate.jaxb.token.RowCountTokenAssert;
 import io.shardingjdbc.core.parsing.integrate.jaxb.token.SQLTokenAssert;
 import io.shardingjdbc.core.parsing.integrate.jaxb.token.TableTokenAssert;
 import io.shardingjdbc.core.parsing.parser.context.OrderItem;
-import io.shardingjdbc.core.parsing.parser.context.condition.Column;
-import io.shardingjdbc.core.parsing.parser.context.condition.Condition;
-import io.shardingjdbc.core.parsing.parser.context.condition.Conditions;
 import io.shardingjdbc.core.parsing.parser.context.limit.Limit;
 import io.shardingjdbc.core.parsing.parser.context.limit.LimitValue;
 import io.shardingjdbc.core.parsing.parser.context.selectitem.AggregationSelectItem;
-import io.shardingjdbc.core.parsing.parser.expression.SQLExpression;
-import io.shardingjdbc.core.parsing.parser.expression.SQLNumberExpression;
-import io.shardingjdbc.core.parsing.parser.expression.SQLPlaceholderExpression;
-import io.shardingjdbc.core.parsing.parser.expression.SQLTextExpression;
 import io.shardingjdbc.core.parsing.parser.token.GeneratedKeyToken;
 import io.shardingjdbc.core.parsing.parser.token.IndexToken;
 import io.shardingjdbc.core.parsing.parser.token.ItemsToken;
@@ -55,7 +45,6 @@ import org.apache.commons.lang3.builder.EqualsBuilder;
 
 import java.util.ArrayList;
 import java.util.Iterator;
-import java.util.LinkedList;
 import java.util.List;
 
 import static org.junit.Assert.assertFalse;
@@ -64,49 +53,6 @@ import static org.junit.Assert.assertTrue;
 
 public class ParserAssertHelper {
     
-    public static void assertConditions(
-            final List<ConditionAssert> expected, final Conditions actual, final boolean isPreparedStatement) {
-        assertTrue(EqualsBuilder.reflectionEquals(buildExpectedConditions(expected, isPreparedStatement), actual));
-    }
-    
-    private static Conditions buildExpectedConditions(final List<ConditionAssert> conditions, final boolean isPreparedStatement) {
-        Conditions result = new Conditions();
-        if (null == conditions) {
-            return result;
-        }
-        for (ConditionAssert each : conditions) {
-            List<SQLExpression> sqlExpressions = new LinkedList<>();
-            for (Value value : each.getValues()) {
-                if (isPreparedStatement) {
-                    sqlExpressions.add(new SQLPlaceholderExpression(value.getIndex()));
-                } else {
-                    Comparable<?> valueWithType = value.getValueWithType();
-                    if (valueWithType instanceof Number) {
-                        sqlExpressions.add(new SQLNumberExpression((Number) valueWithType));
-                    } else {
-                        sqlExpressions.add(new SQLTextExpression(null == valueWithType ? "" : valueWithType.toString()));
-                    }
-                }
-            }
-            Condition condition;
-            switch (ShardingOperator.valueOf(each.getOperator().toUpperCase())) {
-                case EQUAL:
-                    condition = new Condition(new Column(each.getColumnName(), each.getTableName()), sqlExpressions.get(0));
-                    break;
-                case BETWEEN:
-                    condition = new Condition(new Column(each.getColumnName(), each.getTableName()), sqlExpressions.get(0), sqlExpressions.get(1));
-                    break;
-                case IN:
-                    condition = new Condition(new Column(each.getColumnName(), each.getTableName()), sqlExpressions);
-                    break;
-                default:
-                    throw new UnsupportedOperationException();
-            }
-            result.add(condition);
-        }
-        return result;
-    }
-    
     public static void assertSqlTokens(final List<SQLTokenAssert> expected, final List<SQLToken> actual, final boolean isPreparedStatement) {
         if (null == expected || expected.size() == 0) {
             return;

sharding-core/src/test/java/io/shardingjdbc/core/parsing/integrate/engine/IntegrateSupportedSQLParsingTest.java

@@ -22,8 +22,13 @@ import io.shardingjdbc.core.constant.DatabaseType;
 import io.shardingjdbc.core.parsing.SQLParsingEngine;
 import io.shardingjdbc.core.parsing.integrate.asserts.ParserAssertHelper;
 import io.shardingjdbc.core.parsing.integrate.asserts.ParserJAXBHelper;
+import io.shardingjdbc.core.parsing.integrate.jaxb.condition.ConditionAssert;
+import io.shardingjdbc.core.parsing.integrate.jaxb.condition.Value;
 import io.shardingjdbc.core.parsing.integrate.jaxb.root.ParserAssert;
 import io.shardingjdbc.core.parsing.integrate.jaxb.table.TableAssert;
+import io.shardingjdbc.core.parsing.parser.context.condition.Column;
+import io.shardingjdbc.core.parsing.parser.context.condition.Condition;
+import io.shardingjdbc.core.parsing.parser.context.condition.Conditions;
 import io.shardingjdbc.core.parsing.parser.context.table.Table;
 import io.shardingjdbc.core.parsing.parser.context.table.Tables;
 import io.shardingjdbc.core.parsing.parser.sql.SQLStatement;
@@ -71,7 +76,9 @@ public final class IntegrateSupportedSQLParsingTest extends AbstractBaseIntegrat
     private void assertSQLStatement(final SQLStatement actual, final boolean isPreparedStatement) {
         ParserAssert parserAssert = parserAssertsLoader.getParserAssert(sqlCaseId);
         assertTables(actual.getTables(), parserAssert.getTables());
-        ParserAssertHelper.assertConditions(parserAssert.getConditions(), actual.getConditions(), isPreparedStatement);
+        assertConditions(actual.getConditions(), parserAssert.getConditions());
+        
+        
         ParserAssertHelper.assertSqlTokens(parserAssert.getTokens().getTokenAsserts(), actual.getSqlTokens(), isPreparedStatement);
         if (actual instanceof SelectStatement) {
             SelectStatement selectStatement = (SelectStatement) actual;
@@ -101,4 +108,28 @@ public final class IntegrateSupportedSQLParsingTest extends AbstractBaseIntegrat
         assertThat(actual.getName(), is(expected.getName()));
         assertThat(actual.getAlias().orNull(), is(expected.getAlias()));
     }
+    
+    private void assertConditions(final Conditions actual, final List<ConditionAssert> expected) {
+        assertThat(actual.getConditions().size(), is(expected.size()));
+        for (ConditionAssert each : expected) {
+            Optional<Condition> conditionOptional = actual.find(new Column(each.getColumnName(), each.getTableName()));
+            assertTrue(conditionOptional.isPresent());
+            assertCondition(conditionOptional.get(), each);
+        }
+    }
+    
+    private void assertCondition(final Condition actual, final ConditionAssert expected) {
+        assertThat(actual.getColumn().getName().toUpperCase(), is(expected.getColumnName().toUpperCase()));
+        assertThat(actual.getColumn().getTableName().toUpperCase(), is(expected.getTableName().toUpperCase()));
+        assertThat(actual.getOperator().name(), is(expected.getOperator()));
+        int count = 0;
+        for (Value each : expected.getValues()) {
+            if (!actual.getPositionValueMap().isEmpty()) {
+                assertThat(actual.getPositionValueMap().get(count), is((Comparable) each.getLiteralForAccurateType()));
+            } else if (!actual.getPositionIndexMap().isEmpty()) {
+                assertThat(actual.getPositionIndexMap().get(count), is(each.getIndex()));
+            }
+            count++;
+        }
+    }
 }

sharding-core/src/test/java/io/shardingjdbc/core/parsing/integrate/jaxb/condition/Value.java

@@ -39,11 +39,11 @@ public final class Value {
     private String type;
     
     /**
-     * Get value with type.
+     * Get literal for accurate type.
      * 
-     * @return value with type
+     * @return literal for accurate type
      */
-    public Comparable<?> getValueWithType() {
+    public Comparable<?> getLiteralForAccurateType() {
         if (boolean.class.getName().equals(type) || Boolean.class.getName().equals(type)) {
             return Boolean.valueOf(literal);
         }

sharding-core/src/test/java/io/shardingjdbc/core/parsing/integrate/jaxb/root/ParserAssert.java

@@ -46,7 +46,7 @@ public final class ParserAssert {
     
     @XmlAttribute
     @XmlList
-    private List<String> parameters;
+    private List<String> parameters = new LinkedList<>();
     
     @XmlElementWrapper
     @XmlElement(name = "table")
@@ -54,22 +54,22 @@ public final class ParserAssert {
     
     @XmlElementWrapper
     @XmlElement(name = "condition") 
-    private List<ConditionAssert> conditions;
+    private List<ConditionAssert> conditions = new LinkedList<>();
     
     @XmlElement
     private SQLTokenAsserts tokens = new SQLTokenAsserts();
     
     @XmlElementWrapper(name = "order-by-columns")
     @XmlElement(name = "order-by-column") 
-    private List<OrderByColumnAssert> orderByColumns;
+    private List<OrderByColumnAssert> orderByColumns = new LinkedList<>();
     
     @XmlElementWrapper(name = "group-by-columns")
     @XmlElement(name = "group-by-column") 
-    private List<GroupByColumnAssert> groupByColumns;
+    private List<GroupByColumnAssert> groupByColumns = new LinkedList<>();
     
     @XmlElementWrapper(name = "aggregation-select-items")
     @XmlElement(name = "aggregation-select-item") 
-    private List<AggregationSelectItemAssert> aggregationSelectItems;
+    private List<AggregationSelectItemAssert> aggregationSelectItems = new LinkedList<>();
     
     @XmlElement 
     private LimitAssert limit;

sharding-core/src/test/resources/parser/select.xml

@@ -54,8 +54,8 @@
             </condition>
         </conditions>
     </parser-assert>
-    
-    <!-- // TODO 这里可优化，将两个字段AND = 替换为永false -->
+
+    <!-- // TODO 这里可优化，将两个字段AND = 替换为永false, 目前因为condition是map，同样的column会覆盖 -->
     <parser-assert sql-case-id="assertSelectEqualsWithSameShardingColumns" parameters="1 2">
         <tables>
             <table name="t_order" />
@@ -64,9 +64,6 @@
             <table-token begin-position="14" original-literals="t_order" />
         </tokens>
         <conditions>
-            <condition column-name="order_id" table-name="t_order" operator="EQUAL">
-                <value index="0" literal="1" type="int" />
-            </condition>
             <condition column-name="order_id" table-name="t_order" operator="EQUAL">
                 <value index="1" literal="2" type="int" />
             </condition>
@@ -120,7 +117,7 @@
         </order-by-columns>
     </parser-assert>
     
-    <!-- // TODO 目前对于IN多结果不同做到交集处理 仅仅是简单的加入 -->
+    <!-- // TODO 目前对于IN多结果不同做到交集处理 仅仅是简单的加入, 目前因为condition是map，同样的column会覆盖 -->
     <parser-assert sql-case-id="assertSelectInWithSameShardingColumns" parameters="100 1001 1001 1002">
         <tables>
             <table name="t_order" />
@@ -129,10 +126,6 @@
             <table-token begin-position="14" original-literals="t_order" />
         </tokens>
         <conditions>
-            <condition column-name="order_id" table-name="t_order" operator="IN">
-                <value index="0" literal="1000" type="int" />
-                <value index="1" literal="1001" type="int" />
-            </condition>
             <condition column-name="order_id" table-name="t_order" operator="IN">
                 <value index="2" literal="1001" type="int" />
                 <value index="3" literal="1002" type="int" />