public void onMatch(RelOptRuleCall call) {
ProjectRel project = (ProjectRel) call.rels[0];
List<RexNode> expList = new ArrayList<RexNode>(Arrays.asList(project.getChildExps()));
if (reduceExpressions(project, expList)) {
call.transformTo(
new ProjectRel(
project.getCluster(),
project.getChild(),
expList.toArray(new RexNode[expList.size()]),
project.getRowType(),
ProjectRel.Flags.Boxed,
Collections.<RelCollation>emptyList()));
// New plan is absolutely better than old plan.
call.getPlanner().setImportance(project, 0.0);
}
}
public void onMatch(RelOptRuleCall call) {
JoinRel join = (JoinRel) call.rels[0];
List<RexNode> expList = new ArrayList<RexNode>(Arrays.asList(join.getChildExps()));
if (reduceExpressions(join, expList)) {
call.transformTo(
new JoinRel(
join.getCluster(),
join.getLeft(),
join.getRight(),
expList.get(0),
join.getJoinType(),
join.getVariablesStopped()));
// New plan is absolutely better than old plan.
call.getPlanner().setImportance(join, 0.0);
}
}
public void onMatch(RelOptRuleCall call) {
FilterRel filter = (FilterRel) call.rels[0];
List<RexNode> expList = new ArrayList<RexNode>(Arrays.asList(filter.getChildExps()));
RexNode newConditionExp;
boolean reduced;
if (reduceExpressions(filter, expList)) {
assert (expList.size() == 1);
newConditionExp = expList.get(0);
reduced = true;
} else {
// No reduction, but let's still test the original
// predicate to see if it was already a constant,
// in which case we don't need any runtime decision
// about filtering.
newConditionExp = filter.getChildExps()[0];
reduced = false;
}
if (newConditionExp.isAlwaysTrue()) {
call.transformTo(filter.getChild());
} else if ((newConditionExp instanceof RexLiteral)
|| RexUtil.isNullLiteral(newConditionExp, true)) {
call.transformTo(new EmptyRel(filter.getCluster(), filter.getRowType()));
} else if (reduced) {
call.transformTo(CalcRel.createFilter(filter.getChild(), expList.get(0)));
} else {
if (newConditionExp instanceof RexCall) {
RexCall rexCall = (RexCall) newConditionExp;
boolean reverse = (rexCall.getOperator() == SqlStdOperatorTable.notOperator);
if (reverse) {
rexCall = (RexCall) rexCall.getOperands()[0];
}
reduceNotNullableFilter(call, filter, rexCall, reverse);
}
return;
}
// New plan is absolutely better than old plan.
call.getPlanner().setImportance(filter, 0.0);
}
/** Initializes this catalog reader. */
protected void init() {
final RelDataType intType = typeFactory.createSqlType(SqlTypeName.INTEGER);
final RelDataType varchar10Type = typeFactory.createSqlType(SqlTypeName.VARCHAR, 10);
final RelDataType varchar20Type = typeFactory.createSqlType(SqlTypeName.VARCHAR, 20);
final RelDataType timestampType = typeFactory.createSqlType(SqlTypeName.TIMESTAMP);
final RelDataType booleanType = typeFactory.createSqlType(SqlTypeName.BOOLEAN);
final RelDataType rectilinearCoordType =
typeFactory.createStructType(new RelDataType[] {intType, intType}, new String[] {"X", "Y"});
// TODO jvs 12-Feb-2005: register this canonical instance with type
// factory
addressType =
new ObjectSqlType(
SqlTypeName.STRUCTURED,
new SqlIdentifier("ADDRESS", SqlParserPos.ZERO),
false,
Arrays.asList(
new RelDataTypeFieldImpl("STREET", 0, varchar20Type),
new RelDataTypeFieldImpl("CITY", 1, varchar20Type),
new RelDataTypeFieldImpl("ZIP", 1, intType),
new RelDataTypeFieldImpl("STATE", 1, varchar20Type)),
RelDataTypeComparability.None);
// Register "SALES" schema.
MockSchema salesSchema = new MockSchema("SALES");
registerSchema(salesSchema);
// Register "EMP" table.
MockTable empTable = new MockTable(this, salesSchema, "EMP");
empTable.addColumn("EMPNO", intType);
empTable.addColumn("ENAME", varchar20Type);
empTable.addColumn("JOB", varchar10Type);
empTable.addColumn("MGR", intType);
empTable.addColumn("HIREDATE", timestampType);
empTable.addColumn("SAL", intType);
empTable.addColumn("COMM", intType);
empTable.addColumn("DEPTNO", intType);
empTable.addColumn("SLACKER", booleanType);
registerTable(empTable);
// Register "DEPT" table.
MockTable deptTable = new MockTable(this, salesSchema, "DEPT");
deptTable.addColumn("DEPTNO", intType);
deptTable.addColumn("NAME", varchar10Type);
registerTable(deptTable);
// Register "BONUS" table.
MockTable bonusTable = new MockTable(this, salesSchema, "BONUS");
bonusTable.addColumn("ENAME", varchar20Type);
bonusTable.addColumn("JOB", varchar10Type);
bonusTable.addColumn("SAL", intType);
bonusTable.addColumn("COMM", intType);
registerTable(bonusTable);
// Register "SALGRADE" table.
MockTable salgradeTable = new MockTable(this, salesSchema, "SALGRADE");
salgradeTable.addColumn("GRADE", intType);
salgradeTable.addColumn("LOSAL", intType);
salgradeTable.addColumn("HISAL", intType);
registerTable(salgradeTable);
// Register "EMP_ADDRESS" table
MockTable contactAddressTable = new MockTable(this, salesSchema, "EMP_ADDRESS");
contactAddressTable.addColumn("EMPNO", intType);
contactAddressTable.addColumn("HOME_ADDRESS", addressType);
contactAddressTable.addColumn("MAILING_ADDRESS", addressType);
registerTable(contactAddressTable);
// Register "CUSTOMER" schema.
MockSchema customerSchema = new MockSchema("CUSTOMER");
registerSchema(customerSchema);
// Register "CONTACT" table.
MockTable contactTable = new MockTable(this, customerSchema, "CONTACT");
contactTable.addColumn("CONTACTNO", intType);
contactTable.addColumn("FNAME", varchar10Type);
contactTable.addColumn("LNAME", varchar10Type);
contactTable.addColumn("EMAIL", varchar20Type);
contactTable.addColumn("COORD", rectilinearCoordType);
registerTable(contactTable);
// Register "ACCOUNT" table.
MockTable accountTable = new MockTable(this, customerSchema, "ACCOUNT");
accountTable.addColumn("ACCTNO", intType);
accountTable.addColumn("TYPE", varchar20Type);
accountTable.addColumn("BALANCE", intType);
registerTable(accountTable);
}
// override Rel
public void explain(RelOptPlanWriter pw) {
pw.explain(
this, new String[] {"child", "fieldNames"}, new Object[] {Arrays.asList(fieldNames)});
}
