branch-4.0: [Feature](func) Support INTERVAL function and fix EXPORT_SET constant process #58885

be/src/vec/columns/column_const.cpp

@@ -136,6 +136,14 @@ std::pair<const ColumnPtr&, bool> unpack_if_const(const ColumnPtr& ptr) noexcept
 void default_preprocess_parameter_columns(ColumnPtr* columns, const bool* col_const,
                                           const std::initializer_list<size_t>& parameters,
                                           Block& block, const ColumnNumbers& arg_indexes) {
+    default_preprocess_parameter_columns(
+            columns, col_const, std::span<const size_t>(parameters.begin(), parameters.end()),
+            block, arg_indexes);
+}
+
+void default_preprocess_parameter_columns(ColumnPtr* columns, const bool* col_const,
+                                          const std::span<const size_t>& parameters, Block& block,
+                                          const ColumnNumbers& arg_indexes) {
     if (std::all_of(parameters.begin(), parameters.end(),
                     [&](size_t const_index) -> bool { return col_const[const_index]; })) {
         // only need to avoid expanding when all parameters are const

be/src/vec/columns/column_const.h

@@ -92,6 +92,10 @@ void default_preprocess_parameter_columns(ColumnPtr* columns, const bool* col_co
                                           const std::initializer_list<size_t>& parameters,
                                           Block& block, const ColumnNumbers& arg_indexes);
 
+void default_preprocess_parameter_columns(ColumnPtr* columns, const bool* col_const,
+                                          const std::span<const size_t>& parameters, Block& block,
+                                          const ColumnNumbers& arg_indexes);
+
 /** ColumnConst contains another column with single element,
   *  but looks like a column with arbitrary amount of same elements.
   */

be/src/vec/functions/function_interval.cpp

@@ -0,0 +1,125 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include <algorithm>
+#include <cstddef>
+#include <cstdint>
+#include <limits>
+#include <memory>
+#include <vector>
+
+#include "common/status.h"
+#include "runtime/define_primitive_type.h"
+#include "runtime/primitive_type.h"
+#include "vec/columns/column.h"
+#include "vec/columns/column_const.h"
+#include "vec/columns/column_nullable.h"
+#include "vec/columns/column_vector.h"
+#include "vec/common/assert_cast.h"
+#include "vec/core/block.h"
+#include "vec/core/column_numbers.h"
+#include "vec/core/column_with_type_and_name.h"
+#include "vec/core/types.h"
+#include "vec/data_types/data_type.h"
+#include "vec/data_types/data_type_number.h"
+#include "vec/functions/function.h"
+#include "vec/functions/function_needs_to_handle_null.h"
+#include "vec/functions/simple_function_factory.h"
+#include "vec/utils/util.hpp"
+
+namespace doris::vectorized {
+class FunctionInterval : public IFunction {
+public:
+    static constexpr auto name = "interval";
+    static FunctionPtr create() { return std::make_shared<FunctionInterval>(); }
+    String get_name() const override { return name; }
+    bool is_variadic() const override { return true; }
+    size_t get_number_of_arguments() const override { return 0; }
+    bool use_default_implementation_for_nulls() const override { return false; }
+    DataTypePtr get_return_type_impl(const DataTypes& arguments) const override {
+        return std::make_shared<DataTypeInt32>();
+    }
+
+    Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments,
+                        uint32_t result, size_t input_rows_count) const override {
+        auto res_col = ColumnInt32::create();
+
+        const size_t arg_size = arguments.size();
+        std::vector<ColumnPtr> arg_cols(arg_size);
+        std::vector<uint8_t> is_const(arg_size);
+        std::vector<size_t> param_idx(arg_size - 1);
+        bool all_const = true;
+        for (int i = 0; i < arg_size; ++i) {
+            is_const[i] = is_column_const(*block.get_by_position(arguments[i]).column);
+            if (i != 0) {
+                param_idx[i - 1] = i;
+                all_const = all_const & is_const[i];
+            }
+        }
+        arg_cols[0] = is_const[0] ? assert_cast<const ColumnConst&>(
+                                            *block.get_by_position(arguments[0]).column)
+                                            .get_data_column_ptr()
+                                  : block.get_by_position(arguments[0]).column;
+        default_preprocess_parameter_columns(arg_cols.data(),
+                                             reinterpret_cast<const bool*>(is_const.data()),
+                                             param_idx, block, arguments);
+        for (int i = 1; i < arg_size; ++i) {
+            arg_cols[i] = remove_nullable(arg_cols[i]);
+        }
+
+        const NullMap* compare_null_map = VectorizedUtils::get_null_map(arg_cols[0]);
+        arg_cols[0] = remove_nullable(arg_cols[0]);
+        const auto& compare_data = assert_cast<const ColumnInt64&>(*arg_cols[0]).get_data();
+        for (int row = 0; row < input_rows_count; ++row) {
+            const size_t compare_idx = index_check_const(row, is_const[0]);
+            const size_t arr_idx = all_const ? 0 : row;
+            if (compare_null_map && (*compare_null_map)[compare_idx]) {
+                res_col->insert_value(-1);
+                continue;
+            }
+
+            res_col->insert_value(compute_interval(compare_data[compare_idx], arg_cols, is_const,
+                                                   arr_idx, arg_size));
+        }
+        block.get_by_position(result).column = std::move(res_col);
+        return Status::OK();
+    }
+
+private:
+    int32_t compute_interval(int64_t compare_val, const std::vector<ColumnPtr>& arg_cols,
+                             std::vector<uint8_t>& is_const, size_t row_idx,
+                             size_t arg_size) const {
+        size_t l = 1, r = arg_size;
+        while (l < r) {
+            size_t mid = (l + r) >> 1;
+            const auto mid_val =
+                    assert_cast<const ColumnInt64&>(*arg_cols[mid]).get_data()[row_idx];
+            if (mid_val <= compare_val) {
+                l = mid + 1;
+            } else {
+                r = mid;
+            }
+        }
+        return static_cast<int32_t>(l - 1);
+    }
+};
+
+void register_function_interval(SimpleFunctionFactory& factory) {
+    factory.register_function<FunctionInterval>();
+}
+
+} // namespace doris::vectorized

be/src/vec/functions/function_string.h

@@ -5091,7 +5091,7 @@ class FunctionExportSet : public IFunction {
         bool col_const[5];
         ColumnPtr arg_cols[5];
         bool all_const = true;
-        for (int i = 0; i < arg_size; ++i) {
+        for (int i = 1; i < arg_size; ++i) {
             col_const[i] = is_column_const(*block.get_by_position(arguments[i]).column);
             all_const = all_const && col_const[i];
         }

be/src/vec/functions/simple_function_factory.h

@@ -98,6 +98,7 @@ void register_function_geo(SimpleFunctionFactory& factory);
 void register_function_multi_string_position(SimpleFunctionFactory& factory);
 void register_function_multi_string_search(SimpleFunctionFactory& factory);
 void register_function_width_bucket(SimpleFunctionFactory& factory);
+void register_function_interval(SimpleFunctionFactory& factory);
 void register_function_ignore(SimpleFunctionFactory& factory);
 void register_function_encryption(SimpleFunctionFactory& factory);
 void register_function_regexp_extract(SimpleFunctionFactory& factory);
@@ -335,6 +336,7 @@ class SimpleFunctionFactory {
             register_function_multi_string_position(instance);
             register_function_multi_string_search(instance);
             register_function_width_bucket(instance);
+            register_function_interval(instance);
             register_function_match(instance);
             register_function_ip(instance);
             register_function_tokenize(instance);

fe/fe-core/src/main/antlr4/org/apache/doris/nereids/DorisParser.g4

@@ -1703,6 +1703,7 @@ functionNameIdentifier
     | CURRENT_USER
     | DATABASE
     | IF
+    | INTERVAL
     | LEFT
     | LIKE
     | PASSWORD

fe/fe-core/src/main/java/org/apache/doris/catalog/BuiltinScalarFunctions.java

@@ -247,6 +247,7 @@
 import org.apache.doris.nereids.trees.expressions.functions.scalar.InnerProduct;
 import org.apache.doris.nereids.trees.expressions.functions.scalar.InnerProductApproximate;
 import org.apache.doris.nereids.trees.expressions.functions.scalar.Instr;
+import org.apache.doris.nereids.trees.expressions.functions.scalar.Interval;
 import org.apache.doris.nereids.trees.expressions.functions.scalar.InttoUuid;
 import org.apache.doris.nereids.trees.expressions.functions.scalar.Ipv4CIDRToRange;
 import org.apache.doris.nereids.trees.expressions.functions.scalar.Ipv4NumToString;
@@ -784,6 +785,7 @@ public class BuiltinScalarFunctions implements FunctionHelper {
             scalar(InnerProductApproximate.class, "inner_product_approximate"),
             scalar(InnerProduct.class, "inner_product"),
             scalar(Instr.class, "instr"),
+            scalar(Interval.class, "interval"),
             scalar(InttoUuid.class, "int_to_uuid"),
             scalar(Ipv4NumToString.class, "ipv4_num_to_string", "inet_ntoa"),
             scalar(Ipv4StringToNum.class, "ipv4_string_to_num"),
@@ -1067,8 +1069,8 @@ public class BuiltinScalarFunctions implements FunctionHelper {
             scalar(UnhexNull.class, "unhex_null"),
             scalar(UnixTimestamp.class, "unix_timestamp"),
             scalar(Upper.class, "ucase", "upper"),
-            scalar(Uncompress.class, "uncompress"),
             scalar(UnicodeNormalize.class, "unicode_normalize"),
+            scalar(Uncompress.class, "uncompress"),
             scalar(Uniform.class, "uniform"),
             scalar(UrlDecode.class, "url_decode"),
             scalar(UrlEncode.class, "url_encode"),

fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/executable/NumericArithmetic.java

@@ -17,6 +17,7 @@
 
 package org.apache.doris.nereids.trees.expressions.functions.executable;
 
+import org.apache.doris.nereids.exceptions.AnalysisException;
 import org.apache.doris.nereids.trees.expressions.ExecFunction;
 import org.apache.doris.nereids.trees.expressions.Expression;
 import org.apache.doris.nereids.trees.expressions.literal.BigIntLiteral;
@@ -45,6 +46,7 @@
 import java.math.BigDecimal;
 import java.math.BigInteger;
 import java.nio.charset.StandardCharsets;
+import java.util.Arrays;
 
 /**
  * executable functions:
@@ -1108,4 +1110,40 @@ public static Expression boolor(BooleanLiteral first) {
     public static Expression boolxor(BooleanLiteral first) {
         return first;
     }
+
+    /**
+     * interval
+     */
+    @ExecFunction(name = "interval")
+    public static Expression interval(NullLiteral compareValue, Literal... thresholds) {
+        return new IntegerLiteral(-1);
+    }
+
+    /**
+     * interval
+     */
+    @ExecFunction(name = "interval")
+    public static Expression interval(BigIntLiteral compareValue, Literal... thresholds) {
+        long value = compareValue.getValue();
+
+        long[] thresholdValues = new long[thresholds.length];
+        for (int i = 0; i < thresholds.length; i++) {
+            if (thresholds[i] instanceof NullLiteral) {
+                thresholdValues[i] = 0;
+            } else if (thresholds[i] instanceof BigIntLiteral) {
+                thresholdValues[i] = ((BigIntLiteral) thresholds[i]).getValue();
+            } else {
+                throw new AnalysisException("Thresholds must be BigIntLiteral or NullLiteral");
+            }
+        }
+
+        int pos = Arrays.binarySearch(thresholdValues, value);
+
+        if (pos >= 0) {
+            return new IntegerLiteral(pos + 1);
+        } else {
+            int insertionPoint = -(pos + 1);
+            return new IntegerLiteral(insertionPoint);
+        }
+    }
 }

fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/Interval.java

@@ -0,0 +1,61 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+package org.apache.doris.nereids.trees.expressions.functions.scalar;
+
+import org.apache.doris.catalog.FunctionSignature;
+import org.apache.doris.nereids.trees.expressions.Expression;
+import org.apache.doris.nereids.trees.expressions.functions.AlwaysNotNullable;
+import org.apache.doris.nereids.trees.expressions.functions.ExplicitlyCastableSignature;
+import org.apache.doris.nereids.trees.expressions.visitor.ExpressionVisitor;
+import org.apache.doris.nereids.types.BigIntType;
+import org.apache.doris.nereids.types.IntegerType;
+import org.apache.doris.nereids.util.ExpressionUtils;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
+
+import java.util.List;
+
+/**
+ * ScalarFunction 'interval'.
+ */
+public class Interval extends ScalarFunction implements ExplicitlyCastableSignature, AlwaysNotNullable {
+
+    public static final List<FunctionSignature> SIGNATURES = ImmutableList.of(
+            FunctionSignature.ret(IntegerType.INSTANCE).varArgs(BigIntType.INSTANCE, BigIntType.INSTANCE));
+
+    public Interval(Expression arg, Expression... varArgs) {
+        super("interval", ExpressionUtils.mergeArguments(arg, varArgs));
+    }
+
+    @Override
+    public Interval withChildren(List<Expression> children) {
+        Preconditions.checkArgument(children.size() >= 2);
+        return new Interval(children.get(0), children.subList(1, children.size()).toArray(new Expression[0]));
+    }
+
+    @Override
+    public List<FunctionSignature> getSignatures() {
+        return SIGNATURES;
+    }
+
+    @Override
+    public <R, C> R accept(ExpressionVisitor<R, C> visitor, C context) {
+        return visitor.visitInterval(this, context);
+    }
+}

fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/visitor/ScalarFunctionVisitor.java

@@ -255,6 +255,7 @@
 import org.apache.doris.nereids.trees.expressions.functions.scalar.InnerProduct;
 import org.apache.doris.nereids.trees.expressions.functions.scalar.InnerProductApproximate;
 import org.apache.doris.nereids.trees.expressions.functions.scalar.Instr;
+import org.apache.doris.nereids.trees.expressions.functions.scalar.Interval;
 import org.apache.doris.nereids.trees.expressions.functions.scalar.InttoUuid;
 import org.apache.doris.nereids.trees.expressions.functions.scalar.Ipv4CIDRToRange;
 import org.apache.doris.nereids.trees.expressions.functions.scalar.Ipv4NumToString;
@@ -1458,6 +1459,10 @@ default R visitInstr(Instr instr, C context) {
         return visitScalarFunction(instr, context);
     }
 
+    default R visitInterval(Interval interval, C context) {
+        return visitScalarFunction(interval, context);
+    }
+
     default R visitIpv4NumToString(Ipv4NumToString ipv4NumToString, C context) {
         return visitScalarFunction(ipv4NumToString, context);
     }