[feature](exec) support short circuit evaluation for condition expr (#59830)

```mysql
mysql>    set enable_strict_cast = true;
Query OK, 0 rows affected (0.00 sec)

mysql>     select count(
    ->         if(number < 128 , 
    ->           cast(number as tinyint), 
    ->           cast(number as String))
    ->       ) from numbers("number" = "300");
ERROR 1105 (HY000): errCode = 2, detailMessage = (127.0.0.1)[INVALID_ARGUMENT]Value 128 out of range for type tinyint
mysql>    set short_circuit_evaluation = true;
Query OK, 0 rows affected (0.00 sec)

mysql>     select count(
    ->         if(number < 128 , 
    ->           cast(number as tinyint), 
    ->           cast(number as String))
    ->       ) from numbers("number" = "300");
+-----------------------------------------------------------------------------------------------------------------+
| count(
        if(number < 128 , 
          cast(number as tinyint), 
          cast(number as String))
      ) |
+-----------------------------------------------------------------------------------------------------------------+
|                                                                                                             300 |
+-----------------------------------------------------------------------------------------------------------------+
```

Author: Mryange

be/src/vec/columns/column_const.h

@@ -162,7 +162,8 @@ class ColumnConst final : public COWHelper<IColumn, ColumnConst> {
 
     void insert_indices_from(const IColumn& src, const uint32_t* indices_begin,
                              const uint32_t* indices_end) override {
-        if (!is_column_const(src) || compare_at(0, 0, src, 0) != 0) {
+        if (this->s != 0 /*not empty*/ &&
+            (!is_column_const(src) || compare_at(0, 0, src, 0) != 0)) {
             throw Exception(
                     ErrorCode::INTERNAL_ERROR,
                     "ColumnConst::insert_indices_from: src is not const or not equal to dst");

be/src/vec/exprs/lambda_function/lambda_function.h

@@ -21,6 +21,7 @@
 
 #include "common/status.h"
 #include "vec/core/block.h"
+#include "vec/exprs/vexpr.h"
 #include "vec/exprs/vexpr_context.h"
 
 namespace doris::vectorized {
@@ -37,7 +38,7 @@ class LambdaFunction {
     }
 
     virtual doris::Status execute(VExprContext* context, const doris::vectorized::Block* block,
-                                  size_t count, ColumnPtr& result_column,
+                                  Selector* selector, size_t count, ColumnPtr& result_column,
                                   const DataTypePtr& result_type,
                                   const VExprSPtrs& children) const = 0;
 

be/src/vec/exprs/lambda_function/varray_filter_function.cpp

@@ -53,7 +53,7 @@ class ArrayFilterFunction : public LambdaFunction {
     std::string get_name() const override { return name; }
 
     doris::Status execute(VExprContext* context, const doris::vectorized::Block* block,
-                          size_t output_count, ColumnPtr& result_column,
+                          Selector* expr_selector, size_t output_count, ColumnPtr& result_column,
                           const DataTypePtr& result_type,
                           const VExprSPtrs& children) const override {
         ///* array_filter(array, array<boolean>) *///
@@ -62,9 +62,11 @@ class ArrayFilterFunction : public LambdaFunction {
 
         DCHECK_EQ(children.size(), 2);
         ColumnPtr column_ptr_0;
-        RETURN_IF_ERROR(children[0]->execute_column(context, block, output_count, column_ptr_0));
+        RETURN_IF_ERROR(children[0]->execute_column(context, block, expr_selector, output_count,
+                                                    column_ptr_0));
         ColumnPtr column_ptr_1;
-        RETURN_IF_ERROR(children[1]->execute_column(context, block, output_count, column_ptr_1));
+        RETURN_IF_ERROR(children[1]->execute_column(context, block, expr_selector, output_count,
+                                                    column_ptr_1));
 
         //2. get first and second array column
         auto first_column = column_ptr_0->convert_to_full_column_if_const();

be/src/vec/exprs/lambda_function/varray_map_function.cpp

@@ -77,8 +77,8 @@ class ArrayMapFunction : public LambdaFunction {
 
     std::string get_name() const override { return name; }
 
-    Status execute(VExprContext* context, const vectorized::Block* block, size_t count,
-                   ColumnPtr& result_column, const DataTypePtr& result_type,
+    Status execute(VExprContext* context, const vectorized::Block* block, Selector* expr_selector,
+                   size_t count, ColumnPtr& result_column, const DataTypePtr& result_type,
                    const VExprSPtrs& children) const override {
         LambdaArgs args_info;
         // collect used slot ref in lambda function body
@@ -112,7 +112,8 @@ class ArrayMapFunction : public LambdaFunction {
         ColumnsWithTypeAndName arguments(children.size() - 1);
         for (int i = 1; i < children.size(); ++i) {
             ColumnPtr column;
-            RETURN_IF_ERROR(children[i]->execute_column(context, block, count, column));
+            RETURN_IF_ERROR(
+                    children[i]->execute_column(context, block, expr_selector, count, column));
             arguments[i - 1].column = column;
             arguments[i - 1].type = children[i]->execute_type(block);
             arguments[i - 1].name = children[i]->expr_name();
@@ -284,8 +285,8 @@ class ArrayMapFunction : public LambdaFunction {
             //3. child[0]->execute(new_block)
 
             ColumnPtr res_col;
-            RETURN_IF_ERROR(children[0]->execute_column(context, &lambda_block, lambda_block.rows(),
-                                                        res_col));
+            RETURN_IF_ERROR(children[0]->execute_column(context, &lambda_block, expr_selector,
+                                                        lambda_block.rows(), res_col));
             res_col = res_col->convert_to_full_column_if_const();
             res_type = children[0]->execute_type(&lambda_block);
 

be/src/vec/exprs/lambda_function/varray_sort_function.cpp

@@ -67,16 +67,17 @@ class ArraySortFunction : public LambdaFunction {
 
     std::string get_name() const override { return name; }
 
-    Status execute(VExprContext* context, const vectorized::Block* block, size_t count,
-                   ColumnPtr& result_column, const DataTypePtr& result_type,
+    Status execute(VExprContext* context, const vectorized::Block* block, Selector* expr_selector,
+                   size_t count, ColumnPtr& result_column, const DataTypePtr& result_type,
                    const VExprSPtrs& children) const override {
         ///* array_sort(lambda, arg) *///
 
         DCHECK_EQ(children.size(), 2);
 
         // 1. get data, we need to obtain this actual data and type.
         ColumnPtr column_ptr;
-        RETURN_IF_ERROR(children[1]->execute_column(context, block, count, column_ptr));
+        RETURN_IF_ERROR(
+                children[1]->execute_column(context, block, expr_selector, count, column_ptr));
         DataTypePtr type_ptr = children[1]->execute_type(block);
 
         auto column = column_ptr->convert_to_full_column_if_const();