@Override
public ParseTree visitChildInternal(RelNode child, int ordinal) {
final Convention convention = child.getConvention();
if (!(child instanceof JavaRel)) {
throw Util.newInternal(
"Relational expression '"
+ child
+ "' has '"
+ convention
+ "' calling convention, so must implement interface "
+ JavaRel.class);
}
JavaRel javaRel = (JavaRel) child;
final ParseTree p = javaRel.implement(this);
if ((convention == CallingConvention.JAVA) && (p != null)) {
throw Util.newInternal(
"Relational expression '"
+ child
+ "' returned '"
+ p
+ " on implement, but should have "
+ "returned null, because it has JAVA calling-convention. "
+ "(Note that similar calling-conventions, such as "
+ "Iterator, must return a value.)");
}
return p;
}
/**
* Creates a JavaRelImplementor
*
* @param rexBuilder Builder for {@link RexNode}s
* @param implementorTable Table of implementations of operators. Must not be null
*/
public JavaRelImplementor(RexBuilder rexBuilder, OJRexImplementorTable implementorTable) {
super(rexBuilder);
Util.pre(rexBuilder != null, "rexBuilder != null");
Util.pre(implementorTable != null, "implementorTable != null");
this.implementorTable = implementorTable;
nextVariableId = 0;
}
/**
* Creates an expression which references correlating variable <code>
* correlName</code> from the context of <code>rel</code>. For example, if <code>correlName</code>
* is set by the 1st child of <code>rel</code>'s 2nd child, then this method returns <code>
* $input2.$input1</code>.
*/
public Expression makeReference(String correlName, RelNode rel) {
JavaFrame frame = (JavaFrame) mapCorrel2Frame.get(correlName);
assert (frame != null);
assert Util.equal(frame.rel.getCorrelVariable(), correlName);
assert (frame.hasVariable());
return frame.getVariable();
}
private void bindDeferred(JavaFrame frame, final RelNode rel) {
final StatementList statementList = getStatementList();
if (frame.bind == null) {
// this relational expression has not bound itself, so we presume
// that we can call its implementSelf() method
if (!(rel instanceof JavaSelfRel)) {
throw Util.newInternal(
"In order to bind-deferred, a "
+ "relational expression must implement JavaSelfRel: "
+ rel);
}
final JavaSelfRel selfRel = (JavaSelfRel) rel;
LazyBind lazyBind =
new LazyBind(
newVariable(),
statementList,
getTypeFactory(),
rel.getRowType(),
new VariableInitializerThunk() {
public VariableInitializer getInitializer() {
return selfRel.implementSelf(JavaRelImplementor.this);
}
});
bind(rel, lazyBind);
} else if ((frame.bind instanceof LazyBind)
&& (((LazyBind) frame.bind).statementList != statementList)) {
// Frame is already bound, but to a variable declared in a different
// scope. Re-bind it.
final LazyBind lazyBind = (LazyBind) frame.bind;
lazyBind.statementList = statementList;
lazyBind.bound = false;
}
}
/**
* Records the fact that instances of <code>rel</code> are available via <code>bind</code> (which
* may be eager or lazy).
*/
private void bind(RelNode rel, Bind bind) {
tracer.log(Level.FINE, "Bind " + rel.toString() + " to " + bind);
JavaFrame frame = (JavaFrame) mapRel2Frame.get(rel);
frame.bind = bind;
boolean stupid = SaffronProperties.instance().stupid.get();
if (stupid) {
// trigger the declaration of the variable, even though it
// may not be used
Util.discard(bind.getVariable());
}
}
private static int find(StatementList list, Statement statement) {
if (statement == null) {
return 0;
} else {
for (int i = 0, n = list.size(); i < n; i++) {
if (list.get(i) == statement) {
return i + 1;
}
}
throw Util.newInternal("could not find statement " + statement + " in list " + list);
}
}
/**
* Generate the HTML message that appears in the about box.
*
* @param infoSource The path to the information to display in the about box.
* @return the generated message
*/
private String generateMessage(final String infoSource) {
Map appInfo = loadApplicationInfo(infoSource);
StringBuffer message = new StringBuffer("<html>");
message.append("<head>");
message.append("<style type=\"text/css\">");
message.append("P.title {text-align: center; font-size: large;}");
message.append("P.version {text-align: center; font-size: medium;}");
message.append("P.description {text-align: left; font-size:medium;}");
message.append("li.author {font-size:medium;}");
message.append("td.footer {text-align: center; font-size:small;}");
message.append("Body.normal {background-color: silver}");
message.append("</style>");
message.append("</head>");
message.append("<body class=normal>");
String appName = getValue("name", appInfo);
message.append("<P class=title>" + appName + "</P>");
String version = getValue("version", appInfo);
message.append("<P class=version> <b>Version:</b> " + version + "</P>");
String description = getValue("description", appInfo);
message.append("<dl><dt><b>Description:</b></dt><dd>" + description + "</dd></dl>");
String authorList = getValue("authors", appInfo);
String[] authors = Util.getTokens(authorList, ",");
message.append("<p> <b>Authors:</b>");
for (int index = 0; index < authors.length; index++) {
String author = authors[index];
message.append("<li class=author>" + author + "</li>");
}
message.append("</p>");
message.append("<center> <table width=80%>");
message.append("<tr><td class=footer> <hr> </td></tr>");
String organization = getValue("organization", appInfo);
message.append("<tr><td class=footer>" + organization + "</td></tr>");
String date = getValue("date", appInfo);
message.append("<tr><td class=footer>" + date + "</td></tr>");
message.append("</table> </P>");
message.append("</body>");
message.append("</html>");
return message.toString();
}
/**
* Load the application information from the properties file specified by the application adaptor.
* The resource bundle information is stored in a Map for convenient access.
*
* @param path Path to the source information.
* @return The map containing the application information
*/
private Map loadApplicationInfo(final String path) {
Map infoMap;
try {
infoMap = Util.loadResourceBundle(path);
} catch (MissingResourceException exception) {
final String message = "No application \"About Box\" information resource found at: " + path;
Logger.getLogger("global").log(Level.WARNING, message, exception);
System.err.println(message);
// substitute with default information
infoMap = new HashMap();
infoMap.put("name", Application.getAdaptor().getClass().getName());
}
return infoMap;
}
public String format(LogRecord record) {
StringBuffer buf = new StringBuffer(1000);
buf.append(new java.util.Date());
buf.append(" : ");
if (Level.INFO != record.getLevel()) {
buf.append(record.getLevel());
buf.append(": ");
}
buf.append(formatMessage(record));
if (Util.isWinOS()) {
buf.append("\r\n");
} else {
buf.append("\n");
}
return buf.toString();
}
/**
* Convert Key # -> _
*
* @param key
* @return converted key
*/
private String convertKey(String key) {
String retValue = Util.replace(key, "#", "_");
return retValue;
} // convertKey
public Variable getConnectionVariable() {
throw Util.needToImplement("getConnectionVariable");
}
/**
* Generates code for a Java expression satisfying the {@link org.eigenbase.runtime.TupleIter}
* interface. The generated code allocates a {@link org.eigenbase.runtime.CalcTupleIter} with a
* dynamic {@link org.eigenbase.runtime.TupleIter#fetchNext()} method. If the "abort on error"
* flag is false, or an error handling tag is specified, then fetchNext is written to handle row
* errors.
*
* <p>Row errors are handled by wrapping expressions that can fail with a try/catch block. A
* caught RuntimeException is then published to an "connection variable." In the event that errors
* can overflow, an "error buffering" flag allows them to be posted again on the next iteration of
* fetchNext.
*
* @param implementor an object that implements relations as Java code
* @param rel the relation to be implemented
* @param childExp the implemented child of the relation
* @param varInputRow the Java variable to use for the input row
* @param inputRowType the rel data type of the input row
* @param outputRowType the rel data type of the output row
* @param program the rex program to implemented by the relation
* @param tag an error handling tag
* @return a Java expression satisfying the TupleIter interface
*/
public static Expression implementAbstractTupleIter(
JavaRelImplementor implementor,
JavaRel rel,
Expression childExp,
Variable varInputRow,
final RelDataType inputRowType,
final RelDataType outputRowType,
RexProgram program,
String tag) {
MemberDeclarationList memberList = new MemberDeclarationList();
// Perform error recovery if continuing on errors or if
// an error handling tag has been specified
boolean errorRecovery = !abortOnError || (tag != null);
// Error buffering should not be enabled unless error recovery is
assert !errorBuffering || errorRecovery;
// Allow backwards compatibility until all Farrago extensions are
// satisfied with the new error handling semantics. The new semantics
// include:
// (1) cast input object to input row object outside of try block,
// should be fine, at least for base Farrago
// (2) maintain a columnIndex counter to better locate of error,
// at the cost of a few cycles
// (3) publish errors to the runtime context. FarragoRuntimeContext
// now supports this API
boolean backwardsCompatible = true;
if (tag != null) {
backwardsCompatible = false;
}
RelDataTypeFactory typeFactory = implementor.getTypeFactory();
OJClass outputRowClass = OJUtil.typeToOJClass(outputRowType, typeFactory);
OJClass inputRowClass = OJUtil.typeToOJClass(inputRowType, typeFactory);
Variable varOutputRow = implementor.newVariable();
FieldDeclaration inputRowVarDecl =
new FieldDeclaration(
new ModifierList(ModifierList.PRIVATE),
TypeName.forOJClass(inputRowClass),
varInputRow.toString(),
null);
FieldDeclaration outputRowVarDecl =
new FieldDeclaration(
new ModifierList(ModifierList.PRIVATE),
TypeName.forOJClass(outputRowClass),
varOutputRow.toString(),
new AllocationExpression(outputRowClass, new ExpressionList()));
// The method body for fetchNext, a main target of code generation
StatementList nextMethodBody = new StatementList();
// First, post an error if it overflowed the previous time
// if (pendingError) {
// rc = handleRowError(...);
// if (rc instanceof NoDataReason) {
// return rc;
// }
// pendingError = false;
// }
if (errorBuffering) {
// add to next method body...
}
// Most of fetchNext falls within a while() block. The while block
// allows us to try multiple input rows against a filter condition
// before returning a single row.
// while (true) {
// Object varInputObj = inputIterator.fetchNext();
// if (varInputObj instanceof TupleIter.NoDataReason) {
// return varInputObj;
// }
// varInputRow = (InputRowClass) varInputObj;
// int columnIndex = 0;
// [calculation statements]
// }
StatementList whileBody = new StatementList();
Variable varInputObj = implementor.newVariable();
whileBody.add(
new VariableDeclaration(
OJUtil.typeNameForClass(Object.class),
varInputObj.toString(),
new MethodCall(new FieldAccess("inputIterator"), "fetchNext", new ExpressionList())));
StatementList ifNoDataReasonBody = new StatementList();
whileBody.add(
new IfStatement(
new InstanceofExpression(
varInputObj, OJUtil.typeNameForClass(TupleIter.NoDataReason.class)),
ifNoDataReasonBody));
ifNoDataReasonBody.add(new ReturnStatement(varInputObj));
// Push up the row declaration for new error handling so that the
// input row is available to the error handler
if (!backwardsCompatible) {
whileBody.add(assignInputRow(inputRowClass, varInputRow, varInputObj));
}
Variable varColumnIndex = null;
if (errorRecovery && !backwardsCompatible) {
// NOTE jvs 7-Oct-2006: Declare varColumnIndex as a member
// (rather than a local) in case in the future we want
// to decompose complex expressions into helper methods.
varColumnIndex = implementor.newVariable();
FieldDeclaration varColumnIndexDecl =
new FieldDeclaration(
new ModifierList(ModifierList.PRIVATE),
OJUtil.typeNameForClass(int.class),
varColumnIndex.toString(),
null);
memberList.add(varColumnIndexDecl);
whileBody.add(
new ExpressionStatement(
new AssignmentExpression(
varColumnIndex, AssignmentExpression.EQUALS, Literal.makeLiteral(0))));
}
// Calculator (projection, filtering) statements are later appended
// to calcStmts. Typically, this target will be the while list itself.
StatementList calcStmts;
if (!errorRecovery) {
calcStmts = whileBody;
} else {
// For error recovery, we wrap the calc statements
// (e.g., everything but the code that reads rows from the
// inputIterator) in a try/catch that publishes exceptions.
calcStmts = new StatementList();
// try { /* calcStmts */ }
// catch(RuntimeException ex) {
// Object rc = connection.handleRowError(...);
// [buffer error if necessary]
// }
StatementList catchStmts = new StatementList();
if (backwardsCompatible) {
catchStmts.add(
new ExpressionStatement(
new MethodCall(
new MethodCall(
OJUtil.typeNameForClass(EigenbaseTrace.class), "getStatementTracer", null),
"log",
new ExpressionList(
new FieldAccess(OJUtil.typeNameForClass(Level.class), "WARNING"),
Literal.makeLiteral("java calc exception"),
new FieldAccess("ex")))));
} else {
Variable varRc = implementor.newVariable();
ExpressionList handleRowErrorArgs =
new ExpressionList(varInputRow, new FieldAccess("ex"), varColumnIndex);
handleRowErrorArgs.add(Literal.makeLiteral(tag));
catchStmts.add(
new VariableDeclaration(
OJUtil.typeNameForClass(Object.class),
varRc.toString(),
new MethodCall(
implementor.getConnectionVariable(), "handleRowError", handleRowErrorArgs)));
// Buffer an error if it overflowed
// if (rc instanceof NoDataReason) {
// pendingError = true;
// [save error state]
// return rc;
// }
if (errorBuffering) {
// add to catch statements...
}
}
CatchList catchList =
new CatchList(
new CatchBlock(
new Parameter(OJUtil.typeNameForClass(RuntimeException.class), "ex"),
catchStmts));
TryStatement tryStmt = new TryStatement(calcStmts, catchList);
whileBody.add(tryStmt);
}
if (backwardsCompatible) {
calcStmts.add(assignInputRow(inputRowClass, varInputRow, varInputObj));
}
StatementList condBody;
RexToOJTranslator translator = implementor.newStmtTranslator(rel, calcStmts, memberList);
try {
translator.pushProgram(program);
if (program.getCondition() != null) {
// TODO jvs 8-Oct-2006: move condition to its own
// method if big, as below for project exprs.
condBody = new StatementList();
RexNode rexIsTrue =
rel.getCluster()
.getRexBuilder()
.makeCall(SqlStdOperatorTable.isTrueOperator, program.getCondition());
Expression conditionExp = translator.translateRexNode(rexIsTrue);
calcStmts.add(new IfStatement(conditionExp, condBody));
} else {
condBody = calcStmts;
}
RelDataTypeField[] fields = outputRowType.getFields();
final List<RexLocalRef> projectRefList = program.getProjectList();
int i = -1;
for (RexLocalRef rhs : projectRefList) {
// NOTE jvs 14-Sept-2006: Put complicated project expressions
// into their own method, otherwise a big select list can easily
// blow the 64K Java limit on method bytecode size. Make
// methods private final in the hopes that they will get inlined
// JIT. For now we decide "complicated" based on the size of
// the generated Java parse tree. A big enough select list of
// simple expressions could still blow the limit, so we may need
// to group them together, sub-divide, etc.
StatementList projMethodBody = new StatementList();
if (errorRecovery && !backwardsCompatible) {
projMethodBody.add(
new ExpressionStatement(
new UnaryExpression(varColumnIndex, UnaryExpression.POST_INCREMENT)));
}
++i;
RexToOJTranslator projTranslator = translator.push(projMethodBody);
String javaFieldName = Util.toJavaId(fields[i].getName(), i);
Expression lhs = new FieldAccess(varOutputRow, javaFieldName);
projTranslator.translateAssignment(fields[i], lhs, rhs);
int complexity = OJUtil.countParseTreeNodes(projMethodBody);
// REVIEW: HCP 5/18/2011
// The projMethod should be checked
// for causing possible compiler errors caused by the use of
// variables declared in other projMethods. Also the
// local declaration of variabled used by other proj methods
// should also be checked.
// Fixing for backswing integration 14270
// TODO: check if abstracting this method body will cause
// a compiler error
if (true) {
// No method needed; just append.
condBody.addAll(projMethodBody);
continue;
}
// Need a separate method.
String projMethodName = "calc_" + varOutputRow.toString() + "_f_" + i;
MemberDeclaration projMethodDecl =
new MethodDeclaration(
new ModifierList(ModifierList.PRIVATE | ModifierList.FINAL),
TypeName.forOJClass(OJSystem.VOID),
projMethodName,
new ParameterList(),
null,
projMethodBody);
memberList.add(projMethodDecl);
condBody.add(new ExpressionStatement(new MethodCall(projMethodName, new ExpressionList())));
}
} finally {
translator.popProgram(program);
}
condBody.add(new ReturnStatement(varOutputRow));
WhileStatement whileStmt = new WhileStatement(Literal.makeLiteral(true), whileBody);
nextMethodBody.add(whileStmt);
MemberDeclaration fetchNextMethodDecl =
new MethodDeclaration(
new ModifierList(ModifierList.PUBLIC),
OJUtil.typeNameForClass(Object.class),
"fetchNext",
new ParameterList(),
null,
nextMethodBody);
// The restart() method should reset variables used to buffer errors
// pendingError = false
if (errorBuffering) {
// declare refinement of restart() and add to member list...
}
memberList.add(inputRowVarDecl);
memberList.add(outputRowVarDecl);
memberList.add(fetchNextMethodDecl);
Expression newTupleIterExp =
new AllocationExpression(
OJUtil.typeNameForClass(CalcTupleIter.class), new ExpressionList(childExp), memberList);
return newTupleIterExp;
}