for #660: refactor assert SQL token

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

@@ -19,31 +19,12 @@ package io.shardingjdbc.core.parsing.integrate.asserts;
 
 import io.shardingjdbc.core.constant.DatabaseType;
 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;
-import io.shardingjdbc.core.parsing.integrate.jaxb.token.ItemsTokenAssert;
-import io.shardingjdbc.core.parsing.integrate.jaxb.token.MultipleInsertValuesTokenAssert;
-import io.shardingjdbc.core.parsing.integrate.jaxb.token.OffsetTokenAssert;
-import io.shardingjdbc.core.parsing.integrate.jaxb.token.OrderByTokenAssert;
-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.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.token.GeneratedKeyToken;
-import io.shardingjdbc.core.parsing.parser.token.IndexToken;
-import io.shardingjdbc.core.parsing.parser.token.ItemsToken;
-import io.shardingjdbc.core.parsing.parser.token.MultipleInsertValuesToken;
-import io.shardingjdbc.core.parsing.parser.token.OffsetToken;
-import io.shardingjdbc.core.parsing.parser.token.OrderByToken;
-import io.shardingjdbc.core.parsing.parser.token.RowCountToken;
-import io.shardingjdbc.core.parsing.parser.token.SQLToken;
-import io.shardingjdbc.core.parsing.parser.token.TableToken;
 import org.apache.commons.lang3.builder.EqualsBuilder;
 
-import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
 
@@ -53,72 +34,6 @@ import static org.junit.Assert.assertTrue;
 
 public class ParserAssertHelper {
     
-    public static void assertSqlTokens(final List<SQLTokenAssert> expected, final List<SQLToken> actual, final boolean isPreparedStatement) {
-        if (null == expected || expected.size() == 0) {
-            return;
-        }
-        List<SQLToken> expectedSqlTokens = buildExpectedSqlTokens(expected, isPreparedStatement);
-        assertTrue(expectedSqlTokens.size() == actual.size());
-        for (SQLToken each : actual) {
-            boolean hasData = false;
-            for (SQLToken sqlToken : expectedSqlTokens) {
-                if (each.getBeginPosition() == sqlToken.getBeginPosition()) {
-                    hasData = true;
-                    assertTrue(EqualsBuilder.reflectionEquals(sqlToken, each));
-                }
-            }
-            assertTrue(hasData);
-        }
-    }
-    
-    private static List<SQLToken> buildExpectedSqlTokens(final List<SQLTokenAssert> sqlTokens,
-            final boolean isPreparedStatement) {
-        List<SQLToken> result = new ArrayList<>(sqlTokens.size());
-        for (SQLTokenAssert each : sqlTokens) {
-            if (isPreparedStatement && (each instanceof OffsetTokenAssert 
-                    || each instanceof RowCountTokenAssert)) {
-                continue;
-            }
-            result.add(buildExpectedSQLToken(each, isPreparedStatement));
-        }
-        return result;
-    }
-    
-    private static SQLToken buildExpectedSQLToken(final SQLTokenAssert sqlToken, final boolean isPreparedStatement) {
-        if (sqlToken instanceof TableTokenAssert) {
-            return new TableToken(sqlToken.getBeginPosition(), ((TableTokenAssert) sqlToken).getOriginalLiterals());
-        }
-        if (sqlToken instanceof IndexTokenAssert) {
-            return new IndexToken(sqlToken.getBeginPosition(), ((IndexTokenAssert) sqlToken).getOriginalLiterals(), 
-                    ((IndexTokenAssert) sqlToken).getTableName());
-        } else if (sqlToken instanceof ItemsTokenAssert) {
-            ItemsToken itemsToken = new ItemsToken(sqlToken.getBeginPosition());
-            itemsToken.getItems().addAll(((ItemsTokenAssert) sqlToken).getItems());
-            return itemsToken;
-        } else if (sqlToken instanceof GeneratedKeyTokenAssert) {
-            if (isPreparedStatement) {
-                return new GeneratedKeyToken(((GeneratedKeyTokenAssert) sqlToken).getBeginPositionOfPreparedStatement());
-            } else {
-                return new GeneratedKeyToken(((GeneratedKeyTokenAssert) sqlToken).getBeginPositionOfStatement());
-            }
-        } else if (sqlToken instanceof MultipleInsertValuesTokenAssert) {
-            MultipleInsertValuesToken multipleInsertValuesToken = new MultipleInsertValuesToken(sqlToken.getBeginPosition());
-            multipleInsertValuesToken.getValues().addAll(((MultipleInsertValuesTokenAssert) sqlToken).getValues());
-            return multipleInsertValuesToken;
-        } else if (sqlToken instanceof RowCountTokenAssert) {
-            return new RowCountToken(sqlToken.getBeginPosition(), ((RowCountTokenAssert) sqlToken).getRowCount());
-        } else if (sqlToken instanceof OrderByTokenAssert) {
-            if (isPreparedStatement) {
-                return new OrderByToken(((OrderByTokenAssert) sqlToken).getBeginPositionOfPreparedStatement());
-            } else {
-                return new OrderByToken(((OrderByTokenAssert) sqlToken).getBeginPositionOfStatement());
-            }
-        } else if (sqlToken instanceof OffsetTokenAssert) {
-            return new OffsetToken(sqlToken.getBeginPosition(), ((OffsetTokenAssert) sqlToken).getOffset());
-        }
-        return null;
-    }
-    
     public static void assertLimit(final LimitAssert limit, final Limit actual, final boolean isPreparedStatement) {
         Limit expected = buildExpectedLimit(limit, isPreparedStatement);
         if (null == expected) {

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

@@ -26,6 +26,15 @@ 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.integrate.jaxb.token.GeneratedKeyTokenAssert;
+import io.shardingjdbc.core.parsing.integrate.jaxb.token.IndexTokenAssert;
+import io.shardingjdbc.core.parsing.integrate.jaxb.token.ItemsTokenAssert;
+import io.shardingjdbc.core.parsing.integrate.jaxb.token.MultipleInsertValuesTokenAssert;
+import io.shardingjdbc.core.parsing.integrate.jaxb.token.OffsetTokenAssert;
+import io.shardingjdbc.core.parsing.integrate.jaxb.token.OrderByTokenAssert;
+import io.shardingjdbc.core.parsing.integrate.jaxb.token.RowCountTokenAssert;
+import io.shardingjdbc.core.parsing.integrate.jaxb.token.SQLTokenAsserts;
+import io.shardingjdbc.core.parsing.integrate.jaxb.token.TableTokenAssert;
 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;
@@ -33,18 +42,29 @@ 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;
 import io.shardingjdbc.core.parsing.parser.sql.dql.select.SelectStatement;
+import io.shardingjdbc.core.parsing.parser.token.GeneratedKeyToken;
+import io.shardingjdbc.core.parsing.parser.token.IndexToken;
+import io.shardingjdbc.core.parsing.parser.token.ItemsToken;
+import io.shardingjdbc.core.parsing.parser.token.MultipleInsertValuesToken;
+import io.shardingjdbc.core.parsing.parser.token.OffsetToken;
+import io.shardingjdbc.core.parsing.parser.token.OrderByToken;
+import io.shardingjdbc.core.parsing.parser.token.RowCountToken;
+import io.shardingjdbc.core.parsing.parser.token.SQLToken;
+import io.shardingjdbc.core.parsing.parser.token.TableToken;
 import io.shardingjdbc.test.sql.SQLCasesLoader;
 import lombok.RequiredArgsConstructor;
 import org.junit.Test;
 import org.junit.runners.Parameterized.Parameters;
 
 import java.lang.reflect.Field;
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.List;
 import java.util.Map;
 
 import static org.hamcrest.CoreMatchers.is;
+import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertThat;
 import static org.junit.Assert.assertTrue;
 
@@ -75,34 +95,35 @@ public final class IntegrateSupportedSQLParsingTest extends AbstractBaseIntegrat
         assertSQLStatement(new SQLParsingEngine(databaseType, sqlCasesLoader.getSupportedPlaceholderSQL(sqlCaseId), getShardingRule()).parse(), true);
     }
     
-    private void assertSQLStatement(final SQLStatement actual, final boolean isPreparedStatement) throws NoSuchFieldException, IllegalAccessException {
+    private void assertSQLStatement(final SQLStatement actual, final boolean withPlaceholder) throws NoSuchFieldException, IllegalAccessException {
         ParserAssert parserAssert = parserAssertsLoader.getParserAssert(sqlCaseId);
         assertTables(actual.getTables(), parserAssert.getTables());
         assertConditions(actual.getConditions(), parserAssert.getConditions());
+        assertSQLTokens(actual.getSqlTokens(), parserAssert.getTokens(), withPlaceholder);
+        
         
         
-        ParserAssertHelper.assertSqlTokens(parserAssert.getTokens().getTokenAsserts(), actual.getSqlTokens(), isPreparedStatement);
         if (actual instanceof SelectStatement) {
             SelectStatement selectStatement = (SelectStatement) actual;
             SelectStatement expectedSqlStatement = ParserJAXBHelper.getSelectStatement(parserAssert);
             ParserAssertHelper.assertOrderBy(expectedSqlStatement.getOrderByItems(), selectStatement.getOrderByItems());
             ParserAssertHelper.assertGroupBy(expectedSqlStatement.getGroupByItems(), selectStatement.getGroupByItems());
             ParserAssertHelper.assertAggregationSelectItem(expectedSqlStatement.getAggregationSelectItems(), selectStatement.getAggregationSelectItems());
-            ParserAssertHelper.assertLimit(parserAssert.getLimit(), selectStatement.getLimit(), isPreparedStatement);
+            ParserAssertHelper.assertLimit(parserAssert.getLimit(), selectStatement.getLimit(), withPlaceholder);
         }
     }
     
     private void assertTables(final Tables actual, final List<TableAssert> expected) {
         assertThat(actual.getTableNames().size(), is(expected.size()));
         for (TableAssert each : expected) {
-            Optional<Table> tableOptional;
+            Optional<Table> table;
             if (null != each.getAlias()) {
-                tableOptional = actual.find(each.getAlias());
+                table = actual.find(each.getAlias());
             } else {
-                tableOptional = actual.find(each.getName());
+                table = actual.find(each.getName());
             }
-            assertTrue(tableOptional.isPresent());
-            assertTable(tableOptional.get(), each);
+            assertTrue(table.isPresent());
+            assertTable(table.get(), each);
         }
     }
     
@@ -114,9 +135,9 @@ public final class IntegrateSupportedSQLParsingTest extends AbstractBaseIntegrat
     private void assertConditions(final Conditions actual, final List<ConditionAssert> expected) throws NoSuchFieldException, IllegalAccessException {
         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);
+            Optional<Condition> condition = actual.find(new Column(each.getColumnName(), each.getTableName()));
+            assertTrue(condition.isPresent());
+            assertCondition(condition.get(), each);
         }
     }
     
@@ -143,4 +164,209 @@ public final class IntegrateSupportedSQLParsingTest extends AbstractBaseIntegrat
         field.setAccessible(true);
         return field.get(actual);
     }
+    
+    private void assertSQLTokens(final List<SQLToken> actual, final SQLTokenAsserts expected, final boolean withPlaceholder) {
+        assertTableTokens(actual, expected);
+        assertIndexToken(actual, expected);
+        assertItemsToken(actual, expected);
+        assertGeneratedKeyToken(actual, expected, withPlaceholder);
+        assertMultipleInsertValuesToken(actual, expected);
+        assertOrderByToken(actual, expected, withPlaceholder);
+        // TODO fix offset and row count
+//        assertOffsetToken(actual, expected);
+//        assertRowCountToken(actual, expected);
+    }
+    
+    private void assertTableTokens(final List<SQLToken> actual, final SQLTokenAsserts expected) {
+        List<TableToken> tableTokens = getTableTokens(actual);
+        assertThat(tableTokens.size(), is(expected.getTableTokens().size()));
+        int count = 0;
+        for (TableTokenAssert each : expected.getTableTokens()) {
+            assertTableToken(tableTokens.get(count), each);
+            count++;
+        }
+    }
+    
+    private void assertTableToken(final TableToken actual, final TableTokenAssert expected) {
+        assertThat(actual.getBeginPosition(), is(expected.getBeginPosition()));
+        assertThat(actual.getOriginalLiterals(), is(expected.getOriginalLiterals()));
+    }
+    
+    private List<TableToken> getTableTokens(final List<SQLToken> actual) {
+        List<TableToken> result = new ArrayList<>(actual.size());
+        for (SQLToken each : actual) {
+            if (each instanceof TableToken) {
+                result.add((TableToken) each);
+            }
+        }
+        return result;
+    }
+    
+    private void assertIndexToken(final List<SQLToken> actual, final SQLTokenAsserts expected) {
+        Optional<IndexToken> indexToken = getIndexToken(actual);
+        if (indexToken.isPresent()) {
+            assertIndexToken(indexToken.get(), expected.getIndexToken());
+        } else {
+            assertNull(expected.getIndexToken());
+        }
+    }
+    
+    private void assertIndexToken(final IndexToken actual, final IndexTokenAssert expected) {
+        assertThat(actual.getBeginPosition(), is(expected.getBeginPosition()));
+        assertThat(actual.getOriginalLiterals(), is(expected.getOriginalLiterals()));
+        assertThat(actual.getTableName(), is(expected.getTableName()));
+    }
+    
+    private Optional<IndexToken> getIndexToken(final List<SQLToken> actual) {
+        for (SQLToken each : actual) {
+            if (each instanceof IndexToken) {
+                return Optional.of((IndexToken) each);
+            }
+        }
+        return Optional.absent();
+    }
+    
+    private void assertItemsToken(final List<SQLToken> actual, final SQLTokenAsserts expected) {
+        Optional<ItemsToken> itemsToken = getItemsToken(actual);
+        if (itemsToken.isPresent()) {
+            assertItemsToken(itemsToken.get(), expected.getItemsToken());
+        } else {
+            assertNull(expected.getItemsToken());
+        }
+    }
+    
+    private void assertItemsToken(final ItemsToken actual, final ItemsTokenAssert expected) {
+        assertThat(actual.getBeginPosition(), is(expected.getBeginPosition()));
+        assertThat(actual.getItems(), is(expected.getItems()));
+    }
+    
+    private Optional<ItemsToken> getItemsToken(final List<SQLToken> actual) {
+        for (SQLToken each : actual) {
+            if (each instanceof ItemsToken) {
+                return Optional.of((ItemsToken) each);
+            }
+        }
+        return Optional.absent();
+    }
+    
+    private void assertGeneratedKeyToken(final List<SQLToken> actual, final SQLTokenAsserts expected, final boolean withPlaceholder) {
+        Optional<GeneratedKeyToken> generatedKeyToken = getGeneratedKeyToken(actual);
+        if (generatedKeyToken.isPresent()) {
+            assertGeneratedKeyToken(generatedKeyToken.get(), expected.getGeneratedKeyToken(), withPlaceholder);
+        } else {
+            assertNull(expected.getGeneratedKeyToken());
+        }
+    }
+    
+    private void assertGeneratedKeyToken(final GeneratedKeyToken actual, final GeneratedKeyTokenAssert expected, final boolean withPlaceholder) {
+        if (withPlaceholder) {
+            assertThat(actual.getBeginPosition(), is(expected.getBeginPositionWithPlaceholder()));
+        } else {
+            assertThat(actual.getBeginPosition(), is(expected.getBeginPositionWithoutPlaceholder()));
+        }
+    }
+    
+    private Optional<GeneratedKeyToken> getGeneratedKeyToken(final List<SQLToken> actual) {
+        for (SQLToken each : actual) {
+            if (each instanceof GeneratedKeyToken) {
+                return Optional.of((GeneratedKeyToken) each);
+            }
+        }
+        return Optional.absent();
+    }
+    
+    private void assertMultipleInsertValuesToken(final List<SQLToken> actual, final SQLTokenAsserts expected) {
+        Optional<MultipleInsertValuesToken> multipleInsertValuesToken = getMultipleInsertValuesToken(actual);
+        if (multipleInsertValuesToken.isPresent()) {
+            assertMultipleInsertValuesToken(multipleInsertValuesToken.get(), expected.getMultipleInsertValuesToken());
+        } else {
+            assertNull(expected.getMultipleInsertValuesToken());
+        }
+    }
+    
+    private void assertMultipleInsertValuesToken(final MultipleInsertValuesToken actual, final MultipleInsertValuesTokenAssert expected) {
+        assertThat(actual.getBeginPosition(), is(expected.getBeginPosition()));
+        assertThat(actual.getValues(), is(expected.getValues()));
+    }
+    
+    private Optional<MultipleInsertValuesToken> getMultipleInsertValuesToken(final List<SQLToken> actual) {
+        for (SQLToken each : actual) {
+            if (each instanceof MultipleInsertValuesToken) {
+                return Optional.of((MultipleInsertValuesToken) each);
+            }
+        }
+        return Optional.absent();
+    }
+    
+    private void assertOrderByToken(final List<SQLToken> actual, final SQLTokenAsserts expected, final boolean withPlaceholder) {
+        Optional<OrderByToken> orderByToken = getOrderByToken(actual);
+        if (orderByToken.isPresent()) {
+            assertOrderByToken(orderByToken.get(), expected.getOrderByToken(), withPlaceholder);
+        } else {
+            assertNull(expected.getOrderByToken());
+        }
+    }
+    
+    private void assertOrderByToken(final OrderByToken actual, final OrderByTokenAssert expected, final boolean withPlaceholder) {
+        if (withPlaceholder) {
+            assertThat(actual.getBeginPosition(), is(expected.getBeginPositionWithPlaceholder()));
+        } else {
+            assertThat(actual.getBeginPosition(), is(expected.getBeginPositionWithoutPlaceholder()));
+        }
+    }
+    
+    private Optional<OrderByToken> getOrderByToken(final List<SQLToken> actual) {
+        for (SQLToken each : actual) {
+            if (each instanceof OrderByToken) {
+                return Optional.of((OrderByToken) each);
+            }
+        }
+        return Optional.absent();
+    }
+    
+    private void assertOffsetToken(final List<SQLToken> actual, final SQLTokenAsserts expected) {
+        Optional<OffsetToken> offsetToken = getOffsetToken(actual);
+        if (offsetToken.isPresent()) {
+            assertOffsetToken(offsetToken.get(), expected.getOffsetToken());
+        } else {
+            assertNull(expected.getOffsetToken());
+        }
+    }
+    
+    private void assertOffsetToken(final OffsetToken actual, final OffsetTokenAssert expected) {
+        assertThat(actual.getBeginPosition(), is(expected.getBeginPosition()));
+        assertThat(actual.getOffset(), is(expected.getOffset()));
+    }
+    
+    private Optional<OffsetToken> getOffsetToken(final List<SQLToken> actual) {
+        for (SQLToken each : actual) {
+            if (each instanceof OffsetToken) {
+                return Optional.of((OffsetToken) each);
+            }
+        }
+        return Optional.absent();
+    }
+    
+    private void assertRowCountToken(final List<SQLToken> actual, final SQLTokenAsserts expected) {
+        Optional<RowCountToken> rowCountToken = getRowCountToken(actual);
+        if (rowCountToken.isPresent()) {
+            assertRowCountToken(rowCountToken.get(), expected.getRowCountToken());
+        } else {
+            assertNull(expected.getRowCountToken());
+        }
+    }
+    
+    private void assertRowCountToken(final RowCountToken actual, final RowCountTokenAssert expected) {
+        assertThat(actual.getBeginPosition(), is(expected.getBeginPosition()));
+        assertThat(actual.getRowCount(), is(expected.getRowCount()));
+    }
+    
+    private Optional<RowCountToken> getRowCountToken(final List<SQLToken> actual) {
+        for (SQLToken each : actual) {
+            if (each instanceof RowCountToken) {
+                return Optional.of((RowCountToken) each);
+            }
+        }
+        return Optional.absent();
+    }
 }

sharding-core/src/test/java/io/shardingjdbc/core/parsing/integrate/jaxb/token/GeneratedKeyTokenAssert.java

@@ -27,11 +27,11 @@ import javax.xml.bind.annotation.XmlAttribute;
 @Getter
 @Setter
 @XmlAccessorType(XmlAccessType.FIELD)
-public final class GeneratedKeyTokenAssert extends SQLTokenAssert {
+public final class GeneratedKeyTokenAssert implements SQLTokenAssert {
     
-    @XmlAttribute(name = "begin-position-of-statement")
-    private int beginPositionOfStatement;
+    @XmlAttribute(name = "begin-position-with-placeholder")
+    private int beginPositionWithPlaceholder;
     
-    @XmlAttribute(name = "begin-position-of-prepared-statement")
-    private int beginPositionOfPreparedStatement;
+    @XmlAttribute(name = "begin-position-without-placeholder")
+    private int beginPositionWithoutPlaceholder;
 }

sharding-core/src/test/java/io/shardingjdbc/core/parsing/integrate/jaxb/token/IndexTokenAssert.java

@@ -27,7 +27,10 @@ import javax.xml.bind.annotation.XmlAttribute;
 @Getter
 @Setter
 @XmlAccessorType(XmlAccessType.FIELD)
-public final class IndexTokenAssert extends SQLTokenAssert {
+public final class IndexTokenAssert implements SQLTokenAssert {
+    
+    @XmlAttribute(name = "begin-position")
+    private int beginPosition;
     
     @XmlAttribute(name = "original-literals")
     private String originalLiterals;

sharding-core/src/test/java/io/shardingjdbc/core/parsing/integrate/jaxb/token/ItemsTokenAssert.java

@@ -22,6 +22,7 @@ import lombok.Setter;
 
 import javax.xml.bind.annotation.XmlAccessType;
 import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
 import javax.xml.bind.annotation.XmlElement;
 import javax.xml.bind.annotation.XmlElementWrapper;
 import java.util.LinkedList;
@@ -30,7 +31,10 @@ import java.util.List;
 @Getter
 @Setter
 @XmlAccessorType(XmlAccessType.FIELD)
-public final class ItemsTokenAssert extends SQLTokenAssert {
+public final class ItemsTokenAssert implements SQLTokenAssert {
+    
+    @XmlAttribute(name = "begin-position")
+    private int beginPosition;
     
     @XmlElementWrapper(name = "items")
     @XmlElement(name = "item")

sharding-core/src/test/java/io/shardingjdbc/core/parsing/integrate/jaxb/token/MultipleInsertValuesTokenAssert.java

@@ -22,6 +22,7 @@ import lombok.Setter;
 
 import javax.xml.bind.annotation.XmlAccessType;
 import javax.xml.bind.annotation.XmlAccessorType;
+import javax.xml.bind.annotation.XmlAttribute;
 import javax.xml.bind.annotation.XmlElement;
 import javax.xml.bind.annotation.XmlElementWrapper;
 import java.util.LinkedList;
@@ -30,7 +31,10 @@ import java.util.List;
 @Getter
 @Setter
 @XmlAccessorType(XmlAccessType.FIELD)
-public final class MultipleInsertValuesTokenAssert extends SQLTokenAssert {
+public final class MultipleInsertValuesTokenAssert implements SQLTokenAssert {
+    
+    @XmlAttribute(name = "begin-position")
+    private int beginPosition;
     
     @XmlElementWrapper(name = "values")
     @XmlElement(name = "value")

sharding-core/src/test/java/io/shardingjdbc/core/parsing/integrate/jaxb/token/OffsetTokenAssert.java

@@ -27,7 +27,10 @@ import javax.xml.bind.annotation.XmlAttribute;
 @Getter
 @Setter
 @XmlAccessorType(XmlAccessType.FIELD)
-public final class OffsetTokenAssert extends SQLTokenAssert {
+public final class OffsetTokenAssert implements SQLTokenAssert {
+    
+    @XmlAttribute(name = "begin-position")
+    private int beginPosition;
     
     @XmlAttribute(name = "offset")
     private int offset;

sharding-core/src/test/java/io/shardingjdbc/core/parsing/integrate/jaxb/token/OrderByTokenAssert.java

@@ -27,11 +27,11 @@ import javax.xml.bind.annotation.XmlAttribute;
 @Getter
 @Setter
 @XmlAccessorType(XmlAccessType.FIELD)
-public final class OrderByTokenAssert extends SQLTokenAssert {
+public final class OrderByTokenAssert implements SQLTokenAssert {
     
-    @XmlAttribute(name = "begin-position-of-statement")
-    private int beginPositionOfStatement;
+    @XmlAttribute(name = "begin-position-with-placeholder")
+    private int beginPositionWithPlaceholder;
     
-    @XmlAttribute(name = "begin-position-of-prepared-statement")
-    private int beginPositionOfPreparedStatement;
+    @XmlAttribute(name = "begin-position-without-placeholder")
+    private int beginPositionWithoutPlaceholder;
 }

sharding-core/src/test/java/io/shardingjdbc/core/parsing/integrate/jaxb/token/RowCountTokenAssert.java

@@ -27,7 +27,10 @@ import javax.xml.bind.annotation.XmlAttribute;
 @Getter
 @Setter
 @XmlAccessorType(XmlAccessType.FIELD)
-public final class RowCountTokenAssert extends SQLTokenAssert {
+public final class RowCountTokenAssert implements SQLTokenAssert {
+    
+    @XmlAttribute(name = "begin-position")
+    private int beginPosition;
     
     @XmlAttribute(name = "row-count")
     private int rowCount;

sharding-core/src/test/java/io/shardingjdbc/core/parsing/integrate/jaxb/token/SQLTokenAssert.java

@@ -17,18 +17,6 @@
 
 package io.shardingjdbc.core.parsing.integrate.jaxb.token;
 
-import lombok.Getter;
-import lombok.Setter;
-
-import javax.xml.bind.annotation.XmlAccessType;
-import javax.xml.bind.annotation.XmlAccessorType;
-import javax.xml.bind.annotation.XmlAttribute;
-
-@Getter
-@Setter
-@XmlAccessorType(XmlAccessType.FIELD)
-public abstract class SQLTokenAssert {
+public interface SQLTokenAssert {
     
-    @XmlAttribute(name = "begin-position")
-    private int beginPosition;
 }

sharding-core/src/test/java/io/shardingjdbc/core/parsing/integrate/jaxb/token/SQLTokenAsserts.java

@@ -32,7 +32,7 @@ import java.util.List;
 public final class SQLTokenAsserts {
     
     @XmlElement(name = "table-token")
-    private List<TableTokenAssert> tableTokens;
+    private List<TableTokenAssert> tableTokens = new LinkedList<>();
     
     @XmlElement(name = "index-token")
     private IndexTokenAssert indexToken;
@@ -54,38 +54,4 @@ public final class SQLTokenAsserts {
     
     @XmlElement(name = "row-count-token")
     private RowCountTokenAssert rowCountToken;
-    
-    /**
-     * Get all SQL token asserts.
-     *
-     * @return all SQL token asserts
-     */
-    public List<SQLTokenAssert> getTokenAsserts() {
-        List<SQLTokenAssert> result = new LinkedList<>();
-        if (null != tableTokens) {
-            result.addAll(tableTokens);
-        }
-        if (null != indexToken) {
-            result.add(indexToken);
-        }
-        if (null != offsetToken) {
-            result.add(offsetToken);
-        }
-        if (null != rowCountToken) {
-            result.add(rowCountToken);
-        }
-        if (null != itemsToken) {
-            result.add(itemsToken);
-        }
-        if (null != generatedKeyToken) {
-            result.add(generatedKeyToken);
-        }
-        if (null != multipleInsertValuesToken) {
-            result.add(multipleInsertValuesToken);
-        }
-        if (null != orderByToken) {
-            result.add(orderByToken);
-        }
-        return result;
-    }
 }

sharding-core/src/test/java/io/shardingjdbc/core/parsing/integrate/jaxb/token/TableTokenAssert.java

@@ -27,7 +27,10 @@ import javax.xml.bind.annotation.XmlAttribute;
 @Getter
 @Setter
 @XmlAccessorType(XmlAccessType.FIELD)
-public final class TableTokenAssert extends SQLTokenAssert {
+public final class TableTokenAssert implements SQLTokenAssert {
+    
+    @XmlAttribute(name = "begin-position")
+    private int beginPosition;
     
     @XmlAttribute(name = "original-literals")
     private String originalLiterals;

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

@@ -31,6 +31,9 @@
         <tables>
             <table name="t_log" />
         </tables>
+        <tokens>
+            <table-token begin-position="11" original-literals="t_log" />
+        </tokens>
     </parser-assert>
     
     <parser-assert sql-case-id="assertDropTableCascade">

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

@@ -65,7 +65,7 @@
                     <item>item_id</item>
                 </items>
             </items-token>
-            <generated-key-token begin-position-of-statement="77" begin-position-of-prepared-statement="73" />
+            <generated-key-token begin-position-with-placeholder="73" begin-position-without-placeholder="77" />
         </tokens>
         <conditions>
             <condition column-name="order_id" table-name="t_order_item" operator="EQUAL">

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

@@ -6,7 +6,7 @@
         </tables>
         <tokens>
             <table-token begin-position="76" original-literals="`t_order_item`" />
-            <order-by-token begin-position-of-statement="162" begin-position-of-prepared-statement="156"/>
+            <order-by-token begin-position-with-placeholder="156" begin-position-without-placeholder="162" />
         </tokens>
         <conditions>
             <condition column-name="order_id" table-name="t_order_item" operator="IN">
@@ -155,7 +155,7 @@
                     <item>o.user_id AS GROUP_BY_DERIVED_0 </item>
                 </items>
             </items-token>
-            <order-by-token begin-position-of-statement="195" begin-position-of-prepared-statement="194" />
+            <order-by-token begin-position-with-placeholder="194" begin-position-without-placeholder="195" />
         </tokens>
         <conditions>
             <condition column-name="user_id" table-name="t_order" operator="IN">
@@ -266,7 +266,7 @@
         </tables>
         <tokens>
             <table-token begin-position="58" original-literals="t_order" />
-            <order-by-token begin-position-of-statement="80" begin-position-of-prepared-statement="80"/>
+            <order-by-token begin-position-with-placeholder="80" begin-position-without-placeholder="80" />
         </tokens>
         <aggregation-select-items>
             <aggregation-select-item inner-expression="(order_id)" aggregation-type="SUM" alias="orders_sum" />