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

[jOOQ/jOOQ#13640] Implement QOM.CaseSimple

Browse Source
This commit is contained in:
Lukas Eder 2022-10-27 15:46:58 +02:00
parent ed1d0d5e03
commit 46539cf445
7 changed files with 111 additions and 65 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -61,11 +61,9 @@ import org.jooq.DataType;
import org.jooq.Field;
import org.jooq.Function2;
// ...
import org.jooq.QueryPart;
import org.jooq.Record1;
// ...
import org.jooq.Select;
// ...
import org.jooq.impl.QOM.CaseSearched;
import org.jooq.impl.QOM.UTuple2;
import org.jooq.impl.QOM.UnmodifiableList;
@ -226,7 +224,7 @@ implements
.formatIndentStart();
for (UTuple2<Condition, Field<T>> e : when) {
Condition c = e.$part1();
Condition c = e.$1();
@ -245,7 +243,7 @@ implements
ctx.formatSeparator()
.visit(K_WHEN).sql(' ').visit(c).sql(' ')
.visit(K_THEN).sql(' ').visit(e.$part2());
.visit(K_THEN).sql(' ').visit(e.$2());
}
if (else_ != null)
@ -268,7 +266,7 @@ implements
public final Function2<? super UnmodifiableList<? extends UTuple2<Condition, Field<T>>>, ? super Field<T>, ? extends CaseSearched<T>> $constructor() {
return (w, e) -> {
CaseConditionStepImpl<T> r = new CaseConditionStepImpl<>(getDataType());
w.forEach(t -> r.when(t.$part1(), t.$part2()));
w.forEach(t -> r.when(t.$1(), t.$2()));
r.else_(e);
return r;
};
@ -293,20 +291,4 @@ implements
public final CaseSearched<T> $arg2(Field<T> e) {
return $constructor().apply($when(), e);
}
@Override
public final <R> R $traverse(Traverser<?, R> traverser) {
return QOM.traverse(traverser, this, $when(), $else());
}
@Override
public final QueryPart $replace(Replacer replacer) {
return QOM.replace(
this,
$when(),
$else(),
(w, e) -> $constructor().apply(w, e),
replacer
);
}
}

8
jOOQ/src/main/java/org/jooq/impl/CaseImpl.java
View File

@ -44,14 +44,16 @@ import org.jooq.Condition;
import org.jooq.Field;
import org.jooq.Record1;
import org.jooq.Select;
import org.jooq.impl.QOM.UTransient;
/**
* A transient step in the construction of <code>CASE</code> statements.
*
* @author Lukas Eder
*/
final class CaseImpl implements Case {
final class CaseImpl implements Case, UTransient {
CaseImpl() {
}
CaseImpl() {}
@Override
public final <V> CaseValueStep<V> value(V value) {

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

@ -45,11 +45,14 @@ import org.jooq.CaseWhenStep;
import org.jooq.Field;
import org.jooq.Record1;
import org.jooq.Select;
import org.jooq.impl.QOM.UTransient;
/**
* A transient step in the construction of <code>CASE</code> statements.
*
* @author Lukas Eder
*/
final class CaseValueStepImpl<V> implements CaseValueStep<V> {
final class CaseValueStepImpl<V> implements CaseValueStep<V>, UTransient {
private final Field<V> value;

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

@ -47,30 +47,37 @@ import static org.jooq.impl.Keywords.K_THEN;
import static org.jooq.impl.Keywords.K_TRUE;
import static org.jooq.impl.Keywords.K_WHEN;
import static org.jooq.impl.Names.NQ_CASE;
import static org.jooq.impl.QOM.tuple;
import static org.jooq.impl.Tools.BooleanDataKey.DATA_FORCE_CASE_ELSE_NULL;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import org.jooq.CaseConditionStep;
import org.jooq.CaseWhenStep;
import org.jooq.Context;
import org.jooq.DataType;
import org.jooq.Field;
import org.jooq.Function3;
// ...
import org.jooq.impl.QOM.UNotYetImplemented;
import org.jooq.impl.QOM.CaseSimple;
import org.jooq.impl.QOM.UTuple2;
import org.jooq.impl.QOM.UnmodifiableList;
/**
* @author Lukas Eder
*/
final class CaseWhenStepImpl<V, T> extends AbstractField<T> implements CaseWhenStep<V, T>, UNotYetImplemented {
final class CaseWhenStepImpl<V, T>
extends
AbstractField<T>
implements
CaseWhenStep<V, T>,
QOM.CaseSimple<V, T>
{
private final Field<V> value;
private final List<Field<V>> compareValues;
private final List<Field<T>> results;
private Field<T> else_;
private final Field<V> value;
private final List<UTuple2<Field<V>, Field<T>>> when;
private Field<T> else_;
CaseWhenStepImpl(Field<V> value, Field<V> compareValue, Field<T> result) {
this(value, result.getDataType());
@ -84,12 +91,11 @@ final class CaseWhenStepImpl<V, T> extends AbstractField<T> implements CaseWhenS
mapFields(map);
}
private CaseWhenStepImpl(Field<V> value, DataType<T> type) {
CaseWhenStepImpl(Field<V> value, DataType<T> type) {
super(NQ_CASE, type);
this.value = value;
this.compareValues = new ArrayList<>();
this.results = new ArrayList<>();
this.when = new QueryPartList<>();
}
@SuppressWarnings("unchecked")
@ -100,6 +106,10 @@ final class CaseWhenStepImpl<V, T> extends AbstractField<T> implements CaseWhenS
return map.entrySet().iterator().next().getValue().getDataType();
}
// -------------------------------------------------------------------------
// XXX: QueryPart API
// -------------------------------------------------------------------------
@Override
public final Field<T> otherwise(T result) {
return else_(result);
@ -139,8 +149,7 @@ final class CaseWhenStepImpl<V, T> extends AbstractField<T> implements CaseWhenS
@Override
public final CaseWhenStep<V, T> when(Field<V> compareValue, Field<T> result) {
compareValues.add(compareValue);
results.add(result);
when.add(tuple(compareValue, result));
return this;
}
@ -222,39 +231,38 @@ final class CaseWhenStepImpl<V, T> extends AbstractField<T> implements CaseWhenS
private final void acceptSearched(Context<?> ctx) {
int size = compareValues.size();
CaseConditionStep<T> when = null;
for (int i = 0; i < size; i++)
if (when == null)
when = DSL.when(value.eq(compareValues.get(i)), results.get(i));
CaseConditionStep<T> w = null;
for (UTuple2<Field<V>, Field<T>> e : when)
if (w == null)
w = DSL.when(value.eq(e.$1()), e.$2());
else
when = when.when(value.eq(compareValues.get(i)), results.get(i));
w = w.when(value.eq(e.$1()), e.$2());
if (when != null)
if (w != null)
if (else_ != null)
ctx.visit(when.else_(else_));
ctx.visit(w.else_(else_));
else
ctx.visit(when);
ctx.visit(w);
}
private final void acceptNative(Context<?> ctx) {
ctx.visit(K_CASE);
int size = compareValues.size();
ctx.sql(' ')
.visit(value)
.formatIndentStart();
for (int i = 0; i < size; i++)
for (UTuple2<Field<V>, Field<T>> e : when)
ctx.formatSeparator()
.visit(K_WHEN).sql(' ')
.visit(compareValues.get(i)).sql(' ')
.visit(e.$1()).sql(' ')
.visit(K_THEN).sql(' ')
.visit(results.get(i));
.visit(e.$2());
if (else_ != null)
ctx.formatSeparator()
@ -268,4 +276,48 @@ final class CaseWhenStepImpl<V, T> extends AbstractField<T> implements CaseWhenS
.formatSeparator()
.visit(K_END);
}
// -------------------------------------------------------------------------
// XXX: Query Object Model
// -------------------------------------------------------------------------
@Override
public final Function3<? super Field<V>, ? super UnmodifiableList<? extends UTuple2<Field<V>, Field<T>>>, ? super Field<T>, ? extends CaseSimple<V, T>> $constructor() {
return (v, w, e) -> {
CaseWhenStepImpl<V, T> r = new CaseWhenStepImpl<>(v, getDataType());
w.forEach(t -> r.when(t.$1(), t.$2()));
r.else_(e);
return r;
};
}
@Override
public final Field<V> $arg1() {
return value;
}
@Override
public final CaseSimple<V, T> $arg1(Field<V> newArg1) {
return $constructor().apply(newArg1, $when(), $else());
}
@Override
public final UnmodifiableList<? extends UTuple2<Field<V>, Field<T>>> $arg2() {
return QOM.unmodifiable(when);
}
@Override
public final CaseSimple<V, T> $arg2(UnmodifiableList<? extends UTuple2<Field<V>, Field<T>>> w) {
return $constructor().apply($value(), w, $else());
}
@Override
public final Field<T> $arg3() {
return else_;
}
@Override
public final CaseSimple<V, T> $arg3(Field<T> e) {
return $constructor().apply($value(), $when(), e);
}
}

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

@ -1719,6 +1719,11 @@ package org.jooq.impl;

8
jOOQ/src/main/java/org/jooq/impl/QOM.java
View File

@ -224,10 +224,10 @@ public final class QOM {
permits
UTupleImpl2
{
@NotNull Q1 $part1();
@NotNull UTuple2<Q1, Q2> $part1(Q1 newPart1);
@NotNull Q2 $part2();
@NotNull UTuple2<Q1, Q2> $part2(Q2 newPart2);
@NotNull Q1 $1();
@NotNull UTuple2<Q1, Q2> $1(Q1 newPart1);
@NotNull Q2 $2();
@NotNull UTuple2<Q1, Q2> $2(Q2 newPart2);
}
/**

22
jOOQ/src/main/java/org/jooq/impl/UTupleImpl2.java
View File

@ -37,6 +37,8 @@
*/
package org.jooq.impl;
import static org.jooq.impl.QOM.tuple;
import org.jooq.Context;
import org.jooq.QueryPart;
// ...
@ -80,37 +82,37 @@ implements
// -------------------------------------------------------------------------
@Override
public final Q1 $part1() {
public final Q1 $1() {
return part1;
}
@Override
public final Q2 $part2() {
public final Q2 $2() {
return part2;
}
@Override
public final UTuple2<Q1, Q2> $part1(Q1 newPart1) {
return new UTupleImpl2<>(newPart1, part2);
public final UTuple2<Q1, Q2> $1(Q1 newPart1) {
return tuple(newPart1, part2);
}
@Override
public final UTuple2<Q1, Q2> $part2(Q2 newPart2) {
return new UTupleImpl2<>(part1, newPart2);
public final UTuple2<Q1, Q2> $2(Q2 newPart2) {
return tuple(part1, newPart2);
}
@Override
public final <R> R $traverse(Traverser<?, R> traverser) {
return QOM.traverse(traverser, this, $part1(), $part2());
return QOM.traverse(traverser, this, $1(), $2());
}
@Override
public final QueryPart $replace(Replacer replacer) {
return QOM.replace(
this,
$part1(),
$part2(),
(p1, p2) -> new UTupleImpl2<>(p1, p2),
$1(),
$2(),
(p1, p2) -> tuple(p1, p2),
replacer
);
}