private void genWHERE(SqlExprList conditions) { out.print("WHERE"); out.print(" "); out.incIndent(); conditionList(conditions); out.decIndent(); }
@Override public void visit(SqlSelectBlock sqlSelectBlock) { // Need a rename and alias if: // Not top // Not merely a table inside. levelSelectBlock++; if (levelSelectBlock > 1) { // Alias needed. // SqlRename rename = SqlRename.view("X", sqlSelectBlock) ; // rename.visit(this) ; // levelSelectBlock-- ; // return ; } genPrefix(sqlSelectBlock); out.print("SELECT "); if (sqlSelectBlock.getDistinct()) out.print("DISTINCT "); if (annotate(sqlSelectBlock)) out.ensureStartOfLine(); out.incIndent(); genColumnPrefix(sqlSelectBlock); print(sqlSelectBlock.getCols()); out.decIndent(); out.ensureStartOfLine(); // FROM out.print("FROM"); if (!sqlSelectBlock.getSubNode().isTable()) out.println(); else out.print(" "); out.incIndent(); outputNode(sqlSelectBlock.getSubNode(), true); // sqlSelectBlock.getSubNode().visit(this) ; out.decIndent(); out.ensureStartOfLine(); // WHERE if (sqlSelectBlock.getConditions().size() > 0) genWHERE(sqlSelectBlock.getConditions()); // LIMIT/OFFSET out.ensureStartOfLine(); genLimitOffset(sqlSelectBlock); genSuffix(sqlSelectBlock); levelSelectBlock--; }
protected void visitJoin(SqlJoin join, String joinOperatorName) { // TODO revisit this code. Is it now needless complex? // Check brackets for more general SQL generation (safe mode - i.e. always bracketted?) SqlNode left = join.getLeft(); SqlNode right = join.getRight(); // Appearance: stop nesting too much. // Can we linearise the format? (drop indentation) if (left.isJoin() && left.getAliasName() == null) outputNode(left, false); else { out.incIndent(); outputNode(left, true); out.decIndent(); } out.println(); // out.print(" ") ; out.print(joinOperatorName); annotate(join); out.println(); // Aliasing and scoping - may need sub-SELECT - or just don't generate // such SqlNode structures, leaving only COALESCE as the sub-SELECT case boolean bracketsRight = true; // if ( right.isInnerJoin() && join.isInnerJoin() && no conditions ) // bracketsRight = false ; if (bracketsRight) // Why? out.incIndent(); outputNode(right, bracketsRight); if (bracketsRight) out.decIndent(); out.println(); out.print("ON "); if (join.getConditions().size() > 0) conditionList(join.getConditions()); else { out.print(" ( "); out.print(leftJoinNoConditionsString()); out.print(" )"); } }
@Override public void write(IndentedWriter writer) { writer.println("SqlOpProject" + columnNames + "("); writer.incIndent(); subOp.write(writer); writer.println(); writer.decIndent(); writer.print(")"); }
private void outputNode(SqlNode sqlNode, boolean mayNeedBrackets) { if (sqlNode.isTable()) { sqlNode.visit(this); return; } // boolean brackets = ( mayNeedBrackets && ( sqlNode.isSelectBlock() || sqlNode.isCoalesce() ) ) // ; boolean brackets = false; brackets = brackets || (mayNeedBrackets && sqlNode.isCoalesce()); // Work harder? ready for a better test. brackets = brackets || (mayNeedBrackets && sqlNode.isSelectBlock()); // Need brackets if the subpart is a SELECT if (brackets) { out.print("( "); out.incIndent(); } sqlNode.visit(this); if (brackets) { out.decIndent(); out.ensureStartOfLine(); out.print(")"); } // Every derived table (SELECT ...) must have an alias. // Is there a more principled way to do this? .isDerived? // if ( sqlNode.isRestrict() || sqlNode.isProject()) // out.print(+sqlNode.getAliasName()) ; if (sqlNode.getAliasName() != null) { out.print(aliasToken()); out.print(sqlNode.getAliasName()); } annotate(sqlNode); }