diff --git a/milvus-plus-core/src/main/java/org/dromara/milvus/plus/core/conditions/LambdaDeleteWrapper.java b/milvus-plus-core/src/main/java/org/dromara/milvus/plus/core/conditions/LambdaDeleteWrapper.java
index 06922c2..1c2243e 100644
--- a/milvus-plus-core/src/main/java/org/dromara/milvus/plus/core/conditions/LambdaDeleteWrapper.java
+++ b/milvus-plus-core/src/main/java/org/dromara/milvus/plus/core/conditions/LambdaDeleteWrapper.java
@@ -311,6 +311,231 @@ public  class LambdaDeleteWrapper<T> extends AbstractChainWrapper<T> implements
         super.arrayLength(fieldName,length);
         return this;
     }
+    public LambdaDeleteWrapper<T> eq(boolean condition, String fieldName, Object value) {
+        if (condition) {
+            super.eq(fieldName, value);
+        }
+        return this;
+    }
+
+    public LambdaDeleteWrapper<T> ne(boolean condition, String fieldName, Object value) {
+        if (condition) {
+            super.ne(fieldName, value);
+        }
+        return this;
+    }
+
+    public LambdaDeleteWrapper<T> gt(boolean condition, String fieldName, Object value) {
+        if (condition) {
+            super.gt(fieldName, value);
+        }
+        return this;
+    }
+
+    public LambdaDeleteWrapper<T> ge(boolean condition, String fieldName, Object value) {
+        if (condition) {
+            super.ge(fieldName, value);
+        }
+        return this;
+    }
+
+    public LambdaDeleteWrapper<T> lt(boolean condition, String fieldName, Object value) {
+        if (condition) {
+            super.lt(fieldName, value);
+        }
+        return this;
+    }
+
+    public LambdaDeleteWrapper<T> le(boolean condition, String fieldName, Object value) {
+        if (condition) {
+            super.le(fieldName, value);
+        }
+        return this;
+    }
+
+    public LambdaDeleteWrapper<T> between(boolean condition, String fieldName, Object start, Object end) {
+        if (condition) {
+            super.between(fieldName, start, end);
+        }
+        return this;
+    }
+
+
+    public LambdaDeleteWrapper<T> in(boolean condition, String fieldName, List<?> values) {
+        if (condition) {
+            super.in(fieldName, values);
+        }
+        return this;
+    }
+
+    public LambdaDeleteWrapper<T> like(boolean condition, String fieldName, String value) {
+        if (condition) {
+            super.like(fieldName, value);
+        }
+        return this;
+    }
+
+    public LambdaDeleteWrapper<T> jsonContains(boolean condition, String fieldName, Object value) {
+        if (condition) {
+            super.jsonContains(fieldName, value);
+        }
+        return this;
+    }
+
+    public LambdaDeleteWrapper<T> jsonContainsAll(boolean condition, String fieldName, List<?> values) {
+        if (condition) {
+            super.jsonContainsAll(fieldName, values);
+        }
+        return this;
+    }
+
+    public LambdaDeleteWrapper<T> jsonContainsAny(boolean condition, String fieldName, List<?> values) {
+        if (condition) {
+            super.jsonContainsAny(fieldName, values);
+        }
+        return this;
+    }
+
+    public LambdaDeleteWrapper<T> arrayContains(boolean condition, String fieldName, Object value) {
+        if (condition) {
+            super.arrayContains(fieldName, value);
+        }
+        return this;
+    }
+
+    public LambdaDeleteWrapper<T> arrayContainsAll(boolean condition, String fieldName, List<?> values) {
+        if (condition) {
+            super.arrayContainsAll(fieldName, values);
+        }
+        return this;
+    }
+
+    public LambdaDeleteWrapper<T> arrayContainsAny(boolean condition, String fieldName, List<?> values) {
+        if (condition) {
+            super.arrayContainsAny(fieldName, values);
+        }
+        return this;
+    }
+
+    public LambdaDeleteWrapper<T> arrayLength(boolean condition, String fieldName, int length) {
+        if (condition) {
+            super.arrayLength(fieldName, length);
+        }
+        return this;
+    }
+
+    // FieldFunction<T, ?> version methods with condition parameter added
+    public LambdaDeleteWrapper<T> eq(boolean condition, FieldFunction<T, ?> fieldName, Object value) {
+        if (condition) {
+            super.eq(fieldName, value);
+        }
+        return this;
+    }
+
+    public LambdaDeleteWrapper<T> ne(boolean condition, FieldFunction<T, ?> fieldName, Object value) {
+        if (condition) {
+            super.ne(fieldName, value);
+        }
+        return this;
+    }
+
+    public LambdaDeleteWrapper<T> gt(boolean condition, FieldFunction<T, ?> fieldName, Object value) {
+        if (condition) {
+            super.gt(fieldName, value);
+        }
+        return this;
+    }
+
+    public LambdaDeleteWrapper<T> ge(boolean condition, FieldFunction<T, ?> fieldName, Object value) {
+        if (condition) {
+            super.ge(fieldName, value);
+        }
+        return this;
+    }
+
+    public LambdaDeleteWrapper<T> lt(boolean condition, FieldFunction<T, ?> fieldName, Object value) {
+        if (condition) {
+            super.lt(fieldName, value);
+        }
+        return this;
+    }
+
+    public LambdaDeleteWrapper<T> le(boolean condition, FieldFunction<T, ?> fieldName, Object value) {
+        if (condition) {
+            super.le(fieldName, value);
+        }
+        return this;
+    }
+
+    public LambdaDeleteWrapper<T> between(boolean condition, FieldFunction<T, ?> fieldName, Object start, Object end) {
+        if (condition) {
+            super.between(fieldName, start, end);
+        }
+        return this;
+    }
+
+    public LambdaDeleteWrapper<T> in(boolean condition, FieldFunction<T, ?> fieldName, List<?> values) {
+        if (condition) {
+            super.in(fieldName, values);
+        }
+        return this;
+    }
+
+    public LambdaDeleteWrapper<T> like(boolean condition, FieldFunction<T, ?> fieldName, String value) {
+        if (condition) {
+            super.like(fieldName, value);
+        }
+        return this;
+    }
+
+    public LambdaDeleteWrapper<T> jsonContains(boolean condition, FieldFunction<T, ?> fieldName, Object value) {
+        if (condition) {
+            super.jsonContains(fieldName, value);
+        }
+        return this;
+    }
+
+    public LambdaDeleteWrapper<T> jsonContainsAll(boolean condition, FieldFunction<T, ?> fieldName, List<?> values) {
+        if (condition) {
+            super.jsonContainsAll(fieldName, values);
+        }
+        return this;
+    }
+
+    public LambdaDeleteWrapper<T> jsonContainsAny(boolean condition, FieldFunction<T, ?> fieldName, List<?> values) {
+        if (condition) {
+            super.jsonContainsAny(fieldName, values);
+        }
+        return this;
+    }
+
+    public LambdaDeleteWrapper<T> arrayContains(boolean condition, FieldFunction<T, ?> fieldName, Object value) {
+        if (condition) {
+            super.arrayContains(fieldName, value);
+        }
+        return this;
+    }
+
+    public LambdaDeleteWrapper<T> arrayContainsAll(boolean condition, FieldFunction<T, ?> fieldName, List<?> values) {
+        if (condition) {
+            super.arrayContainsAll(fieldName, values);
+        }
+        return this;
+    }
+
+    public LambdaDeleteWrapper<T> arrayContainsAny(boolean condition, FieldFunction<T, ?> fieldName, List<?> values) {
+        if (condition) {
+            super.arrayContainsAny(fieldName, values);
+        }
+        return this;
+    }
+
+    public LambdaDeleteWrapper<T> arrayLength(boolean condition, FieldFunction<T, ?> fieldName, int length) {
+        if (condition) {
+            super.arrayLength(fieldName, length);
+        }
+        return this;
+    }
 
     // Logic operations
     public LambdaDeleteWrapper<T> and(ConditionBuilder<T> other) {
diff --git a/milvus-plus-core/src/main/java/org/dromara/milvus/plus/core/conditions/LambdaQueryWrapper.java b/milvus-plus-core/src/main/java/org/dromara/milvus/plus/core/conditions/LambdaQueryWrapper.java
index 925aab4..05c3557 100644
--- a/milvus-plus-core/src/main/java/org/dromara/milvus/plus/core/conditions/LambdaQueryWrapper.java
+++ b/milvus-plus-core/src/main/java/org/dromara/milvus/plus/core/conditions/LambdaQueryWrapper.java
@@ -133,6 +133,13 @@ public class LambdaQueryWrapper<T> extends AbstractChainWrapper<T> implements Wr
         super.eq(fieldName,value);
         return this;
     }
+    public LambdaQueryWrapper<T> eq(boolean condition,String fieldName, Object value) {
+        if(condition){
+            super.eq(fieldName,value);
+        }
+        return this;
+    }
+
 
     /**
      * 添加不等于条件。
@@ -145,6 +152,12 @@ public class LambdaQueryWrapper<T> extends AbstractChainWrapper<T> implements Wr
         super.ne(fieldName,value);
         return this;
     }
+    public LambdaQueryWrapper<T> ne(boolean condition,String fieldName, Object value) {
+        if(condition){
+            super.ne(fieldName,value);
+        }
+        return this;
+    }
 
     /**
      * 添加大于条件。
@@ -157,6 +170,12 @@ public class LambdaQueryWrapper<T> extends AbstractChainWrapper<T> implements Wr
         super.gt(fieldName,value);
         return this;
     }
+    public LambdaQueryWrapper<T> gt(boolean condition,String fieldName, Object value) {
+        if(condition){
+            super.gt(fieldName,value);
+        }
+        return this;
+    }
 
     /**
      * 添加大于等于条件。
@@ -169,6 +188,12 @@ public class LambdaQueryWrapper<T> extends AbstractChainWrapper<T> implements Wr
         super.ge(fieldName,value);
         return this;
     }
+    public LambdaQueryWrapper<T> ge(boolean condition,String fieldName, Object value) {
+        if(condition){
+            super.ge(fieldName,value);
+        }
+        return this;
+    }
 
     /**
      * 添加小于条件。
@@ -181,6 +206,12 @@ public class LambdaQueryWrapper<T> extends AbstractChainWrapper<T> implements Wr
         super.lt(fieldName,value);
         return this;
     }
+    public LambdaQueryWrapper<T> lt(boolean condition,String fieldName, Object value) {
+        if(condition){
+            super.lt(fieldName,value);
+        }
+        return this;
+    }
 
     /**
      * 添加小于等于条件。
@@ -193,6 +224,12 @@ public class LambdaQueryWrapper<T> extends AbstractChainWrapper<T> implements Wr
         super.le(fieldName,value);
         return this;
     }
+    public LambdaQueryWrapper<T> le(boolean condition,String fieldName, Object value) {
+        if(condition){
+            super.le(fieldName,value);
+        }
+        return this;
+    }
 
     /**
      * 添加范围条件。
@@ -206,6 +243,12 @@ public class LambdaQueryWrapper<T> extends AbstractChainWrapper<T> implements Wr
         super.between(fieldName,start,end);
         return this;
     }
+    public LambdaQueryWrapper<T> between(boolean condition,String fieldName, Object start, Object end) {
+        if(condition){
+            super.between(fieldName,start,end);
+        }
+        return this;
+    }
 
     /**
      * 添加空值检查条件。
@@ -240,6 +283,12 @@ public class LambdaQueryWrapper<T> extends AbstractChainWrapper<T> implements Wr
         super.in(fieldName,values);
         return this;
     }
+    public LambdaQueryWrapper<T> in(boolean condition,String fieldName, List<?> values) {
+        if(condition){
+            super.in(fieldName,values);
+        }
+        return this;
+    }
 
     /**
      * 添加LIKE条件。
@@ -252,42 +301,89 @@ public class LambdaQueryWrapper<T> extends AbstractChainWrapper<T> implements Wr
         super.like(fieldName,value);
         return this;
     }
+    public LambdaQueryWrapper<T> like(boolean condition,String fieldName, String value) {
+        if(condition){
+            super.like(fieldName,value);
+        }
+        return this;
+    }
 
     public LambdaQueryWrapper<T> jsonContains(String fieldName, Object value) {
         super.jsonContains(fieldName,value);
         return this;
     }
+    public LambdaQueryWrapper<T> jsonContains(boolean condition,String fieldName, Object value) {
+        if(condition){
+            super.jsonContains(fieldName,value);
+        }
+        return this;
+    }
 
     public LambdaQueryWrapper<T> jsonContainsAll(String fieldName, List<?> values) {
         super.jsonContainsAll(fieldName,values);
         return this;
     }
-
+    public LambdaQueryWrapper<T> jsonContainsAll(boolean condition,String fieldName, List<?> values) {
+        if(condition){
+            super.jsonContainsAll(fieldName,values);
+        }
+        return this;
+    }
     public LambdaQueryWrapper<T> jsonContainsAny(String fieldName, List<?> values) {
         super.jsonContainsAny(fieldName,values);
         return this;
     }
+    public LambdaQueryWrapper<T> jsonContainsAny(boolean condition,String fieldName, List<?> values) {
+        if(condition){
+            super.jsonContainsAny(fieldName,values);
+        }
+        return this;
+    }
 
     // Array operations
     public LambdaQueryWrapper<T> arrayContains(String fieldName, Object value) {
         super.arrayContains(fieldName,value);
         return this;
     }
+    public LambdaQueryWrapper<T> arrayContains(boolean condition,String fieldName, Object value) {
+        if(condition){
+            super.arrayContains(fieldName,value);
+        }
+        return this;
+    }
 
     public LambdaQueryWrapper<T> arrayContainsAll(String fieldName, List<?> values) {
         super.arrayContainsAll(fieldName,values);
         return this;
     }
+    public LambdaQueryWrapper<T> arrayContainsAll(boolean condition,String fieldName, List<?> values) {
+        if(condition){
+            super.arrayContainsAll(fieldName,values);
+        }
+        return this;
+    }
 
     public LambdaQueryWrapper<T> arrayContainsAny(String fieldName, List<?> values) {
         super.arrayContainsAny(fieldName,values);
         return this;
     }
+    public LambdaQueryWrapper<T> arrayContainsAny(boolean condition,String fieldName, List<?> values) {
+        if(condition){
+            super.arrayContainsAny(fieldName,values);
+        }
+        return this;
+    }
 
     public LambdaQueryWrapper<T> arrayLength(String fieldName, int length) {
         super.arrayLength(fieldName,length);
         return this;
     }
+    public LambdaQueryWrapper<T> arrayLength(boolean condition,String fieldName, int length) {
+        if(condition){
+            super.arrayLength(fieldName,length);
+        }
+        return this;
+    }
 
     public LambdaQueryWrapper<T> eq(FieldFunction<T,?> fieldName, Object value) {
         super.eq(fieldName,value);
@@ -384,6 +480,118 @@ public class LambdaQueryWrapper<T> extends AbstractChainWrapper<T> implements Wr
         return this;
     }
 
+    public LambdaQueryWrapper<T> eq(boolean condition, FieldFunction<T, ?> fieldName, Object value) {
+        if (condition) {
+            super.eq(fieldName, value);
+        }
+        return this;
+    }
+
+    public LambdaQueryWrapper<T> ne(boolean condition, FieldFunction<T, ?> fieldName, Object value) {
+        if (condition) {
+            super.ne(fieldName, value);
+        }
+        return this;
+    }
+
+    public LambdaQueryWrapper<T> gt(boolean condition, FieldFunction<T, ?> fieldName, Object value) {
+        if (condition) {
+            super.gt(fieldName, value);
+        }
+        return this;
+    }
+
+    public LambdaQueryWrapper<T> ge(boolean condition, FieldFunction<T, ?> fieldName, Object value) {
+        if (condition) {
+            super.ge(fieldName, value);
+        }
+        return this;
+    }
+
+    public LambdaQueryWrapper<T> lt(boolean condition, FieldFunction<T, ?> fieldName, Object value) {
+        if (condition) {
+            super.lt(fieldName, value);
+        }
+        return this;
+    }
+
+    public LambdaQueryWrapper<T> le(boolean condition, FieldFunction<T, ?> fieldName, Object value) {
+        if (condition) {
+            super.le(fieldName, value);
+        }
+        return this;
+    }
+
+    public LambdaQueryWrapper<T> between(boolean condition, FieldFunction<T, ?> fieldName, Object start, Object end) {
+        if (condition) {
+            super.between(fieldName, start, end);
+        }
+        return this;
+    }
+
+    public LambdaQueryWrapper<T> in(boolean condition, FieldFunction<T, ?> fieldName, List<?> values) {
+        if (condition) {
+            super.in(fieldName, values);
+        }
+        return this;
+    }
+
+    public LambdaQueryWrapper<T> like(boolean condition, FieldFunction<T, ?> fieldName, String value) {
+        if (condition) {
+            super.like(fieldName, value);
+        }
+        return this;
+    }
+
+    public LambdaQueryWrapper<T> jsonContains(boolean condition, FieldFunction<T, ?> fieldName, Object value) {
+        if (condition) {
+            super.jsonContains(fieldName, value);
+        }
+        return this;
+    }
+
+    public LambdaQueryWrapper<T> jsonContainsAll(boolean condition, FieldFunction<T, ?> fieldName, List<?> values) {
+        if (condition) {
+            super.jsonContainsAll(fieldName, values);
+        }
+        return this;
+    }
+
+    public LambdaQueryWrapper<T> jsonContainsAny(boolean condition, FieldFunction<T, ?> fieldName, List<?> values) {
+        if (condition) {
+            super.jsonContainsAny(fieldName, values);
+        }
+        return this;
+    }
+
+    public LambdaQueryWrapper<T> arrayContains(boolean condition, FieldFunction<T, ?> fieldName, Object value) {
+        if (condition) {
+            super.arrayContains(fieldName, value);
+        }
+        return this;
+    }
+
+    public LambdaQueryWrapper<T> arrayContainsAll(boolean condition, FieldFunction<T, ?> fieldName, List<?> values) {
+        if (condition) {
+            super.arrayContainsAll(fieldName, values);
+        }
+        return this;
+    }
+
+    public LambdaQueryWrapper<T> arrayContainsAny(boolean condition, FieldFunction<T, ?> fieldName, List<?> values) {
+        if (condition) {
+            super.arrayContainsAny(fieldName, values);
+        }
+        return this;
+    }
+
+    public LambdaQueryWrapper<T> arrayLength(boolean condition, FieldFunction<T, ?> fieldName, int length) {
+        if (condition) {
+            super.arrayLength(fieldName, length);
+        }
+        return this;
+    }
+
     // Logic operations
     public LambdaQueryWrapper<T> and(ConditionBuilder<T> other) {
         super.and(other);
diff --git a/milvus-plus-core/src/main/java/org/dromara/milvus/plus/core/conditions/LambdaUpdateWrapper.java b/milvus-plus-core/src/main/java/org/dromara/milvus/plus/core/conditions/LambdaUpdateWrapper.java
index dd6af02..4bcb7ab 100644
--- a/milvus-plus-core/src/main/java/org/dromara/milvus/plus/core/conditions/LambdaUpdateWrapper.java
+++ b/milvus-plus-core/src/main/java/org/dromara/milvus/plus/core/conditions/LambdaUpdateWrapper.java
@@ -318,6 +318,229 @@ public class LambdaUpdateWrapper<T> extends AbstractChainWrapper<T> implements W
         super.arrayLength(fieldName,length);
         return this;
     }
+    public LambdaUpdateWrapper<T> eq(boolean condition, String fieldName, Object value) {
+        if (condition) {
+            super.eq(fieldName, value);
+        }
+        return this;
+    }
+
+    public LambdaUpdateWrapper<T> ne(boolean condition, String fieldName, Object value) {
+        if (condition) {
+            super.ne(fieldName, value);
+        }
+        return this;
+    }
+
+    public LambdaUpdateWrapper<T> gt(boolean condition, String fieldName, Object value) {
+        if (condition) {
+            super.gt(fieldName, value);
+        }
+        return this;
+    }
+
+    public LambdaUpdateWrapper<T> ge(boolean condition, String fieldName, Object value) {
+        if (condition) {
+            super.ge(fieldName, value);
+        }
+        return this;
+    }
+
+    public LambdaUpdateWrapper<T> lt(boolean condition, String fieldName, Object value) {
+        if (condition) {
+            super.lt(fieldName, value);
+        }
+        return this;
+    }
+
+    public LambdaUpdateWrapper<T> le(boolean condition, String fieldName, Object value) {
+        if (condition) {
+            super.le(fieldName, value);
+        }
+        return this;
+    }
+
+    public LambdaUpdateWrapper<T> between(boolean condition, String fieldName, Object start, Object end) {
+        if (condition) {
+            super.between(fieldName, start, end);
+        }
+        return this;
+    }
+
+    public LambdaUpdateWrapper<T> in(boolean condition, String fieldName, List<?> values) {
+        if (condition) {
+            super.in(fieldName, values);
+        }
+        return this;
+    }
+
+    public LambdaUpdateWrapper<T> like(boolean condition, String fieldName, String value) {
+        if (condition) {
+            super.like(fieldName, value);
+        }
+        return this;
+    }
+
+    public LambdaUpdateWrapper<T> jsonContains(boolean condition, String fieldName, Object value) {
+        if (condition) {
+            super.jsonContains(fieldName, value);
+        }
+        return this;
+    }
+
+    public LambdaUpdateWrapper<T> jsonContainsAll(boolean condition, String fieldName, List<?> values) {
+        if (condition) {
+            super.jsonContainsAll(fieldName, values);
+        }
+        return this;
+    }
+
+    public LambdaUpdateWrapper<T> jsonContainsAny(boolean condition, String fieldName, List<?> values) {
+        if (condition) {
+            super.jsonContainsAny(fieldName, values);
+        }
+        return this;
+    }
+
+    public LambdaUpdateWrapper<T> arrayContains(boolean condition, String fieldName, Object value) {
+        if (condition) {
+            super.arrayContains(fieldName, value);
+        }
+        return this;
+    }
+
+    public LambdaUpdateWrapper<T> arrayContainsAll(boolean condition, String fieldName, List<?> values) {
+        if (condition) {
+            super.arrayContainsAll(fieldName, values);
+        }
+        return this;
+    }
+
+    public LambdaUpdateWrapper<T> arrayContainsAny(boolean condition, String fieldName, List<?> values) {
+        if (condition) {
+            super.arrayContainsAny(fieldName, values);
+        }
+        return this;
+    }
+
+    public LambdaUpdateWrapper<T> arrayLength(boolean condition, String fieldName, int length) {
+        if (condition) {
+            super.arrayLength(fieldName, length);
+        }
+        return this;
+    }
+
+    public LambdaUpdateWrapper<T> eq(boolean condition, FieldFunction<T, ?> fieldName, Object value) {
+        if (condition) {
+            super.eq(fieldName, value);
+        }
+        return this;
+    }
+
+    public LambdaUpdateWrapper<T> ne(boolean condition, FieldFunction<T, ?> fieldName, Object value) {
+        if (condition) {
+            super.ne(fieldName, value);
+        }
+        return this;
+    }
+
+    public LambdaUpdateWrapper<T> gt(boolean condition, FieldFunction<T, ?> fieldName, Object value) {
+        if (condition) {
+            super.gt(fieldName, value);
+        }
+        return this;
+    }
+
+    public LambdaUpdateWrapper<T> ge(boolean condition, FieldFunction<T, ?> fieldName, Object value) {
+        if (condition) {
+            super.ge(fieldName, value);
+        }
+        return this;
+    }
+
+    public LambdaUpdateWrapper<T> lt(boolean condition, FieldFunction<T, ?> fieldName, Object value) {
+        if (condition) {
+            super.lt(fieldName, value);
+        }
+        return this;
+    }
+
+    public LambdaUpdateWrapper<T> le(boolean condition, FieldFunction<T, ?> fieldName, Object value) {
+        if (condition) {
+            super.le(fieldName, value);
+        }
+        return this;
+    }
+
+    public LambdaUpdateWrapper<T> between(boolean condition, FieldFunction<T, ?> fieldName, Object start, Object end) {
+        if (condition) {
+            super.between(fieldName, start, end);
+        }
+        return this;
+    }
+
+    public LambdaUpdateWrapper<T> in(boolean condition, FieldFunction<T, ?> fieldName, List<?> values) {
+        if (condition) {
+            super.in(fieldName, values);
+        }
+        return this;
+    }
+
+    public LambdaUpdateWrapper<T> like(boolean condition, FieldFunction<T, ?> fieldName, String value) {
+        if (condition) {
+            super.like(fieldName, value);
+        }
+        return this;
+    }
+
+    public LambdaUpdateWrapper<T> jsonContains(boolean condition, FieldFunction<T, ?> fieldName, Object value) {
+        if (condition) {
+            super.jsonContains(fieldName, value);
+        }
+        return this;
+    }
+
+    public LambdaUpdateWrapper<T> jsonContainsAll(boolean condition, FieldFunction<T, ?> fieldName, List<?> values) {
+        if (condition) {
+            super.jsonContainsAll(fieldName, values);
+        }
+        return this;
+    }
+
+    public LambdaUpdateWrapper<T> jsonContainsAny(boolean condition, FieldFunction<T, ?> fieldName, List<?> values) {
+        if (condition) {
+            super.jsonContainsAny(fieldName, values);
+        }
+        return this;
+    }
+
+    public LambdaUpdateWrapper<T> arrayContains(boolean condition, FieldFunction<T, ?> fieldName, Object value) {
+        if (condition) {
+            super.arrayContains(fieldName, value);
+        }
+        return this;
+    }
+
+    public LambdaUpdateWrapper<T> arrayContainsAll(boolean condition, FieldFunction<T, ?> fieldName, List<?> values) {
+        if (condition) {
+            super.arrayContainsAll(fieldName, values);
+        }
+        return this;
+    }
+
+    public LambdaUpdateWrapper<T> arrayContainsAny(boolean condition, FieldFunction<T, ?> fieldName, List<?> values) {
+        if (condition) {
+            super.arrayContainsAny(fieldName, values);
+        }
+        return this;
+    }
+
+    public LambdaUpdateWrapper<T> arrayLength(boolean condition, FieldFunction<T, ?> fieldName, int length) {
+        if (condition) {
+            super.arrayLength(fieldName, length);
+        }
+        return this;
+    }
 
     // Logic operations
     public LambdaUpdateWrapper<T> and(ConditionBuilder<T> other) {