This is an automated email from the ASF dual-hosted git repository.
Jackie-Jiang pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/pinot.git
The following commit(s) were added to refs/heads/master by this push:
new 2630b03651d Add null-ignoring variants of array union, concat and push
scalar functions (#19981)
2630b03651d is described below
commit 2630b03651dcb240bd04666bb789ee10d085b049
Author: Xiaotian (Jackie) Jiang <[email protected]>
AuthorDate: Tue Oct 20 21:42:05 2026 -0700
Add null-ignoring variants of array union, concat and push scalar functions
(#19981)
---
.../common/function/scalar/ArrayFunctions.java | 188 +++++++++++++++++++++
.../core/data/function/ArrayFunctionsTest.java | 92 ++++++++++
.../resources/udf-test-results/all-functions.yaml | 68 ++++++++
3 files changed, 348 insertions(+)
diff --git
a/pinot-common/src/main/java/org/apache/pinot/common/function/scalar/ArrayFunctions.java
b/pinot-common/src/main/java/org/apache/pinot/common/function/scalar/ArrayFunctions.java
index 67643d17dea..c6bb1104e94 100644
---
a/pinot-common/src/main/java/org/apache/pinot/common/function/scalar/ArrayFunctions.java
+++
b/pinot-common/src/main/java/org/apache/pinot/common/function/scalar/ArrayFunctions.java
@@ -26,6 +26,7 @@ import it.unimi.dsi.fastutil.objects.ObjectLinkedOpenHashSet;
import it.unimi.dsi.fastutil.objects.ObjectSet;
import java.math.BigDecimal;
import java.util.Arrays;
+import javax.annotation.Nullable;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.pinot.spi.annotations.ScalarFunction;
import org.apache.pinot.spi.utils.CommonConstants.NullValuePlaceHolder;
@@ -185,6 +186,28 @@ public class ArrayFunctions {
return set.toArray(new String[0]);
}
+ /// Same as [#arrayUnionInt], but ignores a `null` array instead of
returning `null`. Returns `null` only when both
+ /// arrays are `null`.
+ @Nullable
+ @ScalarFunction(nullableParameters = true)
+ public static int[] arrayUnionIntIgnoreNulls(@Nullable int[] values1,
@Nullable int[] values2) {
+ if (values1 == null) {
+ return values2 != null ? arrayDistinctInt(values2) : null;
+ }
+ return values2 != null ? arrayUnionInt(values1, values2) :
arrayDistinctInt(values1);
+ }
+
+ /// Same as [#arrayUnionString], but ignores a `null` array instead of
returning `null`. Returns `null` only when both
+ /// arrays are `null`.
+ @Nullable
+ @ScalarFunction(nullableParameters = true)
+ public static String[] arrayUnionStringIgnoreNulls(@Nullable String[]
values1, @Nullable String[] values2) {
+ if (values1 == null) {
+ return values2 != null ? arrayDistinctString(values2) : null;
+ }
+ return values2 != null ? arrayUnionString(values1, values2) :
arrayDistinctString(values1);
+ }
+
@ScalarFunction
public static int[] arrayConcatInt(int[] values1, int[] values2) {
return ArrayUtils.addAll(values1, values2);
@@ -210,6 +233,61 @@ public class ArrayFunctions {
return ArrayUtils.addAll(values1, values2);
}
+ /// Same as [#arrayConcatInt], but ignores a `null` array instead of
returning `null`. Returns `null` only when both
+ /// arrays are `null`.
+ @Nullable
+ @ScalarFunction(nullableParameters = true)
+ public static int[] arrayConcatIntIgnoreNulls(@Nullable int[] values1,
@Nullable int[] values2) {
+ if (values1 == null) {
+ return values2;
+ }
+ return values2 != null ? arrayConcatInt(values1, values2) : values1;
+ }
+
+ /// Same as [#arrayConcatLong], but ignores a `null` array instead of
returning `null`. Returns `null` only when both
+ /// arrays are `null`.
+ @Nullable
+ @ScalarFunction(nullableParameters = true)
+ public static long[] arrayConcatLongIgnoreNulls(@Nullable long[] values1,
@Nullable long[] values2) {
+ if (values1 == null) {
+ return values2;
+ }
+ return values2 != null ? arrayConcatLong(values1, values2) : values1;
+ }
+
+ /// Same as [#arrayConcatFloat], but ignores a `null` array instead of
returning `null`. Returns `null` only when both
+ /// arrays are `null`.
+ @Nullable
+ @ScalarFunction(nullableParameters = true)
+ public static float[] arrayConcatFloatIgnoreNulls(@Nullable float[] values1,
@Nullable float[] values2) {
+ if (values1 == null) {
+ return values2;
+ }
+ return values2 != null ? arrayConcatFloat(values1, values2) : values1;
+ }
+
+ /// Same as [#arrayConcatDouble], but ignores a `null` array instead of
returning `null`. Returns `null` only when
+ /// both arrays are `null`.
+ @Nullable
+ @ScalarFunction(nullableParameters = true)
+ public static double[] arrayConcatDoubleIgnoreNulls(@Nullable double[]
values1, @Nullable double[] values2) {
+ if (values1 == null) {
+ return values2;
+ }
+ return values2 != null ? arrayConcatDouble(values1, values2) : values1;
+ }
+
+ /// Same as [#arrayConcatString], but ignores a `null` array instead of
returning `null`. Returns `null` only when
+ /// both arrays are `null`.
+ @Nullable
+ @ScalarFunction(nullableParameters = true)
+ public static String[] arrayConcatStringIgnoreNulls(@Nullable String[]
values1, @Nullable String[] values2) {
+ if (values1 == null) {
+ return values2;
+ }
+ return values2 != null ? arrayConcatString(values1, values2) : values1;
+ }
+
@ScalarFunction
public static int[] arrayPushBackInt(int[] values, int element) {
return ArrayUtils.add(values, element);
@@ -235,6 +313,61 @@ public class ArrayFunctions {
return ArrayUtils.add(values, element);
}
+ /// Same as [#arrayPushBackInt], but ignores a `null` array or element
instead of returning `null`. Returns `null`
+ /// only when both are `null`.
+ @Nullable
+ @ScalarFunction(nullableParameters = true)
+ public static int[] arrayPushBackIntIgnoreNulls(@Nullable int[] values,
@Nullable Integer element) {
+ if (element == null) {
+ return values;
+ }
+ return values != null ? arrayPushBackInt(values, element) : new
int[]{element};
+ }
+
+ /// Same as [#arrayPushBackLong], but ignores a `null` array or element
instead of returning `null`. Returns `null`
+ /// only when both are `null`.
+ @Nullable
+ @ScalarFunction(nullableParameters = true)
+ public static long[] arrayPushBackLongIgnoreNulls(@Nullable long[] values,
@Nullable Long element) {
+ if (element == null) {
+ return values;
+ }
+ return values != null ? arrayPushBackLong(values, element) : new
long[]{element};
+ }
+
+ /// Same as [#arrayPushBackFloat], but ignores a `null` array or element
instead of returning `null`. Returns `null`
+ /// only when both are `null`.
+ @Nullable
+ @ScalarFunction(nullableParameters = true)
+ public static float[] arrayPushBackFloatIgnoreNulls(@Nullable float[]
values, @Nullable Float element) {
+ if (element == null) {
+ return values;
+ }
+ return values != null ? arrayPushBackFloat(values, element) : new
float[]{element};
+ }
+
+ /// Same as [#arrayPushBackDouble], but ignores a `null` array or element
instead of returning `null`. Returns `null`
+ /// only when both are `null`.
+ @Nullable
+ @ScalarFunction(nullableParameters = true)
+ public static double[] arrayPushBackDoubleIgnoreNulls(@Nullable double[]
values, @Nullable Double element) {
+ if (element == null) {
+ return values;
+ }
+ return values != null ? arrayPushBackDouble(values, element) : new
double[]{element};
+ }
+
+ /// Same as [#arrayPushBackString], but ignores a `null` array or element
instead of returning `null`. Returns `null`
+ /// only when both are `null`.
+ @Nullable
+ @ScalarFunction(nullableParameters = true)
+ public static String[] arrayPushBackStringIgnoreNulls(@Nullable String[]
values, @Nullable String element) {
+ if (element == null) {
+ return values;
+ }
+ return values != null ? arrayPushBackString(values, element) : new
String[]{element};
+ }
+
@ScalarFunction
public static int[] arrayPushFrontInt(int[] values, int element) {
return ArrayUtils.insert(0, values, element);
@@ -260,6 +393,61 @@ public class ArrayFunctions {
return ArrayUtils.insert(0, values, element);
}
+ /// Same as [#arrayPushFrontInt], but ignores a `null` array or element
instead of returning `null`. Returns `null`
+ /// only when both are `null`.
+ @Nullable
+ @ScalarFunction(nullableParameters = true)
+ public static int[] arrayPushFrontIntIgnoreNulls(@Nullable int[] values,
@Nullable Integer element) {
+ if (element == null) {
+ return values;
+ }
+ return values != null ? arrayPushFrontInt(values, element) : new
int[]{element};
+ }
+
+ /// Same as [#arrayPushFrontLong], but ignores a `null` array or element
instead of returning `null`. Returns `null`
+ /// only when both are `null`.
+ @Nullable
+ @ScalarFunction(nullableParameters = true)
+ public static long[] arrayPushFrontLongIgnoreNulls(@Nullable long[] values,
@Nullable Long element) {
+ if (element == null) {
+ return values;
+ }
+ return values != null ? arrayPushFrontLong(values, element) : new
long[]{element};
+ }
+
+ /// Same as [#arrayPushFrontFloat], but ignores a `null` array or element
instead of returning `null`. Returns `null`
+ /// only when both are `null`.
+ @Nullable
+ @ScalarFunction(nullableParameters = true)
+ public static float[] arrayPushFrontFloatIgnoreNulls(@Nullable float[]
values, @Nullable Float element) {
+ if (element == null) {
+ return values;
+ }
+ return values != null ? arrayPushFrontFloat(values, element) : new
float[]{element};
+ }
+
+ /// Same as [#arrayPushFrontDouble], but ignores a `null` array or element
instead of returning `null`. Returns `null`
+ /// only when both are `null`.
+ @Nullable
+ @ScalarFunction(nullableParameters = true)
+ public static double[] arrayPushFrontDoubleIgnoreNulls(@Nullable double[]
values, @Nullable Double element) {
+ if (element == null) {
+ return values;
+ }
+ return values != null ? arrayPushFrontDouble(values, element) : new
double[]{element};
+ }
+
+ /// Same as [#arrayPushFrontString], but ignores a `null` array or element
instead of returning `null`. Returns `null`
+ /// only when both are `null`.
+ @Nullable
+ @ScalarFunction(nullableParameters = true)
+ public static String[] arrayPushFrontStringIgnoreNulls(@Nullable String[]
values, @Nullable String element) {
+ if (element == null) {
+ return values;
+ }
+ return values != null ? arrayPushFrontString(values, element) : new
String[]{element};
+ }
+
@ScalarFunction
public static int arrayElementAtInt(int[] arr, int idx) {
return idx > 0 && idx <= arr.length ? arr[idx - 1] :
NullValuePlaceHolder.INT;
diff --git
a/pinot-core/src/test/java/org/apache/pinot/core/data/function/ArrayFunctionsTest.java
b/pinot-core/src/test/java/org/apache/pinot/core/data/function/ArrayFunctionsTest.java
index 02fd3c648eb..6542afc1d42 100644
---
a/pinot-core/src/test/java/org/apache/pinot/core/data/function/ArrayFunctionsTest.java
+++
b/pinot-core/src/test/java/org/apache/pinot/core/data/function/ArrayFunctionsTest.java
@@ -54,6 +54,10 @@ public class ArrayFunctionsTest {
row.putValue("longArray", new long[]{3L, 2L, 10L, 6L, 1L, 12L});
row.putValue("stringArray", new String[]{"3", "2", "10", "6", "1", "12"});
row.putValue("stringArrayWithNulls", new String[]{"3", "2", "10", "6",
"1", "12", "", null});
+ row.putValue("nullIntArray", null);
+ row.putValue("nullStringArray", null);
+ row.putValue("nullInt", null);
+ row.putValue("nullString", null);
inputs.add(new Object[]{
"array_reverse_int(intArray)", List.of("intArray"), row, new int[]{12,
1, 6, 10, 2, 3}
@@ -169,6 +173,29 @@ public class ArrayFunctionsTest {
"array_union_string(stringArray, stringArray)",
Lists.newArrayList("stringArray", "stringArray"), row,
new String[]{"3", "2", "10", "6", "1", "12"}
});
+ inputs.add(new Object[]{
+ "array_union_int_ignore_nulls(array_concat_int(intArray, intArray),
nullIntArray)",
+ List.of("intArray", "intArray", "nullIntArray"), row, new int[]{3, 2,
10, 6, 1, 12}
+ });
+ inputs.add(new Object[]{
+ "array_union_int_ignore_nulls(nullIntArray, intArray)",
List.of("nullIntArray", "intArray"), row,
+ new int[]{3, 2, 10, 6, 1, 12}
+ });
+ inputs.add(new Object[]{
+ "array_union_int_ignore_nulls(nullIntArray, nullIntArray)",
List.of("nullIntArray", "nullIntArray"), row, null
+ });
+ inputs.add(new Object[]{
+ "array_union_string_ignore_nulls(array_concat_string(stringArray,
stringArray), nullStringArray)",
+ List.of("stringArray", "stringArray", "nullStringArray"), row, new
String[]{"3", "2", "10", "6", "1", "12"}
+ });
+ inputs.add(new Object[]{
+ "array_union_string_ignore_nulls(nullStringArray, stringArray)",
List.of("nullStringArray", "stringArray"),
+ row, new String[]{"3", "2", "10", "6", "1", "12"}
+ });
+ inputs.add(new Object[]{
+ "array_union_string_ignore_nulls(nullStringArray, nullStringArray)",
+ List.of("nullStringArray", "nullStringArray"), row, null
+ });
inputs.add(new Object[]{
"array_concat_int(intArray, intArray)", Lists.newArrayList("intArray",
"intArray"), row,
@@ -182,6 +209,29 @@ public class ArrayFunctionsTest {
"array_concat_string(stringArray, stringArray)",
Lists.newArrayList("stringArray", "stringArray"), row,
new String[]{"3", "2", "10", "6", "1", "12", "3", "2", "10", "6", "1",
"12"}
});
+ inputs.add(new Object[]{
+ "array_concat_int_ignore_nulls(intArray, nullIntArray)",
List.of("intArray", "nullIntArray"), row,
+ new int[]{3, 2, 10, 6, 1, 12}
+ });
+ inputs.add(new Object[]{
+ "array_concat_int_ignore_nulls(nullIntArray, intArray)",
List.of("nullIntArray", "intArray"), row,
+ new int[]{3, 2, 10, 6, 1, 12}
+ });
+ inputs.add(new Object[]{
+ "array_concat_int_ignore_nulls(nullIntArray, nullIntArray)",
List.of("nullIntArray", "nullIntArray"), row, null
+ });
+ inputs.add(new Object[]{
+ "array_concat_string_ignore_nulls(stringArray, nullStringArray)",
List.of("stringArray", "nullStringArray"),
+ row, new String[]{"3", "2", "10", "6", "1", "12"}
+ });
+ inputs.add(new Object[]{
+ "array_concat_string_ignore_nulls(nullStringArray, stringArray)",
List.of("nullStringArray", "stringArray"),
+ row, new String[]{"3", "2", "10", "6", "1", "12"}
+ });
+ inputs.add(new Object[]{
+ "array_concat_string_ignore_nulls(nullStringArray, nullStringArray)",
+ List.of("nullStringArray", "nullStringArray"), row, null
+ });
inputs.add(new Object[]{
"array_push_back_int(intArray, 7)", List.of("intArray"), row,
new int[]{3, 2, 10, 6, 1, 12, 7}
@@ -190,6 +240,27 @@ public class ArrayFunctionsTest {
"array_push_back_string(stringArray, 'x')", List.of("stringArray"),
row,
new String[]{"3", "2", "10", "6", "1", "12", "x"}
});
+ inputs.add(new Object[]{
+ "array_push_back_int_ignore_nulls(intArray, nullInt)",
List.of("intArray", "nullInt"), row,
+ new int[]{3, 2, 10, 6, 1, 12}
+ });
+ inputs.add(new Object[]{
+ "array_push_back_int_ignore_nulls(nullIntArray, 7)",
List.of("nullIntArray"), row, new int[]{7}
+ });
+ inputs.add(new Object[]{
+ "array_push_back_int_ignore_nulls(nullIntArray, nullInt)",
List.of("nullIntArray", "nullInt"), row, null
+ });
+ inputs.add(new Object[]{
+ "array_push_back_string_ignore_nulls(stringArray, nullString)",
List.of("stringArray", "nullString"), row,
+ new String[]{"3", "2", "10", "6", "1", "12"}
+ });
+ inputs.add(new Object[]{
+ "array_push_back_string_ignore_nulls(nullStringArray, 'x')",
List.of("nullStringArray"), row, new String[]{"x"}
+ });
+ inputs.add(new Object[]{
+ "array_push_back_string_ignore_nulls(nullStringArray, nullString)",
List.of("nullStringArray", "nullString"),
+ row, null
+ });
inputs.add(new Object[]{
"array_push_front_int(intArray, 7)", List.of("intArray"), row,
new int[]{7, 3, 2, 10, 6, 1, 12}
@@ -198,6 +269,27 @@ public class ArrayFunctionsTest {
"array_push_front_string(stringArray, 'x')", List.of("stringArray"),
row,
new String[]{"x", "3", "2", "10", "6", "1", "12"}
});
+ inputs.add(new Object[]{
+ "array_push_front_int_ignore_nulls(intArray, nullInt)",
List.of("intArray", "nullInt"), row,
+ new int[]{3, 2, 10, 6, 1, 12}
+ });
+ inputs.add(new Object[]{
+ "array_push_front_int_ignore_nulls(nullIntArray, 7)",
List.of("nullIntArray"), row, new int[]{7}
+ });
+ inputs.add(new Object[]{
+ "array_push_front_int_ignore_nulls(nullIntArray, nullInt)",
List.of("nullIntArray", "nullInt"), row, null
+ });
+ inputs.add(new Object[]{
+ "array_push_front_string_ignore_nulls(stringArray, nullString)",
List.of("stringArray", "nullString"), row,
+ new String[]{"3", "2", "10", "6", "1", "12"}
+ });
+ inputs.add(new Object[]{
+ "array_push_front_string_ignore_nulls(nullStringArray, 'x')",
List.of("nullStringArray"), row, new String[]{"x"}
+ });
+ inputs.add(new Object[]{
+ "array_push_front_string_ignore_nulls(nullStringArray, nullString)",
List.of("nullStringArray", "nullString"),
+ row, null
+ });
inputs.add(new Object[]{
"array_to_string(stringArray, '::')", List.of("stringArray"), row,
"3::2::10::6::1::12"
diff --git
a/pinot-integration-tests/src/test/resources/udf-test-results/all-functions.yaml
b/pinot-integration-tests/src/test/resources/udf-test-results/all-functions.yaml
index 87028ae77b7..b1b2a7f7de2 100644
---
a/pinot-integration-tests/src/test/resources/udf-test-results/all-functions.yaml
+++
b/pinot-integration-tests/src/test/resources/udf-test-results/all-functions.yaml
@@ -66,22 +66,42 @@ arrayconcatdouble:
scalar:
"ArgumentCountBasedScalarFunction{org.apache.pinot.common.function.scalar.ArrayFunctions.arrayConcatDouble}"
transform: null
udf: "org.apache.pinot.query.runtime.function.ArrayConcatDoubleUdf"
+arrayconcatdoubleignorenulls:
+ scalar:
"ArgumentCountBasedScalarFunction{org.apache.pinot.common.function.scalar.ArrayFunctions.arrayConcatDoubleIgnoreNulls}"
+ transform: null
+ udf: null
arrayconcatfloat:
scalar:
"ArgumentCountBasedScalarFunction{org.apache.pinot.common.function.scalar.ArrayFunctions.arrayConcatFloat}"
transform: null
udf: null
+arrayconcatfloatignorenulls:
+ scalar:
"ArgumentCountBasedScalarFunction{org.apache.pinot.common.function.scalar.ArrayFunctions.arrayConcatFloatIgnoreNulls}"
+ transform: null
+ udf: null
arrayconcatint:
scalar:
"ArgumentCountBasedScalarFunction{org.apache.pinot.common.function.scalar.ArrayFunctions.arrayConcatInt}"
transform: null
udf: null
+arrayconcatintignorenulls:
+ scalar:
"ArgumentCountBasedScalarFunction{org.apache.pinot.common.function.scalar.ArrayFunctions.arrayConcatIntIgnoreNulls}"
+ transform: null
+ udf: null
arrayconcatlong:
scalar:
"ArgumentCountBasedScalarFunction{org.apache.pinot.common.function.scalar.ArrayFunctions.arrayConcatLong}"
transform: null
udf: null
+arrayconcatlongignorenulls:
+ scalar:
"ArgumentCountBasedScalarFunction{org.apache.pinot.common.function.scalar.ArrayFunctions.arrayConcatLongIgnoreNulls}"
+ transform: null
+ udf: null
arrayconcatstring:
scalar:
"ArgumentCountBasedScalarFunction{org.apache.pinot.common.function.scalar.ArrayFunctions.arrayConcatString}"
transform: null
udf: null
+arrayconcatstringignorenulls:
+ scalar:
"ArgumentCountBasedScalarFunction{org.apache.pinot.common.function.scalar.ArrayFunctions.arrayConcatStringIgnoreNulls}"
+ transform: null
+ udf: null
arraycontainsint:
scalar:
"ArgumentCountBasedScalarFunction{org.apache.pinot.common.function.scalar.ArrayFunctions.arrayContainsInt}"
transform: null
@@ -162,42 +182,82 @@ arraypushbackdouble:
scalar:
"ArgumentCountBasedScalarFunction{org.apache.pinot.common.function.scalar.ArrayFunctions.arrayPushBackDouble}"
transform: null
udf: null
+arraypushbackdoubleignorenulls:
+ scalar:
"ArgumentCountBasedScalarFunction{org.apache.pinot.common.function.scalar.ArrayFunctions.arrayPushBackDoubleIgnoreNulls}"
+ transform: null
+ udf: null
arraypushbackfloat:
scalar:
"ArgumentCountBasedScalarFunction{org.apache.pinot.common.function.scalar.ArrayFunctions.arrayPushBackFloat}"
transform: null
udf: null
+arraypushbackfloatignorenulls:
+ scalar:
"ArgumentCountBasedScalarFunction{org.apache.pinot.common.function.scalar.ArrayFunctions.arrayPushBackFloatIgnoreNulls}"
+ transform: null
+ udf: null
arraypushbackint:
scalar:
"ArgumentCountBasedScalarFunction{org.apache.pinot.common.function.scalar.ArrayFunctions.arrayPushBackInt}"
transform: null
udf: null
+arraypushbackintignorenulls:
+ scalar:
"ArgumentCountBasedScalarFunction{org.apache.pinot.common.function.scalar.ArrayFunctions.arrayPushBackIntIgnoreNulls}"
+ transform: null
+ udf: null
arraypushbacklong:
scalar:
"ArgumentCountBasedScalarFunction{org.apache.pinot.common.function.scalar.ArrayFunctions.arrayPushBackLong}"
transform: null
udf: null
+arraypushbacklongignorenulls:
+ scalar:
"ArgumentCountBasedScalarFunction{org.apache.pinot.common.function.scalar.ArrayFunctions.arrayPushBackLongIgnoreNulls}"
+ transform: null
+ udf: null
arraypushbackstring:
scalar:
"ArgumentCountBasedScalarFunction{org.apache.pinot.common.function.scalar.ArrayFunctions.arrayPushBackString}"
transform: null
udf: null
+arraypushbackstringignorenulls:
+ scalar:
"ArgumentCountBasedScalarFunction{org.apache.pinot.common.function.scalar.ArrayFunctions.arrayPushBackStringIgnoreNulls}"
+ transform: null
+ udf: null
arraypushfrontdouble:
scalar:
"ArgumentCountBasedScalarFunction{org.apache.pinot.common.function.scalar.ArrayFunctions.arrayPushFrontDouble}"
transform: null
udf: null
+arraypushfrontdoubleignorenulls:
+ scalar:
"ArgumentCountBasedScalarFunction{org.apache.pinot.common.function.scalar.ArrayFunctions.arrayPushFrontDoubleIgnoreNulls}"
+ transform: null
+ udf: null
arraypushfrontfloat:
scalar:
"ArgumentCountBasedScalarFunction{org.apache.pinot.common.function.scalar.ArrayFunctions.arrayPushFrontFloat}"
transform: null
udf: null
+arraypushfrontfloatignorenulls:
+ scalar:
"ArgumentCountBasedScalarFunction{org.apache.pinot.common.function.scalar.ArrayFunctions.arrayPushFrontFloatIgnoreNulls}"
+ transform: null
+ udf: null
arraypushfrontint:
scalar:
"ArgumentCountBasedScalarFunction{org.apache.pinot.common.function.scalar.ArrayFunctions.arrayPushFrontInt}"
transform: null
udf: null
+arraypushfrontintignorenulls:
+ scalar:
"ArgumentCountBasedScalarFunction{org.apache.pinot.common.function.scalar.ArrayFunctions.arrayPushFrontIntIgnoreNulls}"
+ transform: null
+ udf: null
arraypushfrontlong:
scalar:
"ArgumentCountBasedScalarFunction{org.apache.pinot.common.function.scalar.ArrayFunctions.arrayPushFrontLong}"
transform: null
udf: null
+arraypushfrontlongignorenulls:
+ scalar:
"ArgumentCountBasedScalarFunction{org.apache.pinot.common.function.scalar.ArrayFunctions.arrayPushFrontLongIgnoreNulls}"
+ transform: null
+ udf: null
arraypushfrontstring:
scalar:
"ArgumentCountBasedScalarFunction{org.apache.pinot.common.function.scalar.ArrayFunctions.arrayPushFrontString}"
transform: null
udf: null
+arraypushfrontstringignorenulls:
+ scalar:
"ArgumentCountBasedScalarFunction{org.apache.pinot.common.function.scalar.ArrayFunctions.arrayPushFrontStringIgnoreNulls}"
+ transform: null
+ udf: null
arrayremoveint:
scalar:
"ArgumentCountBasedScalarFunction{org.apache.pinot.common.function.scalar.ArrayFunctions.arrayRemoveInt}"
transform: null
@@ -255,10 +315,18 @@ arrayunionint:
scalar:
"ArgumentCountBasedScalarFunction{org.apache.pinot.common.function.scalar.ArrayFunctions.arrayUnionInt}"
transform: null
udf: null
+arrayunionintignorenulls:
+ scalar:
"ArgumentCountBasedScalarFunction{org.apache.pinot.common.function.scalar.ArrayFunctions.arrayUnionIntIgnoreNulls}"
+ transform: null
+ udf: null
arrayunionstring:
scalar:
"ArgumentCountBasedScalarFunction{org.apache.pinot.common.function.scalar.ArrayFunctions.arrayUnionString}"
transform: null
udf: null
+arrayunionstringignorenulls:
+ scalar:
"ArgumentCountBasedScalarFunction{org.apache.pinot.common.function.scalar.ArrayFunctions.arrayUnionStringIgnoreNulls}"
+ transform: null
+ udf: null
arrayvalueconstructor:
scalar:
"ArgumentCountBasedScalarFunction{org.apache.pinot.common.function.scalar.ArrayFunctions.arrayValueConstructor}"
transform: null
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
