@Test
public void testSimpleB() throws Throwable {
SchemaContext db = buildSchema(TestName.MULTI, schema);
PEPersistentGroup group = db.getCurrentDatabase().getDefaultStorage(db);
stmtTest(
db,
"select desc from A group by id",
SelectStatement.class,
bes(
new ProjectingExpectedStep(
ExecutionType.SELECT,
group,
"temp1",
TransientExecutionEngine.AGGREGATION,
StaticDistributionModel.MODEL_NAME,
new String[] {},
new String[][] {},
"SELECT `A`.`desc` AS A1d1_7,`A`.`id` AS A1i0_8",
"FROM `A`",
"GROUP BY A1i0_8 ASC"),
new ProjectingExpectedStep(
ExecutionType.SELECT,
null,
"SELECT temp1.A1d1_7 AS t2A0",
"FROM temp1",
"ORDER BY temp1.A1i0_8 ASC")));
}
@Test
public void testComplexA() throws Throwable {
SchemaContext db = buildSchema(TestName.MULTI, schema);
PEPersistentGroup group = db.getCurrentDatabase().getDefaultStorage(db);
stmtTest(
db,
"select n.desc,r.desc from N n, R r where n.id = r.id group by r.flags",
SelectStatement.class,
bes(
bpes(
bes(
new ProjectingExpectedStep(
"SELECT n.`desc` AS nd1_3,n.`id` AS ni0_4 FROM `N` AS n",
group,
"temp1",
TransientExecutionEngine.LARGE,
StaticDistributionModel.MODEL_NAME,
new String[] {"ni0_4"})),
bes(
new ProjectingExpectedStep(
"SELECT r.`desc` AS rd1_4,r.`flags` AS rf2_5,r.`id` AS ri0_6 FROM `R` AS r",
group,
"temp2",
TransientExecutionEngine.LARGE,
StaticDistributionModel.MODEL_NAME,
new String[] {"ri0_6"}))),
new ProjectingExpectedStep(
"SELECT temp1.nd1_3 AS t3n0_11,temp2.rd1_4 AS t4r0_12,temp2.rf2_5 AS t4r1_13 FROM temp1, temp2 WHERE temp1.ni0_4 = temp2.ri0_6",
TransientExecutionEngine.LARGE,
"temp3",
TransientExecutionEngine.LARGE,
StaticDistributionModel.MODEL_NAME,
new String[] {"t4r1_13"}),
new ProjectingExpectedStep(
ExecutionType.SELECT,
"SELECT temp3.t3n0_11 AS t5t0,temp3.t4r0_12 AS t5t1,temp3.t4r1_13 AS t5t2 FROM temp3 GROUP BY t5t2 ASC",
TransientExecutionEngine.LARGE,
"temp4",
TransientExecutionEngine.AGGREGATION,
StaticDistributionModel.MODEL_NAME,
new String[] {}),
new ProjectingExpectedStep(
"SELECT temp4.t5t0 AS t6t0,temp4.t5t1 AS t6t1 FROM temp4 ORDER BY temp4.t5t2 ASC",
null)));
}
// varieties of order by:
// order by non ref col
// order by ref col
// order by ref expr (via alias instance)
// order by non ref expr (expr in order by)
// going to do all of these twice: once on the random table, and once on the bcast table
@Test
public void testNonRefColRandom() throws Throwable {
SchemaContext db = buildSchema(TestName.MULTI, schema);
PEPersistentGroup group = db.getCurrentDatabase().getDefaultStorage(db);
stmtTest(
db,
"select desc from R group by id",
SelectStatement.class,
bes(
new ProjectingExpectedStep(
ExecutionType.SELECT,
group,
"temp1",
TransientExecutionEngine.LARGE,
StaticDistributionModel.MODEL_NAME,
new String[] {"R1i0_8"},
new String[][] {{"R1i0_8"}},
"SELECT `R`.`desc` AS R1d1_7,`R`.`id` AS R1i0_8",
"FROM `R`"),
new ProjectingExpectedStep(
ExecutionType.SELECT,
TransientExecutionEngine.LARGE,
"temp2",
TransientExecutionEngine.AGGREGATION,
StaticDistributionModel.MODEL_NAME,
new String[] {},
new String[][] {},
"SELECT temp1.R1d1_7 AS t2R0,temp1.R1i0_8 AS t2R1",
"FROM temp1",
"GROUP BY t2R1 ASC"),
new ProjectingExpectedStep(
ExecutionType.SELECT,
null,
"SELECT temp2.t2R0 AS t3t0",
"FROM temp2",
"ORDER BY temp2.t2R1 ASC")));
}
@Test
public void testComplexC() throws Throwable {
SchemaContext db = buildSchema(TestName.MULTI, schema);
PEPersistentGroup group = db.getCurrentDatabase().getDefaultStorage(db);
stmtTest(
db,
"select id, concat(desc, slug) as complete from A group by complete",
SelectStatement.class,
bes(
new ProjectingExpectedStep(
ExecutionType.SELECT,
group,
"temp1",
TransientExecutionEngine.LARGE,
StaticDistributionModel.MODEL_NAME,
new String[] {"complete"},
new String[][] {},
"SELECT `A`.`id` AS A1i0_5,concat( `A`.`desc`,`A`.`slug` ) AS complete",
"FROM `A`"),
new ProjectingExpectedStep(
ExecutionType.SELECT,
TransientExecutionEngine.LARGE,
"temp2",
TransientExecutionEngine.AGGREGATION,
StaticDistributionModel.MODEL_NAME,
new String[] {},
new String[][] {},
"SELECT temp1.A1i0_5 AS t2A0,temp1.complete AS complete",
"FROM temp1",
"GROUP BY complete ASC"),
new ProjectingExpectedStep(
ExecutionType.SELECT,
null,
"SELECT temp2.t2A0 AS t3t0,temp2.complete AS complete",
"FROM temp2",
"ORDER BY complete ASC")));
}
private ProjectionInfo buildProjectionMetadata(SchemaContext pc, List<ExpressionNode> proj) {
Emitter emitter = Singletons.require(HostService.class).getDBNative().getEmitter();
try {
emitter.setOptions(EmitOptions.RESULTSETMETADATA);
emitter.pushContext(pc.getTokens());
ProjectionInfo pi = new ProjectionInfo(proj.size());
for (int i = 0; i < proj.size(); i++) {
ExpressionNode e = proj.get(i);
String columnName = null;
String aliasName = null;
ColumnInstance ci = null;
if (e.getSourceLocation() != null && e.getSourceLocation().isComputed()) {
aliasName = e.getSourceLocation().getText();
}
if (e instanceof ExpressionAlias) {
ExpressionAlias ea = (ExpressionAlias) e;
Alias aname = ea.getAlias();
if (aname != null) aliasName = PEStringUtils.dequote(aname.getSQL());
ExpressionNode cname = ea.getTarget();
StringBuilder buf = new StringBuilder();
emitter.emitExpression(pc, cname, buf);
columnName = buf.toString();
if (cname instanceof ColumnInstance) {
ci = (ColumnInstance) cname;
} else {
aliasName = PEStringUtils.dequote(aliasName);
columnName = aliasName;
}
} else if (e instanceof ColumnInstance) {
ci = (ColumnInstance) e;
StringBuilder buf = new StringBuilder();
emitter.emitExpression(pc, e, buf);
columnName = buf.toString();
aliasName = PEStringUtils.dequote(columnName);
} else {
if (aliasName != null) {
// via above
columnName = aliasName;
} else {
StringBuilder buf = new StringBuilder();
emitter.emitExpression(pc, e, buf);
columnName =
(e instanceof LiteralExpression)
? PEStringUtils.dequote(buf.toString())
: buf.toString();
aliasName = columnName;
}
}
ColumnInfo colInfo =
pi.addColumn(i + 1, columnName, (aliasName == null ? columnName : aliasName));
if (ci != null) {
String tblName = null;
String dbName = null;
Column<?> backingColumn = ci.getColumn();
TableKey tk = ci.getTableInstance().getTableKey();
if (tk instanceof MTTableKey) {
MTTableKey mtk = (MTTableKey) tk;
tblName = mtk.getScope().getName().getUnqualified().getUnquotedName().get();
PETenant tenant = mtk.getScope().getTenant(pc);
PEDatabase pdb = tenant.getDatabase(pc);
if (pdb.getMTMode() == MultitenantMode.ADAPTIVE)
dbName = tenant.getName().getUnqualified().getUnquotedName().get();
else dbName = pdb.getName().getUnqualified().getUnquotedName().get();
} else {
Table<?> tab = tk.getTable();
if (tab.isInfoSchema()) {
dbName = PEConstants.INFORMATION_SCHEMA_DBNAME;
} else {
Database<?> tabDb = tab.getDatabase(pc);
if (tab.isTempTable() && (tabDb == null)) {
tabDb = pc.getCurrentDatabase(false);
if (tabDb == null) {
tabDb = pc.getAnyNonSchemaDatabase();
}
final TempTable tabAstempTable = ((TempTable) tab);
tabAstempTable.setDatabase(pc, (PEDatabase) tabDb, true);
tabAstempTable.refreshColumnLookupTable();
}
if (tabDb != null) {
dbName = tabDb.getName().getUnqualified().getUnquotedName().get();
}
}
tblName = tab.getName(pc).getUnqualified().getUnquotedName().get();
}
if (tblName != null) colInfo.setDatabaseAndTable(dbName, tblName);
if (backingColumn instanceof PEColumn) {
// set flags
PEColumn pec = (PEColumn) backingColumn;
if (!pec.isNotNullable() || pec.isNullable())
colInfo.setAttribute(ColumnAttribute.NULLABLE);
if (pec.isAutoIncrement()) colInfo.setAttribute(ColumnAttribute.AUTO_INCREMENT);
if (pec.isKeyPart()) {
colInfo.setAttribute(ColumnAttribute.KEY_PART);
if (pec.isPrimaryKeyPart()) colInfo.setAttribute(ColumnAttribute.PRIMARY_KEY_PART);
if (pec.isUniquePart()) colInfo.setAttribute(ColumnAttribute.UNIQUE_PART);
}
}
}
}
return pi;
} finally {
emitter.popContext();
}
}