From e232a06e8401cab86eb0772db9a97145479b7f19 Mon Sep 17 00:00:00 2001 From: Lukas Eder Date: Tue, 22 Sep 2020 14:32:05 +0200 Subject: [PATCH] [jOOQ/jOOQ#10644] Add Settings.transformUnneededArithmeticExpressions to optimise arithmetic prior to SQL generation - Added INTERNAL implementation to functions - Fixed recursive behaviour - Implement this for unaryMinus() (negation) --- .../java/org/jooq/impl/AbstractField.java | 2 +- jOOQ/src/main/java/org/jooq/impl/Acos.java | 13 ++++++ jOOQ/src/main/java/org/jooq/impl/Asin.java | 9 ++++ jOOQ/src/main/java/org/jooq/impl/Cosh.java | 11 ++++- jOOQ/src/main/java/org/jooq/impl/Cot.java | 1 + jOOQ/src/main/java/org/jooq/impl/DSL.java | 13 ++++-- .../main/java/org/jooq/impl/Expression.java | 20 ++++++++- jOOQ/src/main/java/org/jooq/impl/Extract.java | 44 ++++++++++++------- .../java/org/jooq/impl/GenerateSeries.java | 8 ++-- .../src/main/java/org/jooq/impl/Internal.java | 13 ++++-- jOOQ/src/main/java/org/jooq/impl/Limit.java | 3 +- jOOQ/src/main/java/org/jooq/impl/Ln.java | 3 +- .../src/main/java/org/jooq/impl/LoopImpl.java | 2 + jOOQ/src/main/java/org/jooq/impl/Lpad.java | 1 + jOOQ/src/main/java/org/jooq/impl/Neg.java | 8 ++-- jOOQ/src/main/java/org/jooq/impl/Overlay.java | 10 +++-- jOOQ/src/main/java/org/jooq/impl/Pi.java | 1 + .../src/main/java/org/jooq/impl/Position.java | 4 +- jOOQ/src/main/java/org/jooq/impl/Power.java | 3 +- jOOQ/src/main/java/org/jooq/impl/Product.java | 12 ++--- .../java/org/jooq/impl/RankingFunction.java | 5 +++ jOOQ/src/main/java/org/jooq/impl/Repeat.java | 3 +- jOOQ/src/main/java/org/jooq/impl/Right.java | 4 +- jOOQ/src/main/java/org/jooq/impl/Round.java | 13 +++--- .../org/jooq/impl/RowOverlapsCondition.java | 5 ++- jOOQ/src/main/java/org/jooq/impl/Rpad.java | 1 + jOOQ/src/main/java/org/jooq/impl/Sinh.java | 8 +++- jOOQ/src/main/java/org/jooq/impl/Tanh.java | 9 +++- jOOQ/src/main/java/org/jooq/impl/Trunc.java | 8 ++-- .../main/java/org/jooq/impl/WidthBucket.java | 14 +++++- 30 files changed, 188 insertions(+), 63 deletions(-) diff --git a/jOOQ/src/main/java/org/jooq/impl/AbstractField.java b/jOOQ/src/main/java/org/jooq/impl/AbstractField.java index 65d3dc8b9c..097fa99d74 100644 --- a/jOOQ/src/main/java/org/jooq/impl/AbstractField.java +++ b/jOOQ/src/main/java/org/jooq/impl/AbstractField.java @@ -329,7 +329,7 @@ abstract class AbstractField extends AbstractTypedNamed implements Field neg() { - return new Neg<>(this, ExpressionOperator.SUBTRACT); + return new Neg<>(this, false, ExpressionOperator.SUBTRACT); } @Override diff --git a/jOOQ/src/main/java/org/jooq/impl/Acos.java b/jOOQ/src/main/java/org/jooq/impl/Acos.java index 0b32e335b0..01ea4d7e7b 100644 --- a/jOOQ/src/main/java/org/jooq/impl/Acos.java +++ b/jOOQ/src/main/java/org/jooq/impl/Acos.java @@ -39,6 +39,10 @@ package org.jooq.impl; import static org.jooq.impl.DSL.one; import static org.jooq.impl.DSL.two; +import static org.jooq.impl.Internal.iadd; +import static org.jooq.impl.Internal.idiv; +import static org.jooq.impl.Internal.imul; +import static org.jooq.impl.Internal.ineg; import static org.jooq.impl.Names.N_ACOS; import java.math.BigDecimal; @@ -72,6 +76,15 @@ final class Acos extends AbstractField { + + + + + + + + + default: ctx.visit(N_ACOS).sql('(').visit(arg).sql(')'); break; diff --git a/jOOQ/src/main/java/org/jooq/impl/Asin.java b/jOOQ/src/main/java/org/jooq/impl/Asin.java index 0edab085d5..bbf2978b7e 100644 --- a/jOOQ/src/main/java/org/jooq/impl/Asin.java +++ b/jOOQ/src/main/java/org/jooq/impl/Asin.java @@ -38,6 +38,10 @@ package org.jooq.impl; import static org.jooq.impl.DSL.one; +import static org.jooq.impl.Internal.iadd; +import static org.jooq.impl.Internal.idiv; +import static org.jooq.impl.Internal.imul; +import static org.jooq.impl.Internal.ineg; import static org.jooq.impl.Names.N_ASIN; import java.math.BigDecimal; @@ -71,6 +75,11 @@ final class Asin extends AbstractField { + + + + + default: ctx.visit(N_ASIN).sql('(').visit(arg).sql(')'); break; diff --git a/jOOQ/src/main/java/org/jooq/impl/Cosh.java b/jOOQ/src/main/java/org/jooq/impl/Cosh.java index caf19e3efc..f03eb2c824 100644 --- a/jOOQ/src/main/java/org/jooq/impl/Cosh.java +++ b/jOOQ/src/main/java/org/jooq/impl/Cosh.java @@ -39,6 +39,9 @@ package org.jooq.impl; import static org.jooq.impl.DSL.one; import static org.jooq.impl.DSL.two; +import static org.jooq.impl.Internal.iadd; +import static org.jooq.impl.Internal.idiv; +import static org.jooq.impl.Internal.imul; import static org.jooq.impl.Names.N_COSH; import java.math.BigDecimal; @@ -86,7 +89,13 @@ final class Cosh extends AbstractField { case MARIADB: case MYSQL: case POSTGRES: - ctx.visit(DSL.exp(argument.mul(two())).add(one()).div(DSL.exp(argument).mul(two()))); + ctx.visit(idiv( + iadd( + DSL.exp(imul(argument, two())), + one() + ), + imul(DSL.exp(argument), two()) + )); break; default: diff --git a/jOOQ/src/main/java/org/jooq/impl/Cot.java b/jOOQ/src/main/java/org/jooq/impl/Cot.java index 0048965342..e70c524173 100644 --- a/jOOQ/src/main/java/org/jooq/impl/Cot.java +++ b/jOOQ/src/main/java/org/jooq/impl/Cot.java @@ -37,6 +37,7 @@ */ package org.jooq.impl; +import static org.jooq.impl.Internal.idiv; import static org.jooq.impl.Names.N_COT; import java.math.BigDecimal; diff --git a/jOOQ/src/main/java/org/jooq/impl/DSL.java b/jOOQ/src/main/java/org/jooq/impl/DSL.java index 26c5d3902f..af558ac7e7 100644 --- a/jOOQ/src/main/java/org/jooq/impl/DSL.java +++ b/jOOQ/src/main/java/org/jooq/impl/DSL.java @@ -87,6 +87,10 @@ import static org.jooq.SQLDialect.SQLITE; // ... // ... // ... +import static org.jooq.impl.Internal.iadd; +import static org.jooq.impl.Internal.idiv; +import static org.jooq.impl.Internal.imul; +import static org.jooq.impl.Internal.isub; import static org.jooq.impl.Keywords.K_CUBE; import static org.jooq.impl.Keywords.K_GROUPING_SETS; import static org.jooq.impl.Names.N_IF; @@ -18857,7 +18861,7 @@ public class DSL { @NotNull @Support({ CUBRID, FIREBIRD, H2, HSQLDB, MARIADB, MYSQL, POSTGRES, SQLITE }) public static Field bitNot(Field field) { - return new Neg<>(nullSafe(field), ExpressionOperator.BIT_NOT); + return new Neg<>(nullSafe(field), false, ExpressionOperator.BIT_NOT); } /** @@ -20104,7 +20108,10 @@ public class DSL { @Support({ CUBRID, DERBY, FIREBIRD, H2, HSQLDB, MARIADB, MYSQL, POSTGRES }) public static Field coth(Field field) { field = nullSafe(field); - return exp(field.mul(2)).add(1).div(exp(field.mul(2)).sub(1)); + return idiv( + iadd(exp(imul(field, two())), one()), + isub(exp(imul(field, two())), one()) + ); } /** @@ -26096,7 +26103,7 @@ public class DSL { @NotNull @Support public static Field tau() { - return pi().times(two()); + return imul(pi(), two()); } /** diff --git a/jOOQ/src/main/java/org/jooq/impl/Expression.java b/jOOQ/src/main/java/org/jooq/impl/Expression.java index aa0adfd243..98b871e39b 100644 --- a/jOOQ/src/main/java/org/jooq/impl/Expression.java +++ b/jOOQ/src/main/java/org/jooq/impl/Expression.java @@ -76,6 +76,10 @@ import static org.jooq.impl.ExpressionOperator.MULTIPLY; import static org.jooq.impl.ExpressionOperator.SHL; import static org.jooq.impl.ExpressionOperator.SHR; import static org.jooq.impl.ExpressionOperator.SUBTRACT; +import static org.jooq.impl.Internal.iadd; +import static org.jooq.impl.Internal.idiv; +import static org.jooq.impl.Internal.imul; +import static org.jooq.impl.Internal.isub; import static org.jooq.impl.Keywords.K_AS; import static org.jooq.impl.Keywords.K_CAST; import static org.jooq.impl.Keywords.K_DAY; @@ -162,6 +166,11 @@ final class Expression extends AbstractField { + + + + + SQLDialect family = ctx.family(); // --------------------------------------------------------------------- @@ -209,12 +218,12 @@ final class Expression extends AbstractField { // Many dialects don't support shifts. Use multiplication/division instead else if (SHL == operator && EMULATE_SHR_SHL.contains(ctx.dialect())) - ctx.visit(lhs.mul((Field) castIfNeeded(DSL.power(two(), rhsAsNumber()), lhs))); + ctx.visit(imul(lhs, (Field) castIfNeeded(DSL.power(two(), rhsAsNumber()), lhs))); // [#3962] This emulation is expensive. If this is emulated, BitCount should // use division instead of SHR directly else if (SHR == operator && EMULATE_SHR_SHL.contains(ctx.dialect())) - ctx.visit(lhs.div((Field) castIfNeeded(DSL.power(two(), rhsAsNumber()), lhs))); + ctx.visit(idiv(lhs, (Field) castIfNeeded(DSL.power(two(), rhsAsNumber()), lhs))); // Use the default operator expression for all other cases else @@ -247,6 +256,11 @@ final class Expression extends AbstractField { // Use the default operator expression for all other cases else ctx.visit(new DefaultExpression<>(lhs, operator, rhs)); + + + + + } @@ -331,6 +345,8 @@ final class Expression extends AbstractField { + + diff --git a/jOOQ/src/main/java/org/jooq/impl/Extract.java b/jOOQ/src/main/java/org/jooq/impl/Extract.java index 135b8bc8f3..10e2db7c12 100644 --- a/jOOQ/src/main/java/org/jooq/impl/Extract.java +++ b/jOOQ/src/main/java/org/jooq/impl/Extract.java @@ -43,6 +43,9 @@ import static org.jooq.impl.DSL.inline; import static org.jooq.impl.DSL.isoDayOfWeek; import static org.jooq.impl.DSL.keyword; import static org.jooq.impl.DSL.one; +import static org.jooq.impl.Internal.iadd; +import static org.jooq.impl.Internal.idiv; +import static org.jooq.impl.Internal.imul; import static org.jooq.impl.Keywords.K_DATE; import static org.jooq.impl.Keywords.K_DAY; import static org.jooq.impl.Keywords.K_FROM; @@ -414,44 +417,55 @@ final class Extract extends AbstractField { } private final static Field dowISOToSun1(Field dow) { - return dow.mod(inline(7)).add(one()); + return iadd(dow.mod(inline(7)), one()); } private final static Field dowSun1ToISO(Field dow) { - return dow.add(inline(5)).mod(inline(7)).add(one()); + return iadd(iadd(dow, inline(5)).mod(inline(7)), one()); } private final static Field dowSun0ToISO(Field dow) { - return dow.add(inline(6)).mod(inline(7)).add(one()); + return iadd(iadd(dow, inline(6)).mod(inline(7)), one()); } private final void acceptDefaultEmulation(Context ctx) { switch (datePart) { case DECADE: - ctx.visit(DSL.floor(DSL.year(field).div(inline(10)))); + ctx.visit(DSL.floor(idiv(DSL.year(field), inline(10)))); break; case CENTURY: - ctx.visit(DSL.floor( - DSL.sign(DSL.year(field)) - .mul(DSL.abs(DSL.year(field)).add(inline(99))) - .div(inline(100)))); + ctx.visit(DSL.floor(idiv( + imul( + DSL.sign(DSL.year(field)), + iadd(DSL.abs(DSL.year(field)), inline(99)) + ), + inline(100) + ))); break; case MILLENNIUM: - ctx.visit(DSL.floor( - DSL.sign(DSL.year(field)) - .mul(DSL.abs(DSL.year(field)).add(inline(999))) - .div(inline(1000)))); + ctx.visit(DSL.floor(idiv( + imul( + DSL.sign(DSL.year(field)), + iadd(DSL.abs(DSL.year(field)), inline(999)) + ), + inline(1000) + ))); break; case QUARTER: - ctx.visit(DSL.floor(DSL.month(field).add(inline(2)).div(inline(3)))); + ctx.visit(DSL.floor(idiv( + iadd(DSL.month(field), inline(2)), + inline(3) + ))); break; case TIMEZONE: - ctx.visit(DSL.extract(field, DatePart.TIMEZONE_HOUR).mul(inline(3600)) - .add(DSL.extract(field, DatePart.TIMEZONE_MINUTE).mul(inline(60)))); + ctx.visit(iadd( + imul(DSL.extract(field, DatePart.TIMEZONE_HOUR), inline(3600)), + imul(DSL.extract(field, DatePart.TIMEZONE_MINUTE), inline(60)) + )); break; default: diff --git a/jOOQ/src/main/java/org/jooq/impl/GenerateSeries.java b/jOOQ/src/main/java/org/jooq/impl/GenerateSeries.java index 0b4fbcf6a9..1fa13d58f3 100644 --- a/jOOQ/src/main/java/org/jooq/impl/GenerateSeries.java +++ b/jOOQ/src/main/java/org/jooq/impl/GenerateSeries.java @@ -43,9 +43,9 @@ import static org.jooq.impl.DSL.one; import static org.jooq.impl.DSL.select; import static org.jooq.impl.DSL.unquotedName; import static org.jooq.impl.DSL.withRecursive; -import static org.jooq.impl.Internal.add; -import static org.jooq.impl.Internal.mul; -import static org.jooq.impl.Internal.sub; +import static org.jooq.impl.Internal.iadd; +import static org.jooq.impl.Internal.imul; +import static org.jooq.impl.Internal.isub; import static org.jooq.impl.Names.N_GENERATE_SERIES; import static org.jooq.impl.Names.N_SYSTEM_RANGE; import static org.jooq.impl.SQLDataType.INTEGER; @@ -105,7 +105,7 @@ final class GenerateSeries extends AbstractTable> { visitSubquery( ctx, withRecursive(N_GENERATE_SERIES, v) - .as(select(from).unionAll(select(f.plus(step == null ? inline(1) : step)).from(N_GENERATE_SERIES).where(f.lt(to)))) + .as(select(from).unionAll(select(iadd(f, step == null ? inline(1) : step)).from(N_GENERATE_SERIES).where(f.lt(to)))) .select(f.as(N_GENERATE_SERIES)).from(N_GENERATE_SERIES), true ); diff --git a/jOOQ/src/main/java/org/jooq/impl/Internal.java b/jOOQ/src/main/java/org/jooq/impl/Internal.java index 302a411aab..db75e3fa4e 100644 --- a/jOOQ/src/main/java/org/jooq/impl/Internal.java +++ b/jOOQ/src/main/java/org/jooq/impl/Internal.java @@ -364,22 +364,27 @@ public final class Internal { } @Support - static final Field add(Field lhs, Field rhs) { + static final Field ineg(Field field) { + return new Neg<>(field, true, ExpressionOperator.SUBTRACT); + } + + @Support + static final Field iadd(Field lhs, Field rhs) { return new Expression<>(ADD, true, lhs, nullSafe(rhs, lhs.getDataType())); } @Support - static final Field sub(Field lhs, Field rhs) { + static final Field isub(Field lhs, Field rhs) { return new Expression<>(SUBTRACT, true, lhs, nullSafe(rhs, lhs.getDataType())); } @Support - static final Field mul(Field lhs, Field rhs) { + static final Field imul(Field lhs, Field rhs) { return new Expression<>(MULTIPLY, true, lhs, nullSafe(rhs, lhs.getDataType())); } @Support - static final Field div(Field lhs, Field rhs) { + static final Field idiv(Field lhs, Field rhs) { return new Expression<>(DIVIDE, true, lhs, nullSafe(rhs, lhs.getDataType())); } } diff --git a/jOOQ/src/main/java/org/jooq/impl/Limit.java b/jOOQ/src/main/java/org/jooq/impl/Limit.java index 30f70f79cb..ce667ab191 100644 --- a/jOOQ/src/main/java/org/jooq/impl/Limit.java +++ b/jOOQ/src/main/java/org/jooq/impl/Limit.java @@ -45,6 +45,7 @@ import static org.jooq.conf.ParamType.INLINED; import static org.jooq.impl.DSL.one; import static org.jooq.impl.DSL.val; import static org.jooq.impl.DSL.zero; +import static org.jooq.impl.Internal.iadd; import static org.jooq.impl.Keywords.K_FETCH_FIRST; import static org.jooq.impl.Keywords.K_FETCH_NEXT; import static org.jooq.impl.Keywords.K_FIRST; @@ -423,7 +424,7 @@ final class Limit extends AbstractQueryPart { * The upper bound, such that ROW_NUMBER() <= getUpperRownum() */ final Field getUpperRownum() { - return offsetOrZero.add(numberOfRowsOrMax); + return iadd(offsetOrZero, numberOfRowsOrMax); } /** diff --git a/jOOQ/src/main/java/org/jooq/impl/Ln.java b/jOOQ/src/main/java/org/jooq/impl/Ln.java index 36d88a22a4..5dab17c475 100644 --- a/jOOQ/src/main/java/org/jooq/impl/Ln.java +++ b/jOOQ/src/main/java/org/jooq/impl/Ln.java @@ -38,6 +38,7 @@ package org.jooq.impl; import static org.jooq.impl.DSL.function; +import static org.jooq.impl.Internal.idiv; import static org.jooq.impl.Names.N_LN; import static org.jooq.impl.SQLDataType.NUMERIC; @@ -126,7 +127,7 @@ final class Ln extends AbstractField { case DERBY: case HSQLDB: - ctx.visit(DSL.ln(argument).div(DSL.ln(base))); + ctx.visit(idiv(DSL.ln(argument), DSL.ln(base))); return; default: diff --git a/jOOQ/src/main/java/org/jooq/impl/LoopImpl.java b/jOOQ/src/main/java/org/jooq/impl/LoopImpl.java index cbfcbcb12f..b808a68bd8 100644 --- a/jOOQ/src/main/java/org/jooq/impl/LoopImpl.java +++ b/jOOQ/src/main/java/org/jooq/impl/LoopImpl.java @@ -320,6 +320,8 @@ package org.jooq.impl; + + diff --git a/jOOQ/src/main/java/org/jooq/impl/Lpad.java b/jOOQ/src/main/java/org/jooq/impl/Lpad.java index 615070e64a..6281f08077 100644 --- a/jOOQ/src/main/java/org/jooq/impl/Lpad.java +++ b/jOOQ/src/main/java/org/jooq/impl/Lpad.java @@ -38,6 +38,7 @@ package org.jooq.impl; import static org.jooq.impl.DSL.inline; +import static org.jooq.impl.Internal.isub; import static org.jooq.impl.Names.N_HEX; import static org.jooq.impl.Names.N_LEN; import static org.jooq.impl.Names.N_LENGTH; diff --git a/jOOQ/src/main/java/org/jooq/impl/Neg.java b/jOOQ/src/main/java/org/jooq/impl/Neg.java index 2740a2f65c..af48313ab5 100644 --- a/jOOQ/src/main/java/org/jooq/impl/Neg.java +++ b/jOOQ/src/main/java/org/jooq/impl/Neg.java @@ -66,14 +66,16 @@ final class Neg extends AbstractField { private static final Set EMULATE_BIT_NOT = SQLDialect.supportedBy(HSQLDB); private static final Set SUPPORT_BIT_NOT = SQLDialect.supportedBy(H2); - private final ExpressionOperator operator; private final Field field; + private final boolean internal; + private final ExpressionOperator operator; - Neg(Field field, ExpressionOperator operator) { + Neg(Field field, boolean internal, ExpressionOperator operator) { super(operator.toName(), field.getDataType()); - this.operator = operator; this.field = field; + this.internal = internal; + this.operator = operator; } @Override diff --git a/jOOQ/src/main/java/org/jooq/impl/Overlay.java b/jOOQ/src/main/java/org/jooq/impl/Overlay.java index b7f1ea1f90..3ba8dd4706 100644 --- a/jOOQ/src/main/java/org/jooq/impl/Overlay.java +++ b/jOOQ/src/main/java/org/jooq/impl/Overlay.java @@ -59,6 +59,8 @@ import static org.jooq.SQLDialect.SQLITE; // ... // ... import static org.jooq.impl.DSL.inline; +import static org.jooq.impl.Internal.iadd; +import static org.jooq.impl.Internal.isub; import static org.jooq.impl.Keywords.K_FOR; import static org.jooq.impl.Keywords.K_FROM; import static org.jooq.impl.Keywords.K_PLACING; @@ -114,9 +116,9 @@ final class Overlay extends AbstractField { } else if (NO_SUPPORT.contains(ctx.dialect())) { ctx.visit( - DSL.substring(in, inline(1), startIndex.minus(inline(1))) + DSL.substring(in, inline(1), isub(startIndex, inline(1))) .concat(placing) - .concat(DSL.substring(in, startIndex.plus(l))) + .concat(DSL.substring(in, iadd(startIndex, l))) ); } else { @@ -132,9 +134,9 @@ final class Overlay extends AbstractField { } else if (NO_SUPPORT.contains(ctx.dialect())) { ctx.visit( - DSL.substring(in, inline(1), startIndex.minus(inline(1))) + DSL.substring(in, inline(1), isub(startIndex, inline(1))) .concat(placing) - .concat(DSL.substring(in, startIndex.plus(DSL.length(placing)))) + .concat(DSL.substring(in, iadd(startIndex, DSL.length(placing)))) ); } else { diff --git a/jOOQ/src/main/java/org/jooq/impl/Pi.java b/jOOQ/src/main/java/org/jooq/impl/Pi.java index 0941ee22c0..75fc5f3576 100644 --- a/jOOQ/src/main/java/org/jooq/impl/Pi.java +++ b/jOOQ/src/main/java/org/jooq/impl/Pi.java @@ -41,6 +41,7 @@ import static org.jooq.impl.DSL.function; import static org.jooq.impl.DSL.inline; import static org.jooq.impl.DSL.one; import static org.jooq.impl.DSL.two; +import static org.jooq.impl.Internal.imul; import static org.jooq.impl.Names.N_PI; import java.math.BigDecimal; diff --git a/jOOQ/src/main/java/org/jooq/impl/Position.java b/jOOQ/src/main/java/org/jooq/impl/Position.java index 39fdd95f45..7fc90a764b 100644 --- a/jOOQ/src/main/java/org/jooq/impl/Position.java +++ b/jOOQ/src/main/java/org/jooq/impl/Position.java @@ -39,6 +39,8 @@ package org.jooq.impl; import static org.jooq.impl.DSL.one; +import static org.jooq.impl.Internal.iadd; +import static org.jooq.impl.Internal.isub; import static org.jooq.impl.Keywords.K_IN; import static org.jooq.impl.Names.N_CHARINDEX; import static org.jooq.impl.Names.N_INSTR; @@ -89,7 +91,7 @@ final class Position extends AbstractField { default: - ctx.visit(DSL.position(DSL.substring(in, startIndex), search).add(startIndex).sub(one())); + ctx.visit(iadd(DSL.position(DSL.substring(in, startIndex), search), isub(startIndex, one()))); break; } else diff --git a/jOOQ/src/main/java/org/jooq/impl/Power.java b/jOOQ/src/main/java/org/jooq/impl/Power.java index 102a737edc..c6c3706811 100644 --- a/jOOQ/src/main/java/org/jooq/impl/Power.java +++ b/jOOQ/src/main/java/org/jooq/impl/Power.java @@ -37,6 +37,7 @@ */ package org.jooq.impl; +import static org.jooq.impl.Internal.imul; import static org.jooq.impl.Names.N_POWER; import static org.jooq.impl.SQLDataType.NUMERIC; @@ -76,7 +77,7 @@ final class Power extends AbstractField { case DERBY: case SQLITE: - ctx.visit(DSL.exp(DSL.ln(arg1).mul(arg2))); + ctx.visit(DSL.exp(imul(DSL.ln(arg1), arg2))); break; default: diff --git a/jOOQ/src/main/java/org/jooq/impl/Product.java b/jOOQ/src/main/java/org/jooq/impl/Product.java index 6b5fc471bd..bb6f5a5458 100644 --- a/jOOQ/src/main/java/org/jooq/impl/Product.java +++ b/jOOQ/src/main/java/org/jooq/impl/Product.java @@ -43,6 +43,7 @@ import static org.jooq.impl.DSL.inline; import static org.jooq.impl.DSL.one; import static org.jooq.impl.DSL.when; import static org.jooq.impl.DSL.zero; +import static org.jooq.impl.Internal.imul; import static org.jooq.impl.Names.N_PRODUCT; import static org.jooq.impl.SQLDataType.NUMERIC; @@ -118,10 +119,11 @@ final class Product extends AbstractAggregateFunction { } }; - ctx.visit( - when(zerosSum.gt(inline(BigDecimal.ZERO)), zero()) - .when(negativesSum.mod(inline(2)).lt(inline(BigDecimal.ZERO)), inline(-1)) - .otherwise(one()).mul(DSL.exp(logarithmsSum)) - ); + ctx.visit(imul( + when(zerosSum.gt(inline(BigDecimal.ZERO)), zero()) + .when(negativesSum.mod(inline(2)).lt(inline(BigDecimal.ZERO)), inline(-1)) + .otherwise(one()), + DSL.exp(logarithmsSum) + )); } } diff --git a/jOOQ/src/main/java/org/jooq/impl/RankingFunction.java b/jOOQ/src/main/java/org/jooq/impl/RankingFunction.java index 5201aa3c80..5f6746885f 100644 --- a/jOOQ/src/main/java/org/jooq/impl/RankingFunction.java +++ b/jOOQ/src/main/java/org/jooq/impl/RankingFunction.java @@ -42,6 +42,8 @@ package org.jooq.impl; import static org.jooq.impl.DSL.case_; import static org.jooq.impl.DSL.inline; import static org.jooq.impl.DSL.rank; +import static org.jooq.impl.Internal.idiv; +import static org.jooq.impl.Internal.isub; import static org.jooq.impl.RankingFunction.RankingType.CUME_DIST; import static org.jooq.impl.RankingFunction.RankingType.PERCENT_RANK; import static org.jooq.impl.SQLDataType.NUMERIC; @@ -100,6 +102,9 @@ final class RankingFunction extends AbstractWindowFunction implements Orde + + + { ctx.visit(rankingType.name).sql("()"); diff --git a/jOOQ/src/main/java/org/jooq/impl/Repeat.java b/jOOQ/src/main/java/org/jooq/impl/Repeat.java index 7a80f10ec0..0eb02d52d4 100644 --- a/jOOQ/src/main/java/org/jooq/impl/Repeat.java +++ b/jOOQ/src/main/java/org/jooq/impl/Repeat.java @@ -37,6 +37,7 @@ */ package org.jooq.impl; +import static org.jooq.impl.Internal.imul; import static org.jooq.impl.Names.N_HEX; import static org.jooq.impl.Names.N_REPEAT; import static org.jooq.impl.Names.N_REPLACE; @@ -79,7 +80,7 @@ final class Repeat extends AbstractField { case FIREBIRD: - ctx.visit(DSL.rpad(string, DSL.length(string).mul(count), string)); + ctx.visit(DSL.rpad(string, imul(DSL.length(string), count), string)); break; // Emulation of REPEAT() for SQLite currently cannot be achieved diff --git a/jOOQ/src/main/java/org/jooq/impl/Right.java b/jOOQ/src/main/java/org/jooq/impl/Right.java index b158c2f45e..7f42213cec 100644 --- a/jOOQ/src/main/java/org/jooq/impl/Right.java +++ b/jOOQ/src/main/java/org/jooq/impl/Right.java @@ -38,6 +38,8 @@ package org.jooq.impl; import static org.jooq.impl.DSL.one; +import static org.jooq.impl.Internal.iadd; +import static org.jooq.impl.Internal.isub; import static org.jooq.impl.Names.N_RIGHT; import org.jooq.Context; @@ -67,7 +69,7 @@ final class Right extends AbstractField { public final void accept(Context ctx) { switch (ctx.family()) { case DERBY: - ctx.visit(DSL.substring(field, field.length().add(one()).sub(length))); + ctx.visit(DSL.substring(field, iadd(DSL.length(field), isub(one(), length)))); break; diff --git a/jOOQ/src/main/java/org/jooq/impl/Round.java b/jOOQ/src/main/java/org/jooq/impl/Round.java index 9bdf19b878..4e52e52e1a 100644 --- a/jOOQ/src/main/java/org/jooq/impl/Round.java +++ b/jOOQ/src/main/java/org/jooq/impl/Round.java @@ -39,6 +39,9 @@ package org.jooq.impl; import static org.jooq.impl.DSL.function; import static org.jooq.impl.DSL.inline; +import static org.jooq.impl.Internal.idiv; +import static org.jooq.impl.Internal.imul; +import static org.jooq.impl.Internal.isub; import static org.jooq.impl.Names.N_ROUND; import static org.jooq.impl.SQLDataType.NUMERIC; import static org.jooq.impl.Tools.castIfNeeded; @@ -82,7 +85,7 @@ final class Round extends AbstractField { case DERBY: { if (decimals == null) { ctx.visit(DSL - .when(argument.sub(DSL.floor(argument)) + .when(isub(argument, DSL.floor(argument)) .lessThan((T) Double.valueOf(0.5)), DSL.floor(argument)) .otherwise(DSL.ceil(argument))); @@ -91,12 +94,12 @@ final class Round extends AbstractField { else if (decimals instanceof Param) { Integer decimalsValue = ((Param) decimals).getValue(); Field factor = DSL.val(BigDecimal.ONE.movePointRight(decimalsValue)); - Field mul = argument.mul(factor); + Field mul = imul(argument, factor); ctx.visit(DSL - .when(mul.sub(DSL.floor(mul)) - .lessThan((T) Double.valueOf(0.5)), DSL.floor(mul).div(factor)) - .otherwise(DSL.ceil(mul).div(factor))); + .when(isub(mul, DSL.floor(mul)) + .lessThan((T) Double.valueOf(0.5)), idiv(DSL.floor(mul), factor)) + .otherwise(idiv(DSL.ceil(mul), factor))); return; } diff --git a/jOOQ/src/main/java/org/jooq/impl/RowOverlapsCondition.java b/jOOQ/src/main/java/org/jooq/impl/RowOverlapsCondition.java index 13e6aae557..446a601387 100644 --- a/jOOQ/src/main/java/org/jooq/impl/RowOverlapsCondition.java +++ b/jOOQ/src/main/java/org/jooq/impl/RowOverlapsCondition.java @@ -60,6 +60,7 @@ import static org.jooq.SQLDialect.MYSQL; import static org.jooq.SQLDialect.SQLITE; // ... // ... +import static org.jooq.impl.Internal.iadd; import static org.jooq.impl.Keywords.K_OVERLAPS; import static org.jooq.impl.Tools.castIfNeeded; @@ -114,7 +115,7 @@ final class RowOverlapsCondition extends AbstractCondition { // Interval OVERLAPS predicates need some additional arithmetic if (intervalOverlaps) - ctx.visit(right1.le(left1.add(left2)).and(left1.le(right1.add(right2)))); + ctx.visit(right1.le(iadd(left1, left2)).and(left1.le(iadd(right1, right2)))); // All other OVERLAPS predicates can be emulated simply else @@ -123,7 +124,7 @@ final class RowOverlapsCondition extends AbstractCondition { // These dialects seem to have trouble with INTERVAL OVERLAPS predicates else if (intervalOverlaps && EMULATE_INTERVAL_OVERLAPS.contains(ctx.dialect())) - ctx.visit(right1.le(left1.add(left2)).and(left1.le(right1.add(right2)))); + ctx.visit(right1.le(iadd(left1, left2)).and(left1.le(iadd(right1, right2)))); // Everyone else can handle OVERLAPS else diff --git a/jOOQ/src/main/java/org/jooq/impl/Rpad.java b/jOOQ/src/main/java/org/jooq/impl/Rpad.java index 2af9861013..0a83d4fbdc 100644 --- a/jOOQ/src/main/java/org/jooq/impl/Rpad.java +++ b/jOOQ/src/main/java/org/jooq/impl/Rpad.java @@ -38,6 +38,7 @@ package org.jooq.impl; import static org.jooq.impl.DSL.inline; +import static org.jooq.impl.Internal.isub; import static org.jooq.impl.Names.N_HEX; import static org.jooq.impl.Names.N_LEN; import static org.jooq.impl.Names.N_LENGTH; diff --git a/jOOQ/src/main/java/org/jooq/impl/Sinh.java b/jOOQ/src/main/java/org/jooq/impl/Sinh.java index 7ad1878a0f..fd143f5e75 100644 --- a/jOOQ/src/main/java/org/jooq/impl/Sinh.java +++ b/jOOQ/src/main/java/org/jooq/impl/Sinh.java @@ -39,6 +39,9 @@ package org.jooq.impl; import static org.jooq.impl.DSL.one; import static org.jooq.impl.DSL.two; +import static org.jooq.impl.Internal.idiv; +import static org.jooq.impl.Internal.imul; +import static org.jooq.impl.Internal.isub; import static org.jooq.impl.Names.N_SINH; import static org.jooq.impl.SQLDataType.NUMERIC; @@ -87,7 +90,10 @@ final class Sinh extends AbstractField { case MARIADB: case MYSQL: case POSTGRES: - ctx.visit(DSL.exp(argument.mul(two())).sub(one()).div(DSL.exp(argument).mul(two()))); + ctx.visit(idiv( + isub(DSL.exp(imul(argument, two())), one()), + imul(DSL.exp(argument), two()) + )); break; default: diff --git a/jOOQ/src/main/java/org/jooq/impl/Tanh.java b/jOOQ/src/main/java/org/jooq/impl/Tanh.java index abef432478..d6d07ba9b3 100644 --- a/jOOQ/src/main/java/org/jooq/impl/Tanh.java +++ b/jOOQ/src/main/java/org/jooq/impl/Tanh.java @@ -39,6 +39,10 @@ package org.jooq.impl; import static org.jooq.impl.DSL.one; import static org.jooq.impl.DSL.two; +import static org.jooq.impl.Internal.iadd; +import static org.jooq.impl.Internal.idiv; +import static org.jooq.impl.Internal.imul; +import static org.jooq.impl.Internal.isub; import static org.jooq.impl.Names.N_TANH; import static org.jooq.impl.SQLDataType.NUMERIC; @@ -87,7 +91,10 @@ final class Tanh extends AbstractField { case MARIADB: case MYSQL: case POSTGRES: - ctx.visit(DSL.exp(argument.mul(two())).sub(one()).div(DSL.exp(argument.mul(two())).add(one()))); + ctx.visit(idiv( + isub(DSL.exp(imul(argument, two())), one()), + iadd(DSL.exp(imul(argument, two())), one()) + )); break; default: diff --git a/jOOQ/src/main/java/org/jooq/impl/Trunc.java b/jOOQ/src/main/java/org/jooq/impl/Trunc.java index dc9a984d52..a99f5e8198 100644 --- a/jOOQ/src/main/java/org/jooq/impl/Trunc.java +++ b/jOOQ/src/main/java/org/jooq/impl/Trunc.java @@ -40,6 +40,8 @@ package org.jooq.impl; import static java.math.BigDecimal.TEN; import static org.jooq.impl.DSL.inline; import static org.jooq.impl.DSL.zero; +import static org.jooq.impl.Internal.idiv; +import static org.jooq.impl.Internal.imul; import static org.jooq.impl.Names.N_ROUND; import static org.jooq.impl.Names.N_ROUND_DOWN; import static org.jooq.impl.Names.N_TRUNC; @@ -95,10 +97,8 @@ final class Trunc extends AbstractField { } ctx.visit(DSL.decode() - .when(field.sign().greaterOrEqual(zero()), - field.mul(power).floor().div(power)) - .otherwise( - field.mul(power).ceil().div(power))); + .when(field.sign().greaterOrEqual(zero()), idiv(imul(field, power).floor(), power)) + .otherwise(idiv(imul(field, power).ceil(), power))); break; } diff --git a/jOOQ/src/main/java/org/jooq/impl/WidthBucket.java b/jOOQ/src/main/java/org/jooq/impl/WidthBucket.java index e800ddc864..9b92f16c2c 100644 --- a/jOOQ/src/main/java/org/jooq/impl/WidthBucket.java +++ b/jOOQ/src/main/java/org/jooq/impl/WidthBucket.java @@ -40,6 +40,10 @@ package org.jooq.impl; import static org.jooq.impl.DSL.keyword; import static org.jooq.impl.DSL.one; import static org.jooq.impl.DSL.zero; +import static org.jooq.impl.Internal.iadd; +import static org.jooq.impl.Internal.idiv; +import static org.jooq.impl.Internal.imul; +import static org.jooq.impl.Internal.isub; import static org.jooq.impl.Names.N_WIDTH_BUCKET; import org.jooq.Context; @@ -88,8 +92,14 @@ final class WidthBucket extends AbstractField { default: ctx.visit( DSL.when(field.lt(low), zero()) - .when(field.ge(high), buckets.add(one())) - .otherwise((Field) DSL.floor(field.sub(low).mul(buckets).div(high.sub(low))).add(one())) + .when(field.ge(high), iadd(buckets, one())) + .otherwise((Field) iadd( + DSL.floor(idiv( + imul(isub(field, low), buckets), + isub(high, low) + )), + one() + )) ); break; }