[Feature] support Quantile Sketche

[chenminghua8]

Why I'm doing:

What I'm doing:

[Feature] support Quantile Theta Sketche
Implement the aggregation function that supports DataSketches Quantile:

1. Add ds_quantile_state.h to implement the AggregateState that supports DataSketches Quantile;
2. Add quantile_sketch.h and quantile_sketch.cpp to implement the encapsulation of DataSketches Quantile Sketche;
3. Register the ds_quantile function through SketchType::QUANTILET generic to implement the function that supports DataSketches Quantile.

Fixes #50671

What type of PR is this:

• BugFix
• Feature
• Enhancement
• Refactor
• UT
• Doc
• Tool

Does this PR entail a change in behavior?

• Yes, this PR will result in a change in behavior.
• No, this PR will not result in a change in behavior.

If yes, please specify the type of change:

• Interface/UI changes: syntax, type conversion, expression evaluation, display information
• Parameter changes: default values, similar parameters but with different default values
• Policy changes: use new policy to replace old one, functionality automatically enabled
• Feature removed
• Miscellaneous: upgrade & downgrade compatibility, etc.

Checklist:

• I have added test cases for my bug fix or my new feature
• This pr needs user documentation (for new or modified features or behaviors)
  • I have added documentation for my new feature or new function
• This is a backport pr

Bugfix cherry-pick branch check:

• I have checked the version labels which the pr will be auto-backported to the target branch
  • 3.4
  • 3.3
  • 3.2
  • 3.1
  • 3.0

[starrocks-cr]

The most risky bug in this code is:
Duplicate registration of DS_HLL_COUNT_DISTINCT functions, which can lead to errors or unexpected behavior during function lookup.

You can modify the code like this:

private void registerBuiltinDsFunction() {
    for (Type t : Type.getSupportedTypes()) {
        if (t.isFunctionType() || t.isNull() || t.isChar() || t.isPseudoType()) {
            continue;
        }

        // Avoid re-registering ds_hll_count_distinct functions.
        if (!vectorizedFunctions.containsKey(DS_HLL_COUNT_DISTINCT)) {
            addBuiltin(AggregateFunction.createBuiltin(DS_HLL_COUNT_DISTINCT,
                    Lists.newArrayList(t), Type.BIGINT, Type.VARBINARY,
                    true, false, true));
            addBuiltin(AggregateFunction.createBuiltin(DS_HLL_COUNT_DISTINCT,
                    Lists.newArrayList(t, Type.INT), Type.BIGINT, Type.VARBINARY,
                    true, false, true));
            addBuiltin(AggregateFunction.createBuiltin(DS_HLL_COUNT_DISTINCT,
                    Lists.newArrayList(t, Type.INT, Type.VARCHAR), Type.BIGINT, Type.VARBINARY,
                    true, false, true));
        }
    }
    
    // Rest of the function registrations...
}

[chenminghua8]

The function parameters are different and need to be registered multiple times.

[starrocks-cr]

The most risky bug in this code is:

Typographical error in type name SketchWarapperType.

You can modify the code like this:

+    using SketchWrapperType = DataSketchesQuantile<CppType>;
...
+    std::unique_ptr <SketchWrapperType> ds_sketch_wrapper = nullptr;
...
+        ds_sketch_wrapper = std::make_unique<SketchWrapperType>(k, &memory_usage);
...
+                *ranks_prt = other_state.ranks.get()[i];
+                ranks_prt++;
+            }
+            ds_sketch_wrapper =
+                    std::make_unique<SketchWrapperType>(other_state.ds_sketch_wrapper->get_k(), &memory_usage);
...
+        ds_sketch_wrapper = std::make_unique<SketchWrapperType>(sketch_data_slice, memory_usage);
...

This modification corrects the misspelled type name from SketchWarapperType to SketchWrapperType, ensuring consistency and preventing potential compilation errors.

[starrocks-cr]

The most risky bug in this code is:
Possible null pointer dereference because ds_sketch_wrapper may not be initialized before calling update.

You can modify the code like this:

void update(const Column* data_column, size_t row_num) const {
    if (!is_inited()) {
        // Handle uninitialized ds_sketch_wrapper scenario, e.g., log an error or throw an exception.
        return;
    }

    uint64_t value = 0;
    const ColumnType* column = down_cast<const ColumnType*>(data_column);

    if constexpr (lt_is_string<LT>) {
        Slice s = column->get_slice(row_num);
        value = HashUtil::murmur_hash64A(s.data, s.size, HashUtil::MURMUR_SEED);
    } else {
        const auto& v = column->get_data();
        value = HashUtil::murmur_hash64A(&v[row_num], sizeof(v[row_num]), HashUtil::MURMUR_SEED);
    }
    ds_sketch_wrapper->update(value);
}

[chenminghua8]

There is no need to check whether it has been initialized, because the method calling it has already done the corresponding processing.

[sonarqubecloud]

Quality Gate passed

Issues
7 New issues
0 Accepted issues

Measures
0 Security Hotspots
0.0% Coverage on New Code
0.0% Duplication on New Code

See analysis details on SonarQube Cloud

[github-actions]

[Java-Extensions Incremental Coverage Report]

✅ pass : 0 / 0 (0%)

[github-actions]

[FE Incremental Coverage Report]

✅ pass : 91 / 95 (95.79%)

file detail

	path	covered_line	new_line	coverage	not_covered_line_detail
🔵	com/starrocks/sql/analyzer/FunctionAnalyzer.java	27	31	87.10%	[539, 553, 556, 576]
🔵	com/starrocks/sql/optimizer/rule/tree/PreAggregateTurnOnRule.java	3	3	100.00%	[]
🔵	com/starrocks/catalog/FunctionSet.java	61	61	100.00%	[]

[github-actions]

[BE Incremental Coverage Report]

✅ pass : 266 / 297 (89.56%)

file detail

	path	covered_line	new_line	coverage	not_covered_line_detail
🔵	be/src/types/ds_quantile_sketch.cpp	22	33	66.67%	[33, 34, 57, 58, 77, 78, 81, 84, 85, 86, 87]
🔵	be/src/exprs/agg/ds_hll_state.h	57	68	83.82%	[53, 54, 75, 76, 77, 78, 80, 81, 114, 122, 125]
🔵	be/src/exprs/agg/ds_quantile_state.h	100	106	94.34%	[51, 108, 150, 160, 161, 162]
🔵	be/src/types/ds_quantile_sketch.h	16	17	94.12%	[51]
🔵	be/src/exprs/agg/ds_agg.h	64	66	96.97%	[31, 32]
🔵	be/src/exprs/agg/factory/aggregate_factory.hpp	2	2	100.00%	[]
🔵	be/src/exprs/agg/factory/aggregate_resolver_approx.cpp	5	5	100.00%	[]