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

[jOOQ/jOOQ#16499] Fix ARRAY_MAP(), add kotlin extension functions, add parser support for ANY_MATCH(), ALL_MATCH(), NONE_MATCH()

Browse Source
This commit is contained in:
Lukas Eder 2024-03-25 16:04:29 +01:00
parent 34a1b671f5
commit 32b9d0bf8a
5 changed files with 51 additions and 51 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
jOOQ-kotlin/src/main/kotlin/org/jooq/kotlin/Extensions.kt
View File

@ -2,6 +2,7 @@ package org.jooq.kotlin
import org.jetbrains.annotations.Blocking
import org.jooq.*
import org.jooq.SQLDialect.*
import org.jooq.conf.*
import org.jooq.impl.DSL.*
import org.jooq.migrations.xml.jaxb.*
@ -304,6 +305,21 @@ operator fun <T> Field<Array<T>?>.get(index: Int) = arrayGet(this, index)
@Support
operator fun <T> Field<Array<T>?>.get(index: Field<Int?>) = arrayGet(this, index)
@Support
fun <T> Field<Array<T>?>.filter(predicate: (Field<T>) -> Condition) = arrayFilter(this, predicate)
@Support
fun <T, U> Field<Array<T>?>.map(mapper: (Field<T>) -> Field<U>) = arrayMap(this, mapper)
@Support
fun <T> Field<Array<T>?>.allMatch(predicate: (Field<T>) -> Condition) = arrayAllMatch(this, predicate)
@Support
fun <T> Field<Array<T>?>.anyMatch(predicate: (Field<T>) -> Condition) = arrayAnyMatch(this, predicate)
@Support
fun <T> Field<Array<T>?>.noneMatch(predicate: (Field<T>) -> Condition) = arrayNoneMatch(this, predicate)
// ----------------------------------------------------------------------------
// Extensions to make Field<JSON> and Field<JSONB> aware of its being JSON
// ----------------------------------------------------------------------------

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

@ -65,7 +65,7 @@ import java.util.stream.*;
@SuppressWarnings({ "rawtypes", "unchecked", "unused" })
final class ArrayMap<T, U>
extends
AbstractField<T[]>
AbstractField<U[]>
implements
QOM.ArrayMap<T, U>
{

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

@ -22471,7 +22471,7 @@ public class DSL {
*/
@NotNull
@Support({ CLICKHOUSE, DUCKDB, H2, HSQLDB, POSTGRES, TRINO, YUGABYTEDB })
public static <T, U> Field<T[]> arrayMap(T[] array, Function1<? super Field<T>, ? extends Field<U>> mapper) {
public static <T, U> Field<U[]> arrayMap(T[] array, Function1<? super Field<T>, ? extends Field<U>> mapper) {
return new ArrayMap<>(Tools.field(array), DSL.lambda(array, mapper));
}
@ -22482,7 +22482,7 @@ public class DSL {
*/
@NotNull
@Support({ CLICKHOUSE, DUCKDB, H2, HSQLDB, POSTGRES, TRINO, YUGABYTEDB })
public static <T, U> Field<T[]> arrayMap(T[] array, Lambda1<Field<T>, Field<U>> mapper) {
public static <T, U> Field<U[]> arrayMap(T[] array, Lambda1<Field<T>, Field<U>> mapper) {
return new ArrayMap<>(Tools.field(array), mapper);
}
@ -22493,7 +22493,7 @@ public class DSL {
*/
@NotNull
@Support({ CLICKHOUSE, DUCKDB, H2, HSQLDB, POSTGRES, TRINO, YUGABYTEDB })
public static <T, U> Field<T[]> arrayMap(Field<T[]> array, Function1<? super Field<T>, ? extends Field<U>> mapper) {
public static <T, U> Field<U[]> arrayMap(Field<T[]> array, Function1<? super Field<T>, ? extends Field<U>> mapper) {
return new ArrayMap<>(array, DSL.lambda(array, mapper));
}
@ -22504,7 +22504,7 @@ public class DSL {
*/
@NotNull
@Support({ CLICKHOUSE, DUCKDB, H2, HSQLDB, POSTGRES, TRINO, YUGABYTEDB })
public static <T, U> Field<T[]> arrayMap(Field<T[]> array, Lambda1<Field<T>, Field<U>> mapper) {
public static <T, U> Field<U[]> arrayMap(Field<T[]> array, Lambda1<Field<T>, Field<U>> mapper) {
return new ArrayMap<>(array, mapper);
}

74
jOOQ/src/main/java/org/jooq/impl/ParserImpl.java
View File

@ -8748,10 +8748,18 @@ final class DefaultParseContext extends AbstractScope implements ParseContext {
return parseFunctionArgs2((f1, f2) -> arrayConcat(f1, f2));
else if (parseFunctionNameIf("ARRAY_GET", "arrayElement"))
return parseFunctionArgs2((f1, f2) -> arrayGet(f1, f2));
else if ((field = parseFieldArrayFilterIf()) != null)
return field;
else if ((field = parseFieldArrayMapIf()) != null)
return field;
else if (parseFunctionNameIf("ARRAY_FILTER", "arrayFilter"))
return parseArrayLambdaFunction(DSL::arrayFilter);
else if (parseFunctionNameIf("ARRAY_MAP", "arrayMap", "ARRAY_TRANSFORM"))
return parseArrayLambdaFunction(DSL::arrayMap);
else if (parseFunctionNameIf("ARRAY_ALL_MATCH", "arrayAll", "ALL_MATCH"))
return parseArrayLambdaFunction(DSL::arrayAllMatch);
else if (parseFunctionNameIf("ARRAY_ANY_MATCH", "arrayExists", "ANY_MATCH"))
return parseArrayLambdaFunction(DSL::arrayAnyMatch);
else if (parseFunctionNameIf("ARRAY_NONE_MATCH"))
return parseArrayLambdaFunction(DSL::arrayNoneMatch);
else if (parseFunctionNameIf("ARRAY_MAP", "arrayMap", "ARRAY_TRANSFORM"))
return parseArrayLambdaFunction(DSL::arrayMap);
else if (parseFunctionNameIf("ARRAY_OVERLAP", "ARRAYS_OVERLAP"))
return parseFunctionArgs2((f1, f2) -> arrayOverlap((Field<Void[]>) f1, (Field<Void[]>) f2));
else if (parseFunctionNameIf("ARRAY_PREPEND"))
@ -9199,6 +9207,8 @@ final class DefaultParseContext extends AbstractScope implements ParseContext {
}
else if (parseFunctionNameIf("NEG", "NEGATE"))
return parseFunctionArgs1(DSL::neg);
else if (parseFunctionNameIf("NONE_MATCH"))
return parseArrayLambdaFunction(DSL::arrayNoneMatch);
break;
@ -9561,8 +9571,8 @@ final class DefaultParseContext extends AbstractScope implements ParseContext {
return field;
else if ((field = parseFieldCastIf()) != null)
return field;
else if ((field = parseFieldArrayMapIf()) != null)
return field;
else if (parseFunctionNameIf("TRANSFORM"))
return parseArrayLambdaFunction(DSL::arrayMap);
break;
@ -10417,26 +10427,22 @@ final class DefaultParseContext extends AbstractScope implements ParseContext {
return null;
}
private final Field<?> parseFieldArrayFilterIf() {
if (parseFunctionNameIf("ARRAY_FILTER", "arrayFilter")) {
parse('(');
Field f;
Lambda1 l = parseLambdaIf(c -> c.parseCondition());
private final Field<?> parseArrayLambdaFunction(Function2<Field, Lambda1, Field> function) {
parse('(');
Field f;
Lambda1 l = parseLambdaIf(c -> c.parseField());
if (l != null && parse(',')) {
f = parseField();
}
else {
f = parseField();
parse(',');
l = parseLambda(c -> c.parseCondition());
}
parse(')');
return arrayFilter(f, l);
if (l != null && parse(',')) {
f = parseField();
}
else {
f = parseField();
parse(',');
l = parseLambda(c -> c.parseField());
}
return null;
parse(')');
return function.apply(f, l);
}
private final Lambda1<?, ?> parseLambda(Function<? super ParseContext, ? extends Field<?>> field) {
@ -10460,28 +10466,6 @@ final class DefaultParseContext extends AbstractScope implements ParseContext {
return null;
}
private final Field<?> parseFieldArrayMapIf() {
if (parseFunctionNameIf("ARRAY_MAP", "arrayMap", "ARRAY_TRANSFORM", "TRANSFORM")) {
parse('(');
Field f;
Lambda1 l = parseLambdaIf(c -> c.parseField());
if (l != null && parse(',')) {
f = parseField();
}
else {
f = parseField();
parse(',');
l = parseLambda(c -> c.parseField());
}
parse(')');
return arrayMap(f, l);
}
return null;
}
private final Field<?> parseFieldArrayConstructIf() {
boolean absentOnNull = false;

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

@ -6360,7 +6360,7 @@ public final class QOM {
public /*sealed*/ interface ArrayMap<T, U>
extends
UOperator2<Field<T[]>, Lambda1<Field<T>, Field<U>>, ArrayMap<T, U>>,
org.jooq.Field<T[]>
org.jooq.Field<U[]>
//permits
// ArrayMap
{