fix #644 check expired job logs

src/main/java/org/codelibs/fess/app/service/JobLogService.java

@@ -34,6 +34,8 @@ public class JobLogService {
     @Resource
     protected JobLogBhv jobLogBhv;
 
+    protected long expiredJobInterval = 2 * 60 * 60 * 1000L; // 2hours
+
     public List<JobLog> getJobLogList(final JobLogPager jobLogPager) {
 
         final PagingResultBean<JobLog> jobLogList = jobLogBhv.selectPage(cb -> {
@@ -98,4 +100,26 @@ public class JobLogService {
         });
     }
 
+    public void updateStatus() {
+        final long expiry = ComponentUtil.getSystemHelper().getCurrentTimeAsLong() - expiredJobInterval;
+        final List<JobLog> list = jobLogBhv.selectList(cb -> {
+            cb.query().bool((must, should, mustNot, filter) -> {
+                must.setLastUpdated_LessEqual(expiry);
+                mustNot.setEndTime_Exists();
+            });
+        });
+        if (!list.isEmpty()) {
+            list.forEach(jobLog -> {
+                jobLog.setJobStatus(Constants.FAIL);
+                jobLog.setScriptResult("No response from Job.");
+                jobLog.setEndTime(ComponentUtil.getSystemHelper().getCurrentTimeAsLong());
+            });
+            jobLogBhv.batchUpdate(list);
+        }
+    }
+
+    public void setExpiredJobInterval(long expiredJobInterval) {
+        this.expiredJobInterval = expiredJobInterval;
+    }
+
 }

src/main/java/org/codelibs/fess/es/config/allcommon/EsAbstractConditionQuery.java

@@ -33,17 +33,22 @@ import org.dbflute.dbmeta.name.ColumnSqlName;
 import org.dbflute.exception.InvalidQueryRegisteredException;
 import org.dbflute.util.Srl;
 import org.elasticsearch.index.query.BoolQueryBuilder;
+import org.elasticsearch.index.query.CommonTermsQueryBuilder;
+import org.elasticsearch.index.query.ExistsQueryBuilder;
 import org.elasticsearch.index.query.FuzzyQueryBuilder;
 import org.elasticsearch.index.query.IdsQueryBuilder;
 import org.elasticsearch.index.query.MatchAllQueryBuilder;
 import org.elasticsearch.index.query.MatchQueryBuilder;
+import org.elasticsearch.index.query.MoreLikeThisQueryBuilder;
 import org.elasticsearch.index.query.PrefixQueryBuilder;
 import org.elasticsearch.index.query.QueryBuilder;
 import org.elasticsearch.index.query.QueryBuilders;
 import org.elasticsearch.index.query.QueryStringQueryBuilder;
 import org.elasticsearch.index.query.RangeQueryBuilder;
+import org.elasticsearch.index.query.RegexpQueryBuilder;
 import org.elasticsearch.index.query.TermQueryBuilder;
 import org.elasticsearch.index.query.TermsQueryBuilder;
+import org.elasticsearch.index.query.WildcardQueryBuilder;
 import org.elasticsearch.search.sort.FieldSortBuilder;
 import org.elasticsearch.search.sort.SortBuilders;
 import org.elasticsearch.search.sort.SortOrder;
@@ -257,6 +262,39 @@ public abstract class EsAbstractConditionQuery implements ConditionQuery {
         }
     }
 
+    protected ExistsQueryBuilder regExistsQ(String name) {
+        ExistsQueryBuilder existsQuery = QueryBuilders.existsQuery(name);
+        regQ(existsQuery);
+        return existsQuery;
+    }
+
+    protected WildcardQueryBuilder regWildcardQ(String name, String wildcard) {
+        checkEsInvalidQuery(name, wildcard);
+        WildcardQueryBuilder wildcardQuery = QueryBuilders.wildcardQuery(name, wildcard);
+        regQ(wildcardQuery);
+        return wildcardQuery;
+    }
+
+    protected RegexpQueryBuilder regRegexpQ(String name, String regexp) {
+        checkEsInvalidQuery(name, regexp);
+        RegexpQueryBuilder regexpQuery = QueryBuilders.regexpQuery(name, regexp);
+        regQ(regexpQuery);
+        return regexpQuery;
+    }
+
+    protected CommonTermsQueryBuilder regCommonTermsQ(String name, Object text) {
+        checkEsInvalidQuery(name, text);
+        CommonTermsQueryBuilder commonTermsQuery = QueryBuilders.commonTermsQuery(name, text);
+        regQ(commonTermsQuery);
+        return commonTermsQuery;
+    }
+
+    protected MoreLikeThisQueryBuilder regMoreLikeThisQueryQ(String name) {
+        MoreLikeThisQueryBuilder moreLikeThisQuery = QueryBuilders.moreLikeThisQuery(name);
+        regQ(moreLikeThisQuery);
+        return moreLikeThisQuery;
+    }
+
     protected void regQ(QueryBuilder builder) {
         assertObjectNotNull("builder", builder);
         if (queryBuilderList == null) {

src/main/java/org/codelibs/fess/es/config/cbean/cq/bs/BsBadWordCQ.java

@@ -22,13 +22,17 @@ import org.codelibs.fess.es.config.allcommon.EsAbstractConditionQuery;
 import org.codelibs.fess.es.config.cbean.cq.BadWordCQ;
 import org.dbflute.cbean.ckey.ConditionKey;
 import org.elasticsearch.index.query.BoolQueryBuilder;
+import org.elasticsearch.index.query.CommonTermsQueryBuilder;
+import org.elasticsearch.index.query.ExistsQueryBuilder;
 import org.elasticsearch.index.query.FuzzyQueryBuilder;
 import org.elasticsearch.index.query.IdsQueryBuilder;
 import org.elasticsearch.index.query.MatchQueryBuilder;
 import org.elasticsearch.index.query.PrefixQueryBuilder;
 import org.elasticsearch.index.query.RangeQueryBuilder;
+import org.elasticsearch.index.query.RegexpQueryBuilder;
 import org.elasticsearch.index.query.TermQueryBuilder;
 import org.elasticsearch.index.query.TermsQueryBuilder;
+import org.elasticsearch.index.query.WildcardQueryBuilder;
 
 /**
  * @author ESFlute (using FreeGen)
@@ -267,6 +271,28 @@ public abstract class BsBadWordCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setCreatedBy_Wildcard(String createdBy) {
+        setCreatedBy_Wildcard(createdBy, null);
+    }
+
+    public void setCreatedBy_Wildcard(String createdBy, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Regexp(String createdBy) {
+        setCreatedBy_Regexp(createdBy, null);
+    }
+
+    public void setCreatedBy_Regexp(String createdBy, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setCreatedBy_GreaterThan(String createdBy) {
         setCreatedBy_GreaterThan(createdBy, null);
     }
@@ -311,6 +337,28 @@ public abstract class BsBadWordCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setCreatedBy_Exists() {
+        setCreatedBy_Exists(null);
+    }
+
+    public void setCreatedBy_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("createdBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_CommonTerms(String createdBy) {
+        setCreatedBy_CommonTerms(createdBy, null);
+    }
+
+    public void setCreatedBy_CommonTerms(String createdBy, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsBadWordCQ addOrderBy_CreatedBy_Asc() {
         regOBA("createdBy");
         return this;
@@ -463,6 +511,28 @@ public abstract class BsBadWordCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setCreatedTime_Exists() {
+        setCreatedTime_Exists(null);
+    }
+
+    public void setCreatedTime_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("createdTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_CommonTerms(Long createdTime) {
+        setCreatedTime_CommonTerms(createdTime, null);
+    }
+
+    public void setCreatedTime_CommonTerms(Long createdTime, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("createdTime", createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsBadWordCQ addOrderBy_CreatedTime_Asc() {
         regOBA("createdTime");
         return this;
@@ -582,6 +652,28 @@ public abstract class BsBadWordCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setSuggestWord_Wildcard(String suggestWord) {
+        setSuggestWord_Wildcard(suggestWord, null);
+    }
+
+    public void setSuggestWord_Wildcard(String suggestWord, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("suggestWord", suggestWord);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSuggestWord_Regexp(String suggestWord) {
+        setSuggestWord_Regexp(suggestWord, null);
+    }
+
+    public void setSuggestWord_Regexp(String suggestWord, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("suggestWord", suggestWord);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setSuggestWord_GreaterThan(String suggestWord) {
         setSuggestWord_GreaterThan(suggestWord, null);
     }
@@ -626,6 +718,28 @@ public abstract class BsBadWordCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setSuggestWord_Exists() {
+        setSuggestWord_Exists(null);
+    }
+
+    public void setSuggestWord_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("suggestWord");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSuggestWord_CommonTerms(String suggestWord) {
+        setSuggestWord_CommonTerms(suggestWord, null);
+    }
+
+    public void setSuggestWord_CommonTerms(String suggestWord, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("suggestWord", suggestWord);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsBadWordCQ addOrderBy_SuggestWord_Asc() {
         regOBA("suggestWord");
         return this;
@@ -745,6 +859,28 @@ public abstract class BsBadWordCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setTargetLabel_Wildcard(String targetLabel) {
+        setTargetLabel_Wildcard(targetLabel, null);
+    }
+
+    public void setTargetLabel_Wildcard(String targetLabel, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("targetLabel", targetLabel);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTargetLabel_Regexp(String targetLabel) {
+        setTargetLabel_Regexp(targetLabel, null);
+    }
+
+    public void setTargetLabel_Regexp(String targetLabel, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("targetLabel", targetLabel);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setTargetLabel_GreaterThan(String targetLabel) {
         setTargetLabel_GreaterThan(targetLabel, null);
     }
@@ -789,6 +925,28 @@ public abstract class BsBadWordCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setTargetLabel_Exists() {
+        setTargetLabel_Exists(null);
+    }
+
+    public void setTargetLabel_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("targetLabel");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTargetLabel_CommonTerms(String targetLabel) {
+        setTargetLabel_CommonTerms(targetLabel, null);
+    }
+
+    public void setTargetLabel_CommonTerms(String targetLabel, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("targetLabel", targetLabel);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsBadWordCQ addOrderBy_TargetLabel_Asc() {
         regOBA("targetLabel");
         return this;
@@ -908,6 +1066,28 @@ public abstract class BsBadWordCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setTargetRole_Wildcard(String targetRole) {
+        setTargetRole_Wildcard(targetRole, null);
+    }
+
+    public void setTargetRole_Wildcard(String targetRole, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("targetRole", targetRole);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTargetRole_Regexp(String targetRole) {
+        setTargetRole_Regexp(targetRole, null);
+    }
+
+    public void setTargetRole_Regexp(String targetRole, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("targetRole", targetRole);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setTargetRole_GreaterThan(String targetRole) {
         setTargetRole_GreaterThan(targetRole, null);
     }
@@ -952,6 +1132,28 @@ public abstract class BsBadWordCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setTargetRole_Exists() {
+        setTargetRole_Exists(null);
+    }
+
+    public void setTargetRole_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("targetRole");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTargetRole_CommonTerms(String targetRole) {
+        setTargetRole_CommonTerms(targetRole, null);
+    }
+
+    public void setTargetRole_CommonTerms(String targetRole, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("targetRole", targetRole);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsBadWordCQ addOrderBy_TargetRole_Asc() {
         regOBA("targetRole");
         return this;
@@ -1071,6 +1273,28 @@ public abstract class BsBadWordCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUpdatedBy_Wildcard(String updatedBy) {
+        setUpdatedBy_Wildcard(updatedBy, null);
+    }
+
+    public void setUpdatedBy_Wildcard(String updatedBy, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Regexp(String updatedBy) {
+        setUpdatedBy_Regexp(updatedBy, null);
+    }
+
+    public void setUpdatedBy_Regexp(String updatedBy, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setUpdatedBy_GreaterThan(String updatedBy) {
         setUpdatedBy_GreaterThan(updatedBy, null);
     }
@@ -1115,6 +1339,28 @@ public abstract class BsBadWordCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUpdatedBy_Exists() {
+        setUpdatedBy_Exists(null);
+    }
+
+    public void setUpdatedBy_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("updatedBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_CommonTerms(String updatedBy) {
+        setUpdatedBy_CommonTerms(updatedBy, null);
+    }
+
+    public void setUpdatedBy_CommonTerms(String updatedBy, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsBadWordCQ addOrderBy_UpdatedBy_Asc() {
         regOBA("updatedBy");
         return this;
@@ -1267,6 +1513,28 @@ public abstract class BsBadWordCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUpdatedTime_Exists() {
+        setUpdatedTime_Exists(null);
+    }
+
+    public void setUpdatedTime_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("updatedTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_CommonTerms(Long updatedTime) {
+        setUpdatedTime_CommonTerms(updatedTime, null);
+    }
+
+    public void setUpdatedTime_CommonTerms(Long updatedTime, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("updatedTime", updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsBadWordCQ addOrderBy_UpdatedTime_Asc() {
         regOBA("updatedTime");
         return this;

src/main/java/org/codelibs/fess/es/config/cbean/cq/bs/BsBoostDocumentRuleCQ.java

@@ -22,13 +22,17 @@ import org.codelibs.fess.es.config.allcommon.EsAbstractConditionQuery;
 import org.codelibs.fess.es.config.cbean.cq.BoostDocumentRuleCQ;
 import org.dbflute.cbean.ckey.ConditionKey;
 import org.elasticsearch.index.query.BoolQueryBuilder;
+import org.elasticsearch.index.query.CommonTermsQueryBuilder;
+import org.elasticsearch.index.query.ExistsQueryBuilder;
 import org.elasticsearch.index.query.FuzzyQueryBuilder;
 import org.elasticsearch.index.query.IdsQueryBuilder;
 import org.elasticsearch.index.query.MatchQueryBuilder;
 import org.elasticsearch.index.query.PrefixQueryBuilder;
 import org.elasticsearch.index.query.RangeQueryBuilder;
+import org.elasticsearch.index.query.RegexpQueryBuilder;
 import org.elasticsearch.index.query.TermQueryBuilder;
 import org.elasticsearch.index.query.TermsQueryBuilder;
+import org.elasticsearch.index.query.WildcardQueryBuilder;
 
 /**
  * @author ESFlute (using FreeGen)
@@ -268,6 +272,28 @@ public abstract class BsBoostDocumentRuleCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setBoostExpr_Wildcard(String boostExpr) {
+        setBoostExpr_Wildcard(boostExpr, null);
+    }
+
+    public void setBoostExpr_Wildcard(String boostExpr, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("boostExpr", boostExpr);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setBoostExpr_Regexp(String boostExpr) {
+        setBoostExpr_Regexp(boostExpr, null);
+    }
+
+    public void setBoostExpr_Regexp(String boostExpr, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("boostExpr", boostExpr);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setBoostExpr_GreaterThan(String boostExpr) {
         setBoostExpr_GreaterThan(boostExpr, null);
     }
@@ -312,6 +338,28 @@ public abstract class BsBoostDocumentRuleCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setBoostExpr_Exists() {
+        setBoostExpr_Exists(null);
+    }
+
+    public void setBoostExpr_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("boostExpr");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setBoostExpr_CommonTerms(String boostExpr) {
+        setBoostExpr_CommonTerms(boostExpr, null);
+    }
+
+    public void setBoostExpr_CommonTerms(String boostExpr, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("boostExpr", boostExpr);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsBoostDocumentRuleCQ addOrderBy_BoostExpr_Asc() {
         regOBA("boostExpr");
         return this;
@@ -431,6 +479,28 @@ public abstract class BsBoostDocumentRuleCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setCreatedBy_Wildcard(String createdBy) {
+        setCreatedBy_Wildcard(createdBy, null);
+    }
+
+    public void setCreatedBy_Wildcard(String createdBy, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Regexp(String createdBy) {
+        setCreatedBy_Regexp(createdBy, null);
+    }
+
+    public void setCreatedBy_Regexp(String createdBy, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setCreatedBy_GreaterThan(String createdBy) {
         setCreatedBy_GreaterThan(createdBy, null);
     }
@@ -475,6 +545,28 @@ public abstract class BsBoostDocumentRuleCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setCreatedBy_Exists() {
+        setCreatedBy_Exists(null);
+    }
+
+    public void setCreatedBy_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("createdBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_CommonTerms(String createdBy) {
+        setCreatedBy_CommonTerms(createdBy, null);
+    }
+
+    public void setCreatedBy_CommonTerms(String createdBy, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsBoostDocumentRuleCQ addOrderBy_CreatedBy_Asc() {
         regOBA("createdBy");
         return this;
@@ -627,6 +719,28 @@ public abstract class BsBoostDocumentRuleCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setCreatedTime_Exists() {
+        setCreatedTime_Exists(null);
+    }
+
+    public void setCreatedTime_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("createdTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_CommonTerms(Long createdTime) {
+        setCreatedTime_CommonTerms(createdTime, null);
+    }
+
+    public void setCreatedTime_CommonTerms(Long createdTime, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("createdTime", createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsBoostDocumentRuleCQ addOrderBy_CreatedTime_Asc() {
         regOBA("createdTime");
         return this;
@@ -779,6 +893,28 @@ public abstract class BsBoostDocumentRuleCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setSortOrder_Exists() {
+        setSortOrder_Exists(null);
+    }
+
+    public void setSortOrder_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("sortOrder");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_CommonTerms(Integer sortOrder) {
+        setSortOrder_CommonTerms(sortOrder, null);
+    }
+
+    public void setSortOrder_CommonTerms(Integer sortOrder, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("sortOrder", sortOrder);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsBoostDocumentRuleCQ addOrderBy_SortOrder_Asc() {
         regOBA("sortOrder");
         return this;
@@ -898,6 +1034,28 @@ public abstract class BsBoostDocumentRuleCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUpdatedBy_Wildcard(String updatedBy) {
+        setUpdatedBy_Wildcard(updatedBy, null);
+    }
+
+    public void setUpdatedBy_Wildcard(String updatedBy, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Regexp(String updatedBy) {
+        setUpdatedBy_Regexp(updatedBy, null);
+    }
+
+    public void setUpdatedBy_Regexp(String updatedBy, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setUpdatedBy_GreaterThan(String updatedBy) {
         setUpdatedBy_GreaterThan(updatedBy, null);
     }
@@ -942,6 +1100,28 @@ public abstract class BsBoostDocumentRuleCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUpdatedBy_Exists() {
+        setUpdatedBy_Exists(null);
+    }
+
+    public void setUpdatedBy_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("updatedBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_CommonTerms(String updatedBy) {
+        setUpdatedBy_CommonTerms(updatedBy, null);
+    }
+
+    public void setUpdatedBy_CommonTerms(String updatedBy, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsBoostDocumentRuleCQ addOrderBy_UpdatedBy_Asc() {
         regOBA("updatedBy");
         return this;
@@ -1094,6 +1274,28 @@ public abstract class BsBoostDocumentRuleCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUpdatedTime_Exists() {
+        setUpdatedTime_Exists(null);
+    }
+
+    public void setUpdatedTime_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("updatedTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_CommonTerms(Long updatedTime) {
+        setUpdatedTime_CommonTerms(updatedTime, null);
+    }
+
+    public void setUpdatedTime_CommonTerms(Long updatedTime, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("updatedTime", updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsBoostDocumentRuleCQ addOrderBy_UpdatedTime_Asc() {
         regOBA("updatedTime");
         return this;
@@ -1213,6 +1415,28 @@ public abstract class BsBoostDocumentRuleCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUrlExpr_Wildcard(String urlExpr) {
+        setUrlExpr_Wildcard(urlExpr, null);
+    }
+
+    public void setUrlExpr_Wildcard(String urlExpr, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("urlExpr", urlExpr);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUrlExpr_Regexp(String urlExpr) {
+        setUrlExpr_Regexp(urlExpr, null);
+    }
+
+    public void setUrlExpr_Regexp(String urlExpr, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("urlExpr", urlExpr);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setUrlExpr_GreaterThan(String urlExpr) {
         setUrlExpr_GreaterThan(urlExpr, null);
     }
@@ -1257,6 +1481,28 @@ public abstract class BsBoostDocumentRuleCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUrlExpr_Exists() {
+        setUrlExpr_Exists(null);
+    }
+
+    public void setUrlExpr_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("urlExpr");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUrlExpr_CommonTerms(String urlExpr) {
+        setUrlExpr_CommonTerms(urlExpr, null);
+    }
+
+    public void setUrlExpr_CommonTerms(String urlExpr, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("urlExpr", urlExpr);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsBoostDocumentRuleCQ addOrderBy_UrlExpr_Asc() {
         regOBA("urlExpr");
         return this;

src/main/java/org/codelibs/fess/es/config/cbean/cq/bs/BsCrawlingInfoCQ.java

@@ -22,13 +22,17 @@ import org.codelibs.fess.es.config.allcommon.EsAbstractConditionQuery;
 import org.codelibs.fess.es.config.cbean.cq.CrawlingInfoCQ;
 import org.dbflute.cbean.ckey.ConditionKey;
 import org.elasticsearch.index.query.BoolQueryBuilder;
+import org.elasticsearch.index.query.CommonTermsQueryBuilder;
+import org.elasticsearch.index.query.ExistsQueryBuilder;
 import org.elasticsearch.index.query.FuzzyQueryBuilder;
 import org.elasticsearch.index.query.IdsQueryBuilder;
 import org.elasticsearch.index.query.MatchQueryBuilder;
 import org.elasticsearch.index.query.PrefixQueryBuilder;
 import org.elasticsearch.index.query.RangeQueryBuilder;
+import org.elasticsearch.index.query.RegexpQueryBuilder;
 import org.elasticsearch.index.query.TermQueryBuilder;
 import org.elasticsearch.index.query.TermsQueryBuilder;
+import org.elasticsearch.index.query.WildcardQueryBuilder;
 
 /**
  * @author ESFlute (using FreeGen)
@@ -300,6 +304,28 @@ public abstract class BsCrawlingInfoCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setCreatedTime_Exists() {
+        setCreatedTime_Exists(null);
+    }
+
+    public void setCreatedTime_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("createdTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_CommonTerms(Long createdTime) {
+        setCreatedTime_CommonTerms(createdTime, null);
+    }
+
+    public void setCreatedTime_CommonTerms(Long createdTime, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("createdTime", createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsCrawlingInfoCQ addOrderBy_CreatedTime_Asc() {
         regOBA("createdTime");
         return this;
@@ -452,6 +478,28 @@ public abstract class BsCrawlingInfoCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setExpiredTime_Exists() {
+        setExpiredTime_Exists(null);
+    }
+
+    public void setExpiredTime_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("expiredTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExpiredTime_CommonTerms(Long expiredTime) {
+        setExpiredTime_CommonTerms(expiredTime, null);
+    }
+
+    public void setExpiredTime_CommonTerms(Long expiredTime, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("expiredTime", expiredTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsCrawlingInfoCQ addOrderBy_ExpiredTime_Asc() {
         regOBA("expiredTime");
         return this;
@@ -571,6 +619,28 @@ public abstract class BsCrawlingInfoCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setName_Wildcard(String name) {
+        setName_Wildcard(name, null);
+    }
+
+    public void setName_Wildcard(String name, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("name", name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_Regexp(String name) {
+        setName_Regexp(name, null);
+    }
+
+    public void setName_Regexp(String name, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("name", name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setName_GreaterThan(String name) {
         setName_GreaterThan(name, null);
     }
@@ -615,6 +685,28 @@ public abstract class BsCrawlingInfoCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setName_Exists() {
+        setName_Exists(null);
+    }
+
+    public void setName_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("name");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_CommonTerms(String name) {
+        setName_CommonTerms(name, null);
+    }
+
+    public void setName_CommonTerms(String name, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("name", name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsCrawlingInfoCQ addOrderBy_Name_Asc() {
         regOBA("name");
         return this;
@@ -734,6 +826,28 @@ public abstract class BsCrawlingInfoCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setSessionId_Wildcard(String sessionId) {
+        setSessionId_Wildcard(sessionId, null);
+    }
+
+    public void setSessionId_Wildcard(String sessionId, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("sessionId", sessionId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSessionId_Regexp(String sessionId) {
+        setSessionId_Regexp(sessionId, null);
+    }
+
+    public void setSessionId_Regexp(String sessionId, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("sessionId", sessionId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setSessionId_GreaterThan(String sessionId) {
         setSessionId_GreaterThan(sessionId, null);
     }
@@ -778,6 +892,28 @@ public abstract class BsCrawlingInfoCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setSessionId_Exists() {
+        setSessionId_Exists(null);
+    }
+
+    public void setSessionId_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("sessionId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSessionId_CommonTerms(String sessionId) {
+        setSessionId_CommonTerms(sessionId, null);
+    }
+
+    public void setSessionId_CommonTerms(String sessionId, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("sessionId", sessionId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsCrawlingInfoCQ addOrderBy_SessionId_Asc() {
         regOBA("sessionId");
         return this;

src/main/java/org/codelibs/fess/es/config/cbean/cq/bs/BsCrawlingInfoParamCQ.java

@@ -22,13 +22,17 @@ import org.codelibs.fess.es.config.allcommon.EsAbstractConditionQuery;
 import org.codelibs.fess.es.config.cbean.cq.CrawlingInfoParamCQ;
 import org.dbflute.cbean.ckey.ConditionKey;
 import org.elasticsearch.index.query.BoolQueryBuilder;
+import org.elasticsearch.index.query.CommonTermsQueryBuilder;
+import org.elasticsearch.index.query.ExistsQueryBuilder;
 import org.elasticsearch.index.query.FuzzyQueryBuilder;
 import org.elasticsearch.index.query.IdsQueryBuilder;
 import org.elasticsearch.index.query.MatchQueryBuilder;
 import org.elasticsearch.index.query.PrefixQueryBuilder;
 import org.elasticsearch.index.query.RangeQueryBuilder;
+import org.elasticsearch.index.query.RegexpQueryBuilder;
 import org.elasticsearch.index.query.TermQueryBuilder;
 import org.elasticsearch.index.query.TermsQueryBuilder;
+import org.elasticsearch.index.query.WildcardQueryBuilder;
 
 /**
  * @author ESFlute (using FreeGen)
@@ -268,6 +272,28 @@ public abstract class BsCrawlingInfoParamCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setCrawlingInfoId_Wildcard(String crawlingInfoId) {
+        setCrawlingInfoId_Wildcard(crawlingInfoId, null);
+    }
+
+    public void setCrawlingInfoId_Wildcard(String crawlingInfoId, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("crawlingInfoId", crawlingInfoId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCrawlingInfoId_Regexp(String crawlingInfoId) {
+        setCrawlingInfoId_Regexp(crawlingInfoId, null);
+    }
+
+    public void setCrawlingInfoId_Regexp(String crawlingInfoId, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("crawlingInfoId", crawlingInfoId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setCrawlingInfoId_GreaterThan(String crawlingInfoId) {
         setCrawlingInfoId_GreaterThan(crawlingInfoId, null);
     }
@@ -312,6 +338,28 @@ public abstract class BsCrawlingInfoParamCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setCrawlingInfoId_Exists() {
+        setCrawlingInfoId_Exists(null);
+    }
+
+    public void setCrawlingInfoId_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("crawlingInfoId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCrawlingInfoId_CommonTerms(String crawlingInfoId) {
+        setCrawlingInfoId_CommonTerms(crawlingInfoId, null);
+    }
+
+    public void setCrawlingInfoId_CommonTerms(String crawlingInfoId, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("crawlingInfoId", crawlingInfoId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsCrawlingInfoParamCQ addOrderBy_CrawlingInfoId_Asc() {
         regOBA("crawlingInfoId");
         return this;
@@ -464,6 +512,28 @@ public abstract class BsCrawlingInfoParamCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setCreatedTime_Exists() {
+        setCreatedTime_Exists(null);
+    }
+
+    public void setCreatedTime_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("createdTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_CommonTerms(Long createdTime) {
+        setCreatedTime_CommonTerms(createdTime, null);
+    }
+
+    public void setCreatedTime_CommonTerms(Long createdTime, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("createdTime", createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsCrawlingInfoParamCQ addOrderBy_CreatedTime_Asc() {
         regOBA("createdTime");
         return this;
@@ -583,6 +653,28 @@ public abstract class BsCrawlingInfoParamCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setKey_Wildcard(String key) {
+        setKey_Wildcard(key, null);
+    }
+
+    public void setKey_Wildcard(String key, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("key", key);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setKey_Regexp(String key) {
+        setKey_Regexp(key, null);
+    }
+
+    public void setKey_Regexp(String key, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("key", key);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setKey_GreaterThan(String key) {
         setKey_GreaterThan(key, null);
     }
@@ -627,6 +719,28 @@ public abstract class BsCrawlingInfoParamCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setKey_Exists() {
+        setKey_Exists(null);
+    }
+
+    public void setKey_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("key");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setKey_CommonTerms(String key) {
+        setKey_CommonTerms(key, null);
+    }
+
+    public void setKey_CommonTerms(String key, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("key", key);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsCrawlingInfoParamCQ addOrderBy_Key_Asc() {
         regOBA("key");
         return this;
@@ -746,6 +860,28 @@ public abstract class BsCrawlingInfoParamCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setValue_Wildcard(String value) {
+        setValue_Wildcard(value, null);
+    }
+
+    public void setValue_Wildcard(String value, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("value", value);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setValue_Regexp(String value) {
+        setValue_Regexp(value, null);
+    }
+
+    public void setValue_Regexp(String value, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("value", value);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setValue_GreaterThan(String value) {
         setValue_GreaterThan(value, null);
     }
@@ -790,6 +926,28 @@ public abstract class BsCrawlingInfoParamCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setValue_Exists() {
+        setValue_Exists(null);
+    }
+
+    public void setValue_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("value");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setValue_CommonTerms(String value) {
+        setValue_CommonTerms(value, null);
+    }
+
+    public void setValue_CommonTerms(String value, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("value", value);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsCrawlingInfoParamCQ addOrderBy_Value_Asc() {
         regOBA("value");
         return this;

src/main/java/org/codelibs/fess/es/config/cbean/cq/bs/BsDataConfigCQ.java

@@ -22,13 +22,17 @@ import org.codelibs.fess.es.config.allcommon.EsAbstractConditionQuery;
 import org.codelibs.fess.es.config.cbean.cq.DataConfigCQ;
 import org.dbflute.cbean.ckey.ConditionKey;
 import org.elasticsearch.index.query.BoolQueryBuilder;
+import org.elasticsearch.index.query.CommonTermsQueryBuilder;
+import org.elasticsearch.index.query.ExistsQueryBuilder;
 import org.elasticsearch.index.query.FuzzyQueryBuilder;
 import org.elasticsearch.index.query.IdsQueryBuilder;
 import org.elasticsearch.index.query.MatchQueryBuilder;
 import org.elasticsearch.index.query.PrefixQueryBuilder;
 import org.elasticsearch.index.query.RangeQueryBuilder;
+import org.elasticsearch.index.query.RegexpQueryBuilder;
 import org.elasticsearch.index.query.TermQueryBuilder;
 import org.elasticsearch.index.query.TermsQueryBuilder;
+import org.elasticsearch.index.query.WildcardQueryBuilder;
 
 /**
  * @author ESFlute (using FreeGen)
@@ -300,6 +304,28 @@ public abstract class BsDataConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setAvailable_Exists() {
+        setAvailable_Exists(null);
+    }
+
+    public void setAvailable_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("available");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setAvailable_CommonTerms(Boolean available) {
+        setAvailable_CommonTerms(available, null);
+    }
+
+    public void setAvailable_CommonTerms(Boolean available, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("available", available);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsDataConfigCQ addOrderBy_Available_Asc() {
         regOBA("available");
         return this;
@@ -452,6 +478,28 @@ public abstract class BsDataConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setBoost_Exists() {
+        setBoost_Exists(null);
+    }
+
+    public void setBoost_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("boost");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setBoost_CommonTerms(Float boost) {
+        setBoost_CommonTerms(boost, null);
+    }
+
+    public void setBoost_CommonTerms(Float boost, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("boost", boost);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsDataConfigCQ addOrderBy_Boost_Asc() {
         regOBA("boost");
         return this;
@@ -571,6 +619,28 @@ public abstract class BsDataConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setCreatedBy_Wildcard(String createdBy) {
+        setCreatedBy_Wildcard(createdBy, null);
+    }
+
+    public void setCreatedBy_Wildcard(String createdBy, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Regexp(String createdBy) {
+        setCreatedBy_Regexp(createdBy, null);
+    }
+
+    public void setCreatedBy_Regexp(String createdBy, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setCreatedBy_GreaterThan(String createdBy) {
         setCreatedBy_GreaterThan(createdBy, null);
     }
@@ -615,6 +685,28 @@ public abstract class BsDataConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setCreatedBy_Exists() {
+        setCreatedBy_Exists(null);
+    }
+
+    public void setCreatedBy_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("createdBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_CommonTerms(String createdBy) {
+        setCreatedBy_CommonTerms(createdBy, null);
+    }
+
+    public void setCreatedBy_CommonTerms(String createdBy, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsDataConfigCQ addOrderBy_CreatedBy_Asc() {
         regOBA("createdBy");
         return this;
@@ -767,6 +859,28 @@ public abstract class BsDataConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setCreatedTime_Exists() {
+        setCreatedTime_Exists(null);
+    }
+
+    public void setCreatedTime_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("createdTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_CommonTerms(Long createdTime) {
+        setCreatedTime_CommonTerms(createdTime, null);
+    }
+
+    public void setCreatedTime_CommonTerms(Long createdTime, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("createdTime", createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsDataConfigCQ addOrderBy_CreatedTime_Asc() {
         regOBA("createdTime");
         return this;
@@ -886,6 +1000,28 @@ public abstract class BsDataConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setHandlerName_Wildcard(String handlerName) {
+        setHandlerName_Wildcard(handlerName, null);
+    }
+
+    public void setHandlerName_Wildcard(String handlerName, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("handlerName", handlerName);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHandlerName_Regexp(String handlerName) {
+        setHandlerName_Regexp(handlerName, null);
+    }
+
+    public void setHandlerName_Regexp(String handlerName, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("handlerName", handlerName);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setHandlerName_GreaterThan(String handlerName) {
         setHandlerName_GreaterThan(handlerName, null);
     }
@@ -930,6 +1066,28 @@ public abstract class BsDataConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setHandlerName_Exists() {
+        setHandlerName_Exists(null);
+    }
+
+    public void setHandlerName_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("handlerName");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHandlerName_CommonTerms(String handlerName) {
+        setHandlerName_CommonTerms(handlerName, null);
+    }
+
+    public void setHandlerName_CommonTerms(String handlerName, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("handlerName", handlerName);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsDataConfigCQ addOrderBy_HandlerName_Asc() {
         regOBA("handlerName");
         return this;
@@ -1049,6 +1207,28 @@ public abstract class BsDataConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setHandlerParameter_Wildcard(String handlerParameter) {
+        setHandlerParameter_Wildcard(handlerParameter, null);
+    }
+
+    public void setHandlerParameter_Wildcard(String handlerParameter, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("handlerParameter", handlerParameter);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHandlerParameter_Regexp(String handlerParameter) {
+        setHandlerParameter_Regexp(handlerParameter, null);
+    }
+
+    public void setHandlerParameter_Regexp(String handlerParameter, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("handlerParameter", handlerParameter);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setHandlerParameter_GreaterThan(String handlerParameter) {
         setHandlerParameter_GreaterThan(handlerParameter, null);
     }
@@ -1093,6 +1273,28 @@ public abstract class BsDataConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setHandlerParameter_Exists() {
+        setHandlerParameter_Exists(null);
+    }
+
+    public void setHandlerParameter_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("handlerParameter");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHandlerParameter_CommonTerms(String handlerParameter) {
+        setHandlerParameter_CommonTerms(handlerParameter, null);
+    }
+
+    public void setHandlerParameter_CommonTerms(String handlerParameter, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("handlerParameter", handlerParameter);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsDataConfigCQ addOrderBy_HandlerParameter_Asc() {
         regOBA("handlerParameter");
         return this;
@@ -1212,6 +1414,28 @@ public abstract class BsDataConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setHandlerScript_Wildcard(String handlerScript) {
+        setHandlerScript_Wildcard(handlerScript, null);
+    }
+
+    public void setHandlerScript_Wildcard(String handlerScript, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("handlerScript", handlerScript);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHandlerScript_Regexp(String handlerScript) {
+        setHandlerScript_Regexp(handlerScript, null);
+    }
+
+    public void setHandlerScript_Regexp(String handlerScript, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("handlerScript", handlerScript);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setHandlerScript_GreaterThan(String handlerScript) {
         setHandlerScript_GreaterThan(handlerScript, null);
     }
@@ -1256,6 +1480,28 @@ public abstract class BsDataConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setHandlerScript_Exists() {
+        setHandlerScript_Exists(null);
+    }
+
+    public void setHandlerScript_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("handlerScript");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHandlerScript_CommonTerms(String handlerScript) {
+        setHandlerScript_CommonTerms(handlerScript, null);
+    }
+
+    public void setHandlerScript_CommonTerms(String handlerScript, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("handlerScript", handlerScript);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsDataConfigCQ addOrderBy_HandlerScript_Asc() {
         regOBA("handlerScript");
         return this;
@@ -1375,6 +1621,28 @@ public abstract class BsDataConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setName_Wildcard(String name) {
+        setName_Wildcard(name, null);
+    }
+
+    public void setName_Wildcard(String name, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("name", name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_Regexp(String name) {
+        setName_Regexp(name, null);
+    }
+
+    public void setName_Regexp(String name, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("name", name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setName_GreaterThan(String name) {
         setName_GreaterThan(name, null);
     }
@@ -1419,6 +1687,28 @@ public abstract class BsDataConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setName_Exists() {
+        setName_Exists(null);
+    }
+
+    public void setName_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("name");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_CommonTerms(String name) {
+        setName_CommonTerms(name, null);
+    }
+
+    public void setName_CommonTerms(String name, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("name", name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsDataConfigCQ addOrderBy_Name_Asc() {
         regOBA("name");
         return this;
@@ -1538,6 +1828,28 @@ public abstract class BsDataConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setPermissions_Wildcard(String permissions) {
+        setPermissions_Wildcard(permissions, null);
+    }
+
+    public void setPermissions_Wildcard(String permissions, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("permissions", permissions);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setPermissions_Regexp(String permissions) {
+        setPermissions_Regexp(permissions, null);
+    }
+
+    public void setPermissions_Regexp(String permissions, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("permissions", permissions);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setPermissions_GreaterThan(String permissions) {
         setPermissions_GreaterThan(permissions, null);
     }
@@ -1582,6 +1894,28 @@ public abstract class BsDataConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setPermissions_Exists() {
+        setPermissions_Exists(null);
+    }
+
+    public void setPermissions_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("permissions");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setPermissions_CommonTerms(String permissions) {
+        setPermissions_CommonTerms(permissions, null);
+    }
+
+    public void setPermissions_CommonTerms(String permissions, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("permissions", permissions);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsDataConfigCQ addOrderBy_Permissions_Asc() {
         regOBA("permissions");
         return this;
@@ -1734,6 +2068,28 @@ public abstract class BsDataConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setSortOrder_Exists() {
+        setSortOrder_Exists(null);
+    }
+
+    public void setSortOrder_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("sortOrder");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_CommonTerms(Integer sortOrder) {
+        setSortOrder_CommonTerms(sortOrder, null);
+    }
+
+    public void setSortOrder_CommonTerms(Integer sortOrder, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("sortOrder", sortOrder);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsDataConfigCQ addOrderBy_SortOrder_Asc() {
         regOBA("sortOrder");
         return this;
@@ -1853,6 +2209,28 @@ public abstract class BsDataConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUpdatedBy_Wildcard(String updatedBy) {
+        setUpdatedBy_Wildcard(updatedBy, null);
+    }
+
+    public void setUpdatedBy_Wildcard(String updatedBy, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Regexp(String updatedBy) {
+        setUpdatedBy_Regexp(updatedBy, null);
+    }
+
+    public void setUpdatedBy_Regexp(String updatedBy, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setUpdatedBy_GreaterThan(String updatedBy) {
         setUpdatedBy_GreaterThan(updatedBy, null);
     }
@@ -1897,6 +2275,28 @@ public abstract class BsDataConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUpdatedBy_Exists() {
+        setUpdatedBy_Exists(null);
+    }
+
+    public void setUpdatedBy_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("updatedBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_CommonTerms(String updatedBy) {
+        setUpdatedBy_CommonTerms(updatedBy, null);
+    }
+
+    public void setUpdatedBy_CommonTerms(String updatedBy, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsDataConfigCQ addOrderBy_UpdatedBy_Asc() {
         regOBA("updatedBy");
         return this;
@@ -2049,6 +2449,28 @@ public abstract class BsDataConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUpdatedTime_Exists() {
+        setUpdatedTime_Exists(null);
+    }
+
+    public void setUpdatedTime_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("updatedTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_CommonTerms(Long updatedTime) {
+        setUpdatedTime_CommonTerms(updatedTime, null);
+    }
+
+    public void setUpdatedTime_CommonTerms(Long updatedTime, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("updatedTime", updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsDataConfigCQ addOrderBy_UpdatedTime_Asc() {
         regOBA("updatedTime");
         return this;

src/main/java/org/codelibs/fess/es/config/cbean/cq/bs/BsDataConfigToLabelCQ.java

@@ -22,13 +22,17 @@ import org.codelibs.fess.es.config.allcommon.EsAbstractConditionQuery;
 import org.codelibs.fess.es.config.cbean.cq.DataConfigToLabelCQ;
 import org.dbflute.cbean.ckey.ConditionKey;
 import org.elasticsearch.index.query.BoolQueryBuilder;
+import org.elasticsearch.index.query.CommonTermsQueryBuilder;
+import org.elasticsearch.index.query.ExistsQueryBuilder;
 import org.elasticsearch.index.query.FuzzyQueryBuilder;
 import org.elasticsearch.index.query.IdsQueryBuilder;
 import org.elasticsearch.index.query.MatchQueryBuilder;
 import org.elasticsearch.index.query.PrefixQueryBuilder;
 import org.elasticsearch.index.query.RangeQueryBuilder;
+import org.elasticsearch.index.query.RegexpQueryBuilder;
 import org.elasticsearch.index.query.TermQueryBuilder;
 import org.elasticsearch.index.query.TermsQueryBuilder;
+import org.elasticsearch.index.query.WildcardQueryBuilder;
 
 /**
  * @author ESFlute (using FreeGen)
@@ -268,6 +272,28 @@ public abstract class BsDataConfigToLabelCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setDataConfigId_Wildcard(String dataConfigId) {
+        setDataConfigId_Wildcard(dataConfigId, null);
+    }
+
+    public void setDataConfigId_Wildcard(String dataConfigId, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("dataConfigId", dataConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setDataConfigId_Regexp(String dataConfigId) {
+        setDataConfigId_Regexp(dataConfigId, null);
+    }
+
+    public void setDataConfigId_Regexp(String dataConfigId, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("dataConfigId", dataConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setDataConfigId_GreaterThan(String dataConfigId) {
         setDataConfigId_GreaterThan(dataConfigId, null);
     }
@@ -312,6 +338,28 @@ public abstract class BsDataConfigToLabelCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setDataConfigId_Exists() {
+        setDataConfigId_Exists(null);
+    }
+
+    public void setDataConfigId_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("dataConfigId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setDataConfigId_CommonTerms(String dataConfigId) {
+        setDataConfigId_CommonTerms(dataConfigId, null);
+    }
+
+    public void setDataConfigId_CommonTerms(String dataConfigId, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("dataConfigId", dataConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsDataConfigToLabelCQ addOrderBy_DataConfigId_Asc() {
         regOBA("dataConfigId");
         return this;
@@ -431,6 +479,28 @@ public abstract class BsDataConfigToLabelCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setLabelTypeId_Wildcard(String labelTypeId) {
+        setLabelTypeId_Wildcard(labelTypeId, null);
+    }
+
+    public void setLabelTypeId_Wildcard(String labelTypeId, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("labelTypeId", labelTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setLabelTypeId_Regexp(String labelTypeId) {
+        setLabelTypeId_Regexp(labelTypeId, null);
+    }
+
+    public void setLabelTypeId_Regexp(String labelTypeId, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("labelTypeId", labelTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setLabelTypeId_GreaterThan(String labelTypeId) {
         setLabelTypeId_GreaterThan(labelTypeId, null);
     }
@@ -475,6 +545,28 @@ public abstract class BsDataConfigToLabelCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setLabelTypeId_Exists() {
+        setLabelTypeId_Exists(null);
+    }
+
+    public void setLabelTypeId_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("labelTypeId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setLabelTypeId_CommonTerms(String labelTypeId) {
+        setLabelTypeId_CommonTerms(labelTypeId, null);
+    }
+
+    public void setLabelTypeId_CommonTerms(String labelTypeId, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("labelTypeId", labelTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsDataConfigToLabelCQ addOrderBy_LabelTypeId_Asc() {
         regOBA("labelTypeId");
         return this;

src/main/java/org/codelibs/fess/es/config/cbean/cq/bs/BsDataConfigToRoleCQ.java

@@ -22,13 +22,17 @@ import org.codelibs.fess.es.config.allcommon.EsAbstractConditionQuery;
 import org.codelibs.fess.es.config.cbean.cq.DataConfigToRoleCQ;
 import org.dbflute.cbean.ckey.ConditionKey;
 import org.elasticsearch.index.query.BoolQueryBuilder;
+import org.elasticsearch.index.query.CommonTermsQueryBuilder;
+import org.elasticsearch.index.query.ExistsQueryBuilder;
 import org.elasticsearch.index.query.FuzzyQueryBuilder;
 import org.elasticsearch.index.query.IdsQueryBuilder;
 import org.elasticsearch.index.query.MatchQueryBuilder;
 import org.elasticsearch.index.query.PrefixQueryBuilder;
 import org.elasticsearch.index.query.RangeQueryBuilder;
+import org.elasticsearch.index.query.RegexpQueryBuilder;
 import org.elasticsearch.index.query.TermQueryBuilder;
 import org.elasticsearch.index.query.TermsQueryBuilder;
+import org.elasticsearch.index.query.WildcardQueryBuilder;
 
 /**
  * @author ESFlute (using FreeGen)
@@ -267,6 +271,28 @@ public abstract class BsDataConfigToRoleCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setDataConfigId_Wildcard(String dataConfigId) {
+        setDataConfigId_Wildcard(dataConfigId, null);
+    }
+
+    public void setDataConfigId_Wildcard(String dataConfigId, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("dataConfigId", dataConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setDataConfigId_Regexp(String dataConfigId) {
+        setDataConfigId_Regexp(dataConfigId, null);
+    }
+
+    public void setDataConfigId_Regexp(String dataConfigId, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("dataConfigId", dataConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setDataConfigId_GreaterThan(String dataConfigId) {
         setDataConfigId_GreaterThan(dataConfigId, null);
     }
@@ -311,6 +337,28 @@ public abstract class BsDataConfigToRoleCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setDataConfigId_Exists() {
+        setDataConfigId_Exists(null);
+    }
+
+    public void setDataConfigId_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("dataConfigId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setDataConfigId_CommonTerms(String dataConfigId) {
+        setDataConfigId_CommonTerms(dataConfigId, null);
+    }
+
+    public void setDataConfigId_CommonTerms(String dataConfigId, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("dataConfigId", dataConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsDataConfigToRoleCQ addOrderBy_DataConfigId_Asc() {
         regOBA("dataConfigId");
         return this;
@@ -430,6 +478,28 @@ public abstract class BsDataConfigToRoleCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setRoleTypeId_Wildcard(String roleTypeId) {
+        setRoleTypeId_Wildcard(roleTypeId, null);
+    }
+
+    public void setRoleTypeId_Wildcard(String roleTypeId, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("roleTypeId", roleTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRoleTypeId_Regexp(String roleTypeId) {
+        setRoleTypeId_Regexp(roleTypeId, null);
+    }
+
+    public void setRoleTypeId_Regexp(String roleTypeId, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("roleTypeId", roleTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setRoleTypeId_GreaterThan(String roleTypeId) {
         setRoleTypeId_GreaterThan(roleTypeId, null);
     }
@@ -474,6 +544,28 @@ public abstract class BsDataConfigToRoleCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setRoleTypeId_Exists() {
+        setRoleTypeId_Exists(null);
+    }
+
+    public void setRoleTypeId_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("roleTypeId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRoleTypeId_CommonTerms(String roleTypeId) {
+        setRoleTypeId_CommonTerms(roleTypeId, null);
+    }
+
+    public void setRoleTypeId_CommonTerms(String roleTypeId, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("roleTypeId", roleTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsDataConfigToRoleCQ addOrderBy_RoleTypeId_Asc() {
         regOBA("roleTypeId");
         return this;

src/main/java/org/codelibs/fess/es/config/cbean/cq/bs/BsDuplicateHostCQ.java

@@ -22,13 +22,17 @@ import org.codelibs.fess.es.config.allcommon.EsAbstractConditionQuery;
 import org.codelibs.fess.es.config.cbean.cq.DuplicateHostCQ;
 import org.dbflute.cbean.ckey.ConditionKey;
 import org.elasticsearch.index.query.BoolQueryBuilder;
+import org.elasticsearch.index.query.CommonTermsQueryBuilder;
+import org.elasticsearch.index.query.ExistsQueryBuilder;
 import org.elasticsearch.index.query.FuzzyQueryBuilder;
 import org.elasticsearch.index.query.IdsQueryBuilder;
 import org.elasticsearch.index.query.MatchQueryBuilder;
 import org.elasticsearch.index.query.PrefixQueryBuilder;
 import org.elasticsearch.index.query.RangeQueryBuilder;
+import org.elasticsearch.index.query.RegexpQueryBuilder;
 import org.elasticsearch.index.query.TermQueryBuilder;
 import org.elasticsearch.index.query.TermsQueryBuilder;
+import org.elasticsearch.index.query.WildcardQueryBuilder;
 
 /**
  * @author ESFlute (using FreeGen)
@@ -267,6 +271,28 @@ public abstract class BsDuplicateHostCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setCreatedBy_Wildcard(String createdBy) {
+        setCreatedBy_Wildcard(createdBy, null);
+    }
+
+    public void setCreatedBy_Wildcard(String createdBy, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Regexp(String createdBy) {
+        setCreatedBy_Regexp(createdBy, null);
+    }
+
+    public void setCreatedBy_Regexp(String createdBy, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setCreatedBy_GreaterThan(String createdBy) {
         setCreatedBy_GreaterThan(createdBy, null);
     }
@@ -311,6 +337,28 @@ public abstract class BsDuplicateHostCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setCreatedBy_Exists() {
+        setCreatedBy_Exists(null);
+    }
+
+    public void setCreatedBy_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("createdBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_CommonTerms(String createdBy) {
+        setCreatedBy_CommonTerms(createdBy, null);
+    }
+
+    public void setCreatedBy_CommonTerms(String createdBy, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsDuplicateHostCQ addOrderBy_CreatedBy_Asc() {
         regOBA("createdBy");
         return this;
@@ -463,6 +511,28 @@ public abstract class BsDuplicateHostCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setCreatedTime_Exists() {
+        setCreatedTime_Exists(null);
+    }
+
+    public void setCreatedTime_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("createdTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_CommonTerms(Long createdTime) {
+        setCreatedTime_CommonTerms(createdTime, null);
+    }
+
+    public void setCreatedTime_CommonTerms(Long createdTime, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("createdTime", createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsDuplicateHostCQ addOrderBy_CreatedTime_Asc() {
         regOBA("createdTime");
         return this;
@@ -582,6 +652,28 @@ public abstract class BsDuplicateHostCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setDuplicateHostName_Wildcard(String duplicateHostName) {
+        setDuplicateHostName_Wildcard(duplicateHostName, null);
+    }
+
+    public void setDuplicateHostName_Wildcard(String duplicateHostName, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("duplicateHostName", duplicateHostName);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setDuplicateHostName_Regexp(String duplicateHostName) {
+        setDuplicateHostName_Regexp(duplicateHostName, null);
+    }
+
+    public void setDuplicateHostName_Regexp(String duplicateHostName, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("duplicateHostName", duplicateHostName);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setDuplicateHostName_GreaterThan(String duplicateHostName) {
         setDuplicateHostName_GreaterThan(duplicateHostName, null);
     }
@@ -626,6 +718,28 @@ public abstract class BsDuplicateHostCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setDuplicateHostName_Exists() {
+        setDuplicateHostName_Exists(null);
+    }
+
+    public void setDuplicateHostName_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("duplicateHostName");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setDuplicateHostName_CommonTerms(String duplicateHostName) {
+        setDuplicateHostName_CommonTerms(duplicateHostName, null);
+    }
+
+    public void setDuplicateHostName_CommonTerms(String duplicateHostName, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("duplicateHostName", duplicateHostName);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsDuplicateHostCQ addOrderBy_DuplicateHostName_Asc() {
         regOBA("duplicateHostName");
         return this;
@@ -745,6 +859,28 @@ public abstract class BsDuplicateHostCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setRegularName_Wildcard(String regularName) {
+        setRegularName_Wildcard(regularName, null);
+    }
+
+    public void setRegularName_Wildcard(String regularName, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("regularName", regularName);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRegularName_Regexp(String regularName) {
+        setRegularName_Regexp(regularName, null);
+    }
+
+    public void setRegularName_Regexp(String regularName, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("regularName", regularName);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setRegularName_GreaterThan(String regularName) {
         setRegularName_GreaterThan(regularName, null);
     }
@@ -789,6 +925,28 @@ public abstract class BsDuplicateHostCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setRegularName_Exists() {
+        setRegularName_Exists(null);
+    }
+
+    public void setRegularName_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("regularName");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRegularName_CommonTerms(String regularName) {
+        setRegularName_CommonTerms(regularName, null);
+    }
+
+    public void setRegularName_CommonTerms(String regularName, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("regularName", regularName);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsDuplicateHostCQ addOrderBy_RegularName_Asc() {
         regOBA("regularName");
         return this;
@@ -941,6 +1099,28 @@ public abstract class BsDuplicateHostCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setSortOrder_Exists() {
+        setSortOrder_Exists(null);
+    }
+
+    public void setSortOrder_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("sortOrder");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_CommonTerms(Integer sortOrder) {
+        setSortOrder_CommonTerms(sortOrder, null);
+    }
+
+    public void setSortOrder_CommonTerms(Integer sortOrder, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("sortOrder", sortOrder);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsDuplicateHostCQ addOrderBy_SortOrder_Asc() {
         regOBA("sortOrder");
         return this;
@@ -1060,6 +1240,28 @@ public abstract class BsDuplicateHostCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUpdatedBy_Wildcard(String updatedBy) {
+        setUpdatedBy_Wildcard(updatedBy, null);
+    }
+
+    public void setUpdatedBy_Wildcard(String updatedBy, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Regexp(String updatedBy) {
+        setUpdatedBy_Regexp(updatedBy, null);
+    }
+
+    public void setUpdatedBy_Regexp(String updatedBy, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setUpdatedBy_GreaterThan(String updatedBy) {
         setUpdatedBy_GreaterThan(updatedBy, null);
     }
@@ -1104,6 +1306,28 @@ public abstract class BsDuplicateHostCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUpdatedBy_Exists() {
+        setUpdatedBy_Exists(null);
+    }
+
+    public void setUpdatedBy_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("updatedBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_CommonTerms(String updatedBy) {
+        setUpdatedBy_CommonTerms(updatedBy, null);
+    }
+
+    public void setUpdatedBy_CommonTerms(String updatedBy, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsDuplicateHostCQ addOrderBy_UpdatedBy_Asc() {
         regOBA("updatedBy");
         return this;
@@ -1256,6 +1480,28 @@ public abstract class BsDuplicateHostCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUpdatedTime_Exists() {
+        setUpdatedTime_Exists(null);
+    }
+
+    public void setUpdatedTime_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("updatedTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_CommonTerms(Long updatedTime) {
+        setUpdatedTime_CommonTerms(updatedTime, null);
+    }
+
+    public void setUpdatedTime_CommonTerms(Long updatedTime, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("updatedTime", updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsDuplicateHostCQ addOrderBy_UpdatedTime_Asc() {
         regOBA("updatedTime");
         return this;

src/main/java/org/codelibs/fess/es/config/cbean/cq/bs/BsElevateWordCQ.java

@@ -22,13 +22,17 @@ import org.codelibs.fess.es.config.allcommon.EsAbstractConditionQuery;
 import org.codelibs.fess.es.config.cbean.cq.ElevateWordCQ;
 import org.dbflute.cbean.ckey.ConditionKey;
 import org.elasticsearch.index.query.BoolQueryBuilder;
+import org.elasticsearch.index.query.CommonTermsQueryBuilder;
+import org.elasticsearch.index.query.ExistsQueryBuilder;
 import org.elasticsearch.index.query.FuzzyQueryBuilder;
 import org.elasticsearch.index.query.IdsQueryBuilder;
 import org.elasticsearch.index.query.MatchQueryBuilder;
 import org.elasticsearch.index.query.PrefixQueryBuilder;
 import org.elasticsearch.index.query.RangeQueryBuilder;
+import org.elasticsearch.index.query.RegexpQueryBuilder;
 import org.elasticsearch.index.query.TermQueryBuilder;
 import org.elasticsearch.index.query.TermsQueryBuilder;
+import org.elasticsearch.index.query.WildcardQueryBuilder;
 
 /**
  * @author ESFlute (using FreeGen)
@@ -300,6 +304,28 @@ public abstract class BsElevateWordCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setBoost_Exists() {
+        setBoost_Exists(null);
+    }
+
+    public void setBoost_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("boost");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setBoost_CommonTerms(Float boost) {
+        setBoost_CommonTerms(boost, null);
+    }
+
+    public void setBoost_CommonTerms(Float boost, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("boost", boost);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsElevateWordCQ addOrderBy_Boost_Asc() {
         regOBA("boost");
         return this;
@@ -419,6 +445,28 @@ public abstract class BsElevateWordCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setCreatedBy_Wildcard(String createdBy) {
+        setCreatedBy_Wildcard(createdBy, null);
+    }
+
+    public void setCreatedBy_Wildcard(String createdBy, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Regexp(String createdBy) {
+        setCreatedBy_Regexp(createdBy, null);
+    }
+
+    public void setCreatedBy_Regexp(String createdBy, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setCreatedBy_GreaterThan(String createdBy) {
         setCreatedBy_GreaterThan(createdBy, null);
     }
@@ -463,6 +511,28 @@ public abstract class BsElevateWordCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setCreatedBy_Exists() {
+        setCreatedBy_Exists(null);
+    }
+
+    public void setCreatedBy_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("createdBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_CommonTerms(String createdBy) {
+        setCreatedBy_CommonTerms(createdBy, null);
+    }
+
+    public void setCreatedBy_CommonTerms(String createdBy, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsElevateWordCQ addOrderBy_CreatedBy_Asc() {
         regOBA("createdBy");
         return this;
@@ -615,6 +685,28 @@ public abstract class BsElevateWordCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setCreatedTime_Exists() {
+        setCreatedTime_Exists(null);
+    }
+
+    public void setCreatedTime_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("createdTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_CommonTerms(Long createdTime) {
+        setCreatedTime_CommonTerms(createdTime, null);
+    }
+
+    public void setCreatedTime_CommonTerms(Long createdTime, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("createdTime", createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsElevateWordCQ addOrderBy_CreatedTime_Asc() {
         regOBA("createdTime");
         return this;
@@ -734,6 +826,28 @@ public abstract class BsElevateWordCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setReading_Wildcard(String reading) {
+        setReading_Wildcard(reading, null);
+    }
+
+    public void setReading_Wildcard(String reading, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("reading", reading);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setReading_Regexp(String reading) {
+        setReading_Regexp(reading, null);
+    }
+
+    public void setReading_Regexp(String reading, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("reading", reading);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setReading_GreaterThan(String reading) {
         setReading_GreaterThan(reading, null);
     }
@@ -778,6 +892,28 @@ public abstract class BsElevateWordCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setReading_Exists() {
+        setReading_Exists(null);
+    }
+
+    public void setReading_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("reading");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setReading_CommonTerms(String reading) {
+        setReading_CommonTerms(reading, null);
+    }
+
+    public void setReading_CommonTerms(String reading, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("reading", reading);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsElevateWordCQ addOrderBy_Reading_Asc() {
         regOBA("reading");
         return this;
@@ -897,6 +1033,28 @@ public abstract class BsElevateWordCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setSuggestWord_Wildcard(String suggestWord) {
+        setSuggestWord_Wildcard(suggestWord, null);
+    }
+
+    public void setSuggestWord_Wildcard(String suggestWord, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("suggestWord", suggestWord);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSuggestWord_Regexp(String suggestWord) {
+        setSuggestWord_Regexp(suggestWord, null);
+    }
+
+    public void setSuggestWord_Regexp(String suggestWord, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("suggestWord", suggestWord);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setSuggestWord_GreaterThan(String suggestWord) {
         setSuggestWord_GreaterThan(suggestWord, null);
     }
@@ -941,6 +1099,28 @@ public abstract class BsElevateWordCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setSuggestWord_Exists() {
+        setSuggestWord_Exists(null);
+    }
+
+    public void setSuggestWord_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("suggestWord");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSuggestWord_CommonTerms(String suggestWord) {
+        setSuggestWord_CommonTerms(suggestWord, null);
+    }
+
+    public void setSuggestWord_CommonTerms(String suggestWord, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("suggestWord", suggestWord);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsElevateWordCQ addOrderBy_SuggestWord_Asc() {
         regOBA("suggestWord");
         return this;
@@ -1060,6 +1240,28 @@ public abstract class BsElevateWordCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setTargetLabel_Wildcard(String targetLabel) {
+        setTargetLabel_Wildcard(targetLabel, null);
+    }
+
+    public void setTargetLabel_Wildcard(String targetLabel, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("targetLabel", targetLabel);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTargetLabel_Regexp(String targetLabel) {
+        setTargetLabel_Regexp(targetLabel, null);
+    }
+
+    public void setTargetLabel_Regexp(String targetLabel, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("targetLabel", targetLabel);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setTargetLabel_GreaterThan(String targetLabel) {
         setTargetLabel_GreaterThan(targetLabel, null);
     }
@@ -1104,6 +1306,28 @@ public abstract class BsElevateWordCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setTargetLabel_Exists() {
+        setTargetLabel_Exists(null);
+    }
+
+    public void setTargetLabel_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("targetLabel");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTargetLabel_CommonTerms(String targetLabel) {
+        setTargetLabel_CommonTerms(targetLabel, null);
+    }
+
+    public void setTargetLabel_CommonTerms(String targetLabel, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("targetLabel", targetLabel);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsElevateWordCQ addOrderBy_TargetLabel_Asc() {
         regOBA("targetLabel");
         return this;
@@ -1223,6 +1447,28 @@ public abstract class BsElevateWordCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setTargetRole_Wildcard(String targetRole) {
+        setTargetRole_Wildcard(targetRole, null);
+    }
+
+    public void setTargetRole_Wildcard(String targetRole, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("targetRole", targetRole);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTargetRole_Regexp(String targetRole) {
+        setTargetRole_Regexp(targetRole, null);
+    }
+
+    public void setTargetRole_Regexp(String targetRole, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("targetRole", targetRole);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setTargetRole_GreaterThan(String targetRole) {
         setTargetRole_GreaterThan(targetRole, null);
     }
@@ -1267,6 +1513,28 @@ public abstract class BsElevateWordCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setTargetRole_Exists() {
+        setTargetRole_Exists(null);
+    }
+
+    public void setTargetRole_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("targetRole");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTargetRole_CommonTerms(String targetRole) {
+        setTargetRole_CommonTerms(targetRole, null);
+    }
+
+    public void setTargetRole_CommonTerms(String targetRole, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("targetRole", targetRole);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsElevateWordCQ addOrderBy_TargetRole_Asc() {
         regOBA("targetRole");
         return this;
@@ -1386,6 +1654,28 @@ public abstract class BsElevateWordCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setPermissions_Wildcard(String permissions) {
+        setPermissions_Wildcard(permissions, null);
+    }
+
+    public void setPermissions_Wildcard(String permissions, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("permissions", permissions);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setPermissions_Regexp(String permissions) {
+        setPermissions_Regexp(permissions, null);
+    }
+
+    public void setPermissions_Regexp(String permissions, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("permissions", permissions);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setPermissions_GreaterThan(String permissions) {
         setPermissions_GreaterThan(permissions, null);
     }
@@ -1430,6 +1720,28 @@ public abstract class BsElevateWordCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setPermissions_Exists() {
+        setPermissions_Exists(null);
+    }
+
+    public void setPermissions_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("permissions");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setPermissions_CommonTerms(String permissions) {
+        setPermissions_CommonTerms(permissions, null);
+    }
+
+    public void setPermissions_CommonTerms(String permissions, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("permissions", permissions);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsElevateWordCQ addOrderBy_Permissions_Asc() {
         regOBA("permissions");
         return this;
@@ -1549,6 +1861,28 @@ public abstract class BsElevateWordCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUpdatedBy_Wildcard(String updatedBy) {
+        setUpdatedBy_Wildcard(updatedBy, null);
+    }
+
+    public void setUpdatedBy_Wildcard(String updatedBy, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Regexp(String updatedBy) {
+        setUpdatedBy_Regexp(updatedBy, null);
+    }
+
+    public void setUpdatedBy_Regexp(String updatedBy, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setUpdatedBy_GreaterThan(String updatedBy) {
         setUpdatedBy_GreaterThan(updatedBy, null);
     }
@@ -1593,6 +1927,28 @@ public abstract class BsElevateWordCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUpdatedBy_Exists() {
+        setUpdatedBy_Exists(null);
+    }
+
+    public void setUpdatedBy_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("updatedBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_CommonTerms(String updatedBy) {
+        setUpdatedBy_CommonTerms(updatedBy, null);
+    }
+
+    public void setUpdatedBy_CommonTerms(String updatedBy, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsElevateWordCQ addOrderBy_UpdatedBy_Asc() {
         regOBA("updatedBy");
         return this;
@@ -1745,6 +2101,28 @@ public abstract class BsElevateWordCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUpdatedTime_Exists() {
+        setUpdatedTime_Exists(null);
+    }
+
+    public void setUpdatedTime_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("updatedTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_CommonTerms(Long updatedTime) {
+        setUpdatedTime_CommonTerms(updatedTime, null);
+    }
+
+    public void setUpdatedTime_CommonTerms(Long updatedTime, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("updatedTime", updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsElevateWordCQ addOrderBy_UpdatedTime_Asc() {
         regOBA("updatedTime");
         return this;

src/main/java/org/codelibs/fess/es/config/cbean/cq/bs/BsElevateWordToLabelCQ.java

@@ -22,13 +22,17 @@ import org.codelibs.fess.es.config.allcommon.EsAbstractConditionQuery;
 import org.codelibs.fess.es.config.cbean.cq.ElevateWordToLabelCQ;
 import org.dbflute.cbean.ckey.ConditionKey;
 import org.elasticsearch.index.query.BoolQueryBuilder;
+import org.elasticsearch.index.query.CommonTermsQueryBuilder;
+import org.elasticsearch.index.query.ExistsQueryBuilder;
 import org.elasticsearch.index.query.FuzzyQueryBuilder;
 import org.elasticsearch.index.query.IdsQueryBuilder;
 import org.elasticsearch.index.query.MatchQueryBuilder;
 import org.elasticsearch.index.query.PrefixQueryBuilder;
 import org.elasticsearch.index.query.RangeQueryBuilder;
+import org.elasticsearch.index.query.RegexpQueryBuilder;
 import org.elasticsearch.index.query.TermQueryBuilder;
 import org.elasticsearch.index.query.TermsQueryBuilder;
+import org.elasticsearch.index.query.WildcardQueryBuilder;
 
 /**
  * @author ESFlute (using FreeGen)
@@ -268,6 +272,28 @@ public abstract class BsElevateWordToLabelCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setElevateWordId_Wildcard(String elevateWordId) {
+        setElevateWordId_Wildcard(elevateWordId, null);
+    }
+
+    public void setElevateWordId_Wildcard(String elevateWordId, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("elevateWordId", elevateWordId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setElevateWordId_Regexp(String elevateWordId) {
+        setElevateWordId_Regexp(elevateWordId, null);
+    }
+
+    public void setElevateWordId_Regexp(String elevateWordId, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("elevateWordId", elevateWordId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setElevateWordId_GreaterThan(String elevateWordId) {
         setElevateWordId_GreaterThan(elevateWordId, null);
     }
@@ -312,6 +338,28 @@ public abstract class BsElevateWordToLabelCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setElevateWordId_Exists() {
+        setElevateWordId_Exists(null);
+    }
+
+    public void setElevateWordId_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("elevateWordId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setElevateWordId_CommonTerms(String elevateWordId) {
+        setElevateWordId_CommonTerms(elevateWordId, null);
+    }
+
+    public void setElevateWordId_CommonTerms(String elevateWordId, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("elevateWordId", elevateWordId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsElevateWordToLabelCQ addOrderBy_ElevateWordId_Asc() {
         regOBA("elevateWordId");
         return this;
@@ -431,6 +479,28 @@ public abstract class BsElevateWordToLabelCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setLabelTypeId_Wildcard(String labelTypeId) {
+        setLabelTypeId_Wildcard(labelTypeId, null);
+    }
+
+    public void setLabelTypeId_Wildcard(String labelTypeId, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("labelTypeId", labelTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setLabelTypeId_Regexp(String labelTypeId) {
+        setLabelTypeId_Regexp(labelTypeId, null);
+    }
+
+    public void setLabelTypeId_Regexp(String labelTypeId, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("labelTypeId", labelTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setLabelTypeId_GreaterThan(String labelTypeId) {
         setLabelTypeId_GreaterThan(labelTypeId, null);
     }
@@ -475,6 +545,28 @@ public abstract class BsElevateWordToLabelCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setLabelTypeId_Exists() {
+        setLabelTypeId_Exists(null);
+    }
+
+    public void setLabelTypeId_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("labelTypeId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setLabelTypeId_CommonTerms(String labelTypeId) {
+        setLabelTypeId_CommonTerms(labelTypeId, null);
+    }
+
+    public void setLabelTypeId_CommonTerms(String labelTypeId, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("labelTypeId", labelTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsElevateWordToLabelCQ addOrderBy_LabelTypeId_Asc() {
         regOBA("labelTypeId");
         return this;

src/main/java/org/codelibs/fess/es/config/cbean/cq/bs/BsFailureUrlCQ.java

@@ -22,13 +22,17 @@ import org.codelibs.fess.es.config.allcommon.EsAbstractConditionQuery;
 import org.codelibs.fess.es.config.cbean.cq.FailureUrlCQ;
 import org.dbflute.cbean.ckey.ConditionKey;
 import org.elasticsearch.index.query.BoolQueryBuilder;
+import org.elasticsearch.index.query.CommonTermsQueryBuilder;
+import org.elasticsearch.index.query.ExistsQueryBuilder;
 import org.elasticsearch.index.query.FuzzyQueryBuilder;
 import org.elasticsearch.index.query.IdsQueryBuilder;
 import org.elasticsearch.index.query.MatchQueryBuilder;
 import org.elasticsearch.index.query.PrefixQueryBuilder;
 import org.elasticsearch.index.query.RangeQueryBuilder;
+import org.elasticsearch.index.query.RegexpQueryBuilder;
 import org.elasticsearch.index.query.TermQueryBuilder;
 import org.elasticsearch.index.query.TermsQueryBuilder;
+import org.elasticsearch.index.query.WildcardQueryBuilder;
 
 /**
  * @author ESFlute (using FreeGen)
@@ -267,6 +271,28 @@ public abstract class BsFailureUrlCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setConfigId_Wildcard(String configId) {
+        setConfigId_Wildcard(configId, null);
+    }
+
+    public void setConfigId_Wildcard(String configId, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("configId", configId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setConfigId_Regexp(String configId) {
+        setConfigId_Regexp(configId, null);
+    }
+
+    public void setConfigId_Regexp(String configId, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("configId", configId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setConfigId_GreaterThan(String configId) {
         setConfigId_GreaterThan(configId, null);
     }
@@ -311,6 +337,28 @@ public abstract class BsFailureUrlCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setConfigId_Exists() {
+        setConfigId_Exists(null);
+    }
+
+    public void setConfigId_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("configId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setConfigId_CommonTerms(String configId) {
+        setConfigId_CommonTerms(configId, null);
+    }
+
+    public void setConfigId_CommonTerms(String configId, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("configId", configId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsFailureUrlCQ addOrderBy_ConfigId_Asc() {
         regOBA("configId");
         return this;
@@ -463,6 +511,28 @@ public abstract class BsFailureUrlCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setErrorCount_Exists() {
+        setErrorCount_Exists(null);
+    }
+
+    public void setErrorCount_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("errorCount");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setErrorCount_CommonTerms(Integer errorCount) {
+        setErrorCount_CommonTerms(errorCount, null);
+    }
+
+    public void setErrorCount_CommonTerms(Integer errorCount, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("errorCount", errorCount);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsFailureUrlCQ addOrderBy_ErrorCount_Asc() {
         regOBA("errorCount");
         return this;
@@ -582,6 +652,28 @@ public abstract class BsFailureUrlCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setErrorLog_Wildcard(String errorLog) {
+        setErrorLog_Wildcard(errorLog, null);
+    }
+
+    public void setErrorLog_Wildcard(String errorLog, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("errorLog", errorLog);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setErrorLog_Regexp(String errorLog) {
+        setErrorLog_Regexp(errorLog, null);
+    }
+
+    public void setErrorLog_Regexp(String errorLog, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("errorLog", errorLog);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setErrorLog_GreaterThan(String errorLog) {
         setErrorLog_GreaterThan(errorLog, null);
     }
@@ -626,6 +718,28 @@ public abstract class BsFailureUrlCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setErrorLog_Exists() {
+        setErrorLog_Exists(null);
+    }
+
+    public void setErrorLog_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("errorLog");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setErrorLog_CommonTerms(String errorLog) {
+        setErrorLog_CommonTerms(errorLog, null);
+    }
+
+    public void setErrorLog_CommonTerms(String errorLog, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("errorLog", errorLog);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsFailureUrlCQ addOrderBy_ErrorLog_Asc() {
         regOBA("errorLog");
         return this;
@@ -745,6 +859,28 @@ public abstract class BsFailureUrlCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setErrorName_Wildcard(String errorName) {
+        setErrorName_Wildcard(errorName, null);
+    }
+
+    public void setErrorName_Wildcard(String errorName, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("errorName", errorName);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setErrorName_Regexp(String errorName) {
+        setErrorName_Regexp(errorName, null);
+    }
+
+    public void setErrorName_Regexp(String errorName, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("errorName", errorName);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setErrorName_GreaterThan(String errorName) {
         setErrorName_GreaterThan(errorName, null);
     }
@@ -789,6 +925,28 @@ public abstract class BsFailureUrlCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setErrorName_Exists() {
+        setErrorName_Exists(null);
+    }
+
+    public void setErrorName_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("errorName");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setErrorName_CommonTerms(String errorName) {
+        setErrorName_CommonTerms(errorName, null);
+    }
+
+    public void setErrorName_CommonTerms(String errorName, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("errorName", errorName);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsFailureUrlCQ addOrderBy_ErrorName_Asc() {
         regOBA("errorName");
         return this;
@@ -941,6 +1099,28 @@ public abstract class BsFailureUrlCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setLastAccessTime_Exists() {
+        setLastAccessTime_Exists(null);
+    }
+
+    public void setLastAccessTime_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("lastAccessTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setLastAccessTime_CommonTerms(Long lastAccessTime) {
+        setLastAccessTime_CommonTerms(lastAccessTime, null);
+    }
+
+    public void setLastAccessTime_CommonTerms(Long lastAccessTime, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("lastAccessTime", lastAccessTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsFailureUrlCQ addOrderBy_LastAccessTime_Asc() {
         regOBA("lastAccessTime");
         return this;
@@ -1060,6 +1240,28 @@ public abstract class BsFailureUrlCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setThreadName_Wildcard(String threadName) {
+        setThreadName_Wildcard(threadName, null);
+    }
+
+    public void setThreadName_Wildcard(String threadName, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("threadName", threadName);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setThreadName_Regexp(String threadName) {
+        setThreadName_Regexp(threadName, null);
+    }
+
+    public void setThreadName_Regexp(String threadName, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("threadName", threadName);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setThreadName_GreaterThan(String threadName) {
         setThreadName_GreaterThan(threadName, null);
     }
@@ -1104,6 +1306,28 @@ public abstract class BsFailureUrlCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setThreadName_Exists() {
+        setThreadName_Exists(null);
+    }
+
+    public void setThreadName_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("threadName");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setThreadName_CommonTerms(String threadName) {
+        setThreadName_CommonTerms(threadName, null);
+    }
+
+    public void setThreadName_CommonTerms(String threadName, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("threadName", threadName);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsFailureUrlCQ addOrderBy_ThreadName_Asc() {
         regOBA("threadName");
         return this;
@@ -1223,6 +1447,28 @@ public abstract class BsFailureUrlCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUrl_Wildcard(String url) {
+        setUrl_Wildcard(url, null);
+    }
+
+    public void setUrl_Wildcard(String url, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("url", url);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUrl_Regexp(String url) {
+        setUrl_Regexp(url, null);
+    }
+
+    public void setUrl_Regexp(String url, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("url", url);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setUrl_GreaterThan(String url) {
         setUrl_GreaterThan(url, null);
     }
@@ -1267,6 +1513,28 @@ public abstract class BsFailureUrlCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUrl_Exists() {
+        setUrl_Exists(null);
+    }
+
+    public void setUrl_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("url");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUrl_CommonTerms(String url) {
+        setUrl_CommonTerms(url, null);
+    }
+
+    public void setUrl_CommonTerms(String url, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("url", url);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsFailureUrlCQ addOrderBy_Url_Asc() {
         regOBA("url");
         return this;

src/main/java/org/codelibs/fess/es/config/cbean/cq/bs/BsFileAuthenticationCQ.java

@@ -22,13 +22,17 @@ import org.codelibs.fess.es.config.allcommon.EsAbstractConditionQuery;
 import org.codelibs.fess.es.config.cbean.cq.FileAuthenticationCQ;
 import org.dbflute.cbean.ckey.ConditionKey;
 import org.elasticsearch.index.query.BoolQueryBuilder;
+import org.elasticsearch.index.query.CommonTermsQueryBuilder;
+import org.elasticsearch.index.query.ExistsQueryBuilder;
 import org.elasticsearch.index.query.FuzzyQueryBuilder;
 import org.elasticsearch.index.query.IdsQueryBuilder;
 import org.elasticsearch.index.query.MatchQueryBuilder;
 import org.elasticsearch.index.query.PrefixQueryBuilder;
 import org.elasticsearch.index.query.RangeQueryBuilder;
+import org.elasticsearch.index.query.RegexpQueryBuilder;
 import org.elasticsearch.index.query.TermQueryBuilder;
 import org.elasticsearch.index.query.TermsQueryBuilder;
+import org.elasticsearch.index.query.WildcardQueryBuilder;
 
 /**
  * @author ESFlute (using FreeGen)
@@ -268,6 +272,28 @@ public abstract class BsFileAuthenticationCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setCreatedBy_Wildcard(String createdBy) {
+        setCreatedBy_Wildcard(createdBy, null);
+    }
+
+    public void setCreatedBy_Wildcard(String createdBy, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Regexp(String createdBy) {
+        setCreatedBy_Regexp(createdBy, null);
+    }
+
+    public void setCreatedBy_Regexp(String createdBy, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setCreatedBy_GreaterThan(String createdBy) {
         setCreatedBy_GreaterThan(createdBy, null);
     }
@@ -312,6 +338,28 @@ public abstract class BsFileAuthenticationCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setCreatedBy_Exists() {
+        setCreatedBy_Exists(null);
+    }
+
+    public void setCreatedBy_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("createdBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_CommonTerms(String createdBy) {
+        setCreatedBy_CommonTerms(createdBy, null);
+    }
+
+    public void setCreatedBy_CommonTerms(String createdBy, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsFileAuthenticationCQ addOrderBy_CreatedBy_Asc() {
         regOBA("createdBy");
         return this;
@@ -464,6 +512,28 @@ public abstract class BsFileAuthenticationCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setCreatedTime_Exists() {
+        setCreatedTime_Exists(null);
+    }
+
+    public void setCreatedTime_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("createdTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_CommonTerms(Long createdTime) {
+        setCreatedTime_CommonTerms(createdTime, null);
+    }
+
+    public void setCreatedTime_CommonTerms(Long createdTime, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("createdTime", createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsFileAuthenticationCQ addOrderBy_CreatedTime_Asc() {
         regOBA("createdTime");
         return this;
@@ -583,6 +653,28 @@ public abstract class BsFileAuthenticationCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setFileConfigId_Wildcard(String fileConfigId) {
+        setFileConfigId_Wildcard(fileConfigId, null);
+    }
+
+    public void setFileConfigId_Wildcard(String fileConfigId, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("fileConfigId", fileConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setFileConfigId_Regexp(String fileConfigId) {
+        setFileConfigId_Regexp(fileConfigId, null);
+    }
+
+    public void setFileConfigId_Regexp(String fileConfigId, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("fileConfigId", fileConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setFileConfigId_GreaterThan(String fileConfigId) {
         setFileConfigId_GreaterThan(fileConfigId, null);
     }
@@ -627,6 +719,28 @@ public abstract class BsFileAuthenticationCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setFileConfigId_Exists() {
+        setFileConfigId_Exists(null);
+    }
+
+    public void setFileConfigId_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("fileConfigId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setFileConfigId_CommonTerms(String fileConfigId) {
+        setFileConfigId_CommonTerms(fileConfigId, null);
+    }
+
+    public void setFileConfigId_CommonTerms(String fileConfigId, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("fileConfigId", fileConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsFileAuthenticationCQ addOrderBy_FileConfigId_Asc() {
         regOBA("fileConfigId");
         return this;
@@ -746,6 +860,28 @@ public abstract class BsFileAuthenticationCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setHostname_Wildcard(String hostname) {
+        setHostname_Wildcard(hostname, null);
+    }
+
+    public void setHostname_Wildcard(String hostname, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("hostname", hostname);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHostname_Regexp(String hostname) {
+        setHostname_Regexp(hostname, null);
+    }
+
+    public void setHostname_Regexp(String hostname, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("hostname", hostname);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setHostname_GreaterThan(String hostname) {
         setHostname_GreaterThan(hostname, null);
     }
@@ -790,6 +926,28 @@ public abstract class BsFileAuthenticationCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setHostname_Exists() {
+        setHostname_Exists(null);
+    }
+
+    public void setHostname_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("hostname");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHostname_CommonTerms(String hostname) {
+        setHostname_CommonTerms(hostname, null);
+    }
+
+    public void setHostname_CommonTerms(String hostname, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("hostname", hostname);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsFileAuthenticationCQ addOrderBy_Hostname_Asc() {
         regOBA("hostname");
         return this;
@@ -909,6 +1067,28 @@ public abstract class BsFileAuthenticationCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setParameters_Wildcard(String parameters) {
+        setParameters_Wildcard(parameters, null);
+    }
+
+    public void setParameters_Wildcard(String parameters, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("parameters", parameters);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setParameters_Regexp(String parameters) {
+        setParameters_Regexp(parameters, null);
+    }
+
+    public void setParameters_Regexp(String parameters, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("parameters", parameters);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setParameters_GreaterThan(String parameters) {
         setParameters_GreaterThan(parameters, null);
     }
@@ -953,6 +1133,28 @@ public abstract class BsFileAuthenticationCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setParameters_Exists() {
+        setParameters_Exists(null);
+    }
+
+    public void setParameters_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("parameters");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setParameters_CommonTerms(String parameters) {
+        setParameters_CommonTerms(parameters, null);
+    }
+
+    public void setParameters_CommonTerms(String parameters, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("parameters", parameters);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsFileAuthenticationCQ addOrderBy_Parameters_Asc() {
         regOBA("parameters");
         return this;
@@ -1072,6 +1274,28 @@ public abstract class BsFileAuthenticationCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setPassword_Wildcard(String password) {
+        setPassword_Wildcard(password, null);
+    }
+
+    public void setPassword_Wildcard(String password, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("password", password);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setPassword_Regexp(String password) {
+        setPassword_Regexp(password, null);
+    }
+
+    public void setPassword_Regexp(String password, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("password", password);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setPassword_GreaterThan(String password) {
         setPassword_GreaterThan(password, null);
     }
@@ -1116,6 +1340,28 @@ public abstract class BsFileAuthenticationCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setPassword_Exists() {
+        setPassword_Exists(null);
+    }
+
+    public void setPassword_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("password");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setPassword_CommonTerms(String password) {
+        setPassword_CommonTerms(password, null);
+    }
+
+    public void setPassword_CommonTerms(String password, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("password", password);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsFileAuthenticationCQ addOrderBy_Password_Asc() {
         regOBA("password");
         return this;
@@ -1268,6 +1514,28 @@ public abstract class BsFileAuthenticationCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setPort_Exists() {
+        setPort_Exists(null);
+    }
+
+    public void setPort_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("port");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setPort_CommonTerms(Integer port) {
+        setPort_CommonTerms(port, null);
+    }
+
+    public void setPort_CommonTerms(Integer port, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("port", port);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsFileAuthenticationCQ addOrderBy_Port_Asc() {
         regOBA("port");
         return this;
@@ -1387,6 +1655,28 @@ public abstract class BsFileAuthenticationCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setProtocolScheme_Wildcard(String protocolScheme) {
+        setProtocolScheme_Wildcard(protocolScheme, null);
+    }
+
+    public void setProtocolScheme_Wildcard(String protocolScheme, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("protocolScheme", protocolScheme);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setProtocolScheme_Regexp(String protocolScheme) {
+        setProtocolScheme_Regexp(protocolScheme, null);
+    }
+
+    public void setProtocolScheme_Regexp(String protocolScheme, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("protocolScheme", protocolScheme);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setProtocolScheme_GreaterThan(String protocolScheme) {
         setProtocolScheme_GreaterThan(protocolScheme, null);
     }
@@ -1431,6 +1721,28 @@ public abstract class BsFileAuthenticationCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setProtocolScheme_Exists() {
+        setProtocolScheme_Exists(null);
+    }
+
+    public void setProtocolScheme_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("protocolScheme");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setProtocolScheme_CommonTerms(String protocolScheme) {
+        setProtocolScheme_CommonTerms(protocolScheme, null);
+    }
+
+    public void setProtocolScheme_CommonTerms(String protocolScheme, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("protocolScheme", protocolScheme);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsFileAuthenticationCQ addOrderBy_ProtocolScheme_Asc() {
         regOBA("protocolScheme");
         return this;
@@ -1550,6 +1862,28 @@ public abstract class BsFileAuthenticationCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUpdatedBy_Wildcard(String updatedBy) {
+        setUpdatedBy_Wildcard(updatedBy, null);
+    }
+
+    public void setUpdatedBy_Wildcard(String updatedBy, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Regexp(String updatedBy) {
+        setUpdatedBy_Regexp(updatedBy, null);
+    }
+
+    public void setUpdatedBy_Regexp(String updatedBy, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setUpdatedBy_GreaterThan(String updatedBy) {
         setUpdatedBy_GreaterThan(updatedBy, null);
     }
@@ -1594,6 +1928,28 @@ public abstract class BsFileAuthenticationCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUpdatedBy_Exists() {
+        setUpdatedBy_Exists(null);
+    }
+
+    public void setUpdatedBy_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("updatedBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_CommonTerms(String updatedBy) {
+        setUpdatedBy_CommonTerms(updatedBy, null);
+    }
+
+    public void setUpdatedBy_CommonTerms(String updatedBy, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsFileAuthenticationCQ addOrderBy_UpdatedBy_Asc() {
         regOBA("updatedBy");
         return this;
@@ -1746,6 +2102,28 @@ public abstract class BsFileAuthenticationCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUpdatedTime_Exists() {
+        setUpdatedTime_Exists(null);
+    }
+
+    public void setUpdatedTime_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("updatedTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_CommonTerms(Long updatedTime) {
+        setUpdatedTime_CommonTerms(updatedTime, null);
+    }
+
+    public void setUpdatedTime_CommonTerms(Long updatedTime, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("updatedTime", updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsFileAuthenticationCQ addOrderBy_UpdatedTime_Asc() {
         regOBA("updatedTime");
         return this;
@@ -1865,6 +2243,28 @@ public abstract class BsFileAuthenticationCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUsername_Wildcard(String username) {
+        setUsername_Wildcard(username, null);
+    }
+
+    public void setUsername_Wildcard(String username, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("username", username);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUsername_Regexp(String username) {
+        setUsername_Regexp(username, null);
+    }
+
+    public void setUsername_Regexp(String username, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("username", username);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setUsername_GreaterThan(String username) {
         setUsername_GreaterThan(username, null);
     }
@@ -1909,6 +2309,28 @@ public abstract class BsFileAuthenticationCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUsername_Exists() {
+        setUsername_Exists(null);
+    }
+
+    public void setUsername_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("username");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUsername_CommonTerms(String username) {
+        setUsername_CommonTerms(username, null);
+    }
+
+    public void setUsername_CommonTerms(String username, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("username", username);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsFileAuthenticationCQ addOrderBy_Username_Asc() {
         regOBA("username");
         return this;

src/main/java/org/codelibs/fess/es/config/cbean/cq/bs/BsFileConfigCQ.java

@@ -22,13 +22,17 @@ import org.codelibs.fess.es.config.allcommon.EsAbstractConditionQuery;
 import org.codelibs.fess.es.config.cbean.cq.FileConfigCQ;
 import org.dbflute.cbean.ckey.ConditionKey;
 import org.elasticsearch.index.query.BoolQueryBuilder;
+import org.elasticsearch.index.query.CommonTermsQueryBuilder;
+import org.elasticsearch.index.query.ExistsQueryBuilder;
 import org.elasticsearch.index.query.FuzzyQueryBuilder;
 import org.elasticsearch.index.query.IdsQueryBuilder;
 import org.elasticsearch.index.query.MatchQueryBuilder;
 import org.elasticsearch.index.query.PrefixQueryBuilder;
 import org.elasticsearch.index.query.RangeQueryBuilder;
+import org.elasticsearch.index.query.RegexpQueryBuilder;
 import org.elasticsearch.index.query.TermQueryBuilder;
 import org.elasticsearch.index.query.TermsQueryBuilder;
+import org.elasticsearch.index.query.WildcardQueryBuilder;
 
 /**
  * @author ESFlute (using FreeGen)
@@ -300,6 +304,28 @@ public abstract class BsFileConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setAvailable_Exists() {
+        setAvailable_Exists(null);
+    }
+
+    public void setAvailable_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("available");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setAvailable_CommonTerms(Boolean available) {
+        setAvailable_CommonTerms(available, null);
+    }
+
+    public void setAvailable_CommonTerms(Boolean available, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("available", available);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsFileConfigCQ addOrderBy_Available_Asc() {
         regOBA("available");
         return this;
@@ -452,6 +478,28 @@ public abstract class BsFileConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setBoost_Exists() {
+        setBoost_Exists(null);
+    }
+
+    public void setBoost_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("boost");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setBoost_CommonTerms(Float boost) {
+        setBoost_CommonTerms(boost, null);
+    }
+
+    public void setBoost_CommonTerms(Float boost, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("boost", boost);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsFileConfigCQ addOrderBy_Boost_Asc() {
         regOBA("boost");
         return this;
@@ -571,6 +619,28 @@ public abstract class BsFileConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setConfigParameter_Wildcard(String configParameter) {
+        setConfigParameter_Wildcard(configParameter, null);
+    }
+
+    public void setConfigParameter_Wildcard(String configParameter, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("configParameter", configParameter);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setConfigParameter_Regexp(String configParameter) {
+        setConfigParameter_Regexp(configParameter, null);
+    }
+
+    public void setConfigParameter_Regexp(String configParameter, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("configParameter", configParameter);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setConfigParameter_GreaterThan(String configParameter) {
         setConfigParameter_GreaterThan(configParameter, null);
     }
@@ -615,6 +685,28 @@ public abstract class BsFileConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setConfigParameter_Exists() {
+        setConfigParameter_Exists(null);
+    }
+
+    public void setConfigParameter_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("configParameter");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setConfigParameter_CommonTerms(String configParameter) {
+        setConfigParameter_CommonTerms(configParameter, null);
+    }
+
+    public void setConfigParameter_CommonTerms(String configParameter, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("configParameter", configParameter);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsFileConfigCQ addOrderBy_ConfigParameter_Asc() {
         regOBA("configParameter");
         return this;
@@ -734,6 +826,28 @@ public abstract class BsFileConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setCreatedBy_Wildcard(String createdBy) {
+        setCreatedBy_Wildcard(createdBy, null);
+    }
+
+    public void setCreatedBy_Wildcard(String createdBy, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Regexp(String createdBy) {
+        setCreatedBy_Regexp(createdBy, null);
+    }
+
+    public void setCreatedBy_Regexp(String createdBy, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setCreatedBy_GreaterThan(String createdBy) {
         setCreatedBy_GreaterThan(createdBy, null);
     }
@@ -778,6 +892,28 @@ public abstract class BsFileConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setCreatedBy_Exists() {
+        setCreatedBy_Exists(null);
+    }
+
+    public void setCreatedBy_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("createdBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_CommonTerms(String createdBy) {
+        setCreatedBy_CommonTerms(createdBy, null);
+    }
+
+    public void setCreatedBy_CommonTerms(String createdBy, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsFileConfigCQ addOrderBy_CreatedBy_Asc() {
         regOBA("createdBy");
         return this;
@@ -930,6 +1066,28 @@ public abstract class BsFileConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setCreatedTime_Exists() {
+        setCreatedTime_Exists(null);
+    }
+
+    public void setCreatedTime_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("createdTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_CommonTerms(Long createdTime) {
+        setCreatedTime_CommonTerms(createdTime, null);
+    }
+
+    public void setCreatedTime_CommonTerms(Long createdTime, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("createdTime", createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsFileConfigCQ addOrderBy_CreatedTime_Asc() {
         regOBA("createdTime");
         return this;
@@ -1082,6 +1240,28 @@ public abstract class BsFileConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setDepth_Exists() {
+        setDepth_Exists(null);
+    }
+
+    public void setDepth_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("depth");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setDepth_CommonTerms(Integer depth) {
+        setDepth_CommonTerms(depth, null);
+    }
+
+    public void setDepth_CommonTerms(Integer depth, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("depth", depth);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsFileConfigCQ addOrderBy_Depth_Asc() {
         regOBA("depth");
         return this;
@@ -1201,6 +1381,28 @@ public abstract class BsFileConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setExcludedDocPaths_Wildcard(String excludedDocPaths) {
+        setExcludedDocPaths_Wildcard(excludedDocPaths, null);
+    }
+
+    public void setExcludedDocPaths_Wildcard(String excludedDocPaths, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("excludedDocPaths", excludedDocPaths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExcludedDocPaths_Regexp(String excludedDocPaths) {
+        setExcludedDocPaths_Regexp(excludedDocPaths, null);
+    }
+
+    public void setExcludedDocPaths_Regexp(String excludedDocPaths, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("excludedDocPaths", excludedDocPaths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setExcludedDocPaths_GreaterThan(String excludedDocPaths) {
         setExcludedDocPaths_GreaterThan(excludedDocPaths, null);
     }
@@ -1245,6 +1447,28 @@ public abstract class BsFileConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setExcludedDocPaths_Exists() {
+        setExcludedDocPaths_Exists(null);
+    }
+
+    public void setExcludedDocPaths_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("excludedDocPaths");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExcludedDocPaths_CommonTerms(String excludedDocPaths) {
+        setExcludedDocPaths_CommonTerms(excludedDocPaths, null);
+    }
+
+    public void setExcludedDocPaths_CommonTerms(String excludedDocPaths, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("excludedDocPaths", excludedDocPaths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsFileConfigCQ addOrderBy_ExcludedDocPaths_Asc() {
         regOBA("excludedDocPaths");
         return this;
@@ -1364,6 +1588,28 @@ public abstract class BsFileConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setExcludedPaths_Wildcard(String excludedPaths) {
+        setExcludedPaths_Wildcard(excludedPaths, null);
+    }
+
+    public void setExcludedPaths_Wildcard(String excludedPaths, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("excludedPaths", excludedPaths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExcludedPaths_Regexp(String excludedPaths) {
+        setExcludedPaths_Regexp(excludedPaths, null);
+    }
+
+    public void setExcludedPaths_Regexp(String excludedPaths, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("excludedPaths", excludedPaths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setExcludedPaths_GreaterThan(String excludedPaths) {
         setExcludedPaths_GreaterThan(excludedPaths, null);
     }
@@ -1408,6 +1654,28 @@ public abstract class BsFileConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setExcludedPaths_Exists() {
+        setExcludedPaths_Exists(null);
+    }
+
+    public void setExcludedPaths_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("excludedPaths");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExcludedPaths_CommonTerms(String excludedPaths) {
+        setExcludedPaths_CommonTerms(excludedPaths, null);
+    }
+
+    public void setExcludedPaths_CommonTerms(String excludedPaths, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("excludedPaths", excludedPaths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsFileConfigCQ addOrderBy_ExcludedPaths_Asc() {
         regOBA("excludedPaths");
         return this;
@@ -1527,6 +1795,28 @@ public abstract class BsFileConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setIncludedDocPaths_Wildcard(String includedDocPaths) {
+        setIncludedDocPaths_Wildcard(includedDocPaths, null);
+    }
+
+    public void setIncludedDocPaths_Wildcard(String includedDocPaths, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("includedDocPaths", includedDocPaths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIncludedDocPaths_Regexp(String includedDocPaths) {
+        setIncludedDocPaths_Regexp(includedDocPaths, null);
+    }
+
+    public void setIncludedDocPaths_Regexp(String includedDocPaths, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("includedDocPaths", includedDocPaths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setIncludedDocPaths_GreaterThan(String includedDocPaths) {
         setIncludedDocPaths_GreaterThan(includedDocPaths, null);
     }
@@ -1571,6 +1861,28 @@ public abstract class BsFileConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setIncludedDocPaths_Exists() {
+        setIncludedDocPaths_Exists(null);
+    }
+
+    public void setIncludedDocPaths_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("includedDocPaths");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIncludedDocPaths_CommonTerms(String includedDocPaths) {
+        setIncludedDocPaths_CommonTerms(includedDocPaths, null);
+    }
+
+    public void setIncludedDocPaths_CommonTerms(String includedDocPaths, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("includedDocPaths", includedDocPaths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsFileConfigCQ addOrderBy_IncludedDocPaths_Asc() {
         regOBA("includedDocPaths");
         return this;
@@ -1690,6 +2002,28 @@ public abstract class BsFileConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setIncludedPaths_Wildcard(String includedPaths) {
+        setIncludedPaths_Wildcard(includedPaths, null);
+    }
+
+    public void setIncludedPaths_Wildcard(String includedPaths, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("includedPaths", includedPaths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIncludedPaths_Regexp(String includedPaths) {
+        setIncludedPaths_Regexp(includedPaths, null);
+    }
+
+    public void setIncludedPaths_Regexp(String includedPaths, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("includedPaths", includedPaths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setIncludedPaths_GreaterThan(String includedPaths) {
         setIncludedPaths_GreaterThan(includedPaths, null);
     }
@@ -1734,6 +2068,28 @@ public abstract class BsFileConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setIncludedPaths_Exists() {
+        setIncludedPaths_Exists(null);
+    }
+
+    public void setIncludedPaths_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("includedPaths");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIncludedPaths_CommonTerms(String includedPaths) {
+        setIncludedPaths_CommonTerms(includedPaths, null);
+    }
+
+    public void setIncludedPaths_CommonTerms(String includedPaths, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("includedPaths", includedPaths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsFileConfigCQ addOrderBy_IncludedPaths_Asc() {
         regOBA("includedPaths");
         return this;
@@ -1886,6 +2242,28 @@ public abstract class BsFileConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setIntervalTime_Exists() {
+        setIntervalTime_Exists(null);
+    }
+
+    public void setIntervalTime_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("intervalTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIntervalTime_CommonTerms(Integer intervalTime) {
+        setIntervalTime_CommonTerms(intervalTime, null);
+    }
+
+    public void setIntervalTime_CommonTerms(Integer intervalTime, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("intervalTime", intervalTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsFileConfigCQ addOrderBy_IntervalTime_Asc() {
         regOBA("intervalTime");
         return this;
@@ -2038,6 +2416,28 @@ public abstract class BsFileConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setTimeToLive_Exists() {
+        setTimeToLive_Exists(null);
+    }
+
+    public void setTimeToLive_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("timeToLive");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTimeToLive_CommonTerms(Integer timeToLive) {
+        setTimeToLive_CommonTerms(timeToLive, null);
+    }
+
+    public void setTimeToLive_CommonTerms(Integer timeToLive, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("timeToLive", timeToLive);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsFileConfigCQ addOrderBy_TimeToLive_Asc() {
         regOBA("timeToLive");
         return this;
@@ -2190,6 +2590,28 @@ public abstract class BsFileConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setMaxAccessCount_Exists() {
+        setMaxAccessCount_Exists(null);
+    }
+
+    public void setMaxAccessCount_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("maxAccessCount");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setMaxAccessCount_CommonTerms(Long maxAccessCount) {
+        setMaxAccessCount_CommonTerms(maxAccessCount, null);
+    }
+
+    public void setMaxAccessCount_CommonTerms(Long maxAccessCount, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("maxAccessCount", maxAccessCount);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsFileConfigCQ addOrderBy_MaxAccessCount_Asc() {
         regOBA("maxAccessCount");
         return this;
@@ -2309,6 +2731,28 @@ public abstract class BsFileConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setName_Wildcard(String name) {
+        setName_Wildcard(name, null);
+    }
+
+    public void setName_Wildcard(String name, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("name", name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_Regexp(String name) {
+        setName_Regexp(name, null);
+    }
+
+    public void setName_Regexp(String name, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("name", name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setName_GreaterThan(String name) {
         setName_GreaterThan(name, null);
     }
@@ -2353,6 +2797,28 @@ public abstract class BsFileConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setName_Exists() {
+        setName_Exists(null);
+    }
+
+    public void setName_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("name");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_CommonTerms(String name) {
+        setName_CommonTerms(name, null);
+    }
+
+    public void setName_CommonTerms(String name, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("name", name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsFileConfigCQ addOrderBy_Name_Asc() {
         regOBA("name");
         return this;
@@ -2505,6 +2971,28 @@ public abstract class BsFileConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setNumOfThread_Exists() {
+        setNumOfThread_Exists(null);
+    }
+
+    public void setNumOfThread_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("numOfThread");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setNumOfThread_CommonTerms(Integer numOfThread) {
+        setNumOfThread_CommonTerms(numOfThread, null);
+    }
+
+    public void setNumOfThread_CommonTerms(Integer numOfThread, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("numOfThread", numOfThread);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsFileConfigCQ addOrderBy_NumOfThread_Asc() {
         regOBA("numOfThread");
         return this;
@@ -2624,6 +3112,28 @@ public abstract class BsFileConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setPaths_Wildcard(String paths) {
+        setPaths_Wildcard(paths, null);
+    }
+
+    public void setPaths_Wildcard(String paths, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("paths", paths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setPaths_Regexp(String paths) {
+        setPaths_Regexp(paths, null);
+    }
+
+    public void setPaths_Regexp(String paths, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("paths", paths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setPaths_GreaterThan(String paths) {
         setPaths_GreaterThan(paths, null);
     }
@@ -2668,6 +3178,28 @@ public abstract class BsFileConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setPaths_Exists() {
+        setPaths_Exists(null);
+    }
+
+    public void setPaths_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("paths");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setPaths_CommonTerms(String paths) {
+        setPaths_CommonTerms(paths, null);
+    }
+
+    public void setPaths_CommonTerms(String paths, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("paths", paths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsFileConfigCQ addOrderBy_Paths_Asc() {
         regOBA("paths");
         return this;
@@ -2787,6 +3319,28 @@ public abstract class BsFileConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setPermissions_Wildcard(String permissions) {
+        setPermissions_Wildcard(permissions, null);
+    }
+
+    public void setPermissions_Wildcard(String permissions, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("permissions", permissions);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setPermissions_Regexp(String permissions) {
+        setPermissions_Regexp(permissions, null);
+    }
+
+    public void setPermissions_Regexp(String permissions, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("permissions", permissions);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setPermissions_GreaterThan(String permissions) {
         setPermissions_GreaterThan(permissions, null);
     }
@@ -2831,6 +3385,28 @@ public abstract class BsFileConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setPermissions_Exists() {
+        setPermissions_Exists(null);
+    }
+
+    public void setPermissions_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("permissions");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setPermissions_CommonTerms(String permissions) {
+        setPermissions_CommonTerms(permissions, null);
+    }
+
+    public void setPermissions_CommonTerms(String permissions, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("permissions", permissions);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsFileConfigCQ addOrderBy_Permissions_Asc() {
         regOBA("permissions");
         return this;
@@ -2983,6 +3559,28 @@ public abstract class BsFileConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setSortOrder_Exists() {
+        setSortOrder_Exists(null);
+    }
+
+    public void setSortOrder_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("sortOrder");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_CommonTerms(Integer sortOrder) {
+        setSortOrder_CommonTerms(sortOrder, null);
+    }
+
+    public void setSortOrder_CommonTerms(Integer sortOrder, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("sortOrder", sortOrder);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsFileConfigCQ addOrderBy_SortOrder_Asc() {
         regOBA("sortOrder");
         return this;
@@ -3102,6 +3700,28 @@ public abstract class BsFileConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUpdatedBy_Wildcard(String updatedBy) {
+        setUpdatedBy_Wildcard(updatedBy, null);
+    }
+
+    public void setUpdatedBy_Wildcard(String updatedBy, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Regexp(String updatedBy) {
+        setUpdatedBy_Regexp(updatedBy, null);
+    }
+
+    public void setUpdatedBy_Regexp(String updatedBy, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setUpdatedBy_GreaterThan(String updatedBy) {
         setUpdatedBy_GreaterThan(updatedBy, null);
     }
@@ -3146,6 +3766,28 @@ public abstract class BsFileConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUpdatedBy_Exists() {
+        setUpdatedBy_Exists(null);
+    }
+
+    public void setUpdatedBy_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("updatedBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_CommonTerms(String updatedBy) {
+        setUpdatedBy_CommonTerms(updatedBy, null);
+    }
+
+    public void setUpdatedBy_CommonTerms(String updatedBy, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsFileConfigCQ addOrderBy_UpdatedBy_Asc() {
         regOBA("updatedBy");
         return this;
@@ -3298,6 +3940,28 @@ public abstract class BsFileConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUpdatedTime_Exists() {
+        setUpdatedTime_Exists(null);
+    }
+
+    public void setUpdatedTime_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("updatedTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_CommonTerms(Long updatedTime) {
+        setUpdatedTime_CommonTerms(updatedTime, null);
+    }
+
+    public void setUpdatedTime_CommonTerms(Long updatedTime, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("updatedTime", updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsFileConfigCQ addOrderBy_UpdatedTime_Asc() {
         regOBA("updatedTime");
         return this;

src/main/java/org/codelibs/fess/es/config/cbean/cq/bs/BsFileConfigToLabelCQ.java

@@ -22,13 +22,17 @@ import org.codelibs.fess.es.config.allcommon.EsAbstractConditionQuery;
 import org.codelibs.fess.es.config.cbean.cq.FileConfigToLabelCQ;
 import org.dbflute.cbean.ckey.ConditionKey;
 import org.elasticsearch.index.query.BoolQueryBuilder;
+import org.elasticsearch.index.query.CommonTermsQueryBuilder;
+import org.elasticsearch.index.query.ExistsQueryBuilder;
 import org.elasticsearch.index.query.FuzzyQueryBuilder;
 import org.elasticsearch.index.query.IdsQueryBuilder;
 import org.elasticsearch.index.query.MatchQueryBuilder;
 import org.elasticsearch.index.query.PrefixQueryBuilder;
 import org.elasticsearch.index.query.RangeQueryBuilder;
+import org.elasticsearch.index.query.RegexpQueryBuilder;
 import org.elasticsearch.index.query.TermQueryBuilder;
 import org.elasticsearch.index.query.TermsQueryBuilder;
+import org.elasticsearch.index.query.WildcardQueryBuilder;
 
 /**
  * @author ESFlute (using FreeGen)
@@ -268,6 +272,28 @@ public abstract class BsFileConfigToLabelCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setFileConfigId_Wildcard(String fileConfigId) {
+        setFileConfigId_Wildcard(fileConfigId, null);
+    }
+
+    public void setFileConfigId_Wildcard(String fileConfigId, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("fileConfigId", fileConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setFileConfigId_Regexp(String fileConfigId) {
+        setFileConfigId_Regexp(fileConfigId, null);
+    }
+
+    public void setFileConfigId_Regexp(String fileConfigId, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("fileConfigId", fileConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setFileConfigId_GreaterThan(String fileConfigId) {
         setFileConfigId_GreaterThan(fileConfigId, null);
     }
@@ -312,6 +338,28 @@ public abstract class BsFileConfigToLabelCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setFileConfigId_Exists() {
+        setFileConfigId_Exists(null);
+    }
+
+    public void setFileConfigId_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("fileConfigId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setFileConfigId_CommonTerms(String fileConfigId) {
+        setFileConfigId_CommonTerms(fileConfigId, null);
+    }
+
+    public void setFileConfigId_CommonTerms(String fileConfigId, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("fileConfigId", fileConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsFileConfigToLabelCQ addOrderBy_FileConfigId_Asc() {
         regOBA("fileConfigId");
         return this;
@@ -431,6 +479,28 @@ public abstract class BsFileConfigToLabelCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setLabelTypeId_Wildcard(String labelTypeId) {
+        setLabelTypeId_Wildcard(labelTypeId, null);
+    }
+
+    public void setLabelTypeId_Wildcard(String labelTypeId, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("labelTypeId", labelTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setLabelTypeId_Regexp(String labelTypeId) {
+        setLabelTypeId_Regexp(labelTypeId, null);
+    }
+
+    public void setLabelTypeId_Regexp(String labelTypeId, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("labelTypeId", labelTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setLabelTypeId_GreaterThan(String labelTypeId) {
         setLabelTypeId_GreaterThan(labelTypeId, null);
     }
@@ -475,6 +545,28 @@ public abstract class BsFileConfigToLabelCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setLabelTypeId_Exists() {
+        setLabelTypeId_Exists(null);
+    }
+
+    public void setLabelTypeId_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("labelTypeId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setLabelTypeId_CommonTerms(String labelTypeId) {
+        setLabelTypeId_CommonTerms(labelTypeId, null);
+    }
+
+    public void setLabelTypeId_CommonTerms(String labelTypeId, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("labelTypeId", labelTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsFileConfigToLabelCQ addOrderBy_LabelTypeId_Asc() {
         regOBA("labelTypeId");
         return this;

src/main/java/org/codelibs/fess/es/config/cbean/cq/bs/BsFileConfigToRoleCQ.java

@@ -22,13 +22,17 @@ import org.codelibs.fess.es.config.allcommon.EsAbstractConditionQuery;
 import org.codelibs.fess.es.config.cbean.cq.FileConfigToRoleCQ;
 import org.dbflute.cbean.ckey.ConditionKey;
 import org.elasticsearch.index.query.BoolQueryBuilder;
+import org.elasticsearch.index.query.CommonTermsQueryBuilder;
+import org.elasticsearch.index.query.ExistsQueryBuilder;
 import org.elasticsearch.index.query.FuzzyQueryBuilder;
 import org.elasticsearch.index.query.IdsQueryBuilder;
 import org.elasticsearch.index.query.MatchQueryBuilder;
 import org.elasticsearch.index.query.PrefixQueryBuilder;
 import org.elasticsearch.index.query.RangeQueryBuilder;
+import org.elasticsearch.index.query.RegexpQueryBuilder;
 import org.elasticsearch.index.query.TermQueryBuilder;
 import org.elasticsearch.index.query.TermsQueryBuilder;
+import org.elasticsearch.index.query.WildcardQueryBuilder;
 
 /**
  * @author ESFlute (using FreeGen)
@@ -267,6 +271,28 @@ public abstract class BsFileConfigToRoleCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setFileConfigId_Wildcard(String fileConfigId) {
+        setFileConfigId_Wildcard(fileConfigId, null);
+    }
+
+    public void setFileConfigId_Wildcard(String fileConfigId, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("fileConfigId", fileConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setFileConfigId_Regexp(String fileConfigId) {
+        setFileConfigId_Regexp(fileConfigId, null);
+    }
+
+    public void setFileConfigId_Regexp(String fileConfigId, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("fileConfigId", fileConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setFileConfigId_GreaterThan(String fileConfigId) {
         setFileConfigId_GreaterThan(fileConfigId, null);
     }
@@ -311,6 +337,28 @@ public abstract class BsFileConfigToRoleCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setFileConfigId_Exists() {
+        setFileConfigId_Exists(null);
+    }
+
+    public void setFileConfigId_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("fileConfigId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setFileConfigId_CommonTerms(String fileConfigId) {
+        setFileConfigId_CommonTerms(fileConfigId, null);
+    }
+
+    public void setFileConfigId_CommonTerms(String fileConfigId, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("fileConfigId", fileConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsFileConfigToRoleCQ addOrderBy_FileConfigId_Asc() {
         regOBA("fileConfigId");
         return this;
@@ -430,6 +478,28 @@ public abstract class BsFileConfigToRoleCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setRoleTypeId_Wildcard(String roleTypeId) {
+        setRoleTypeId_Wildcard(roleTypeId, null);
+    }
+
+    public void setRoleTypeId_Wildcard(String roleTypeId, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("roleTypeId", roleTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRoleTypeId_Regexp(String roleTypeId) {
+        setRoleTypeId_Regexp(roleTypeId, null);
+    }
+
+    public void setRoleTypeId_Regexp(String roleTypeId, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("roleTypeId", roleTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setRoleTypeId_GreaterThan(String roleTypeId) {
         setRoleTypeId_GreaterThan(roleTypeId, null);
     }
@@ -474,6 +544,28 @@ public abstract class BsFileConfigToRoleCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setRoleTypeId_Exists() {
+        setRoleTypeId_Exists(null);
+    }
+
+    public void setRoleTypeId_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("roleTypeId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRoleTypeId_CommonTerms(String roleTypeId) {
+        setRoleTypeId_CommonTerms(roleTypeId, null);
+    }
+
+    public void setRoleTypeId_CommonTerms(String roleTypeId, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("roleTypeId", roleTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsFileConfigToRoleCQ addOrderBy_RoleTypeId_Asc() {
         regOBA("roleTypeId");
         return this;

src/main/java/org/codelibs/fess/es/config/cbean/cq/bs/BsJobLogCQ.java

@@ -22,13 +22,17 @@ import org.codelibs.fess.es.config.allcommon.EsAbstractConditionQuery;
 import org.codelibs.fess.es.config.cbean.cq.JobLogCQ;
 import org.dbflute.cbean.ckey.ConditionKey;
 import org.elasticsearch.index.query.BoolQueryBuilder;
+import org.elasticsearch.index.query.CommonTermsQueryBuilder;
+import org.elasticsearch.index.query.ExistsQueryBuilder;
 import org.elasticsearch.index.query.FuzzyQueryBuilder;
 import org.elasticsearch.index.query.IdsQueryBuilder;
 import org.elasticsearch.index.query.MatchQueryBuilder;
 import org.elasticsearch.index.query.PrefixQueryBuilder;
 import org.elasticsearch.index.query.RangeQueryBuilder;
+import org.elasticsearch.index.query.RegexpQueryBuilder;
 import org.elasticsearch.index.query.TermQueryBuilder;
 import org.elasticsearch.index.query.TermsQueryBuilder;
+import org.elasticsearch.index.query.WildcardQueryBuilder;
 
 /**
  * @author ESFlute (using FreeGen)
@@ -300,6 +304,28 @@ public abstract class BsJobLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setEndTime_Exists() {
+        setEndTime_Exists(null);
+    }
+
+    public void setEndTime_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("endTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setEndTime_CommonTerms(Long endTime) {
+        setEndTime_CommonTerms(endTime, null);
+    }
+
+    public void setEndTime_CommonTerms(Long endTime, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("endTime", endTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsJobLogCQ addOrderBy_EndTime_Asc() {
         regOBA("endTime");
         return this;
@@ -419,6 +445,28 @@ public abstract class BsJobLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setJobName_Wildcard(String jobName) {
+        setJobName_Wildcard(jobName, null);
+    }
+
+    public void setJobName_Wildcard(String jobName, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("jobName", jobName);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setJobName_Regexp(String jobName) {
+        setJobName_Regexp(jobName, null);
+    }
+
+    public void setJobName_Regexp(String jobName, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("jobName", jobName);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setJobName_GreaterThan(String jobName) {
         setJobName_GreaterThan(jobName, null);
     }
@@ -463,6 +511,28 @@ public abstract class BsJobLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setJobName_Exists() {
+        setJobName_Exists(null);
+    }
+
+    public void setJobName_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("jobName");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setJobName_CommonTerms(String jobName) {
+        setJobName_CommonTerms(jobName, null);
+    }
+
+    public void setJobName_CommonTerms(String jobName, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("jobName", jobName);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsJobLogCQ addOrderBy_JobName_Asc() {
         regOBA("jobName");
         return this;
@@ -582,6 +652,28 @@ public abstract class BsJobLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setJobStatus_Wildcard(String jobStatus) {
+        setJobStatus_Wildcard(jobStatus, null);
+    }
+
+    public void setJobStatus_Wildcard(String jobStatus, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("jobStatus", jobStatus);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setJobStatus_Regexp(String jobStatus) {
+        setJobStatus_Regexp(jobStatus, null);
+    }
+
+    public void setJobStatus_Regexp(String jobStatus, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("jobStatus", jobStatus);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setJobStatus_GreaterThan(String jobStatus) {
         setJobStatus_GreaterThan(jobStatus, null);
     }
@@ -626,6 +718,28 @@ public abstract class BsJobLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setJobStatus_Exists() {
+        setJobStatus_Exists(null);
+    }
+
+    public void setJobStatus_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("jobStatus");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setJobStatus_CommonTerms(String jobStatus) {
+        setJobStatus_CommonTerms(jobStatus, null);
+    }
+
+    public void setJobStatus_CommonTerms(String jobStatus, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("jobStatus", jobStatus);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsJobLogCQ addOrderBy_JobStatus_Asc() {
         regOBA("jobStatus");
         return this;
@@ -745,6 +859,28 @@ public abstract class BsJobLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setScriptData_Wildcard(String scriptData) {
+        setScriptData_Wildcard(scriptData, null);
+    }
+
+    public void setScriptData_Wildcard(String scriptData, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("scriptData", scriptData);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setScriptData_Regexp(String scriptData) {
+        setScriptData_Regexp(scriptData, null);
+    }
+
+    public void setScriptData_Regexp(String scriptData, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("scriptData", scriptData);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setScriptData_GreaterThan(String scriptData) {
         setScriptData_GreaterThan(scriptData, null);
     }
@@ -789,6 +925,28 @@ public abstract class BsJobLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setScriptData_Exists() {
+        setScriptData_Exists(null);
+    }
+
+    public void setScriptData_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("scriptData");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setScriptData_CommonTerms(String scriptData) {
+        setScriptData_CommonTerms(scriptData, null);
+    }
+
+    public void setScriptData_CommonTerms(String scriptData, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("scriptData", scriptData);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsJobLogCQ addOrderBy_ScriptData_Asc() {
         regOBA("scriptData");
         return this;
@@ -908,6 +1066,28 @@ public abstract class BsJobLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setScriptResult_Wildcard(String scriptResult) {
+        setScriptResult_Wildcard(scriptResult, null);
+    }
+
+    public void setScriptResult_Wildcard(String scriptResult, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("scriptResult", scriptResult);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setScriptResult_Regexp(String scriptResult) {
+        setScriptResult_Regexp(scriptResult, null);
+    }
+
+    public void setScriptResult_Regexp(String scriptResult, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("scriptResult", scriptResult);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setScriptResult_GreaterThan(String scriptResult) {
         setScriptResult_GreaterThan(scriptResult, null);
     }
@@ -952,6 +1132,28 @@ public abstract class BsJobLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setScriptResult_Exists() {
+        setScriptResult_Exists(null);
+    }
+
+    public void setScriptResult_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("scriptResult");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setScriptResult_CommonTerms(String scriptResult) {
+        setScriptResult_CommonTerms(scriptResult, null);
+    }
+
+    public void setScriptResult_CommonTerms(String scriptResult, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("scriptResult", scriptResult);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsJobLogCQ addOrderBy_ScriptResult_Asc() {
         regOBA("scriptResult");
         return this;
@@ -1071,6 +1273,28 @@ public abstract class BsJobLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setScriptType_Wildcard(String scriptType) {
+        setScriptType_Wildcard(scriptType, null);
+    }
+
+    public void setScriptType_Wildcard(String scriptType, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("scriptType", scriptType);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setScriptType_Regexp(String scriptType) {
+        setScriptType_Regexp(scriptType, null);
+    }
+
+    public void setScriptType_Regexp(String scriptType, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("scriptType", scriptType);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setScriptType_GreaterThan(String scriptType) {
         setScriptType_GreaterThan(scriptType, null);
     }
@@ -1115,6 +1339,28 @@ public abstract class BsJobLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setScriptType_Exists() {
+        setScriptType_Exists(null);
+    }
+
+    public void setScriptType_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("scriptType");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setScriptType_CommonTerms(String scriptType) {
+        setScriptType_CommonTerms(scriptType, null);
+    }
+
+    public void setScriptType_CommonTerms(String scriptType, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("scriptType", scriptType);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsJobLogCQ addOrderBy_ScriptType_Asc() {
         regOBA("scriptType");
         return this;
@@ -1267,6 +1513,28 @@ public abstract class BsJobLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setStartTime_Exists() {
+        setStartTime_Exists(null);
+    }
+
+    public void setStartTime_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("startTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setStartTime_CommonTerms(Long startTime) {
+        setStartTime_CommonTerms(startTime, null);
+    }
+
+    public void setStartTime_CommonTerms(Long startTime, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("startTime", startTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsJobLogCQ addOrderBy_StartTime_Asc() {
         regOBA("startTime");
         return this;
@@ -1386,6 +1654,28 @@ public abstract class BsJobLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setTarget_Wildcard(String target) {
+        setTarget_Wildcard(target, null);
+    }
+
+    public void setTarget_Wildcard(String target, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("target", target);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTarget_Regexp(String target) {
+        setTarget_Regexp(target, null);
+    }
+
+    public void setTarget_Regexp(String target, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("target", target);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setTarget_GreaterThan(String target) {
         setTarget_GreaterThan(target, null);
     }
@@ -1430,6 +1720,28 @@ public abstract class BsJobLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setTarget_Exists() {
+        setTarget_Exists(null);
+    }
+
+    public void setTarget_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("target");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTarget_CommonTerms(String target) {
+        setTarget_CommonTerms(target, null);
+    }
+
+    public void setTarget_CommonTerms(String target, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("target", target);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsJobLogCQ addOrderBy_Target_Asc() {
         regOBA("target");
         return this;
@@ -1582,6 +1894,28 @@ public abstract class BsJobLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setLastUpdated_Exists() {
+        setLastUpdated_Exists(null);
+    }
+
+    public void setLastUpdated_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("lastUpdated");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setLastUpdated_CommonTerms(Long lastUpdated) {
+        setLastUpdated_CommonTerms(lastUpdated, null);
+    }
+
+    public void setLastUpdated_CommonTerms(Long lastUpdated, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("lastUpdated", lastUpdated);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsJobLogCQ addOrderBy_LastUpdated_Asc() {
         regOBA("lastUpdated");
         return this;

src/main/java/org/codelibs/fess/es/config/cbean/cq/bs/BsKeyMatchCQ.java

@@ -22,13 +22,17 @@ import org.codelibs.fess.es.config.allcommon.EsAbstractConditionQuery;
 import org.codelibs.fess.es.config.cbean.cq.KeyMatchCQ;
 import org.dbflute.cbean.ckey.ConditionKey;
 import org.elasticsearch.index.query.BoolQueryBuilder;
+import org.elasticsearch.index.query.CommonTermsQueryBuilder;
+import org.elasticsearch.index.query.ExistsQueryBuilder;
 import org.elasticsearch.index.query.FuzzyQueryBuilder;
 import org.elasticsearch.index.query.IdsQueryBuilder;
 import org.elasticsearch.index.query.MatchQueryBuilder;
 import org.elasticsearch.index.query.PrefixQueryBuilder;
 import org.elasticsearch.index.query.RangeQueryBuilder;
+import org.elasticsearch.index.query.RegexpQueryBuilder;
 import org.elasticsearch.index.query.TermQueryBuilder;
 import org.elasticsearch.index.query.TermsQueryBuilder;
+import org.elasticsearch.index.query.WildcardQueryBuilder;
 
 /**
  * @author ESFlute (using FreeGen)
@@ -300,6 +304,28 @@ public abstract class BsKeyMatchCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setBoost_Exists() {
+        setBoost_Exists(null);
+    }
+
+    public void setBoost_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("boost");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setBoost_CommonTerms(Float boost) {
+        setBoost_CommonTerms(boost, null);
+    }
+
+    public void setBoost_CommonTerms(Float boost, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("boost", boost);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsKeyMatchCQ addOrderBy_Boost_Asc() {
         regOBA("boost");
         return this;
@@ -419,6 +445,28 @@ public abstract class BsKeyMatchCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setCreatedBy_Wildcard(String createdBy) {
+        setCreatedBy_Wildcard(createdBy, null);
+    }
+
+    public void setCreatedBy_Wildcard(String createdBy, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Regexp(String createdBy) {
+        setCreatedBy_Regexp(createdBy, null);
+    }
+
+    public void setCreatedBy_Regexp(String createdBy, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setCreatedBy_GreaterThan(String createdBy) {
         setCreatedBy_GreaterThan(createdBy, null);
     }
@@ -463,6 +511,28 @@ public abstract class BsKeyMatchCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setCreatedBy_Exists() {
+        setCreatedBy_Exists(null);
+    }
+
+    public void setCreatedBy_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("createdBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_CommonTerms(String createdBy) {
+        setCreatedBy_CommonTerms(createdBy, null);
+    }
+
+    public void setCreatedBy_CommonTerms(String createdBy, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsKeyMatchCQ addOrderBy_CreatedBy_Asc() {
         regOBA("createdBy");
         return this;
@@ -615,6 +685,28 @@ public abstract class BsKeyMatchCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setCreatedTime_Exists() {
+        setCreatedTime_Exists(null);
+    }
+
+    public void setCreatedTime_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("createdTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_CommonTerms(Long createdTime) {
+        setCreatedTime_CommonTerms(createdTime, null);
+    }
+
+    public void setCreatedTime_CommonTerms(Long createdTime, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("createdTime", createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsKeyMatchCQ addOrderBy_CreatedTime_Asc() {
         regOBA("createdTime");
         return this;
@@ -767,6 +859,28 @@ public abstract class BsKeyMatchCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setMaxSize_Exists() {
+        setMaxSize_Exists(null);
+    }
+
+    public void setMaxSize_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("maxSize");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setMaxSize_CommonTerms(Integer maxSize) {
+        setMaxSize_CommonTerms(maxSize, null);
+    }
+
+    public void setMaxSize_CommonTerms(Integer maxSize, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("maxSize", maxSize);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsKeyMatchCQ addOrderBy_MaxSize_Asc() {
         regOBA("maxSize");
         return this;
@@ -886,6 +1000,28 @@ public abstract class BsKeyMatchCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setQuery_Wildcard(String query) {
+        setQuery_Wildcard(query, null);
+    }
+
+    public void setQuery_Wildcard(String query, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("query", query);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setQuery_Regexp(String query) {
+        setQuery_Regexp(query, null);
+    }
+
+    public void setQuery_Regexp(String query, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("query", query);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setQuery_GreaterThan(String query) {
         setQuery_GreaterThan(query, null);
     }
@@ -930,6 +1066,28 @@ public abstract class BsKeyMatchCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setQuery_Exists() {
+        setQuery_Exists(null);
+    }
+
+    public void setQuery_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("query");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setQuery_CommonTerms(String query) {
+        setQuery_CommonTerms(query, null);
+    }
+
+    public void setQuery_CommonTerms(String query, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("query", query);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsKeyMatchCQ addOrderBy_Query_Asc() {
         regOBA("query");
         return this;
@@ -1049,6 +1207,28 @@ public abstract class BsKeyMatchCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setTerm_Wildcard(String term) {
+        setTerm_Wildcard(term, null);
+    }
+
+    public void setTerm_Wildcard(String term, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("term", term);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTerm_Regexp(String term) {
+        setTerm_Regexp(term, null);
+    }
+
+    public void setTerm_Regexp(String term, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("term", term);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setTerm_GreaterThan(String term) {
         setTerm_GreaterThan(term, null);
     }
@@ -1093,6 +1273,28 @@ public abstract class BsKeyMatchCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setTerm_Exists() {
+        setTerm_Exists(null);
+    }
+
+    public void setTerm_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("term");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTerm_CommonTerms(String term) {
+        setTerm_CommonTerms(term, null);
+    }
+
+    public void setTerm_CommonTerms(String term, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("term", term);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsKeyMatchCQ addOrderBy_Term_Asc() {
         regOBA("term");
         return this;
@@ -1212,6 +1414,28 @@ public abstract class BsKeyMatchCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUpdatedBy_Wildcard(String updatedBy) {
+        setUpdatedBy_Wildcard(updatedBy, null);
+    }
+
+    public void setUpdatedBy_Wildcard(String updatedBy, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Regexp(String updatedBy) {
+        setUpdatedBy_Regexp(updatedBy, null);
+    }
+
+    public void setUpdatedBy_Regexp(String updatedBy, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setUpdatedBy_GreaterThan(String updatedBy) {
         setUpdatedBy_GreaterThan(updatedBy, null);
     }
@@ -1256,6 +1480,28 @@ public abstract class BsKeyMatchCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUpdatedBy_Exists() {
+        setUpdatedBy_Exists(null);
+    }
+
+    public void setUpdatedBy_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("updatedBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_CommonTerms(String updatedBy) {
+        setUpdatedBy_CommonTerms(updatedBy, null);
+    }
+
+    public void setUpdatedBy_CommonTerms(String updatedBy, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsKeyMatchCQ addOrderBy_UpdatedBy_Asc() {
         regOBA("updatedBy");
         return this;
@@ -1408,6 +1654,28 @@ public abstract class BsKeyMatchCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUpdatedTime_Exists() {
+        setUpdatedTime_Exists(null);
+    }
+
+    public void setUpdatedTime_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("updatedTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_CommonTerms(Long updatedTime) {
+        setUpdatedTime_CommonTerms(updatedTime, null);
+    }
+
+    public void setUpdatedTime_CommonTerms(Long updatedTime, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("updatedTime", updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsKeyMatchCQ addOrderBy_UpdatedTime_Asc() {
         regOBA("updatedTime");
         return this;

src/main/java/org/codelibs/fess/es/config/cbean/cq/bs/BsLabelToRoleCQ.java

@@ -22,13 +22,17 @@ import org.codelibs.fess.es.config.allcommon.EsAbstractConditionQuery;
 import org.codelibs.fess.es.config.cbean.cq.LabelToRoleCQ;
 import org.dbflute.cbean.ckey.ConditionKey;
 import org.elasticsearch.index.query.BoolQueryBuilder;
+import org.elasticsearch.index.query.CommonTermsQueryBuilder;
+import org.elasticsearch.index.query.ExistsQueryBuilder;
 import org.elasticsearch.index.query.FuzzyQueryBuilder;
 import org.elasticsearch.index.query.IdsQueryBuilder;
 import org.elasticsearch.index.query.MatchQueryBuilder;
 import org.elasticsearch.index.query.PrefixQueryBuilder;
 import org.elasticsearch.index.query.RangeQueryBuilder;
+import org.elasticsearch.index.query.RegexpQueryBuilder;
 import org.elasticsearch.index.query.TermQueryBuilder;
 import org.elasticsearch.index.query.TermsQueryBuilder;
+import org.elasticsearch.index.query.WildcardQueryBuilder;
 
 /**
  * @author ESFlute (using FreeGen)
@@ -267,6 +271,28 @@ public abstract class BsLabelToRoleCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setLabelTypeId_Wildcard(String labelTypeId) {
+        setLabelTypeId_Wildcard(labelTypeId, null);
+    }
+
+    public void setLabelTypeId_Wildcard(String labelTypeId, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("labelTypeId", labelTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setLabelTypeId_Regexp(String labelTypeId) {
+        setLabelTypeId_Regexp(labelTypeId, null);
+    }
+
+    public void setLabelTypeId_Regexp(String labelTypeId, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("labelTypeId", labelTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setLabelTypeId_GreaterThan(String labelTypeId) {
         setLabelTypeId_GreaterThan(labelTypeId, null);
     }
@@ -311,6 +337,28 @@ public abstract class BsLabelToRoleCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setLabelTypeId_Exists() {
+        setLabelTypeId_Exists(null);
+    }
+
+    public void setLabelTypeId_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("labelTypeId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setLabelTypeId_CommonTerms(String labelTypeId) {
+        setLabelTypeId_CommonTerms(labelTypeId, null);
+    }
+
+    public void setLabelTypeId_CommonTerms(String labelTypeId, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("labelTypeId", labelTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsLabelToRoleCQ addOrderBy_LabelTypeId_Asc() {
         regOBA("labelTypeId");
         return this;
@@ -430,6 +478,28 @@ public abstract class BsLabelToRoleCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setRoleTypeId_Wildcard(String roleTypeId) {
+        setRoleTypeId_Wildcard(roleTypeId, null);
+    }
+
+    public void setRoleTypeId_Wildcard(String roleTypeId, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("roleTypeId", roleTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRoleTypeId_Regexp(String roleTypeId) {
+        setRoleTypeId_Regexp(roleTypeId, null);
+    }
+
+    public void setRoleTypeId_Regexp(String roleTypeId, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("roleTypeId", roleTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setRoleTypeId_GreaterThan(String roleTypeId) {
         setRoleTypeId_GreaterThan(roleTypeId, null);
     }
@@ -474,6 +544,28 @@ public abstract class BsLabelToRoleCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setRoleTypeId_Exists() {
+        setRoleTypeId_Exists(null);
+    }
+
+    public void setRoleTypeId_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("roleTypeId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRoleTypeId_CommonTerms(String roleTypeId) {
+        setRoleTypeId_CommonTerms(roleTypeId, null);
+    }
+
+    public void setRoleTypeId_CommonTerms(String roleTypeId, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("roleTypeId", roleTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsLabelToRoleCQ addOrderBy_RoleTypeId_Asc() {
         regOBA("roleTypeId");
         return this;

src/main/java/org/codelibs/fess/es/config/cbean/cq/bs/BsLabelTypeCQ.java

@@ -22,13 +22,17 @@ import org.codelibs.fess.es.config.allcommon.EsAbstractConditionQuery;
 import org.codelibs.fess.es.config.cbean.cq.LabelTypeCQ;
 import org.dbflute.cbean.ckey.ConditionKey;
 import org.elasticsearch.index.query.BoolQueryBuilder;
+import org.elasticsearch.index.query.CommonTermsQueryBuilder;
+import org.elasticsearch.index.query.ExistsQueryBuilder;
 import org.elasticsearch.index.query.FuzzyQueryBuilder;
 import org.elasticsearch.index.query.IdsQueryBuilder;
 import org.elasticsearch.index.query.MatchQueryBuilder;
 import org.elasticsearch.index.query.PrefixQueryBuilder;
 import org.elasticsearch.index.query.RangeQueryBuilder;
+import org.elasticsearch.index.query.RegexpQueryBuilder;
 import org.elasticsearch.index.query.TermQueryBuilder;
 import org.elasticsearch.index.query.TermsQueryBuilder;
+import org.elasticsearch.index.query.WildcardQueryBuilder;
 
 /**
  * @author ESFlute (using FreeGen)
@@ -267,6 +271,28 @@ public abstract class BsLabelTypeCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setCreatedBy_Wildcard(String createdBy) {
+        setCreatedBy_Wildcard(createdBy, null);
+    }
+
+    public void setCreatedBy_Wildcard(String createdBy, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Regexp(String createdBy) {
+        setCreatedBy_Regexp(createdBy, null);
+    }
+
+    public void setCreatedBy_Regexp(String createdBy, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setCreatedBy_GreaterThan(String createdBy) {
         setCreatedBy_GreaterThan(createdBy, null);
     }
@@ -311,6 +337,28 @@ public abstract class BsLabelTypeCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setCreatedBy_Exists() {
+        setCreatedBy_Exists(null);
+    }
+
+    public void setCreatedBy_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("createdBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_CommonTerms(String createdBy) {
+        setCreatedBy_CommonTerms(createdBy, null);
+    }
+
+    public void setCreatedBy_CommonTerms(String createdBy, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsLabelTypeCQ addOrderBy_CreatedBy_Asc() {
         regOBA("createdBy");
         return this;
@@ -463,6 +511,28 @@ public abstract class BsLabelTypeCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setCreatedTime_Exists() {
+        setCreatedTime_Exists(null);
+    }
+
+    public void setCreatedTime_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("createdTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_CommonTerms(Long createdTime) {
+        setCreatedTime_CommonTerms(createdTime, null);
+    }
+
+    public void setCreatedTime_CommonTerms(Long createdTime, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("createdTime", createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsLabelTypeCQ addOrderBy_CreatedTime_Asc() {
         regOBA("createdTime");
         return this;
@@ -582,6 +652,28 @@ public abstract class BsLabelTypeCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setExcludedPaths_Wildcard(String excludedPaths) {
+        setExcludedPaths_Wildcard(excludedPaths, null);
+    }
+
+    public void setExcludedPaths_Wildcard(String excludedPaths, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("excludedPaths", excludedPaths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExcludedPaths_Regexp(String excludedPaths) {
+        setExcludedPaths_Regexp(excludedPaths, null);
+    }
+
+    public void setExcludedPaths_Regexp(String excludedPaths, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("excludedPaths", excludedPaths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setExcludedPaths_GreaterThan(String excludedPaths) {
         setExcludedPaths_GreaterThan(excludedPaths, null);
     }
@@ -626,6 +718,28 @@ public abstract class BsLabelTypeCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setExcludedPaths_Exists() {
+        setExcludedPaths_Exists(null);
+    }
+
+    public void setExcludedPaths_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("excludedPaths");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExcludedPaths_CommonTerms(String excludedPaths) {
+        setExcludedPaths_CommonTerms(excludedPaths, null);
+    }
+
+    public void setExcludedPaths_CommonTerms(String excludedPaths, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("excludedPaths", excludedPaths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsLabelTypeCQ addOrderBy_ExcludedPaths_Asc() {
         regOBA("excludedPaths");
         return this;
@@ -745,6 +859,28 @@ public abstract class BsLabelTypeCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setIncludedPaths_Wildcard(String includedPaths) {
+        setIncludedPaths_Wildcard(includedPaths, null);
+    }
+
+    public void setIncludedPaths_Wildcard(String includedPaths, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("includedPaths", includedPaths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIncludedPaths_Regexp(String includedPaths) {
+        setIncludedPaths_Regexp(includedPaths, null);
+    }
+
+    public void setIncludedPaths_Regexp(String includedPaths, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("includedPaths", includedPaths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setIncludedPaths_GreaterThan(String includedPaths) {
         setIncludedPaths_GreaterThan(includedPaths, null);
     }
@@ -789,6 +925,28 @@ public abstract class BsLabelTypeCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setIncludedPaths_Exists() {
+        setIncludedPaths_Exists(null);
+    }
+
+    public void setIncludedPaths_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("includedPaths");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIncludedPaths_CommonTerms(String includedPaths) {
+        setIncludedPaths_CommonTerms(includedPaths, null);
+    }
+
+    public void setIncludedPaths_CommonTerms(String includedPaths, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("includedPaths", includedPaths);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsLabelTypeCQ addOrderBy_IncludedPaths_Asc() {
         regOBA("includedPaths");
         return this;
@@ -908,6 +1066,28 @@ public abstract class BsLabelTypeCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setName_Wildcard(String name) {
+        setName_Wildcard(name, null);
+    }
+
+    public void setName_Wildcard(String name, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("name", name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_Regexp(String name) {
+        setName_Regexp(name, null);
+    }
+
+    public void setName_Regexp(String name, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("name", name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setName_GreaterThan(String name) {
         setName_GreaterThan(name, null);
     }
@@ -952,6 +1132,28 @@ public abstract class BsLabelTypeCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setName_Exists() {
+        setName_Exists(null);
+    }
+
+    public void setName_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("name");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_CommonTerms(String name) {
+        setName_CommonTerms(name, null);
+    }
+
+    public void setName_CommonTerms(String name, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("name", name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsLabelTypeCQ addOrderBy_Name_Asc() {
         regOBA("name");
         return this;
@@ -1071,6 +1273,28 @@ public abstract class BsLabelTypeCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setPermissions_Wildcard(String permissions) {
+        setPermissions_Wildcard(permissions, null);
+    }
+
+    public void setPermissions_Wildcard(String permissions, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("permissions", permissions);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setPermissions_Regexp(String permissions) {
+        setPermissions_Regexp(permissions, null);
+    }
+
+    public void setPermissions_Regexp(String permissions, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("permissions", permissions);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setPermissions_GreaterThan(String permissions) {
         setPermissions_GreaterThan(permissions, null);
     }
@@ -1115,6 +1339,28 @@ public abstract class BsLabelTypeCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setPermissions_Exists() {
+        setPermissions_Exists(null);
+    }
+
+    public void setPermissions_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("permissions");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setPermissions_CommonTerms(String permissions) {
+        setPermissions_CommonTerms(permissions, null);
+    }
+
+    public void setPermissions_CommonTerms(String permissions, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("permissions", permissions);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsLabelTypeCQ addOrderBy_Permissions_Asc() {
         regOBA("permissions");
         return this;
@@ -1267,6 +1513,28 @@ public abstract class BsLabelTypeCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setSortOrder_Exists() {
+        setSortOrder_Exists(null);
+    }
+
+    public void setSortOrder_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("sortOrder");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_CommonTerms(Integer sortOrder) {
+        setSortOrder_CommonTerms(sortOrder, null);
+    }
+
+    public void setSortOrder_CommonTerms(Integer sortOrder, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("sortOrder", sortOrder);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsLabelTypeCQ addOrderBy_SortOrder_Asc() {
         regOBA("sortOrder");
         return this;
@@ -1386,6 +1654,28 @@ public abstract class BsLabelTypeCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUpdatedBy_Wildcard(String updatedBy) {
+        setUpdatedBy_Wildcard(updatedBy, null);
+    }
+
+    public void setUpdatedBy_Wildcard(String updatedBy, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Regexp(String updatedBy) {
+        setUpdatedBy_Regexp(updatedBy, null);
+    }
+
+    public void setUpdatedBy_Regexp(String updatedBy, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setUpdatedBy_GreaterThan(String updatedBy) {
         setUpdatedBy_GreaterThan(updatedBy, null);
     }
@@ -1430,6 +1720,28 @@ public abstract class BsLabelTypeCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUpdatedBy_Exists() {
+        setUpdatedBy_Exists(null);
+    }
+
+    public void setUpdatedBy_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("updatedBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_CommonTerms(String updatedBy) {
+        setUpdatedBy_CommonTerms(updatedBy, null);
+    }
+
+    public void setUpdatedBy_CommonTerms(String updatedBy, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsLabelTypeCQ addOrderBy_UpdatedBy_Asc() {
         regOBA("updatedBy");
         return this;
@@ -1582,6 +1894,28 @@ public abstract class BsLabelTypeCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUpdatedTime_Exists() {
+        setUpdatedTime_Exists(null);
+    }
+
+    public void setUpdatedTime_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("updatedTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_CommonTerms(Long updatedTime) {
+        setUpdatedTime_CommonTerms(updatedTime, null);
+    }
+
+    public void setUpdatedTime_CommonTerms(Long updatedTime, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("updatedTime", updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsLabelTypeCQ addOrderBy_UpdatedTime_Asc() {
         regOBA("updatedTime");
         return this;
@@ -1701,6 +2035,28 @@ public abstract class BsLabelTypeCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setValue_Wildcard(String value) {
+        setValue_Wildcard(value, null);
+    }
+
+    public void setValue_Wildcard(String value, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("value", value);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setValue_Regexp(String value) {
+        setValue_Regexp(value, null);
+    }
+
+    public void setValue_Regexp(String value, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("value", value);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setValue_GreaterThan(String value) {
         setValue_GreaterThan(value, null);
     }
@@ -1745,6 +2101,28 @@ public abstract class BsLabelTypeCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setValue_Exists() {
+        setValue_Exists(null);
+    }
+
+    public void setValue_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("value");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setValue_CommonTerms(String value) {
+        setValue_CommonTerms(value, null);
+    }
+
+    public void setValue_CommonTerms(String value, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("value", value);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsLabelTypeCQ addOrderBy_Value_Asc() {
         regOBA("value");
         return this;

src/main/java/org/codelibs/fess/es/config/cbean/cq/bs/BsPathMappingCQ.java

@@ -22,13 +22,17 @@ import org.codelibs.fess.es.config.allcommon.EsAbstractConditionQuery;
 import org.codelibs.fess.es.config.cbean.cq.PathMappingCQ;
 import org.dbflute.cbean.ckey.ConditionKey;
 import org.elasticsearch.index.query.BoolQueryBuilder;
+import org.elasticsearch.index.query.CommonTermsQueryBuilder;
+import org.elasticsearch.index.query.ExistsQueryBuilder;
 import org.elasticsearch.index.query.FuzzyQueryBuilder;
 import org.elasticsearch.index.query.IdsQueryBuilder;
 import org.elasticsearch.index.query.MatchQueryBuilder;
 import org.elasticsearch.index.query.PrefixQueryBuilder;
 import org.elasticsearch.index.query.RangeQueryBuilder;
+import org.elasticsearch.index.query.RegexpQueryBuilder;
 import org.elasticsearch.index.query.TermQueryBuilder;
 import org.elasticsearch.index.query.TermsQueryBuilder;
+import org.elasticsearch.index.query.WildcardQueryBuilder;
 
 /**
  * @author ESFlute (using FreeGen)
@@ -267,6 +271,28 @@ public abstract class BsPathMappingCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setCreatedBy_Wildcard(String createdBy) {
+        setCreatedBy_Wildcard(createdBy, null);
+    }
+
+    public void setCreatedBy_Wildcard(String createdBy, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Regexp(String createdBy) {
+        setCreatedBy_Regexp(createdBy, null);
+    }
+
+    public void setCreatedBy_Regexp(String createdBy, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setCreatedBy_GreaterThan(String createdBy) {
         setCreatedBy_GreaterThan(createdBy, null);
     }
@@ -311,6 +337,28 @@ public abstract class BsPathMappingCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setCreatedBy_Exists() {
+        setCreatedBy_Exists(null);
+    }
+
+    public void setCreatedBy_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("createdBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_CommonTerms(String createdBy) {
+        setCreatedBy_CommonTerms(createdBy, null);
+    }
+
+    public void setCreatedBy_CommonTerms(String createdBy, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsPathMappingCQ addOrderBy_CreatedBy_Asc() {
         regOBA("createdBy");
         return this;
@@ -463,6 +511,28 @@ public abstract class BsPathMappingCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setCreatedTime_Exists() {
+        setCreatedTime_Exists(null);
+    }
+
+    public void setCreatedTime_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("createdTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_CommonTerms(Long createdTime) {
+        setCreatedTime_CommonTerms(createdTime, null);
+    }
+
+    public void setCreatedTime_CommonTerms(Long createdTime, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("createdTime", createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsPathMappingCQ addOrderBy_CreatedTime_Asc() {
         regOBA("createdTime");
         return this;
@@ -582,6 +652,28 @@ public abstract class BsPathMappingCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setProcessType_Wildcard(String processType) {
+        setProcessType_Wildcard(processType, null);
+    }
+
+    public void setProcessType_Wildcard(String processType, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("processType", processType);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setProcessType_Regexp(String processType) {
+        setProcessType_Regexp(processType, null);
+    }
+
+    public void setProcessType_Regexp(String processType, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("processType", processType);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setProcessType_GreaterThan(String processType) {
         setProcessType_GreaterThan(processType, null);
     }
@@ -626,6 +718,28 @@ public abstract class BsPathMappingCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setProcessType_Exists() {
+        setProcessType_Exists(null);
+    }
+
+    public void setProcessType_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("processType");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setProcessType_CommonTerms(String processType) {
+        setProcessType_CommonTerms(processType, null);
+    }
+
+    public void setProcessType_CommonTerms(String processType, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("processType", processType);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsPathMappingCQ addOrderBy_ProcessType_Asc() {
         regOBA("processType");
         return this;
@@ -745,6 +859,28 @@ public abstract class BsPathMappingCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setRegex_Wildcard(String regex) {
+        setRegex_Wildcard(regex, null);
+    }
+
+    public void setRegex_Wildcard(String regex, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("regex", regex);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRegex_Regexp(String regex) {
+        setRegex_Regexp(regex, null);
+    }
+
+    public void setRegex_Regexp(String regex, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("regex", regex);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setRegex_GreaterThan(String regex) {
         setRegex_GreaterThan(regex, null);
     }
@@ -789,6 +925,28 @@ public abstract class BsPathMappingCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setRegex_Exists() {
+        setRegex_Exists(null);
+    }
+
+    public void setRegex_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("regex");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRegex_CommonTerms(String regex) {
+        setRegex_CommonTerms(regex, null);
+    }
+
+    public void setRegex_CommonTerms(String regex, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("regex", regex);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsPathMappingCQ addOrderBy_Regex_Asc() {
         regOBA("regex");
         return this;
@@ -908,6 +1066,28 @@ public abstract class BsPathMappingCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setReplacement_Wildcard(String replacement) {
+        setReplacement_Wildcard(replacement, null);
+    }
+
+    public void setReplacement_Wildcard(String replacement, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("replacement", replacement);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setReplacement_Regexp(String replacement) {
+        setReplacement_Regexp(replacement, null);
+    }
+
+    public void setReplacement_Regexp(String replacement, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("replacement", replacement);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setReplacement_GreaterThan(String replacement) {
         setReplacement_GreaterThan(replacement, null);
     }
@@ -952,6 +1132,28 @@ public abstract class BsPathMappingCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setReplacement_Exists() {
+        setReplacement_Exists(null);
+    }
+
+    public void setReplacement_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("replacement");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setReplacement_CommonTerms(String replacement) {
+        setReplacement_CommonTerms(replacement, null);
+    }
+
+    public void setReplacement_CommonTerms(String replacement, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("replacement", replacement);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsPathMappingCQ addOrderBy_Replacement_Asc() {
         regOBA("replacement");
         return this;
@@ -1104,6 +1306,28 @@ public abstract class BsPathMappingCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setSortOrder_Exists() {
+        setSortOrder_Exists(null);
+    }
+
+    public void setSortOrder_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("sortOrder");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_CommonTerms(Integer sortOrder) {
+        setSortOrder_CommonTerms(sortOrder, null);
+    }
+
+    public void setSortOrder_CommonTerms(Integer sortOrder, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("sortOrder", sortOrder);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsPathMappingCQ addOrderBy_SortOrder_Asc() {
         regOBA("sortOrder");
         return this;
@@ -1223,6 +1447,28 @@ public abstract class BsPathMappingCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUserAgent_Wildcard(String userAgent) {
+        setUserAgent_Wildcard(userAgent, null);
+    }
+
+    public void setUserAgent_Wildcard(String userAgent, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("userAgent", userAgent);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUserAgent_Regexp(String userAgent) {
+        setUserAgent_Regexp(userAgent, null);
+    }
+
+    public void setUserAgent_Regexp(String userAgent, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("userAgent", userAgent);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setUserAgent_GreaterThan(String userAgent) {
         setUserAgent_GreaterThan(userAgent, null);
     }
@@ -1267,6 +1513,28 @@ public abstract class BsPathMappingCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUserAgent_Exists() {
+        setUserAgent_Exists(null);
+    }
+
+    public void setUserAgent_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("userAgent");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUserAgent_CommonTerms(String userAgent) {
+        setUserAgent_CommonTerms(userAgent, null);
+    }
+
+    public void setUserAgent_CommonTerms(String userAgent, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("userAgent", userAgent);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsPathMappingCQ addOrderBy_UserAgent_Asc() {
         regOBA("userAgent");
         return this;
@@ -1386,6 +1654,28 @@ public abstract class BsPathMappingCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUpdatedBy_Wildcard(String updatedBy) {
+        setUpdatedBy_Wildcard(updatedBy, null);
+    }
+
+    public void setUpdatedBy_Wildcard(String updatedBy, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Regexp(String updatedBy) {
+        setUpdatedBy_Regexp(updatedBy, null);
+    }
+
+    public void setUpdatedBy_Regexp(String updatedBy, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setUpdatedBy_GreaterThan(String updatedBy) {
         setUpdatedBy_GreaterThan(updatedBy, null);
     }
@@ -1430,6 +1720,28 @@ public abstract class BsPathMappingCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUpdatedBy_Exists() {
+        setUpdatedBy_Exists(null);
+    }
+
+    public void setUpdatedBy_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("updatedBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_CommonTerms(String updatedBy) {
+        setUpdatedBy_CommonTerms(updatedBy, null);
+    }
+
+    public void setUpdatedBy_CommonTerms(String updatedBy, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsPathMappingCQ addOrderBy_UpdatedBy_Asc() {
         regOBA("updatedBy");
         return this;
@@ -1582,6 +1894,28 @@ public abstract class BsPathMappingCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUpdatedTime_Exists() {
+        setUpdatedTime_Exists(null);
+    }
+
+    public void setUpdatedTime_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("updatedTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_CommonTerms(Long updatedTime) {
+        setUpdatedTime_CommonTerms(updatedTime, null);
+    }
+
+    public void setUpdatedTime_CommonTerms(Long updatedTime, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("updatedTime", updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsPathMappingCQ addOrderBy_UpdatedTime_Asc() {
         regOBA("updatedTime");
         return this;

src/main/java/org/codelibs/fess/es/config/cbean/cq/bs/BsRequestHeaderCQ.java

@@ -22,13 +22,17 @@ import org.codelibs.fess.es.config.allcommon.EsAbstractConditionQuery;
 import org.codelibs.fess.es.config.cbean.cq.RequestHeaderCQ;
 import org.dbflute.cbean.ckey.ConditionKey;
 import org.elasticsearch.index.query.BoolQueryBuilder;
+import org.elasticsearch.index.query.CommonTermsQueryBuilder;
+import org.elasticsearch.index.query.ExistsQueryBuilder;
 import org.elasticsearch.index.query.FuzzyQueryBuilder;
 import org.elasticsearch.index.query.IdsQueryBuilder;
 import org.elasticsearch.index.query.MatchQueryBuilder;
 import org.elasticsearch.index.query.PrefixQueryBuilder;
 import org.elasticsearch.index.query.RangeQueryBuilder;
+import org.elasticsearch.index.query.RegexpQueryBuilder;
 import org.elasticsearch.index.query.TermQueryBuilder;
 import org.elasticsearch.index.query.TermsQueryBuilder;
+import org.elasticsearch.index.query.WildcardQueryBuilder;
 
 /**
  * @author ESFlute (using FreeGen)
@@ -267,6 +271,28 @@ public abstract class BsRequestHeaderCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setCreatedBy_Wildcard(String createdBy) {
+        setCreatedBy_Wildcard(createdBy, null);
+    }
+
+    public void setCreatedBy_Wildcard(String createdBy, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Regexp(String createdBy) {
+        setCreatedBy_Regexp(createdBy, null);
+    }
+
+    public void setCreatedBy_Regexp(String createdBy, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setCreatedBy_GreaterThan(String createdBy) {
         setCreatedBy_GreaterThan(createdBy, null);
     }
@@ -311,6 +337,28 @@ public abstract class BsRequestHeaderCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setCreatedBy_Exists() {
+        setCreatedBy_Exists(null);
+    }
+
+    public void setCreatedBy_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("createdBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_CommonTerms(String createdBy) {
+        setCreatedBy_CommonTerms(createdBy, null);
+    }
+
+    public void setCreatedBy_CommonTerms(String createdBy, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsRequestHeaderCQ addOrderBy_CreatedBy_Asc() {
         regOBA("createdBy");
         return this;
@@ -463,6 +511,28 @@ public abstract class BsRequestHeaderCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setCreatedTime_Exists() {
+        setCreatedTime_Exists(null);
+    }
+
+    public void setCreatedTime_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("createdTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_CommonTerms(Long createdTime) {
+        setCreatedTime_CommonTerms(createdTime, null);
+    }
+
+    public void setCreatedTime_CommonTerms(Long createdTime, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("createdTime", createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsRequestHeaderCQ addOrderBy_CreatedTime_Asc() {
         regOBA("createdTime");
         return this;
@@ -582,6 +652,28 @@ public abstract class BsRequestHeaderCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setName_Wildcard(String name) {
+        setName_Wildcard(name, null);
+    }
+
+    public void setName_Wildcard(String name, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("name", name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_Regexp(String name) {
+        setName_Regexp(name, null);
+    }
+
+    public void setName_Regexp(String name, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("name", name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setName_GreaterThan(String name) {
         setName_GreaterThan(name, null);
     }
@@ -626,6 +718,28 @@ public abstract class BsRequestHeaderCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setName_Exists() {
+        setName_Exists(null);
+    }
+
+    public void setName_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("name");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_CommonTerms(String name) {
+        setName_CommonTerms(name, null);
+    }
+
+    public void setName_CommonTerms(String name, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("name", name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsRequestHeaderCQ addOrderBy_Name_Asc() {
         regOBA("name");
         return this;
@@ -745,6 +859,28 @@ public abstract class BsRequestHeaderCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUpdatedBy_Wildcard(String updatedBy) {
+        setUpdatedBy_Wildcard(updatedBy, null);
+    }
+
+    public void setUpdatedBy_Wildcard(String updatedBy, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Regexp(String updatedBy) {
+        setUpdatedBy_Regexp(updatedBy, null);
+    }
+
+    public void setUpdatedBy_Regexp(String updatedBy, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setUpdatedBy_GreaterThan(String updatedBy) {
         setUpdatedBy_GreaterThan(updatedBy, null);
     }
@@ -789,6 +925,28 @@ public abstract class BsRequestHeaderCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUpdatedBy_Exists() {
+        setUpdatedBy_Exists(null);
+    }
+
+    public void setUpdatedBy_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("updatedBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_CommonTerms(String updatedBy) {
+        setUpdatedBy_CommonTerms(updatedBy, null);
+    }
+
+    public void setUpdatedBy_CommonTerms(String updatedBy, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsRequestHeaderCQ addOrderBy_UpdatedBy_Asc() {
         regOBA("updatedBy");
         return this;
@@ -941,6 +1099,28 @@ public abstract class BsRequestHeaderCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUpdatedTime_Exists() {
+        setUpdatedTime_Exists(null);
+    }
+
+    public void setUpdatedTime_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("updatedTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_CommonTerms(Long updatedTime) {
+        setUpdatedTime_CommonTerms(updatedTime, null);
+    }
+
+    public void setUpdatedTime_CommonTerms(Long updatedTime, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("updatedTime", updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsRequestHeaderCQ addOrderBy_UpdatedTime_Asc() {
         regOBA("updatedTime");
         return this;
@@ -1060,6 +1240,28 @@ public abstract class BsRequestHeaderCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setValue_Wildcard(String value) {
+        setValue_Wildcard(value, null);
+    }
+
+    public void setValue_Wildcard(String value, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("value", value);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setValue_Regexp(String value) {
+        setValue_Regexp(value, null);
+    }
+
+    public void setValue_Regexp(String value, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("value", value);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setValue_GreaterThan(String value) {
         setValue_GreaterThan(value, null);
     }
@@ -1104,6 +1306,28 @@ public abstract class BsRequestHeaderCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setValue_Exists() {
+        setValue_Exists(null);
+    }
+
+    public void setValue_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("value");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setValue_CommonTerms(String value) {
+        setValue_CommonTerms(value, null);
+    }
+
+    public void setValue_CommonTerms(String value, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("value", value);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsRequestHeaderCQ addOrderBy_Value_Asc() {
         regOBA("value");
         return this;
@@ -1223,6 +1447,28 @@ public abstract class BsRequestHeaderCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setWebConfigId_Wildcard(String webConfigId) {
+        setWebConfigId_Wildcard(webConfigId, null);
+    }
+
+    public void setWebConfigId_Wildcard(String webConfigId, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("webConfigId", webConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setWebConfigId_Regexp(String webConfigId) {
+        setWebConfigId_Regexp(webConfigId, null);
+    }
+
+    public void setWebConfigId_Regexp(String webConfigId, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("webConfigId", webConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setWebConfigId_GreaterThan(String webConfigId) {
         setWebConfigId_GreaterThan(webConfigId, null);
     }
@@ -1267,6 +1513,28 @@ public abstract class BsRequestHeaderCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setWebConfigId_Exists() {
+        setWebConfigId_Exists(null);
+    }
+
+    public void setWebConfigId_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("webConfigId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setWebConfigId_CommonTerms(String webConfigId) {
+        setWebConfigId_CommonTerms(webConfigId, null);
+    }
+
+    public void setWebConfigId_CommonTerms(String webConfigId, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("webConfigId", webConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsRequestHeaderCQ addOrderBy_WebConfigId_Asc() {
         regOBA("webConfigId");
         return this;

src/main/java/org/codelibs/fess/es/config/cbean/cq/bs/BsRoleTypeCQ.java

@@ -22,13 +22,17 @@ import org.codelibs.fess.es.config.allcommon.EsAbstractConditionQuery;
 import org.codelibs.fess.es.config.cbean.cq.RoleTypeCQ;
 import org.dbflute.cbean.ckey.ConditionKey;
 import org.elasticsearch.index.query.BoolQueryBuilder;
+import org.elasticsearch.index.query.CommonTermsQueryBuilder;
+import org.elasticsearch.index.query.ExistsQueryBuilder;
 import org.elasticsearch.index.query.FuzzyQueryBuilder;
 import org.elasticsearch.index.query.IdsQueryBuilder;
 import org.elasticsearch.index.query.MatchQueryBuilder;
 import org.elasticsearch.index.query.PrefixQueryBuilder;
 import org.elasticsearch.index.query.RangeQueryBuilder;
+import org.elasticsearch.index.query.RegexpQueryBuilder;
 import org.elasticsearch.index.query.TermQueryBuilder;
 import org.elasticsearch.index.query.TermsQueryBuilder;
+import org.elasticsearch.index.query.WildcardQueryBuilder;
 
 /**
  * @author ESFlute (using FreeGen)
@@ -267,6 +271,28 @@ public abstract class BsRoleTypeCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setCreatedBy_Wildcard(String createdBy) {
+        setCreatedBy_Wildcard(createdBy, null);
+    }
+
+    public void setCreatedBy_Wildcard(String createdBy, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Regexp(String createdBy) {
+        setCreatedBy_Regexp(createdBy, null);
+    }
+
+    public void setCreatedBy_Regexp(String createdBy, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setCreatedBy_GreaterThan(String createdBy) {
         setCreatedBy_GreaterThan(createdBy, null);
     }
@@ -311,6 +337,28 @@ public abstract class BsRoleTypeCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setCreatedBy_Exists() {
+        setCreatedBy_Exists(null);
+    }
+
+    public void setCreatedBy_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("createdBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_CommonTerms(String createdBy) {
+        setCreatedBy_CommonTerms(createdBy, null);
+    }
+
+    public void setCreatedBy_CommonTerms(String createdBy, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsRoleTypeCQ addOrderBy_CreatedBy_Asc() {
         regOBA("createdBy");
         return this;
@@ -463,6 +511,28 @@ public abstract class BsRoleTypeCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setCreatedTime_Exists() {
+        setCreatedTime_Exists(null);
+    }
+
+    public void setCreatedTime_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("createdTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_CommonTerms(Long createdTime) {
+        setCreatedTime_CommonTerms(createdTime, null);
+    }
+
+    public void setCreatedTime_CommonTerms(Long createdTime, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("createdTime", createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsRoleTypeCQ addOrderBy_CreatedTime_Asc() {
         regOBA("createdTime");
         return this;
@@ -582,6 +652,28 @@ public abstract class BsRoleTypeCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setName_Wildcard(String name) {
+        setName_Wildcard(name, null);
+    }
+
+    public void setName_Wildcard(String name, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("name", name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_Regexp(String name) {
+        setName_Regexp(name, null);
+    }
+
+    public void setName_Regexp(String name, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("name", name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setName_GreaterThan(String name) {
         setName_GreaterThan(name, null);
     }
@@ -626,6 +718,28 @@ public abstract class BsRoleTypeCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setName_Exists() {
+        setName_Exists(null);
+    }
+
+    public void setName_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("name");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_CommonTerms(String name) {
+        setName_CommonTerms(name, null);
+    }
+
+    public void setName_CommonTerms(String name, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("name", name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsRoleTypeCQ addOrderBy_Name_Asc() {
         regOBA("name");
         return this;
@@ -778,6 +892,28 @@ public abstract class BsRoleTypeCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setSortOrder_Exists() {
+        setSortOrder_Exists(null);
+    }
+
+    public void setSortOrder_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("sortOrder");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_CommonTerms(Integer sortOrder) {
+        setSortOrder_CommonTerms(sortOrder, null);
+    }
+
+    public void setSortOrder_CommonTerms(Integer sortOrder, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("sortOrder", sortOrder);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsRoleTypeCQ addOrderBy_SortOrder_Asc() {
         regOBA("sortOrder");
         return this;
@@ -897,6 +1033,28 @@ public abstract class BsRoleTypeCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUpdatedBy_Wildcard(String updatedBy) {
+        setUpdatedBy_Wildcard(updatedBy, null);
+    }
+
+    public void setUpdatedBy_Wildcard(String updatedBy, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Regexp(String updatedBy) {
+        setUpdatedBy_Regexp(updatedBy, null);
+    }
+
+    public void setUpdatedBy_Regexp(String updatedBy, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setUpdatedBy_GreaterThan(String updatedBy) {
         setUpdatedBy_GreaterThan(updatedBy, null);
     }
@@ -941,6 +1099,28 @@ public abstract class BsRoleTypeCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUpdatedBy_Exists() {
+        setUpdatedBy_Exists(null);
+    }
+
+    public void setUpdatedBy_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("updatedBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_CommonTerms(String updatedBy) {
+        setUpdatedBy_CommonTerms(updatedBy, null);
+    }
+
+    public void setUpdatedBy_CommonTerms(String updatedBy, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsRoleTypeCQ addOrderBy_UpdatedBy_Asc() {
         regOBA("updatedBy");
         return this;
@@ -1093,6 +1273,28 @@ public abstract class BsRoleTypeCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUpdatedTime_Exists() {
+        setUpdatedTime_Exists(null);
+    }
+
+    public void setUpdatedTime_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("updatedTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_CommonTerms(Long updatedTime) {
+        setUpdatedTime_CommonTerms(updatedTime, null);
+    }
+
+    public void setUpdatedTime_CommonTerms(Long updatedTime, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("updatedTime", updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsRoleTypeCQ addOrderBy_UpdatedTime_Asc() {
         regOBA("updatedTime");
         return this;
@@ -1212,6 +1414,28 @@ public abstract class BsRoleTypeCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setValue_Wildcard(String value) {
+        setValue_Wildcard(value, null);
+    }
+
+    public void setValue_Wildcard(String value, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("value", value);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setValue_Regexp(String value) {
+        setValue_Regexp(value, null);
+    }
+
+    public void setValue_Regexp(String value, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("value", value);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setValue_GreaterThan(String value) {
         setValue_GreaterThan(value, null);
     }
@@ -1256,6 +1480,28 @@ public abstract class BsRoleTypeCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setValue_Exists() {
+        setValue_Exists(null);
+    }
+
+    public void setValue_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("value");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setValue_CommonTerms(String value) {
+        setValue_CommonTerms(value, null);
+    }
+
+    public void setValue_CommonTerms(String value, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("value", value);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsRoleTypeCQ addOrderBy_Value_Asc() {
         regOBA("value");
         return this;

src/main/java/org/codelibs/fess/es/config/cbean/cq/bs/BsScheduledJobCQ.java

@@ -22,13 +22,17 @@ import org.codelibs.fess.es.config.allcommon.EsAbstractConditionQuery;
 import org.codelibs.fess.es.config.cbean.cq.ScheduledJobCQ;
 import org.dbflute.cbean.ckey.ConditionKey;
 import org.elasticsearch.index.query.BoolQueryBuilder;
+import org.elasticsearch.index.query.CommonTermsQueryBuilder;
+import org.elasticsearch.index.query.ExistsQueryBuilder;
 import org.elasticsearch.index.query.FuzzyQueryBuilder;
 import org.elasticsearch.index.query.IdsQueryBuilder;
 import org.elasticsearch.index.query.MatchQueryBuilder;
 import org.elasticsearch.index.query.PrefixQueryBuilder;
 import org.elasticsearch.index.query.RangeQueryBuilder;
+import org.elasticsearch.index.query.RegexpQueryBuilder;
 import org.elasticsearch.index.query.TermQueryBuilder;
 import org.elasticsearch.index.query.TermsQueryBuilder;
+import org.elasticsearch.index.query.WildcardQueryBuilder;
 
 /**
  * @author ESFlute (using FreeGen)
@@ -300,6 +304,28 @@ public abstract class BsScheduledJobCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setAvailable_Exists() {
+        setAvailable_Exists(null);
+    }
+
+    public void setAvailable_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("available");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setAvailable_CommonTerms(Boolean available) {
+        setAvailable_CommonTerms(available, null);
+    }
+
+    public void setAvailable_CommonTerms(Boolean available, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("available", available);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsScheduledJobCQ addOrderBy_Available_Asc() {
         regOBA("available");
         return this;
@@ -452,6 +478,28 @@ public abstract class BsScheduledJobCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setCrawler_Exists() {
+        setCrawler_Exists(null);
+    }
+
+    public void setCrawler_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("crawler");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCrawler_CommonTerms(Boolean crawler) {
+        setCrawler_CommonTerms(crawler, null);
+    }
+
+    public void setCrawler_CommonTerms(Boolean crawler, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("crawler", crawler);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsScheduledJobCQ addOrderBy_Crawler_Asc() {
         regOBA("crawler");
         return this;
@@ -571,6 +619,28 @@ public abstract class BsScheduledJobCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setCreatedBy_Wildcard(String createdBy) {
+        setCreatedBy_Wildcard(createdBy, null);
+    }
+
+    public void setCreatedBy_Wildcard(String createdBy, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Regexp(String createdBy) {
+        setCreatedBy_Regexp(createdBy, null);
+    }
+
+    public void setCreatedBy_Regexp(String createdBy, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setCreatedBy_GreaterThan(String createdBy) {
         setCreatedBy_GreaterThan(createdBy, null);
     }
@@ -615,6 +685,28 @@ public abstract class BsScheduledJobCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setCreatedBy_Exists() {
+        setCreatedBy_Exists(null);
+    }
+
+    public void setCreatedBy_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("createdBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_CommonTerms(String createdBy) {
+        setCreatedBy_CommonTerms(createdBy, null);
+    }
+
+    public void setCreatedBy_CommonTerms(String createdBy, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsScheduledJobCQ addOrderBy_CreatedBy_Asc() {
         regOBA("createdBy");
         return this;
@@ -767,6 +859,28 @@ public abstract class BsScheduledJobCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setCreatedTime_Exists() {
+        setCreatedTime_Exists(null);
+    }
+
+    public void setCreatedTime_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("createdTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_CommonTerms(Long createdTime) {
+        setCreatedTime_CommonTerms(createdTime, null);
+    }
+
+    public void setCreatedTime_CommonTerms(Long createdTime, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("createdTime", createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsScheduledJobCQ addOrderBy_CreatedTime_Asc() {
         regOBA("createdTime");
         return this;
@@ -886,6 +1000,28 @@ public abstract class BsScheduledJobCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setCronExpression_Wildcard(String cronExpression) {
+        setCronExpression_Wildcard(cronExpression, null);
+    }
+
+    public void setCronExpression_Wildcard(String cronExpression, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("cronExpression", cronExpression);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCronExpression_Regexp(String cronExpression) {
+        setCronExpression_Regexp(cronExpression, null);
+    }
+
+    public void setCronExpression_Regexp(String cronExpression, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("cronExpression", cronExpression);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setCronExpression_GreaterThan(String cronExpression) {
         setCronExpression_GreaterThan(cronExpression, null);
     }
@@ -930,6 +1066,28 @@ public abstract class BsScheduledJobCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setCronExpression_Exists() {
+        setCronExpression_Exists(null);
+    }
+
+    public void setCronExpression_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("cronExpression");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCronExpression_CommonTerms(String cronExpression) {
+        setCronExpression_CommonTerms(cronExpression, null);
+    }
+
+    public void setCronExpression_CommonTerms(String cronExpression, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("cronExpression", cronExpression);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsScheduledJobCQ addOrderBy_CronExpression_Asc() {
         regOBA("cronExpression");
         return this;
@@ -1082,6 +1240,28 @@ public abstract class BsScheduledJobCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setJobLogging_Exists() {
+        setJobLogging_Exists(null);
+    }
+
+    public void setJobLogging_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("jobLogging");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setJobLogging_CommonTerms(Boolean jobLogging) {
+        setJobLogging_CommonTerms(jobLogging, null);
+    }
+
+    public void setJobLogging_CommonTerms(Boolean jobLogging, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("jobLogging", jobLogging);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsScheduledJobCQ addOrderBy_JobLogging_Asc() {
         regOBA("jobLogging");
         return this;
@@ -1201,6 +1381,28 @@ public abstract class BsScheduledJobCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setName_Wildcard(String name) {
+        setName_Wildcard(name, null);
+    }
+
+    public void setName_Wildcard(String name, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("name", name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_Regexp(String name) {
+        setName_Regexp(name, null);
+    }
+
+    public void setName_Regexp(String name, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("name", name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setName_GreaterThan(String name) {
         setName_GreaterThan(name, null);
     }
@@ -1245,6 +1447,28 @@ public abstract class BsScheduledJobCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setName_Exists() {
+        setName_Exists(null);
+    }
+
+    public void setName_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("name");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_CommonTerms(String name) {
+        setName_CommonTerms(name, null);
+    }
+
+    public void setName_CommonTerms(String name, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("name", name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsScheduledJobCQ addOrderBy_Name_Asc() {
         regOBA("name");
         return this;
@@ -1364,6 +1588,28 @@ public abstract class BsScheduledJobCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setScriptData_Wildcard(String scriptData) {
+        setScriptData_Wildcard(scriptData, null);
+    }
+
+    public void setScriptData_Wildcard(String scriptData, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("scriptData", scriptData);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setScriptData_Regexp(String scriptData) {
+        setScriptData_Regexp(scriptData, null);
+    }
+
+    public void setScriptData_Regexp(String scriptData, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("scriptData", scriptData);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setScriptData_GreaterThan(String scriptData) {
         setScriptData_GreaterThan(scriptData, null);
     }
@@ -1408,6 +1654,28 @@ public abstract class BsScheduledJobCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setScriptData_Exists() {
+        setScriptData_Exists(null);
+    }
+
+    public void setScriptData_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("scriptData");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setScriptData_CommonTerms(String scriptData) {
+        setScriptData_CommonTerms(scriptData, null);
+    }
+
+    public void setScriptData_CommonTerms(String scriptData, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("scriptData", scriptData);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsScheduledJobCQ addOrderBy_ScriptData_Asc() {
         regOBA("scriptData");
         return this;
@@ -1527,6 +1795,28 @@ public abstract class BsScheduledJobCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setScriptType_Wildcard(String scriptType) {
+        setScriptType_Wildcard(scriptType, null);
+    }
+
+    public void setScriptType_Wildcard(String scriptType, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("scriptType", scriptType);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setScriptType_Regexp(String scriptType) {
+        setScriptType_Regexp(scriptType, null);
+    }
+
+    public void setScriptType_Regexp(String scriptType, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("scriptType", scriptType);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setScriptType_GreaterThan(String scriptType) {
         setScriptType_GreaterThan(scriptType, null);
     }
@@ -1571,6 +1861,28 @@ public abstract class BsScheduledJobCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setScriptType_Exists() {
+        setScriptType_Exists(null);
+    }
+
+    public void setScriptType_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("scriptType");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setScriptType_CommonTerms(String scriptType) {
+        setScriptType_CommonTerms(scriptType, null);
+    }
+
+    public void setScriptType_CommonTerms(String scriptType, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("scriptType", scriptType);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsScheduledJobCQ addOrderBy_ScriptType_Asc() {
         regOBA("scriptType");
         return this;
@@ -1723,6 +2035,28 @@ public abstract class BsScheduledJobCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setSortOrder_Exists() {
+        setSortOrder_Exists(null);
+    }
+
+    public void setSortOrder_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("sortOrder");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_CommonTerms(Integer sortOrder) {
+        setSortOrder_CommonTerms(sortOrder, null);
+    }
+
+    public void setSortOrder_CommonTerms(Integer sortOrder, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("sortOrder", sortOrder);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsScheduledJobCQ addOrderBy_SortOrder_Asc() {
         regOBA("sortOrder");
         return this;
@@ -1842,6 +2176,28 @@ public abstract class BsScheduledJobCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setTarget_Wildcard(String target) {
+        setTarget_Wildcard(target, null);
+    }
+
+    public void setTarget_Wildcard(String target, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("target", target);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTarget_Regexp(String target) {
+        setTarget_Regexp(target, null);
+    }
+
+    public void setTarget_Regexp(String target, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("target", target);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setTarget_GreaterThan(String target) {
         setTarget_GreaterThan(target, null);
     }
@@ -1886,6 +2242,28 @@ public abstract class BsScheduledJobCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setTarget_Exists() {
+        setTarget_Exists(null);
+    }
+
+    public void setTarget_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("target");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTarget_CommonTerms(String target) {
+        setTarget_CommonTerms(target, null);
+    }
+
+    public void setTarget_CommonTerms(String target, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("target", target);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsScheduledJobCQ addOrderBy_Target_Asc() {
         regOBA("target");
         return this;
@@ -2005,6 +2383,28 @@ public abstract class BsScheduledJobCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUpdatedBy_Wildcard(String updatedBy) {
+        setUpdatedBy_Wildcard(updatedBy, null);
+    }
+
+    public void setUpdatedBy_Wildcard(String updatedBy, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Regexp(String updatedBy) {
+        setUpdatedBy_Regexp(updatedBy, null);
+    }
+
+    public void setUpdatedBy_Regexp(String updatedBy, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setUpdatedBy_GreaterThan(String updatedBy) {
         setUpdatedBy_GreaterThan(updatedBy, null);
     }
@@ -2049,6 +2449,28 @@ public abstract class BsScheduledJobCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUpdatedBy_Exists() {
+        setUpdatedBy_Exists(null);
+    }
+
+    public void setUpdatedBy_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("updatedBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_CommonTerms(String updatedBy) {
+        setUpdatedBy_CommonTerms(updatedBy, null);
+    }
+
+    public void setUpdatedBy_CommonTerms(String updatedBy, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsScheduledJobCQ addOrderBy_UpdatedBy_Asc() {
         regOBA("updatedBy");
         return this;
@@ -2201,6 +2623,28 @@ public abstract class BsScheduledJobCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUpdatedTime_Exists() {
+        setUpdatedTime_Exists(null);
+    }
+
+    public void setUpdatedTime_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("updatedTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_CommonTerms(Long updatedTime) {
+        setUpdatedTime_CommonTerms(updatedTime, null);
+    }
+
+    public void setUpdatedTime_CommonTerms(Long updatedTime, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("updatedTime", updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsScheduledJobCQ addOrderBy_UpdatedTime_Asc() {
         regOBA("updatedTime");
         return this;

src/main/java/org/codelibs/fess/es/config/cbean/cq/bs/BsWebAuthenticationCQ.java

@@ -22,13 +22,17 @@ import org.codelibs.fess.es.config.allcommon.EsAbstractConditionQuery;
 import org.codelibs.fess.es.config.cbean.cq.WebAuthenticationCQ;
 import org.dbflute.cbean.ckey.ConditionKey;
 import org.elasticsearch.index.query.BoolQueryBuilder;
+import org.elasticsearch.index.query.CommonTermsQueryBuilder;
+import org.elasticsearch.index.query.ExistsQueryBuilder;
 import org.elasticsearch.index.query.FuzzyQueryBuilder;
 import org.elasticsearch.index.query.IdsQueryBuilder;
 import org.elasticsearch.index.query.MatchQueryBuilder;
 import org.elasticsearch.index.query.PrefixQueryBuilder;
 import org.elasticsearch.index.query.RangeQueryBuilder;
+import org.elasticsearch.index.query.RegexpQueryBuilder;
 import org.elasticsearch.index.query.TermQueryBuilder;
 import org.elasticsearch.index.query.TermsQueryBuilder;
+import org.elasticsearch.index.query.WildcardQueryBuilder;
 
 /**
  * @author ESFlute (using FreeGen)
@@ -268,6 +272,28 @@ public abstract class BsWebAuthenticationCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setAuthRealm_Wildcard(String authRealm) {
+        setAuthRealm_Wildcard(authRealm, null);
+    }
+
+    public void setAuthRealm_Wildcard(String authRealm, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("authRealm", authRealm);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setAuthRealm_Regexp(String authRealm) {
+        setAuthRealm_Regexp(authRealm, null);
+    }
+
+    public void setAuthRealm_Regexp(String authRealm, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("authRealm", authRealm);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setAuthRealm_GreaterThan(String authRealm) {
         setAuthRealm_GreaterThan(authRealm, null);
     }
@@ -312,6 +338,28 @@ public abstract class BsWebAuthenticationCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setAuthRealm_Exists() {
+        setAuthRealm_Exists(null);
+    }
+
+    public void setAuthRealm_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("authRealm");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setAuthRealm_CommonTerms(String authRealm) {
+        setAuthRealm_CommonTerms(authRealm, null);
+    }
+
+    public void setAuthRealm_CommonTerms(String authRealm, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("authRealm", authRealm);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsWebAuthenticationCQ addOrderBy_AuthRealm_Asc() {
         regOBA("authRealm");
         return this;
@@ -431,6 +479,28 @@ public abstract class BsWebAuthenticationCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setCreatedBy_Wildcard(String createdBy) {
+        setCreatedBy_Wildcard(createdBy, null);
+    }
+
+    public void setCreatedBy_Wildcard(String createdBy, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Regexp(String createdBy) {
+        setCreatedBy_Regexp(createdBy, null);
+    }
+
+    public void setCreatedBy_Regexp(String createdBy, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setCreatedBy_GreaterThan(String createdBy) {
         setCreatedBy_GreaterThan(createdBy, null);
     }
@@ -475,6 +545,28 @@ public abstract class BsWebAuthenticationCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setCreatedBy_Exists() {
+        setCreatedBy_Exists(null);
+    }
+
+    public void setCreatedBy_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("createdBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_CommonTerms(String createdBy) {
+        setCreatedBy_CommonTerms(createdBy, null);
+    }
+
+    public void setCreatedBy_CommonTerms(String createdBy, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsWebAuthenticationCQ addOrderBy_CreatedBy_Asc() {
         regOBA("createdBy");
         return this;
@@ -627,6 +719,28 @@ public abstract class BsWebAuthenticationCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setCreatedTime_Exists() {
+        setCreatedTime_Exists(null);
+    }
+
+    public void setCreatedTime_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("createdTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_CommonTerms(Long createdTime) {
+        setCreatedTime_CommonTerms(createdTime, null);
+    }
+
+    public void setCreatedTime_CommonTerms(Long createdTime, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("createdTime", createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsWebAuthenticationCQ addOrderBy_CreatedTime_Asc() {
         regOBA("createdTime");
         return this;
@@ -746,6 +860,28 @@ public abstract class BsWebAuthenticationCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setHostname_Wildcard(String hostname) {
+        setHostname_Wildcard(hostname, null);
+    }
+
+    public void setHostname_Wildcard(String hostname, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("hostname", hostname);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHostname_Regexp(String hostname) {
+        setHostname_Regexp(hostname, null);
+    }
+
+    public void setHostname_Regexp(String hostname, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("hostname", hostname);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setHostname_GreaterThan(String hostname) {
         setHostname_GreaterThan(hostname, null);
     }
@@ -790,6 +926,28 @@ public abstract class BsWebAuthenticationCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setHostname_Exists() {
+        setHostname_Exists(null);
+    }
+
+    public void setHostname_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("hostname");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHostname_CommonTerms(String hostname) {
+        setHostname_CommonTerms(hostname, null);
+    }
+
+    public void setHostname_CommonTerms(String hostname, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("hostname", hostname);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsWebAuthenticationCQ addOrderBy_Hostname_Asc() {
         regOBA("hostname");
         return this;
@@ -909,6 +1067,28 @@ public abstract class BsWebAuthenticationCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setParameters_Wildcard(String parameters) {
+        setParameters_Wildcard(parameters, null);
+    }
+
+    public void setParameters_Wildcard(String parameters, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("parameters", parameters);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setParameters_Regexp(String parameters) {
+        setParameters_Regexp(parameters, null);
+    }
+
+    public void setParameters_Regexp(String parameters, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("parameters", parameters);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setParameters_GreaterThan(String parameters) {
         setParameters_GreaterThan(parameters, null);
     }
@@ -953,6 +1133,28 @@ public abstract class BsWebAuthenticationCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setParameters_Exists() {
+        setParameters_Exists(null);
+    }
+
+    public void setParameters_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("parameters");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setParameters_CommonTerms(String parameters) {
+        setParameters_CommonTerms(parameters, null);
+    }
+
+    public void setParameters_CommonTerms(String parameters, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("parameters", parameters);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsWebAuthenticationCQ addOrderBy_Parameters_Asc() {
         regOBA("parameters");
         return this;
@@ -1072,6 +1274,28 @@ public abstract class BsWebAuthenticationCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setPassword_Wildcard(String password) {
+        setPassword_Wildcard(password, null);
+    }
+
+    public void setPassword_Wildcard(String password, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("password", password);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setPassword_Regexp(String password) {
+        setPassword_Regexp(password, null);
+    }
+
+    public void setPassword_Regexp(String password, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("password", password);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setPassword_GreaterThan(String password) {
         setPassword_GreaterThan(password, null);
     }
@@ -1116,6 +1340,28 @@ public abstract class BsWebAuthenticationCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setPassword_Exists() {
+        setPassword_Exists(null);
+    }
+
+    public void setPassword_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("password");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setPassword_CommonTerms(String password) {
+        setPassword_CommonTerms(password, null);
+    }
+
+    public void setPassword_CommonTerms(String password, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("password", password);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsWebAuthenticationCQ addOrderBy_Password_Asc() {
         regOBA("password");
         return this;
@@ -1268,6 +1514,28 @@ public abstract class BsWebAuthenticationCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setPort_Exists() {
+        setPort_Exists(null);
+    }
+
+    public void setPort_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("port");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setPort_CommonTerms(Integer port) {
+        setPort_CommonTerms(port, null);
+    }
+
+    public void setPort_CommonTerms(Integer port, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("port", port);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsWebAuthenticationCQ addOrderBy_Port_Asc() {
         regOBA("port");
         return this;
@@ -1387,6 +1655,28 @@ public abstract class BsWebAuthenticationCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setProtocolScheme_Wildcard(String protocolScheme) {
+        setProtocolScheme_Wildcard(protocolScheme, null);
+    }
+
+    public void setProtocolScheme_Wildcard(String protocolScheme, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("protocolScheme", protocolScheme);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setProtocolScheme_Regexp(String protocolScheme) {
+        setProtocolScheme_Regexp(protocolScheme, null);
+    }
+
+    public void setProtocolScheme_Regexp(String protocolScheme, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("protocolScheme", protocolScheme);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setProtocolScheme_GreaterThan(String protocolScheme) {
         setProtocolScheme_GreaterThan(protocolScheme, null);
     }
@@ -1431,6 +1721,28 @@ public abstract class BsWebAuthenticationCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setProtocolScheme_Exists() {
+        setProtocolScheme_Exists(null);
+    }
+
+    public void setProtocolScheme_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("protocolScheme");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setProtocolScheme_CommonTerms(String protocolScheme) {
+        setProtocolScheme_CommonTerms(protocolScheme, null);
+    }
+
+    public void setProtocolScheme_CommonTerms(String protocolScheme, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("protocolScheme", protocolScheme);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsWebAuthenticationCQ addOrderBy_ProtocolScheme_Asc() {
         regOBA("protocolScheme");
         return this;
@@ -1550,6 +1862,28 @@ public abstract class BsWebAuthenticationCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUpdatedBy_Wildcard(String updatedBy) {
+        setUpdatedBy_Wildcard(updatedBy, null);
+    }
+
+    public void setUpdatedBy_Wildcard(String updatedBy, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Regexp(String updatedBy) {
+        setUpdatedBy_Regexp(updatedBy, null);
+    }
+
+    public void setUpdatedBy_Regexp(String updatedBy, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setUpdatedBy_GreaterThan(String updatedBy) {
         setUpdatedBy_GreaterThan(updatedBy, null);
     }
@@ -1594,6 +1928,28 @@ public abstract class BsWebAuthenticationCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUpdatedBy_Exists() {
+        setUpdatedBy_Exists(null);
+    }
+
+    public void setUpdatedBy_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("updatedBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_CommonTerms(String updatedBy) {
+        setUpdatedBy_CommonTerms(updatedBy, null);
+    }
+
+    public void setUpdatedBy_CommonTerms(String updatedBy, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsWebAuthenticationCQ addOrderBy_UpdatedBy_Asc() {
         regOBA("updatedBy");
         return this;
@@ -1746,6 +2102,28 @@ public abstract class BsWebAuthenticationCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUpdatedTime_Exists() {
+        setUpdatedTime_Exists(null);
+    }
+
+    public void setUpdatedTime_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("updatedTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_CommonTerms(Long updatedTime) {
+        setUpdatedTime_CommonTerms(updatedTime, null);
+    }
+
+    public void setUpdatedTime_CommonTerms(Long updatedTime, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("updatedTime", updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsWebAuthenticationCQ addOrderBy_UpdatedTime_Asc() {
         regOBA("updatedTime");
         return this;
@@ -1865,6 +2243,28 @@ public abstract class BsWebAuthenticationCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUsername_Wildcard(String username) {
+        setUsername_Wildcard(username, null);
+    }
+
+    public void setUsername_Wildcard(String username, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("username", username);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUsername_Regexp(String username) {
+        setUsername_Regexp(username, null);
+    }
+
+    public void setUsername_Regexp(String username, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("username", username);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setUsername_GreaterThan(String username) {
         setUsername_GreaterThan(username, null);
     }
@@ -1909,6 +2309,28 @@ public abstract class BsWebAuthenticationCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUsername_Exists() {
+        setUsername_Exists(null);
+    }
+
+    public void setUsername_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("username");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUsername_CommonTerms(String username) {
+        setUsername_CommonTerms(username, null);
+    }
+
+    public void setUsername_CommonTerms(String username, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("username", username);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsWebAuthenticationCQ addOrderBy_Username_Asc() {
         regOBA("username");
         return this;
@@ -2028,6 +2450,28 @@ public abstract class BsWebAuthenticationCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setWebConfigId_Wildcard(String webConfigId) {
+        setWebConfigId_Wildcard(webConfigId, null);
+    }
+
+    public void setWebConfigId_Wildcard(String webConfigId, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("webConfigId", webConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setWebConfigId_Regexp(String webConfigId) {
+        setWebConfigId_Regexp(webConfigId, null);
+    }
+
+    public void setWebConfigId_Regexp(String webConfigId, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("webConfigId", webConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setWebConfigId_GreaterThan(String webConfigId) {
         setWebConfigId_GreaterThan(webConfigId, null);
     }
@@ -2072,6 +2516,28 @@ public abstract class BsWebAuthenticationCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setWebConfigId_Exists() {
+        setWebConfigId_Exists(null);
+    }
+
+    public void setWebConfigId_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("webConfigId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setWebConfigId_CommonTerms(String webConfigId) {
+        setWebConfigId_CommonTerms(webConfigId, null);
+    }
+
+    public void setWebConfigId_CommonTerms(String webConfigId, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("webConfigId", webConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsWebAuthenticationCQ addOrderBy_WebConfigId_Asc() {
         regOBA("webConfigId");
         return this;

src/main/java/org/codelibs/fess/es/config/cbean/cq/bs/BsWebConfigCQ.java

@@ -22,13 +22,17 @@ import org.codelibs.fess.es.config.allcommon.EsAbstractConditionQuery;
 import org.codelibs.fess.es.config.cbean.cq.WebConfigCQ;
 import org.dbflute.cbean.ckey.ConditionKey;
 import org.elasticsearch.index.query.BoolQueryBuilder;
+import org.elasticsearch.index.query.CommonTermsQueryBuilder;
+import org.elasticsearch.index.query.ExistsQueryBuilder;
 import org.elasticsearch.index.query.FuzzyQueryBuilder;
 import org.elasticsearch.index.query.IdsQueryBuilder;
 import org.elasticsearch.index.query.MatchQueryBuilder;
 import org.elasticsearch.index.query.PrefixQueryBuilder;
 import org.elasticsearch.index.query.RangeQueryBuilder;
+import org.elasticsearch.index.query.RegexpQueryBuilder;
 import org.elasticsearch.index.query.TermQueryBuilder;
 import org.elasticsearch.index.query.TermsQueryBuilder;
+import org.elasticsearch.index.query.WildcardQueryBuilder;
 
 /**
  * @author ESFlute (using FreeGen)
@@ -300,6 +304,28 @@ public abstract class BsWebConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setAvailable_Exists() {
+        setAvailable_Exists(null);
+    }
+
+    public void setAvailable_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("available");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setAvailable_CommonTerms(Boolean available) {
+        setAvailable_CommonTerms(available, null);
+    }
+
+    public void setAvailable_CommonTerms(Boolean available, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("available", available);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsWebConfigCQ addOrderBy_Available_Asc() {
         regOBA("available");
         return this;
@@ -452,6 +478,28 @@ public abstract class BsWebConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setBoost_Exists() {
+        setBoost_Exists(null);
+    }
+
+    public void setBoost_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("boost");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setBoost_CommonTerms(Float boost) {
+        setBoost_CommonTerms(boost, null);
+    }
+
+    public void setBoost_CommonTerms(Float boost, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("boost", boost);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsWebConfigCQ addOrderBy_Boost_Asc() {
         regOBA("boost");
         return this;
@@ -571,6 +619,28 @@ public abstract class BsWebConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setConfigParameter_Wildcard(String configParameter) {
+        setConfigParameter_Wildcard(configParameter, null);
+    }
+
+    public void setConfigParameter_Wildcard(String configParameter, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("configParameter", configParameter);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setConfigParameter_Regexp(String configParameter) {
+        setConfigParameter_Regexp(configParameter, null);
+    }
+
+    public void setConfigParameter_Regexp(String configParameter, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("configParameter", configParameter);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setConfigParameter_GreaterThan(String configParameter) {
         setConfigParameter_GreaterThan(configParameter, null);
     }
@@ -615,6 +685,28 @@ public abstract class BsWebConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setConfigParameter_Exists() {
+        setConfigParameter_Exists(null);
+    }
+
+    public void setConfigParameter_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("configParameter");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setConfigParameter_CommonTerms(String configParameter) {
+        setConfigParameter_CommonTerms(configParameter, null);
+    }
+
+    public void setConfigParameter_CommonTerms(String configParameter, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("configParameter", configParameter);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsWebConfigCQ addOrderBy_ConfigParameter_Asc() {
         regOBA("configParameter");
         return this;
@@ -734,6 +826,28 @@ public abstract class BsWebConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setCreatedBy_Wildcard(String createdBy) {
+        setCreatedBy_Wildcard(createdBy, null);
+    }
+
+    public void setCreatedBy_Wildcard(String createdBy, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_Regexp(String createdBy) {
+        setCreatedBy_Regexp(createdBy, null);
+    }
+
+    public void setCreatedBy_Regexp(String createdBy, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setCreatedBy_GreaterThan(String createdBy) {
         setCreatedBy_GreaterThan(createdBy, null);
     }
@@ -778,6 +892,28 @@ public abstract class BsWebConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setCreatedBy_Exists() {
+        setCreatedBy_Exists(null);
+    }
+
+    public void setCreatedBy_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("createdBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedBy_CommonTerms(String createdBy) {
+        setCreatedBy_CommonTerms(createdBy, null);
+    }
+
+    public void setCreatedBy_CommonTerms(String createdBy, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("createdBy", createdBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsWebConfigCQ addOrderBy_CreatedBy_Asc() {
         regOBA("createdBy");
         return this;
@@ -930,6 +1066,28 @@ public abstract class BsWebConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setCreatedTime_Exists() {
+        setCreatedTime_Exists(null);
+    }
+
+    public void setCreatedTime_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("createdTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedTime_CommonTerms(Long createdTime) {
+        setCreatedTime_CommonTerms(createdTime, null);
+    }
+
+    public void setCreatedTime_CommonTerms(Long createdTime, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("createdTime", createdTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsWebConfigCQ addOrderBy_CreatedTime_Asc() {
         regOBA("createdTime");
         return this;
@@ -1082,6 +1240,28 @@ public abstract class BsWebConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setDepth_Exists() {
+        setDepth_Exists(null);
+    }
+
+    public void setDepth_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("depth");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setDepth_CommonTerms(Integer depth) {
+        setDepth_CommonTerms(depth, null);
+    }
+
+    public void setDepth_CommonTerms(Integer depth, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("depth", depth);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsWebConfigCQ addOrderBy_Depth_Asc() {
         regOBA("depth");
         return this;
@@ -1201,6 +1381,28 @@ public abstract class BsWebConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setExcludedDocUrls_Wildcard(String excludedDocUrls) {
+        setExcludedDocUrls_Wildcard(excludedDocUrls, null);
+    }
+
+    public void setExcludedDocUrls_Wildcard(String excludedDocUrls, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("excludedDocUrls", excludedDocUrls);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExcludedDocUrls_Regexp(String excludedDocUrls) {
+        setExcludedDocUrls_Regexp(excludedDocUrls, null);
+    }
+
+    public void setExcludedDocUrls_Regexp(String excludedDocUrls, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("excludedDocUrls", excludedDocUrls);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setExcludedDocUrls_GreaterThan(String excludedDocUrls) {
         setExcludedDocUrls_GreaterThan(excludedDocUrls, null);
     }
@@ -1245,6 +1447,28 @@ public abstract class BsWebConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setExcludedDocUrls_Exists() {
+        setExcludedDocUrls_Exists(null);
+    }
+
+    public void setExcludedDocUrls_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("excludedDocUrls");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExcludedDocUrls_CommonTerms(String excludedDocUrls) {
+        setExcludedDocUrls_CommonTerms(excludedDocUrls, null);
+    }
+
+    public void setExcludedDocUrls_CommonTerms(String excludedDocUrls, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("excludedDocUrls", excludedDocUrls);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsWebConfigCQ addOrderBy_ExcludedDocUrls_Asc() {
         regOBA("excludedDocUrls");
         return this;
@@ -1364,6 +1588,28 @@ public abstract class BsWebConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setExcludedUrls_Wildcard(String excludedUrls) {
+        setExcludedUrls_Wildcard(excludedUrls, null);
+    }
+
+    public void setExcludedUrls_Wildcard(String excludedUrls, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("excludedUrls", excludedUrls);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExcludedUrls_Regexp(String excludedUrls) {
+        setExcludedUrls_Regexp(excludedUrls, null);
+    }
+
+    public void setExcludedUrls_Regexp(String excludedUrls, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("excludedUrls", excludedUrls);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setExcludedUrls_GreaterThan(String excludedUrls) {
         setExcludedUrls_GreaterThan(excludedUrls, null);
     }
@@ -1408,6 +1654,28 @@ public abstract class BsWebConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setExcludedUrls_Exists() {
+        setExcludedUrls_Exists(null);
+    }
+
+    public void setExcludedUrls_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("excludedUrls");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setExcludedUrls_CommonTerms(String excludedUrls) {
+        setExcludedUrls_CommonTerms(excludedUrls, null);
+    }
+
+    public void setExcludedUrls_CommonTerms(String excludedUrls, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("excludedUrls", excludedUrls);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsWebConfigCQ addOrderBy_ExcludedUrls_Asc() {
         regOBA("excludedUrls");
         return this;
@@ -1527,6 +1795,28 @@ public abstract class BsWebConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setIncludedDocUrls_Wildcard(String includedDocUrls) {
+        setIncludedDocUrls_Wildcard(includedDocUrls, null);
+    }
+
+    public void setIncludedDocUrls_Wildcard(String includedDocUrls, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("includedDocUrls", includedDocUrls);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIncludedDocUrls_Regexp(String includedDocUrls) {
+        setIncludedDocUrls_Regexp(includedDocUrls, null);
+    }
+
+    public void setIncludedDocUrls_Regexp(String includedDocUrls, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("includedDocUrls", includedDocUrls);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setIncludedDocUrls_GreaterThan(String includedDocUrls) {
         setIncludedDocUrls_GreaterThan(includedDocUrls, null);
     }
@@ -1571,6 +1861,28 @@ public abstract class BsWebConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setIncludedDocUrls_Exists() {
+        setIncludedDocUrls_Exists(null);
+    }
+
+    public void setIncludedDocUrls_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("includedDocUrls");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIncludedDocUrls_CommonTerms(String includedDocUrls) {
+        setIncludedDocUrls_CommonTerms(includedDocUrls, null);
+    }
+
+    public void setIncludedDocUrls_CommonTerms(String includedDocUrls, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("includedDocUrls", includedDocUrls);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsWebConfigCQ addOrderBy_IncludedDocUrls_Asc() {
         regOBA("includedDocUrls");
         return this;
@@ -1690,6 +2002,28 @@ public abstract class BsWebConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setIncludedUrls_Wildcard(String includedUrls) {
+        setIncludedUrls_Wildcard(includedUrls, null);
+    }
+
+    public void setIncludedUrls_Wildcard(String includedUrls, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("includedUrls", includedUrls);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIncludedUrls_Regexp(String includedUrls) {
+        setIncludedUrls_Regexp(includedUrls, null);
+    }
+
+    public void setIncludedUrls_Regexp(String includedUrls, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("includedUrls", includedUrls);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setIncludedUrls_GreaterThan(String includedUrls) {
         setIncludedUrls_GreaterThan(includedUrls, null);
     }
@@ -1734,6 +2068,28 @@ public abstract class BsWebConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setIncludedUrls_Exists() {
+        setIncludedUrls_Exists(null);
+    }
+
+    public void setIncludedUrls_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("includedUrls");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIncludedUrls_CommonTerms(String includedUrls) {
+        setIncludedUrls_CommonTerms(includedUrls, null);
+    }
+
+    public void setIncludedUrls_CommonTerms(String includedUrls, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("includedUrls", includedUrls);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsWebConfigCQ addOrderBy_IncludedUrls_Asc() {
         regOBA("includedUrls");
         return this;
@@ -1886,6 +2242,28 @@ public abstract class BsWebConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setIntervalTime_Exists() {
+        setIntervalTime_Exists(null);
+    }
+
+    public void setIntervalTime_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("intervalTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setIntervalTime_CommonTerms(Integer intervalTime) {
+        setIntervalTime_CommonTerms(intervalTime, null);
+    }
+
+    public void setIntervalTime_CommonTerms(Integer intervalTime, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("intervalTime", intervalTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsWebConfigCQ addOrderBy_IntervalTime_Asc() {
         regOBA("intervalTime");
         return this;
@@ -2038,6 +2416,28 @@ public abstract class BsWebConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setTimeToLive_Exists() {
+        setTimeToLive_Exists(null);
+    }
+
+    public void setTimeToLive_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("timeToLive");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setTimeToLive_CommonTerms(Integer timeToLive) {
+        setTimeToLive_CommonTerms(timeToLive, null);
+    }
+
+    public void setTimeToLive_CommonTerms(Integer timeToLive, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("timeToLive", timeToLive);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsWebConfigCQ addOrderBy_TimeToLive_Asc() {
         regOBA("timeToLive");
         return this;
@@ -2190,6 +2590,28 @@ public abstract class BsWebConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setMaxAccessCount_Exists() {
+        setMaxAccessCount_Exists(null);
+    }
+
+    public void setMaxAccessCount_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("maxAccessCount");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setMaxAccessCount_CommonTerms(Long maxAccessCount) {
+        setMaxAccessCount_CommonTerms(maxAccessCount, null);
+    }
+
+    public void setMaxAccessCount_CommonTerms(Long maxAccessCount, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("maxAccessCount", maxAccessCount);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsWebConfigCQ addOrderBy_MaxAccessCount_Asc() {
         regOBA("maxAccessCount");
         return this;
@@ -2309,6 +2731,28 @@ public abstract class BsWebConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setName_Wildcard(String name) {
+        setName_Wildcard(name, null);
+    }
+
+    public void setName_Wildcard(String name, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("name", name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_Regexp(String name) {
+        setName_Regexp(name, null);
+    }
+
+    public void setName_Regexp(String name, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("name", name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setName_GreaterThan(String name) {
         setName_GreaterThan(name, null);
     }
@@ -2353,6 +2797,28 @@ public abstract class BsWebConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setName_Exists() {
+        setName_Exists(null);
+    }
+
+    public void setName_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("name");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_CommonTerms(String name) {
+        setName_CommonTerms(name, null);
+    }
+
+    public void setName_CommonTerms(String name, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("name", name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsWebConfigCQ addOrderBy_Name_Asc() {
         regOBA("name");
         return this;
@@ -2505,6 +2971,28 @@ public abstract class BsWebConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setNumOfThread_Exists() {
+        setNumOfThread_Exists(null);
+    }
+
+    public void setNumOfThread_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("numOfThread");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setNumOfThread_CommonTerms(Integer numOfThread) {
+        setNumOfThread_CommonTerms(numOfThread, null);
+    }
+
+    public void setNumOfThread_CommonTerms(Integer numOfThread, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("numOfThread", numOfThread);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsWebConfigCQ addOrderBy_NumOfThread_Asc() {
         regOBA("numOfThread");
         return this;
@@ -2624,6 +3112,28 @@ public abstract class BsWebConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setPermissions_Wildcard(String permissions) {
+        setPermissions_Wildcard(permissions, null);
+    }
+
+    public void setPermissions_Wildcard(String permissions, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("permissions", permissions);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setPermissions_Regexp(String permissions) {
+        setPermissions_Regexp(permissions, null);
+    }
+
+    public void setPermissions_Regexp(String permissions, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("permissions", permissions);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setPermissions_GreaterThan(String permissions) {
         setPermissions_GreaterThan(permissions, null);
     }
@@ -2668,6 +3178,28 @@ public abstract class BsWebConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setPermissions_Exists() {
+        setPermissions_Exists(null);
+    }
+
+    public void setPermissions_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("permissions");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setPermissions_CommonTerms(String permissions) {
+        setPermissions_CommonTerms(permissions, null);
+    }
+
+    public void setPermissions_CommonTerms(String permissions, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("permissions", permissions);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsWebConfigCQ addOrderBy_Permissions_Asc() {
         regOBA("permissions");
         return this;
@@ -2820,6 +3352,28 @@ public abstract class BsWebConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setSortOrder_Exists() {
+        setSortOrder_Exists(null);
+    }
+
+    public void setSortOrder_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("sortOrder");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSortOrder_CommonTerms(Integer sortOrder) {
+        setSortOrder_CommonTerms(sortOrder, null);
+    }
+
+    public void setSortOrder_CommonTerms(Integer sortOrder, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("sortOrder", sortOrder);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsWebConfigCQ addOrderBy_SortOrder_Asc() {
         regOBA("sortOrder");
         return this;
@@ -2939,6 +3493,28 @@ public abstract class BsWebConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUpdatedBy_Wildcard(String updatedBy) {
+        setUpdatedBy_Wildcard(updatedBy, null);
+    }
+
+    public void setUpdatedBy_Wildcard(String updatedBy, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_Regexp(String updatedBy) {
+        setUpdatedBy_Regexp(updatedBy, null);
+    }
+
+    public void setUpdatedBy_Regexp(String updatedBy, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setUpdatedBy_GreaterThan(String updatedBy) {
         setUpdatedBy_GreaterThan(updatedBy, null);
     }
@@ -2983,6 +3559,28 @@ public abstract class BsWebConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUpdatedBy_Exists() {
+        setUpdatedBy_Exists(null);
+    }
+
+    public void setUpdatedBy_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("updatedBy");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedBy_CommonTerms(String updatedBy) {
+        setUpdatedBy_CommonTerms(updatedBy, null);
+    }
+
+    public void setUpdatedBy_CommonTerms(String updatedBy, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("updatedBy", updatedBy);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsWebConfigCQ addOrderBy_UpdatedBy_Asc() {
         regOBA("updatedBy");
         return this;
@@ -3135,6 +3733,28 @@ public abstract class BsWebConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUpdatedTime_Exists() {
+        setUpdatedTime_Exists(null);
+    }
+
+    public void setUpdatedTime_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("updatedTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedTime_CommonTerms(Long updatedTime) {
+        setUpdatedTime_CommonTerms(updatedTime, null);
+    }
+
+    public void setUpdatedTime_CommonTerms(Long updatedTime, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("updatedTime", updatedTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsWebConfigCQ addOrderBy_UpdatedTime_Asc() {
         regOBA("updatedTime");
         return this;
@@ -3254,6 +3874,28 @@ public abstract class BsWebConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUrls_Wildcard(String urls) {
+        setUrls_Wildcard(urls, null);
+    }
+
+    public void setUrls_Wildcard(String urls, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("urls", urls);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUrls_Regexp(String urls) {
+        setUrls_Regexp(urls, null);
+    }
+
+    public void setUrls_Regexp(String urls, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("urls", urls);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setUrls_GreaterThan(String urls) {
         setUrls_GreaterThan(urls, null);
     }
@@ -3298,6 +3940,28 @@ public abstract class BsWebConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUrls_Exists() {
+        setUrls_Exists(null);
+    }
+
+    public void setUrls_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("urls");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUrls_CommonTerms(String urls) {
+        setUrls_CommonTerms(urls, null);
+    }
+
+    public void setUrls_CommonTerms(String urls, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("urls", urls);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsWebConfigCQ addOrderBy_Urls_Asc() {
         regOBA("urls");
         return this;
@@ -3417,6 +4081,28 @@ public abstract class BsWebConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUserAgent_Wildcard(String userAgent) {
+        setUserAgent_Wildcard(userAgent, null);
+    }
+
+    public void setUserAgent_Wildcard(String userAgent, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("userAgent", userAgent);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUserAgent_Regexp(String userAgent) {
+        setUserAgent_Regexp(userAgent, null);
+    }
+
+    public void setUserAgent_Regexp(String userAgent, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("userAgent", userAgent);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setUserAgent_GreaterThan(String userAgent) {
         setUserAgent_GreaterThan(userAgent, null);
     }
@@ -3461,6 +4147,28 @@ public abstract class BsWebConfigCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUserAgent_Exists() {
+        setUserAgent_Exists(null);
+    }
+
+    public void setUserAgent_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("userAgent");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUserAgent_CommonTerms(String userAgent) {
+        setUserAgent_CommonTerms(userAgent, null);
+    }
+
+    public void setUserAgent_CommonTerms(String userAgent, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("userAgent", userAgent);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsWebConfigCQ addOrderBy_UserAgent_Asc() {
         regOBA("userAgent");
         return this;

src/main/java/org/codelibs/fess/es/config/cbean/cq/bs/BsWebConfigToLabelCQ.java

@@ -22,13 +22,17 @@ import org.codelibs.fess.es.config.allcommon.EsAbstractConditionQuery;
 import org.codelibs.fess.es.config.cbean.cq.WebConfigToLabelCQ;
 import org.dbflute.cbean.ckey.ConditionKey;
 import org.elasticsearch.index.query.BoolQueryBuilder;
+import org.elasticsearch.index.query.CommonTermsQueryBuilder;
+import org.elasticsearch.index.query.ExistsQueryBuilder;
 import org.elasticsearch.index.query.FuzzyQueryBuilder;
 import org.elasticsearch.index.query.IdsQueryBuilder;
 import org.elasticsearch.index.query.MatchQueryBuilder;
 import org.elasticsearch.index.query.PrefixQueryBuilder;
 import org.elasticsearch.index.query.RangeQueryBuilder;
+import org.elasticsearch.index.query.RegexpQueryBuilder;
 import org.elasticsearch.index.query.TermQueryBuilder;
 import org.elasticsearch.index.query.TermsQueryBuilder;
+import org.elasticsearch.index.query.WildcardQueryBuilder;
 
 /**
  * @author ESFlute (using FreeGen)
@@ -267,6 +271,28 @@ public abstract class BsWebConfigToLabelCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setLabelTypeId_Wildcard(String labelTypeId) {
+        setLabelTypeId_Wildcard(labelTypeId, null);
+    }
+
+    public void setLabelTypeId_Wildcard(String labelTypeId, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("labelTypeId", labelTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setLabelTypeId_Regexp(String labelTypeId) {
+        setLabelTypeId_Regexp(labelTypeId, null);
+    }
+
+    public void setLabelTypeId_Regexp(String labelTypeId, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("labelTypeId", labelTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setLabelTypeId_GreaterThan(String labelTypeId) {
         setLabelTypeId_GreaterThan(labelTypeId, null);
     }
@@ -311,6 +337,28 @@ public abstract class BsWebConfigToLabelCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setLabelTypeId_Exists() {
+        setLabelTypeId_Exists(null);
+    }
+
+    public void setLabelTypeId_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("labelTypeId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setLabelTypeId_CommonTerms(String labelTypeId) {
+        setLabelTypeId_CommonTerms(labelTypeId, null);
+    }
+
+    public void setLabelTypeId_CommonTerms(String labelTypeId, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("labelTypeId", labelTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsWebConfigToLabelCQ addOrderBy_LabelTypeId_Asc() {
         regOBA("labelTypeId");
         return this;
@@ -430,6 +478,28 @@ public abstract class BsWebConfigToLabelCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setWebConfigId_Wildcard(String webConfigId) {
+        setWebConfigId_Wildcard(webConfigId, null);
+    }
+
+    public void setWebConfigId_Wildcard(String webConfigId, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("webConfigId", webConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setWebConfigId_Regexp(String webConfigId) {
+        setWebConfigId_Regexp(webConfigId, null);
+    }
+
+    public void setWebConfigId_Regexp(String webConfigId, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("webConfigId", webConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setWebConfigId_GreaterThan(String webConfigId) {
         setWebConfigId_GreaterThan(webConfigId, null);
     }
@@ -474,6 +544,28 @@ public abstract class BsWebConfigToLabelCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setWebConfigId_Exists() {
+        setWebConfigId_Exists(null);
+    }
+
+    public void setWebConfigId_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("webConfigId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setWebConfigId_CommonTerms(String webConfigId) {
+        setWebConfigId_CommonTerms(webConfigId, null);
+    }
+
+    public void setWebConfigId_CommonTerms(String webConfigId, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("webConfigId", webConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsWebConfigToLabelCQ addOrderBy_WebConfigId_Asc() {
         regOBA("webConfigId");
         return this;

src/main/java/org/codelibs/fess/es/config/cbean/cq/bs/BsWebConfigToRoleCQ.java

@@ -22,13 +22,17 @@ import org.codelibs.fess.es.config.allcommon.EsAbstractConditionQuery;
 import org.codelibs.fess.es.config.cbean.cq.WebConfigToRoleCQ;
 import org.dbflute.cbean.ckey.ConditionKey;
 import org.elasticsearch.index.query.BoolQueryBuilder;
+import org.elasticsearch.index.query.CommonTermsQueryBuilder;
+import org.elasticsearch.index.query.ExistsQueryBuilder;
 import org.elasticsearch.index.query.FuzzyQueryBuilder;
 import org.elasticsearch.index.query.IdsQueryBuilder;
 import org.elasticsearch.index.query.MatchQueryBuilder;
 import org.elasticsearch.index.query.PrefixQueryBuilder;
 import org.elasticsearch.index.query.RangeQueryBuilder;
+import org.elasticsearch.index.query.RegexpQueryBuilder;
 import org.elasticsearch.index.query.TermQueryBuilder;
 import org.elasticsearch.index.query.TermsQueryBuilder;
+import org.elasticsearch.index.query.WildcardQueryBuilder;
 
 /**
  * @author ESFlute (using FreeGen)
@@ -267,6 +271,28 @@ public abstract class BsWebConfigToRoleCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setRoleTypeId_Wildcard(String roleTypeId) {
+        setRoleTypeId_Wildcard(roleTypeId, null);
+    }
+
+    public void setRoleTypeId_Wildcard(String roleTypeId, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("roleTypeId", roleTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRoleTypeId_Regexp(String roleTypeId) {
+        setRoleTypeId_Regexp(roleTypeId, null);
+    }
+
+    public void setRoleTypeId_Regexp(String roleTypeId, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("roleTypeId", roleTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setRoleTypeId_GreaterThan(String roleTypeId) {
         setRoleTypeId_GreaterThan(roleTypeId, null);
     }
@@ -311,6 +337,28 @@ public abstract class BsWebConfigToRoleCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setRoleTypeId_Exists() {
+        setRoleTypeId_Exists(null);
+    }
+
+    public void setRoleTypeId_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("roleTypeId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRoleTypeId_CommonTerms(String roleTypeId) {
+        setRoleTypeId_CommonTerms(roleTypeId, null);
+    }
+
+    public void setRoleTypeId_CommonTerms(String roleTypeId, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("roleTypeId", roleTypeId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsWebConfigToRoleCQ addOrderBy_RoleTypeId_Asc() {
         regOBA("roleTypeId");
         return this;
@@ -430,6 +478,28 @@ public abstract class BsWebConfigToRoleCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setWebConfigId_Wildcard(String webConfigId) {
+        setWebConfigId_Wildcard(webConfigId, null);
+    }
+
+    public void setWebConfigId_Wildcard(String webConfigId, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("webConfigId", webConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setWebConfigId_Regexp(String webConfigId) {
+        setWebConfigId_Regexp(webConfigId, null);
+    }
+
+    public void setWebConfigId_Regexp(String webConfigId, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("webConfigId", webConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setWebConfigId_GreaterThan(String webConfigId) {
         setWebConfigId_GreaterThan(webConfigId, null);
     }
@@ -474,6 +544,28 @@ public abstract class BsWebConfigToRoleCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setWebConfigId_Exists() {
+        setWebConfigId_Exists(null);
+    }
+
+    public void setWebConfigId_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("webConfigId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setWebConfigId_CommonTerms(String webConfigId) {
+        setWebConfigId_CommonTerms(webConfigId, null);
+    }
+
+    public void setWebConfigId_CommonTerms(String webConfigId, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("webConfigId", webConfigId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsWebConfigToRoleCQ addOrderBy_WebConfigId_Asc() {
         regOBA("webConfigId");
         return this;

src/main/java/org/codelibs/fess/es/log/allcommon/EsAbstractConditionQuery.java

@@ -33,17 +33,22 @@ import org.dbflute.dbmeta.name.ColumnSqlName;
 import org.dbflute.exception.InvalidQueryRegisteredException;
 import org.dbflute.util.Srl;
 import org.elasticsearch.index.query.BoolQueryBuilder;
+import org.elasticsearch.index.query.CommonTermsQueryBuilder;
+import org.elasticsearch.index.query.ExistsQueryBuilder;
 import org.elasticsearch.index.query.FuzzyQueryBuilder;
 import org.elasticsearch.index.query.IdsQueryBuilder;
 import org.elasticsearch.index.query.MatchAllQueryBuilder;
 import org.elasticsearch.index.query.MatchQueryBuilder;
+import org.elasticsearch.index.query.MoreLikeThisQueryBuilder;
 import org.elasticsearch.index.query.PrefixQueryBuilder;
 import org.elasticsearch.index.query.QueryBuilder;
 import org.elasticsearch.index.query.QueryBuilders;
 import org.elasticsearch.index.query.QueryStringQueryBuilder;
 import org.elasticsearch.index.query.RangeQueryBuilder;
+import org.elasticsearch.index.query.RegexpQueryBuilder;
 import org.elasticsearch.index.query.TermQueryBuilder;
 import org.elasticsearch.index.query.TermsQueryBuilder;
+import org.elasticsearch.index.query.WildcardQueryBuilder;
 import org.elasticsearch.search.sort.FieldSortBuilder;
 import org.elasticsearch.search.sort.SortBuilders;
 import org.elasticsearch.search.sort.SortOrder;
@@ -257,6 +262,39 @@ public abstract class EsAbstractConditionQuery implements ConditionQuery {
         }
     }
 
+    protected ExistsQueryBuilder regExistsQ(String name) {
+        ExistsQueryBuilder existsQuery = QueryBuilders.existsQuery(name);
+        regQ(existsQuery);
+        return existsQuery;
+    }
+
+    protected WildcardQueryBuilder regWildcardQ(String name, String wildcard) {
+        checkEsInvalidQuery(name, wildcard);
+        WildcardQueryBuilder wildcardQuery = QueryBuilders.wildcardQuery(name, wildcard);
+        regQ(wildcardQuery);
+        return wildcardQuery;
+    }
+
+    protected RegexpQueryBuilder regRegexpQ(String name, String regexp) {
+        checkEsInvalidQuery(name, regexp);
+        RegexpQueryBuilder regexpQuery = QueryBuilders.regexpQuery(name, regexp);
+        regQ(regexpQuery);
+        return regexpQuery;
+    }
+
+    protected CommonTermsQueryBuilder regCommonTermsQ(String name, Object text) {
+        checkEsInvalidQuery(name, text);
+        CommonTermsQueryBuilder commonTermsQuery = QueryBuilders.commonTermsQuery(name, text);
+        regQ(commonTermsQuery);
+        return commonTermsQuery;
+    }
+
+    protected MoreLikeThisQueryBuilder regMoreLikeThisQueryQ(String name) {
+        MoreLikeThisQueryBuilder moreLikeThisQuery = QueryBuilders.moreLikeThisQuery(name);
+        regQ(moreLikeThisQuery);
+        return moreLikeThisQuery;
+    }
+
     protected void regQ(QueryBuilder builder) {
         assertObjectNotNull("builder", builder);
         if (queryBuilderList == null) {

src/main/java/org/codelibs/fess/es/log/cbean/cq/bs/BsClickLogCQ.java

@@ -22,13 +22,17 @@ import org.codelibs.fess.es.log.allcommon.EsAbstractConditionQuery;
 import org.codelibs.fess.es.log.cbean.cq.ClickLogCQ;
 import org.dbflute.cbean.ckey.ConditionKey;
 import org.elasticsearch.index.query.BoolQueryBuilder;
+import org.elasticsearch.index.query.CommonTermsQueryBuilder;
+import org.elasticsearch.index.query.ExistsQueryBuilder;
 import org.elasticsearch.index.query.FuzzyQueryBuilder;
 import org.elasticsearch.index.query.IdsQueryBuilder;
 import org.elasticsearch.index.query.MatchQueryBuilder;
 import org.elasticsearch.index.query.PrefixQueryBuilder;
 import org.elasticsearch.index.query.RangeQueryBuilder;
+import org.elasticsearch.index.query.RegexpQueryBuilder;
 import org.elasticsearch.index.query.TermQueryBuilder;
 import org.elasticsearch.index.query.TermsQueryBuilder;
+import org.elasticsearch.index.query.WildcardQueryBuilder;
 
 /**
  * @author ESFlute (using FreeGen)
@@ -300,6 +304,28 @@ public abstract class BsClickLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setQueryRequestedAt_Exists() {
+        setQueryRequestedAt_Exists(null);
+    }
+
+    public void setQueryRequestedAt_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("queryRequestedAt");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setQueryRequestedAt_CommonTerms(LocalDateTime queryRequestedAt) {
+        setQueryRequestedAt_CommonTerms(queryRequestedAt, null);
+    }
+
+    public void setQueryRequestedAt_CommonTerms(LocalDateTime queryRequestedAt, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("queryRequestedAt", queryRequestedAt);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsClickLogCQ addOrderBy_QueryRequestedAt_Asc() {
         regOBA("queryRequestedAt");
         return this;
@@ -452,6 +478,28 @@ public abstract class BsClickLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setRequestedAt_Exists() {
+        setRequestedAt_Exists(null);
+    }
+
+    public void setRequestedAt_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("requestedAt");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRequestedAt_CommonTerms(LocalDateTime requestedAt) {
+        setRequestedAt_CommonTerms(requestedAt, null);
+    }
+
+    public void setRequestedAt_CommonTerms(LocalDateTime requestedAt, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("requestedAt", requestedAt);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsClickLogCQ addOrderBy_RequestedAt_Asc() {
         regOBA("requestedAt");
         return this;
@@ -571,6 +619,28 @@ public abstract class BsClickLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setQueryId_Wildcard(String queryId) {
+        setQueryId_Wildcard(queryId, null);
+    }
+
+    public void setQueryId_Wildcard(String queryId, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("queryId", queryId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setQueryId_Regexp(String queryId) {
+        setQueryId_Regexp(queryId, null);
+    }
+
+    public void setQueryId_Regexp(String queryId, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("queryId", queryId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setQueryId_GreaterThan(String queryId) {
         setQueryId_GreaterThan(queryId, null);
     }
@@ -615,6 +685,28 @@ public abstract class BsClickLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setQueryId_Exists() {
+        setQueryId_Exists(null);
+    }
+
+    public void setQueryId_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("queryId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setQueryId_CommonTerms(String queryId) {
+        setQueryId_CommonTerms(queryId, null);
+    }
+
+    public void setQueryId_CommonTerms(String queryId, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("queryId", queryId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsClickLogCQ addOrderBy_QueryId_Asc() {
         regOBA("queryId");
         return this;
@@ -734,6 +826,28 @@ public abstract class BsClickLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setDocId_Wildcard(String docId) {
+        setDocId_Wildcard(docId, null);
+    }
+
+    public void setDocId_Wildcard(String docId, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("docId", docId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setDocId_Regexp(String docId) {
+        setDocId_Regexp(docId, null);
+    }
+
+    public void setDocId_Regexp(String docId, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("docId", docId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setDocId_GreaterThan(String docId) {
         setDocId_GreaterThan(docId, null);
     }
@@ -778,6 +892,28 @@ public abstract class BsClickLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setDocId_Exists() {
+        setDocId_Exists(null);
+    }
+
+    public void setDocId_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("docId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setDocId_CommonTerms(String docId) {
+        setDocId_CommonTerms(docId, null);
+    }
+
+    public void setDocId_CommonTerms(String docId, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("docId", docId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsClickLogCQ addOrderBy_DocId_Asc() {
         regOBA("docId");
         return this;
@@ -897,6 +1033,28 @@ public abstract class BsClickLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUserSessionId_Wildcard(String userSessionId) {
+        setUserSessionId_Wildcard(userSessionId, null);
+    }
+
+    public void setUserSessionId_Wildcard(String userSessionId, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("userSessionId", userSessionId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUserSessionId_Regexp(String userSessionId) {
+        setUserSessionId_Regexp(userSessionId, null);
+    }
+
+    public void setUserSessionId_Regexp(String userSessionId, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("userSessionId", userSessionId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setUserSessionId_GreaterThan(String userSessionId) {
         setUserSessionId_GreaterThan(userSessionId, null);
     }
@@ -941,6 +1099,28 @@ public abstract class BsClickLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUserSessionId_Exists() {
+        setUserSessionId_Exists(null);
+    }
+
+    public void setUserSessionId_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("userSessionId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUserSessionId_CommonTerms(String userSessionId) {
+        setUserSessionId_CommonTerms(userSessionId, null);
+    }
+
+    public void setUserSessionId_CommonTerms(String userSessionId, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("userSessionId", userSessionId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsClickLogCQ addOrderBy_UserSessionId_Asc() {
         regOBA("userSessionId");
         return this;
@@ -1060,6 +1240,28 @@ public abstract class BsClickLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUrl_Wildcard(String url) {
+        setUrl_Wildcard(url, null);
+    }
+
+    public void setUrl_Wildcard(String url, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("url", url);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUrl_Regexp(String url) {
+        setUrl_Regexp(url, null);
+    }
+
+    public void setUrl_Regexp(String url, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("url", url);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setUrl_GreaterThan(String url) {
         setUrl_GreaterThan(url, null);
     }
@@ -1104,6 +1306,28 @@ public abstract class BsClickLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUrl_Exists() {
+        setUrl_Exists(null);
+    }
+
+    public void setUrl_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("url");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUrl_CommonTerms(String url) {
+        setUrl_CommonTerms(url, null);
+    }
+
+    public void setUrl_CommonTerms(String url, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("url", url);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsClickLogCQ addOrderBy_Url_Asc() {
         regOBA("url");
         return this;
@@ -1256,6 +1480,28 @@ public abstract class BsClickLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setOrder_Exists() {
+        setOrder_Exists(null);
+    }
+
+    public void setOrder_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("order");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setOrder_CommonTerms(Integer order) {
+        setOrder_CommonTerms(order, null);
+    }
+
+    public void setOrder_CommonTerms(Integer order, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("order", order);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsClickLogCQ addOrderBy_Order_Asc() {
         regOBA("order");
         return this;

src/main/java/org/codelibs/fess/es/log/cbean/cq/bs/BsFavoriteLogCQ.java

@@ -22,13 +22,17 @@ import org.codelibs.fess.es.log.allcommon.EsAbstractConditionQuery;
 import org.codelibs.fess.es.log.cbean.cq.FavoriteLogCQ;
 import org.dbflute.cbean.ckey.ConditionKey;
 import org.elasticsearch.index.query.BoolQueryBuilder;
+import org.elasticsearch.index.query.CommonTermsQueryBuilder;
+import org.elasticsearch.index.query.ExistsQueryBuilder;
 import org.elasticsearch.index.query.FuzzyQueryBuilder;
 import org.elasticsearch.index.query.IdsQueryBuilder;
 import org.elasticsearch.index.query.MatchQueryBuilder;
 import org.elasticsearch.index.query.PrefixQueryBuilder;
 import org.elasticsearch.index.query.RangeQueryBuilder;
+import org.elasticsearch.index.query.RegexpQueryBuilder;
 import org.elasticsearch.index.query.TermQueryBuilder;
 import org.elasticsearch.index.query.TermsQueryBuilder;
+import org.elasticsearch.index.query.WildcardQueryBuilder;
 
 /**
  * @author ESFlute (using FreeGen)
@@ -300,6 +304,28 @@ public abstract class BsFavoriteLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setCreatedAt_Exists() {
+        setCreatedAt_Exists(null);
+    }
+
+    public void setCreatedAt_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("createdAt");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedAt_CommonTerms(LocalDateTime createdAt) {
+        setCreatedAt_CommonTerms(createdAt, null);
+    }
+
+    public void setCreatedAt_CommonTerms(LocalDateTime createdAt, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("createdAt", createdAt);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsFavoriteLogCQ addOrderBy_CreatedAt_Asc() {
         regOBA("createdAt");
         return this;
@@ -419,6 +445,28 @@ public abstract class BsFavoriteLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUrl_Wildcard(String url) {
+        setUrl_Wildcard(url, null);
+    }
+
+    public void setUrl_Wildcard(String url, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("url", url);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUrl_Regexp(String url) {
+        setUrl_Regexp(url, null);
+    }
+
+    public void setUrl_Regexp(String url, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("url", url);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setUrl_GreaterThan(String url) {
         setUrl_GreaterThan(url, null);
     }
@@ -463,6 +511,28 @@ public abstract class BsFavoriteLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUrl_Exists() {
+        setUrl_Exists(null);
+    }
+
+    public void setUrl_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("url");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUrl_CommonTerms(String url) {
+        setUrl_CommonTerms(url, null);
+    }
+
+    public void setUrl_CommonTerms(String url, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("url", url);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsFavoriteLogCQ addOrderBy_Url_Asc() {
         regOBA("url");
         return this;
@@ -582,6 +652,28 @@ public abstract class BsFavoriteLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setDocId_Wildcard(String docId) {
+        setDocId_Wildcard(docId, null);
+    }
+
+    public void setDocId_Wildcard(String docId, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("docId", docId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setDocId_Regexp(String docId) {
+        setDocId_Regexp(docId, null);
+    }
+
+    public void setDocId_Regexp(String docId, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("docId", docId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setDocId_GreaterThan(String docId) {
         setDocId_GreaterThan(docId, null);
     }
@@ -626,6 +718,28 @@ public abstract class BsFavoriteLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setDocId_Exists() {
+        setDocId_Exists(null);
+    }
+
+    public void setDocId_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("docId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setDocId_CommonTerms(String docId) {
+        setDocId_CommonTerms(docId, null);
+    }
+
+    public void setDocId_CommonTerms(String docId, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("docId", docId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsFavoriteLogCQ addOrderBy_DocId_Asc() {
         regOBA("docId");
         return this;
@@ -745,6 +859,28 @@ public abstract class BsFavoriteLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setQueryId_Wildcard(String queryId) {
+        setQueryId_Wildcard(queryId, null);
+    }
+
+    public void setQueryId_Wildcard(String queryId, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("queryId", queryId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setQueryId_Regexp(String queryId) {
+        setQueryId_Regexp(queryId, null);
+    }
+
+    public void setQueryId_Regexp(String queryId, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("queryId", queryId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setQueryId_GreaterThan(String queryId) {
         setQueryId_GreaterThan(queryId, null);
     }
@@ -789,6 +925,28 @@ public abstract class BsFavoriteLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setQueryId_Exists() {
+        setQueryId_Exists(null);
+    }
+
+    public void setQueryId_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("queryId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setQueryId_CommonTerms(String queryId) {
+        setQueryId_CommonTerms(queryId, null);
+    }
+
+    public void setQueryId_CommonTerms(String queryId, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("queryId", queryId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsFavoriteLogCQ addOrderBy_QueryId_Asc() {
         regOBA("queryId");
         return this;
@@ -908,6 +1066,28 @@ public abstract class BsFavoriteLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUserInfoId_Wildcard(String userInfoId) {
+        setUserInfoId_Wildcard(userInfoId, null);
+    }
+
+    public void setUserInfoId_Wildcard(String userInfoId, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("userInfoId", userInfoId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUserInfoId_Regexp(String userInfoId) {
+        setUserInfoId_Regexp(userInfoId, null);
+    }
+
+    public void setUserInfoId_Regexp(String userInfoId, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("userInfoId", userInfoId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setUserInfoId_GreaterThan(String userInfoId) {
         setUserInfoId_GreaterThan(userInfoId, null);
     }
@@ -952,6 +1132,28 @@ public abstract class BsFavoriteLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUserInfoId_Exists() {
+        setUserInfoId_Exists(null);
+    }
+
+    public void setUserInfoId_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("userInfoId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUserInfoId_CommonTerms(String userInfoId) {
+        setUserInfoId_CommonTerms(userInfoId, null);
+    }
+
+    public void setUserInfoId_CommonTerms(String userInfoId, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("userInfoId", userInfoId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsFavoriteLogCQ addOrderBy_UserInfoId_Asc() {
         regOBA("userInfoId");
         return this;

src/main/java/org/codelibs/fess/es/log/cbean/cq/bs/BsSearchFieldLogCQ.java

@@ -22,13 +22,17 @@ import org.codelibs.fess.es.log.allcommon.EsAbstractConditionQuery;
 import org.codelibs.fess.es.log.cbean.cq.SearchFieldLogCQ;
 import org.dbflute.cbean.ckey.ConditionKey;
 import org.elasticsearch.index.query.BoolQueryBuilder;
+import org.elasticsearch.index.query.CommonTermsQueryBuilder;
+import org.elasticsearch.index.query.ExistsQueryBuilder;
 import org.elasticsearch.index.query.FuzzyQueryBuilder;
 import org.elasticsearch.index.query.IdsQueryBuilder;
 import org.elasticsearch.index.query.MatchQueryBuilder;
 import org.elasticsearch.index.query.PrefixQueryBuilder;
 import org.elasticsearch.index.query.RangeQueryBuilder;
+import org.elasticsearch.index.query.RegexpQueryBuilder;
 import org.elasticsearch.index.query.TermQueryBuilder;
 import org.elasticsearch.index.query.TermsQueryBuilder;
+import org.elasticsearch.index.query.WildcardQueryBuilder;
 
 /**
  * @author ESFlute (using FreeGen)
@@ -267,6 +271,28 @@ public abstract class BsSearchFieldLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setName_Wildcard(String name) {
+        setName_Wildcard(name, null);
+    }
+
+    public void setName_Wildcard(String name, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("name", name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_Regexp(String name) {
+        setName_Regexp(name, null);
+    }
+
+    public void setName_Regexp(String name, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("name", name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setName_GreaterThan(String name) {
         setName_GreaterThan(name, null);
     }
@@ -311,6 +337,28 @@ public abstract class BsSearchFieldLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setName_Exists() {
+        setName_Exists(null);
+    }
+
+    public void setName_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("name");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_CommonTerms(String name) {
+        setName_CommonTerms(name, null);
+    }
+
+    public void setName_CommonTerms(String name, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("name", name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsSearchFieldLogCQ addOrderBy_Name_Asc() {
         regOBA("name");
         return this;
@@ -430,6 +478,28 @@ public abstract class BsSearchFieldLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setSearchLogId_Wildcard(String searchLogId) {
+        setSearchLogId_Wildcard(searchLogId, null);
+    }
+
+    public void setSearchLogId_Wildcard(String searchLogId, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("searchLogId", searchLogId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSearchLogId_Regexp(String searchLogId) {
+        setSearchLogId_Regexp(searchLogId, null);
+    }
+
+    public void setSearchLogId_Regexp(String searchLogId, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("searchLogId", searchLogId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setSearchLogId_GreaterThan(String searchLogId) {
         setSearchLogId_GreaterThan(searchLogId, null);
     }
@@ -474,6 +544,28 @@ public abstract class BsSearchFieldLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setSearchLogId_Exists() {
+        setSearchLogId_Exists(null);
+    }
+
+    public void setSearchLogId_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("searchLogId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSearchLogId_CommonTerms(String searchLogId) {
+        setSearchLogId_CommonTerms(searchLogId, null);
+    }
+
+    public void setSearchLogId_CommonTerms(String searchLogId, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("searchLogId", searchLogId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsSearchFieldLogCQ addOrderBy_SearchLogId_Asc() {
         regOBA("searchLogId");
         return this;
@@ -593,6 +685,28 @@ public abstract class BsSearchFieldLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setValue_Wildcard(String value) {
+        setValue_Wildcard(value, null);
+    }
+
+    public void setValue_Wildcard(String value, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("value", value);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setValue_Regexp(String value) {
+        setValue_Regexp(value, null);
+    }
+
+    public void setValue_Regexp(String value, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("value", value);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setValue_GreaterThan(String value) {
         setValue_GreaterThan(value, null);
     }
@@ -637,6 +751,28 @@ public abstract class BsSearchFieldLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setValue_Exists() {
+        setValue_Exists(null);
+    }
+
+    public void setValue_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("value");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setValue_CommonTerms(String value) {
+        setValue_CommonTerms(value, null);
+    }
+
+    public void setValue_CommonTerms(String value, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("value", value);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsSearchFieldLogCQ addOrderBy_Value_Asc() {
         regOBA("value");
         return this;

src/main/java/org/codelibs/fess/es/log/cbean/cq/bs/BsSearchLogCQ.java

@@ -22,13 +22,17 @@ import org.codelibs.fess.es.log.allcommon.EsAbstractConditionQuery;
 import org.codelibs.fess.es.log.cbean.cq.SearchLogCQ;
 import org.dbflute.cbean.ckey.ConditionKey;
 import org.elasticsearch.index.query.BoolQueryBuilder;
+import org.elasticsearch.index.query.CommonTermsQueryBuilder;
+import org.elasticsearch.index.query.ExistsQueryBuilder;
 import org.elasticsearch.index.query.FuzzyQueryBuilder;
 import org.elasticsearch.index.query.IdsQueryBuilder;
 import org.elasticsearch.index.query.MatchQueryBuilder;
 import org.elasticsearch.index.query.PrefixQueryBuilder;
 import org.elasticsearch.index.query.RangeQueryBuilder;
+import org.elasticsearch.index.query.RegexpQueryBuilder;
 import org.elasticsearch.index.query.TermQueryBuilder;
 import org.elasticsearch.index.query.TermsQueryBuilder;
+import org.elasticsearch.index.query.WildcardQueryBuilder;
 
 /**
  * @author ESFlute (using FreeGen)
@@ -267,6 +271,28 @@ public abstract class BsSearchLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setAccessType_Wildcard(String accessType) {
+        setAccessType_Wildcard(accessType, null);
+    }
+
+    public void setAccessType_Wildcard(String accessType, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("accessType", accessType);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setAccessType_Regexp(String accessType) {
+        setAccessType_Regexp(accessType, null);
+    }
+
+    public void setAccessType_Regexp(String accessType, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("accessType", accessType);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setAccessType_GreaterThan(String accessType) {
         setAccessType_GreaterThan(accessType, null);
     }
@@ -311,6 +337,28 @@ public abstract class BsSearchLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setAccessType_Exists() {
+        setAccessType_Exists(null);
+    }
+
+    public void setAccessType_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("accessType");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setAccessType_CommonTerms(String accessType) {
+        setAccessType_CommonTerms(accessType, null);
+    }
+
+    public void setAccessType_CommonTerms(String accessType, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("accessType", accessType);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsSearchLogCQ addOrderBy_AccessType_Asc() {
         regOBA("accessType");
         return this;
@@ -430,6 +478,28 @@ public abstract class BsSearchLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUser_Wildcard(String user) {
+        setUser_Wildcard(user, null);
+    }
+
+    public void setUser_Wildcard(String user, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("user", user);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUser_Regexp(String user) {
+        setUser_Regexp(user, null);
+    }
+
+    public void setUser_Regexp(String user, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("user", user);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setUser_GreaterThan(String user) {
         setUser_GreaterThan(user, null);
     }
@@ -474,6 +544,28 @@ public abstract class BsSearchLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUser_Exists() {
+        setUser_Exists(null);
+    }
+
+    public void setUser_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("user");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUser_CommonTerms(String user) {
+        setUser_CommonTerms(user, null);
+    }
+
+    public void setUser_CommonTerms(String user, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("user", user);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsSearchLogCQ addOrderBy_User_Asc() {
         regOBA("user");
         return this;
@@ -593,6 +685,28 @@ public abstract class BsSearchLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setRoles_Wildcard(String roles) {
+        setRoles_Wildcard(roles, null);
+    }
+
+    public void setRoles_Wildcard(String roles, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("roles", roles);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRoles_Regexp(String roles) {
+        setRoles_Regexp(roles, null);
+    }
+
+    public void setRoles_Regexp(String roles, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("roles", roles);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setRoles_GreaterThan(String roles) {
         setRoles_GreaterThan(roles, null);
     }
@@ -637,6 +751,28 @@ public abstract class BsSearchLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setRoles_Exists() {
+        setRoles_Exists(null);
+    }
+
+    public void setRoles_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("roles");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRoles_CommonTerms(String roles) {
+        setRoles_CommonTerms(roles, null);
+    }
+
+    public void setRoles_CommonTerms(String roles, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("roles", roles);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsSearchLogCQ addOrderBy_Roles_Asc() {
         regOBA("roles");
         return this;
@@ -756,6 +892,28 @@ public abstract class BsSearchLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setQueryId_Wildcard(String queryId) {
+        setQueryId_Wildcard(queryId, null);
+    }
+
+    public void setQueryId_Wildcard(String queryId, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("queryId", queryId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setQueryId_Regexp(String queryId) {
+        setQueryId_Regexp(queryId, null);
+    }
+
+    public void setQueryId_Regexp(String queryId, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("queryId", queryId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setQueryId_GreaterThan(String queryId) {
         setQueryId_GreaterThan(queryId, null);
     }
@@ -800,6 +958,28 @@ public abstract class BsSearchLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setQueryId_Exists() {
+        setQueryId_Exists(null);
+    }
+
+    public void setQueryId_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("queryId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setQueryId_CommonTerms(String queryId) {
+        setQueryId_CommonTerms(queryId, null);
+    }
+
+    public void setQueryId_CommonTerms(String queryId, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("queryId", queryId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsSearchLogCQ addOrderBy_QueryId_Asc() {
         regOBA("queryId");
         return this;
@@ -919,6 +1099,28 @@ public abstract class BsSearchLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setClientIp_Wildcard(String clientIp) {
+        setClientIp_Wildcard(clientIp, null);
+    }
+
+    public void setClientIp_Wildcard(String clientIp, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("clientIp", clientIp);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setClientIp_Regexp(String clientIp) {
+        setClientIp_Regexp(clientIp, null);
+    }
+
+    public void setClientIp_Regexp(String clientIp, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("clientIp", clientIp);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setClientIp_GreaterThan(String clientIp) {
         setClientIp_GreaterThan(clientIp, null);
     }
@@ -963,6 +1165,28 @@ public abstract class BsSearchLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setClientIp_Exists() {
+        setClientIp_Exists(null);
+    }
+
+    public void setClientIp_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("clientIp");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setClientIp_CommonTerms(String clientIp) {
+        setClientIp_CommonTerms(clientIp, null);
+    }
+
+    public void setClientIp_CommonTerms(String clientIp, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("clientIp", clientIp);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsSearchLogCQ addOrderBy_ClientIp_Asc() {
         regOBA("clientIp");
         return this;
@@ -1115,6 +1339,28 @@ public abstract class BsSearchLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setHitCount_Exists() {
+        setHitCount_Exists(null);
+    }
+
+    public void setHitCount_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("hitCount");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setHitCount_CommonTerms(Long hitCount) {
+        setHitCount_CommonTerms(hitCount, null);
+    }
+
+    public void setHitCount_CommonTerms(Long hitCount, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("hitCount", hitCount);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsSearchLogCQ addOrderBy_HitCount_Asc() {
         regOBA("hitCount");
         return this;
@@ -1267,6 +1513,28 @@ public abstract class BsSearchLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setQueryOffset_Exists() {
+        setQueryOffset_Exists(null);
+    }
+
+    public void setQueryOffset_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("queryOffset");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setQueryOffset_CommonTerms(Integer queryOffset) {
+        setQueryOffset_CommonTerms(queryOffset, null);
+    }
+
+    public void setQueryOffset_CommonTerms(Integer queryOffset, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("queryOffset", queryOffset);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsSearchLogCQ addOrderBy_QueryOffset_Asc() {
         regOBA("queryOffset");
         return this;
@@ -1419,6 +1687,28 @@ public abstract class BsSearchLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setQueryPageSize_Exists() {
+        setQueryPageSize_Exists(null);
+    }
+
+    public void setQueryPageSize_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("queryPageSize");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setQueryPageSize_CommonTerms(Integer queryPageSize) {
+        setQueryPageSize_CommonTerms(queryPageSize, null);
+    }
+
+    public void setQueryPageSize_CommonTerms(Integer queryPageSize, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("queryPageSize", queryPageSize);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsSearchLogCQ addOrderBy_QueryPageSize_Asc() {
         regOBA("queryPageSize");
         return this;
@@ -1538,6 +1828,28 @@ public abstract class BsSearchLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setReferer_Wildcard(String referer) {
+        setReferer_Wildcard(referer, null);
+    }
+
+    public void setReferer_Wildcard(String referer, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("referer", referer);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setReferer_Regexp(String referer) {
+        setReferer_Regexp(referer, null);
+    }
+
+    public void setReferer_Regexp(String referer, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("referer", referer);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setReferer_GreaterThan(String referer) {
         setReferer_GreaterThan(referer, null);
     }
@@ -1582,6 +1894,28 @@ public abstract class BsSearchLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setReferer_Exists() {
+        setReferer_Exists(null);
+    }
+
+    public void setReferer_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("referer");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setReferer_CommonTerms(String referer) {
+        setReferer_CommonTerms(referer, null);
+    }
+
+    public void setReferer_CommonTerms(String referer, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("referer", referer);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsSearchLogCQ addOrderBy_Referer_Asc() {
         regOBA("referer");
         return this;
@@ -1734,6 +2068,28 @@ public abstract class BsSearchLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setRequestedAt_Exists() {
+        setRequestedAt_Exists(null);
+    }
+
+    public void setRequestedAt_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("requestedAt");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setRequestedAt_CommonTerms(LocalDateTime requestedAt) {
+        setRequestedAt_CommonTerms(requestedAt, null);
+    }
+
+    public void setRequestedAt_CommonTerms(LocalDateTime requestedAt, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("requestedAt", requestedAt);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsSearchLogCQ addOrderBy_RequestedAt_Asc() {
         regOBA("requestedAt");
         return this;
@@ -1886,6 +2242,28 @@ public abstract class BsSearchLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setResponseTime_Exists() {
+        setResponseTime_Exists(null);
+    }
+
+    public void setResponseTime_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("responseTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setResponseTime_CommonTerms(Long responseTime) {
+        setResponseTime_CommonTerms(responseTime, null);
+    }
+
+    public void setResponseTime_CommonTerms(Long responseTime, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("responseTime", responseTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsSearchLogCQ addOrderBy_ResponseTime_Asc() {
         regOBA("responseTime");
         return this;
@@ -2038,6 +2416,28 @@ public abstract class BsSearchLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setQueryTime_Exists() {
+        setQueryTime_Exists(null);
+    }
+
+    public void setQueryTime_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("queryTime");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setQueryTime_CommonTerms(Long queryTime) {
+        setQueryTime_CommonTerms(queryTime, null);
+    }
+
+    public void setQueryTime_CommonTerms(Long queryTime, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("queryTime", queryTime);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsSearchLogCQ addOrderBy_QueryTime_Asc() {
         regOBA("queryTime");
         return this;
@@ -2157,6 +2557,28 @@ public abstract class BsSearchLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setSearchWord_Wildcard(String searchWord) {
+        setSearchWord_Wildcard(searchWord, null);
+    }
+
+    public void setSearchWord_Wildcard(String searchWord, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("searchWord", searchWord);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSearchWord_Regexp(String searchWord) {
+        setSearchWord_Regexp(searchWord, null);
+    }
+
+    public void setSearchWord_Regexp(String searchWord, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("searchWord", searchWord);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setSearchWord_GreaterThan(String searchWord) {
         setSearchWord_GreaterThan(searchWord, null);
     }
@@ -2201,6 +2623,28 @@ public abstract class BsSearchLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setSearchWord_Exists() {
+        setSearchWord_Exists(null);
+    }
+
+    public void setSearchWord_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("searchWord");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setSearchWord_CommonTerms(String searchWord) {
+        setSearchWord_CommonTerms(searchWord, null);
+    }
+
+    public void setSearchWord_CommonTerms(String searchWord, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("searchWord", searchWord);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsSearchLogCQ addOrderBy_SearchWord_Asc() {
         regOBA("searchWord");
         return this;
@@ -2320,6 +2764,28 @@ public abstract class BsSearchLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUserAgent_Wildcard(String userAgent) {
+        setUserAgent_Wildcard(userAgent, null);
+    }
+
+    public void setUserAgent_Wildcard(String userAgent, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("userAgent", userAgent);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUserAgent_Regexp(String userAgent) {
+        setUserAgent_Regexp(userAgent, null);
+    }
+
+    public void setUserAgent_Regexp(String userAgent, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("userAgent", userAgent);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setUserAgent_GreaterThan(String userAgent) {
         setUserAgent_GreaterThan(userAgent, null);
     }
@@ -2364,6 +2830,28 @@ public abstract class BsSearchLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUserAgent_Exists() {
+        setUserAgent_Exists(null);
+    }
+
+    public void setUserAgent_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("userAgent");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUserAgent_CommonTerms(String userAgent) {
+        setUserAgent_CommonTerms(userAgent, null);
+    }
+
+    public void setUserAgent_CommonTerms(String userAgent, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("userAgent", userAgent);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsSearchLogCQ addOrderBy_UserAgent_Asc() {
         regOBA("userAgent");
         return this;
@@ -2483,6 +2971,28 @@ public abstract class BsSearchLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUserInfoId_Wildcard(String userInfoId) {
+        setUserInfoId_Wildcard(userInfoId, null);
+    }
+
+    public void setUserInfoId_Wildcard(String userInfoId, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("userInfoId", userInfoId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUserInfoId_Regexp(String userInfoId) {
+        setUserInfoId_Regexp(userInfoId, null);
+    }
+
+    public void setUserInfoId_Regexp(String userInfoId, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("userInfoId", userInfoId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setUserInfoId_GreaterThan(String userInfoId) {
         setUserInfoId_GreaterThan(userInfoId, null);
     }
@@ -2527,6 +3037,28 @@ public abstract class BsSearchLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUserInfoId_Exists() {
+        setUserInfoId_Exists(null);
+    }
+
+    public void setUserInfoId_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("userInfoId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUserInfoId_CommonTerms(String userInfoId) {
+        setUserInfoId_CommonTerms(userInfoId, null);
+    }
+
+    public void setUserInfoId_CommonTerms(String userInfoId, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("userInfoId", userInfoId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsSearchLogCQ addOrderBy_UserInfoId_Asc() {
         regOBA("userInfoId");
         return this;
@@ -2646,6 +3178,28 @@ public abstract class BsSearchLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUserSessionId_Wildcard(String userSessionId) {
+        setUserSessionId_Wildcard(userSessionId, null);
+    }
+
+    public void setUserSessionId_Wildcard(String userSessionId, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("userSessionId", userSessionId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUserSessionId_Regexp(String userSessionId) {
+        setUserSessionId_Regexp(userSessionId, null);
+    }
+
+    public void setUserSessionId_Regexp(String userSessionId, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("userSessionId", userSessionId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setUserSessionId_GreaterThan(String userSessionId) {
         setUserSessionId_GreaterThan(userSessionId, null);
     }
@@ -2690,6 +3244,28 @@ public abstract class BsSearchLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUserSessionId_Exists() {
+        setUserSessionId_Exists(null);
+    }
+
+    public void setUserSessionId_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("userSessionId");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUserSessionId_CommonTerms(String userSessionId) {
+        setUserSessionId_CommonTerms(userSessionId, null);
+    }
+
+    public void setUserSessionId_CommonTerms(String userSessionId, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("userSessionId", userSessionId);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsSearchLogCQ addOrderBy_UserSessionId_Asc() {
         regOBA("userSessionId");
         return this;
@@ -2809,6 +3385,28 @@ public abstract class BsSearchLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setLanguages_Wildcard(String languages) {
+        setLanguages_Wildcard(languages, null);
+    }
+
+    public void setLanguages_Wildcard(String languages, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("languages", languages);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setLanguages_Regexp(String languages) {
+        setLanguages_Regexp(languages, null);
+    }
+
+    public void setLanguages_Regexp(String languages, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("languages", languages);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setLanguages_GreaterThan(String languages) {
         setLanguages_GreaterThan(languages, null);
     }
@@ -2853,6 +3451,28 @@ public abstract class BsSearchLogCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setLanguages_Exists() {
+        setLanguages_Exists(null);
+    }
+
+    public void setLanguages_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("languages");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setLanguages_CommonTerms(String languages) {
+        setLanguages_CommonTerms(languages, null);
+    }
+
+    public void setLanguages_CommonTerms(String languages, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("languages", languages);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsSearchLogCQ addOrderBy_Languages_Asc() {
         regOBA("languages");
         return this;

src/main/java/org/codelibs/fess/es/log/cbean/cq/bs/BsUserInfoCQ.java

@@ -22,6 +22,8 @@ import org.codelibs.fess.es.log.allcommon.EsAbstractConditionQuery;
 import org.codelibs.fess.es.log.cbean.cq.UserInfoCQ;
 import org.dbflute.cbean.ckey.ConditionKey;
 import org.elasticsearch.index.query.BoolQueryBuilder;
+import org.elasticsearch.index.query.CommonTermsQueryBuilder;
+import org.elasticsearch.index.query.ExistsQueryBuilder;
 import org.elasticsearch.index.query.FuzzyQueryBuilder;
 import org.elasticsearch.index.query.IdsQueryBuilder;
 import org.elasticsearch.index.query.MatchQueryBuilder;
@@ -299,6 +301,28 @@ public abstract class BsUserInfoCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setCreatedAt_Exists() {
+        setCreatedAt_Exists(null);
+    }
+
+    public void setCreatedAt_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("createdAt");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setCreatedAt_CommonTerms(LocalDateTime createdAt) {
+        setCreatedAt_CommonTerms(createdAt, null);
+    }
+
+    public void setCreatedAt_CommonTerms(LocalDateTime createdAt, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("createdAt", createdAt);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsUserInfoCQ addOrderBy_CreatedAt_Asc() {
         regOBA("createdAt");
         return this;
@@ -451,6 +475,28 @@ public abstract class BsUserInfoCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setUpdatedAt_Exists() {
+        setUpdatedAt_Exists(null);
+    }
+
+    public void setUpdatedAt_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("updatedAt");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setUpdatedAt_CommonTerms(LocalDateTime updatedAt) {
+        setUpdatedAt_CommonTerms(updatedAt, null);
+    }
+
+    public void setUpdatedAt_CommonTerms(LocalDateTime updatedAt, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("updatedAt", updatedAt);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsUserInfoCQ addOrderBy_UpdatedAt_Asc() {
         regOBA("updatedAt");
         return this;

src/main/java/org/codelibs/fess/es/user/allcommon/EsAbstractConditionQuery.java

@@ -33,17 +33,22 @@ import org.dbflute.dbmeta.name.ColumnSqlName;
 import org.dbflute.exception.InvalidQueryRegisteredException;
 import org.dbflute.util.Srl;
 import org.elasticsearch.index.query.BoolQueryBuilder;
+import org.elasticsearch.index.query.CommonTermsQueryBuilder;
+import org.elasticsearch.index.query.ExistsQueryBuilder;
 import org.elasticsearch.index.query.FuzzyQueryBuilder;
 import org.elasticsearch.index.query.IdsQueryBuilder;
 import org.elasticsearch.index.query.MatchAllQueryBuilder;
 import org.elasticsearch.index.query.MatchQueryBuilder;
+import org.elasticsearch.index.query.MoreLikeThisQueryBuilder;
 import org.elasticsearch.index.query.PrefixQueryBuilder;
 import org.elasticsearch.index.query.QueryBuilder;
 import org.elasticsearch.index.query.QueryBuilders;
 import org.elasticsearch.index.query.QueryStringQueryBuilder;
 import org.elasticsearch.index.query.RangeQueryBuilder;
+import org.elasticsearch.index.query.RegexpQueryBuilder;
 import org.elasticsearch.index.query.TermQueryBuilder;
 import org.elasticsearch.index.query.TermsQueryBuilder;
+import org.elasticsearch.index.query.WildcardQueryBuilder;
 import org.elasticsearch.search.sort.FieldSortBuilder;
 import org.elasticsearch.search.sort.SortBuilders;
 import org.elasticsearch.search.sort.SortOrder;
@@ -257,6 +262,39 @@ public abstract class EsAbstractConditionQuery implements ConditionQuery {
         }
     }
 
+    protected ExistsQueryBuilder regExistsQ(String name) {
+        ExistsQueryBuilder existsQuery = QueryBuilders.existsQuery(name);
+        regQ(existsQuery);
+        return existsQuery;
+    }
+
+    protected WildcardQueryBuilder regWildcardQ(String name, String wildcard) {
+        checkEsInvalidQuery(name, wildcard);
+        WildcardQueryBuilder wildcardQuery = QueryBuilders.wildcardQuery(name, wildcard);
+        regQ(wildcardQuery);
+        return wildcardQuery;
+    }
+
+    protected RegexpQueryBuilder regRegexpQ(String name, String regexp) {
+        checkEsInvalidQuery(name, regexp);
+        RegexpQueryBuilder regexpQuery = QueryBuilders.regexpQuery(name, regexp);
+        regQ(regexpQuery);
+        return regexpQuery;
+    }
+
+    protected CommonTermsQueryBuilder regCommonTermsQ(String name, Object text) {
+        checkEsInvalidQuery(name, text);
+        CommonTermsQueryBuilder commonTermsQuery = QueryBuilders.commonTermsQuery(name, text);
+        regQ(commonTermsQuery);
+        return commonTermsQuery;
+    }
+
+    protected MoreLikeThisQueryBuilder regMoreLikeThisQueryQ(String name) {
+        MoreLikeThisQueryBuilder moreLikeThisQuery = QueryBuilders.moreLikeThisQuery(name);
+        regQ(moreLikeThisQuery);
+        return moreLikeThisQuery;
+    }
+
     protected void regQ(QueryBuilder builder) {
         assertObjectNotNull("builder", builder);
         if (queryBuilderList == null) {

src/main/java/org/codelibs/fess/es/user/cbean/cq/bs/BsGroupCQ.java

@@ -22,13 +22,17 @@ import org.codelibs.fess.es.user.allcommon.EsAbstractConditionQuery;
 import org.codelibs.fess.es.user.cbean.cq.GroupCQ;
 import org.dbflute.cbean.ckey.ConditionKey;
 import org.elasticsearch.index.query.BoolQueryBuilder;
+import org.elasticsearch.index.query.CommonTermsQueryBuilder;
+import org.elasticsearch.index.query.ExistsQueryBuilder;
 import org.elasticsearch.index.query.FuzzyQueryBuilder;
 import org.elasticsearch.index.query.IdsQueryBuilder;
 import org.elasticsearch.index.query.MatchQueryBuilder;
 import org.elasticsearch.index.query.PrefixQueryBuilder;
 import org.elasticsearch.index.query.RangeQueryBuilder;
+import org.elasticsearch.index.query.RegexpQueryBuilder;
 import org.elasticsearch.index.query.TermQueryBuilder;
 import org.elasticsearch.index.query.TermsQueryBuilder;
+import org.elasticsearch.index.query.WildcardQueryBuilder;
 
 /**
  * @author ESFlute (using FreeGen)
@@ -267,6 +271,28 @@ public abstract class BsGroupCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setName_Wildcard(String name) {
+        setName_Wildcard(name, null);
+    }
+
+    public void setName_Wildcard(String name, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("name", name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_Regexp(String name) {
+        setName_Regexp(name, null);
+    }
+
+    public void setName_Regexp(String name, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("name", name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setName_GreaterThan(String name) {
         setName_GreaterThan(name, null);
     }
@@ -311,6 +337,28 @@ public abstract class BsGroupCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setName_Exists() {
+        setName_Exists(null);
+    }
+
+    public void setName_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("name");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_CommonTerms(String name) {
+        setName_CommonTerms(name, null);
+    }
+
+    public void setName_CommonTerms(String name, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("name", name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsGroupCQ addOrderBy_Name_Asc() {
         regOBA("name");
         return this;
@@ -463,6 +511,28 @@ public abstract class BsGroupCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setGidNumber_Exists() {
+        setGidNumber_Exists(null);
+    }
+
+    public void setGidNumber_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("gidNumber");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setGidNumber_CommonTerms(Long gidNumber) {
+        setGidNumber_CommonTerms(gidNumber, null);
+    }
+
+    public void setGidNumber_CommonTerms(Long gidNumber, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("gidNumber", gidNumber);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsGroupCQ addOrderBy_GidNumber_Asc() {
         regOBA("gidNumber");
         return this;

src/main/java/org/codelibs/fess/es/user/cbean/cq/bs/BsRoleCQ.java

@@ -22,13 +22,17 @@ import org.codelibs.fess.es.user.allcommon.EsAbstractConditionQuery;
 import org.codelibs.fess.es.user.cbean.cq.RoleCQ;
 import org.dbflute.cbean.ckey.ConditionKey;
 import org.elasticsearch.index.query.BoolQueryBuilder;
+import org.elasticsearch.index.query.CommonTermsQueryBuilder;
+import org.elasticsearch.index.query.ExistsQueryBuilder;
 import org.elasticsearch.index.query.FuzzyQueryBuilder;
 import org.elasticsearch.index.query.IdsQueryBuilder;
 import org.elasticsearch.index.query.MatchQueryBuilder;
 import org.elasticsearch.index.query.PrefixQueryBuilder;
 import org.elasticsearch.index.query.RangeQueryBuilder;
+import org.elasticsearch.index.query.RegexpQueryBuilder;
 import org.elasticsearch.index.query.TermQueryBuilder;
 import org.elasticsearch.index.query.TermsQueryBuilder;
+import org.elasticsearch.index.query.WildcardQueryBuilder;
 
 /**
  * @author ESFlute (using FreeGen)
@@ -267,6 +271,28 @@ public abstract class BsRoleCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setName_Wildcard(String name) {
+        setName_Wildcard(name, null);
+    }
+
+    public void setName_Wildcard(String name, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
+        WildcardQueryBuilder builder = regWildcardQ("name", name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_Regexp(String name) {
+        setName_Regexp(name, null);
+    }
+
+    public void setName_Regexp(String name, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
+        RegexpQueryBuilder builder = regRegexpQ("name", name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public void setName_GreaterThan(String name) {
         setName_GreaterThan(name, null);
     }
@@ -311,6 +337,28 @@ public abstract class BsRoleCQ extends EsAbstractConditionQuery {
         }
     }
 
+    public void setName_Exists() {
+        setName_Exists(null);
+    }
+
+    public void setName_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
+        ExistsQueryBuilder builder = regExistsQ("name");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setName_CommonTerms(String name) {
+        setName_CommonTerms(name, null);
+    }
+
+    public void setName_CommonTerms(String name, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
+        CommonTermsQueryBuilder builder = regCommonTermsQ("name", name);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
     public BsRoleCQ addOrderBy_Name_Asc() {
         regOBA("name");
         return this;

src/main/java/org/codelibs/fess/job/PurgeLogJob.java

@@ -84,6 +84,14 @@ public class PurgeLogJob {
             resultBuf.append(e.getMessage()).append("\n");
         }
 
+        // update job logs
+        try {
+            jobLogService.updateStatus();
+        } catch (final Exception e) {
+            logger.error("Failed to purge job logs.", e);
+            resultBuf.append(e.getMessage()).append("\n");
+        }
+
         return resultBuf.toString();
     }