use of herddb.model.Projection in project herddb by diennea.
the class SQLPlanner method buildSelectStatement.
private ExecutionPlan buildSelectStatement(String defaultTableSpace, Select s, boolean scan, int maxRows) throws StatementExecutionException {
PlainSelect selectBody = (PlainSelect) s.getSelectBody();
net.sf.jsqlparser.schema.Table fromTable = (net.sf.jsqlparser.schema.Table) selectBody.getFromItem();
TableRef mainTable = TableRef.buildFrom(fromTable, defaultTableSpace);
String mainTableAlias = mainTable.tableAlias;
String tableSpace = mainTable.tableSpace;
TableSpaceManager tableSpaceManager = manager.getTableSpaceManager(tableSpace);
if (tableSpaceManager == null) {
throw new TableSpaceDoesNotExistException("no such tablespace " + tableSpace + " here at " + manager.getNodeId());
}
AbstractTableManager tableManager = tableSpaceManager.getTableManager(mainTable.tableName);
if (tableManager == null) {
throw new TableDoesNotExistException("no such table " + mainTable.tableName + " in tablespace " + tableSpace);
}
// linked hash map retains the order of insertions
LinkedHashMap<String, JoinSupport> joins = new LinkedHashMap<>();
boolean joinPresent = false;
joins.put(mainTable.tableAlias, new JoinSupport(mainTable, tableManager));
if (selectBody.getJoins() != null) {
for (Join join : selectBody.getJoins()) {
joinPresent = true;
if (join.isLeft() || join.isCross() || join.isRight() || join.isOuter() || join.isSimple()) {
throw new StatementExecutionException("unsupported JOIN type: " + join);
}
net.sf.jsqlparser.schema.Table joinedTable = (net.sf.jsqlparser.schema.Table) join.getRightItem();
TableRef joinedTableRef = TableRef.buildFrom(joinedTable, defaultTableSpace);
if (!joinedTableRef.tableSpace.equalsIgnoreCase(mainTable.tableSpace)) {
throw new TableDoesNotExistException("unsupported cross-tablespace JOIN " + "between" + mainTable.tableSpace + "." + mainTable.tableName + " and " + joinedTableRef.tableSpace + "." + joinedTableRef.tableName);
}
AbstractTableManager joinedTableManager = tableSpaceManager.getTableManager(joinedTableRef.tableName);
if (joinedTableManager == null) {
throw new TableDoesNotExistException("no such table " + joinedTableRef.tableName + " in tablespace " + tableSpace);
}
JoinSupport joinSupport = new JoinSupport(joinedTableRef, joinedTableManager);
joins.put(joinedTableRef.tableAlias, joinSupport);
}
}
Projection mainTableProjection;
Table table = tableManager.getTable();
boolean allColumns = false;
boolean containsAggregateFunctions = false;
for (SelectItem c : selectBody.getSelectItems()) {
if (c instanceof AllColumns) {
allColumns = true;
break;
} else if (c instanceof AllTableColumns) {
AllTableColumns allTableColumns = (AllTableColumns) c;
TableRef ref = TableRef.buildFrom(allTableColumns.getTable(), defaultTableSpace);
if (!joinPresent && ref.tableAlias.equals(mainTable.tableAlias)) {
// select a.* FROM table a
allColumns = true;
} else {
// select a.*, b.* FROM table a JOIN table b
joins.get(ref.tableAlias).allColumns = true;
}
} else if (c instanceof SelectExpressionItem) {
SelectExpressionItem se = (SelectExpressionItem) c;
if (isAggregateFunction(se.getExpression())) {
containsAggregateFunctions = true;
}
if (!joinPresent) {
joins.get(mainTable.tableAlias).selectItems.add(c);
} else {
ColumnReferencesDiscovery discoverMainTableAlias = discoverMainTableAlias(se.getExpression());
String mainTableAliasForItem = discoverMainTableAlias.getMainTableAlias();
if (discoverMainTableAlias.isContainsMixedAliases()) {
throw new StatementExecutionException("unsupported single SELECT ITEM with mixed aliases: " + c);
}
if (mainTableAliasForItem == null) {
mainTableAliasForItem = mainTable.tableAlias;
}
joins.get(mainTableAliasForItem).selectItems.add(c);
}
} else {
throw new StatementExecutionException("unsupported SELECT ITEM type: " + c);
}
}
if (allColumns) {
mainTableProjection = Projection.IDENTITY(table.columnNames, table.columns);
for (Map.Entry<String, JoinSupport> join : joins.entrySet()) {
JoinSupport support = join.getValue();
support.projection = Projection.IDENTITY(support.table.columnNames, support.table.columns);
support.allColumns = true;
}
} else {
if (!joinPresent) {
mainTableProjection = new SQLProjection(table, mainTableAlias, selectBody.getSelectItems());
} else {
for (JoinSupport support : joins.values()) {
if (support.allColumns) {
support.projection = Projection.IDENTITY(support.table.columnNames, support.table.columns);
} else {
support.projection = new SQLProjection(support.table, support.tableRef.tableAlias, support.selectItems);
}
}
mainTableProjection = joins.get(mainTableAlias).projection;
}
}
if (scan) {
if (!joinPresent) {
SQLRecordPredicate where = selectBody.getWhere() != null ? new SQLRecordPredicate(table, mainTableAlias, selectBody.getWhere()) : null;
if (where != null) {
discoverIndexOperations(selectBody.getWhere(), table, mainTableAlias, where, tableSpaceManager);
}
Aggregator aggregator = null;
ScanLimitsImpl scanLimits = null;
if (containsAggregateFunctions || (selectBody.getGroupByColumnReferences() != null && !selectBody.getGroupByColumnReferences().isEmpty())) {
aggregator = new SQLAggregator(selectBody.getSelectItems(), selectBody.getGroupByColumnReferences(), manager.getRecordSetFactory());
}
TupleComparator comparatorOnScan = null;
TupleComparator comparatorOnPlan = null;
if (selectBody.getOrderByElements() != null && !selectBody.getOrderByElements().isEmpty()) {
if (aggregator != null) {
comparatorOnPlan = SingleColumnSQLTupleComparator.make(mainTableAlias, selectBody.getOrderByElements(), null);
} else {
comparatorOnScan = SingleColumnSQLTupleComparator.make(mainTableAlias, selectBody.getOrderByElements(), table.primaryKey);
}
}
Limit limit = selectBody.getLimit();
Top top = selectBody.getTop();
if (limit != null && top != null) {
throw new StatementExecutionException("LIMIT and TOP cannot be used on the same query");
}
if (limit != null) {
if (limit.isLimitAll() || limit.isLimitNull() || limit.getOffset() instanceof JdbcParameter) {
throw new StatementExecutionException("Invalid LIMIT clause (limit=" + limit + ")");
}
if (maxRows > 0 && limit.getRowCount() instanceof JdbcParameter) {
throw new StatementExecutionException("Invalid LIMIT clause (limit=" + limit + ") and JDBC setMaxRows=" + maxRows);
}
int rowCount;
int rowCountJdbcParameter = -1;
if (limit.getRowCount() instanceof JdbcParameter) {
rowCount = -1;
rowCountJdbcParameter = ((JdbcParameter) limit.getRowCount()).getIndex() - 1;
} else {
rowCount = ((Number) resolveValue(limit.getRowCount(), false)).intValue();
}
int offset = limit.getOffset() != null ? ((Number) resolveValue(limit.getOffset(), false)).intValue() : 0;
scanLimits = new ScanLimitsImpl(rowCount, offset, rowCountJdbcParameter + 1);
} else if (top != null) {
if (top.isPercentage() || top.getExpression() == null) {
throw new StatementExecutionException("Invalid TOP clause (top=" + top + ")");
}
try {
int rowCount = Integer.parseInt(resolveValue(top.getExpression(), false) + "");
scanLimits = new ScanLimitsImpl(rowCount, 0);
} catch (NumberFormatException error) {
throw new StatementExecutionException("Invalid TOP clause: " + error, error);
}
}
if (maxRows > 0) {
if (scanLimits == null) {
scanLimits = new ScanLimitsImpl(maxRows, 0);
} else if (scanLimits.getMaxRows() <= 0 || scanLimits.getMaxRows() > maxRows) {
scanLimits = new ScanLimitsImpl(maxRows, scanLimits.getOffset());
}
}
ScanLimitsImpl limitsOnScan = null;
ScanLimitsImpl limitsOnPlan = null;
if (aggregator != null) {
limitsOnPlan = scanLimits;
} else {
limitsOnScan = scanLimits;
}
try {
ScanStatement statement = new ScanStatement(tableSpace, mainTable.tableName, mainTableProjection, where, comparatorOnScan, limitsOnScan);
return ExecutionPlan.make(statement, aggregator, limitsOnPlan, comparatorOnPlan);
} catch (IllegalArgumentException err) {
throw new StatementExecutionException(err);
}
} else {
if (containsAggregateFunctions || (selectBody.getGroupByColumnReferences() != null && !selectBody.getGroupByColumnReferences().isEmpty())) {
throw new StatementExecutionException("AGGREGATEs are not yet supported with JOIN");
}
Limit limit = selectBody.getLimit();
Top top = selectBody.getTop();
if (limit != null && top != null) {
throw new StatementExecutionException("LIMIT and TOP cannot be used on the same query");
}
ScanLimitsImpl scanLimits = null;
if (limit != null) {
if (limit.isLimitAll() || limit.isLimitNull() || limit.getOffset() instanceof JdbcParameter) {
throw new StatementExecutionException("Invalid LIMIT clause (limit=" + limit + ")");
}
if (maxRows > 0 && limit.getRowCount() instanceof JdbcParameter) {
throw new StatementExecutionException("Invalid LIMIT clause (limit=" + limit + ") and JDBC setMaxRows=" + maxRows);
}
int rowCount;
int rowCountJdbcParameter = -1;
if (limit.getRowCount() instanceof JdbcParameter) {
rowCount = -1;
rowCountJdbcParameter = ((JdbcParameter) limit.getRowCount()).getIndex() - 1;
} else {
rowCount = ((Number) resolveValue(limit.getRowCount(), false)).intValue();
}
int offset = limit.getOffset() != null ? ((Number) resolveValue(limit.getOffset(), false)).intValue() : 0;
scanLimits = new ScanLimitsImpl(rowCount, offset, rowCountJdbcParameter + 1);
} else if (top != null) {
if (top.isPercentage() || top.getExpression() == null) {
throw new StatementExecutionException("Invalid TOP clause");
}
try {
int rowCount = Integer.parseInt(resolveValue(top.getExpression(), false) + "");
scanLimits = new ScanLimitsImpl(rowCount, 0);
} catch (NumberFormatException error) {
throw new StatementExecutionException("Invalid TOP clause: " + error, error);
}
}
if (maxRows > 0) {
if (scanLimits == null) {
scanLimits = new ScanLimitsImpl(maxRows, 0);
} else if (scanLimits.getMaxRows() <= 0 || scanLimits.getMaxRows() > maxRows) {
scanLimits = new ScanLimitsImpl(maxRows, scanLimits.getOffset());
}
}
List<ColumnReferencesDiscovery> conditionsOnJoinedResult = new ArrayList<>();
List<ScanStatement> scans = new ArrayList<>();
for (Map.Entry<String, JoinSupport> join : joins.entrySet()) {
String alias = join.getKey();
JoinSupport joinSupport = join.getValue();
Expression collectedConditionsForAlias = collectConditionsForAlias(alias, selectBody.getWhere(), conditionsOnJoinedResult, mainTableAlias);
LOG.severe("Collected WHERE for alias " + alias + ": " + collectedConditionsForAlias);
if (collectedConditionsForAlias == null) {
joinSupport.predicate = null;
} else {
joinSupport.predicate = new SQLRecordPredicate(join.getValue().table, alias, collectedConditionsForAlias);
}
}
for (Join join : selectBody.getJoins()) {
if (join.getOnExpression() != null) {
ColumnReferencesDiscovery discoverMainTableAliasForJoinCondition = discoverMainTableAlias(join.getOnExpression());
conditionsOnJoinedResult.add(discoverMainTableAliasForJoinCondition);
LOG.severe("Collected ON-condition on final JOIN result: " + join.getOnExpression());
}
}
for (ColumnReferencesDiscovery e : conditionsOnJoinedResult) {
LOG.severe("Collected WHERE on final JOIN result: " + e.getExpression());
for (Map.Entry<String, List<net.sf.jsqlparser.schema.Column>> entry : e.getColumnsByTable().entrySet()) {
String tableAlias = entry.getKey();
List<net.sf.jsqlparser.schema.Column> filteredColumnsOnJoin = entry.getValue();
LOG.severe("for TABLE " + tableAlias + " we need to load " + filteredColumnsOnJoin);
JoinSupport support = joins.get(tableAlias);
if (support == null) {
throw new StatementExecutionException("invalid table alias " + tableAlias);
}
if (!support.allColumns) {
for (net.sf.jsqlparser.schema.Column c : filteredColumnsOnJoin) {
support.selectItems.add(new SelectExpressionItem(c));
}
support.projection = new SQLProjection(support.table, support.tableRef.tableAlias, support.selectItems);
}
}
}
Map<String, Table> tables = new HashMap<>();
for (Map.Entry<String, JoinSupport> join : joins.entrySet()) {
JoinSupport joinSupport = join.getValue();
tables.put(join.getKey(), joinSupport.table);
ScanStatement statement = new ScanStatement(tableSpace, joinSupport.table.name, joinSupport.projection, joinSupport.predicate, null, null);
scans.add(statement);
}
TuplePredicate joinFilter = null;
if (!conditionsOnJoinedResult.isEmpty()) {
joinFilter = new SQLRecordPredicate(null, null, composeAndExpression(conditionsOnJoinedResult));
}
Projection joinProjection = null;
if (!allColumns) {
joinProjection = new SQLProjection(tableSpace, tables, selectBody.getSelectItems());
}
TupleComparator comparatorOnPlan = null;
if (selectBody.getOrderByElements() != null && !selectBody.getOrderByElements().isEmpty()) {
comparatorOnPlan = SingleColumnSQLTupleComparator.make(mainTableAlias, selectBody.getOrderByElements(), null);
}
try {
return ExecutionPlan.joinedScan(scans, joinFilter, joinProjection, scanLimits, comparatorOnPlan);
} catch (IllegalArgumentException err) {
throw new StatementExecutionException(err);
}
}
} else {
if (selectBody.getWhere() == null) {
throw new StatementExecutionException("unsupported GET without WHERE");
}
if (joinPresent) {
throw new StatementExecutionException("unsupported GET with JOIN");
}
// SELECT * FROM WHERE KEY=? AND ....
SQLRecordKeyFunction keyFunction = findPrimaryKeyIndexSeek(selectBody.getWhere(), table, mainTableAlias);
if (keyFunction == null || !keyFunction.isFullPrimaryKey()) {
throw new StatementExecutionException("unsupported GET not on PK, bad where clause: " + selectBody.getWhere() + " (" + selectBody.getWhere().getClass() + ")");
}
Predicate where = buildSimplePredicate(selectBody.getWhere(), table, mainTableAlias);
try {
return ExecutionPlan.simple(new GetStatement(tableSpace, mainTable.tableName, keyFunction, where, false));
} catch (IllegalArgumentException err) {
throw new StatementExecutionException(err);
}
}
}
use of herddb.model.Projection in project herddb by diennea.
the class CalcitePlanner method planBindableTableScan.
private PlannerOp planBindableTableScan(BindableTableScan scan, RelDataType rowType) {
if (rowType == null) {
rowType = scan.getRowType();
}
final String tableSpace = scan.getTable().getQualifiedName().get(0);
final TableImpl tableImpl = (TableImpl) scan.getTable().unwrap(org.apache.calcite.schema.Table.class);
Table table = tableImpl.tableManager.getTable();
SQLRecordPredicate predicate = null;
if (!scan.filters.isEmpty()) {
CompiledSQLExpression where = null;
if (scan.filters.size() == 1) {
RexNode expr = scan.filters.get(0);
where = SQLExpressionCompiler.compileExpression(expr);
} else {
CompiledSQLExpression[] operands = new CompiledSQLExpression[scan.filters.size()];
int i = 0;
for (RexNode expr : scan.filters) {
CompiledSQLExpression condition = SQLExpressionCompiler.compileExpression(expr);
operands[i++] = condition;
}
where = new CompiledMultiAndExpression(operands);
}
predicate = new SQLRecordPredicate(table, null, where);
TableSpaceManager tableSpaceManager = manager.getTableSpaceManager(tableSpace);
IndexOperation op = scanForIndexAccess(where, table, tableSpaceManager);
predicate.setIndexOperation(op);
CompiledSQLExpression filterPk = findFiltersOnPrimaryKey(table, where);
if (filterPk != null) {
filterPk = remapPositionalAccessToToPrimaryKeyAccessor(filterPk, table, scan);
}
predicate.setPrimaryKeyFilter(filterPk);
}
List<RexNode> projections = new ArrayList<>(scan.projects.size());
int i = 0;
for (int fieldpos : scan.projects) {
projections.add(new RexInputRef(fieldpos, rowType.getFieldList().get(i++).getType()));
}
Projection projection = buildProjection(projections, rowType, true, table.columns);
ScanStatement scanStatement = new ScanStatement(tableSpace, table.name, projection, predicate, null, null);
scanStatement.setTableDef(table);
return new BindableTableScanOp(scanStatement);
}
use of herddb.model.Projection in project herddb by diennea.
the class CalcitePlanner method planProject.
private PlannerOp planProject(EnumerableProject op, RelDataType rowType) {
PlannerOp input = convertRelNode(op.getInput(), null, false);
final List<RexNode> projects = op.getProjects();
final RelDataType _rowType = rowType == null ? op.getRowType() : rowType;
Projection projection = buildProjection(projects, _rowType, false, null);
return new ProjectOp(projection, input);
}
use of herddb.model.Projection in project herddb by diennea.
the class RecordSetSuite method testApplyProjectionNoSwap.
@Test
public void testApplyProjectionNoSwap() throws Exception {
RecordSetFactory factory = buildRecordSetFactory(Integer.MAX_VALUE);
Column[] columns = new Column[2];
columns[0] = Column.column("s1", ColumnTypes.STRING);
columns[1] = Column.column("n1", ColumnTypes.LONG);
Set<String> expected_s2 = new HashSet<>();
Set<Integer> expected_n2 = new HashSet<>();
String[] fieldNames = Column.buildFieldNamesList(columns);
try (MaterializedRecordSet rs = factory.createRecordSet(fieldNames, columns)) {
for (int i = 0; i < 100; i++) {
Map<String, Object> record = new HashMap<>();
String s1 = "test_" + i;
record.put("s1", s1);
record.put("n1", i);
expected_s2.add(s1);
expected_n2.add(i);
rs.add(new Tuple(record, fieldNames));
}
rs.writeFinished();
Column[] columns_projected = new Column[2];
columns_projected[0] = Column.column("n2", ColumnTypes.LONG);
columns_projected[1] = Column.column("s2", ColumnTypes.STRING);
String[] fieldNames_projected = new String[] { "n2", "s2" };
rs.applyProjection(new Projection() {
@Override
public Column[] getColumns() {
return columns_projected;
}
@Override
public String[] getFieldNames() {
return fieldNames_projected;
}
@Override
public Tuple map(DataAccessor tuple, StatementEvaluationContext context) throws StatementExecutionException {
Object[] projected_values = new Object[2];
projected_values[0] = tuple.get("n1");
projected_values[1] = tuple.get("s1");
return new Tuple(fieldNames_projected, projected_values);
}
}, StatementEvaluationContext.DEFAULT_EVALUATION_CONTEXT());
for (DataAccessor t : rs) {
expected_s2.remove((String) t.get("s2"));
expected_n2.remove((Integer) t.get("n2"));
}
assertTrue(expected_s2.isEmpty());
assertTrue(expected_n2.isEmpty());
assertEquals("n2", rs.getColumns()[0].name);
assertEquals("s2", rs.getColumns()[1].name);
}
}
use of herddb.model.Projection in project herddb by diennea.
the class CalcitePlannerTest method simplePlansTests.
@Test
public void simplePlansTests() throws Exception {
String nodeId = "localhost";
try (DBManager manager = new DBManager("localhost", new MemoryMetadataStorageManager(), new MemoryDataStorageManager(), new MemoryCommitLogManager(), null, null)) {
assumeThat(manager.getPlanner(), instanceOf(CalcitePlanner.class));
manager.start();
CreateTableSpaceStatement st1 = new CreateTableSpaceStatement("tblspace1", Collections.singleton(nodeId), nodeId, 1, 0, 0);
manager.executeStatement(st1, StatementEvaluationContext.DEFAULT_EVALUATION_CONTEXT(), TransactionContext.NO_TRANSACTION);
manager.waitForTablespace("tblspace1", 10000);
execute(manager, "CREATE TABLE tblspace1.tsql (k1 string primary key,n1 int,s1 string)", Collections.emptyList());
execute(manager, "INSERT INTO tblspace1.tsql (k1,n1) values(?,?)", Arrays.asList("mykey", 1234), TransactionContext.NO_TRANSACTION);
try (DataScanner scan = scan(manager, "SELECT n1,k1 FROM tblspace1.tsql where k1='mykey'", Collections.emptyList())) {
assertEquals(1, scan.consume().size());
}
assertInstanceOf(plan(manager, "select * from tblspace1.tsql"), TableScanOp.class);
assertInstanceOf(plan(manager, "select * from tblspace1.tsql where n1=1"), BindableTableScanOp.class);
assertInstanceOf(plan(manager, "select n1 from tblspace1.tsql"), BindableTableScanOp.class);
assertInstanceOf(plan(manager, "update tblspace1.tsql set n1=? where k1=?"), SimpleUpdateOp.class);
assertInstanceOf(plan(manager, "update tblspace1.tsql set n1=? where k1=? and n1=?"), SimpleUpdateOp.class);
assertInstanceOf(plan(manager, "update tblspace1.tsql set n1=?" + " where n1 in (select b.n1*2 from tblspace1.tsql b)"), UpdateOp.class);
assertInstanceOf(plan(manager, "delete from tblspace1.tsql where k1=?"), SimpleDeleteOp.class);
assertInstanceOf(plan(manager, "delete from tblspace1.tsql where k1=? and n1=?"), SimpleDeleteOp.class);
assertInstanceOf(plan(manager, "delete from tblspace1.tsql where n1 in (select b.n1*2 from tblspace1.tsql b)"), DeleteOp.class);
assertInstanceOf(plan(manager, "INSERT INTO tblspace1.tsql (k1,n1) values(?,?)"), SimpleInsertOp.class);
assertInstanceOf(plan(manager, "INSERT INTO tblspace1.tsql (k1,n1) values(?,?),(?,?)"), InsertOp.class);
assertInstanceOf(plan(manager, "select k1 from tblspace1.tsql order by k1"), SortedBindableTableScanOp.class);
assertInstanceOf(plan(manager, "select k1 from tblspace1.tsql order by k1 limit 10"), LimitedSortedBindableTableScanOp.class);
{
BindableTableScanOp plan = assertInstanceOf(plan(manager, "select * from tblspace1.tsql where k1=?"), BindableTableScanOp.class);
Projection projection = plan.getStatement().getProjection();
System.out.println("projection:" + projection);
assertThat(projection, instanceOf(IdentityProjection.class));
assertNull(plan.getStatement().getComparator());
}
{
SortedBindableTableScanOp plan = assertInstanceOf(plan(manager, "select n1,k1 from tblspace1.tsql order by n1"), SortedBindableTableScanOp.class);
Projection projection = plan.getStatement().getProjection();
System.out.println("projection:" + projection);
assertThat(projection, instanceOf(ZeroCopyProjection.class));
ZeroCopyProjection zero = (ZeroCopyProjection) projection;
assertArrayEquals(new String[] { "n1", "k1" }, zero.getFieldNames());
assertEquals("n1", zero.getColumns()[0].name);
assertEquals("k1", zero.getColumns()[1].name);
TupleComparator comparator = plan.getStatement().getComparator();
System.out.println("comparator:" + comparator);
assertThat(comparator, instanceOf(SortOp.class));
SortOp sortOp = (SortOp) comparator;
assertFalse(sortOp.isOnlyPrimaryKeyAndAscending());
}
{
SortedBindableTableScanOp plan = assertInstanceOf(plan(manager, "select n1,k1 from tblspace1.tsql order by k1"), SortedBindableTableScanOp.class);
Projection projection = plan.getStatement().getProjection();
System.out.println("projection:" + projection);
assertThat(projection, instanceOf(ZeroCopyProjection.class));
ZeroCopyProjection zero = (ZeroCopyProjection) projection;
assertArrayEquals(new String[] { "n1", "k1" }, zero.getFieldNames());
assertEquals("n1", zero.getColumns()[0].name);
assertEquals("k1", zero.getColumns()[1].name);
TupleComparator comparator = plan.getStatement().getComparator();
System.out.println("comparator:" + comparator);
assertThat(comparator, instanceOf(SortOp.class));
SortOp sortOp = (SortOp) comparator;
assertTrue(sortOp.isOnlyPrimaryKeyAndAscending());
}
{
SortedTableScanOp plan = assertInstanceOf(plan(manager, "select * from tblspace1.tsql order by n1"), SortedTableScanOp.class);
Projection projection = plan.getStatement().getProjection();
System.out.println("projection:" + projection);
assertThat(projection, instanceOf(IdentityProjection.class));
IdentityProjection zero = (IdentityProjection) projection;
assertArrayEquals(new String[] { "k1", "n1", "s1" }, zero.getFieldNames());
assertEquals("k1", zero.getColumns()[0].name);
assertEquals("n1", zero.getColumns()[1].name);
assertEquals("s1", zero.getColumns()[2].name);
TupleComparator comparator = plan.getStatement().getComparator();
System.out.println("comparator:" + comparator);
assertThat(comparator, instanceOf(SortOp.class));
SortOp sortOp = (SortOp) comparator;
assertFalse(sortOp.isOnlyPrimaryKeyAndAscending());
}
{
SortedTableScanOp plan = assertInstanceOf(plan(manager, "select * from tblspace1.tsql order by k1"), SortedTableScanOp.class);
Projection projection = plan.getStatement().getProjection();
System.out.println("projection:" + projection);
assertThat(projection, instanceOf(IdentityProjection.class));
IdentityProjection zero = (IdentityProjection) projection;
assertArrayEquals(new String[] { "k1", "n1", "s1" }, zero.getFieldNames());
assertEquals("k1", zero.getColumns()[0].name);
assertEquals("n1", zero.getColumns()[1].name);
assertEquals("s1", zero.getColumns()[2].name);
TupleComparator comparator = plan.getStatement().getComparator();
System.out.println("comparator:" + comparator);
assertThat(comparator, instanceOf(SortOp.class));
SortOp sortOp = (SortOp) comparator;
assertTrue(sortOp.isOnlyPrimaryKeyAndAscending());
}
}
}
Aggregations