/*
* Copyright 1999-2015 dangdang.com.
* <p>
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
* </p>
*/
package com.dangdang.ddframe.rdb.sharding.parser;
import com.dangdang.ddframe.rdb.sharding.parser.jaxb.Assert;
import com.dangdang.ddframe.rdb.sharding.parser.jaxb.Asserts;
import com.dangdang.ddframe.rdb.sharding.parser.jaxb.Value;
import com.dangdang.ddframe.rdb.sharding.parser.result.SQLParsedResult;
import com.dangdang.ddframe.rdb.sharding.parser.result.merger.AggregationColumn;
import com.dangdang.ddframe.rdb.sharding.parser.result.merger.AggregationColumn.AggregationType;
import com.dangdang.ddframe.rdb.sharding.parser.result.merger.GroupByColumn;
import com.dangdang.ddframe.rdb.sharding.parser.result.merger.Limit;
import com.dangdang.ddframe.rdb.sharding.parser.result.merger.MergeContext;
import com.dangdang.ddframe.rdb.sharding.parser.result.merger.OrderByColumn;
import com.dangdang.ddframe.rdb.sharding.parser.result.merger.OrderByColumn.OrderByType;
import com.dangdang.ddframe.rdb.sharding.parser.result.router.Condition;
import com.dangdang.ddframe.rdb.sharding.parser.result.router.Condition.BinaryOperator;
import com.dangdang.ddframe.rdb.sharding.parser.result.router.Condition.Column;
import com.dangdang.ddframe.rdb.sharding.parser.result.router.ConditionContext;
import com.dangdang.ddframe.rdb.sharding.parser.result.router.Table;
import com.google.common.base.Function;
import com.google.common.base.Optional;
import com.google.common.base.Strings;
import com.google.common.collect.Lists;
import lombok.AccessLevel;
import lombok.Getter;
import org.mockito.internal.matchers.apachecommons.ReflectionEquals;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import java.io.File;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertThat;
public abstract class AbstractBaseParseTest {
@Getter(AccessLevel.PROTECTED)
private final String testCaseName;
@Getter(AccessLevel.PROTECTED)
private final String sql;
private final String expectedSQL;
private final Iterator<Table> expectedTables;
private final Iterator<ConditionContext> expectedConditionContexts;
private final Iterator<OrderByColumn> orderByColumns;
private final Iterator<GroupByColumn> groupByColumns;
private final Iterator<AggregationColumn> aggregationColumns;
private final Limit limit;
protected AbstractBaseParseTest(final String testCaseName, final String sql, final String expectedSQL,
final Collection<Table> expectedTables, final Collection<ConditionContext> expectedConditionContext, final MergeContext expectedMergeContext) {
this.testCaseName = testCaseName;
this.sql = sql;
this.expectedSQL = expectedSQL;
this.expectedTables = expectedTables.iterator();
this.expectedConditionContexts = expectedConditionContext.iterator();
this.orderByColumns = expectedMergeContext.getOrderByColumns().iterator();
this.groupByColumns = expectedMergeContext.getGroupByColumns().iterator();
this.aggregationColumns = expectedMergeContext.getAggregationColumns().iterator();
this.limit = expectedMergeContext.getLimit();
}
protected static Collection<Object[]> dataParameters(final String path) {
Collection<Object[]> result = new ArrayList<>();
for (File each : new File(AbstractBaseParseTest.class.getClassLoader().getResource(path).getPath()).listFiles()) {
result.addAll(dataParameters(each));
}
return result;
}
private static Collection<Object[]> dataParameters(final File file) {
Asserts asserts = loadAsserts(file);
Object[][] result = new Object[asserts.getAsserts().size()][6];
for (int i = 0; i < asserts.getAsserts().size(); i++) {
result[i] = getDataParameter(asserts.getAsserts().get(i));
}
return Arrays.asList(result);
}
private static Asserts loadAsserts(final File file) {
try {
return (Asserts) JAXBContext.newInstance(Asserts.class).createUnmarshaller().unmarshal(file);
} catch (final JAXBException ex) {
throw new RuntimeException(ex);
}
}
private static Object[] getDataParameter(final Assert assertObj) {
Object[] result = new Object[6];
result[0] = assertObj.getId();
result[1] = assertObj.getSql();
result[2] = assertObj.getExpectedSQL();
result[3] = Lists.transform(assertObj.getTables(), new Function<com.dangdang.ddframe.rdb.sharding.parser.jaxb.Table, Table>() {
@Override
public Table apply(final com.dangdang.ddframe.rdb.sharding.parser.jaxb.Table input) {
return new Table(input.getName(), input.getAlias());
}
});
if (null == assertObj.getConditionContexts()) {
result[4] = Collections.<ConditionContext>emptyList();
} else {
result[4] = Lists.transform(assertObj.getConditionContexts(), new Function<com.dangdang.ddframe.rdb.sharding.parser.jaxb.ConditionContext, ConditionContext>() {
@Override
public ConditionContext apply(final com.dangdang.ddframe.rdb.sharding.parser.jaxb.ConditionContext input) {
ConditionContext result = new ConditionContext();
if (null == input.getConditions()) {
return result;
}
for (com.dangdang.ddframe.rdb.sharding.parser.jaxb.Condition each : input.getConditions()) {
Condition condition = new Condition(new Column(each.getColumnName(), each.getTableName()), BinaryOperator.valueOf(each.getOperator().toUpperCase()));
condition.getValues().addAll(Lists.transform(each.getValues(), new Function<Value, Comparable<?>>() {
@Override
public Comparable<?> apply(final Value input) {
return input.getValueWithType();
}
}));
if (null != each.getValueIndices()) {
condition.getValueIndices().addAll(each.getValueIndices());
}
result.add(condition);
}
return result;
}
});
}
MergeContext mergeContext = new MergeContext();
if (null != assertObj.getOrderByColumns()) {
mergeContext.getOrderByColumns().addAll(Lists.transform(assertObj.getOrderByColumns(), new Function<com.dangdang.ddframe.rdb.sharding.parser.jaxb.OrderByColumn, OrderByColumn>() {
@Override
public OrderByColumn apply(final com.dangdang.ddframe.rdb.sharding.parser.jaxb.OrderByColumn input) {
return Strings.isNullOrEmpty(input.getName()) ? new OrderByColumn(input.getIndex(), OrderByType.valueOf(input.getOrderByType().toUpperCase()))
: new OrderByColumn(Optional.fromNullable(input.getOwner()), input.getName(),
Optional.fromNullable(input.getAlias()), OrderByType.valueOf(input.getOrderByType().toUpperCase()));
}
}));
}
if (null != assertObj.getGroupByColumns()) {
mergeContext.getGroupByColumns().addAll(Lists.transform(assertObj.getGroupByColumns(), new Function<com.dangdang.ddframe.rdb.sharding.parser.jaxb.GroupByColumn, GroupByColumn>() {
@Override
public GroupByColumn apply(final com.dangdang.ddframe.rdb.sharding.parser.jaxb.GroupByColumn input) {
return new GroupByColumn(
Optional.fromNullable(input.getOwner()), input.getName(), Optional.fromNullable(input.getAlias()), OrderByType.valueOf(input.getOrderByType().toUpperCase()));
}
}));
}
if (null != assertObj.getAggregationColumns()) {
mergeContext.getAggregationColumns().addAll(Lists.transform(assertObj.getAggregationColumns(),
new Function<com.dangdang.ddframe.rdb.sharding.parser.jaxb.AggregationColumn, AggregationColumn>() {
@Override
public AggregationColumn apply(final com.dangdang.ddframe.rdb.sharding.parser.jaxb.AggregationColumn input) {
AggregationColumn result = new AggregationColumn(input.getExpression(),
AggregationType.valueOf(input.getAggregationType().toUpperCase()), Optional.fromNullable(input.getAlias()), Optional.fromNullable(input.getOption()));
if (null != input.getIndex()) {
result.setColumnIndex(input.getIndex());
}
for (com.dangdang.ddframe.rdb.sharding.parser.jaxb.AggregationColumn each : input.getDerivedColumns()) {
result.getDerivedColumns().add(new AggregationColumn(each.getExpression(),
AggregationType.valueOf(each.getAggregationType().toUpperCase()), Optional.fromNullable(each.getAlias()), Optional.fromNullable(each.getOption())));
}
return result;
}
}));
}
if (null != assertObj.getLimit()) {
mergeContext.setLimit(
new Limit(assertObj.getLimit().getOffset(), assertObj.getLimit().getRowCount(), assertObj.getLimit().getOffsetParameterIndex(), assertObj.getLimit().getRowCountParameterIndex()));
}
result[5] = mergeContext;
return result;
}
protected final void assertSQLParsedResult(final SQLParsedResult actual) {
assertRouteContext(actual);
assertConditionContexts(actual);
assertMergeContext(actual);
}
private void assertRouteContext(final SQLParsedResult actual) {
assertThat(actual.getRouteContext().getSqlBuilder().toString(), is(expectedSQL));
for (Table each : actual.getRouteContext().getTables()) {
assertThat(each, new ReflectionEquals(expectedTables.next()));
}
assertFalse(expectedTables.hasNext());
}
private void assertConditionContexts(final SQLParsedResult actual) {
for (ConditionContext each : actual.getConditionContexts()) {
assertThat(each, is(new ReflectionEquals(expectedConditionContexts.next())));
}
assertFalse(expectedConditionContexts.hasNext());
}
private void assertMergeContext(final SQLParsedResult actual) {
for (OrderByColumn each : actual.getMergeContext().getOrderByColumns()) {
assertThat(each, new ReflectionEquals(orderByColumns.next()));
}
assertFalse(orderByColumns.hasNext());
for (GroupByColumn each : actual.getMergeContext().getGroupByColumns()) {
assertThat(each, new ReflectionEquals(groupByColumns.next()));
}
assertFalse(groupByColumns.hasNext());
for (AggregationColumn each : actual.getMergeContext().getAggregationColumns()) {
AggregationColumn expected = aggregationColumns.next();
assertThat(each, new ReflectionEquals(expected, "derivedColumns"));
for (int i = 0; i < each.getDerivedColumns().size(); i++) {
assertThat(each.getDerivedColumns().get(i), new ReflectionEquals(expected.getDerivedColumns().get(i)));
}
}
assertFalse(aggregationColumns.hasNext());
assertThat(actual.getMergeContext().getLimit(), new ReflectionEquals(limit));
}
}