private void normalizeSorts(
SchemaContext pc, Map<RewriteKey, ExpressionNode> projMap, Edge<?, ?> in) {
@SuppressWarnings("unchecked")
MultiEdge<?, SortingSpecification> min = (MultiEdge<?, SortingSpecification>) in;
for (SortingSpecification ss : min.getMulti()) {
ExpressionNode target = ss.getTarget();
if (target instanceof AliasInstance) continue;
else if (target instanceof LiteralExpression) {
// i.e. order by 1,2,3
LiteralExpression le = (LiteralExpression) target;
Object value = le.getValue(pc);
if (value instanceof Long) {
Long index = (Long) value;
if ((index.intValue() - 1) < projection.size()) {
target = ExpressionUtils.getTarget(projection.get(index.intValue() - 1));
}
}
}
ExpressionNode inProjection = projMap.get(target.getRewriteKey());
if (inProjection != null) {
ExpressionAlias ea = (ExpressionAlias) inProjection.getParent();
AliasInstance ai = ea.buildAliasInstance();
ss.getTargetEdge().set(ai);
}
}
}
private LanguageNode fold(LanguageNode in, EngineToken variety) {
FunctionCall fc = (FunctionCall) in;
ArrayList<ExpressionNode> grouped = new ArrayList<ExpressionNode>();
ArrayList<ExpressionNode> same = new ArrayList<ExpressionNode>();
ArrayList<ExpressionNode> others = new ArrayList<ExpressionNode>();
for (ExpressionNode p : fc.getParameters()) {
if (EngineConstant.FUNCTION.has(p, variety)) {
if (p.isGrouped()) grouped.add(p);
else same.add(p);
} else {
others.add(p);
}
}
if (same.isEmpty() || !grouped.isEmpty()) return in;
// if others is empty, this is op(op(a,b),op(c,d)), build op(a,b,c,d)
// if others is not empty, this is op(a,op(b,c)) or op(op(a,b),c), build op(a,b,c)
ArrayList<ExpressionNode> allsubs = new ArrayList<ExpressionNode>();
for (ExpressionNode p : same) {
FunctionCall pfc = (FunctionCall) p;
allsubs.addAll(pfc.getParameters());
}
allsubs.addAll(others);
// we're going to group this as well
FunctionCall ofc = new FunctionCall(fc.getFunctionName(), allsubs);
ofc.setGrouped();
return ofc;
}
public static SelectStatement filterEntryProjection(SelectStatement in, PartitionEntry jre)
throws PEException {
PartitionEntry actual = jre.getActualEntry();
SelectStatement expecting = null;
if (actual instanceof OriginalPartitionEntry)
expecting = ((OriginalPartitionEntry) actual).getChildCopy();
else expecting = actual.getJoinQuery(null);
ListSet<ColumnKey> ec = new ListSet<ColumnKey>();
for (ExpressionNode en : expecting.getProjection()) {
ExpressionNode targ = ExpressionUtils.getTarget(en);
if (targ instanceof ColumnInstance) {
ColumnKey was = ((ColumnInstance) targ).getColumnKey();
ColumnKey isnow = in.getMapper().copyColumnKeyForward(was);
if (isnow == null) {
throw new SchemaException(Pass.PLANNER, "Lost column during lookup table join");
}
ec.add(isnow);
} else if (targ instanceof FunctionCall) {
ExpressionNode exn = targ;
RewriteKey rk = in.getMapper().mapExpressionToColumn(exn);
while (rk == null && (exn.getParent() instanceof ExpressionNode)) {
exn = (ExpressionNode) exn.getParent();
rk = in.getMapper().mapExpressionToColumn(exn);
}
if (rk != null) {
ec.add((ColumnKey) rk);
}
}
}
for (Iterator<ExpressionNode> iter = in.getProjectionEdge().iterator(); iter.hasNext(); ) {
ExpressionNode en = ExpressionUtils.getTarget(iter.next());
if (en instanceof ColumnInstance) {
ColumnKey ck = ((ColumnInstance) en).getColumnKey();
if (!ec.contains(ck)) iter.remove();
}
}
return in;
}
private List<ExpressionNode> assignProjectionAliases(
SchemaContext pc, List<ExpressionNode> in, AliasInformation ai) {
ArrayList<ExpressionNode> np = new ArrayList<ExpressionNode>();
for (ExpressionNode e : in) {
if (e instanceof ExpressionAlias) {
// already has an alias
ExpressionAlias ea = (ExpressionAlias) e;
if (ea.isSynthetic()) {
// check for dup aliases
UnqualifiedName unq = ea.getAlias().getNameAlias();
if (ai.isDuplicateAlias(unq)) {
NameAlias prefix = ea.getTarget().buildAlias(pc);
ea.setAlias(ai.buildNewAlias(prefix.getNameAlias()));
}
} else if (ea.getAlias() instanceof StringLiteralAlias) {
// mysql 5.5 docs state it is OK specify as a column alias as either a identifier or
// string quoted literal in the projection
// so here we convert the StringLiteralAlias 'foo' into NameAlias `foo`
final StringLiteralAlias stringLit = (StringLiteralAlias) ea.getAlias();
if (!stringLit.get().isEmpty()) {
final UnqualifiedName unq = new UnqualifiedName(stringLit.get(), true);
ea.setAlias(unq);
} else {
ea.setAlias(ai.buildNewAlias(null));
}
}
np.add(e);
} else {
// see if we can build something reasonable
NameAlias prefix = e.buildAlias(pc);
np.add(
new ExpressionAlias(e, new NameAlias(ai.buildNewAlias(prefix.getNameAlias())), true));
}
}
return np;
}
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();
}
}
public AndedParts(LanguageNode owning, TableKey tk, List<Part> inparts) {
this(owning, tk, inparts, false);
((ExpressionNode) owning).setGrouped();
}
public OredParts(LanguageNode parent, TableKey tk, Collection<Part> p) {
super(parent, tk);
parts = new ListSet<Part>();
parts.addAll(p);
((ExpressionNode) parent).setGrouped();
}