Skip to content

Shardingsphere
Shardingsphere

apache / Shardingsphere

通知 56
Star 3
Fork 0
Shardingsphere
Shardingsphere

前往新版Gitcode，体验更适合开发者的 AI 搜索 >>

提交 6e33a073 编写于 作者: L Liang Zhang 提交者： Juan Pan(Trista)
浏览文件
操作

Remove QueryResult‘s fixture from merge test case (#3661) 

* remove useless throw exception for MergeEngineFactory

* remove useless throw exception for MergeEngineFactoryTest

* decouple MergeEngineFactoryTest and ResultSetBasedQueryResultFixture

* decouple DALMergeEngineTest and ResultSetBasedQueryResultFixture

* decouple ShowCreateTableMergedResultTest and ResultSetBasedQueryResultFixture

* decouple ShowDatabasesMergedResultTest and ResultSetBasedQueryResultFixture

* decouple ShowOtherMergedResultTest and ResultSetBasedQueryResultFixture

* decouple ShowTablesMergedResultTest and ResultSetBasedQueryResultFixture

* refactor LogicTablesMergedResult's constructor

* decouple DQLMergeEngineTest and ResultSetBasedQueryResultFixture

* decouple StreamMergedResultTest and ResultSetBasedQueryResultFixture

* decouple MemoryQueryResultRowTest and ResultSetBasedQueryResultFixture

* decouple MemoryMergedResultTest and ResultSetBasedQueryResultFixture

* decouple GroupByMemoryMergedResultTest and ResultSetBasedQueryResultFixture

* decouple GroupByRowComparatorTest and ResultSetBasedQueryResultFixture

* decouple GroupByStreamMergedResultTest and ResultSetBasedQueryResultFixture

* decouple GroupByValueTest and ResultSetBasedQueryResultFixture

* decouple IteratorStreamMergedResultTest and ResultSetBasedQueryResultFixture

* decouple OrderByStreamMergedResultTest and ResultSetBasedQueryResultFixture

* decouple OrderByValueTest and ResultSetBasedQueryResultFixture

* decouple LimitDecoratorMergedResultTest and ResultSetBasedQueryResultFixture

* decouple RowNumberDecoratorMergedResultTest and ResultSetBasedQueryResultFixture

* decouple TopAndRowNumberDecoratorMergedResultTest and ResultSetBasedQueryResultFixture

* remove ResultSetBasedQueryResultFixture

* decouple DescribeTableMergedResultTest and QueryResultBasedQueryResultFixture

* remove QueryResultBasedQueryResultFixture
上级 26b1ad75
展开全部 隐藏空白更改
内联 并排
Showing with 539 addition and 1337 deletion
sharding-core/sharding-core-merge/src/main/java/org/apache/shardingsphere/core/merge/MergeEngineFactory.java
浏览文件 @ 6e33a073
......@@ -23,13 +23,12 @@ import org.apache.shardingsphere.core.execute.sql.execute.result.QueryResult;
import org.apache.shardingsphere.core.merge.dal.DALMergeEngine;
import org.apache.shardingsphere.core.merge.dql.DQLMergeEngine;
import org.apache.shardingsphere.core.metadata.table.TableMetas;
import org.apache.shardingsphere.sql.parser.relation.statement.impl.SelectSQLStatementContext;
import org.apache.shardingsphere.sql.parser.sql.statement.dal.DALStatement;
import org.apache.shardingsphere.core.route.SQLRouteResult;
import org.apache.shardingsphere.core.rule.ShardingRule;
import org.apache.shardingsphere.spi.database.DatabaseType;
import org.apache.shardingsphere.sql.parser.relation.statement.impl.SelectSQLStatementContext;
import org.apache.shardingsphere.sql.parser.sql.statement.dal.DALStatement;
import java.sql.SQLException;
import java.util.List;
/**
......@@ -50,10 +49,9 @@ public final class MergeEngineFactory {
* @param tableMetas sharding table meta Data
* @param queryResults query results
* @return merge engine instance
* @throws SQLException SQL exception
*/
public static MergeEngine newInstance(final DatabaseType databaseType, final ShardingRule shardingRule,
final SQLRouteResult routeResult, final TableMetas tableMetas, final List<QueryResult> queryResults) throws SQLException {
final SQLRouteResult routeResult, final TableMetas tableMetas, final List<QueryResult> queryResults) {
if (routeResult.getSqlStatementContext() instanceof SelectSQLStatementContext) {
return new DQLMergeEngine(databaseType, (SelectSQLStatementContext) routeResult.getSqlStatementContext(), queryResults);
}
......
sharding-core/sharding-core-merge/src/main/java/org/apache/shardingsphere/core/merge/dal/DALMergeEngine.java
浏览文件 @ 6e33a073
......@@ -66,16 +66,16 @@ public final class DALMergeEngine implements MergeEngine {
return new ShowDatabasesMergedResult(shardingRule, queryResults);
}
if (dalStatement instanceof ShowTableStatusStatement) {
return new ShowTableStatusMergedResult(shardingRule, queryResults, tableMetas);
return new ShowTableStatusMergedResult(shardingRule, tableMetas, queryResults);
}
if (dalStatement instanceof ShowTablesStatement) {
return new ShowTablesMergedResult(shardingRule, queryResults, tableMetas);
return new ShowTablesMergedResult(shardingRule, tableMetas, queryResults);
}
if (dalStatement instanceof ShowCreateTableStatement) {
return new ShowCreateTableMergedResult(shardingRule, queryResults, tableMetas);
return new ShowCreateTableMergedResult(shardingRule, tableMetas, queryResults);
}
if (dalStatement instanceof ShowIndexStatement) {
return new ShowIndexMergedResult(shardingRule, queryResults, tableMetas);
return new ShowIndexMergedResult(shardingRule, tableMetas, queryResults);
}
if (dalStatement instanceof DescribeStatement) {
return new DescribeTableMergedResult(shardingRule, queryResults, sqlStatementContext);
......
sharding-core/sharding-core-merge/src/main/java/org/apache/shardingsphere/core/merge/dal/show/LogicTablesMergedResult.java
浏览文件 @ 6e33a073
......@@ -42,14 +42,14 @@ public abstract class LogicTablesMergedResult extends MemoryMergedResult {
private final ShardingRule shardingRule;
private final TableMetas tableMetas;
private final Iterator<MemoryQueryResultRow> memoryResultSetRows;
private final Set<String> tableNames = new HashSet<>();
private final TableMetas tableMetas;
public LogicTablesMergedResult(final Map<String, Integer> labelAndIndexMap,
final ShardingRule shardingRule, final List<QueryResult> queryResults, final TableMetas tableMetas) throws SQLException {
final ShardingRule shardingRule, final TableMetas tableMetas, final List<QueryResult> queryResults) throws SQLException {
super(labelAndIndexMap);
this.shardingRule = shardingRule;
this.tableMetas = tableMetas;
......
sharding-core/sharding-core-merge/src/main/java/org/apache/shardingsphere/core/merge/dal/show/ShowCreateTableMergedResult.java
浏览文件 @ 6e33a073
......@@ -41,8 +41,8 @@ public final class ShowCreateTableMergedResult extends LogicTablesMergedResult {
LABEL_AND_INDEX_MAP.put("Create Table", 2);
}
public ShowCreateTableMergedResult(final ShardingRule shardingRule, final List<QueryResult> queryResults, final TableMetas tableMetas) throws SQLException {
super(LABEL_AND_INDEX_MAP, shardingRule, queryResults, tableMetas);
public ShowCreateTableMergedResult(final ShardingRule shardingRule, final TableMetas tableMetas, final List<QueryResult> queryResults) throws SQLException {
super(LABEL_AND_INDEX_MAP, shardingRule, tableMetas, queryResults);
}
@Override
......
sharding-core/sharding-core-merge/src/main/java/org/apache/shardingsphere/core/merge/dal/show/ShowIndexMergedResult.java
浏览文件 @ 6e33a073
......@@ -51,7 +51,7 @@ public final class ShowIndexMergedResult extends LogicTablesMergedResult {
LABEL_AND_INDEX_MAP.put("Index_comment", 13);
}
public ShowIndexMergedResult(final ShardingRule shardingRule, final List<QueryResult> queryResults, final TableMetas tableMetas) throws SQLException {
super(LABEL_AND_INDEX_MAP, shardingRule, queryResults, tableMetas);
public ShowIndexMergedResult(final ShardingRule shardingRule, final TableMetas tableMetas, final List<QueryResult> queryResults) throws SQLException {
super(LABEL_AND_INDEX_MAP, shardingRule, tableMetas, queryResults);
}
}
sharding-core/sharding-core-merge/src/main/java/org/apache/shardingsphere/core/merge/dal/show/ShowTableStatusMergedResult.java
浏览文件 @ 6e33a073
......@@ -55,7 +55,7 @@ public final class ShowTableStatusMergedResult extends LogicTablesMergedResult {
LABEL_AND_INDEX_MAP.put("Comment", 17);
}
public ShowTableStatusMergedResult(final ShardingRule shardingRule, final List<QueryResult> queryResults, final TableMetas tableMetas) throws SQLException {
super(LABEL_AND_INDEX_MAP, shardingRule, queryResults, tableMetas);
public ShowTableStatusMergedResult(final ShardingRule shardingRule, final TableMetas tableMetas, final List<QueryResult> queryResults) throws SQLException {
super(LABEL_AND_INDEX_MAP, shardingRule, tableMetas, queryResults);
}
}
sharding-core/sharding-core-merge/src/main/java/org/apache/shardingsphere/core/merge/dal/show/ShowTablesMergedResult.java
浏览文件 @ 6e33a073
......@@ -41,8 +41,8 @@ public final class ShowTablesMergedResult extends LogicTablesMergedResult {
LABEL_AND_INDEX_MAP.put("Tables_in_" + ShardingConstant.LOGIC_SCHEMA_NAME, 1);
}
public ShowTablesMergedResult(final ShardingRule shardingRule, final List<QueryResult> queryResults, final TableMetas tableMetas) throws SQLException {
super(LABEL_AND_INDEX_MAP, shardingRule, queryResults, tableMetas);
public ShowTablesMergedResult(final ShardingRule shardingRule, final TableMetas tableMetas, final List<QueryResult> queryResults) throws SQLException {
super(LABEL_AND_INDEX_MAP, shardingRule, tableMetas, queryResults);
}
/**
......
sharding-core/sharding-core-merge/src/test/java/org/apache/shardingsphere/core/merge/MergeEngineFactoryTest.java
浏览文件 @ 6e33a073
......@@ -17,13 +17,14 @@
package org.apache.shardingsphere.core.merge;
import com.google.common.collect.Lists;
import org.apache.shardingsphere.core.database.DatabaseTypes;
import org.apache.shardingsphere.core.execute.sql.execute.result.QueryResult;
import org.apache.shardingsphere.core.merge.dal.DALMergeEngine;
import org.apache.shardingsphere.core.merge.dql.DQLMergeEngine;
import org.apache.shardingsphere.core.merge.fixture.ResultSetBasedQueryResultFixture;
import org.apache.shardingsphere.core.metadata.table.TableMetas;
import org.apache.shardingsphere.core.route.SQLRouteResult;
import org.apache.shardingsphere.core.route.router.sharding.condition.ShardingCondition;
import org.apache.shardingsphere.core.route.router.sharding.condition.ShardingConditions;
import org.apache.shardingsphere.sql.parser.relation.segment.select.groupby.GroupByContext;
import org.apache.shardingsphere.sql.parser.relation.segment.select.orderby.OrderByContext;
import org.apache.shardingsphere.sql.parser.relation.segment.select.orderby.OrderByItem;
......@@ -33,9 +34,6 @@ import org.apache.shardingsphere.sql.parser.relation.segment.select.projection.P
import org.apache.shardingsphere.sql.parser.relation.statement.impl.CommonSQLStatementContext;
import org.apache.shardingsphere.sql.parser.relation.statement.impl.InsertSQLStatementContext;
import org.apache.shardingsphere.sql.parser.relation.statement.impl.SelectSQLStatementContext;
import org.apache.shardingsphere.core.route.SQLRouteResult;
import org.apache.shardingsphere.core.route.router.sharding.condition.ShardingCondition;
import org.apache.shardingsphere.core.route.router.sharding.condition.ShardingConditions;
import org.apache.shardingsphere.sql.parser.sql.segment.dml.column.ColumnSegment;
import org.apache.shardingsphere.sql.parser.sql.segment.generic.TableSegment;
import org.apache.shardingsphere.sql.parser.sql.statement.dal.DALStatement;
......@@ -44,11 +42,9 @@ import org.apache.shardingsphere.sql.parser.sql.statement.dml.SelectStatement;
import org.junit.Before;
import org.junit.Test;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import static org.hamcrest.CoreMatchers.instanceOf;
......@@ -58,22 +54,18 @@ import static org.mockito.Mockito.when;
public final class MergeEngineFactoryTest {
private List<QueryResult> queryResults;
private final List<QueryResult> queryResults = new LinkedList<>();
@Before
public void setUp() throws SQLException {
ResultSet resultSet = mock(ResultSet.class);
ResultSetMetaData resultSetMetaData = mock(ResultSetMetaData.class);
when(resultSet.getMetaData()).thenReturn(resultSetMetaData);
when(resultSetMetaData.getColumnCount()).thenReturn(1);
when(resultSetMetaData.getColumnLabel(1)).thenReturn("label");
List<ResultSet> resultSets = Lists.newArrayList(resultSet);
queryResults = new ArrayList<>(resultSets.size());
queryResults.add(new ResultSetBasedQueryResultFixture(resultSets.get(0)));
QueryResult queryResult = mock(QueryResult.class);
when(queryResult.getColumnCount()).thenReturn(1);
when(queryResult.getColumnLabel(1)).thenReturn("label");
queryResults.add(queryResult);
}
@Test
public void assertNewInstanceWithSelectStatement() throws SQLException {
public void assertNewInstanceWithSelectStatement() {
SQLRouteResult routeResult = new SQLRouteResult(
new SelectSQLStatementContext(new SelectStatement(),
new GroupByContext(Collections.<OrderByItem>emptyList(), 0), new OrderByContext(Collections.<OrderByItem>emptyList(), false),
......@@ -83,13 +75,13 @@ public final class MergeEngineFactoryTest {
}
@Test
public void assertNewInstanceWithDALStatement() throws SQLException {
public void assertNewInstanceWithDALStatement() {
SQLRouteResult routeResult = new SQLRouteResult(new CommonSQLStatementContext(new DALStatement()), new ShardingConditions(Collections.<ShardingCondition>emptyList()));
assertThat(MergeEngineFactory.newInstance(DatabaseTypes.getActualDatabaseType("MySQL"), null, routeResult, mock(TableMetas.class), queryResults), instanceOf(DALMergeEngine.class));
}
@Test
public void assertNewInstanceWithOtherStatement() throws SQLException {
public void assertNewInstanceWithOtherStatement() {
InsertStatement insertStatement = new InsertStatement();
insertStatement.getAllSQLSegments().add(new TableSegment(0, 0, "tbl"));
insertStatement.getColumns().add(new ColumnSegment(0, 0, "col"));
......
sharding-core/sharding-core-merge/src/test/java/org/apache/shardingsphere/core/merge/dal/DALMergeEngineTest.java
浏览文件 @ 6e33a073
......@@ -23,7 +23,6 @@ import org.apache.shardingsphere.core.merge.dal.show.ShowCreateTableMergedResult
import org.apache.shardingsphere.core.merge.dal.show.ShowDatabasesMergedResult;
import org.apache.shardingsphere.core.merge.dal.show.ShowOtherMergedResult;
import org.apache.shardingsphere.core.merge.dal.show.ShowTablesMergedResult;
import org.apache.shardingsphere.core.merge.fixture.ResultSetBasedQueryResultFixture;
import org.apache.shardingsphere.sql.parser.relation.statement.SQLStatementContext;
import org.apache.shardingsphere.sql.parser.sql.statement.dal.DALStatement;
import org.apache.shardingsphere.sql.parser.sql.statement.dal.dialect.mysql.DescribeStatement;
......@@ -34,9 +33,8 @@ import org.apache.shardingsphere.sql.parser.sql.statement.dal.dialect.mysql.Show
import org.junit.Before;
import org.junit.Test;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import static org.hamcrest.CoreMatchers.instanceOf;
......@@ -46,12 +44,11 @@ import static org.mockito.Mockito.when;
public final class DALMergeEngineTest {
private List<QueryResult> queryResults;
private List<QueryResult> queryResults = new LinkedList<>();
@Before
public void setUp() {
ResultSet resultSet = mock(ResultSet.class);
queryResults = Collections.<QueryResult>singletonList(new ResultSetBasedQueryResultFixture(resultSet));
queryResults.add(mock(QueryResult.class));
}
@Test
......
sharding-core/sharding-core-merge/src/test/java/org/apache/shardingsphere/core/merge/dal/desc/DescribeTableMergedResultTest.java
浏览文件 @ 6e33a073
......@@ -18,21 +18,16 @@
package org.apache.shardingsphere.core.merge.dal.desc;
import com.google.common.base.Optional;
import com.google.common.collect.Lists;
import org.apache.shardingsphere.core.execute.sql.execute.result.QueryResult;
import org.apache.shardingsphere.core.merge.fixture.QueryResultBasedQueryResultFixture;
import org.apache.shardingsphere.core.rule.EncryptRule;
import org.apache.shardingsphere.core.rule.ShardingRule;
import org.apache.shardingsphere.core.strategy.encrypt.EncryptTable;
import org.apache.shardingsphere.sql.parser.relation.segment.table.TablesContext;
import org.apache.shardingsphere.sql.parser.relation.statement.SQLStatementContext;
import org.junit.Before;
import org.junit.Test;
import java.sql.SQLException;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertFalse;
......@@ -43,127 +38,104 @@ import static org.mockito.Mockito.when;
public final class DescribeTableMergedResultTest {
private List<QueryResult> queryResults;
private SQLStatementContext sqlStatementContext;
@Before
public void setUp() throws SQLException {
sqlStatementContext = mock(SQLStatementContext.class);
TablesContext tablesContext = mock(TablesContext.class);
when(tablesContext.getSingleTableName()).thenReturn("user");
when(sqlStatementContext.getTablesContext()).thenReturn(tablesContext);
List<QueryResult> mockQueryResults = mockQueryResults();
QueryResult queryResult = new QueryResultBasedQueryResultFixture(mockQueryResults.iterator());
queryResults = Lists.newArrayList(queryResult);
}
private List<QueryResult> mockQueryResults() throws SQLException {
List<QueryResult> queryResults = new LinkedList<>();
queryResults.add(mockQueryResult(6, "id", "int(11) unsigned", "NO", "PRI", "", "auto_increment"));
queryResults.add(mockQueryResult(6, "name", "varchar(100)", "YES", "", "", ""));
queryResults.add(mockQueryResult(6, "pre_name", "varchar(100)", "YES", "", "", ""));
queryResults.add(mockQueryResult(6, "name_assisted", "varchar(100)", "YES", "", "", ""));
return queryResults;
}
private QueryResult mockQueryResult(final int columnNum, final String field,
final String type, final String nullValue, final String key, final String defaultValue, final String extra) throws SQLException {
QueryResult queryResult = mock(QueryResult.class);
when(queryResult.getColumnCount()).thenReturn(columnNum);
when(queryResult.getValue(1, String.class)).thenReturn(field);
when(queryResult.getValue(1, Object.class)).thenReturn(field);
when(queryResult.getValue(2, String.class)).thenReturn(type);
when(queryResult.getValue(2, Object.class)).thenReturn(type);
when(queryResult.getValue(3, String.class)).thenReturn(nullValue);
when(queryResult.getValue(3, Object.class)).thenReturn(nullValue);
when(queryResult.getValue(4, String.class)).thenReturn(key);
when(queryResult.getValue(4, Object.class)).thenReturn(key);
when(queryResult.getValue(5, String.class)).thenReturn(defaultValue);
when(queryResult.getValue(5, Object.class)).thenReturn(defaultValue);
when(queryResult.getValue(6, String.class)).thenReturn(extra);
when(queryResult.getValue(6, Object.class)).thenReturn(extra);
return queryResult;
}
@Test
public void assertNextForEmptyQueryResult() throws SQLException {
ShardingRule shardingRule = mock(ShardingRule.class);
List<QueryResult> queryResults = Collections.emptyList();
DescribeTableMergedResult describeTableMergedResult = new DescribeTableMergedResult(shardingRule, queryResults, sqlStatementContext);
assertFalse(describeTableMergedResult.next());
DescribeTableMergedResult actual = new DescribeTableMergedResult(shardingRule, Collections.<QueryResult>emptyList(), createSQLStatementContext());
assertFalse(actual.next());
}
@Test
public void assertFieldWithEncryptRule() throws SQLException {
ShardingRule shardingRule = mockShardingRuleWithEncryptRule();
DescribeTableMergedResult describeTableMergedResult = new DescribeTableMergedResult(shardingRule, queryResults, sqlStatementContext);
assertTrue(describeTableMergedResult.next());
assertThat(describeTableMergedResult.getValue(1, String.class).toString(), is("id"));
assertTrue(describeTableMergedResult.next());
assertThat(describeTableMergedResult.getValue(1, String.class).toString(), is("logic_name"));
assertTrue(describeTableMergedResult.next());
assertThat(describeTableMergedResult.getValue(1, String.class).toString(), is("pre_name"));
assertFalse(describeTableMergedResult.next());
ShardingRule shardingRule = createShardingRuleWithEncryptRule();
DescribeTableMergedResult actual = new DescribeTableMergedResult(shardingRule, Collections.singletonList(createQueryResult()), createSQLStatementContext());
assertTrue(actual.next());
assertThat(actual.getValue(1, String.class).toString(), is("id"));
assertTrue(actual.next());
assertThat(actual.getValue(1, String.class).toString(), is("logic_name"));
assertTrue(actual.next());
assertThat(actual.getValue(1, String.class).toString(), is("pre_name"));
assertFalse(actual.next());
}
@Test
public void assertFieldWithoutEncryptRule() throws SQLException {
ShardingRule shardingRule = mockShardingRuleWithoutEncryptRule();
DescribeTableMergedResult describeTableMergedResult = new DescribeTableMergedResult(shardingRule, queryResults, sqlStatementContext);
assertTrue(describeTableMergedResult.next());
assertThat(describeTableMergedResult.getValue(1, String.class).toString(), is("id"));
assertTrue(describeTableMergedResult.next());
assertThat(describeTableMergedResult.getValue(1, String.class).toString(), is("name"));
assertTrue(describeTableMergedResult.next());
assertThat(describeTableMergedResult.getValue(1, String.class).toString(), is("pre_name"));
assertTrue(describeTableMergedResult.next());
assertThat(describeTableMergedResult.getValue(1, String.class).toString(), is("name_assisted"));
ShardingRule shardingRule = createShardingRuleWithoutEncryptRule();
DescribeTableMergedResult actual = new DescribeTableMergedResult(shardingRule, Collections.singletonList(createQueryResult()), createSQLStatementContext());
assertTrue(actual.next());
assertThat(actual.getValue(1, String.class).toString(), is("id"));
assertTrue(actual.next());
assertThat(actual.getValue(1, String.class).toString(), is("name"));
assertTrue(actual.next());
assertThat(actual.getValue(1, String.class).toString(), is("pre_name"));
assertTrue(actual.next());
assertThat(actual.getValue(1, String.class).toString(), is("name_assisted"));
}
@Test
public void assertAllWithoutEncryptRule() throws SQLException {
ShardingRule shardingRule = mockShardingRuleWithoutEncryptRule();
DescribeTableMergedResult describeTableMergedResult = new DescribeTableMergedResult(shardingRule, queryResults, sqlStatementContext);
assertTrue(describeTableMergedResult.next());
assertThat(describeTableMergedResult.getValue(1, String.class).toString(), is("id"));
assertThat(describeTableMergedResult.getValue(2, String.class).toString(), is("int(11) unsigned"));
assertThat(describeTableMergedResult.getValue(3, String.class).toString(), is("NO"));
assertThat(describeTableMergedResult.getValue(4, String.class).toString(), is("PRI"));
assertThat(describeTableMergedResult.getValue(5, String.class).toString(), is(""));
assertThat(describeTableMergedResult.getValue(6, String.class).toString(), is("auto_increment"));
ShardingRule shardingRule = createShardingRuleWithoutEncryptRule();
DescribeTableMergedResult actual = new DescribeTableMergedResult(shardingRule, Collections.singletonList(createQueryResult()), createSQLStatementContext());
assertTrue(actual.next());
assertThat(actual.getValue(1, String.class).toString(), is("id"));
assertThat(actual.getValue(2, String.class).toString(), is("int(11) unsigned"));
assertThat(actual.getValue(3, String.class).toString(), is("NO"));
assertThat(actual.getValue(4, String.class).toString(), is("PRI"));
assertThat(actual.getValue(5, String.class).toString(), is(""));
assertThat(actual.getValue(6, String.class).toString(), is("auto_increment"));
}
@Test
public void assertAllWithEncryptRule() throws SQLException {
ShardingRule shardingRule = mockShardingRuleWithEncryptRule();
DescribeTableMergedResult describeTableMergedResult = new DescribeTableMergedResult(shardingRule, queryResults, sqlStatementContext);
assertTrue(describeTableMergedResult.next());
assertThat(describeTableMergedResult.getValue(1, String.class).toString(), is("id"));
assertThat(describeTableMergedResult.getValue(2, String.class).toString(), is("int(11) unsigned"));
assertThat(describeTableMergedResult.getValue(3, String.class).toString(), is("NO"));
assertThat(describeTableMergedResult.getValue(4, String.class).toString(), is("PRI"));
assertThat(describeTableMergedResult.getValue(5, String.class).toString(), is(""));
assertThat(describeTableMergedResult.getValue(6, String.class).toString(), is("auto_increment"));
ShardingRule shardingRule = createShardingRuleWithEncryptRule();
DescribeTableMergedResult actual = new DescribeTableMergedResult(shardingRule, Collections.singletonList(createQueryResult()), createSQLStatementContext());
assertTrue(actual.next());
assertThat(actual.getValue(1, String.class).toString(), is("id"));
assertThat(actual.getValue(2, String.class).toString(), is("int(11) unsigned"));
assertThat(actual.getValue(3, String.class).toString(), is("NO"));
assertThat(actual.getValue(4, String.class).toString(), is("PRI"));
assertThat(actual.getValue(5, String.class).toString(), is(""));
assertThat(actual.getValue(6, String.class).toString(), is("auto_increment"));
}
private ShardingRule mockShardingRuleWithoutEncryptRule() {
ShardingRule shardingRule = mock(ShardingRule.class);
private ShardingRule createShardingRuleWithoutEncryptRule() {
ShardingRule result = mock(ShardingRule.class);
EncryptRule encryptRule = mock(EncryptRule.class);
when(encryptRule.findEncryptTable("user")).thenReturn(Optional.<EncryptTable>absent());
when(shardingRule.getEncryptRule()).thenReturn(encryptRule);
return shardingRule;
when(result.getEncryptRule()).thenReturn(encryptRule);
return result;
}
private ShardingRule mockShardingRuleWithEncryptRule() {
ShardingRule shardingRule = mock(ShardingRule.class);
private ShardingRule createShardingRuleWithEncryptRule() {
ShardingRule result = mock(ShardingRule.class);
EncryptRule encryptRule = mock(EncryptRule.class);
EncryptTable encryptTable = mock(EncryptTable.class);
when(shardingRule.getEncryptRule()).thenReturn(encryptRule);
when(result.getEncryptRule()).thenReturn(encryptRule);
when(encryptRule.findEncryptTable("user")).thenReturn(Optional.of(encryptTable));
when(encryptTable.getAssistedQueryColumns()).thenReturn(Collections.singletonList("name_assisted"));
when(encryptTable.getCipherColumns()).thenReturn(Collections.singletonList("name"));
when(encryptTable.getLogicColumn("name")).thenReturn("logic_name");
return shardingRule;
return result;
}
private QueryResult createQueryResult() throws SQLException {
QueryResult result = mock(QueryResult.class);
when(result.getColumnCount()).thenReturn(6);
when(result.next()).thenReturn(true, true, true, true, true, false);
when(result.getValue(1, Object.class)).thenReturn("id", "name", "pre_name", "name_assisted");
when(result.getValue(2, Object.class)).thenReturn("int(11) unsigned", "varchar(100)");
when(result.getValue(3, Object.class)).thenReturn("NO", "YES");
when(result.getValue(4, Object.class)).thenReturn("PRI", "");
when(result.getValue(5, Object.class)).thenReturn("");
when(result.getValue(6, Object.class)).thenReturn("auto_increment", "");
return result;
}
private SQLStatementContext createSQLStatementContext() {
SQLStatementContext result = mock(SQLStatementContext.class);
TablesContext tablesContext = mock(TablesContext.class);
when(tablesContext.getSingleTableName()).thenReturn("user");
when(result.getTablesContext()).thenReturn(tablesContext);
return result;
}
}
sharding-core/sharding-core-merge/src/test/java/org/apache/shardingsphere/core/merge/dal/show/ShowCreateTableMergedResultTest.java
浏览文件 @ 6e33a073
......@@ -17,13 +17,11 @@
package org.apache.shardingsphere.core.merge.dal.show;
import com.google.common.collect.Lists;
import org.apache.shardingsphere.api.config.sharding.ShardingRuleConfiguration;
import org.apache.shardingsphere.api.config.sharding.TableRuleConfiguration;
import org.apache.shardingsphere.api.config.sharding.strategy.ComplexShardingStrategyConfiguration;
import org.apache.shardingsphere.core.execute.sql.execute.result.QueryResult;
import org.apache.shardingsphere.core.merge.fixture.ComplexKeysShardingAlgorithmFixture;
import org.apache.shardingsphere.core.merge.fixture.ResultSetBasedQueryResultFixture;
import org.apache.shardingsphere.core.metadata.column.ColumnMetaData;
import org.apache.shardingsphere.core.metadata.table.TableMetaData;
import org.apache.shardingsphere.core.metadata.table.TableMetas;
......@@ -31,13 +29,9 @@ import org.apache.shardingsphere.core.rule.ShardingRule;
import org.junit.Before;
import org.junit.Test;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import static org.junit.Assert.assertFalse;
......@@ -49,69 +43,53 @@ public final class ShowCreateTableMergedResultTest {
private ShardingRule shardingRule;
private List<QueryResult> queryResults;
private ResultSet resultSet;
private TableMetas tableMetas;
@Before
public void setUp() throws SQLException {
public void setUp() {
shardingRule = createShardingRule();
tableMetas = createTableMetas();
}
private ShardingRule createShardingRule() {
TableRuleConfiguration tableRuleConfig = new TableRuleConfiguration("table", "ds.table_${0..2}");
tableRuleConfig.setTableShardingStrategyConfig(new ComplexShardingStrategyConfiguration("field1, field2, field3", new ComplexKeysShardingAlgorithmFixture()));
ShardingRuleConfiguration shardingRuleConfig = new ShardingRuleConfiguration();
shardingRuleConfig.getTableRuleConfigs().add(tableRuleConfig);
shardingRule = new ShardingRule(shardingRuleConfig, Lists.newArrayList("ds"));
return new ShardingRule(shardingRuleConfig, Collections.singletonList("ds"));
}
private TableMetas createTableMetas() {
Map<String, TableMetaData> tableMetaDataMap = new HashMap<>(1, 1);
tableMetaDataMap.put("table", new TableMetaData(Collections.<ColumnMetaData>emptyList(), Collections.<String>emptySet()));
tableMetas = new TableMetas(tableMetaDataMap);
resultSet = mock(ResultSet.class);
ResultSetMetaData resultSetMetaData = mock(ResultSetMetaData.class);
when(resultSet.getMetaData()).thenReturn(resultSetMetaData);
when(resultSetMetaData.getColumnCount()).thenReturn(2);
List<ResultSet> resultSets = Lists.newArrayList(resultSet);
for (ResultSet each : resultSets) {
when(each.next()).thenReturn(true, false);
}
queryResults = new ArrayList<>(resultSets.size());
for (ResultSet each : resultSets) {
queryResults.add(new ResultSetBasedQueryResultFixture(each));
}
return new TableMetas(tableMetaDataMap);
}
@Test
public void assertNextForEmptyQueryResult() throws SQLException {
ShowCreateTableMergedResult showCreateTableMergedResult = new ShowCreateTableMergedResult(shardingRule, new ArrayList<QueryResult>(), tableMetas);
assertFalse(showCreateTableMergedResult.next());
ShowCreateTableMergedResult actual = new ShowCreateTableMergedResult(shardingRule, tableMetas, Collections.<QueryResult>emptyList());
assertFalse(actual.next());
}
@Test
public void assertNextForTableRuleIsPresentForBackQuotes() throws SQLException {
when(resultSet.getObject(1)).thenReturn("table_0");
when(resultSet.getObject(2)).thenReturn("CREATE TABLE `t_order` (\n"
+ " `id` int(11) NOT NULL AUTO_INCREMENT,\n"
+ " `order_id` int(11) NOT NULL COMMENT,\n"
+ " `user_id` int(11) NOT NULL COMMENT,\n"
+ " `status` tinyint(4) NOT NULL DEFAULT '1',\n"
+ " `created_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,\n"
+ " PRIMARY KEY (`id`)\n"
+ ") ENGINE=InnoDB AUTO_INCREMENT=121 DEFAULT CHARSET=utf8 COLLATE=utf8_bin");
ShowCreateTableMergedResult showCreateTableMergedResult = new ShowCreateTableMergedResult(shardingRule, queryResults, tableMetas);
assertTrue(showCreateTableMergedResult.next());
public void assertNextForTableRuleIsPresent() throws SQLException {
ShowCreateTableMergedResult actual = new ShowCreateTableMergedResult(shardingRule, tableMetas, Collections.singletonList(createQueryResult()));
assertTrue(actual.next());
}
@Test
public void assertNextForTableRuleIsPresentForNoBackQuotes() throws SQLException {
when(resultSet.getObject(1)).thenReturn("table_0");
when(resultSet.getObject(2)).thenReturn("CREATE TABLE t_order (\n"
+ " `id` int(11) NOT NULL AUTO_INCREMENT,\n"
+ " `order_id` int(11) NOT NULL COMMENT,\n"
+ " `user_id` int(11) NOT NULL COMMENT,\n"
+ " `status` tinyint(4) NOT NULL DEFAULT '1',\n"
+ " `created_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,\n"
+ " PRIMARY KEY (`id`)\n"
+ ") ENGINE=InnoDB AUTO_INCREMENT=121 DEFAULT CHARSET=utf8 COLLATE=utf8_bin");
ShowCreateTableMergedResult showCreateTableMergedResult = new ShowCreateTableMergedResult(shardingRule, queryResults, tableMetas);
assertTrue(showCreateTableMergedResult.next());
private QueryResult createQueryResult() throws SQLException {
QueryResult result = mock(QueryResult.class);
when(result.getColumnCount()).thenReturn(2);
when(result.next()).thenReturn(true, false);
when(result.getValue(1, Object.class)).thenReturn("table_0");
when(result.getValue(2, Object.class)).thenReturn("CREATE TABLE `t_order` (\n"
+ " `id` int(11) NOT NULL AUTO_INCREMENT,\n"
+ " `order_id` int(11) NOT NULL COMMENT,\n"
+ " `user_id` int(11) NOT NULL COMMENT,\n"
+ " `status` tinyint(4) NOT NULL DEFAULT '1',\n"
+ " `created_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,\n"
+ " PRIMARY KEY (`id`)\n"
+ ") ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_bin");
return result;
}
}
sharding-core/sharding-core-merge/src/test/java/org/apache/shardingsphere/core/merge/dal/show/ShowDatabasesMergedResultTest.java
浏览文件 @ 6e33a073
......@@ -19,23 +19,18 @@ package org.apache.shardingsphere.core.merge.dal.show;
import org.apache.shardingsphere.core.constant.ShardingConstant;
import org.apache.shardingsphere.core.execute.sql.execute.result.QueryResult;
import org.apache.shardingsphere.core.merge.fixture.ResultSetBasedQueryResultFixture;
import org.junit.Before;
import org.junit.Test;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.List;
import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
......@@ -77,50 +72,49 @@ public final class ShowDatabasesMergedResultTest {
@Test
public void assertMergeNext() throws SQLException {
ShowDatabasesMergedResult showDatabasesMergedResult = buildMergedShowDatabasesMergedResult();
assertTrue(showDatabasesMergedResult.next());
assertTrue(showDatabasesMergedResult.next());
assertTrue(showDatabasesMergedResult.next());
assertTrue(showDatabasesMergedResult.next());
assertTrue(showDatabasesMergedResult.next());
assertFalse(showDatabasesMergedResult.next());
ShowDatabasesMergedResult actual = buildMergedShowDatabasesMergedResult();
assertTrue(actual.next());
assertTrue(actual.next());
assertTrue(actual.next());
assertTrue(actual.next());
assertTrue(actual.next());
assertFalse(actual.next());
}
@Test
public void assertSchemes() throws SQLException {
ShowDatabasesMergedResult showDatabasesMergedResult = buildMergedShowDatabasesMergedResult();
showDatabasesMergedResult.next();
assertThat(showDatabasesMergedResult.getValue(1, String.class).toString(), is("A"));
showDatabasesMergedResult.next();
assertThat(showDatabasesMergedResult.getValue(1, String.class).toString(), is("B"));
showDatabasesMergedResult.next();
assertThat(showDatabasesMergedResult.getValue(1, String.class).toString(), is("C"));
showDatabasesMergedResult.next();
assertThat(showDatabasesMergedResult.getValue(1, String.class).toString(), is("D"));
showDatabasesMergedResult.next();
assertThat(showDatabasesMergedResult.getValue(1, String.class).toString(), is("E"));
ShowDatabasesMergedResult actual = buildMergedShowDatabasesMergedResult();
actual.next();
assertThat(actual.getValue(1, String.class).toString(), is("A"));
actual.next();
assertThat(actual.getValue(1, String.class).toString(), is("B"));
actual.next();
assertThat(actual.getValue(1, String.class).toString(), is("C"));
actual.next();
assertThat(actual.getValue(1, String.class).toString(), is("D"));
actual.next();
assertThat(actual.getValue(1, String.class).toString(), is("E"));
}
private ShowDatabasesMergedResult buildMergedShowDatabasesMergedResult() throws SQLException {
ResultSet resultSet = mock(ResultSet.class);
when(resultSet.next()).thenReturn(true, true, true, false);
when(resultSet.getString(anyInt())).thenReturn("A", "B", "C");
ResultSetMetaData resultSetMetaData = mock(ResultSetMetaData.class);
when(resultSet.getMetaData()).thenReturn(resultSetMetaData);
when(resultSetMetaData.getColumnCount()).thenReturn(1);
when(resultSetMetaData.getColumnLabel(1)).thenReturn("SCHEMA_NAME");
ResultSet resultSet2 = mock(ResultSet.class);
when(resultSet2.next()).thenReturn(true, true, false);
when(resultSet2.getString(anyInt())).thenReturn("D", "E");
ResultSetMetaData resultSetMetaData2 = mock(ResultSetMetaData.class);
when(resultSet2.getMetaData()).thenReturn(resultSetMetaData);
when(resultSetMetaData2.getColumnCount()).thenReturn(1);
when(resultSetMetaData2.getColumnLabel(1)).thenReturn("SCHEMA_NAME");
List<QueryResult> queryResults = new ArrayList<>();
queryResults.add(new ResultSetBasedQueryResultFixture(resultSet));
queryResults.add(new ResultSetBasedQueryResultFixture(resultSet2));
return new ShowDatabasesMergedResult(null, queryResults);
return new ShowDatabasesMergedResult(null, Arrays.asList(createQueryResult1(), createQueryResult2()));
}
private QueryResult createQueryResult1() throws SQLException {
QueryResult result = mock(QueryResult.class);
when(result.next()).thenReturn(true, true, true, false);
when(result.getValue(1, String.class)).thenReturn("A", "B", "C");
when(result.getColumnCount()).thenReturn(1);
when(result.getColumnLabel(1)).thenReturn("SCHEMA_NAME");
return result;
}
private QueryResult createQueryResult2() throws SQLException {
QueryResult result = mock(QueryResult.class);
when(result.next()).thenReturn(true, true, false);
when(result.getValue(1, String.class)).thenReturn("D", "E");
when(result.getColumnCount()).thenReturn(1);
when(result.getColumnLabel(1)).thenReturn("SCHEMA_NAME");
return result;
}
}
sharding-core/sharding-core-merge/src/test/java/org/apache/shardingsphere/core/merge/dal/show/ShowOtherMergedResultTest.java
浏览文件 @ 6e33a073
......@@ -17,29 +17,15 @@
package org.apache.shardingsphere.core.merge.dal.show;
import org.apache.shardingsphere.core.merge.fixture.ResultSetBasedQueryResultFixture;
import org.junit.Before;
import org.apache.shardingsphere.core.execute.sql.execute.result.QueryResult;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import java.io.InputStream;
import java.io.Reader;
import java.math.BigDecimal;
import java.net.MalformedURLException;
import java.net.URL;
import java.sql.Blob;
import java.sql.Clob;
import java.sql.Date;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.sql.SQLXML;
import java.sql.Time;
import java.sql.Timestamp;
import java.util.Calendar;
import java.util.Collection;
import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertFalse;
......@@ -51,196 +37,38 @@ import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.class)
public final class ShowOtherMergedResultTest {
@Mock
private ResultSet resultSet;
private ShowOtherMergedResult showOtherMergedResult;
@Before
public void setUp() {
showOtherMergedResult = new ShowOtherMergedResult(new ResultSetBasedQueryResultFixture(resultSet));
}
@Test
public void assertNext() throws SQLException {
when(resultSet.next()).thenReturn(true, false);
assertThat(showOtherMergedResult.next(), is(true));
assertThat(showOtherMergedResult.next(), is(false));
}
@Test
public void assertGetValueWithColumnIndexWithObject() throws SQLException {
when(resultSet.getObject(1)).thenReturn("1");
assertThat(showOtherMergedResult.getValue(1, Object.class).toString(), is("1"));
}
@Test
public void assertGetValueWithColumnIndexWithBoolean() throws SQLException {
when(resultSet.getBoolean(1)).thenReturn(true);
assertTrue((Boolean) showOtherMergedResult.getValue(1, boolean.class));
QueryResult queryResult = mock(QueryResult.class);
when(queryResult.next()).thenReturn(true, false);
ShowOtherMergedResult actual = new ShowOtherMergedResult(queryResult);
assertTrue(actual.next());
assertFalse(actual.next());
}
@Test
public void assertGetValueWithColumnIndexWithByte() throws SQLException {
when(resultSet.getByte(1)).thenReturn((byte) 1);
assertThat((byte) showOtherMergedResult.getValue(1, byte.class), is((byte) 1));
}
@Test
public void assertGetValueWithColumnIndexWithShort() throws SQLException {
when(resultSet.getShort(1)).thenReturn((short) 1);
assertThat((short) showOtherMergedResult.getValue(1, short.class), is((short) 1));
}
@Test
public void assertGetValueWithColumnIndexWithInt() throws SQLException {
when(resultSet.getInt(1)).thenReturn(1);
assertThat((int) showOtherMergedResult.getValue(1, int.class), is(1));
}
@Test
public void assertGetValueWithColumnIndexWithLong() throws SQLException {
when(resultSet.getLong(1)).thenReturn(1L);
assertThat((long) showOtherMergedResult.getValue(1, long.class), is(1L));
}
@Test
public void assertGetValueWithColumnIndexWithFloat() throws SQLException {
when(resultSet.getFloat(1)).thenReturn(1F);
assertThat((float) showOtherMergedResult.getValue(1, float.class), is(1F));
}
@Test
public void assertGetValueWithColumnIndexWithDouble() throws SQLException {
when(resultSet.getDouble(1)).thenReturn(1D);
assertThat((double) showOtherMergedResult.getValue(1, double.class), is(1D));
}
@Test
public void assertGetValueWithColumnIndexWithString() throws SQLException {
when(resultSet.getString(1)).thenReturn("1");
assertThat((String) showOtherMergedResult.getValue(1, String.class), is("1"));
}
@Test
public void assertGetValueWithColumnIndexWithBigDecimal() throws SQLException {
when(resultSet.getBigDecimal(1)).thenReturn(new BigDecimal("1"));
assertThat((BigDecimal) showOtherMergedResult.getValue(1, BigDecimal.class), is(new BigDecimal("1")));
}
@Test
public void assertGetValueWithColumnIndexWithByteArray() throws SQLException {
when(resultSet.getBytes(1)).thenReturn(new byte[] {(byte) 1});
assertThat((byte[]) showOtherMergedResult.getValue(1, byte[].class), is(new byte[] {(byte) 1}));
}
@Test
public void assertGetValueWithColumnIndexWithDate() throws SQLException {
when(resultSet.getDate(1)).thenReturn(new Date(0L));
assertThat((Date) showOtherMergedResult.getValue(1, Date.class), is(new Date(0L)));
}
@Test
public void assertGetValueWithColumnIndexWithTime() throws SQLException {
when(resultSet.getTime(1)).thenReturn(new Time(0L));
assertThat((Time) showOtherMergedResult.getValue(1, Time.class), is(new Time(0L)));
}
@Test
public void assertGetValueWithColumnIndexWithTimestamp() throws SQLException {
when(resultSet.getTimestamp(1)).thenReturn(new Timestamp(0L));
assertThat((Timestamp) showOtherMergedResult.getValue(1, Timestamp.class), is(new Timestamp(0L)));
}
@Test
public void assertGetValueWithColumnIndexWithURL() throws SQLException, MalformedURLException {
when(resultSet.getURL(1)).thenReturn(new URL("http://xxx.xxx"));
assertThat((URL) showOtherMergedResult.getValue(1, URL.class), is(new URL("http://xxx.xxx")));
}
@Test
public void assertGetValueWithColumnIndexWithBlob() throws SQLException {
Blob blob = mock(Blob.class);
when(resultSet.getBlob(1)).thenReturn(blob);
assertThat((Blob) showOtherMergedResult.getValue(1, Blob.class), is(blob));
}
@Test
public void assertGetValueWithColumnIndexWithClob() throws SQLException {
Clob clob = mock(Clob.class);
when(resultSet.getClob(1)).thenReturn(clob);
assertThat((Clob) showOtherMergedResult.getValue(1, Clob.class), is(clob));
}
@Test
public void assertGetValueWithColumnIndexWithSQLXML() throws SQLException {
SQLXML sqlxml = mock(SQLXML.class);
when(resultSet.getSQLXML(1)).thenReturn(sqlxml);
assertThat((SQLXML) showOtherMergedResult.getValue(1, SQLXML.class), is(sqlxml));
}
@Test
public void assertGetValueWithColumnIndexWithReader() throws SQLException {
Reader reader = mock(Reader.class);
when(resultSet.getCharacterStream(1)).thenReturn(reader);
assertThat((Reader) showOtherMergedResult.getValue(1, Reader.class), is(reader));
}
@Test
public void assertGetValueWithColumnIndexWithOtherObject() throws SQLException {
when(resultSet.getObject(1)).thenReturn("1");
assertThat((String) showOtherMergedResult.getValue(1, Collection.class), is("1"));
}
@Test(expected = SQLFeatureNotSupportedException.class)
public void assertGetCalendarValueWithColumnIndexWithDate() throws SQLException {
Calendar calendar = Calendar.getInstance();
assertThat((Date) showOtherMergedResult.getCalendarValue(1, Date.class, calendar), is(new Date(0L)));
public void assertGetValue() throws SQLException {
QueryResult queryResult = mock(QueryResult.class);
when(queryResult.getValue(1, Object.class)).thenReturn("1");
ShowOtherMergedResult actual = new ShowOtherMergedResult(queryResult);
assertThat(actual.getValue(1, Object.class).toString(), is("1"));
}
@Test(expected = SQLFeatureNotSupportedException.class)
public void assertGetCalendarValueWithColumnIndexWithTime() throws SQLException {
Calendar calendar = Calendar.getInstance();
assertThat((Time) showOtherMergedResult.getCalendarValue(1, Time.class, calendar), is(new Time(0L)));
public void assertGetCalendarValue() throws SQLException {
ShowOtherMergedResult actual = new ShowOtherMergedResult(mock(QueryResult.class));
actual.getCalendarValue(1, Date.class, Calendar.getInstance());
}
@Test(expected = SQLFeatureNotSupportedException.class)
public void assertGetCalendarValueWithColumnIndexWithTimestamp() throws SQLException {
Calendar calendar = Calendar.getInstance();
assertThat((Timestamp) showOtherMergedResult.getCalendarValue(1, Timestamp.class, calendar), is(new Timestamp(0L)));
}
@Test(expected = SQLException.class)
public void assertGetCalendarValueWithColumnIndexWithInvalidType() throws SQLException {
showOtherMergedResult.getCalendarValue(1, Object.class, Calendar.getInstance());
}
@Test(expected = SQLFeatureNotSupportedException.class)
public void assertGetInputStreamWithColumnIndexWithAscii() throws SQLException {
InputStream inputStream = mock(InputStream.class);
assertThat(showOtherMergedResult.getInputStream(1, "Ascii"), is(inputStream));
}
@SuppressWarnings("deprecation")
@Test(expected = SQLFeatureNotSupportedException.class)
public void assertGetInputStreamWithColumnIndexWithUnicode() throws SQLException {
InputStream inputStream = mock(InputStream.class);
assertThat(showOtherMergedResult.getInputStream(1, "Unicode"), is(inputStream));
}
@Test(expected = SQLFeatureNotSupportedException.class)
public void assertGetInputStreamWithColumnIndexWithBinary() throws SQLException {
InputStream inputStream = mock(InputStream.class);
assertThat(showOtherMergedResult.getInputStream(1, "Binary"), is(inputStream));
}
@Test(expected = SQLException.class)
public void assertGetInputStreamWithColumnIndexWithInvalidType() throws SQLException {
showOtherMergedResult.getInputStream(1, "Invalid");
public void assertGetInputStream() throws SQLException {
ShowOtherMergedResult actual = new ShowOtherMergedResult(mock(QueryResult.class));
actual.getInputStream(1, "Ascii");
}
@Test
public void assertWasNull() {
assertFalse(showOtherMergedResult.wasNull());
ShowOtherMergedResult actual = new ShowOtherMergedResult(mock(QueryResult.class));
assertFalse(actual.wasNull());
}
}
sharding-core/sharding-core-merge/src/test/java/org/apache/shardingsphere/core/merge/dal/show/ShowTablesMergedResultTest.java
浏览文件 @ 6e33a073
......@@ -23,7 +23,6 @@ import org.apache.shardingsphere.api.config.sharding.TableRuleConfiguration;
import org.apache.shardingsphere.api.config.sharding.strategy.ComplexShardingStrategyConfiguration;
import org.apache.shardingsphere.core.execute.sql.execute.result.QueryResult;
import org.apache.shardingsphere.core.merge.fixture.ComplexKeysShardingAlgorithmFixture;
import org.apache.shardingsphere.core.merge.fixture.ResultSetBasedQueryResultFixture;
import org.apache.shardingsphere.core.metadata.column.ColumnMetaData;
import org.apache.shardingsphere.core.metadata.table.TableMetaData;
import org.apache.shardingsphere.core.metadata.table.TableMetas;
......@@ -31,13 +30,9 @@ import org.apache.shardingsphere.core.rule.ShardingRule;
import org.junit.Before;
import org.junit.Test;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import static org.junit.Assert.assertFalse;
......@@ -49,60 +44,57 @@ public final class ShowTablesMergedResultTest {
private ShardingRule shardingRule;
private List<QueryResult> queryResults;
private ResultSet resultSet;
private TableMetas tableMetas;
@Before
public void setUp() throws SQLException {
public void setUp() {
shardingRule = createShardingRule();
tableMetas = createTableMetas();
}
private ShardingRule createShardingRule() {
TableRuleConfiguration tableRuleConfig = new TableRuleConfiguration("table", "ds.table_${0..2}");
tableRuleConfig.setTableShardingStrategyConfig(new ComplexShardingStrategyConfiguration("field1, field2, field3", new ComplexKeysShardingAlgorithmFixture()));
ShardingRuleConfiguration shardingRuleConfig = new ShardingRuleConfiguration();
shardingRuleConfig.getTableRuleConfigs().add(tableRuleConfig);
shardingRule = new ShardingRule(shardingRuleConfig, Lists.newArrayList("ds"));
return new ShardingRule(shardingRuleConfig, Lists.newArrayList("ds"));
}
private TableMetas createTableMetas() {
Map<String, TableMetaData> tableMetaDataMap = new HashMap<>(1, 1);
tableMetaDataMap.put("table", new TableMetaData(Collections.<ColumnMetaData>emptyList(), Collections.<String>emptySet()));
tableMetas = new TableMetas(tableMetaDataMap);
resultSet = mock(ResultSet.class);
ResultSetMetaData resultSetMetaData = mock(ResultSetMetaData.class);
when(resultSet.getMetaData()).thenReturn(resultSetMetaData);
when(resultSetMetaData.getColumnCount()).thenReturn(1);
List<ResultSet> resultSets = Lists.newArrayList(resultSet);
for (ResultSet each : resultSets) {
when(each.next()).thenReturn(true, false);
}
queryResults = new ArrayList<>(resultSets.size());
for (ResultSet each : resultSets) {
queryResults.add(new ResultSetBasedQueryResultFixture(each));
}
return new TableMetas(tableMetaDataMap);
}
private QueryResult createQueryResult(final String value) throws SQLException {
QueryResult result = mock(QueryResult.class);
when(result.next()).thenReturn(true, false);
when(result.getValue(1, Object.class)).thenReturn(value);
when(result.getColumnCount()).thenReturn(1);
return result;
}
@Test
public void assertNextForEmptyQueryResult() throws SQLException {
ShowTablesMergedResult showTablesMergedResult = new ShowTablesMergedResult(shardingRule, new ArrayList<QueryResult>(), tableMetas);
assertFalse(showTablesMergedResult.next());
ShowTablesMergedResult actual = new ShowTablesMergedResult(shardingRule, tableMetas, Collections.<QueryResult>emptyList());
assertFalse(actual.next());
}
@Test
public void assertNextForActualTableNameInTableRule() throws SQLException {
when(resultSet.getObject(1)).thenReturn("table_0");
ShowTablesMergedResult showTablesMergedResult = new ShowTablesMergedResult(shardingRule, queryResults, tableMetas);
assertTrue(showTablesMergedResult.next());
ShowTablesMergedResult actual = new ShowTablesMergedResult(shardingRule, tableMetas, Collections.singletonList(createQueryResult("table_0")));
assertTrue(actual.next());
}
@Test
public void assertNextForActualTableNameNotInTableRuleWithDefaultDataSource() throws SQLException {
when(resultSet.getObject(1)).thenReturn("table");
ShowTablesMergedResult showTablesMergedResult = new ShowTablesMergedResult(shardingRule, queryResults, tableMetas);
assertTrue(showTablesMergedResult.next());
ShowTablesMergedResult actual = new ShowTablesMergedResult(shardingRule, tableMetas, Collections.singletonList(createQueryResult("table")));
assertTrue(actual.next());
}
@Test
public void assertNextForActualTableNameNotInTableRuleWithoutDefaultDataSource() throws SQLException {
when(resultSet.getObject(1)).thenReturn("table_3");
ShowTablesMergedResult showTablesMergedResult = new ShowTablesMergedResult(shardingRule, queryResults, tableMetas);
assertFalse(showTablesMergedResult.next());
ShowTablesMergedResult actual = new ShowTablesMergedResult(shardingRule, tableMetas, Collections.singletonList(createQueryResult("table_3")));
assertFalse(actual.next());
}
}
sharding-core/sharding-core-merge/src/test/java/org/apache/shardingsphere/core/merge/dql/common/MemoryMergedResultTest.java
浏览文件 @ 6e33a073
......@@ -58,44 +58,44 @@ public final class MemoryMergedResultTest {
}
@Test
public void assertGetValueWithColumnIndex() throws SQLException {
public void assertGetValue() throws SQLException {
when(memoryResultSetRow.getCell(1)).thenReturn("1");
assertThat(memoryMergedResult.getValue(1, Object.class).toString(), is("1"));
}
@Test(expected = SQLFeatureNotSupportedException.class)
public void assertGetValueWithColumnIndexForBlob() throws SQLException {
public void assertGetValueForBlob() throws SQLException {
memoryMergedResult.getValue(1, Blob.class);
}
@Test(expected = SQLFeatureNotSupportedException.class)
public void assertGetValueWithColumnIndexForClob() throws SQLException {
public void assertGetValueForClob() throws SQLException {
memoryMergedResult.getValue(1, Clob.class);
}
@Test(expected = SQLFeatureNotSupportedException.class)
public void assertGetValueWithColumnIndexForReader() throws SQLException {
public void assertGetValueForReader() throws SQLException {
memoryMergedResult.getValue(1, Reader.class);
}
@Test(expected = SQLFeatureNotSupportedException.class)
public void assertGetValueWithColumnIndexForInputStream() throws SQLException {
public void assertGetValueForInputStream() throws SQLException {
memoryMergedResult.getValue(1, InputStream.class);
}
@Test(expected = SQLFeatureNotSupportedException.class)
public void assertGetValueWithColumnIndexForSQLXML() throws SQLException {
public void assertGetValueForSQLXML() throws SQLException {
memoryMergedResult.getValue(1, SQLXML.class);
}
@Test
public void assertGetCalendarValueWithColumnIndex() {
public void assertGetCalendarValue() {
when(memoryResultSetRow.getCell(1)).thenReturn(new Date(0L));
assertThat((Date) memoryMergedResult.getCalendarValue(1, Object.class, Calendar.getInstance()), is(new Date(0L)));
}
@Test(expected = SQLFeatureNotSupportedException.class)
public void assertGetInputStreamWithColumnIndex() throws SQLException {
public void assertGetInputStream() throws SQLException {
memoryMergedResult.getInputStream(1, "ascii");
}
......
sharding-core/sharding-core-merge/src/test/java/org/apache/shardingsphere/core/merge/dql/common/MemoryQueryResultRowTest.java
浏览文件 @ 6e33a073
......@@ -17,15 +17,10 @@
package org.apache.shardingsphere.core.merge.dql.common;
import org.apache.shardingsphere.core.merge.fixture.ResultSetBasedQueryResultFixture;
import org.apache.shardingsphere.core.execute.sql.execute.result.QueryResult;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import static org.hamcrest.CoreMatchers.is;
......@@ -33,21 +28,16 @@ import static org.junit.Assert.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.class)
public final class MemoryQueryResultRowTest {
@Mock
private ResultSet resultSet;
private MemoryQueryResultRow memoryResultSetRow;
@Before
public void setUp() throws SQLException {
ResultSetMetaData resultSetMetaData = mock(ResultSetMetaData.class);
when(resultSet.getMetaData()).thenReturn(resultSetMetaData);
when(resultSetMetaData.getColumnCount()).thenReturn(1);
when(resultSet.getObject(1)).thenReturn("value");
memoryResultSetRow = new MemoryQueryResultRow(new ResultSetBasedQueryResultFixture(resultSet));
QueryResult queryResult = mock(QueryResult.class);
when(queryResult.getColumnCount()).thenReturn(1);
when(queryResult.getValue(1, Object.class)).thenReturn("value");
memoryResultSetRow = new MemoryQueryResultRow(queryResult);
}
@Test
......
sharding-core/sharding-core-merge/src/test/java/org/apache/shardingsphere/core/merge/dql/common/StreamMergedResultTest.java
浏览文件 @ 6e33a073
......@@ -17,236 +17,60 @@
package org.apache.shardingsphere.core.merge.dql.common;
import org.apache.shardingsphere.core.execute.sql.execute.result.QueryResult;
import org.apache.shardingsphere.core.merge.dql.common.fixture.TestStreamMergedResult;
import org.apache.shardingsphere.core.merge.fixture.ResultSetBasedQueryResultFixture;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import java.io.InputStream;
import java.io.Reader;
import java.math.BigDecimal;
import java.net.MalformedURLException;
import java.net.URL;
import java.sql.Blob;
import java.sql.Clob;
import java.sql.Date;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.SQLXML;
import java.sql.Time;
import java.sql.Timestamp;
import java.util.Calendar;
import java.util.Collection;
import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.class)
public final class StreamMergedResultTest {
@Mock
private ResultSet resultSet;
private TestStreamMergedResult streamMergedResult;
@Before
public void setUp() {
streamMergedResult = new TestStreamMergedResult();
streamMergedResult.setCurrentQueryResult(new ResultSetBasedQueryResultFixture(resultSet));
}
private final TestStreamMergedResult streamMergedResult = new TestStreamMergedResult();
@Test(expected = SQLException.class)
public void assertGetCurrentResultSetIfNull() throws SQLException {
streamMergedResult.setCurrentQueryResult(null);
public void assertGetCurrentQueryResultIfNull() throws SQLException {
streamMergedResult.getCurrentQueryResult();
}
@Test
public void assertGetValueWithColumnIndexWithObject() throws SQLException {
when(resultSet.getObject(1)).thenReturn("1");
assertThat(streamMergedResult.getValue(1, Object.class).toString(), is("1"));
}
@Test
public void assertGetValueWithColumnIndexWithBoolean() throws SQLException {
when(resultSet.getBoolean(1)).thenReturn(true);
assertTrue((Boolean) streamMergedResult.getValue(1, boolean.class));
}
@Test
public void assertGetValueWithColumnIndexWithByte() throws SQLException {
when(resultSet.getByte(1)).thenReturn((byte) 1);
assertThat((byte) streamMergedResult.getValue(1, byte.class), is((byte) 1));
}
@Test
public void assertGetValueWithColumnIndexWithShort() throws SQLException {
when(resultSet.getShort(1)).thenReturn((short) 1);
assertThat((short) streamMergedResult.getValue(1, short.class), is((short) 1));
}
@Test
public void assertGetValueWithColumnIndexWithInt() throws SQLException {
when(resultSet.getInt(1)).thenReturn(1);
assertThat((int) streamMergedResult.getValue(1, int.class), is(1));
}
@Test
public void assertGetValueWithColumnIndexWithLong() throws SQLException {
when(resultSet.getLong(1)).thenReturn(1L);
assertThat((long) streamMergedResult.getValue(1, long.class), is(1L));
}
@Test
public void assertGetValueWithColumnIndexWithFloat() throws SQLException {
when(resultSet.getFloat(1)).thenReturn(1F);
assertThat((float) streamMergedResult.getValue(1, float.class), is(1F));
}
@Test
public void assertGetValueWithColumnIndexWithDouble() throws SQLException {
when(resultSet.getDouble(1)).thenReturn(1D);
assertThat((double) streamMergedResult.getValue(1, double.class), is(1D));
}
@Test
public void assertGetValueWithColumnIndexWithString() throws SQLException {
when(resultSet.getString(1)).thenReturn("1");
assertThat((String) streamMergedResult.getValue(1, String.class), is("1"));
}
@Test
public void assertGetValueWithColumnIndexWithBigDecimal() throws SQLException {
when(resultSet.getBigDecimal(1)).thenReturn(new BigDecimal("1"));
assertThat((BigDecimal) streamMergedResult.getValue(1, BigDecimal.class), is(new BigDecimal("1")));
}
@Test
public void assertGetValueWithColumnIndexWithByteArray() throws SQLException {
when(resultSet.getBytes(1)).thenReturn(new byte[] {(byte) 1});
assertThat((byte[]) streamMergedResult.getValue(1, byte[].class), is(new byte[] {(byte) 1}));
}
@Test
public void assertGetValueWithColumnIndexWithDate() throws SQLException {
when(resultSet.getDate(1)).thenReturn(new Date(0L));
assertThat((Date) streamMergedResult.getValue(1, Date.class), is(new Date(0L)));
}
@Test
public void assertGetValueWithColumnIndexWithTime() throws SQLException {
when(resultSet.getTime(1)).thenReturn(new Time(0L));
assertThat((Time) streamMergedResult.getValue(1, Time.class), is(new Time(0L)));
}
@Test
public void assertGetValueWithColumnIndexWithTimestamp() throws SQLException {
when(resultSet.getTimestamp(1)).thenReturn(new Timestamp(0L));
assertThat((Timestamp) streamMergedResult.getValue(1, Timestamp.class), is(new Timestamp(0L)));
}
@Test
public void assertGetValueWithColumnIndexWithURL() throws SQLException, MalformedURLException {
when(resultSet.getURL(1)).thenReturn(new URL("http://xxx.xxx"));
assertThat((URL) streamMergedResult.getValue(1, URL.class), is(new URL("http://xxx.xxx")));
}
@Test
public void assertGetValueWithColumnIndexWithBlob() throws SQLException {
Blob blob = mock(Blob.class);
when(resultSet.getBlob(1)).thenReturn(blob);
assertThat((Blob) streamMergedResult.getValue(1, Blob.class), is(blob));
}
@Test
public void assertGetValueWithColumnIndexWithClob() throws SQLException {
Clob clob = mock(Clob.class);
when(resultSet.getClob(1)).thenReturn(clob);
assertThat((Clob) streamMergedResult.getValue(1, Clob.class), is(clob));
}
@Test
public void assertGetValueWithColumnIndexWithSQLXML() throws SQLException {
SQLXML sqlxml = mock(SQLXML.class);
when(resultSet.getSQLXML(1)).thenReturn(sqlxml);
assertThat((SQLXML) streamMergedResult.getValue(1, SQLXML.class), is(sqlxml));
}
@Test
public void assertGetValueWithColumnIndexWithReader() throws SQLException {
Reader reader = mock(Reader.class);
when(resultSet.getCharacterStream(1)).thenReturn(reader);
assertThat((Reader) streamMergedResult.getValue(1, Reader.class), is(reader));
}
@Test
public void assertGetValueWithColumnIndexWithOtherObject() throws SQLException {
when(resultSet.getObject(1)).thenReturn("1");
assertThat((String) streamMergedResult.getValue(1, Collection.class), is("1"));
public void assertGetValue() throws SQLException {
QueryResult queryResult = mock(QueryResult.class);
when(queryResult.getValue(1, Object.class)).thenReturn("1");
streamMergedResult.setCurrentQueryResult(queryResult);
assertThat(streamMergedResult.getValue(1, Object.class).toString(), is("1"));
}
@Test
public void assertGetCalendarValueWithColumnIndexWithDate() throws SQLException {
public void assertGetCalendarValue() throws SQLException {
QueryResult queryResult = mock(QueryResult.class);
Calendar calendar = Calendar.getInstance();
when(resultSet.getDate(1, calendar)).thenReturn(new Date(0L));
when(queryResult.getCalendarValue(1, Date.class, calendar)).thenReturn(new Date(0L));
streamMergedResult.setCurrentQueryResult(queryResult);
assertThat((Date) streamMergedResult.getCalendarValue(1, Date.class, calendar), is(new Date(0L)));
}
@Test
public void assertGetCalendarValueWithColumnIndexWithTime() throws SQLException {
Calendar calendar = Calendar.getInstance();
when(resultSet.getTime(1, calendar)).thenReturn(new Time(0L));
assertThat((Time) streamMergedResult.getCalendarValue(1, Time.class, calendar), is(new Time(0L)));
}
@Test
public void assertGetCalendarValueWithColumnIndexWithTimestamp() throws SQLException {
Calendar calendar = Calendar.getInstance();
when(resultSet.getTimestamp(1, calendar)).thenReturn(new Timestamp(0L));
assertThat((Timestamp) streamMergedResult.getCalendarValue(1, Timestamp.class, calendar), is(new Timestamp(0L)));
}
@Test(expected = SQLException.class)
public void assertGetCalendarValueWithColumnIndexWithInvalidType() throws SQLException {
streamMergedResult.getCalendarValue(1, Object.class, Calendar.getInstance());
}
@Test
public void assertGetInputStreamWithColumnIndexWithAscii() throws SQLException {
InputStream inputStream = mock(InputStream.class);
when(resultSet.getAsciiStream(1)).thenReturn(inputStream);
assertThat(streamMergedResult.getInputStream(1, "Ascii"), is(inputStream));
}
@SuppressWarnings("deprecation")
@Test
public void assertGetInputStreamWithColumnIndexWithUnicode() throws SQLException {
InputStream inputStream = mock(InputStream.class);
when(resultSet.getUnicodeStream(1)).thenReturn(inputStream);
assertThat(streamMergedResult.getInputStream(1, "Unicode"), is(inputStream));
}
@Test
public void assertGetInputStreamWithColumnIndexWithBinary() throws SQLException {
InputStream inputStream = mock(InputStream.class);
when(resultSet.getBinaryStream(1)).thenReturn(inputStream);
assertThat(streamMergedResult.getInputStream(1, "Binary"), is(inputStream));
}
@Test(expected = SQLException.class)
public void assertGetInputStreamWithColumnIndexWithInvalidType() throws SQLException {
streamMergedResult.getInputStream(1, "Invalid");
public void assertGetInputStream() throws SQLException {
QueryResult queryResult = mock(QueryResult.class);
InputStream value = mock(InputStream.class);
when(queryResult.getInputStream(1, "Ascii")).thenReturn(value);
streamMergedResult.setCurrentQueryResult(queryResult);
assertThat(streamMergedResult.getInputStream(1, "Ascii"), is(value));
}
@Test
public void assertWasNull() {
QueryResult queryResult = mock(QueryResult.class);
streamMergedResult.setCurrentQueryResult(queryResult);
assertFalse(streamMergedResult.wasNull());
}
}
sharding-core/sharding-core-merge/src/test/java/org/apache/shardingsphere/core/merge/dql/groupby/GroupByMemoryMergedResultTest.java
浏览文件 @ 6e33a073
......@@ -17,12 +17,10 @@
package org.apache.shardingsphere.core.merge.dql.groupby;
import com.google.common.collect.Lists;
import org.apache.shardingsphere.core.database.DatabaseTypes;
import org.apache.shardingsphere.core.execute.sql.execute.result.QueryResult;
import org.apache.shardingsphere.core.merge.MergedResult;
import org.apache.shardingsphere.core.merge.dql.DQLMergeEngine;
import org.apache.shardingsphere.core.merge.fixture.ResultSetBasedQueryResultFixture;
import org.apache.shardingsphere.sql.parser.core.constant.AggregationType;
import org.apache.shardingsphere.sql.parser.core.constant.OrderDirection;
import org.apache.shardingsphere.sql.parser.relation.segment.select.groupby.GroupByContext;
......@@ -35,17 +33,12 @@ import org.apache.shardingsphere.sql.parser.relation.segment.select.projection.i
import org.apache.shardingsphere.sql.parser.relation.statement.impl.SelectSQLStatementContext;
import org.apache.shardingsphere.sql.parser.sql.segment.dml.order.item.IndexOrderByItemSegment;
import org.apache.shardingsphere.sql.parser.sql.statement.dml.SelectStatement;
import org.junit.Before;
import org.junit.Test;
import java.math.BigDecimal;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertFalse;
......@@ -56,21 +49,49 @@ import static org.mockito.Mockito.when;
public final class GroupByMemoryMergedResultTest {
private DQLMergeEngine mergeEngine;
private List<ResultSet> resultSets;
private List<QueryResult> queryResults;
@Test
public void assertNextForResultSetsAllEmpty() throws SQLException {
DQLMergeEngine mergeEngine = new DQLMergeEngine(
DatabaseTypes.getActualDatabaseType("MySQL"), createSelectSQLStatementContext(), Arrays.asList(createQueryResult(), createQueryResult(), createQueryResult()));
MergedResult actual = mergeEngine.merge();
assertFalse(actual.next());
}
private SelectSQLStatementContext selectSQLStatementContext;
@Test
public void assertNextForSomeResultSetsEmpty() throws SQLException {
QueryResult queryResult1 = createQueryResult();
when(queryResult1.next()).thenReturn(true, false);
when(queryResult1.getValue(1, Object.class)).thenReturn(20);
when(queryResult1.getValue(2, Object.class)).thenReturn(0);
when(queryResult1.getValue(3, Object.class)).thenReturn(2);
when(queryResult1.getValue(4, Object.class)).thenReturn(2);
when(queryResult1.getValue(5, Object.class)).thenReturn(20);
QueryResult queryResult2 = createQueryResult();
QueryResult queryResult3 = createQueryResult();
when(queryResult3.next()).thenReturn(true, true, false);
when(queryResult3.getValue(1, Object.class)).thenReturn(20, 30);
when(queryResult3.getValue(2, Object.class)).thenReturn(0);
when(queryResult3.getValue(3, Object.class)).thenReturn(2, 3);
when(queryResult3.getValue(4, Object.class)).thenReturn(2, 2, 3);
when(queryResult3.getValue(5, Object.class)).thenReturn(20, 20, 30);
DQLMergeEngine mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("MySQL"), createSelectSQLStatementContext(), Arrays.asList(queryResult1, queryResult2, queryResult3));
MergedResult actual = mergeEngine.merge();
assertTrue(actual.next());
assertThat((BigDecimal) actual.getValue(1, Object.class), is(new BigDecimal(30)));
assertThat(((BigDecimal) actual.getValue(2, Object.class)).intValue(), is(10));
assertThat((Integer) actual.getValue(3, Object.class), is(3));
assertThat((BigDecimal) actual.getValue(4, Object.class), is(new BigDecimal(3)));
assertThat((BigDecimal) actual.getValue(5, Object.class), is(new BigDecimal(30)));
assertTrue(actual.next());
assertThat((BigDecimal) actual.getValue(1, Object.class), is(new BigDecimal(40)));
assertThat(((BigDecimal) actual.getValue(2, Object.class)).intValue(), is(10));
assertThat((Integer) actual.getValue(3, Object.class), is(2));
assertThat((BigDecimal) actual.getValue(4, Object.class), is(new BigDecimal(4)));
assertThat((BigDecimal) actual.getValue(5, Object.class), is(new BigDecimal(40)));
assertFalse(actual.next());
}
@Before
public void setUp() throws SQLException {
resultSets = Lists.newArrayList(mockResultSet(), mockResultSet(), mockResultSet());
queryResults = new ArrayList<>(resultSets.size());
for (ResultSet each : resultSets) {
queryResults.add(new ResultSetBasedQueryResultFixture(each));
}
private SelectSQLStatementContext createSelectSQLStatementContext() {
AggregationProjection aggregationSelectItem1 = new AggregationProjection(AggregationType.COUNT, "(*)", null);
aggregationSelectItem1.setIndex(1);
AggregationProjection aggregationSelectItem2 = new AggregationProjection(AggregationType.AVG, "(num)", null);
......@@ -82,66 +103,26 @@ public final class GroupByMemoryMergedResultTest {
aggregationSelectItem2.setIndex(5);
aggregationSelectItem2.getDerivedAggregationProjections().add(derivedAggregationSelectItem2);
ProjectionsContext projectionsContext = new ProjectionsContext(0, 0, false, Arrays.<Projection>asList(aggregationSelectItem1, aggregationSelectItem2), Collections.<String>emptyList());
selectSQLStatementContext = new SelectSQLStatementContext(new SelectStatement(),
return new SelectSQLStatementContext(new SelectStatement(),
new GroupByContext(Collections.singletonList(createOrderByItem(new IndexOrderByItemSegment(0, 0, 3, OrderDirection.ASC, OrderDirection.ASC))), 0),
new OrderByContext(Collections.singletonList(createOrderByItem(new IndexOrderByItemSegment(0, 0, 3, OrderDirection.DESC, OrderDirection.ASC))), false),
projectionsContext, new PaginationContext(null, null, Collections.emptyList()));
}
private ResultSet mockResultSet() throws SQLException {
ResultSet result = mock(ResultSet.class);
ResultSetMetaData resultSetMetaData = mock(ResultSetMetaData.class);
when(result.getMetaData()).thenReturn(resultSetMetaData);
when(resultSetMetaData.getColumnCount()).thenReturn(5);
when(resultSetMetaData.getColumnLabel(1)).thenReturn("COUNT(*)");
when(resultSetMetaData.getColumnLabel(2)).thenReturn("AVG(num)");
when(resultSetMetaData.getColumnLabel(3)).thenReturn("id");
when(resultSetMetaData.getColumnLabel(4)).thenReturn("AVG_DERIVED_COUNT_0");
when(resultSetMetaData.getColumnLabel(5)).thenReturn("AVG_DERIVED_SUM_0");
return result;
}
private OrderByItem createOrderByItem(final IndexOrderByItemSegment indexOrderByItemSegment) {
OrderByItem result = new OrderByItem(indexOrderByItemSegment);
result.setIndex(indexOrderByItemSegment.getColumnIndex());
return result;
}
@Test
public void assertNextForResultSetsAllEmpty() throws SQLException {
mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("MySQL"), selectSQLStatementContext, queryResults);
MergedResult actual = mergeEngine.merge();
assertFalse(actual.next());
}
@Test
public void assertNextForSomeResultSetsEmpty() throws SQLException {
mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("MySQL"), selectSQLStatementContext, queryResults);
when(resultSets.get(0).next()).thenReturn(true, false);
when(resultSets.get(0).getObject(1)).thenReturn(20);
when(resultSets.get(0).getObject(2)).thenReturn(0);
when(resultSets.get(0).getObject(3)).thenReturn(2);
when(resultSets.get(0).getObject(4)).thenReturn(2);
when(resultSets.get(0).getObject(5)).thenReturn(20);
when(resultSets.get(2).next()).thenReturn(true, true, false);
when(resultSets.get(2).getObject(1)).thenReturn(20, 30);
when(resultSets.get(2).getObject(2)).thenReturn(0);
when(resultSets.get(2).getObject(3)).thenReturn(2, 3);
when(resultSets.get(2).getObject(4)).thenReturn(2, 2, 3);
when(resultSets.get(2).getObject(5)).thenReturn(20, 20, 30);
MergedResult actual = mergeEngine.merge();
assertTrue(actual.next());
assertThat((BigDecimal) actual.getValue(1, Object.class), is(new BigDecimal(30)));
assertThat(((BigDecimal) actual.getValue(2, Object.class)).intValue(), is(10));
assertThat((Integer) actual.getValue(3, Object.class), is(3));
assertThat((BigDecimal) actual.getValue(4, Object.class), is(new BigDecimal(3)));
assertThat((BigDecimal) actual.getValue(5, Object.class), is(new BigDecimal(30)));
assertTrue(actual.next());
assertThat((BigDecimal) actual.getValue(1, Object.class), is(new BigDecimal(40)));
assertThat(((BigDecimal) actual.getValue(2, Object.class)).intValue(), is(10));
assertThat((Integer) actual.getValue(3, Object.class), is(2));
assertThat((BigDecimal) actual.getValue(4, Object.class), is(new BigDecimal(4)));
assertThat((BigDecimal) actual.getValue(5, Object.class), is(new BigDecimal(40)));
assertFalse(actual.next());
private QueryResult createQueryResult() throws SQLException {
QueryResult result = mock(QueryResult.class);
when(result.getColumnCount()).thenReturn(5);
when(result.getColumnLabel(1)).thenReturn("COUNT(*)");
when(result.getColumnLabel(2)).thenReturn("AVG(num)");
when(result.getColumnLabel(3)).thenReturn("id");
when(result.getColumnLabel(4)).thenReturn("AVG_DERIVED_COUNT_0");
when(result.getColumnLabel(5)).thenReturn("AVG_DERIVED_SUM_0");
return result;
}
}
sharding-core/sharding-core-merge/src/test/java/org/apache/shardingsphere/core/merge/dql/groupby/GroupByRowComparatorTest.java
浏览文件 @ 6e33a073
......@@ -20,15 +20,14 @@ package org.apache.shardingsphere.core.merge.dql.groupby;
import com.google.common.collect.Lists;
import org.apache.shardingsphere.core.execute.sql.execute.result.QueryResult;
import org.apache.shardingsphere.core.merge.dql.common.MemoryQueryResultRow;
import org.apache.shardingsphere.core.merge.fixture.ResultSetBasedQueryResultFixture;
import org.apache.shardingsphere.sql.parser.core.constant.OrderDirection;
import org.apache.shardingsphere.sql.parser.relation.segment.select.groupby.GroupByContext;
import org.apache.shardingsphere.sql.parser.relation.segment.select.projection.Projection;
import org.apache.shardingsphere.sql.parser.relation.segment.select.projection.ProjectionsContext;
import org.apache.shardingsphere.sql.parser.relation.segment.select.orderby.OrderByContext;
import org.apache.shardingsphere.sql.parser.relation.segment.select.orderby.OrderByItem;
import org.apache.shardingsphere.sql.parser.relation.segment.select.pagination.PaginationContext;
import org.apache.shardingsphere.sql.parser.relation.segment.select.projection.Projection;
import org.apache.shardingsphere.sql.parser.relation.segment.select.projection.ProjectionsContext;
import org.apache.shardingsphere.sql.parser.relation.statement.impl.SelectSQLStatementContext;
import org.apache.shardingsphere.sql.parser.core.constant.OrderDirection;
import org.apache.shardingsphere.sql.parser.sql.segment.dml.order.item.IndexOrderByItemSegment;
import org.apache.shardingsphere.sql.parser.sql.statement.dml.SelectStatement;
import org.junit.Test;
......@@ -61,8 +60,8 @@ public final class GroupByRowComparatorTest {
createOrderByItem(new IndexOrderByItemSegment(0, 0, 2, OrderDirection.ASC, OrderDirection.ASC))), false),
new ProjectionsContext(0, 0, false, Collections.<Projection>emptyList(), Collections.<String>emptyList()), new PaginationContext(null, null, Collections.emptyList()));
GroupByRowComparator groupByRowComparator = new GroupByRowComparator(selectSQLStatementContext, caseSensitives);
MemoryQueryResultRow o1 = new MemoryQueryResultRow(mockQueryResult("1", "2"));
MemoryQueryResultRow o2 = new MemoryQueryResultRow(mockQueryResult("3", "4"));
MemoryQueryResultRow o1 = new MemoryQueryResultRow(createQueryResult("1", "2"));
MemoryQueryResultRow o2 = new MemoryQueryResultRow(createQueryResult("3", "4"));
assertTrue(groupByRowComparator.compare(o1, o2) < 0);
}
......@@ -77,8 +76,8 @@ public final class GroupByRowComparatorTest {
createOrderByItem(new IndexOrderByItemSegment(0, 0, 2, OrderDirection.DESC, OrderDirection.ASC))), false),
new ProjectionsContext(0, 0, false, Collections.<Projection>emptyList(), Collections.<String>emptyList()), new PaginationContext(null, null, Collections.emptyList()));
GroupByRowComparator groupByRowComparator = new GroupByRowComparator(selectSQLStatementContext, caseSensitives);
MemoryQueryResultRow o1 = new MemoryQueryResultRow(mockQueryResult("1", "2"));
MemoryQueryResultRow o2 = new MemoryQueryResultRow(mockQueryResult("3", "4"));
MemoryQueryResultRow o1 = new MemoryQueryResultRow(createQueryResult("1", "2"));
MemoryQueryResultRow o2 = new MemoryQueryResultRow(createQueryResult("3", "4"));
assertTrue(groupByRowComparator.compare(o1, o2) > 0);
}
......@@ -93,8 +92,8 @@ public final class GroupByRowComparatorTest {
createOrderByItem(new IndexOrderByItemSegment(0, 0, 2, OrderDirection.DESC, OrderDirection.ASC))), false),
new ProjectionsContext(0, 0, false, Collections.<Projection>emptyList(), Collections.<String>emptyList()), new PaginationContext(null, null, Collections.emptyList()));
GroupByRowComparator groupByRowComparator = new GroupByRowComparator(selectSQLStatementContext, caseSensitives);
MemoryQueryResultRow o1 = new MemoryQueryResultRow(mockQueryResult("1", "2"));
MemoryQueryResultRow o2 = new MemoryQueryResultRow(mockQueryResult("1", "2"));
MemoryQueryResultRow o1 = new MemoryQueryResultRow(createQueryResult("1", "2"));
MemoryQueryResultRow o2 = new MemoryQueryResultRow(createQueryResult("1", "2"));
assertThat(groupByRowComparator.compare(o1, o2), is(0));
}
......@@ -106,8 +105,8 @@ public final class GroupByRowComparatorTest {
createOrderByItem(new IndexOrderByItemSegment(0, 0, 2, OrderDirection.ASC, OrderDirection.ASC))), 0), new OrderByContext(Collections.<OrderByItem>emptyList(), false),
new ProjectionsContext(0, 0, false, Collections.<Projection>emptyList(), Collections.<String>emptyList()), new PaginationContext(null, null, Collections.emptyList()));
GroupByRowComparator groupByRowComparator = new GroupByRowComparator(selectSQLStatementContext, caseSensitives);
MemoryQueryResultRow o1 = new MemoryQueryResultRow(mockQueryResult("1", "2"));
MemoryQueryResultRow o2 = new MemoryQueryResultRow(mockQueryResult("3", "4"));
MemoryQueryResultRow o1 = new MemoryQueryResultRow(createQueryResult("1", "2"));
MemoryQueryResultRow o2 = new MemoryQueryResultRow(createQueryResult("3", "4"));
assertTrue(groupByRowComparator.compare(o1, o2) < 0);
}
......@@ -119,8 +118,8 @@ public final class GroupByRowComparatorTest {
createOrderByItem(new IndexOrderByItemSegment(0, 0, 2, OrderDirection.DESC, OrderDirection.ASC))), 0), new OrderByContext(Collections.<OrderByItem>emptyList(), false),
new ProjectionsContext(0, 0, false, Collections.<Projection>emptyList(), Collections.<String>emptyList()), new PaginationContext(null, null, Collections.emptyList()));
GroupByRowComparator groupByRowComparator = new GroupByRowComparator(selectSQLStatementContext, caseSensitives);
MemoryQueryResultRow o1 = new MemoryQueryResultRow(mockQueryResult("1", "2"));
MemoryQueryResultRow o2 = new MemoryQueryResultRow(mockQueryResult("3", "4"));
MemoryQueryResultRow o1 = new MemoryQueryResultRow(createQueryResult("1", "2"));
MemoryQueryResultRow o2 = new MemoryQueryResultRow(createQueryResult("3", "4"));
assertTrue(groupByRowComparator.compare(o1, o2) > 0);
}
......@@ -132,8 +131,8 @@ public final class GroupByRowComparatorTest {
createOrderByItem(new IndexOrderByItemSegment(0, 0, 2, OrderDirection.DESC, OrderDirection.ASC))), 0), new OrderByContext(Collections.<OrderByItem>emptyList(), false),
new ProjectionsContext(0, 0, false, Collections.<Projection>emptyList(), Collections.<String>emptyList()), new PaginationContext(null, null, Collections.emptyList()));
GroupByRowComparator groupByRowComparator = new GroupByRowComparator(selectSQLStatementContext, caseSensitives);
MemoryQueryResultRow o1 = new MemoryQueryResultRow(mockQueryResult("1", "2"));
MemoryQueryResultRow o2 = new MemoryQueryResultRow(mockQueryResult("1", "2"));
MemoryQueryResultRow o1 = new MemoryQueryResultRow(createQueryResult("1", "2"));
MemoryQueryResultRow o2 = new MemoryQueryResultRow(createQueryResult("1", "2"));
assertThat(groupByRowComparator.compare(o1, o2), is(0));
}
......@@ -143,15 +142,17 @@ public final class GroupByRowComparatorTest {
return result;
}
private QueryResult mockQueryResult(final Object... values) throws SQLException {
ResultSet result = mock(ResultSet.class);
private QueryResult createQueryResult(final Object... values) throws SQLException {
ResultSet resultSet = mock(ResultSet.class);
ResultSetMetaData resultSetMetaData = mock(ResultSetMetaData.class);
when(result.getMetaData()).thenReturn(resultSetMetaData);
when(resultSet.getMetaData()).thenReturn(resultSetMetaData);
when(resultSetMetaData.getColumnCount()).thenReturn(values.length);
QueryResult result = mock(QueryResult.class);
when(result.getColumnCount()).thenReturn(values.length);
int index = 0;
for (Object each : values) {
when(result.getObject(++index)).thenReturn(each);
when(result.getValue(++index, Object.class)).thenReturn(each);
}
return new ResultSetBasedQueryResultFixture(result);
return result;
}
}
sharding-core/sharding-core-merge/src/test/java/org/apache/shardingsphere/core/merge/dql/groupby/GroupByStreamMergedResultTest.java
浏览文件 @ 6e33a073
......@@ -17,12 +17,10 @@
package org.apache.shardingsphere.core.merge.dql.groupby;
import com.google.common.collect.Lists;
import org.apache.shardingsphere.core.database.DatabaseTypes;
import org.apache.shardingsphere.core.execute.sql.execute.result.QueryResult;
import org.apache.shardingsphere.core.merge.MergedResult;
import org.apache.shardingsphere.core.merge.dql.DQLMergeEngine;
import org.apache.shardingsphere.core.merge.fixture.ResultSetBasedQueryResultFixture;
import org.apache.shardingsphere.sql.parser.core.constant.AggregationType;
import org.apache.shardingsphere.sql.parser.core.constant.OrderDirection;
import org.apache.shardingsphere.sql.parser.relation.segment.select.groupby.GroupByContext;
......@@ -35,19 +33,14 @@ import org.apache.shardingsphere.sql.parser.relation.segment.select.projection.i
import org.apache.shardingsphere.sql.parser.relation.statement.impl.SelectSQLStatementContext;
import org.apache.shardingsphere.sql.parser.sql.segment.dml.order.item.IndexOrderByItemSegment;
import org.apache.shardingsphere.sql.parser.sql.statement.dml.SelectStatement;
import org.junit.Before;
import org.junit.Test;
import java.math.BigDecimal;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Collections;
import java.util.Date;
import java.util.List;
import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertFalse;
......@@ -58,76 +51,34 @@ import static org.mockito.Mockito.when;
public final class GroupByStreamMergedResultTest {
private DQLMergeEngine mergeEngine;
private List<ResultSet> resultSets;
private List<QueryResult> queryResults;
private SelectSQLStatementContext selectSQLStatementContext;
@Before
public void setUp() throws SQLException {
resultSets = Lists.newArrayList(mockResultSet(), mockResultSet(), mockResultSet());
queryResults = new ArrayList<>(resultSets.size());
for (ResultSet each : resultSets) {
queryResults.add(new ResultSetBasedQueryResultFixture(each));
}
AggregationProjection aggregationSelectItem1 = new AggregationProjection(AggregationType.COUNT, "(*)", null);
aggregationSelectItem1.setIndex(1);
AggregationProjection aggregationSelectItem2 = new AggregationProjection(AggregationType.AVG, "(num)", null);
aggregationSelectItem2.setIndex(2);
AggregationProjection derivedAggregationSelectItem1 = new AggregationProjection(AggregationType.COUNT, "(num)", "AVG_DERIVED_COUNT_0");
aggregationSelectItem2.setIndex(5);
aggregationSelectItem2.getDerivedAggregationProjections().add(derivedAggregationSelectItem1);
AggregationProjection derivedAggregationSelectItem2 = new AggregationProjection(AggregationType.SUM, "(num)", "AVG_DERIVED_SUM_0");
aggregationSelectItem2.setIndex(6);
aggregationSelectItem2.getDerivedAggregationProjections().add(derivedAggregationSelectItem2);
ProjectionsContext projectionsContext = new ProjectionsContext(0, 0, false, Arrays.<Projection>asList(aggregationSelectItem1, aggregationSelectItem2), Collections.<String>emptyList());
selectSQLStatementContext = new SelectSQLStatementContext(new SelectStatement(),
new GroupByContext(Collections.singletonList(new OrderByItem(new IndexOrderByItemSegment(0, 0, 3, OrderDirection.ASC, OrderDirection.ASC))), 0),
new OrderByContext(Collections.singletonList(new OrderByItem(new IndexOrderByItemSegment(0, 0, 3, OrderDirection.ASC, OrderDirection.ASC))), false),
projectionsContext, new PaginationContext(null, null, Collections.emptyList()));
}
private ResultSet mockResultSet() throws SQLException {
ResultSet result = mock(ResultSet.class);
ResultSetMetaData resultSetMetaData = mock(ResultSetMetaData.class);
when(result.getMetaData()).thenReturn(resultSetMetaData);
when(resultSetMetaData.getColumnCount()).thenReturn(6);
when(resultSetMetaData.getColumnLabel(1)).thenReturn("COUNT(*)");
when(resultSetMetaData.getColumnLabel(2)).thenReturn("AVG(num)");
when(resultSetMetaData.getColumnLabel(3)).thenReturn("id");
when(resultSetMetaData.getColumnLabel(4)).thenReturn("date");
when(resultSetMetaData.getColumnLabel(5)).thenReturn("AVG_DERIVED_COUNT_0");
when(resultSetMetaData.getColumnLabel(6)).thenReturn("AVG_DERIVED_SUM_0");
return result;
}
@Test
public void assertNextForResultSetsAllEmpty() throws SQLException {
mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("MySQL"), selectSQLStatementContext, queryResults);
DQLMergeEngine mergeEngine = new DQLMergeEngine(
DatabaseTypes.getActualDatabaseType("MySQL"), createSelectSQLStatementContext(), Arrays.asList(createQueryResult(), createQueryResult(), createQueryResult()));
MergedResult actual = mergeEngine.merge();
assertFalse(actual.next());
}
@Test
public void assertNextForSomeResultSetsEmpty() throws SQLException {
mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("MySQL"), selectSQLStatementContext, queryResults);
when(resultSets.get(0).next()).thenReturn(true, false);
when(resultSets.get(0).getObject(1)).thenReturn(20);
when(resultSets.get(0).getObject(2)).thenReturn(0);
when(resultSets.get(0).getObject(3)).thenReturn(2);
when(resultSets.get(0).getObject(4)).thenReturn(new Date(0L));
when(resultSets.get(0).getObject(5)).thenReturn(2);
when(resultSets.get(0).getObject(6)).thenReturn(20);
when(resultSets.get(2).next()).thenReturn(true, true, false);
when(resultSets.get(2).getObject(1)).thenReturn(20, 30);
when(resultSets.get(2).getObject(2)).thenReturn(0);
when(resultSets.get(2).getObject(3)).thenReturn(2, 2, 3);
when(resultSets.get(2).getObject(4)).thenReturn(new Date(0L));
when(resultSets.get(2).getObject(5)).thenReturn(2, 2, 3);
when(resultSets.get(2).getObject(6)).thenReturn(20, 20, 30);
QueryResult queryResult1 = createQueryResult();
when(queryResult1.next()).thenReturn(true, false);
when(queryResult1.getValue(1, Object.class)).thenReturn(20);
when(queryResult1.getValue(2, Object.class)).thenReturn(0);
when(queryResult1.getValue(3, Object.class)).thenReturn(2);
when(queryResult1.getValue(4, Object.class)).thenReturn(new Date(0L));
when(queryResult1.getValue(5, Object.class)).thenReturn(2);
when(queryResult1.getValue(6, Object.class)).thenReturn(20);
QueryResult queryResult2 = createQueryResult();
QueryResult queryResult3 = createQueryResult();
when(queryResult3.next()).thenReturn(true, true, false);
when(queryResult3.getValue(1, Object.class)).thenReturn(20, 30);
when(queryResult3.getValue(2, Object.class)).thenReturn(0);
when(queryResult3.getValue(3, Object.class)).thenReturn(2, 2, 3);
when(queryResult3.getValue(4, Object.class)).thenReturn(new Date(0L));
when(queryResult3.getValue(5, Object.class)).thenReturn(2, 2, 3);
when(queryResult3.getValue(6, Object.class)).thenReturn(20, 20, 30);
DQLMergeEngine mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("MySQL"), createSelectSQLStatementContext(), Arrays.asList(queryResult1, queryResult2, queryResult3));
MergedResult actual = mergeEngine.merge();
assertTrue(actual.next());
assertThat((BigDecimal) actual.getValue(1, Object.class), is(new BigDecimal(40)));
......@@ -148,25 +99,28 @@ public final class GroupByStreamMergedResultTest {
@Test
public void assertNextForMix() throws SQLException {
mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("MySQL"), selectSQLStatementContext, queryResults);
when(resultSets.get(0).next()).thenReturn(true, false);
when(resultSets.get(0).getObject(1)).thenReturn(20);
when(resultSets.get(0).getObject(2)).thenReturn(0);
when(resultSets.get(0).getObject(3)).thenReturn(2);
when(resultSets.get(0).getObject(5)).thenReturn(2);
when(resultSets.get(0).getObject(6)).thenReturn(20);
when(resultSets.get(1).next()).thenReturn(true, true, true, false);
when(resultSets.get(1).getObject(1)).thenReturn(20, 30, 30, 40);
when(resultSets.get(1).getObject(2)).thenReturn(0);
when(resultSets.get(1).getObject(3)).thenReturn(2, 2, 3, 3, 3, 4);
when(resultSets.get(1).getObject(5)).thenReturn(2, 2, 3, 3, 3, 4);
when(resultSets.get(1).getObject(6)).thenReturn(20, 20, 30, 30, 30, 40);
when(resultSets.get(2).next()).thenReturn(true, true, false);
when(resultSets.get(2).getObject(1)).thenReturn(10, 30);
when(resultSets.get(2).getObject(2)).thenReturn(10);
when(resultSets.get(2).getObject(3)).thenReturn(1, 1, 1, 1, 3);
when(resultSets.get(2).getObject(5)).thenReturn(1, 1, 3);
when(resultSets.get(2).getObject(6)).thenReturn(10, 10, 30);
QueryResult queryResult1 = createQueryResult();
when(queryResult1.next()).thenReturn(true, false);
when(queryResult1.getValue(1, Object.class)).thenReturn(20);
when(queryResult1.getValue(2, Object.class)).thenReturn(0);
when(queryResult1.getValue(3, Object.class)).thenReturn(2);
when(queryResult1.getValue(5, Object.class)).thenReturn(2);
when(queryResult1.getValue(6, Object.class)).thenReturn(20);
QueryResult queryResult2 = createQueryResult();
when(queryResult2.next()).thenReturn(true, true, true, false);
when(queryResult2.getValue(1, Object.class)).thenReturn(20, 30, 30, 40);
when(queryResult2.getValue(2, Object.class)).thenReturn(0);
when(queryResult2.getValue(3, Object.class)).thenReturn(2, 2, 3, 3, 3, 4);
when(queryResult2.getValue(5, Object.class)).thenReturn(2, 2, 3, 3, 3, 4);
when(queryResult2.getValue(6, Object.class)).thenReturn(20, 20, 30, 30, 30, 40);
QueryResult queryResult3 = createQueryResult();
when(queryResult3.next()).thenReturn(true, true, false);
when(queryResult3.getValue(1, Object.class)).thenReturn(10, 30);
when(queryResult3.getValue(2, Object.class)).thenReturn(10);
when(queryResult3.getValue(3, Object.class)).thenReturn(1, 1, 1, 1, 3);
when(queryResult3.getValue(5, Object.class)).thenReturn(1, 1, 3);
when(queryResult3.getValue(6, Object.class)).thenReturn(10, 10, 30);
DQLMergeEngine mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("MySQL"), createSelectSQLStatementContext(), Arrays.asList(queryResult1, queryResult2, queryResult3));
MergedResult actual = mergeEngine.merge();
assertTrue(actual.next());
assertThat((BigDecimal) actual.getValue(1, Object.class), is(new BigDecimal(10)));
......@@ -194,4 +148,34 @@ public final class GroupByStreamMergedResultTest {
assertThat((BigDecimal) actual.getValue(6, Object.class), is(new BigDecimal(40)));
assertFalse(actual.next());
}
private SelectSQLStatementContext createSelectSQLStatementContext() {
AggregationProjection aggregationSelectItem1 = new AggregationProjection(AggregationType.COUNT, "(*)", null);
aggregationSelectItem1.setIndex(1);
AggregationProjection aggregationSelectItem2 = new AggregationProjection(AggregationType.AVG, "(num)", null);
aggregationSelectItem2.setIndex(2);
AggregationProjection derivedAggregationSelectItem1 = new AggregationProjection(AggregationType.COUNT, "(num)", "AVG_DERIVED_COUNT_0");
aggregationSelectItem2.setIndex(5);
aggregationSelectItem2.getDerivedAggregationProjections().add(derivedAggregationSelectItem1);
AggregationProjection derivedAggregationSelectItem2 = new AggregationProjection(AggregationType.SUM, "(num)", "AVG_DERIVED_SUM_0");
aggregationSelectItem2.setIndex(6);
aggregationSelectItem2.getDerivedAggregationProjections().add(derivedAggregationSelectItem2);
ProjectionsContext projectionsContext = new ProjectionsContext(0, 0, false, Arrays.<Projection>asList(aggregationSelectItem1, aggregationSelectItem2), Collections.<String>emptyList());
return new SelectSQLStatementContext(new SelectStatement(),
new GroupByContext(Collections.singletonList(new OrderByItem(new IndexOrderByItemSegment(0, 0, 3, OrderDirection.ASC, OrderDirection.ASC))), 0),
new OrderByContext(Collections.singletonList(new OrderByItem(new IndexOrderByItemSegment(0, 0, 3, OrderDirection.ASC, OrderDirection.ASC))), false),
projectionsContext, new PaginationContext(null, null, Collections.emptyList()));
}
private QueryResult createQueryResult() throws SQLException {
QueryResult result = mock(QueryResult.class);
when(result.getColumnCount()).thenReturn(6);
when(result.getColumnLabel(1)).thenReturn("COUNT(*)");
when(result.getColumnLabel(2)).thenReturn("AVG(num)");
when(result.getColumnLabel(3)).thenReturn("id");
when(result.getColumnLabel(4)).thenReturn("date");
when(result.getColumnLabel(5)).thenReturn("AVG_DERIVED_COUNT_0");
when(result.getColumnLabel(6)).thenReturn("AVG_DERIVED_SUM_0");
return result;
}
}
sharding-core/sharding-core-merge/src/test/java/org/apache/shardingsphere/core/merge/dql/groupby/GroupByValueTest.java
浏览文件 @ 6e33a073
......@@ -17,9 +17,9 @@
package org.apache.shardingsphere.core.merge.dql.groupby;
import org.apache.shardingsphere.core.merge.fixture.ResultSetBasedQueryResultFixture;
import org.apache.shardingsphere.sql.parser.relation.segment.select.orderby.OrderByItem;
import org.apache.shardingsphere.core.execute.sql.execute.result.QueryResult;
import org.apache.shardingsphere.sql.parser.core.constant.OrderDirection;
import org.apache.shardingsphere.sql.parser.relation.segment.select.orderby.OrderByItem;
import org.apache.shardingsphere.sql.parser.sql.segment.dml.order.item.IndexOrderByItemSegment;
import org.junit.Before;
import org.junit.Test;
......@@ -27,7 +27,6 @@ import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Arrays;
import java.util.List;
......@@ -40,18 +39,17 @@ import static org.mockito.Mockito.when;
public final class GroupByValueTest {
@Mock
private ResultSet resultSet;
private QueryResult queryResult;
@Before
public void setUp() throws SQLException {
when(resultSet.getObject(1)).thenReturn("1");
when(resultSet.getObject(3)).thenReturn("3");
when(queryResult.getValue(1, Object.class)).thenReturn("1");
when(queryResult.getValue(3, Object.class)).thenReturn("3");
}
@Test
public void assertGetGroupByValues() throws SQLException {
List<?> actual = new GroupByValue(new ResultSetBasedQueryResultFixture(resultSet),
Arrays.asList(
List<?> actual = new GroupByValue(queryResult, Arrays.asList(
createOrderByItem(new IndexOrderByItemSegment(0, 0, 1, OrderDirection.ASC, OrderDirection.ASC)),
createOrderByItem(new IndexOrderByItemSegment(0, 0, 3, OrderDirection.DESC, OrderDirection.ASC)))).getGroupValues();
List<?> expected = Arrays.asList("1", "3");
......@@ -60,12 +58,10 @@ public final class GroupByValueTest {
@Test
public void assertGroupByValueEquals() throws SQLException {
GroupByValue groupByValue1 = new GroupByValue(new ResultSetBasedQueryResultFixture(resultSet),
Arrays.asList(
GroupByValue groupByValue1 = new GroupByValue(queryResult, Arrays.asList(
createOrderByItem(new IndexOrderByItemSegment(0, 0, 1, OrderDirection.ASC, OrderDirection.ASC)),
createOrderByItem(new IndexOrderByItemSegment(0, 0, 3, OrderDirection.DESC, OrderDirection.ASC))));
GroupByValue groupByValue2 = new GroupByValue(new ResultSetBasedQueryResultFixture(resultSet),
Arrays.asList(
GroupByValue groupByValue2 = new GroupByValue(queryResult, Arrays.asList(
createOrderByItem(new IndexOrderByItemSegment(0, 0, 1, OrderDirection.ASC, OrderDirection.ASC)),
createOrderByItem(new IndexOrderByItemSegment(0, 0, 3, OrderDirection.DESC, OrderDirection.ASC))));
assertTrue(groupByValue1.equals(groupByValue2));
......@@ -75,12 +71,10 @@ public final class GroupByValueTest {
@Test
public void assertGroupByValueNotEquals() throws SQLException {
GroupByValue groupByValue1 = new GroupByValue(new ResultSetBasedQueryResultFixture(resultSet),
Arrays.asList(
GroupByValue groupByValue1 = new GroupByValue(queryResult, Arrays.asList(
createOrderByItem(new IndexOrderByItemSegment(0, 0, 1, OrderDirection.ASC, OrderDirection.ASC)),
createOrderByItem(new IndexOrderByItemSegment(0, 0, 3, OrderDirection.DESC, OrderDirection.ASC))));
GroupByValue groupByValue2 = new GroupByValue(new ResultSetBasedQueryResultFixture(resultSet),
Arrays.asList(
GroupByValue groupByValue2 = new GroupByValue(queryResult, Arrays.asList(
createOrderByItem(new IndexOrderByItemSegment(0, 0, 3, OrderDirection.ASC, OrderDirection.ASC)),
createOrderByItem(new IndexOrderByItemSegment(0, 0, 1, OrderDirection.DESC, OrderDirection.ASC))));
assertFalse(groupByValue1.equals(groupByValue2));
......
sharding-core/sharding-core-merge/src/test/java/org/apache/shardingsphere/core/merge/dql/iterator/IteratorStreamMergedResultTest.java
浏览文件 @ 6e33a073
......@@ -17,12 +17,10 @@
package org.apache.shardingsphere.core.merge.dql.iterator;
import com.google.common.collect.Lists;
import org.apache.shardingsphere.core.database.DatabaseTypes;
import org.apache.shardingsphere.core.execute.sql.execute.result.QueryResult;
import org.apache.shardingsphere.core.merge.MergedResult;
import org.apache.shardingsphere.core.merge.dql.DQLMergeEngine;
import org.apache.shardingsphere.core.merge.fixture.ResultSetBasedQueryResultFixture;
import org.apache.shardingsphere.sql.parser.relation.segment.select.groupby.GroupByContext;
import org.apache.shardingsphere.sql.parser.relation.segment.select.orderby.OrderByContext;
import org.apache.shardingsphere.sql.parser.relation.segment.select.orderby.OrderByItem;
......@@ -34,9 +32,8 @@ import org.apache.shardingsphere.sql.parser.sql.statement.dml.SelectStatement;
import org.junit.Before;
import org.junit.Test;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
......@@ -47,19 +44,10 @@ import static org.mockito.Mockito.when;
public final class IteratorStreamMergedResultTest {
private DQLMergeEngine mergeEngine;
private List<QueryResult> queryResults;
private SelectSQLStatementContext selectSQLStatementContext;
@Before
public void setUp() throws SQLException {
ResultSet resultSet = mock(ResultSet.class);
ResultSetMetaData resultSetMetaData = mock(ResultSetMetaData.class);
when(resultSet.getMetaData()).thenReturn(resultSetMetaData);
queryResults = Lists.<QueryResult>newArrayList(
new ResultSetBasedQueryResultFixture(resultSet), new ResultSetBasedQueryResultFixture(mock(ResultSet.class)), new ResultSetBasedQueryResultFixture(mock(ResultSet.class)));
public void setUp() {
selectSQLStatementContext = new SelectSQLStatementContext(new SelectStatement(),
new GroupByContext(Collections.<OrderByItem>emptyList(), 0), new OrderByContext(Collections.<OrderByItem>emptyList(), false),
new ProjectionsContext(0, 0, false, Collections.<Projection>emptyList(), Collections.<String>emptyList()), new PaginationContext(null, null, Collections.emptyList()));
......@@ -67,17 +55,19 @@ public final class IteratorStreamMergedResultTest {
@Test
public void assertNextForResultSetsAllEmpty() throws SQLException {
mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("MySQL"), selectSQLStatementContext, queryResults);
List<QueryResult> queryResults = Arrays.asList(mock(QueryResult.class), mock(QueryResult.class), mock(QueryResult.class));
DQLMergeEngine mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("MySQL"), selectSQLStatementContext, queryResults);
MergedResult actual = mergeEngine.merge();
assertFalse(actual.next());
}
@Test
public void assertNextForResultSetsAllNotEmpty() throws SQLException {
List<QueryResult> queryResults = Arrays.asList(mock(QueryResult.class), mock(QueryResult.class), mock(QueryResult.class));
for (QueryResult each : queryResults) {
when(each.next()).thenReturn(true, false);
}
mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("MySQL"), selectSQLStatementContext, queryResults);
DQLMergeEngine mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("MySQL"), selectSQLStatementContext, queryResults);
MergedResult actual = mergeEngine.merge();
assertTrue(actual.next());
assertTrue(actual.next());
......@@ -87,8 +77,9 @@ public final class IteratorStreamMergedResultTest {
@Test
public void assertNextForFirstResultSetsNotEmptyOnly() throws SQLException {
List<QueryResult> queryResults = Arrays.asList(mock(QueryResult.class), mock(QueryResult.class), mock(QueryResult.class));
when(queryResults.get(0).next()).thenReturn(true, false);
mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("MySQL"), selectSQLStatementContext, queryResults);
DQLMergeEngine mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("MySQL"), selectSQLStatementContext, queryResults);
MergedResult actual = mergeEngine.merge();
assertTrue(actual.next());
assertFalse(actual.next());
......@@ -96,8 +87,9 @@ public final class IteratorStreamMergedResultTest {
@Test
public void assertNextForMiddleResultSetsNotEmpty() throws SQLException {
List<QueryResult> queryResults = Arrays.asList(mock(QueryResult.class), mock(QueryResult.class), mock(QueryResult.class));
when(queryResults.get(1).next()).thenReturn(true, false);
mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("MySQL"), selectSQLStatementContext, queryResults);
DQLMergeEngine mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("MySQL"), selectSQLStatementContext, queryResults);
MergedResult actual = mergeEngine.merge();
assertTrue(actual.next());
assertFalse(actual.next());
......@@ -105,8 +97,9 @@ public final class IteratorStreamMergedResultTest {
@Test
public void assertNextForLastResultSetsNotEmptyOnly() throws SQLException {
List<QueryResult> queryResults = Arrays.asList(mock(QueryResult.class), mock(QueryResult.class), mock(QueryResult.class));
when(queryResults.get(2).next()).thenReturn(true, false);
mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("MySQL"), selectSQLStatementContext, queryResults);
DQLMergeEngine mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("MySQL"), selectSQLStatementContext, queryResults);
MergedResult actual = mergeEngine.merge();
assertTrue(actual.next());
assertFalse(actual.next());
......@@ -114,13 +107,12 @@ public final class IteratorStreamMergedResultTest {
@Test
public void assertNextForMix() throws SQLException {
queryResults.add(new ResultSetBasedQueryResultFixture(mock(ResultSet.class)));
queryResults.add(new ResultSetBasedQueryResultFixture(mock(ResultSet.class)));
queryResults.add(new ResultSetBasedQueryResultFixture(mock(ResultSet.class)));
List<QueryResult> queryResults = Arrays.asList(
mock(QueryResult.class), mock(QueryResult.class), mock(QueryResult.class), mock(QueryResult.class), mock(QueryResult.class), mock(QueryResult.class));
when(queryResults.get(1).next()).thenReturn(true, false);
when(queryResults.get(3).next()).thenReturn(true, false);
when(queryResults.get(5).next()).thenReturn(true, false);
mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("MySQL"), selectSQLStatementContext, queryResults);
DQLMergeEngine mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("MySQL"), selectSQLStatementContext, queryResults);
MergedResult actual = mergeEngine.merge();
assertTrue(actual.next());
assertTrue(actual.next());
......
sharding-core/sharding-core-merge/src/test/java/org/apache/shardingsphere/core/merge/dql/orderby/OrderByStreamMergedResultTest.java
浏览文件 @ 6e33a073
......@@ -17,12 +17,10 @@
package org.apache.shardingsphere.core.merge.dql.orderby;
import com.google.common.collect.Lists;
import org.apache.shardingsphere.core.database.DatabaseTypes;
import org.apache.shardingsphere.core.execute.sql.execute.result.QueryResult;
import org.apache.shardingsphere.core.merge.MergedResult;
import org.apache.shardingsphere.core.merge.dql.DQLMergeEngine;
import org.apache.shardingsphere.core.merge.fixture.ResultSetBasedQueryResultFixture;
import org.apache.shardingsphere.sql.parser.core.constant.OrderDirection;
import org.apache.shardingsphere.sql.parser.relation.segment.select.groupby.GroupByContext;
import org.apache.shardingsphere.sql.parser.relation.segment.select.orderby.OrderByContext;
......@@ -36,9 +34,8 @@ import org.apache.shardingsphere.sql.parser.sql.statement.dml.SelectStatement;
import org.junit.Before;
import org.junit.Test;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
......@@ -51,39 +48,28 @@ import static org.mockito.Mockito.when;
public final class OrderByStreamMergedResultTest {
private DQLMergeEngine mergeEngine;
private List<QueryResult> queryResults;
private SelectSQLStatementContext selectSQLStatementContext;
@Before
public void setUp() throws SQLException {
queryResults = Lists.<QueryResult>newArrayList(
new ResultSetBasedQueryResultFixture(mockResultSet()), new ResultSetBasedQueryResultFixture(mockResultSet()), new ResultSetBasedQueryResultFixture(mockResultSet()));
public void setUp() {
selectSQLStatementContext = new SelectSQLStatementContext(new SelectStatement(),
new GroupByContext(Collections.<OrderByItem>emptyList(), 0),
new OrderByContext(Collections.singletonList(new OrderByItem(new IndexOrderByItemSegment(0, 0, 1, OrderDirection.ASC, OrderDirection.ASC))), false),
new ProjectionsContext(0, 0, false, Collections.<Projection>emptyList(), Collections.<String>emptyList()), new PaginationContext(null, null, Collections.emptyList()));
}
private ResultSet mockResultSet() throws SQLException {
ResultSet result = mock(ResultSet.class);
ResultSetMetaData resultSetMetaData = mock(ResultSetMetaData.class);
when(result.getMetaData()).thenReturn(resultSetMetaData);
return result;
}
@Test
public void assertNextForResultSetsAllEmpty() throws SQLException {
mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("MySQL"), selectSQLStatementContext, queryResults);
List<QueryResult> queryResults = Arrays.asList(mock(QueryResult.class), mock(QueryResult.class), mock(QueryResult.class));
DQLMergeEngine mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("MySQL"), selectSQLStatementContext, queryResults);
MergedResult actual = mergeEngine.merge();
assertFalse(actual.next());
}
@Test
public void assertNextForSomeResultSetsEmpty() throws SQLException {
mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("MySQL"), selectSQLStatementContext, queryResults);
List<QueryResult> queryResults = Arrays.asList(mock(QueryResult.class), mock(QueryResult.class), mock(QueryResult.class));
DQLMergeEngine mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("MySQL"), selectSQLStatementContext, queryResults);
when(queryResults.get(0).next()).thenReturn(true, false);
when(queryResults.get(0).getValue(1, Object.class)).thenReturn("2");
when(queryResults.get(2).next()).thenReturn(true, true, false);
......@@ -100,7 +86,8 @@ public final class OrderByStreamMergedResultTest {
@Test
public void assertNextForMix() throws SQLException {
mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("MySQL"), selectSQLStatementContext, queryResults);
List<QueryResult> queryResults = Arrays.asList(mock(QueryResult.class), mock(QueryResult.class), mock(QueryResult.class));
DQLMergeEngine mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("MySQL"), selectSQLStatementContext, queryResults);
when(queryResults.get(0).next()).thenReturn(true, false);
when(queryResults.get(0).getValue(1, Object.class)).thenReturn("2");
when(queryResults.get(1).next()).thenReturn(true, true, true, false);
......@@ -125,6 +112,7 @@ public final class OrderByStreamMergedResultTest {
@Test
public void assertNextForCaseSensitive() throws SQLException {
List<QueryResult> queryResults = Arrays.asList(mock(QueryResult.class), mock(QueryResult.class), mock(QueryResult.class));
when(queryResults.get(0).next()).thenReturn(true, false);
when(queryResults.get(0).isCaseSensitive(1)).thenReturn(true);
when(queryResults.get(0).getValue(1, Object.class)).thenReturn("b");
......@@ -134,7 +122,7 @@ public final class OrderByStreamMergedResultTest {
when(queryResults.get(2).next()).thenReturn(true, false);
when(queryResults.get(2).isCaseSensitive(1)).thenReturn(true);
when(queryResults.get(2).getValue(1, Object.class)).thenReturn("A");
mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("MySQL"), selectSQLStatementContext, queryResults);
DQLMergeEngine mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("MySQL"), selectSQLStatementContext, queryResults);
MergedResult actual = mergeEngine.merge();
assertTrue(actual.next());
assertThat(actual.getValue(1, Object.class).toString(), is("A"));
......@@ -149,6 +137,7 @@ public final class OrderByStreamMergedResultTest {
@Test
public void assertNextForCaseInsensitive() throws SQLException {
List<QueryResult> queryResults = Arrays.asList(mock(QueryResult.class), mock(QueryResult.class), mock(QueryResult.class));
when(queryResults.get(0).next()).thenReturn(true, false);
when(queryResults.get(0).isCaseSensitive(1)).thenReturn(false);
when(queryResults.get(0).getValue(1, Object.class)).thenReturn("b");
......@@ -158,7 +147,7 @@ public final class OrderByStreamMergedResultTest {
when(queryResults.get(2).next()).thenReturn(true, false);
when(queryResults.get(2).isCaseSensitive(1)).thenReturn(false);
when(queryResults.get(2).getValue(1, Object.class)).thenReturn("A");
mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("MySQL"), selectSQLStatementContext, queryResults);
DQLMergeEngine mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("MySQL"), selectSQLStatementContext, queryResults);
MergedResult actual = mergeEngine.merge();
assertTrue(actual.next());
assertThat(actual.getValue(1, Object.class).toString(), is("a"));
......
sharding-core/sharding-core-merge/src/test/java/org/apache/shardingsphere/core/merge/dql/orderby/OrderByValueTest.java
浏览文件 @ 6e33a073
......@@ -17,18 +17,12 @@
package org.apache.shardingsphere.core.merge.dql.orderby;
import org.apache.shardingsphere.core.merge.fixture.ResultSetBasedQueryResultFixture;
import org.apache.shardingsphere.sql.parser.relation.segment.select.orderby.OrderByItem;
import org.apache.shardingsphere.core.execute.sql.execute.result.QueryResult;
import org.apache.shardingsphere.sql.parser.core.constant.OrderDirection;
import org.apache.shardingsphere.sql.parser.relation.segment.select.orderby.OrderByItem;
import org.apache.shardingsphere.sql.parser.sql.segment.dml.order.item.IndexOrderByItemSegment;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.Arrays;
......@@ -36,43 +30,20 @@ import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertThat;
import static org.junit.Assert.assertTrue;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.class)
public final class OrderByValueTest {
@Mock
private ResultSet resultSet1;
@Mock
private ResultSet resultSet2;
@Mock
private ResultSetMetaData resultSetMetaData;
@Before
public void setUp() throws SQLException {
when(resultSet1.next()).thenReturn(true, false);
when(resultSet2.next()).thenReturn(true, false);
when(resultSet1.getObject(1)).thenReturn("1");
when(resultSet1.getObject(2)).thenReturn("2");
when(resultSet1.getMetaData()).thenReturn(resultSetMetaData);
when(resultSet2.getMetaData()).thenReturn(resultSetMetaData);
when(resultSetMetaData.isCaseSensitive(1)).thenReturn(false);
when(resultSetMetaData.isCaseSensitive(1)).thenReturn(true);
}
@Test
public void assertCompareToForAsc() throws SQLException {
OrderByValue orderByValue1 = new OrderByValue(new ResultSetBasedQueryResultFixture(resultSet1),
Arrays.asList(
QueryResult queryResult1 = createQueryResult("1", "2");
OrderByValue orderByValue1 = new OrderByValue(queryResult1, Arrays.asList(
createOrderByItem(new IndexOrderByItemSegment(0, 0, 1, OrderDirection.ASC, OrderDirection.ASC)),
createOrderByItem(new IndexOrderByItemSegment(0, 0, 2, OrderDirection.ASC, OrderDirection.ASC))));
assertTrue(orderByValue1.next());
when(resultSet2.getObject(1)).thenReturn("3");
when(resultSet2.getObject(2)).thenReturn("4");
OrderByValue orderByValue2 = new OrderByValue(new ResultSetBasedQueryResultFixture(resultSet2),
Arrays.asList(
QueryResult queryResult2 = createQueryResult("3", "4");
OrderByValue orderByValue2 = new OrderByValue(queryResult2, Arrays.asList(
createOrderByItem(new IndexOrderByItemSegment(0, 0, 1, OrderDirection.ASC, OrderDirection.ASC)),
createOrderByItem(new IndexOrderByItemSegment(0, 0, 2, OrderDirection.ASC, OrderDirection.ASC))));
assertTrue(orderByValue2.next());
......@@ -83,15 +54,13 @@ public final class OrderByValueTest {
@Test
public void assertCompareToForDesc() throws SQLException {
OrderByValue orderByValue1 = new OrderByValue(new ResultSetBasedQueryResultFixture(resultSet1),
Arrays.asList(
QueryResult queryResult1 = createQueryResult("1", "2");
OrderByValue orderByValue1 = new OrderByValue(queryResult1, Arrays.asList(
createOrderByItem(new IndexOrderByItemSegment(0, 0, 1, OrderDirection.DESC, OrderDirection.ASC)),
createOrderByItem(new IndexOrderByItemSegment(0, 0, 2, OrderDirection.DESC, OrderDirection.ASC))));
assertTrue(orderByValue1.next());
when(resultSet2.getObject(1)).thenReturn("3");
when(resultSet2.getObject(2)).thenReturn("4");
OrderByValue orderByValue2 = new OrderByValue(new ResultSetBasedQueryResultFixture(resultSet2),
Arrays.asList(
QueryResult queryResult2 = createQueryResult("3", "4");
OrderByValue orderByValue2 = new OrderByValue(queryResult2, Arrays.asList(
createOrderByItem(new IndexOrderByItemSegment(0, 0, 1, OrderDirection.DESC, OrderDirection.ASC)),
createOrderByItem(new IndexOrderByItemSegment(0, 0, 2, OrderDirection.DESC, OrderDirection.ASC))));
assertTrue(orderByValue2.next());
......@@ -102,14 +71,13 @@ public final class OrderByValueTest {
@Test
public void assertCompareToWhenEqual() throws SQLException {
OrderByValue orderByValue1 = new OrderByValue(new ResultSetBasedQueryResultFixture(resultSet1),
Arrays.asList(
QueryResult queryResult1 = createQueryResult("1", "2");
OrderByValue orderByValue1 = new OrderByValue(queryResult1, Arrays.asList(
createOrderByItem(new IndexOrderByItemSegment(0, 0, 1, OrderDirection.ASC, OrderDirection.ASC)),
createOrderByItem(new IndexOrderByItemSegment(0, 0, 2, OrderDirection.DESC, OrderDirection.ASC))));
assertTrue(orderByValue1.next());
when(resultSet2.getObject(1)).thenReturn("1");
when(resultSet2.getObject(2)).thenReturn("2");
OrderByValue orderByValue2 = new OrderByValue(new ResultSetBasedQueryResultFixture(resultSet2),
QueryResult queryResult2 = createQueryResult("1", "2");
OrderByValue orderByValue2 = new OrderByValue(queryResult2,
Arrays.asList(createOrderByItem(new IndexOrderByItemSegment(0, 0, 1, OrderDirection.ASC, OrderDirection.ASC)),
createOrderByItem(new IndexOrderByItemSegment(0, 0, 2, OrderDirection.DESC, OrderDirection.ASC))));
assertTrue(orderByValue2.next());
......@@ -118,6 +86,15 @@ public final class OrderByValueTest {
assertFalse(orderByValue2.getQueryResult().next());
}
private QueryResult createQueryResult(final String... values) throws SQLException {
QueryResult result = mock(QueryResult.class);
when(result.next()).thenReturn(true, false);
for (int i = 0; i < values.length; i++) {
when(result.getValue(i + 1, Object.class)).thenReturn(values[i]);
}
return result;
}
private OrderByItem createOrderByItem(final IndexOrderByItemSegment indexOrderByItemSegment) {
OrderByItem result = new OrderByItem(indexOrderByItemSegment);
result.setIndex(indexOrderByItemSegment.getColumnIndex());
......
sharding-core/sharding-core-merge/src/test/java/org/apache/shardingsphere/core/merge/dql/pagination/LimitDecoratorMergedResultTest.java
浏览文件 @ 6e33a073
......@@ -17,12 +17,10 @@
package org.apache.shardingsphere.core.merge.dql.pagination;
import com.google.common.collect.Lists;
import org.apache.shardingsphere.core.database.DatabaseTypes;
import org.apache.shardingsphere.core.execute.sql.execute.result.QueryResult;
import org.apache.shardingsphere.core.merge.MergedResult;
import org.apache.shardingsphere.core.merge.dql.DQLMergeEngine;
import org.apache.shardingsphere.core.merge.fixture.ResultSetBasedQueryResultFixture;
import org.apache.shardingsphere.sql.parser.relation.segment.select.groupby.GroupByContext;
import org.apache.shardingsphere.sql.parser.relation.segment.select.orderby.OrderByContext;
import org.apache.shardingsphere.sql.parser.relation.segment.select.orderby.OrderByItem;
......@@ -32,15 +30,11 @@ import org.apache.shardingsphere.sql.parser.relation.segment.select.projection.P
import org.apache.shardingsphere.sql.parser.relation.statement.impl.SelectSQLStatementContext;
import org.apache.shardingsphere.sql.parser.sql.segment.dml.pagination.limit.NumberLiteralLimitValueSegment;
import org.apache.shardingsphere.sql.parser.sql.statement.dml.SelectStatement;
import org.junit.Before;
import org.junit.Test;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
......@@ -49,32 +43,14 @@ import static org.mockito.Mockito.when;
public final class LimitDecoratorMergedResultTest {
private DQLMergeEngine mergeEngine;
private List<QueryResult> queryResults;
@Before
public void setUp() throws SQLException {
ResultSet resultSet = mock(ResultSet.class);
ResultSetMetaData resultSetMetaData = mock(ResultSetMetaData.class);
when(resultSet.getMetaData()).thenReturn(resultSetMetaData);
List<ResultSet> resultSets = Lists.newArrayList(resultSet, mock(ResultSet.class), mock(ResultSet.class), mock(ResultSet.class));
for (ResultSet each : resultSets) {
when(each.next()).thenReturn(true, true, false);
}
queryResults = new ArrayList<>(resultSets.size());
for (ResultSet each : resultSets) {
queryResults.add(new ResultSetBasedQueryResultFixture(each));
}
}
@Test
public void assertNextForSkipAll() throws SQLException {
SelectSQLStatementContext selectSQLStatementContext = new SelectSQLStatementContext(new SelectStatement(),
new GroupByContext(Collections.<OrderByItem>emptyList(), 0), new OrderByContext(Collections.<OrderByItem>emptyList(), false),
new ProjectionsContext(0, 0, false, Collections.<Projection>emptyList(), Collections.<String>emptyList()),
new PaginationContext(new NumberLiteralLimitValueSegment(0, 0, Integer.MAX_VALUE), null, Collections.emptyList()));
mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("MySQL"), selectSQLStatementContext, queryResults);
DQLMergeEngine mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("MySQL"), selectSQLStatementContext,
Arrays.asList(createQueryResult(), createQueryResult(), createQueryResult(), createQueryResult()));
MergedResult actual = mergeEngine.merge();
assertFalse(actual.next());
}
......@@ -85,7 +61,8 @@ public final class LimitDecoratorMergedResultTest {
new GroupByContext(Collections.<OrderByItem>emptyList(), 0), new OrderByContext(Collections.<OrderByItem>emptyList(), false),
new ProjectionsContext(0, 0, false, Collections.<Projection>emptyList(), Collections.<String>emptyList()),
new PaginationContext(new NumberLiteralLimitValueSegment(0, 0, 2), null, Collections.emptyList()));
mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("MySQL"), selectSQLStatementContext, queryResults);
DQLMergeEngine mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("MySQL"), selectSQLStatementContext,
Arrays.asList(createQueryResult(), createQueryResult(), createQueryResult(), createQueryResult()));
MergedResult actual = mergeEngine.merge();
for (int i = 0; i < 6; i++) {
assertTrue(actual.next());
......@@ -99,10 +76,17 @@ public final class LimitDecoratorMergedResultTest {
new GroupByContext(Collections.<OrderByItem>emptyList(), 0), new OrderByContext(Collections.<OrderByItem>emptyList(), false),
new ProjectionsContext(0, 0, false, Collections.<Projection>emptyList(), Collections.<String>emptyList()),
new PaginationContext(new NumberLiteralLimitValueSegment(0, 0, 2), new NumberLiteralLimitValueSegment(0, 0, 2), Collections.emptyList()));
mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("MySQL"), selectSQLStatementContext, queryResults);
DQLMergeEngine mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("MySQL"), selectSQLStatementContext,
Arrays.asList(createQueryResult(), createQueryResult(), createQueryResult(), createQueryResult()));
MergedResult actual = mergeEngine.merge();
assertTrue(actual.next());
assertTrue(actual.next());
assertFalse(actual.next());
}
private QueryResult createQueryResult() throws SQLException {
QueryResult result = mock(QueryResult.class);
when(result.next()).thenReturn(true, true, false);
return result;
}
}
sharding-core/sharding-core-merge/src/test/java/org/apache/shardingsphere/core/merge/dql/pagination/RowNumberDecoratorMergedResultTest.java
浏览文件 @ 6e33a073
......@@ -17,12 +17,10 @@
package org.apache.shardingsphere.core.merge.dql.pagination;
import com.google.common.collect.Lists;
import org.apache.shardingsphere.core.database.DatabaseTypes;
import org.apache.shardingsphere.core.execute.sql.execute.result.QueryResult;
import org.apache.shardingsphere.core.merge.MergedResult;
import org.apache.shardingsphere.core.merge.dql.DQLMergeEngine;
import org.apache.shardingsphere.core.merge.fixture.ResultSetBasedQueryResultFixture;
import org.apache.shardingsphere.sql.parser.relation.segment.select.groupby.GroupByContext;
import org.apache.shardingsphere.sql.parser.relation.segment.select.orderby.OrderByContext;
import org.apache.shardingsphere.sql.parser.relation.segment.select.orderby.OrderByItem;
......@@ -32,15 +30,11 @@ import org.apache.shardingsphere.sql.parser.relation.segment.select.projection.P
import org.apache.shardingsphere.sql.parser.relation.statement.impl.SelectSQLStatementContext;
import org.apache.shardingsphere.sql.parser.sql.segment.dml.pagination.rownum.NumberLiteralRowNumberValueSegment;
import org.apache.shardingsphere.sql.parser.sql.statement.dml.SelectStatement;
import org.junit.Before;
import org.junit.Test;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
......@@ -49,32 +43,14 @@ import static org.mockito.Mockito.when;
public final class RowNumberDecoratorMergedResultTest {
private DQLMergeEngine mergeEngine;
private List<QueryResult> queryResults;
@Before
public void setUp() throws SQLException {
ResultSet resultSet = mock(ResultSet.class);
ResultSetMetaData resultSetMetaData = mock(ResultSetMetaData.class);
when(resultSet.getMetaData()).thenReturn(resultSetMetaData);
List<ResultSet> resultSets = Lists.newArrayList(resultSet, mock(ResultSet.class), mock(ResultSet.class), mock(ResultSet.class));
for (ResultSet each : resultSets) {
when(each.next()).thenReturn(true, true, false);
}
queryResults = new ArrayList<>(resultSets.size());
for (ResultSet each : resultSets) {
queryResults.add(new ResultSetBasedQueryResultFixture(each));
}
}
@Test
public void assertNextForSkipAll() throws SQLException {
SelectSQLStatementContext selectSQLStatementContext = new SelectSQLStatementContext(new SelectStatement(),
new GroupByContext(Collections.<OrderByItem>emptyList(), 0), new OrderByContext(Collections.<OrderByItem>emptyList(), false),
new ProjectionsContext(0, 0, false, Collections.<Projection>emptyList(), Collections.<String>emptyList()),
new PaginationContext(new NumberLiteralRowNumberValueSegment(0, 0, Integer.MAX_VALUE, true), null, Collections.emptyList()));
mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("Oracle"), selectSQLStatementContext, queryResults);
DQLMergeEngine mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("Oracle"), selectSQLStatementContext,
Arrays.asList(createQueryResult(), createQueryResult(), createQueryResult(), createQueryResult()));
MergedResult actual = mergeEngine.merge();
assertFalse(actual.next());
}
......@@ -84,7 +60,8 @@ public final class RowNumberDecoratorMergedResultTest {
SelectSQLStatementContext selectSQLStatementContext = new SelectSQLStatementContext(new SelectStatement(),
new GroupByContext(Collections.<OrderByItem>emptyList(), 0), new OrderByContext(Collections.<OrderByItem>emptyList(), false),
new ProjectionsContext(0, 0, false, Collections.<Projection>emptyList(), Collections.<String>emptyList()), new PaginationContext(null, null, Collections.emptyList()));
mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("Oracle"), selectSQLStatementContext, queryResults);
DQLMergeEngine mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("Oracle"), selectSQLStatementContext,
Arrays.asList(createQueryResult(), createQueryResult(), createQueryResult(), createQueryResult()));
MergedResult actual = mergeEngine.merge();
for (int i = 0; i < 8; i++) {
assertTrue(actual.next());
......@@ -98,7 +75,8 @@ public final class RowNumberDecoratorMergedResultTest {
new GroupByContext(Collections.<OrderByItem>emptyList(), 0), new OrderByContext(Collections.<OrderByItem>emptyList(), false),
new ProjectionsContext(0, 0, false, Collections.<Projection>emptyList(), Collections.<String>emptyList()),
new PaginationContext(new NumberLiteralRowNumberValueSegment(0, 0, 2, true), new NumberLiteralRowNumberValueSegment(0, 0, 4, false), Collections.emptyList()));
mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("Oracle"), selectSQLStatementContext, queryResults);
DQLMergeEngine mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("Oracle"), selectSQLStatementContext,
Arrays.asList(createQueryResult(), createQueryResult(), createQueryResult(), createQueryResult()));
MergedResult actual = mergeEngine.merge();
assertTrue(actual.next());
assertTrue(actual.next());
......@@ -111,11 +89,18 @@ public final class RowNumberDecoratorMergedResultTest {
new GroupByContext(Collections.<OrderByItem>emptyList(), 0), new OrderByContext(Collections.<OrderByItem>emptyList(), false),
new ProjectionsContext(0, 0, false, Collections.<Projection>emptyList(), Collections.<String>emptyList()),
new PaginationContext(new NumberLiteralRowNumberValueSegment(0, 0, 2, true), new NumberLiteralRowNumberValueSegment(0, 0, 4, true), Collections.emptyList()));
mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("Oracle"), selectSQLStatementContext, queryResults);
DQLMergeEngine mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("Oracle"), selectSQLStatementContext,
Arrays.asList(createQueryResult(), createQueryResult(), createQueryResult(), createQueryResult()));
MergedResult actual = mergeEngine.merge();
assertTrue(actual.next());
assertTrue(actual.next());
assertTrue(actual.next());
assertFalse(actual.next());
}
private QueryResult createQueryResult() throws SQLException {
QueryResult result = mock(QueryResult.class);
when(result.next()).thenReturn(true, true, false);
return result;
}
}
sharding-core/sharding-core-merge/src/test/java/org/apache/shardingsphere/core/merge/dql/pagination/TopAndRowNumberDecoratorMergedResultTest.java
浏览文件 @ 6e33a073
......@@ -17,12 +17,10 @@
package org.apache.shardingsphere.core.merge.dql.pagination;
import com.google.common.collect.Lists;
import org.apache.shardingsphere.core.database.DatabaseTypes;
import org.apache.shardingsphere.core.execute.sql.execute.result.QueryResult;
import org.apache.shardingsphere.core.merge.MergedResult;
import org.apache.shardingsphere.core.merge.dql.DQLMergeEngine;
import org.apache.shardingsphere.core.merge.fixture.ResultSetBasedQueryResultFixture;
import org.apache.shardingsphere.sql.parser.relation.segment.select.groupby.GroupByContext;
import org.apache.shardingsphere.sql.parser.relation.segment.select.orderby.OrderByContext;
import org.apache.shardingsphere.sql.parser.relation.segment.select.orderby.OrderByItem;
......@@ -33,15 +31,11 @@ import org.apache.shardingsphere.sql.parser.relation.statement.impl.SelectSQLSta
import org.apache.shardingsphere.sql.parser.sql.segment.dml.pagination.limit.NumberLiteralLimitValueSegment;
import org.apache.shardingsphere.sql.parser.sql.segment.dml.pagination.rownum.NumberLiteralRowNumberValueSegment;
import org.apache.shardingsphere.sql.parser.sql.statement.dml.SelectStatement;
import org.junit.Before;
import org.junit.Test;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
......@@ -50,32 +44,14 @@ import static org.mockito.Mockito.when;
public final class TopAndRowNumberDecoratorMergedResultTest {
private DQLMergeEngine mergeEngine;
private List<QueryResult> queryResults;
@Before
public void setUp() throws SQLException {
ResultSet resultSet = mock(ResultSet.class);
ResultSetMetaData resultSetMetaData = mock(ResultSetMetaData.class);
when(resultSet.getMetaData()).thenReturn(resultSetMetaData);
List<ResultSet> resultSets = Lists.newArrayList(resultSet, mock(ResultSet.class), mock(ResultSet.class), mock(ResultSet.class));
for (ResultSet each : resultSets) {
when(each.next()).thenReturn(true, true, false);
}
queryResults = new ArrayList<>(resultSets.size());
for (ResultSet each : resultSets) {
queryResults.add(new ResultSetBasedQueryResultFixture(each));
}
}
@Test
public void assertNextForSkipAll() throws SQLException {
SelectSQLStatementContext selectSQLStatementContext = new SelectSQLStatementContext(new SelectStatement(),
new GroupByContext(Collections.<OrderByItem>emptyList(), 0), new OrderByContext(Collections.<OrderByItem>emptyList(), false),
new ProjectionsContext(0, 0, false, Collections.<Projection>emptyList(), Collections.<String>emptyList()),
new PaginationContext(new NumberLiteralRowNumberValueSegment(0, 0, Integer.MAX_VALUE, true), null, Collections.emptyList()));
mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("SQLServer"), selectSQLStatementContext, queryResults);
DQLMergeEngine mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("SQLServer"), selectSQLStatementContext,
Arrays.asList(createQueryResult(), createQueryResult(), createQueryResult(), createQueryResult()));
MergedResult actual = mergeEngine.merge();
assertFalse(actual.next());
}
......@@ -86,7 +62,8 @@ public final class TopAndRowNumberDecoratorMergedResultTest {
new GroupByContext(Collections.<OrderByItem>emptyList(), 0), new OrderByContext(Collections.<OrderByItem>emptyList(), false),
new ProjectionsContext(0, 0, false, Collections.<Projection>emptyList(), Collections.<String>emptyList()),
new PaginationContext(null, new NumberLiteralLimitValueSegment(0, 0, 5), Collections.emptyList()));
mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("SQLServer"), selectSQLStatementContext, queryResults);
DQLMergeEngine mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("SQLServer"), selectSQLStatementContext,
Arrays.asList(createQueryResult(), createQueryResult(), createQueryResult(), createQueryResult()));
MergedResult actual = mergeEngine.merge();
for (int i = 0; i < 5; i++) {
assertTrue(actual.next());
......@@ -100,7 +77,8 @@ public final class TopAndRowNumberDecoratorMergedResultTest {
new GroupByContext(Collections.<OrderByItem>emptyList(), 0), new OrderByContext(Collections.<OrderByItem>emptyList(), false),
new ProjectionsContext(0, 0, false, Collections.<Projection>emptyList(), Collections.<String>emptyList()),
new PaginationContext(new NumberLiteralRowNumberValueSegment(0, 0, 2, true), null, Collections.emptyList()));
mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("SQLServer"), selectSQLStatementContext, queryResults);
DQLMergeEngine mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("SQLServer"), selectSQLStatementContext,
Arrays.asList(createQueryResult(), createQueryResult(), createQueryResult(), createQueryResult()));
MergedResult actual = mergeEngine.merge();
for (int i = 0; i < 7; i++) {
assertTrue(actual.next());
......@@ -114,7 +92,8 @@ public final class TopAndRowNumberDecoratorMergedResultTest {
new GroupByContext(Collections.<OrderByItem>emptyList(), 0), new OrderByContext(Collections.<OrderByItem>emptyList(), false),
new ProjectionsContext(0, 0, false, Collections.<Projection>emptyList(), Collections.<String>emptyList()),
new PaginationContext(new NumberLiteralRowNumberValueSegment(0, 0, 2, false), new NumberLiteralLimitValueSegment(0, 0, 4), Collections.emptyList()));
mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("SQLServer"), selectSQLStatementContext, queryResults);
DQLMergeEngine mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("SQLServer"), selectSQLStatementContext,
Arrays.asList(createQueryResult(), createQueryResult(), createQueryResult(), createQueryResult()));
MergedResult actual = mergeEngine.merge();
assertTrue(actual.next());
assertTrue(actual.next());
......@@ -127,11 +106,18 @@ public final class TopAndRowNumberDecoratorMergedResultTest {
new GroupByContext(Collections.<OrderByItem>emptyList(), 0), new OrderByContext(Collections.<OrderByItem>emptyList(), false),
new ProjectionsContext(0, 0, false, Collections.<Projection>emptyList(), Collections.<String>emptyList()),
new PaginationContext(new NumberLiteralRowNumberValueSegment(0, 0, 2, true), new NumberLiteralLimitValueSegment(0, 0, 4), Collections.emptyList()));
mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("SQLServer"), selectSQLStatementContext, queryResults);
DQLMergeEngine mergeEngine = new DQLMergeEngine(DatabaseTypes.getActualDatabaseType("SQLServer"), selectSQLStatementContext,
Arrays.asList(createQueryResult(), createQueryResult(), createQueryResult(), createQueryResult()));
MergedResult actual = mergeEngine.merge();
assertTrue(actual.next());
assertTrue(actual.next());
assertTrue(actual.next());
assertFalse(actual.next());
}
private QueryResult createQueryResult() throws SQLException {
QueryResult result = mock(QueryResult.class);
when(result.next()).thenReturn(true, true, false);
return result;
}
}
sharding-core/sharding-core-merge/src/test/java/org/apache/shardingsphere/core/merge/fixture/QueryResultBasedQueryResultFixture.java 已删除 100644 → 0
浏览文件 @ 26b1ad75
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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.
*/
package org.apache.shardingsphere.core.merge.fixture;
import lombok.RequiredArgsConstructor;
import org.apache.shardingsphere.core.execute.sql.execute.result.QueryResult;
import java.io.InputStream;
import java.sql.SQLException;
import java.util.Calendar;
import java.util.Iterator;
@RequiredArgsConstructor
public final class QueryResultBasedQueryResultFixture implements QueryResult {
private final Iterator<QueryResult> queryResults;
private QueryResult currQueryResult;
@Override
public boolean next() {
boolean hasNext = queryResults.hasNext();
if (hasNext) {
currQueryResult = queryResults.next();
}
return hasNext;
}
@Override
public Object getValue(final int columnIndex, final Class<?> type) throws SQLException {
return currQueryResult.getValue(columnIndex, type);
}
@Override
public Object getCalendarValue(final int columnIndex, final Class<?> type, final Calendar calendar) {
return null;
}
@Override
public InputStream getInputStream(final int columnIndex, final String type) {
return null;
}
@Override
public boolean wasNull() {
return false;
}
@Override
public boolean isCaseSensitive(final int columnIndex) {
return false;
}
@Override
public int getColumnCount() throws SQLException {
return currQueryResult.getColumnCount();
}
@Override
public String getColumnLabel(final int columnIndex) {
return null;
}
}
sharding-core/sharding-core-merge/src/test/java/org/apache/shardingsphere/core/merge/fixture/ResultSetBasedQueryResultFixture.java 已删除 100644 → 0
浏览文件 @ 26b1ad75
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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.
*/
package org.apache.shardingsphere.core.merge.fixture;
import lombok.RequiredArgsConstructor;
import org.apache.shardingsphere.core.execute.sql.execute.result.QueryResult;
import java.io.InputStream;
import java.io.Reader;
import java.math.BigDecimal;
import java.net.URL;
import java.sql.Blob;
import java.sql.Clob;
import java.sql.Date;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.SQLXML;
import java.sql.Time;
import java.sql.Timestamp;
import java.util.Calendar;
@RequiredArgsConstructor
public final class ResultSetBasedQueryResultFixture implements QueryResult {
private final ResultSet resultSet;
@Override
public boolean next() throws SQLException {
return resultSet.next();
}
@Override
public Object getValue(final int columnIndex, final Class<?> type) throws SQLException {
Object result;
if (Object.class == type) {
result = resultSet.getObject(columnIndex);
} else if (boolean.class == type) {
result = resultSet.getBoolean(columnIndex);
} else if (byte.class == type) {
result = resultSet.getByte(columnIndex);
} else if (short.class == type) {
result = resultSet.getShort(columnIndex);
} else if (int.class == type) {
result = resultSet.getInt(columnIndex);
} else if (long.class == type) {
result = resultSet.getLong(columnIndex);
} else if (float.class == type) {
result = resultSet.getFloat(columnIndex);
} else if (double.class == type) {
result = resultSet.getDouble(columnIndex);
} else if (String.class == type) {
result = resultSet.getString(columnIndex);
} else if (BigDecimal.class == type) {
result = resultSet.getBigDecimal(columnIndex);
} else if (byte[].class == type) {
result = resultSet.getBytes(columnIndex);
} else if (Date.class == type) {
result = resultSet.getDate(columnIndex);
} else if (Time.class == type) {
result = resultSet.getTime(columnIndex);
} else if (Timestamp.class == type) {
result = resultSet.getTimestamp(columnIndex);
} else if (URL.class == type) {
result = resultSet.getURL(columnIndex);
} else if (Blob.class == type) {
result = resultSet.getBlob(columnIndex);
} else if (Clob.class == type) {
result = resultSet.getClob(columnIndex);
} else if (SQLXML.class == type) {
result = resultSet.getSQLXML(columnIndex);
} else if (Reader.class == type) {
result = resultSet.getCharacterStream(columnIndex);
} else {
result = resultSet.getObject(columnIndex);
}
return result;
}
@Override
public Object getCalendarValue(final int columnIndex, final Class<?> type, final Calendar calendar) throws SQLException {
if (Date.class == type) {
return resultSet.getDate(columnIndex, calendar);
}
if (Time.class == type) {
return resultSet.getTime(columnIndex, calendar);
}
if (Timestamp.class == type) {
return resultSet.getTimestamp(columnIndex, calendar);
}
throw new SQLException(String.format("Unsupported type: %s", type));
}
@SuppressWarnings("deprecation")
@Override
public InputStream getInputStream(final int columnIndex, final String type) throws SQLException {
switch (type) {
case "Ascii":
return resultSet.getAsciiStream(columnIndex);
case "Unicode":
return resultSet.getUnicodeStream(columnIndex);
case "Binary":
return resultSet.getBinaryStream(columnIndex);
default:
throw new SQLException(String.format("Unsupported type: %s", type));
}
}
@Override
public boolean wasNull() throws SQLException {
return resultSet.wasNull();
}
@Override
public boolean isCaseSensitive(final int columnIndex) throws SQLException {
return resultSet.getMetaData().isCaseSensitive(columnIndex);
}
@Override
public int getColumnCount() throws SQLException {
return resultSet.getMetaData().getColumnCount();
}
@Override
public String getColumnLabel(final int columnIndex) throws SQLException {
return resultSet.getMetaData().getColumnLabel(columnIndex);
}
}
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或