feat(expr): Implement IS [NOT] DISTINCT FROM expression

e2e_test/batch/basic_test.slt

@@ -408,5 +408,34 @@ select extract(year from date '1993-09-01');
 ----
 1993
 
+statement ok
+drop table t;
+
+# Test for distinct from
+statement ok
+create table t (v1 int, v2 int);
+
+statement ok
+insert into t values (null, null), (1, null), (null, 2), (3, 3), (4, 5);
+
+query I
+select v1 IS DISTINCT FROM v2 from t;
+----
+f
+t
+t
+f
+t
+
+query II
+select v1 IS NOT DISTINCT FROM v2 from t;
+----
+t
+f
+f
+t
+f
+
+
 statement ok
 drop table t;

src/frontend/src/binder/expr/mod.rs

@@ -66,6 +66,8 @@ impl Binder {
             Expr::IsNotTrue(expr) => self.bind_is_operator(ExprType::IsNotTrue, *expr),
             Expr::IsFalse(expr) => self.bind_is_operator(ExprType::IsFalse, *expr),
             Expr::IsNotFalse(expr) => self.bind_is_operator(ExprType::IsNotFalse, *expr),
+            Expr::IsDistinctFrom(left, right) => self.bind_distinct_from(false, *left, *right),
+            Expr::IsNotDistinctFrom(left, right) => self.bind_distinct_from(true, *left, *right),
             Expr::Case {
                 operand,
                 conditions,
@@ -302,6 +304,51 @@ impl Binder {
         Ok(FunctionCall::new(func_type, vec![expr])?.into())
     }
 
+    pub(super) fn bind_distinct_from(
+        &mut self,
+        negated: bool,
+        left: Expr,
+        right: Expr,
+    ) -> Result<ExprImpl> {
+        let left = self.bind_expr(left)?;
+        let right = self.bind_expr(right)?;
+        let both_not_null = FunctionCall::new(
+            ExprType::And,
+            vec![
+                FunctionCall::new(ExprType::IsNotNull, vec![left.clone()])?.into(),
+                FunctionCall::new(ExprType::IsNotNull, vec![right.clone()])?.into(),
+            ],
+        );
+
+        let func_call = FunctionCall::new(
+            ExprType::Or,
+            vec![
+                FunctionCall::new(
+                    ExprType::And,
+                    vec![
+                        FunctionCall::new(ExprType::IsNull, vec![left.clone()])?.into(),
+                        FunctionCall::new(ExprType::IsNull, vec![right.clone()])?.into(),
+                    ],
+                )?
+                .into(),
+                FunctionCall::new(
+                    ExprType::And,
+                    vec![
+                        both_not_null?.into(),
+                        FunctionCall::new(ExprType::Equal, vec![left, right])?.into(),
+                    ],
+                )?
+                .into(),
+            ],
+        );
+
+        if negated {
+            Ok(func_call?.into())
+        } else {
+            Ok(FunctionCall::new(ExprType::Not, vec![func_call?.into()])?.into())
+        }
+    }
+
     pub(super) fn bind_cast(&mut self, expr: Expr, data_type: AstDataType) -> Result<ExprImpl> {
         self.bind_expr(expr)?
             .cast_explicit(bind_data_type(&data_type)?)