From 86b0fe1e1df42eab628fbc81ea0e2b0b94de45b9 Mon Sep 17 00:00:00 2001 From: Lukas Eder Date: Mon, 12 Aug 2013 14:52:42 +0200 Subject: [PATCH] Improved SQL rendering - cleanly separate keyword() and sql() calls. --- jOOQ/src/main/java/org/jooq/impl/Alias.java | 2 +- .../main/java/org/jooq/impl/ArrayTable.java | 11 ++- .../org/jooq/impl/CaseConditionStepImpl.java | 9 +-- .../java/org/jooq/impl/CaseWhenStepImpl.java | 11 ++- jOOQ/src/main/java/org/jooq/impl/Cast.java | 49 ++++++------- .../java/org/jooq/impl/CompareCondition.java | 11 ++- .../java/org/jooq/impl/DeleteQueryImpl.java | 6 +- .../src/main/java/org/jooq/impl/Function.java | 50 +++++++------- jOOQ/src/main/java/org/jooq/impl/Limit.java | 69 +++++++++---------- .../main/java/org/jooq/impl/MergeImpl.java | 25 +++---- jOOQ/src/main/java/org/jooq/impl/Pivot.java | 6 +- .../java/org/jooq/impl/SelectQueryImpl.java | 28 ++++---- .../main/java/org/jooq/impl/TruncateImpl.java | 4 +- .../java/org/jooq/impl/UpdateQueryImpl.java | 2 +- jOOQ/src/main/java/org/jooq/impl/Val.java | 10 +-- .../main/java/org/jooq/impl/WithTable.java | 5 +- 16 files changed, 147 insertions(+), 151 deletions(-) diff --git a/jOOQ/src/main/java/org/jooq/impl/Alias.java b/jOOQ/src/main/java/org/jooq/impl/Alias.java index 83e79b5194..682a19a27c 100644 --- a/jOOQ/src/main/java/org/jooq/impl/Alias.java +++ b/jOOQ/src/main/java/org/jooq/impl/Alias.java @@ -189,7 +189,7 @@ class Alias extends AbstractQueryPart { private void toSQLAs(RenderContext context) { if (asList(DERBY, HSQLDB, MARIADB, MYSQL, POSTGRES).contains(context.configuration().dialect())) { - context.keyword(" as"); + context.sql(" ").keyword("as"); } } diff --git a/jOOQ/src/main/java/org/jooq/impl/ArrayTable.java b/jOOQ/src/main/java/org/jooq/impl/ArrayTable.java index ea00ab44ed..89d441756e 100644 --- a/jOOQ/src/main/java/org/jooq/impl/ArrayTable.java +++ b/jOOQ/src/main/java/org/jooq/impl/ArrayTable.java @@ -225,13 +225,10 @@ class ArrayTable extends AbstractTable { @Override public void toSQL(RenderContext context) { - context.keyword("(select * from unnest(") - .visit(array) - .keyword(") as ") - .literal(alias) - .sql("(") - .literal("COLUMN_VALUE") - .sql("))"); + context.sql("(").keyword("select").sql(" * ") + .keyword("from").sql(" ").keyword("unnest").sql("(").visit(array).sql(") ") + .keyword("as").sql(" ").literal(alias) + .sql("(").literal("COLUMN_VALUE").sql("))"); } } diff --git a/jOOQ/src/main/java/org/jooq/impl/CaseConditionStepImpl.java b/jOOQ/src/main/java/org/jooq/impl/CaseConditionStepImpl.java index d1d233a463..8bd2ceabdd 100644 --- a/jOOQ/src/main/java/org/jooq/impl/CaseConditionStepImpl.java +++ b/jOOQ/src/main/java/org/jooq/impl/CaseConditionStepImpl.java @@ -113,16 +113,13 @@ class CaseConditionStepImpl extends AbstractField implements CaseCondition context.formatNewLine(); } - context.keyword(" when ") - .visit(conditions.get(i)) - .keyword(" then ") - .visit(results.get(i)); + context.sql(" ").keyword("when").sql(" ").visit(conditions.get(i)) + .sql(" ").keyword("then").sql(" ").visit(results.get(i)); } if (otherwise != null) { context.formatNewLine() - .keyword(" else ") - .visit(otherwise); + .sql(" ").keyword("else").sql(" ").visit(otherwise); } context.formatIndentLockEnd(); diff --git a/jOOQ/src/main/java/org/jooq/impl/CaseWhenStepImpl.java b/jOOQ/src/main/java/org/jooq/impl/CaseWhenStepImpl.java index 96e00c563b..97f2392e34 100644 --- a/jOOQ/src/main/java/org/jooq/impl/CaseWhenStepImpl.java +++ b/jOOQ/src/main/java/org/jooq/impl/CaseWhenStepImpl.java @@ -149,9 +149,9 @@ class CaseWhenStepImpl extends AbstractField implements CaseWhenStep extends AbstractField implements CaseWhenStep extends AbstractField implements CaseWhenStep extends AbstractField { if (field.getDataType().isNumeric() && VARCHAR.equals(getSQLDataType())) { - context.keyword("trim(cast(") - .keyword("cast(") - .castMode(CastMode.NEVER) - .visit(field) - .castMode(castMode) - .keyword(" as char(38))") - .keyword(" as ") - .keyword(getDataType(context.configuration()).getCastTypeName(context.configuration())) - .sql("))"); + context.keyword("trim").sql("(") + .keyword("cast").sql("(") + .keyword("cast").sql("(") + .castMode(CastMode.NEVER) + .visit(field) + .castMode(castMode) + .sql(" ").keyword("as").sql(" char(38))") + .sql(" ").keyword("as").sql(" ") + .keyword(getDataType(context.configuration()).getCastTypeName(context.configuration())) + .sql("))"); return; } @@ -102,14 +103,16 @@ class Cast extends AbstractField { else if (field.getDataType().isString() && asList(FLOAT, DOUBLE, REAL).contains(getSQLDataType())) { - context.keyword("cast(") - .keyword("cast(") - .castMode(CastMode.NEVER) - .visit(field) - .castMode(castMode) - .keyword(" as decimal)") - .keyword(" as ") - .keyword(getDataType(context.configuration()).getCastTypeName(context.configuration())) + context.keyword("cast").sql("(") + .keyword("cast").sql("(") + .castMode(CastMode.NEVER) + .visit(field) + .castMode(castMode) + .sql(" ").keyword("as").sql(" ").keyword("decimal") + .sql(") ") + .keyword("as") + .sql(" ") + .keyword(getDataType(context.configuration()).getCastTypeName(context.configuration())) .sql(")"); return; @@ -133,12 +136,12 @@ class Cast extends AbstractField { } // Default rendering, if no special case has applied yet - context.keyword("cast(") - .castMode(CastMode.NEVER) - .visit(field) - .castMode(castMode) - .keyword(" as ") - .keyword(getDataType(context.configuration()).getCastTypeName(context.configuration())) + context.keyword("cast").sql("(") + .castMode(CastMode.NEVER) + .visit(field) + .castMode(castMode) + .sql(" ").keyword("as").sql(" ") + .keyword(getDataType(context.configuration()).getCastTypeName(context.configuration())) .sql(")"); } diff --git a/jOOQ/src/main/java/org/jooq/impl/CompareCondition.java b/jOOQ/src/main/java/org/jooq/impl/CompareCondition.java index e3e5275f5c..feb77a642e 100644 --- a/jOOQ/src/main/java/org/jooq/impl/CompareCondition.java +++ b/jOOQ/src/main/java/org/jooq/impl/CompareCondition.java @@ -120,14 +120,13 @@ class CompareCondition extends AbstractCondition { // characters long boolean castRhs = (dialect == DB2 && rhs instanceof Concat); - context.keyword(op.toSQL()) - .sql(" ") - .keyword(castRhs ? "cast(" : "") - .visit(rhs) - .keyword(castRhs ? " as varchar(4000))" : ""); + context.keyword(op.toSQL()).sql(" "); + if (castRhs) context.keyword("cast").sql("("); + context.visit(rhs); + if (castRhs) context.sql(" ").keyword("as").sql(" ").keyword("varchar").sql("(4000))"); if (escape != null) { - context.keyword(" escape '") + context.sql(" ").keyword("escape").sql(" '") .sql(escape) .sql("'"); } diff --git a/jOOQ/src/main/java/org/jooq/impl/DeleteQueryImpl.java b/jOOQ/src/main/java/org/jooq/impl/DeleteQueryImpl.java index 0e1d8e58e4..38d8983e2d 100644 --- a/jOOQ/src/main/java/org/jooq/impl/DeleteQueryImpl.java +++ b/jOOQ/src/main/java/org/jooq/impl/DeleteQueryImpl.java @@ -104,7 +104,7 @@ class DeleteQueryImpl extends AbstractQuery implements DeleteQ public final void toSQL(RenderContext context) { boolean declare = context.declareTables(); - context.keyword("delete "); + context.keyword("delete").sql(" "); // [#2464] MySQL supports a peculiar multi-table DELETE syntax for aliased tables: // DELETE t1 FROM my_table AS t1 @@ -119,14 +119,14 @@ class DeleteQueryImpl extends AbstractQuery implements DeleteQ } } - context.keyword("from "); + context.keyword("from").sql(" "); context.declareTables(true) .visit(getFrom()) .declareTables(declare); if (!(getWhere() instanceof TrueCondition)) { context.formatSeparator() - .keyword("where ") + .keyword("where").sql(" ") .visit(getWhere()); } } diff --git a/jOOQ/src/main/java/org/jooq/impl/Function.java b/jOOQ/src/main/java/org/jooq/impl/Function.java index bf3684b9de..fe3c4052dc 100644 --- a/jOOQ/src/main/java/org/jooq/impl/Function.java +++ b/jOOQ/src/main/java/org/jooq/impl/Function.java @@ -247,12 +247,12 @@ class Function extends AbstractField implements context.sql(")"); // XMLTEXT if (!withinGroupOrderBy.isEmpty()) { - context.keyword(" order by ") + context.sql(" ").keyword("order by").sql(" ") .visit(withinGroupOrderBy); } context.sql(")"); // XMLAGG - context.keyword(" as "); + context.sql(" ").keyword("as").sql(" "); context.sql(DB2DataType.VARCHAR.getCastTypeName()); context.sql(")"); // XMLSERIALIZE @@ -274,7 +274,7 @@ class Function extends AbstractField implements context.sql("("); if (distinct) { - context.keyword("distinct "); + context.keyword("distinct").sql(" "); } // The explicit cast is needed in Postgres @@ -289,7 +289,7 @@ class Function extends AbstractField implements } if (!withinGroupOrderBy.isEmpty()) { - context.keyword(" order by ") + context.sql(" ").keyword("order by").sql(" ") .visit(withinGroupOrderBy); } @@ -305,18 +305,18 @@ class Function extends AbstractField implements context.sql("("); if (distinct) { - context.keyword("distinct "); + context.keyword("distinct").sql(" "); } context.visit(arguments.get(0)); if (!withinGroupOrderBy.isEmpty()) { - context.keyword(" order by ") + context.sql(" ").keyword("order by").sql(" ") .visit(withinGroupOrderBy); } if (arguments.size() > 1) { - context.keyword(" separator ") + context.sql(" ").keyword("separator").sql(" ") .visit(arguments.get(1)); } @@ -336,7 +336,7 @@ class Function extends AbstractField implements } String glue = ""; - context.keyword(" over ("); + context.sql(" ").keyword("over").sql(" ("); if (!partitionBy.isEmpty()) { // Ignore PARTITION BY 1 clause. These databases erroneously map the @@ -345,7 +345,7 @@ class Function extends AbstractField implements } else { context.sql(glue) - .keyword("partition by ") + .keyword("partition by").sql(" ") .visit(partitionBy); glue = " "; @@ -354,7 +354,7 @@ class Function extends AbstractField implements if (!orderBy.isEmpty()) { context.sql(glue) - .keyword("order by ") + .keyword("order by").sql(" ") .visit(orderBy); glue = " "; @@ -362,13 +362,13 @@ class Function extends AbstractField implements if (rowsStart != null) { context.sql(glue); - context.keyword("rows "); + context.keyword("rows").sql(" "); if (rowsEnd != null) { - context.keyword("between "); + context.keyword("between").sql(" "); toSQLRows(context, rowsStart); - context.keyword(" and "); + context.sql(" ").keyword("and").sql(" "); toSQLRows(context, rowsEnd); } else { @@ -386,10 +386,11 @@ class Function extends AbstractField implements */ private void toSQLKeepDenseRankOrderByClause(RenderContext context) { if (!keepDenseRankOrderBy.isEmpty()) { - context.keyword(" keep (dense_rank ") - .keyword(first ? "first" : "last") - .keyword(" order by ") - .visit(keepDenseRankOrderBy) + context.sql(" ").keyword("keep") + .sql(" (").keyword("dense_rank") + .sql(" ").keyword(first ? "first" : "last") + .sql(" ").keyword("order by") + .sql(" ").visit(keepDenseRankOrderBy) .sql(")"); } } @@ -399,8 +400,9 @@ class Function extends AbstractField implements */ private final void toSQLWithinGroupClause(RenderContext context) { if (!withinGroupOrderBy.isEmpty()) { - context.keyword(" within group (order by ") - .visit(withinGroupOrderBy) + context.sql(" ").keyword("within group") + .sql(" (").keyword("order by") + .sql(" ").visit(withinGroupOrderBy) .sql(")"); } } @@ -413,7 +415,7 @@ class Function extends AbstractField implements context.sql("("); if (distinct) { - context.keyword("distinct "); + context.keyword("distinct").sql(" "); } if (!arguments.isEmpty()) { @@ -425,7 +427,7 @@ class Function extends AbstractField implements context.sql(", 'IGNORE NULLS'"); } else { - context.keyword(" ignore nulls"); + context.sql(" ").keyword("ignore nulls"); } } else if (respectNulls) { @@ -433,7 +435,7 @@ class Function extends AbstractField implements context.sql(", 'RESPECT NULLS'"); } else { - context.keyword(" respect nulls"); + context.sql(" ").keyword("respect nulls"); } } @@ -461,11 +463,11 @@ class Function extends AbstractField implements } else if (rows < 0) { context.sql(-rows); - context.keyword(" preceding"); + context.sql(" ").keyword("preceding"); } else if (rows > 0) { context.sql(rows); - context.keyword(" following"); + context.sql(" ").keyword("following"); } else { context.keyword("current row"); diff --git a/jOOQ/src/main/java/org/jooq/impl/Limit.java b/jOOQ/src/main/java/org/jooq/impl/Limit.java index d8f86d75c5..fb6d412b36 100644 --- a/jOOQ/src/main/java/org/jooq/impl/Limit.java +++ b/jOOQ/src/main/java/org/jooq/impl/Limit.java @@ -84,10 +84,10 @@ class Limit extends AbstractQueryPart { case SQLITE: { context.castMode(NEVER) .formatSeparator() - .keyword("limit ") - .visit(numberOfRows) - .keyword(" offset ") - .visit(offsetOrZero) + .keyword("limit") + .sql(" ").visit(numberOfRows) + .sql(" ").keyword("offset") + .sql(" ").visit(offsetOrZero) .castMode(castMode); break; @@ -98,10 +98,9 @@ class Limit extends AbstractQueryPart { case CUBRID: { context.castMode(NEVER) .formatSeparator() - .keyword("limit ") - .visit(offsetOrZero) - .sql(", ") - .visit(numberOfRows) + .keyword("limit") + .sql(" ").visit(offsetOrZero) + .sql(", ").visit(numberOfRows) .castMode(castMode); break; @@ -112,10 +111,10 @@ class Limit extends AbstractQueryPart { case FIREBIRD: { context.castMode(NEVER) .formatSeparator() - .keyword("rows ") - .visit(getLowerRownum().add(inline(1))) - .keyword(" to ") - .visit(getUpperRownum()) + .keyword("rows") + .sql(" ").visit(getLowerRownum().add(inline(1))) + .sql(" ").keyword("to") + .sql(" ").visit(getUpperRownum()) .castMode(castMode); break; @@ -128,11 +127,11 @@ class Limit extends AbstractQueryPart { // Casts are not supported here... context.castMode(NEVER) .formatSeparator() - .keyword("offset ") - .visit(offsetOrZero) - .keyword(" rows fetch next ") - .visit(numberOfRows) - .keyword(" rows only") + .keyword("offset") + .sql(" ").visit(offsetOrZero) + .sql(" ").keyword("rows fetch next") + .sql(" ").visit(numberOfRows) + .sql(" ").keyword("rows only") .castMode(castMode); break; @@ -144,11 +143,11 @@ class Limit extends AbstractQueryPart { // OFFSET m FETCH FIRST n ROWS ONLY clause context.paramType(INLINED) .formatSeparator() - .keyword("offset ") - .visit(offsetOrZero) - .keyword(" fetch first ") - .visit(numberOfRows) - .keyword(" rows only") + .keyword("offset") + .sql(" ").visit(offsetOrZero) + .sql(" ").keyword("fetch first") + .sql(" ").visit(numberOfRows) + .sql(" ").keyword("rows only") .paramType(paramType); break; @@ -158,10 +157,10 @@ class Limit extends AbstractQueryPart { // ---------------------------- case SYBASE: { context.paramType(INLINED) - .keyword("top ") - .visit(numberOfRows) - .keyword(" start at ") - .visit(offsetPlusOne) + .keyword("top") + .sql(" ").visit(numberOfRows) + .sql(" ").keyword("start at") + .sql(" ").visit(offsetPlusOne) .paramType(paramType); break; @@ -178,9 +177,9 @@ class Limit extends AbstractQueryPart { // DB2 doesn't allow bind variables here. Casting is not needed. context.paramType(INLINED) .formatSeparator() - .keyword("fetch first ") - .visit(numberOfRows) - .keyword(" rows only") + .keyword("fetch first") + .sql(" ").visit(numberOfRows) + .sql(" ").keyword("rows only") .paramType(paramType); break; @@ -194,8 +193,8 @@ class Limit extends AbstractQueryPart { // SQL Server and Sybase don't allow bind variables in the TOP n clause context.paramType(INLINED) - .keyword("top ") - .visit(numberOfRows) + .keyword("top") + .sql(" ").visit(numberOfRows) .paramType(paramType); break; @@ -205,10 +204,10 @@ class Limit extends AbstractQueryPart { default: { context.castMode(NEVER) .formatSeparator() - .keyword("limit ") - .visit(numberOfRows) - .keyword(" offset ") - .visit(offsetOrZero) + .keyword("limit") + .sql(" ").visit(numberOfRows) + .sql(" ").keyword("offset") + .sql(" ").visit(offsetOrZero) .castMode(castMode); break; diff --git a/jOOQ/src/main/java/org/jooq/impl/MergeImpl.java b/jOOQ/src/main/java/org/jooq/impl/MergeImpl.java index 374b2e4594..a1f25b59fd 100644 --- a/jOOQ/src/main/java/org/jooq/impl/MergeImpl.java +++ b/jOOQ/src/main/java/org/jooq/impl/MergeImpl.java @@ -1047,7 +1047,8 @@ implements } private final void toSQLH2(RenderContext context) { - context.keyword("merge into ") + context.keyword("merge into") + .sql(" ") .declareTables(true) .visit(table) .formatSeparator(); @@ -1057,7 +1058,7 @@ implements context.sql(")"); if (!getH2Keys().isEmpty()) { - context.keyword(" key ("); + context.sql(" ").keyword("key").sql(" ("); Utils.fieldNames(context, getH2Keys()); context.sql(")"); } @@ -1067,18 +1068,18 @@ implements .visit(h2Select); } else { - context.keyword(" values (") + context.sql(" ").keyword("values").sql(" (") .visit(getH2Values()) .sql(")"); } } private final void toSQLStandard(RenderContext context) { - context.keyword("merge into ") + context.keyword("merge into").sql(" ") .declareTables(true) .visit(table) .formatSeparator() - .keyword("using ") + .keyword("using").sql(" ") .formatIndentStart() .formatNewLine() .sql(Utils.wrapInParentheses(context.render(using))) @@ -1091,7 +1092,7 @@ implements if (using instanceof Select) { int hash = Utils.hash(using); - context.keyword(" as ") + context.sql(" ").keyword("as").sql(" ") .sql("dummy_") .sql(hash) .sql("("); @@ -1117,41 +1118,41 @@ implements } context.formatSeparator() - .keyword("on ") + .keyword("on").sql(" ") .sql(Utils.wrapInParentheses(context.render(on))); // [#999] WHEN MATCHED clause is optional if (matchedUpdate != null) { context.formatSeparator() - .keyword("when matched then update set ") + .keyword("when matched then update set").sql(" ") .visit(matchedUpdate); } // [#998] Oracle MERGE extension: WHEN MATCHED THEN UPDATE .. WHERE if (matchedWhere != null) { context.formatSeparator() - .keyword("where ") + .keyword("where").sql(" ") .visit(matchedWhere); } // [#998] Oracle MERGE extension: WHEN MATCHED THEN UPDATE .. DELETE WHERE if (matchedDeleteWhere != null) { context.formatSeparator() - .keyword("delete where ") + .keyword("delete where").sql(" ") .visit(matchedDeleteWhere); } // [#999] WHEN NOT MATCHED clause is optional if (notMatchedInsert != null) { context.formatSeparator() - .sql("when not matched then insert ") + .keyword("when not matched then insert").sql(" ") .visit(notMatchedInsert); } // [#998] Oracle MERGE extension: WHEN NOT MATCHED THEN INSERT .. WHERE if (notMatchedWhere != null) { context.formatSeparator() - .keyword("where ") + .keyword("where").sql(" ") .visit(notMatchedWhere); } diff --git a/jOOQ/src/main/java/org/jooq/impl/Pivot.java b/jOOQ/src/main/java/org/jooq/impl/Pivot.java index 6e8d33bbe6..85323c98ce 100644 --- a/jOOQ/src/main/java/org/jooq/impl/Pivot.java +++ b/jOOQ/src/main/java/org/jooq/impl/Pivot.java @@ -242,16 +242,16 @@ implements .visit(table) .declareTables(declareTables) .formatSeparator() - .keyword("pivot (") + .keyword("pivot").sql(" (") .paramType(INLINED) .declareFields(true) .formatIndentStart() .visit(aggregateFunctions) .formatSeparator() - .keyword("for ") + .keyword("for").sql(" ") .literal(on.getName()) .formatSeparator() - .keyword("in (") + .keyword("in").sql(" (") .visit(in) .declareFields(declareFields) .paramType(paramType) diff --git a/jOOQ/src/main/java/org/jooq/impl/SelectQueryImpl.java b/jOOQ/src/main/java/org/jooq/impl/SelectQueryImpl.java index 3298bf07f7..24cd468cce 100644 --- a/jOOQ/src/main/java/org/jooq/impl/SelectQueryImpl.java +++ b/jOOQ/src/main/java/org/jooq/impl/SelectQueryImpl.java @@ -281,11 +281,11 @@ class SelectQueryImpl extends AbstractSelect implements Sel .keyword("for update"); if (!forUpdateOf.isEmpty()) { - context.keyword(" of "); + context.sql(" ").keyword("of").sql(" "); Utils.fieldNames(context, forUpdateOf); } else if (!forUpdateOfTables.isEmpty()) { - context.keyword(" of "); + context.sql(" ").keyword("of").sql(" "); switch (context.configuration().dialect().family()) { @@ -378,15 +378,15 @@ class SelectQueryImpl extends AbstractSelect implements Sel .sql(enclosed) .formatIndentEnd() .formatNewLine() - .keyword(") as ") + .sql(") ").keyword("as").sql(" ") .visit(name(subqueryName)) .formatSeparator() - .keyword("where ") + .keyword("where").sql(" ") .visit(name(rownumName)) .sql(" > ") .visit(getLimit().getLowerRownum()) .formatSeparator() - .keyword("and ") + .keyword("and").sql(" ") .visit(name(rownumName)) .sql(" <= ") .visit(getLimit().getUpperRownum()); @@ -404,15 +404,15 @@ class SelectQueryImpl extends AbstractSelect implements Sel String subqueryName = "limit_" + Utils.hash(enclosed); String rownumName = "rownum_" + Utils.hash(enclosed); - context.keyword("select * from (") + context.keyword("select").sql(" * ").keyword("from").sql(" (") .formatIndentStart() .formatNewLine() - .keyword("select ") - .visit(name(subqueryName)) - .keyword(".*, rownum as ") + .keyword("select").sql(" ") + .visit(name(subqueryName)).sql(".*, ") + .keyword("rownum").sql(" ").keyword("as").sql(" ") .visit(name(rownumName)) .formatSeparator() - .keyword("from (") + .keyword("from").sql(" (") .formatIndentStart() .formatNewLine() .sql(enclosed) @@ -421,13 +421,13 @@ class SelectQueryImpl extends AbstractSelect implements Sel .sql(") ") .visit(name(subqueryName)) .formatSeparator() - .keyword("where rownum <= ") + .keyword("where").sql(" ").keyword("rownum").sql(" <= ") .visit(getLimit().getUpperRownum()) .formatIndentEnd() .formatNewLine() .sql(") ") .formatSeparator() - .keyword("where ") + .keyword("where").sql(" ") .visit(name(rownumName)) .sql(" > ") .visit(getLimit().getLowerRownum()); @@ -485,7 +485,7 @@ class SelectQueryImpl extends AbstractSelect implements Sel // [#2423] SQL Server 2012 will render an OFFSET .. FETCH // clause if there is an applicable limit if (dialect == SQLSERVER2008 || !getLimit().isApplicable()) { - context.keyword("top 100 percent "); + context.keyword("top").sql(" 100 ").keyword("percent").sql(" "); } } @@ -611,7 +611,7 @@ class SelectQueryImpl extends AbstractSelect implements Sel .keyword("connect by"); if (connectByNoCycle) { - context.keyword(" nocycle"); + context.sql(" ").keyword("nocycle"); } context.sql(" ").visit(getConnectBy()); diff --git a/jOOQ/src/main/java/org/jooq/impl/TruncateImpl.java b/jOOQ/src/main/java/org/jooq/impl/TruncateImpl.java index 9b0156e219..910dddcdaa 100644 --- a/jOOQ/src/main/java/org/jooq/impl/TruncateImpl.java +++ b/jOOQ/src/main/java/org/jooq/impl/TruncateImpl.java @@ -111,11 +111,11 @@ class TruncateImpl extends AbstractQuery implements // All other dialects do default: { - context.keyword("truncate table "); + context.keyword("truncate table").sql(" "); context.visit(table); if (context.configuration().dialect() == SQLDialect.DB2) { - context.keyword(" immediate"); + context.sql(" ").keyword("immediate"); } break; diff --git a/jOOQ/src/main/java/org/jooq/impl/UpdateQueryImpl.java b/jOOQ/src/main/java/org/jooq/impl/UpdateQueryImpl.java index a0c01f67f7..b80e1e7f3c 100644 --- a/jOOQ/src/main/java/org/jooq/impl/UpdateQueryImpl.java +++ b/jOOQ/src/main/java/org/jooq/impl/UpdateQueryImpl.java @@ -516,7 +516,7 @@ class UpdateQueryImpl extends AbstractStoreQuery implements if (!(getWhere() instanceof TrueCondition)) { context.formatSeparator() - .keyword("where ") + .keyword("where").sql(" ") .visit(getWhere()); } diff --git a/jOOQ/src/main/java/org/jooq/impl/Val.java b/jOOQ/src/main/java/org/jooq/impl/Val.java index 6f28d9787f..6d26340901 100644 --- a/jOOQ/src/main/java/org/jooq/impl/Val.java +++ b/jOOQ/src/main/java/org/jooq/impl/Val.java @@ -270,9 +270,9 @@ class Val extends AbstractParam { } 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()); - context.keyword(" as ") + context.sql(" ").keyword("as").sql(" ") .sql(type.length(length).precision(precision, scale).getCastTypeName(context.configuration())) .sql(")"); } @@ -447,17 +447,17 @@ class Val extends AbstractParam { // [#1253] Derby doesn't support the standard literal 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 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 else { - context.keyword("time '").sql(escape(val)).sql("'"); + context.keyword("time").sql(" '").sql(escape(val)).sql("'"); } } else if (type.isArray()) { diff --git a/jOOQ/src/main/java/org/jooq/impl/WithTable.java b/jOOQ/src/main/java/org/jooq/impl/WithTable.java index dad5b72514..26118f6442 100644 --- a/jOOQ/src/main/java/org/jooq/impl/WithTable.java +++ b/jOOQ/src/main/java/org/jooq/impl/WithTable.java @@ -72,9 +72,8 @@ class WithTable extends AbstractTable { @Override public final void toSQL(RenderContext context) { context.visit(delegate) - .keyword(" with ") - .sql("(") - .sql(hint) + .sql(" ").keyword("with") + .sql(" (").sql(hint) .sql(")"); }