LIST support should be emulated.
- *
- */
- public NestedCollectionEmulation getEmulateList() {
- return emulateList;
- }
-
- /**
- * [#3884] Whether LIST support should be emulated.
- *
- */
- public void setEmulateList(NestedCollectionEmulation value) {
- this.emulateList = value;
- }
-
- /**
- * [#3884] Whether MULTISET support should be emulated.
+ * [#3884] How MULTISET support should be emulated.
*
*/
public NestedCollectionEmulation getEmulateMultiset() {
@@ -2305,29 +2283,13 @@ public class Settings
}
/**
- * [#3884] Whether MULTISET support should be emulated.
+ * [#3884] How MULTISET support should be emulated.
*
*/
public void setEmulateMultiset(NestedCollectionEmulation value) {
this.emulateMultiset = value;
}
- /**
- * [#3884] Whether SET support should be emulated.
- *
- */
- public NestedCollectionEmulation getEmulateSet() {
- return emulateSet;
- }
-
- /**
- * [#3884] Whether SET support should be emulated.
- *
- */
- public void setEmulateSet(NestedCollectionEmulation value) {
- this.emulateSet = value;
- }
-
/**
* [#6771] Specifies whether UPDATE statements are allowed to be executed lacking a WHERE clause. This has no effect on rendering the statements SQL string.
*
@@ -3676,16 +3638,7 @@ public class Settings
}
/**
- * [#3884] Whether LIST support should be emulated.
- *
- */
- public Settings withEmulateList(NestedCollectionEmulation value) {
- setEmulateList(value);
- return this;
- }
-
- /**
- * [#3884] Whether MULTISET support should be emulated.
+ * [#3884] How MULTISET support should be emulated.
*
*/
public Settings withEmulateMultiset(NestedCollectionEmulation value) {
@@ -3693,15 +3646,6 @@ public class Settings
return this;
}
- /**
- * [#3884] Whether SET support should be emulated.
- *
- */
- public Settings withEmulateSet(NestedCollectionEmulation value) {
- setEmulateSet(value);
- return this;
- }
-
/**
* [#6771] Specifies whether UPDATE statements are allowed to be executed lacking a WHERE clause. This has no effect on rendering the statements SQL string.
*
@@ -4090,9 +4034,7 @@ public class Settings
builder.append("inListPadBase", inListPadBase);
builder.append("delimiter", delimiter);
builder.append("emulateOnDuplicateKeyUpdateOnPrimaryKeyOnly", emulateOnDuplicateKeyUpdateOnPrimaryKeyOnly);
- builder.append("emulateList", emulateList);
builder.append("emulateMultiset", emulateMultiset);
- builder.append("emulateSet", emulateSet);
builder.append("executeUpdateWithoutWhere", executeUpdateWithoutWhere);
builder.append("executeDeleteWithoutWhere", executeDeleteWithoutWhere);
builder.append("interpreterDialect", interpreterDialect);
@@ -4921,15 +4863,6 @@ public class Settings
return false;
}
}
- if (emulateList == null) {
- if (other.emulateList!= null) {
- return false;
- }
- } else {
- if (!emulateList.equals(other.emulateList)) {
- return false;
- }
- }
if (emulateMultiset == null) {
if (other.emulateMultiset!= null) {
return false;
@@ -4939,15 +4872,6 @@ public class Settings
return false;
}
}
- if (emulateSet == null) {
- if (other.emulateSet!= null) {
- return false;
- }
- } else {
- if (!emulateSet.equals(other.emulateSet)) {
- return false;
- }
- }
if (executeUpdateWithoutWhere == null) {
if (other.executeUpdateWithoutWhere!= null) {
return false;
@@ -5338,9 +5262,7 @@ public class Settings
result = ((prime*result)+((inListPadBase == null)? 0 :inListPadBase.hashCode()));
result = ((prime*result)+((delimiter == null)? 0 :delimiter.hashCode()));
result = ((prime*result)+((emulateOnDuplicateKeyUpdateOnPrimaryKeyOnly == null)? 0 :emulateOnDuplicateKeyUpdateOnPrimaryKeyOnly.hashCode()));
- result = ((prime*result)+((emulateList == null)? 0 :emulateList.hashCode()));
result = ((prime*result)+((emulateMultiset == null)? 0 :emulateMultiset.hashCode()));
- result = ((prime*result)+((emulateSet == null)? 0 :emulateSet.hashCode()));
result = ((prime*result)+((executeUpdateWithoutWhere == null)? 0 :executeUpdateWithoutWhere.hashCode()));
result = ((prime*result)+((executeDeleteWithoutWhere == null)? 0 :executeDeleteWithoutWhere.hashCode()));
result = ((prime*result)+((interpreterDialect == null)? 0 :interpreterDialect.hashCode()));
diff --git a/jOOQ/src/main/java/org/jooq/impl/AbstractAggregateFunction.java b/jOOQ/src/main/java/org/jooq/impl/AbstractAggregateFunction.java
index 712dead3df..5f09cdd810 100644
--- a/jOOQ/src/main/java/org/jooq/impl/AbstractAggregateFunction.java
+++ b/jOOQ/src/main/java/org/jooq/impl/AbstractAggregateFunction.java
@@ -60,6 +60,7 @@ import static org.jooq.impl.QueryPartCollectionView.wrap;
import static org.jooq.impl.SQLDataType.DOUBLE;
import static org.jooq.impl.SQLDataType.NUMERIC;
import static org.jooq.impl.Tools.camelCase;
+import static org.jooq.impl.Tools.isEmpty;
import java.util.Arrays;
import java.util.Collection;
@@ -369,6 +370,15 @@ implements
return DSL.nullif(fo(function), (Field) zero());
}
+ /**
+ * Apply this aggregate function's ORDER BY,
+ * FILTER and OVER clauses to an argument
+ * aggregate function.
+ */
+ final Field ofo(AbstractAggregateFunction function) {
+ return fo(isEmpty(withinGroupOrderBy) ? function : function.orderBy(withinGroupOrderBy));
+ }
+
/**
* Apply this aggregate function's FILTER and OVER
* clauses to an argument aggregate function.
diff --git a/jOOQ/src/main/java/org/jooq/impl/ArrayAgg.java b/jOOQ/src/main/java/org/jooq/impl/ArrayAgg.java
index 5bb2c98f77..576ed84664 100644
--- a/jOOQ/src/main/java/org/jooq/impl/ArrayAgg.java
+++ b/jOOQ/src/main/java/org/jooq/impl/ArrayAgg.java
@@ -37,7 +37,6 @@
*/
package org.jooq.impl;
-// ...
import static org.jooq.impl.Names.N_ARRAY_AGG;
import org.jooq.Context;
diff --git a/jOOQ/src/main/java/org/jooq/impl/DSL.java b/jOOQ/src/main/java/org/jooq/impl/DSL.java
index 3bc47a19f6..a65f9a03f4 100644
--- a/jOOQ/src/main/java/org/jooq/impl/DSL.java
+++ b/jOOQ/src/main/java/org/jooq/impl/DSL.java
@@ -23683,6 +23683,9 @@ public class DSL {
* transparently.
*
* + * The emulation to be chosen is governed by + * {@link Settings#getEmulateMultiset()}. + *
* A set of known limitations can be found here: https://github.com/jOOQ/jOOQ/issues/12021.
* An important known limitation is that predicates based on
@@ -23878,6 +23881,1306 @@ public class DSL {
return new ArrayAgg(true, Tools.nullSafe(field));
}
+ /**
+ * Get the
+ * EXPERIMENTAL: This synthetic, non-standard aggregate function works in a
+ * similar way as the standard SQL
+ *
+ * The emulation to be chosen is governed by
+ * {@link Settings#getEmulateMultiset()}.
+ *
+ *
+ * A set of known limitations can be found here: https://github.com/jOOQ/jOOQ/issues/12021.
+ * An important known limitation is that predicates based on
+ * MULTISETs expose undefined behaviour: Either they don't work
+ * (uncomparable types, such as XML), or they will compare JSON/XML document
+ * structures where ordinals matter. Please do not rely on the current
+ * comparison behaviour.
+ *
+ * Please report any issues you may encounter on the above issue, or in a
+ * new issue on github.
+ */
+ @NotNull
+ @Support({ H2, HSQLDB, MARIADB, MYSQL, POSTGRES })
+ public static ArrayAggOrderByStep
+ * EXPERIMENTAL: This synthetic, non-standard aggregate function works in a
+ * similar way as the standard SQL
+ *
+ * The emulation to be chosen is governed by
+ * {@link Settings#getEmulateMultiset()}.
+ *
+ *
+ * A set of known limitations can be found here: https://github.com/jOOQ/jOOQ/issues/12021.
+ * An important known limitation is that predicates based on
+ * MULTISETs expose undefined behaviour: Either they don't work
+ * (uncomparable types, such as XML), or they will compare JSON/XML document
+ * structures where ordinals matter. Please do not rely on the current
+ * comparison behaviour.
+ *
+ * Please report any issues you may encounter on the above issue, or in a
+ * new issue on github.
+ */
+ @NotNull
+ @Support({ H2, HSQLDB, MARIADB, MYSQL, POSTGRES })
+ public static ArrayAggOrderByStep
+ * EXPERIMENTAL: This synthetic, non-standard aggregate function works in a
+ * similar way as the standard SQL
+ *
+ * The emulation to be chosen is governed by
+ * {@link Settings#getEmulateMultiset()}.
+ *
+ *
+ * A set of known limitations can be found here: https://github.com/jOOQ/jOOQ/issues/12021.
+ * An important known limitation is that predicates based on
+ * MULTISETs expose undefined behaviour: Either they don't work
+ * (uncomparable types, such as XML), or they will compare JSON/XML document
+ * structures where ordinals matter. Please do not rely on the current
+ * comparison behaviour.
+ *
+ * Please report any issues you may encounter on the above issue, or in a
+ * new issue on github.
+ */
+ @NotNull
+ @Support({ H2, HSQLDB, MARIADB, MYSQL, POSTGRES })
+ public static
+ * EXPERIMENTAL: This synthetic, non-standard aggregate function works in a
+ * similar way as the standard SQL
+ *
+ * The emulation to be chosen is governed by
+ * {@link Settings#getEmulateMultiset()}.
+ *
+ *
+ * A set of known limitations can be found here: https://github.com/jOOQ/jOOQ/issues/12021.
+ * An important known limitation is that predicates based on
+ * MULTISETs expose undefined behaviour: Either they don't work
+ * (uncomparable types, such as XML), or they will compare JSON/XML document
+ * structures where ordinals matter. Please do not rely on the current
+ * comparison behaviour.
+ *
+ * Please report any issues you may encounter on the above issue, or in a
+ * new issue on github.
+ */
+ @NotNull
+ @Support({ H2, HSQLDB, MARIADB, MYSQL, POSTGRES })
+ public static
+ * EXPERIMENTAL: This synthetic, non-standard aggregate function works in a
+ * similar way as the standard SQL
+ *
+ * The emulation to be chosen is governed by
+ * {@link Settings#getEmulateMultiset()}.
+ *
+ *
+ * A set of known limitations can be found here: https://github.com/jOOQ/jOOQ/issues/12021.
+ * An important known limitation is that predicates based on
+ * MULTISETs expose undefined behaviour: Either they don't work
+ * (uncomparable types, such as XML), or they will compare JSON/XML document
+ * structures where ordinals matter. Please do not rely on the current
+ * comparison behaviour.
+ *
+ * Please report any issues you may encounter on the above issue, or in a
+ * new issue on github.
+ */
+ @NotNull
+ @Support({ H2, HSQLDB, MARIADB, MYSQL, POSTGRES })
+ public static
+ * EXPERIMENTAL: This synthetic, non-standard aggregate function works in a
+ * similar way as the standard SQL
+ *
+ * The emulation to be chosen is governed by
+ * {@link Settings#getEmulateMultiset()}.
+ *
+ *
+ * A set of known limitations can be found here: https://github.com/jOOQ/jOOQ/issues/12021.
+ * An important known limitation is that predicates based on
+ * MULTISETs expose undefined behaviour: Either they don't work
+ * (uncomparable types, such as XML), or they will compare JSON/XML document
+ * structures where ordinals matter. Please do not rely on the current
+ * comparison behaviour.
+ *
+ * Please report any issues you may encounter on the above issue, or in a
+ * new issue on github.
+ */
+ @NotNull
+ @Support({ H2, HSQLDB, MARIADB, MYSQL, POSTGRES })
+ public static
+ * EXPERIMENTAL: This synthetic, non-standard aggregate function works in a
+ * similar way as the standard SQL
+ *
+ * The emulation to be chosen is governed by
+ * {@link Settings#getEmulateMultiset()}.
+ *
+ *
+ * A set of known limitations can be found here: https://github.com/jOOQ/jOOQ/issues/12021.
+ * An important known limitation is that predicates based on
+ * MULTISETs expose undefined behaviour: Either they don't work
+ * (uncomparable types, such as XML), or they will compare JSON/XML document
+ * structures where ordinals matter. Please do not rely on the current
+ * comparison behaviour.
+ *
+ * Please report any issues you may encounter on the above issue, or in a
+ * new issue on github.
+ */
+ @NotNull
+ @Support({ H2, HSQLDB, MARIADB, MYSQL, POSTGRES })
+ public static
+ * EXPERIMENTAL: This synthetic, non-standard aggregate function works in a
+ * similar way as the standard SQL
+ *
+ * The emulation to be chosen is governed by
+ * {@link Settings#getEmulateMultiset()}.
+ *
+ *
+ * A set of known limitations can be found here: https://github.com/jOOQ/jOOQ/issues/12021.
+ * An important known limitation is that predicates based on
+ * MULTISETs expose undefined behaviour: Either they don't work
+ * (uncomparable types, such as XML), or they will compare JSON/XML document
+ * structures where ordinals matter. Please do not rely on the current
+ * comparison behaviour.
+ *
+ * Please report any issues you may encounter on the above issue, or in a
+ * new issue on github.
+ */
+ @NotNull
+ @Support({ H2, HSQLDB, MARIADB, MYSQL, POSTGRES })
+ public static
+ * EXPERIMENTAL: This synthetic, non-standard aggregate function works in a
+ * similar way as the standard SQL
+ *
+ * The emulation to be chosen is governed by
+ * {@link Settings#getEmulateMultiset()}.
+ *
+ *
+ * A set of known limitations can be found here: https://github.com/jOOQ/jOOQ/issues/12021.
+ * An important known limitation is that predicates based on
+ * MULTISETs expose undefined behaviour: Either they don't work
+ * (uncomparable types, such as XML), or they will compare JSON/XML document
+ * structures where ordinals matter. Please do not rely on the current
+ * comparison behaviour.
+ *
+ * Please report any issues you may encounter on the above issue, or in a
+ * new issue on github.
+ */
+ @NotNull
+ @Support({ H2, HSQLDB, MARIADB, MYSQL, POSTGRES })
+ public static
+ * EXPERIMENTAL: This synthetic, non-standard aggregate function works in a
+ * similar way as the standard SQL
+ *
+ * The emulation to be chosen is governed by
+ * {@link Settings#getEmulateMultiset()}.
+ *
+ *
+ * A set of known limitations can be found here: https://github.com/jOOQ/jOOQ/issues/12021.
+ * An important known limitation is that predicates based on
+ * MULTISETs expose undefined behaviour: Either they don't work
+ * (uncomparable types, such as XML), or they will compare JSON/XML document
+ * structures where ordinals matter. Please do not rely on the current
+ * comparison behaviour.
+ *
+ * Please report any issues you may encounter on the above issue, or in a
+ * new issue on github.
+ */
+ @NotNull
+ @Support({ H2, HSQLDB, MARIADB, MYSQL, POSTGRES })
+ public static
+ * EXPERIMENTAL: This synthetic, non-standard aggregate function works in a
+ * similar way as the standard SQL
+ *
+ * The emulation to be chosen is governed by
+ * {@link Settings#getEmulateMultiset()}.
+ *
+ *
+ * A set of known limitations can be found here: https://github.com/jOOQ/jOOQ/issues/12021.
+ * An important known limitation is that predicates based on
+ * MULTISETs expose undefined behaviour: Either they don't work
+ * (uncomparable types, such as XML), or they will compare JSON/XML document
+ * structures where ordinals matter. Please do not rely on the current
+ * comparison behaviour.
+ *
+ * Please report any issues you may encounter on the above issue, or in a
+ * new issue on github.
+ */
+ @NotNull
+ @Support({ H2, HSQLDB, MARIADB, MYSQL, POSTGRES })
+ public static
+ * EXPERIMENTAL: This synthetic, non-standard aggregate function works in a
+ * similar way as the standard SQL
+ *
+ * The emulation to be chosen is governed by
+ * {@link Settings#getEmulateMultiset()}.
+ *
+ *
+ * A set of known limitations can be found here: https://github.com/jOOQ/jOOQ/issues/12021.
+ * An important known limitation is that predicates based on
+ * MULTISETs expose undefined behaviour: Either they don't work
+ * (uncomparable types, such as XML), or they will compare JSON/XML document
+ * structures where ordinals matter. Please do not rely on the current
+ * comparison behaviour.
+ *
+ * Please report any issues you may encounter on the above issue, or in a
+ * new issue on github.
+ */
+ @NotNull
+ @Support({ H2, HSQLDB, MARIADB, MYSQL, POSTGRES })
+ public static
+ * EXPERIMENTAL: This synthetic, non-standard aggregate function works in a
+ * similar way as the standard SQL
+ *
+ * The emulation to be chosen is governed by
+ * {@link Settings#getEmulateMultiset()}.
+ *
+ *
+ * A set of known limitations can be found here: https://github.com/jOOQ/jOOQ/issues/12021.
+ * An important known limitation is that predicates based on
+ * MULTISETs expose undefined behaviour: Either they don't work
+ * (uncomparable types, such as XML), or they will compare JSON/XML document
+ * structures where ordinals matter. Please do not rely on the current
+ * comparison behaviour.
+ *
+ * Please report any issues you may encounter on the above issue, or in a
+ * new issue on github.
+ */
+ @NotNull
+ @Support({ H2, HSQLDB, MARIADB, MYSQL, POSTGRES })
+ public static
+ * EXPERIMENTAL: This synthetic, non-standard aggregate function works in a
+ * similar way as the standard SQL
+ *
+ * The emulation to be chosen is governed by
+ * {@link Settings#getEmulateMultiset()}.
+ *
+ *
+ * A set of known limitations can be found here: https://github.com/jOOQ/jOOQ/issues/12021.
+ * An important known limitation is that predicates based on
+ * MULTISETs expose undefined behaviour: Either they don't work
+ * (uncomparable types, such as XML), or they will compare JSON/XML document
+ * structures where ordinals matter. Please do not rely on the current
+ * comparison behaviour.
+ *
+ * Please report any issues you may encounter on the above issue, or in a
+ * new issue on github.
+ */
+ @NotNull
+ @Support({ H2, HSQLDB, MARIADB, MYSQL, POSTGRES })
+ public static
+ * EXPERIMENTAL: This synthetic, non-standard aggregate function works in a
+ * similar way as the standard SQL
+ *
+ * The emulation to be chosen is governed by
+ * {@link Settings#getEmulateMultiset()}.
+ *
+ *
+ * A set of known limitations can be found here: https://github.com/jOOQ/jOOQ/issues/12021.
+ * An important known limitation is that predicates based on
+ * MULTISETs expose undefined behaviour: Either they don't work
+ * (uncomparable types, such as XML), or they will compare JSON/XML document
+ * structures where ordinals matter. Please do not rely on the current
+ * comparison behaviour.
+ *
+ * Please report any issues you may encounter on the above issue, or in a
+ * new issue on github.
+ */
+ @NotNull
+ @Support({ H2, HSQLDB, MARIADB, MYSQL, POSTGRES })
+ public static
+ * EXPERIMENTAL: This synthetic, non-standard aggregate function works in a
+ * similar way as the standard SQL
+ *
+ * The emulation to be chosen is governed by
+ * {@link Settings#getEmulateMultiset()}.
+ *
+ *
+ * A set of known limitations can be found here: https://github.com/jOOQ/jOOQ/issues/12021.
+ * An important known limitation is that predicates based on
+ * MULTISETs expose undefined behaviour: Either they don't work
+ * (uncomparable types, such as XML), or they will compare JSON/XML document
+ * structures where ordinals matter. Please do not rely on the current
+ * comparison behaviour.
+ *
+ * Please report any issues you may encounter on the above issue, or in a
+ * new issue on github.
+ */
+ @NotNull
+ @Support({ H2, HSQLDB, MARIADB, MYSQL, POSTGRES })
+ public static
+ * EXPERIMENTAL: This synthetic, non-standard aggregate function works in a
+ * similar way as the standard SQL
+ *
+ * The emulation to be chosen is governed by
+ * {@link Settings#getEmulateMultiset()}.
+ *
+ *
+ * A set of known limitations can be found here: https://github.com/jOOQ/jOOQ/issues/12021.
+ * An important known limitation is that predicates based on
+ * MULTISETs expose undefined behaviour: Either they don't work
+ * (uncomparable types, such as XML), or they will compare JSON/XML document
+ * structures where ordinals matter. Please do not rely on the current
+ * comparison behaviour.
+ *
+ * Please report any issues you may encounter on the above issue, or in a
+ * new issue on github.
+ */
+ @NotNull
+ @Support({ H2, HSQLDB, MARIADB, MYSQL, POSTGRES })
+ public static
+ * EXPERIMENTAL: This synthetic, non-standard aggregate function works in a
+ * similar way as the standard SQL
+ *
+ * The emulation to be chosen is governed by
+ * {@link Settings#getEmulateMultiset()}.
+ *
+ *
+ * A set of known limitations can be found here: https://github.com/jOOQ/jOOQ/issues/12021.
+ * An important known limitation is that predicates based on
+ * MULTISETs expose undefined behaviour: Either they don't work
+ * (uncomparable types, such as XML), or they will compare JSON/XML document
+ * structures where ordinals matter. Please do not rely on the current
+ * comparison behaviour.
+ *
+ * Please report any issues you may encounter on the above issue, or in a
+ * new issue on github.
+ */
+ @NotNull
+ @Support({ H2, HSQLDB, MARIADB, MYSQL, POSTGRES })
+ public static
+ * EXPERIMENTAL: This synthetic, non-standard aggregate function works in a
+ * similar way as the standard SQL
+ *
+ * The emulation to be chosen is governed by
+ * {@link Settings#getEmulateMultiset()}.
+ *
+ *
+ * A set of known limitations can be found here: https://github.com/jOOQ/jOOQ/issues/12021.
+ * An important known limitation is that predicates based on
+ * MULTISETs expose undefined behaviour: Either they don't work
+ * (uncomparable types, such as XML), or they will compare JSON/XML document
+ * structures where ordinals matter. Please do not rely on the current
+ * comparison behaviour.
+ *
+ * Please report any issues you may encounter on the above issue, or in a
+ * new issue on github.
+ */
+ @NotNull
+ @Support({ H2, HSQLDB, MARIADB, MYSQL, POSTGRES })
+ public static
+ * EXPERIMENTAL: This synthetic, non-standard aggregate function works in a
+ * similar way as the standard SQL
+ *
+ * The emulation to be chosen is governed by
+ * {@link Settings#getEmulateMultiset()}.
+ *
+ *
+ * A set of known limitations can be found here: https://github.com/jOOQ/jOOQ/issues/12021.
+ * An important known limitation is that predicates based on
+ * MULTISETs expose undefined behaviour: Either they don't work
+ * (uncomparable types, such as XML), or they will compare JSON/XML document
+ * structures where ordinals matter. Please do not rely on the current
+ * comparison behaviour.
+ *
+ * Please report any issues you may encounter on the above issue, or in a
+ * new issue on github.
+ */
+ @NotNull
+ @Support({ H2, HSQLDB, MARIADB, MYSQL, POSTGRES })
+ public static
+ * EXPERIMENTAL: This synthetic, non-standard aggregate function works in a
+ * similar way as the standard SQL
+ *
+ * The emulation to be chosen is governed by
+ * {@link Settings#getEmulateMultiset()}.
+ *
+ *
+ * A set of known limitations can be found here: https://github.com/jOOQ/jOOQ/issues/12021.
+ * An important known limitation is that predicates based on
+ * MULTISETs expose undefined behaviour: Either they don't work
+ * (uncomparable types, such as XML), or they will compare JSON/XML document
+ * structures where ordinals matter. Please do not rely on the current
+ * comparison behaviour.
+ *
+ * Please report any issues you may encounter on the above issue, or in a
+ * new issue on github.
+ */
+ @NotNull
+ @Support({ H2, HSQLDB, MARIADB, MYSQL, POSTGRES })
+ public static
+ * EXPERIMENTAL: This synthetic, non-standard aggregate function works in a
+ * similar way as the standard SQL MULTISET_AGG aggregate function to nest group
+ * contents.
+ * ARRAY_AGG aggregate
+ * function. It is emulated using mappings to any of:
+ *
+ *
+ * JSON,
+ * but we're using {@link #jsonbArrayAgg(Field)} and
+ * {@link #jsonbObject(Field...)}, or {@link SelectForStep#forJSONB()}.MULTISET_AGG aggregate function to nest group
+ * contents.
+ * ARRAY_AGG aggregate
+ * function. It is emulated using mappings to any of:
+ *
+ *
+ * JSON,
+ * but we're using {@link #jsonbArrayAgg(Field)} and
+ * {@link #jsonbObject(Field...)}, or {@link SelectForStep#forJSONB()}.MULTISET_AGG aggregate function to nest group
+ * contents.
+ * ARRAY_AGG aggregate
+ * function. It is emulated using mappings to any of:
+ *
+ *
+ * JSON,
+ * but we're using {@link #jsonbArrayAgg(Field)} and
+ * {@link #jsonbObject(Field...)}, or {@link SelectForStep#forJSONB()}.MULTISET_AGG aggregate function to nest group
+ * contents.
+ * ARRAY_AGG aggregate
+ * function. It is emulated using mappings to any of:
+ *
+ *
+ * JSON,
+ * but we're using {@link #jsonbArrayAgg(Field)} and
+ * {@link #jsonbObject(Field...)}, or {@link SelectForStep#forJSONB()}.MULTISET_AGG aggregate function to nest group
+ * contents.
+ * ARRAY_AGG aggregate
+ * function. It is emulated using mappings to any of:
+ *
+ *
+ * JSON,
+ * but we're using {@link #jsonbArrayAgg(Field)} and
+ * {@link #jsonbObject(Field...)}, or {@link SelectForStep#forJSONB()}.MULTISET_AGG aggregate function to nest group
+ * contents.
+ * ARRAY_AGG aggregate
+ * function. It is emulated using mappings to any of:
+ *
+ *
+ * JSON,
+ * but we're using {@link #jsonbArrayAgg(Field)} and
+ * {@link #jsonbObject(Field...)}, or {@link SelectForStep#forJSONB()}.MULTISET_AGG aggregate function to nest group
+ * contents.
+ * ARRAY_AGG aggregate
+ * function. It is emulated using mappings to any of:
+ *
+ *
+ * JSON,
+ * but we're using {@link #jsonbArrayAgg(Field)} and
+ * {@link #jsonbObject(Field...)}, or {@link SelectForStep#forJSONB()}.MULTISET_AGG aggregate function to nest group
+ * contents.
+ * ARRAY_AGG aggregate
+ * function. It is emulated using mappings to any of:
+ *
+ *
+ * JSON,
+ * but we're using {@link #jsonbArrayAgg(Field)} and
+ * {@link #jsonbObject(Field...)}, or {@link SelectForStep#forJSONB()}.MULTISET_AGG aggregate function to nest group
+ * contents.
+ * ARRAY_AGG aggregate
+ * function. It is emulated using mappings to any of:
+ *
+ *
+ * JSON,
+ * but we're using {@link #jsonbArrayAgg(Field)} and
+ * {@link #jsonbObject(Field...)}, or {@link SelectForStep#forJSONB()}.MULTISET_AGG aggregate function to nest group
+ * contents.
+ * ARRAY_AGG aggregate
+ * function. It is emulated using mappings to any of:
+ *
+ *
+ * JSON,
+ * but we're using {@link #jsonbArrayAgg(Field)} and
+ * {@link #jsonbObject(Field...)}, or {@link SelectForStep#forJSONB()}.MULTISET_AGG aggregate function to nest group
+ * contents.
+ * ARRAY_AGG aggregate
+ * function. It is emulated using mappings to any of:
+ *
+ *
+ * JSON,
+ * but we're using {@link #jsonbArrayAgg(Field)} and
+ * {@link #jsonbObject(Field...)}, or {@link SelectForStep#forJSONB()}.MULTISET_AGG aggregate function to nest group
+ * contents.
+ * ARRAY_AGG aggregate
+ * function. It is emulated using mappings to any of:
+ *
+ *
+ * JSON,
+ * but we're using {@link #jsonbArrayAgg(Field)} and
+ * {@link #jsonbObject(Field...)}, or {@link SelectForStep#forJSONB()}.MULTISET_AGG aggregate function to nest group
+ * contents.
+ * ARRAY_AGG aggregate
+ * function. It is emulated using mappings to any of:
+ *
+ *
+ * JSON,
+ * but we're using {@link #jsonbArrayAgg(Field)} and
+ * {@link #jsonbObject(Field...)}, or {@link SelectForStep#forJSONB()}.MULTISET_AGG aggregate function to nest group
+ * contents.
+ * ARRAY_AGG aggregate
+ * function. It is emulated using mappings to any of:
+ *
+ *
+ * JSON,
+ * but we're using {@link #jsonbArrayAgg(Field)} and
+ * {@link #jsonbObject(Field...)}, or {@link SelectForStep#forJSONB()}.MULTISET_AGG aggregate function to nest group
+ * contents.
+ * ARRAY_AGG aggregate
+ * function. It is emulated using mappings to any of:
+ *
+ *
+ * JSON,
+ * but we're using {@link #jsonbArrayAgg(Field)} and
+ * {@link #jsonbObject(Field...)}, or {@link SelectForStep#forJSONB()}.MULTISET_AGG aggregate function to nest group
+ * contents.
+ * ARRAY_AGG aggregate
+ * function. It is emulated using mappings to any of:
+ *
+ *
+ * JSON,
+ * but we're using {@link #jsonbArrayAgg(Field)} and
+ * {@link #jsonbObject(Field...)}, or {@link SelectForStep#forJSONB()}.MULTISET_AGG aggregate function to nest group
+ * contents.
+ * ARRAY_AGG aggregate
+ * function. It is emulated using mappings to any of:
+ *
+ *
+ * JSON,
+ * but we're using {@link #jsonbArrayAgg(Field)} and
+ * {@link #jsonbObject(Field...)}, or {@link SelectForStep#forJSONB()}.MULTISET_AGG aggregate function to nest group
+ * contents.
+ * ARRAY_AGG aggregate
+ * function. It is emulated using mappings to any of:
+ *
+ *
+ * JSON,
+ * but we're using {@link #jsonbArrayAgg(Field)} and
+ * {@link #jsonbObject(Field...)}, or {@link SelectForStep#forJSONB()}.MULTISET_AGG aggregate function to nest group
+ * contents.
+ * ARRAY_AGG aggregate
+ * function. It is emulated using mappings to any of:
+ *
+ *
+ * JSON,
+ * but we're using {@link #jsonbArrayAgg(Field)} and
+ * {@link #jsonbObject(Field...)}, or {@link SelectForStep#forJSONB()}.MULTISET_AGG aggregate function to nest group
+ * contents.
+ * ARRAY_AGG aggregate
+ * function. It is emulated using mappings to any of:
+ *
+ *
+ * JSON,
+ * but we're using {@link #jsonbArrayAgg(Field)} and
+ * {@link #jsonbObject(Field...)}, or {@link SelectForStep#forJSONB()}.MULTISET_AGG aggregate function to nest group
+ * contents.
+ * ARRAY_AGG aggregate
+ * function. It is emulated using mappings to any of:
+ *
+ *
+ * JSON,
+ * but we're using {@link #jsonbArrayAgg(Field)} and
+ * {@link #jsonbObject(Field...)}, or {@link SelectForStep#forJSONB()}.MULTISET_AGG aggregate function to nest group
+ * contents.
+ *