github/jooq
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Improved SQL rendering - cleanly separate keyword() and sql() calls.

Browse Source
This commit is contained in:
Lukas Eder 2013-08-12 14:52:42 +02:00
parent 983e9d2b5b
commit 86b0fe1e1d
16 changed files with 147 additions and 151 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
jOOQ/src/main/java/org/jooq/impl/Alias.java
View File

@ -189,7 +189,7 @@ class Alias<Q extends QueryPart> extends AbstractQueryPart {
private void toSQLAs(RenderContext context) { private void toSQLAs(RenderContext context) {
if (asList(DERBY, HSQLDB, MARIADB, MYSQL, POSTGRES).contains(context.configuration().dialect())) { if (asList(DERBY, HSQLDB, MARIADB, MYSQL, POSTGRES).contains(context.configuration().dialect())) {
context.keyword(" as"); context.sql(" ").keyword("as");
} }
} }

11
jOOQ/src/main/java/org/jooq/impl/ArrayTable.java
View File

@ -225,13 +225,10 @@ class ArrayTable extends AbstractTable<Record> {
@Override @Override
public void toSQL(RenderContext context) { public void toSQL(RenderContext context) {
context.keyword("(select * from unnest(") context.sql("(").keyword("select").sql(" * ")
.visit(array) .keyword("from").sql(" ").keyword("unnest").sql("(").visit(array).sql(") ")
.keyword(") as ") .keyword("as").sql(" ").literal(alias)
.literal(alias) .sql("(").literal("COLUMN_VALUE").sql("))");
.sql("(")
.literal("COLUMN_VALUE")
.sql("))");
} }
} }

9
jOOQ/src/main/java/org/jooq/impl/CaseConditionStepImpl.java
View File

@ -113,16 +113,13 @@ class CaseConditionStepImpl<T> extends AbstractField<T> implements CaseCondition
context.formatNewLine(); context.formatNewLine();
} }
context.keyword(" when ") context.sql(" ").keyword("when").sql(" ").visit(conditions.get(i))
.visit(conditions.get(i)) .sql(" ").keyword("then").sql(" ").visit(results.get(i));
.keyword(" then ")
.visit(results.get(i));
} }
if (otherwise != null) { if (otherwise != null) {
context.formatNewLine() context.formatNewLine()
.keyword(" else ") .sql(" ").keyword("else").sql(" ").visit(otherwise);
.visit(otherwise);
} }
context.formatIndentLockEnd(); context.formatIndentLockEnd();

11
jOOQ/src/main/java/org/jooq/impl/CaseWhenStepImpl.java
View File

@ -149,9 +149,9 @@ class CaseWhenStepImpl<V, T> extends AbstractField<T> implements CaseWhenStep<V,
ctx.formatNewLine(); ctx.formatNewLine();
} }
ctx.keyword(" when "); ctx.sql(" ").keyword("when").sql(" ");
ctx.visit(value.equal(compareValues.get(i))); ctx.visit(value.equal(compareValues.get(i)));
ctx.keyword(" then "); ctx.sql(" ").keyword("then").sql(" ");
ctx.visit(results.get(i)); ctx.visit(results.get(i));
} }
@ -168,9 +168,9 @@ class CaseWhenStepImpl<V, T> extends AbstractField<T> implements CaseWhenStep<V,
ctx.formatNewLine(); ctx.formatNewLine();
} }
ctx.keyword(" when "); ctx.sql(" ").keyword("when").sql(" ");
ctx.visit(compareValues.get(i)); ctx.visit(compareValues.get(i));
ctx.keyword(" then "); ctx.sql(" ").keyword("then").sql(" ");
ctx.visit(results.get(i)); ctx.visit(results.get(i));
} }
@ -180,8 +180,7 @@ class CaseWhenStepImpl<V, T> extends AbstractField<T> implements CaseWhenStep<V,
if (otherwise != null) { if (otherwise != null) {
ctx.formatNewLine() ctx.formatNewLine()
.keyword(" else ") .sql(" ").keyword("else").sql(" ").visit(otherwise);
.visit(otherwise);
} }
ctx.formatIndentLockEnd(); ctx.formatIndentLockEnd();

49
jOOQ/src/main/java/org/jooq/impl/Cast.java
View File

@ -85,15 +85,16 @@ class Cast<T> extends AbstractField<T> {
if (field.getDataType().isNumeric() && if (field.getDataType().isNumeric() &&
VARCHAR.equals(getSQLDataType())) { VARCHAR.equals(getSQLDataType())) {
context.keyword("trim(cast(") context.keyword("trim").sql("(")
.keyword("cast(") .keyword("cast").sql("(")
.castMode(CastMode.NEVER) .keyword("cast").sql("(")
.visit(field) .castMode(CastMode.NEVER)
.castMode(castMode) .visit(field)
.keyword(" as char(38))") .castMode(castMode)
.keyword(" as ") .sql(" ").keyword("as").sql(" char(38))")
.keyword(getDataType(context.configuration()).getCastTypeName(context.configuration())) .sql(" ").keyword("as").sql(" ")
.sql("))"); .keyword(getDataType(context.configuration()).getCastTypeName(context.configuration()))
.sql("))");
return; return;
} }
@ -102,14 +103,16 @@ class Cast<T> extends AbstractField<T> {
else if (field.getDataType().isString() && else if (field.getDataType().isString() &&
asList(FLOAT, DOUBLE, REAL).contains(getSQLDataType())) { asList(FLOAT, DOUBLE, REAL).contains(getSQLDataType())) {
context.keyword("cast(") context.keyword("cast").sql("(")
.keyword("cast(") .keyword("cast").sql("(")
.castMode(CastMode.NEVER) .castMode(CastMode.NEVER)
.visit(field) .visit(field)
.castMode(castMode) .castMode(castMode)
.keyword(" as decimal)") .sql(" ").keyword("as").sql(" ").keyword("decimal")
.keyword(" as ") .sql(") ")
.keyword(getDataType(context.configuration()).getCastTypeName(context.configuration())) .keyword("as")
.sql(" ")
.keyword(getDataType(context.configuration()).getCastTypeName(context.configuration()))
.sql(")"); .sql(")");
return; return;
@ -133,12 +136,12 @@ class Cast<T> extends AbstractField<T> {
} }
// Default rendering, if no special case has applied yet // Default rendering, if no special case has applied yet
context.keyword("cast(") context.keyword("cast").sql("(")
.castMode(CastMode.NEVER) .castMode(CastMode.NEVER)
.visit(field) .visit(field)
.castMode(castMode) .castMode(castMode)
.keyword(" as ") .sql(" ").keyword("as").sql(" ")
.keyword(getDataType(context.configuration()).getCastTypeName(context.configuration())) .keyword(getDataType(context.configuration()).getCastTypeName(context.configuration()))
.sql(")"); .sql(")");
} }

11
jOOQ/src/main/java/org/jooq/impl/CompareCondition.java
View File

@ -120,14 +120,13 @@ class CompareCondition extends AbstractCondition {
// characters long // characters long
boolean castRhs = (dialect == DB2 && rhs instanceof Concat); boolean castRhs = (dialect == DB2 && rhs instanceof Concat);
context.keyword(op.toSQL()) context.keyword(op.toSQL()).sql(" ");
.sql(" ") if (castRhs) context.keyword("cast").sql("(");
.keyword(castRhs ? "cast(" : "") context.visit(rhs);
.visit(rhs) if (castRhs) context.sql(" ").keyword("as").sql(" ").keyword("varchar").sql("(4000))");
.keyword(castRhs ? " as varchar(4000))" : "");
if (escape != null) { if (escape != null) {
context.keyword(" escape '") context.sql(" ").keyword("escape").sql(" '")
.sql(escape) .sql(escape)
.sql("'"); .sql("'");
} }

6
jOOQ/src/main/java/org/jooq/impl/DeleteQueryImpl.java
View File

@ -104,7 +104,7 @@ class DeleteQueryImpl<R extends Record> extends AbstractQuery implements DeleteQ
public final void toSQL(RenderContext context) { public final void toSQL(RenderContext context) {
boolean declare = context.declareTables(); boolean declare = context.declareTables();
context.keyword("delete "); context.keyword("delete").sql(" ");
// [#2464] MySQL supports a peculiar multi-table DELETE syntax for aliased tables: // [#2464] MySQL supports a peculiar multi-table DELETE syntax for aliased tables:
// DELETE t1 FROM my_table AS t1 // DELETE t1 FROM my_table AS t1
@ -119,14 +119,14 @@ class DeleteQueryImpl<R extends Record> extends AbstractQuery implements DeleteQ
} }
} }
context.keyword("from "); context.keyword("from").sql(" ");
context.declareTables(true) context.declareTables(true)
.visit(getFrom()) .visit(getFrom())
.declareTables(declare); .declareTables(declare);
if (!(getWhere() instanceof TrueCondition)) { if (!(getWhere() instanceof TrueCondition)) {
context.formatSeparator() context.formatSeparator()
.keyword("where ") .keyword("where").sql(" ")
.visit(getWhere()); .visit(getWhere());
} }
} }

50
jOOQ/src/main/java/org/jooq/impl/Function.java
View File

@ -247,12 +247,12 @@ class Function<T> extends AbstractField<T> implements
context.sql(")"); // XMLTEXT context.sql(")"); // XMLTEXT
if (!withinGroupOrderBy.isEmpty()) { if (!withinGroupOrderBy.isEmpty()) {
context.keyword(" order by ") context.sql(" ").keyword("order by").sql(" ")
.visit(withinGroupOrderBy); .visit(withinGroupOrderBy);
} }
context.sql(")"); // XMLAGG context.sql(")"); // XMLAGG
context.keyword(" as "); context.sql(" ").keyword("as").sql(" ");
context.sql(DB2DataType.VARCHAR.getCastTypeName()); context.sql(DB2DataType.VARCHAR.getCastTypeName());
context.sql(")"); // XMLSERIALIZE context.sql(")"); // XMLSERIALIZE
@ -274,7 +274,7 @@ class Function<T> extends AbstractField<T> implements
context.sql("("); context.sql("(");
if (distinct) { if (distinct) {
context.keyword("distinct "); context.keyword("distinct").sql(" ");
} }
// The explicit cast is needed in Postgres // The explicit cast is needed in Postgres
@ -289,7 +289,7 @@ class Function<T> extends AbstractField<T> implements
} }
if (!withinGroupOrderBy.isEmpty()) { if (!withinGroupOrderBy.isEmpty()) {
context.keyword(" order by ") context.sql(" ").keyword("order by").sql(" ")
.visit(withinGroupOrderBy); .visit(withinGroupOrderBy);
} }
@ -305,18 +305,18 @@ class Function<T> extends AbstractField<T> implements
context.sql("("); context.sql("(");
if (distinct) { if (distinct) {
context.keyword("distinct "); context.keyword("distinct").sql(" ");
} }
context.visit(arguments.get(0)); context.visit(arguments.get(0));
if (!withinGroupOrderBy.isEmpty()) { if (!withinGroupOrderBy.isEmpty()) {
context.keyword(" order by ") context.sql(" ").keyword("order by").sql(" ")
.visit(withinGroupOrderBy); .visit(withinGroupOrderBy);
} }
if (arguments.size() > 1) { if (arguments.size() > 1) {
context.keyword(" separator ") context.sql(" ").keyword("separator").sql(" ")
.visit(arguments.get(1)); .visit(arguments.get(1));
} }
@ -336,7 +336,7 @@ class Function<T> extends AbstractField<T> implements
} }
String glue = ""; String glue = "";
context.keyword(" over ("); context.sql(" ").keyword("over").sql(" (");
if (!partitionBy.isEmpty()) { if (!partitionBy.isEmpty()) {
// Ignore PARTITION BY 1 clause. These databases erroneously map the // Ignore PARTITION BY 1 clause. These databases erroneously map the
@ -345,7 +345,7 @@ class Function<T> extends AbstractField<T> implements
} }
else { else {
context.sql(glue) context.sql(glue)
.keyword("partition by ") .keyword("partition by").sql(" ")
.visit(partitionBy); .visit(partitionBy);
glue = " "; glue = " ";
@ -354,7 +354,7 @@ class Function<T> extends AbstractField<T> implements
if (!orderBy.isEmpty()) { if (!orderBy.isEmpty()) {
context.sql(glue) context.sql(glue)
.keyword("order by ") .keyword("order by").sql(" ")
.visit(orderBy); .visit(orderBy);
glue = " "; glue = " ";
@ -362,13 +362,13 @@ class Function<T> extends AbstractField<T> implements
if (rowsStart != null) { if (rowsStart != null) {
context.sql(glue); context.sql(glue);
context.keyword("rows "); context.keyword("rows").sql(" ");
if (rowsEnd != null) { if (rowsEnd != null) {
context.keyword("between "); context.keyword("between").sql(" ");
toSQLRows(context, rowsStart); toSQLRows(context, rowsStart);
context.keyword(" and "); context.sql(" ").keyword("and").sql(" ");
toSQLRows(context, rowsEnd); toSQLRows(context, rowsEnd);
} }
else { else {
@ -386,10 +386,11 @@ class Function<T> extends AbstractField<T> implements
*/ */
private void toSQLKeepDenseRankOrderByClause(RenderContext context) { private void toSQLKeepDenseRankOrderByClause(RenderContext context) {
if (!keepDenseRankOrderBy.isEmpty()) { if (!keepDenseRankOrderBy.isEmpty()) {
context.keyword(" keep (dense_rank ") context.sql(" ").keyword("keep")
.keyword(first ? "first" : "last") .sql(" (").keyword("dense_rank")
.keyword(" order by ") .sql(" ").keyword(first ? "first" : "last")
.visit(keepDenseRankOrderBy) .sql(" ").keyword("order by")
.sql(" ").visit(keepDenseRankOrderBy)
.sql(")"); .sql(")");
} }
} }
@ -399,8 +400,9 @@ class Function<T> extends AbstractField<T> implements
*/ */
private final void toSQLWithinGroupClause(RenderContext context) { private final void toSQLWithinGroupClause(RenderContext context) {
if (!withinGroupOrderBy.isEmpty()) { if (!withinGroupOrderBy.isEmpty()) {
context.keyword(" within group (order by ") context.sql(" ").keyword("within group")
.visit(withinGroupOrderBy) .sql(" (").keyword("order by")
.sql(" ").visit(withinGroupOrderBy)
.sql(")"); .sql(")");
} }
} }
@ -413,7 +415,7 @@ class Function<T> extends AbstractField<T> implements
context.sql("("); context.sql("(");
if (distinct) { if (distinct) {
context.keyword("distinct "); context.keyword("distinct").sql(" ");
} }
if (!arguments.isEmpty()) { if (!arguments.isEmpty()) {
@ -425,7 +427,7 @@ class Function<T> extends AbstractField<T> implements
context.sql(", 'IGNORE NULLS'"); context.sql(", 'IGNORE NULLS'");
} }
else { else {
context.keyword(" ignore nulls"); context.sql(" ").keyword("ignore nulls");
} }
} }
else if (respectNulls) { else if (respectNulls) {
@ -433,7 +435,7 @@ class Function<T> extends AbstractField<T> implements
context.sql(", 'RESPECT NULLS'"); context.sql(", 'RESPECT NULLS'");
} }
else { else {
context.keyword(" respect nulls"); context.sql(" ").keyword("respect nulls");
} }
} }
@ -461,11 +463,11 @@ class Function<T> extends AbstractField<T> implements
} }
else if (rows < 0) { else if (rows < 0) {
context.sql(-rows); context.sql(-rows);
context.keyword(" preceding"); context.sql(" ").keyword("preceding");
} }
else if (rows > 0) { else if (rows > 0) {
context.sql(rows); context.sql(rows);
context.keyword(" following"); context.sql(" ").keyword("following");
} }
else { else {
context.keyword("current row"); context.keyword("current row");

69
jOOQ/src/main/java/org/jooq/impl/Limit.java
View File

@ -84,10 +84,10 @@ class Limit extends AbstractQueryPart {
case SQLITE: { case SQLITE: {
context.castMode(NEVER) context.castMode(NEVER)
.formatSeparator() .formatSeparator()
.keyword("limit ") .keyword("limit")
.visit(numberOfRows) .sql(" ").visit(numberOfRows)
.keyword(" offset ") .sql(" ").keyword("offset")
.visit(offsetOrZero) .sql(" ").visit(offsetOrZero)
.castMode(castMode); .castMode(castMode);
break; break;
@ -98,10 +98,9 @@ class Limit extends AbstractQueryPart {
case CUBRID: { case CUBRID: {
context.castMode(NEVER) context.castMode(NEVER)
.formatSeparator() .formatSeparator()
.keyword("limit ") .keyword("limit")
.visit(offsetOrZero) .sql(" ").visit(offsetOrZero)
.sql(", ") .sql(", ").visit(numberOfRows)
.visit(numberOfRows)
.castMode(castMode); .castMode(castMode);
break; break;
@ -112,10 +111,10 @@ class Limit extends AbstractQueryPart {
case FIREBIRD: { case FIREBIRD: {
context.castMode(NEVER) context.castMode(NEVER)
.formatSeparator() .formatSeparator()
.keyword("rows ") .keyword("rows")
.visit(getLowerRownum().add(inline(1))) .sql(" ").visit(getLowerRownum().add(inline(1)))
.keyword(" to ") .sql(" ").keyword("to")
.visit(getUpperRownum()) .sql(" ").visit(getUpperRownum())
.castMode(castMode); .castMode(castMode);
break; break;
@ -128,11 +127,11 @@ class Limit extends AbstractQueryPart {
// Casts are not supported here... // Casts are not supported here...
context.castMode(NEVER) context.castMode(NEVER)
.formatSeparator() .formatSeparator()
.keyword("offset ") .keyword("offset")
.visit(offsetOrZero) .sql(" ").visit(offsetOrZero)
.keyword(" rows fetch next ") .sql(" ").keyword("rows fetch next")
.visit(numberOfRows) .sql(" ").visit(numberOfRows)
.keyword(" rows only") .sql(" ").keyword("rows only")
.castMode(castMode); .castMode(castMode);
break; break;
@ -144,11 +143,11 @@ class Limit extends AbstractQueryPart {
// OFFSET m FETCH FIRST n ROWS ONLY clause // OFFSET m FETCH FIRST n ROWS ONLY clause
context.paramType(INLINED) context.paramType(INLINED)
.formatSeparator() .formatSeparator()
.keyword("offset ") .keyword("offset")
.visit(offsetOrZero) .sql(" ").visit(offsetOrZero)
.keyword(" fetch first ") .sql(" ").keyword("fetch first")
.visit(numberOfRows) .sql(" ").visit(numberOfRows)
.keyword(" rows only") .sql(" ").keyword("rows only")
.paramType(paramType); .paramType(paramType);
break; break;
@ -158,10 +157,10 @@ class Limit extends AbstractQueryPart {
// ---------------------------- // ----------------------------
case SYBASE: { case SYBASE: {
context.paramType(INLINED) context.paramType(INLINED)
.keyword("top ") .keyword("top")
.visit(numberOfRows) .sql(" ").visit(numberOfRows)
.keyword(" start at ") .sql(" ").keyword("start at")
.visit(offsetPlusOne) .sql(" ").visit(offsetPlusOne)
.paramType(paramType); .paramType(paramType);
break; break;
@ -178,9 +177,9 @@ class Limit extends AbstractQueryPart {
// DB2 doesn't allow bind variables here. Casting is not needed. // DB2 doesn't allow bind variables here. Casting is not needed.
context.paramType(INLINED) context.paramType(INLINED)
.formatSeparator() .formatSeparator()
.keyword("fetch first ") .keyword("fetch first")
.visit(numberOfRows) .sql(" ").visit(numberOfRows)
.keyword(" rows only") .sql(" ").keyword("rows only")
.paramType(paramType); .paramType(paramType);
break; break;
@ -194,8 +193,8 @@ class Limit extends AbstractQueryPart {
// SQL Server and Sybase don't allow bind variables in the TOP n clause // SQL Server and Sybase don't allow bind variables in the TOP n clause
context.paramType(INLINED) context.paramType(INLINED)
.keyword("top ") .keyword("top")
.visit(numberOfRows) .sql(" ").visit(numberOfRows)
.paramType(paramType); .paramType(paramType);
break; break;
@ -205,10 +204,10 @@ class Limit extends AbstractQueryPart {
default: { default: {
context.castMode(NEVER) context.castMode(NEVER)
.formatSeparator() .formatSeparator()
.keyword("limit ") .keyword("limit")
.visit(numberOfRows) .sql(" ").visit(numberOfRows)
.keyword(" offset ") .sql(" ").keyword("offset")
.visit(offsetOrZero) .sql(" ").visit(offsetOrZero)
.castMode(castMode); .castMode(castMode);
break; break;

25
jOOQ/src/main/java/org/jooq/impl/MergeImpl.java
View File

@ -1047,7 +1047,8 @@ implements
} }
private final void toSQLH2(RenderContext context) { private final void toSQLH2(RenderContext context) {
context.keyword("merge into ") context.keyword("merge into")
.sql(" ")
.declareTables(true) .declareTables(true)
.visit(table) .visit(table)
.formatSeparator(); .formatSeparator();
@ -1057,7 +1058,7 @@ implements
context.sql(")"); context.sql(")");
if (!getH2Keys().isEmpty()) { if (!getH2Keys().isEmpty()) {
context.keyword(" key ("); context.sql(" ").keyword("key").sql(" (");
Utils.fieldNames(context, getH2Keys()); Utils.fieldNames(context, getH2Keys());
context.sql(")"); context.sql(")");
} }
@ -1067,18 +1068,18 @@ implements
.visit(h2Select); .visit(h2Select);
} }
else { else {
context.keyword(" values (") context.sql(" ").keyword("values").sql(" (")
.visit(getH2Values()) .visit(getH2Values())
.sql(")"); .sql(")");
} }
} }
private final void toSQLStandard(RenderContext context) { private final void toSQLStandard(RenderContext context) {
context.keyword("merge into ") context.keyword("merge into").sql(" ")
.declareTables(true) .declareTables(true)
.visit(table) .visit(table)
.formatSeparator() .formatSeparator()
.keyword("using ") .keyword("using").sql(" ")
.formatIndentStart() .formatIndentStart()
.formatNewLine() .formatNewLine()
.sql(Utils.wrapInParentheses(context.render(using))) .sql(Utils.wrapInParentheses(context.render(using)))
@ -1091,7 +1092,7 @@ implements
if (using instanceof Select) { if (using instanceof Select) {
int hash = Utils.hash(using); int hash = Utils.hash(using);
context.keyword(" as ") context.sql(" ").keyword("as").sql(" ")
.sql("dummy_") .sql("dummy_")
.sql(hash) .sql(hash)
.sql("("); .sql("(");
@ -1117,41 +1118,41 @@ implements
} }
context.formatSeparator() context.formatSeparator()
.keyword("on ") .keyword("on").sql(" ")
.sql(Utils.wrapInParentheses(context.render(on))); .sql(Utils.wrapInParentheses(context.render(on)));
// [#999] WHEN MATCHED clause is optional // [#999] WHEN MATCHED clause is optional
if (matchedUpdate != null) { if (matchedUpdate != null) {
context.formatSeparator() context.formatSeparator()
.keyword("when matched then update set ") .keyword("when matched then update set").sql(" ")
.visit(matchedUpdate); .visit(matchedUpdate);
} }
// [#998] Oracle MERGE extension: WHEN MATCHED THEN UPDATE .. WHERE // [#998] Oracle MERGE extension: WHEN MATCHED THEN UPDATE .. WHERE
if (matchedWhere != null) { if (matchedWhere != null) {
context.formatSeparator() context.formatSeparator()
.keyword("where ") .keyword("where").sql(" ")
.visit(matchedWhere); .visit(matchedWhere);
} }
// [#998] Oracle MERGE extension: WHEN MATCHED THEN UPDATE .. DELETE WHERE // [#998] Oracle MERGE extension: WHEN MATCHED THEN UPDATE .. DELETE WHERE
if (matchedDeleteWhere != null) { if (matchedDeleteWhere != null) {
context.formatSeparator() context.formatSeparator()
.keyword("delete where ") .keyword("delete where").sql(" ")
.visit(matchedDeleteWhere); .visit(matchedDeleteWhere);
} }
// [#999] WHEN NOT MATCHED clause is optional // [#999] WHEN NOT MATCHED clause is optional
if (notMatchedInsert != null) { if (notMatchedInsert != null) {
context.formatSeparator() context.formatSeparator()
.sql("when not matched then insert ") .keyword("when not matched then insert").sql(" ")
.visit(notMatchedInsert); .visit(notMatchedInsert);
} }
// [#998] Oracle MERGE extension: WHEN NOT MATCHED THEN INSERT .. WHERE // [#998] Oracle MERGE extension: WHEN NOT MATCHED THEN INSERT .. WHERE
if (notMatchedWhere != null) { if (notMatchedWhere != null) {
context.formatSeparator() context.formatSeparator()
.keyword("where ") .keyword("where").sql(" ")
.visit(notMatchedWhere); .visit(notMatchedWhere);
} }

6
jOOQ/src/main/java/org/jooq/impl/Pivot.java
View File

@ -242,16 +242,16 @@ implements
.visit(table) .visit(table)
.declareTables(declareTables) .declareTables(declareTables)
.formatSeparator() .formatSeparator()
.keyword("pivot (") .keyword("pivot").sql(" (")
.paramType(INLINED) .paramType(INLINED)
.declareFields(true) .declareFields(true)
.formatIndentStart() .formatIndentStart()
.visit(aggregateFunctions) .visit(aggregateFunctions)
.formatSeparator() .formatSeparator()
.keyword("for ") .keyword("for").sql(" ")
.literal(on.getName()) .literal(on.getName())
.formatSeparator() .formatSeparator()
.keyword("in (") .keyword("in").sql(" (")
.visit(in) .visit(in)
.declareFields(declareFields) .declareFields(declareFields)
.paramType(paramType) .paramType(paramType)

28
jOOQ/src/main/java/org/jooq/impl/SelectQueryImpl.java
View File

@ -281,11 +281,11 @@ class SelectQueryImpl<R extends Record> extends AbstractSelect<R> implements Sel
.keyword("for update"); .keyword("for update");
if (!forUpdateOf.isEmpty()) { if (!forUpdateOf.isEmpty()) {
context.keyword(" of "); context.sql(" ").keyword("of").sql(" ");
Utils.fieldNames(context, forUpdateOf); Utils.fieldNames(context, forUpdateOf);
} }
else if (!forUpdateOfTables.isEmpty()) { else if (!forUpdateOfTables.isEmpty()) {
context.keyword(" of "); context.sql(" ").keyword("of").sql(" ");
switch (context.configuration().dialect().family()) { switch (context.configuration().dialect().family()) {
@ -378,15 +378,15 @@ class SelectQueryImpl<R extends Record> extends AbstractSelect<R> implements Sel
.sql(enclosed) .sql(enclosed)
.formatIndentEnd() .formatIndentEnd()
.formatNewLine() .formatNewLine()
.keyword(") as ") .sql(") ").keyword("as").sql(" ")
.visit(name(subqueryName)) .visit(name(subqueryName))
.formatSeparator() .formatSeparator()
.keyword("where ") .keyword("where").sql(" ")
.visit(name(rownumName)) .visit(name(rownumName))
.sql(" > ") .sql(" > ")
.visit(getLimit().getLowerRownum()) .visit(getLimit().getLowerRownum())
.formatSeparator() .formatSeparator()
.keyword("and ") .keyword("and").sql(" ")
.visit(name(rownumName)) .visit(name(rownumName))
.sql(" <= ") .sql(" <= ")
.visit(getLimit().getUpperRownum()); .visit(getLimit().getUpperRownum());
@ -404,15 +404,15 @@ class SelectQueryImpl<R extends Record> extends AbstractSelect<R> implements Sel
String subqueryName = "limit_" + Utils.hash(enclosed); String subqueryName = "limit_" + Utils.hash(enclosed);
String rownumName = "rownum_" + Utils.hash(enclosed); String rownumName = "rownum_" + Utils.hash(enclosed);
context.keyword("select * from (") context.keyword("select").sql(" * ").keyword("from").sql(" (")
.formatIndentStart() .formatIndentStart()
.formatNewLine() .formatNewLine()
.keyword("select ") .keyword("select").sql(" ")
.visit(name(subqueryName)) .visit(name(subqueryName)).sql(".*, ")
.keyword(".*, rownum as ") .keyword("rownum").sql(" ").keyword("as").sql(" ")
.visit(name(rownumName)) .visit(name(rownumName))
.formatSeparator() .formatSeparator()
.keyword("from (") .keyword("from").sql(" (")
.formatIndentStart() .formatIndentStart()
.formatNewLine() .formatNewLine()
.sql(enclosed) .sql(enclosed)
@ -421,13 +421,13 @@ class SelectQueryImpl<R extends Record> extends AbstractSelect<R> implements Sel
.sql(") ") .sql(") ")
.visit(name(subqueryName)) .visit(name(subqueryName))
.formatSeparator() .formatSeparator()
.keyword("where rownum <= ") .keyword("where").sql(" ").keyword("rownum").sql(" <= ")
.visit(getLimit().getUpperRownum()) .visit(getLimit().getUpperRownum())
.formatIndentEnd() .formatIndentEnd()
.formatNewLine() .formatNewLine()
.sql(") ") .sql(") ")
.formatSeparator() .formatSeparator()
.keyword("where ") .keyword("where").sql(" ")
.visit(name(rownumName)) .visit(name(rownumName))
.sql(" > ") .sql(" > ")
.visit(getLimit().getLowerRownum()); .visit(getLimit().getLowerRownum());
@ -485,7 +485,7 @@ class SelectQueryImpl<R extends Record> extends AbstractSelect<R> implements Sel
// [#2423] SQL Server 2012 will render an OFFSET .. FETCH // [#2423] SQL Server 2012 will render an OFFSET .. FETCH
// clause if there is an applicable limit // clause if there is an applicable limit
if (dialect == SQLSERVER2008 || !getLimit().isApplicable()) { if (dialect == SQLSERVER2008 || !getLimit().isApplicable()) {
context.keyword("top 100 percent "); context.keyword("top").sql(" 100 ").keyword("percent").sql(" ");
} }
} }
@ -611,7 +611,7 @@ class SelectQueryImpl<R extends Record> extends AbstractSelect<R> implements Sel
.keyword("connect by"); .keyword("connect by");
if (connectByNoCycle) { if (connectByNoCycle) {
context.keyword(" nocycle"); context.sql(" ").keyword("nocycle");
} }
context.sql(" ").visit(getConnectBy()); context.sql(" ").visit(getConnectBy());

4
jOOQ/src/main/java/org/jooq/impl/TruncateImpl.java
View File

@ -111,11 +111,11 @@ class TruncateImpl<R extends Record> extends AbstractQuery implements
// All other dialects do // All other dialects do
default: { default: {
context.keyword("truncate table "); context.keyword("truncate table").sql(" ");
context.visit(table); context.visit(table);
if (context.configuration().dialect() == SQLDialect.DB2) { if (context.configuration().dialect() == SQLDialect.DB2) {
context.keyword(" immediate"); context.sql(" ").keyword("immediate");
} }
break; break;

2
jOOQ/src/main/java/org/jooq/impl/UpdateQueryImpl.java
View File

@ -516,7 +516,7 @@ class UpdateQueryImpl<R extends Record> extends AbstractStoreQuery<R> implements
if (!(getWhere() instanceof TrueCondition)) { if (!(getWhere() instanceof TrueCondition)) {
context.formatSeparator() context.formatSeparator()
.keyword("where ") .keyword("where").sql(" ")
.visit(getWhere()); .visit(getWhere());
} }

10
jOOQ/src/main/java/org/jooq/impl/Val.java
View File

@ -270,9 +270,9 @@ class Val<T> extends AbstractParam<T> {
} }
private final void toSQLCast(RenderContext context, DataType<?> type, int length, int precision, int scale) { private final void toSQLCast(RenderContext context, DataType<?> type, int length, int precision, int scale) {
context.keyword("cast("); context.keyword("cast").sql("(");
toSQL(context, value, getType()); toSQL(context, value, getType());
context.keyword(" as ") context.sql(" ").keyword("as").sql(" ")
.sql(type.length(length).precision(precision, scale).getCastTypeName(context.configuration())) .sql(type.length(length).precision(precision, scale).getCastTypeName(context.configuration()))
.sql(")"); .sql(")");
} }
@ -447,17 +447,17 @@ class Val<T> extends AbstractParam<T> {
// [#1253] Derby doesn't support the standard literal // [#1253] Derby doesn't support the standard literal
else if (family == DERBY) { else if (family == DERBY) {
context.keyword("time('").sql(escape(val)).sql("')"); context.keyword("time").sql("('").sql(escape(val)).sql("')");
} }
// [#1253] Oracle doesn't know time literals // [#1253] Oracle doesn't know time literals
else if (family == ORACLE) { else if (family == ORACLE) {
context.keyword("timestamp '1970-01-01 ").sql(escape(val)).sql("'"); context.keyword("timestamp").sql(" '1970-01-01 ").sql(escape(val)).sql("'");
} }
// Most dialects implement SQL standard time literals // Most dialects implement SQL standard time literals
else { else {
context.keyword("time '").sql(escape(val)).sql("'"); context.keyword("time").sql(" '").sql(escape(val)).sql("'");
} }
} }
else if (type.isArray()) { else if (type.isArray()) {

5
jOOQ/src/main/java/org/jooq/impl/WithTable.java
View File

@ -72,9 +72,8 @@ class WithTable<R extends Record> extends AbstractTable<R> {
@Override @Override
public final void toSQL(RenderContext context) { public final void toSQL(RenderContext context) {
context.visit(delegate) context.visit(delegate)
.keyword(" with ") .sql(" ").keyword("with")
.sql("(") .sql(" (").sql(hint)
.sql(hint)
.sql(")"); .sql(")");
} }