[opt](function) speed up md5 with AVX2 batch path (#63484)

Root cause: md5/md5sum evaluated every row through Md5Digest and
OpenSSL, which leaves the vectorized string function path dominated by
per-row scalar digest setup and hex materialization.

Fix: add an AVX2 multi-buffer MD5 helper with scalar fallback, expose a
batch hex API, and route single-argument md5/md5sum over
ColumnString/ColumnVarbinary through the batch path while keeping
multi-argument md5sum and sm3 on the existing digest implementation.

test with sql:
```sql
SET parallel_pipeline_task_num=1;
SET enable_query_cache=false;
SELECT SUM(ASCII(SUBSTRING(MD5(CAST(number AS STRING)), 1, 1)))
FROM numbers("number" = "50000000");
```

result:

| version | times | avg | median |
|---|---:|---:|---:|
| upstream/master baseline | 8.59, 10.21, 9.52, 9.93, 8.85s | 9.42s |
9.52s |
| after AVX2 batch | 2.83, 2.84, 2.82, 2.79, 2.82s | 2.82s | 2.82s |

Author: zclllyybb

be/src/exprs/function/function_string_digest.cpp

@@ -16,7 +16,10 @@
 // under the License.
 
 #include <cstddef>
+#include <cstring>
 #include <string_view>
+#include <type_traits>
+#include <vector>
 
 #include "common/status.h"
 #include "core/assert_cast.h"
@@ -98,6 +101,14 @@ class FunctionStringDigestMulti : public IFunction {
                         const std::vector<ColumnPtr>& argument_columns,
                         const std::vector<uint8_t>& is_const, ColumnString::Chars& res_data,
                         ColumnString::Offsets& res_offset) const {
+        if constexpr (std::is_same_v<Impl, MD5Sum>) {
+            if (argument_columns.size() == 1) {
+                const auto* col = assert_cast<const ColumnType*>(argument_columns[0].get());
+                vector_execute_single_md5(col, input_rows_count, is_const[0], res_data, res_offset);
+                return;
+            }
+        }
+
         using ObjectData = typename Impl::ObjectData;
         for (size_t i = 0; i < input_rows_count; ++i) {
             ObjectData digest;
@@ -114,6 +125,42 @@ class FunctionStringDigestMulti : public IFunction {
                                         i, res_data, res_offset);
         }
     }
+
+    template <typename ColumnType>
+    void vector_execute_single_md5(const ColumnType* col, size_t input_rows_count, bool is_const,
+                                   ColumnString::Chars& res_data,
+                                   ColumnString::Offsets& res_offset) const {
+        ColumnString::check_chars_length(input_rows_count * MD5_HEX_LENGTH, input_rows_count);
+        res_data.resize(input_rows_count * MD5_HEX_LENGTH);
+        for (size_t i = 0; i < input_rows_count; ++i) {
+            res_offset[i] = (i + 1) * MD5_HEX_LENGTH;
+        }
+        if (input_rows_count == 0) {
+            return;
+        }
+
+        if (is_const) {
+            StringRef data_ref = col->get_data_at(0);
+            const unsigned char* input = reinterpret_cast<const unsigned char*>(data_ref.data);
+            size_t length = data_ref.size;
+            char digest[MD5_HEX_LENGTH];
+            md5_hex_batch(&input, &length, digest, 1);
+            for (size_t i = 0; i < input_rows_count; ++i) {
+                std::memcpy(res_data.data() + i * MD5_HEX_LENGTH, digest, MD5_HEX_LENGTH);
+            }
+            return;
+        }
+
+        std::vector<const unsigned char*> inputs(input_rows_count);
+        std::vector<size_t> lengths(input_rows_count);
+        for (size_t i = 0; i < input_rows_count; ++i) {
+            StringRef data_ref = col->get_data_at(i);
+            inputs[i] = reinterpret_cast<const unsigned char*>(data_ref.data);
+            lengths[i] = data_ref.size;
+        }
+        md5_hex_batch(inputs.data(), lengths.data(), reinterpret_cast<char*>(res_data.data()),
+                      input_rows_count);
+    }
 };
 
 class FunctionStringDigestSHA1 : public IFunction {