[feat](hll) add to_hll(bigint) scalar function

Add a new built-in scalar function to_hll(bigint) that constructs an
HLL value from a BIGINT directly, bypassing any hash — the bigint is
fed as-is into HyperLogLog::update(uint64_t).

Changes:
- BE (vec/functions/function_hll.cpp): implement struct ToHll with
  Status-returning execute/vector/vector_nullable methods; register as
  FunctionAlwaysNotNullable<ToHll, true> so InvalidArgument status is
  propagated on negative input.
- BE test (be/test/vec/function/function_hll_test.cpp): add unit test
  function_hll_test.function_to_hll_test covering values 0, 1, 2, 100.
- FE Nereids (scalar/ToHll.java): new ScalarFunction with signature
  BIGINT -> HLL.
- FE catalog (BuiltinScalarFunctions.java): register to_hll.
- FE visitor (ScalarFunctionVisitor.java): add visitToHll visitor hook.

Author: HappenLee

be/src/vec/functions/function_hll.cpp

@@ -103,26 +103,19 @@ class FunctionHLL : public IFunction {
 
         MutableColumnPtr column_result = get_return_type_impl({})->create_column();
         column_result->resize(input_rows_count);
+
         if (const ColumnNullable* col_nullable =
                     check_and_get_column<ColumnNullable>(column.get())) {
             const ColumnHLL* col =
                     check_and_get_column<ColumnHLL>(col_nullable->get_nested_column_ptr().get());
             const ColumnUInt8* col_nullmap = check_and_get_column<ColumnUInt8>(
                     col_nullable->get_null_map_column_ptr().get());
 
-            if (col != nullptr && col_nullmap != nullptr) {
+            if (col && col_nullmap) {
                 Function::vector_nullable(col->get_data(), col_nullmap->get_data(), column_result);
-                block.replace_by_position(result, std::move(column_result));
-                return Status::OK();
             }
         } else if (const ColumnHLL* col = check_and_get_column<ColumnHLL>(column.get())) {
             Function::vector(col->get_data(), column_result);
-            block.replace_by_position(result, std::move(column_result));
-            return Status::OK();
-        } else {
-            return Status::RuntimeError("Illegal column {} of argument of function {}",
-                                        block.get_by_position(arguments[0]).column->get_name(),
-                                        get_name());
         }
 
         block.replace_by_position(result, std::move(column_result));
@@ -259,6 +252,47 @@ struct HLLHash {
     }
 };
 
+struct ToHll {
+    static constexpr auto name = "to_hll";
+
+    using ReturnType = DataTypeHLL;
+    template <typename ColumnType>
+    static Status vector(const ColumnType* col, MutableColumnPtr& col_res) {
+        return execute<ColumnType, false>(col, nullptr, col_res);
+    }
+    template <typename ColumnType>
+    static Status vector_nullable(const ColumnType* col, const NullMap& nullmap,
+                                  MutableColumnPtr& col_res) {
+        return execute<ColumnType, true>(col, &nullmap, col_res);
+    }
+    template <typename ColumnType, bool arg_is_nullable>
+    static Status execute(const ColumnType* col, const NullMap* nullmap,
+                          MutableColumnPtr& col_res) {
+        if constexpr (std::is_same_v<ColumnType, ColumnInt64>) {
+            auto* res_column = reinterpret_cast<ColumnHLL*>(col_res.get());
+            auto& res_data = res_column->get_data();
+            size_t size = col->size();
+            const auto& data = col->get_data();
+
+            for (size_t i = 0; i < size; ++i) {
+                if (arg_is_nullable && (*nullmap)[i]) {
+                    continue;
+                } else {
+                    int64_t value = data[i];
+                    if (value < 0) {
+                        return Status::InvalidArgument(
+                                "to_hll does not support negative bigint value: {}", value);
+                    }
+                    res_data[i].update(static_cast<uint64_t>(value));
+                }
+            }
+            return Status::OK();
+        } else {
+            return Status::InvalidArgument("not support type");
+        }
+    }
+};
+
 struct NameHllToBase64 {
     static constexpr auto name = "hll_to_base64";
 };
@@ -311,13 +345,15 @@ struct HllToBase64 {
 using FunctionHLLCardinality = FunctionHLL<HLLCardinality>;
 using FunctionHLLEmpty = FunctionConst<HLLEmptyImpl, false>;
 using FunctionHLLHash = FunctionAlwaysNotNullable<HLLHash>;
+using FunctionToHll = FunctionAlwaysNotNullable<ToHll, true>;
 using FunctionHllToBase64 = FunctionUnaryToType<HllToBase64, NameHllToBase64>;
 
 void register_function_hll(SimpleFunctionFactory& factory) {
     factory.register_function<FunctionHLLCardinality>();
     factory.register_function<FunctionHLLEmpty>();
     factory.register_function<FunctionHllFromBase64>();
     factory.register_function<FunctionHLLHash>();
+    factory.register_function<FunctionToHll>();
     factory.register_function<FunctionHllToBase64>();
 }
 

be/test/vec/function/function_hll_test.cpp

@@ -133,4 +133,26 @@ TEST(function_hll_test, function_hll_from_base64_test) {
 
     static_cast<void>(check_function<DataTypeHLL, true>(func_name, input_types, data_set));
 }
+
+TEST(function_hll_test, function_to_hll_test) {
+    std::string func_name = "to_hll";
+    InputTypeSet input_types = {PrimitiveType::TYPE_BIGINT};
+
+    HyperLogLog hll1;
+    hll1.update(1);
+    HyperLogLog hll2;
+    hll2.update(2);
+    HyperLogLog hll3;
+    hll3.update(100);
+    HyperLogLog hll4;
+    hll4.update(0);
+
+    DataSet data_set = {{{(int64_t)1}, &hll1},
+                        {{(int64_t)2}, &hll2},
+                        {{(int64_t)100}, &hll3},
+                        {{(int64_t)0}, &hll4},
+                        {{Null()}, Null()}};
+
+    static_cast<void>(check_function<DataTypeHLL>(func_name, input_types, data_set));
+}
 } // namespace doris::vectorized

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

@@ -518,6 +518,7 @@
 import org.apache.doris.nereids.trees.expressions.functions.scalar.ToDate;
 import org.apache.doris.nereids.trees.expressions.functions.scalar.ToDateV2;
 import org.apache.doris.nereids.trees.expressions.functions.scalar.ToDays;
+import org.apache.doris.nereids.trees.expressions.functions.scalar.ToHll;
 import org.apache.doris.nereids.trees.expressions.functions.scalar.ToIpv4;
 import org.apache.doris.nereids.trees.expressions.functions.scalar.ToIpv4OrDefault;
 import org.apache.doris.nereids.trees.expressions.functions.scalar.ToIpv4OrNull;
@@ -1103,6 +1104,7 @@ public class BuiltinScalarFunctions implements FunctionHelper {
             scalar(ToIpv6OrNull.class, "to_ipv6_or_null"),
             scalar(ToIso8601.class, "to_iso8601"),
             scalar(Tokenize.class, "tokenize"),
+            scalar(ToHll.class, "to_hll"),
             scalar(ToJson.class, "to_json"),
             scalar(ToMonday.class, "to_monday"),
             scalar(TopLevelDomain.class, "top_level_domain"),

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

@@ -0,0 +1,74 @@
+// 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.shape.UnaryExpression;
+import org.apache.doris.nereids.trees.expressions.visitor.ExpressionVisitor;
+import org.apache.doris.nereids.types.BigIntType;
+import org.apache.doris.nereids.types.HllType;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
+
+import java.util.List;
+
+/**
+ * ScalarFunction 'to_hll'. This class is generated by GenerateFunction.
+ */
+public class ToHll extends ScalarFunction
+        implements UnaryExpression, ExplicitlyCastableSignature, AlwaysNotNullable {
+
+    public static final List<FunctionSignature> SIGNATURES = ImmutableList.of(
+            FunctionSignature.ret(HllType.INSTANCE).args(BigIntType.INSTANCE)
+    );
+
+    /**
+     * constructor with 1 argument.
+     */
+    public ToHll(Expression arg) {
+        super("to_hll", arg);
+    }
+
+    /** constructor for withChildren and reuse signature */
+    private ToHll(ScalarFunctionParams functionParams) {
+        super(functionParams);
+    }
+
+    /**
+     * withChildren.
+     */
+    @Override
+    public ToHll withChildren(List<Expression> children) {
+        Preconditions.checkArgument(children.size() == 1);
+        return new ToHll(getFunctionParams(children));
+    }
+
+    @Override
+    public List<FunctionSignature> getSignatures() {
+        return SIGNATURES;
+    }
+
+    @Override
+    public <R, C> R accept(ExpressionVisitor<R, C> visitor, C context) {
+        return visitor.visitToHll(this, context);
+    }
+}

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

@@ -538,6 +538,7 @@
 import org.apache.doris.nereids.trees.expressions.functions.scalar.ToDate;
 import org.apache.doris.nereids.trees.expressions.functions.scalar.ToDateV2;
 import org.apache.doris.nereids.trees.expressions.functions.scalar.ToDays;
+import org.apache.doris.nereids.trees.expressions.functions.scalar.ToHll;
 import org.apache.doris.nereids.trees.expressions.functions.scalar.ToIpv4;
 import org.apache.doris.nereids.trees.expressions.functions.scalar.ToIpv4OrDefault;
 import org.apache.doris.nereids.trees.expressions.functions.scalar.ToIpv4OrNull;
@@ -1796,6 +1797,10 @@ default R visitJsonbExtractString(JsonbExtractString jsonbExtractString, C conte
         return visitScalarFunction(jsonbExtractString, context);
     }
 
+    default R visitToHll(ToHll toHll, C context) {
+        return visitScalarFunction(toHll, context);
+    }
+
     default R visitToJson(ToJson toJson, C context) {
         return visitScalarFunction(toJson, context);
     }