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) {
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
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("))");
}
}

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.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();

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

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

@ -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("'");
}

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) {
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<R extends Record> 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());
}
}

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
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<T> extends AbstractField<T> 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<T> extends AbstractField<T> implements
}
if (!withinGroupOrderBy.isEmpty()) {
context.keyword(" order by ")
context.sql(" ").keyword("order by").sql(" ")
.visit(withinGroupOrderBy);
}
@ -305,18 +305,18 @@ class Function<T> extends AbstractField<T> 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<T> extends AbstractField<T> 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<T> extends AbstractField<T> implements
}
else {
context.sql(glue)
.keyword("partition by ")
.keyword("partition by").sql(" ")
.visit(partitionBy);
glue = " ";
@ -354,7 +354,7 @@ class Function<T> extends AbstractField<T> implements
if (!orderBy.isEmpty()) {
context.sql(glue)
.keyword("order by ")
.keyword("order by").sql(" ")
.visit(orderBy);
glue = " ";
@ -362,13 +362,13 @@ class Function<T> extends AbstractField<T> 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<T> extends AbstractField<T> 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<T> extends AbstractField<T> 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<T> extends AbstractField<T> implements
context.sql("(");
if (distinct) {
context.keyword("distinct ");
context.keyword("distinct").sql(" ");
}
if (!arguments.isEmpty()) {
@ -425,7 +427,7 @@ class Function<T> extends AbstractField<T> implements
context.sql(", 'IGNORE NULLS'");
}
else {
context.keyword(" ignore nulls");
context.sql(" ").keyword("ignore nulls");
}
}
else if (respectNulls) {
@ -433,7 +435,7 @@ class Function<T> extends AbstractField<T> implements
context.sql(", 'RESPECT NULLS'");
}
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) {
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");

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

@ -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;

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

@ -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);
}

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

@ -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)

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");
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<R extends Record> extends AbstractSelect<R> 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<R extends Record> extends AbstractSelect<R> 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<R extends Record> extends AbstractSelect<R> 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<R extends Record> extends AbstractSelect<R> 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<R extends Record> extends AbstractSelect<R> implements Sel
.keyword("connect by");
if (connectByNoCycle) {
context.keyword(" nocycle");
context.sql(" ").keyword("nocycle");
}
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
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;

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)) {
context.formatSeparator()
.keyword("where ")
.keyword("where").sql(" ")
.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) {
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<T> extends AbstractParam<T> {
// [#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()) {

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
public final void toSQL(RenderContext context) {
context.visit(delegate)
.keyword(" with ")
.sql("(")
.sql(hint)
.sql(" ").keyword("with")
.sql(" (").sql(hint)
.sql(")");
}