Merge pull request #10594 from andylokandy/validity

Author: sundy-li

docs/doc/15-sql-functions/11-conditional-functions/index.md

@@ -4,11 +4,10 @@ title: 'Conditional Functions'
 
 | Function                                                   | Description                                                                                                                                              | Example                                                                          | Result   |
 |------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------|----------|
-| **IF(expr1, expr2, expr3)**                                | Return expr2 if expr1 is TRUE. Otherwise return expr3. expr2 and expr3 must have the lowest common type.                                                 | **IF(1 > 2, 3, 4)**                                                              | 4        |
+| **IF(cond1, expr1, [cond2, expr2, ...], expr_else)**       | If cond1 is TRUE, it returns expr1. Otherwise if cond2 is TRUE, it returns expr2, and so on.                                                             | **IF(1 > 2, 3, 4 < 5, 6, 7)**                                                    | 6        |
 | **IFNULL(expr1, expr2)**                                   | Return expr1 if it is not NULL. Otherwise return expr2. They must have the same data type.                                                               | **IFNULL(0, NULL)**                                                              | 0        |
 | **value [ NOT ] IN (value1, value2, ...)**                 | Check whether value is (or is not) one of the members of an explicit list.                                                                               | **1 not in (2, 3)**                                                              | 1(TRUE)  |
 | **expr1 IS [ NOT ] DISTINCT FROM expr2**                   | Compares whether two expressions are equal (or not equal) with awareness of nullability, meaning it treats NULLs as known values for comparing equality. | **NULL is distinct from NULL**                                                   | 0(FALSE) |
 | **IS_NOT_NULL(expr)**                                      | Check whether the value is not NULL.                                                                                                                     | **IS_NOT_NULL(1)**                                                               | 1(TRUE)  |
 | **IS_NULL(expr)**                                          | Check whether the value is NULL.                                                                                                                         | **IS_NULL(1)**                                                                   | 0(FALSE) |
-| **MULTI_IF(cond1, expr1, [cond2, expr2, ...], expr_else)** | If cond1 is TRUE, it returns expr1. Otherwise if cond2 is TRUE, it returns expr2, and so on.                                                             | **MULTI_IF(1 > 2, 3, 4 < 5, 6, 7)**                                              | 6        |
 | **NULLIF(expr1, expr2)**                                   | Return NULL if two expressions are equal. Otherwise return expr1. They must have the same data type.                                                     | **NULLIF(0, NULL)**                                                              | 0        |

src/query/codegen/src/bin/codegen.rs

@@ -13,6 +13,6 @@
 // limitations under the License.
 
 fn main() {
-    codegen::writes::codegen_arithmetic_type_v2();
+    codegen::writes::codegen_arithmetic_type();
     codegen::writes::codegen_register();
 }

src/query/codegen/src/writes/arithmetics_type.rs

@@ -29,7 +29,7 @@ pub enum OP {
     Super,
 }
 
-pub fn codegen_arithmetic_type_v2() {
+pub fn codegen_arithmetic_type() {
     let dest = Path::new("src/query/expression/src/utils");
     let path = dest.join("arithmetics_type.rs");
 

src/query/codegen/src/writes/register.rs

@@ -634,7 +634,8 @@ pub fn codegen_register() {
 
                 format!(
                     "({arm_pat}) => {{
-                        let validity = {and_validity};
+                        let and_validity = {and_validity};
+                        let validity = ctx.validity.as_ref().map(|valid| valid & (&and_validity)).unwrap_or(and_validity);
                         ctx.validity = Some(validity.clone());
                         let column = func({func_arg} ctx).into_column().unwrap();
                         Value::Column(NullableColumn {{ column, validity }})
@@ -741,11 +742,12 @@ pub fn codegen_register() {
 
                 format!(
                     "({arm_pat}) => {{
-                        let validity = {and_validity};
+                        let and_validity = {and_validity};
+                        let validity = ctx.validity.as_ref().map(|valid| valid & (&and_validity)).unwrap_or(and_validity);
                         ctx.validity = Some(validity.clone());
                         let nullable_column = func({func_arg} ctx).into_column().unwrap();
-                        let merge_validity = common_arrow::arrow::bitmap::and(&validity, &nullable_column.validity);
-                        Value::Column(NullableColumn {{ column: nullable_column.column, validity: merge_validity }})
+                        let combine_validity = common_arrow::arrow::bitmap::and(&validity, &nullable_column.validity);
+                        Value::Column(NullableColumn {{ column: nullable_column.column, validity: combine_validity }})
                     }}"
                 )
             })