#285

dbflute_fess/freegen/ControlFreeGen.vm

@@ -90,6 +90,18 @@ $manager.makeDirectory($request.generateDirPath)
       $generator.parse("./elasticsearch/ExConditionQuery.vm", $path, "", "")
     #end
 
+    #set ($path = "${request.generateDirPath}/cbean/cf/bs/Bs${table.camelizedName}CF.java")
+    $manager.makeDirectory($path)
+    $request.info("parse('${path}')")
+    $generator.parse("./elasticsearch/BsConditionFilter.vm", $path, "", "")
+
+    #set ($path = "${request.generateDirPath}/cbean/cf/${table.camelizedName}CF.java")
+    $manager.makeDirectory($path)
+    $request.info("parse('${path}')")
+    #if (!$files.file(${generator.outputPath},$path).exists())
+      $generator.parse("./elasticsearch/ExConditionFilter.vm", $path, "", "")
+    #end
+
     #set ($path = "${request.generateDirPath}/bsbhv/Bs${table.camelizedName}Bhv.java")
     $manager.makeDirectory($path)
     $request.info("parse('${path}')")
@@ -113,6 +125,11 @@ $manager.makeDirectory($request.generateDirPath)
   $request.info("parse('${path}')")
   $generator.parse("./elasticsearch/AbstractConditionQuery.vm", $path, "", "")
 
+  #set ($path = "${request.generateDirPath}/cbean/cf/bs/AbstractConditionFilter.java")
+  $manager.makeDirectory($path)
+  $request.info("parse('${path}')")
+  $generator.parse("./elasticsearch/AbstractConditionFilter.vm", $path, "", "")
+
   #set ($path = "${request.generateDirPath}/bsentity/AbstractEntity.java")
   $manager.makeDirectory($path)
   $request.info("parse('${path}')")

dbflute_fess/freegen/elasticsearch/AbstractConditionBean.vm

@@ -592,6 +592,8 @@ public abstract class AbstractConditionBean implements ConditionBean {
 
         private Boolean version;
 
+        private int terminateAfter = 0;
+
         public void build(SearchRequestBuilder builder) {
             if (explain != null) {
                 builder.setExplain(explain);
@@ -614,6 +616,9 @@ public abstract class AbstractConditionBean implements ConditionBean {
             if (version != null) {
                 builder.setVersion(version);
             }
+            if (terminateAfter > 0) {
+                builder.setTerminateAfter(terminateAfter);
+            }
         }
 
         public void setExplain(boolean explain) {
@@ -644,6 +649,10 @@ public abstract class AbstractConditionBean implements ConditionBean {
             this.version = version;
         }
 
+        public void setTerminateAfter(int terminateAfter) {
+            this.terminateAfter = terminateAfter;
+        }
+
     }
 
 }

dbflute_fess/freegen/elasticsearch/AbstractConditionFilter.vm

@@ -0,0 +1,216 @@
+package ${request.package}.cbean.cf.bs;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+
+import org.dbflute.cbean.ckey.ConditionKey;
+import org.elasticsearch.index.query.AndFilterBuilder;
+import org.elasticsearch.index.query.BoolFilterBuilder;
+import org.elasticsearch.index.query.ExistsFilterBuilder;
+import org.elasticsearch.index.query.FilterBuilder;
+import org.elasticsearch.index.query.FilterBuilders;
+import org.elasticsearch.index.query.IdsFilterBuilder;
+import org.elasticsearch.index.query.MatchAllFilterBuilder;
+import org.elasticsearch.index.query.MissingFilterBuilder;
+import org.elasticsearch.index.query.NotFilterBuilder;
+import org.elasticsearch.index.query.OrFilterBuilder;
+import org.elasticsearch.index.query.PrefixFilterBuilder;
+import org.elasticsearch.index.query.QueryBuilder;
+import org.elasticsearch.index.query.QueryFilterBuilder;
+import org.elasticsearch.index.query.RangeFilterBuilder;
+import org.elasticsearch.index.query.ScriptFilterBuilder;
+import org.elasticsearch.index.query.TermFilterBuilder;
+import org.elasticsearch.index.query.TermsFilterBuilder;
+
+public class AbstractConditionFilter {
+    protected List<FilterBuilder> filterBuilderList;
+
+    public boolean hasFilters() {
+        return filterBuilderList != null && !filterBuilderList.isEmpty();
+    }
+
+    public FilterBuilder getFilter() {
+        if (filterBuilderList == null) {
+            return null;
+        } else if (filterBuilderList.size() == 1) {
+            return filterBuilderList.get(0);
+        }
+        return FilterBuilders.andFilter(filterBuilderList.toArray(new FilterBuilder[filterBuilderList.size()]));
+    }
+
+    public void addFilter(FilterBuilder filterBuilder) {
+        regF(filterBuilder);
+    }
+
+    public void setIds_Equal(Collection<String> idList) {
+        setIds_Equal(idList, null);
+    }
+
+    public void setIds_Equal(Collection<String> idList, ConditionOptionCall<IdsFilterBuilder> opLambda) {
+        IdsFilterBuilder builder = regIdsF(idList);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void matchAll() {
+        matchAll(null);
+    }
+
+    public void matchAll(ConditionOptionCall<MatchAllFilterBuilder> opLambda) {
+        MatchAllFilterBuilder builder = FilterBuilders.matchAllFilter();
+        regF(builder);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void setScript(String script) {
+        setScript(script, null);
+    }
+
+    public void setScript(String script, ConditionOptionCall<ScriptFilterBuilder> opLambda) {
+        ScriptFilterBuilder builder = regScriptF(script);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    protected void regF(FilterBuilder builder) {
+        if (filterBuilderList == null) {
+            filterBuilderList = new ArrayList<>();
+        }
+        filterBuilderList.add(builder);
+    }
+
+    protected TermFilterBuilder regTermF(String name, Object value) {
+        TermFilterBuilder termFilter = FilterBuilders.termFilter(name, value);
+        regF(termFilter);
+        return termFilter;
+    }
+
+    protected TermsFilterBuilder regTermsF(String name, Collection<?> value) {
+        TermsFilterBuilder termsFilter = FilterBuilders.termsFilter(name, value);
+        regF(termsFilter);
+        return termsFilter;
+    }
+
+    protected PrefixFilterBuilder regPrefixF(String name, String value) {
+        PrefixFilterBuilder prefixFilter = FilterBuilders.prefixFilter(name, value);
+        regF(prefixFilter);
+        return prefixFilter;
+    }
+
+    protected ExistsFilterBuilder regExistsF(String name) {
+        ExistsFilterBuilder existsFilter = FilterBuilders.existsFilter(name);
+        regF(existsFilter);
+        return existsFilter;
+    }
+
+    protected MissingFilterBuilder regMissingF(String name) {
+        MissingFilterBuilder missingFilter = FilterBuilders.missingFilter(name);
+        regF(missingFilter);
+        return missingFilter;
+    }
+
+    protected RangeFilterBuilder regRangeF(String name, ConditionKey ck, Object value) {
+        for (FilterBuilder builder : filterBuilderList) {
+            if (builder instanceof RangeFilterBuilder) {
+                RangeFilterBuilder rangeFilterBuilder = (RangeFilterBuilder) builder;
+                if (rangeFilterBuilder.toString().replaceAll("\\s", "").startsWith("{\"range\":{\"" + name + "\"")) {
+                    addRangeC(rangeFilterBuilder, ck, value);
+                    return rangeFilterBuilder;
+                }
+            }
+        }
+        RangeFilterBuilder rangeFilterBuilder = FilterBuilders.rangeFilter(name);
+        addRangeC(rangeFilterBuilder, ck, value);
+        regF(rangeFilterBuilder);
+        return rangeFilterBuilder;
+    }
+
+    protected void addRangeC(RangeFilterBuilder builder, ConditionKey ck, Object value) {
+        if (ck.equals(ConditionKey.CK_GREATER_THAN)) {
+            builder.gt(value);
+        } else if (ck.equals(ConditionKey.CK_GREATER_EQUAL)) {
+            builder.gte(value);
+        } else if (ck.equals(ConditionKey.CK_LESS_THAN)) {
+            builder.lt(value);
+        } else if (ck.equals(ConditionKey.CK_LESS_EQUAL)) {
+            builder.lte(value);
+        }
+    }
+
+    protected ScriptFilterBuilder regScriptF(String script) {
+        ScriptFilterBuilder scriptFilter = FilterBuilders.scriptFilter(script);
+        regF(scriptFilter);
+        return scriptFilter;
+    }
+
+    protected IdsFilterBuilder regIdsF(Collection<?> value) {
+        IdsFilterBuilder idsFilter = FilterBuilders.idsFilter(value.toArray(new String[value.size()]));
+        regF(idsFilter);
+        return idsFilter;
+    }
+
+    protected BoolFilterBuilder regBoolF(List<FilterBuilder> mustList, List<FilterBuilder> shouldList, List<FilterBuilder> mustNotList) {
+        BoolFilterBuilder boolFilter = FilterBuilders.boolFilter();
+        mustList.forEach(query -> {
+            boolFilter.must(query);
+        });
+        shouldList.forEach(query -> {
+            boolFilter.should(query);
+        });
+        mustNotList.forEach(query -> {
+            boolFilter.mustNot(query);
+        });
+        return boolFilter;
+    }
+
+    protected AndFilterBuilder regAndF(List<FilterBuilder> filterList) {
+        AndFilterBuilder andFilter = FilterBuilders.andFilter(filterList.toArray(new FilterBuilder[filterList.size()]));
+        regF(andFilter);
+        return andFilter;
+    }
+
+    protected OrFilterBuilder regOrF(List<FilterBuilder> filterList) {
+        OrFilterBuilder andFilter = FilterBuilders.orFilter(filterList.toArray(new FilterBuilder[filterList.size()]));
+        regF(andFilter);
+        return andFilter;
+    }
+
+    protected NotFilterBuilder regNotF(FilterBuilder filter) {
+        NotFilterBuilder notFilter = FilterBuilders.notFilter(filter);
+        regF(notFilter);
+        return notFilter;
+    }
+
+    protected QueryFilterBuilder regQueryF(QueryBuilder filter) {
+        QueryFilterBuilder queryFilter = FilterBuilders.queryFilter(filter);
+        regF(queryFilter);
+        return queryFilter;
+    }
+
+    @FunctionalInterface
+    public interface ConditionOptionCall<OP extends FilterBuilder> {
+
+        /**
+         * @param op The option of condition to be set up. (NotNull)
+         */
+        void callback(OP op);
+    }
+
+    @FunctionalInterface
+    public interface BoolCall<CF extends AbstractConditionFilter> {
+
+        void callback(CF must, CF should, CF mustNot);
+    }
+
+    @FunctionalInterface
+    public interface OperatorCall<CF extends AbstractConditionFilter> {
+
+        void callback(CF and);
+    }
+}
+

dbflute_fess/freegen/elasticsearch/AbstractConditionQuery.vm

@@ -5,6 +5,7 @@ import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
 
+import ${request.package}.cbean.cf.bs.AbstractConditionFilter;
 import org.dbflute.cbean.ConditionBean;
 import org.dbflute.cbean.ConditionQuery;
 import org.dbflute.cbean.ckey.ConditionKey;
@@ -20,6 +21,7 @@ import org.elasticsearch.index.query.BoolQueryBuilder;
 import org.elasticsearch.index.query.FilterBuilder;
 import org.elasticsearch.index.query.FilteredQueryBuilder;
 import org.elasticsearch.index.query.FuzzyQueryBuilder;
+import org.elasticsearch.index.query.MatchAllQueryBuilder;
 import org.elasticsearch.index.query.MatchQueryBuilder;
 import org.elasticsearch.index.query.PrefixQueryBuilder;
 import org.elasticsearch.index.query.QueryBuilder;
@@ -56,6 +58,10 @@ public abstract class AbstractConditionQuery implements ConditionQuery {
         return fieldSortBuilderList == null ? Collections.emptyList() : fieldSortBuilderList;
     }
 
+    public boolean hasQueries() {
+        return queryBuilderList != null && !queryBuilderList.isEmpty();
+    }
+
     public QueryBuilder getQuery() {
         if (queryBuilderList == null) {
             return null;
@@ -70,7 +76,7 @@ public abstract class AbstractConditionQuery implements ConditionQuery {
     }
 
     public void addQuery(QueryBuilder queryBuilder) {
-        queryBuilderList.add(queryBuilder);
+        regQ(queryBuilder);
     }
 
     public void queryString(String queryString) {
@@ -85,11 +91,23 @@ public abstract class AbstractConditionQuery implements ConditionQuery {
         }
     }
 
-    protected FilteredQueryBuilder reqFilteredQ(QueryBuilder queryBuilder, FilterBuilder filterBuilder) {
+    public void matchAll() {
+        matchAll(null);
+    }
+
+    public void matchAll(ConditionOptionCall<MatchAllQueryBuilder> opLambda) {
+        MatchAllQueryBuilder builder = QueryBuilders.matchAllQuery();
+        regQ(builder);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    protected FilteredQueryBuilder regFilteredQ(QueryBuilder queryBuilder, FilterBuilder filterBuilder) {
         return QueryBuilders.filteredQuery(queryBuilder, filterBuilder);
     }
 
-    protected BoolQueryBuilder reqBoolCQ(List<QueryBuilder> mustList, List<QueryBuilder> shouldList, List<QueryBuilder> mustNotList) {
+    protected BoolQueryBuilder regBoolCQ(List<QueryBuilder> mustList, List<QueryBuilder> shouldList, List<QueryBuilder> mustNotList) {
         BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
         mustList.forEach(query -> {
             boolQuery.must(query);
@@ -103,49 +121,49 @@ public abstract class AbstractConditionQuery implements ConditionQuery {
         return boolQuery;
     }
 
-    protected TermQueryBuilder reqTermQ(String name, Object value) {
+    protected TermQueryBuilder regTermQ(String name, Object value) {
         TermQueryBuilder termQuery = QueryBuilders.termQuery(name, value);
         regQ(termQuery);
         return termQuery;
     }
 
-    protected TermsQueryBuilder reqTermsQ(String name, Collection<?> value) {
+    protected TermsQueryBuilder regTermsQ(String name, Collection<?> value) {
         TermsQueryBuilder termsQuery = QueryBuilders.termsQuery(name, value);
         regQ(termsQuery);
         return termsQuery;
     }
 
-    protected MatchQueryBuilder reqMatchQ(String name, Object value) {
+    protected MatchQueryBuilder regMatchQ(String name, Object value) {
         MatchQueryBuilder matchQuery = QueryBuilders.matchQuery(name, value);
         regQ(matchQuery);
         return matchQuery;
     }
 
-    protected MatchQueryBuilder reqMatchPhraseQ(String name, Object value) {
+    protected MatchQueryBuilder regMatchPhraseQ(String name, Object value) {
         MatchQueryBuilder matchQuery = QueryBuilders.matchPhraseQuery(name, value);
         regQ(matchQuery);
         return matchQuery;
     }
 
-    protected MatchQueryBuilder reqMatchPhrasePrefixQ(String name, Object value) {
+    protected MatchQueryBuilder regMatchPhrasePrefixQ(String name, Object value) {
         MatchQueryBuilder matchQuery = QueryBuilders.matchPhrasePrefixQuery(name, value);
         regQ(matchQuery);
         return matchQuery;
     }
 
-    protected FuzzyQueryBuilder reqFuzzyQ(String name, Object value) {
+    protected FuzzyQueryBuilder regFuzzyQ(String name, Object value) {
         FuzzyQueryBuilder fuzzyQuery = QueryBuilders.fuzzyQuery(name, value);
         regQ(fuzzyQuery);
         return fuzzyQuery;
     }
 
-    protected PrefixQueryBuilder reqPrefixQ(String name, String prefix) {
+    protected PrefixQueryBuilder regPrefixQ(String name, String prefix) {
         PrefixQueryBuilder prefixQuery = QueryBuilders.prefixQuery(name, prefix);
         regQ(prefixQuery);
         return prefixQuery;
     }
 
-    protected RangeQueryBuilder reqRangeQ(String name, ConditionKey ck, Object value) {
+    protected RangeQueryBuilder regRangeQ(String name, ConditionKey ck, Object value) {
         for (QueryBuilder builder : queryBuilderList) {
             if (builder instanceof RangeQueryBuilder) {
                 RangeQueryBuilder rangeQueryBuilder = (RangeQueryBuilder) builder;
@@ -353,10 +371,15 @@ public abstract class AbstractConditionQuery implements ConditionQuery {
     }
 
     @FunctionalInterface
-    public interface FilteredCall<CQ extends AbstractConditionQuery> {
+    public interface FilteredCall<CQ extends AbstractConditionQuery, CF extends AbstractConditionFilter> {
 
-        void callback(CQ query);
+        void callback(CQ query, CF filter);
     }
-}
 
+    @FunctionalInterface
+    public interface OperatorCall<CQ extends AbstractConditionQuery> {
+
+        void callback(CQ and);
+    }
+}
 

dbflute_fess/freegen/elasticsearch/BsConditionFilter.vm

@@ -0,0 +1,225 @@
+package ${request.package}.cbean.cf.bs;
+
+import java.util.Collection;
+
+import ${request.package}.cbean.cf.${table.camelizedName}CF;
+import ${request.package}.cbean.cq.${table.camelizedName}CQ;
+import org.dbflute.exception.IllegalConditionBeanOperationException;
+import org.dbflute.cbean.ckey.ConditionKey;
+import org.elasticsearch.index.query.AndFilterBuilder;
+import org.elasticsearch.index.query.BoolFilterBuilder;
+import org.elasticsearch.index.query.ExistsFilterBuilder;
+import org.elasticsearch.index.query.MissingFilterBuilder;
+import org.elasticsearch.index.query.NotFilterBuilder;
+import org.elasticsearch.index.query.OrFilterBuilder;
+import org.elasticsearch.index.query.PrefixFilterBuilder;
+import org.elasticsearch.index.query.QueryFilterBuilder;
+import org.elasticsearch.index.query.RangeFilterBuilder;
+import org.elasticsearch.index.query.TermFilterBuilder;
+import org.elasticsearch.index.query.TermsFilterBuilder;
+
+/**
+ * @author FreeGen
+ */
+public abstract class Bs${table.camelizedName}CF extends AbstractConditionFilter {
+
+    public void bool(BoolCall<${table.camelizedName}CF> boolLambda) {
+        bool(boolLambda, null);
+    }
+
+    public void bool(BoolCall<${table.camelizedName}CF> boolLambda, ConditionOptionCall<BoolFilterBuilder> opLambda) {
+        ${table.camelizedName}CF mustFilter = new ${table.camelizedName}CF();
+        ${table.camelizedName}CF shouldFilter = new ${table.camelizedName}CF();
+        ${table.camelizedName}CF mustNotFilter = new ${table.camelizedName}CF();
+        boolLambda.callback(mustFilter, shouldFilter, mustNotFilter);
+        if (mustFilter.hasFilters() || shouldFilter.hasFilters() || mustNotFilter.hasFilters()) {
+            BoolFilterBuilder builder =
+                    regBoolF(mustFilter.filterBuilderList, shouldFilter.filterBuilderList, mustNotFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void and(OperatorCall<${table.camelizedName}CF> andLambda) {
+        and(andLambda, null);
+    }
+
+    public void and(OperatorCall<${table.camelizedName}CF> andLambda, ConditionOptionCall<AndFilterBuilder> opLambda) {
+        ${table.camelizedName}CF andFilter = new ${table.camelizedName}CF();
+        andLambda.callback(andFilter);
+        if (andFilter.hasFilters()) {
+            AndFilterBuilder builder = regAndF(andFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void or(OperatorCall<${table.camelizedName}CF> orLambda) {
+        or(orLambda, null);
+    }
+
+    public void or(OperatorCall<${table.camelizedName}CF> orLambda, ConditionOptionCall<OrFilterBuilder> opLambda) {
+        ${table.camelizedName}CF orFilter = new ${table.camelizedName}CF();
+        orLambda.callback(orFilter);
+        if (orFilter.hasFilters()) {
+            OrFilterBuilder builder = regOrF(orFilter.filterBuilderList);
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void not(OperatorCall<${table.camelizedName}CF> notLambda) {
+        not(notLambda, null);
+    }
+
+    public void not(OperatorCall<${table.camelizedName}CF> notLambda, ConditionOptionCall<NotFilterBuilder> opLambda) {
+        ${table.camelizedName}CF notFilter = new ${table.camelizedName}CF();
+        notLambda.callback(notFilter);
+        if (notFilter.hasFilters()) {
+            if (notFilter.filterBuilderList.size() > 1) {
+                final String msg = "not filter must be one filter.";
+                throw new IllegalConditionBeanOperationException(msg);
+            }
+            NotFilterBuilder builder = regNotF(notFilter.filterBuilderList.get(0));
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<${table.camelizedName}CQ> queryLambda) {
+        query(queryLambda, null);
+    }
+
+    public void query(org.codelibs.fess.es.cbean.cq.bs.AbstractConditionQuery.OperatorCall<${table.camelizedName}CQ> queryLambda,
+            ConditionOptionCall<QueryFilterBuilder> opLambda) {
+        ${table.camelizedName}CQ query = new ${table.camelizedName}CQ();
+        queryLambda.callback(query);
+        if (query.hasQueries()) {
+            QueryFilterBuilder builder = regQueryF(query.getQuery());
+            if (opLambda != null) {
+                opLambda.callback(builder);
+            }
+        }
+    }
+
+
+#foreach ($column in $table.columnList)
+#if ($column.isNormalColumn)
+#set ($javaNative = ${column.type})
+
+    public void set${column.capCamelName}_Term($javaNative ${column.uncapCamelName}) {
+        set${column.capCamelName}_Term(${column.uncapCamelName}, null);
+    }
+
+    public void set${column.capCamelName}_Term($javaNative ${column.uncapCamelName}, ConditionOptionCall<TermFilterBuilder> opLambda) {
+        TermFilterBuilder builder = regTermF("${column.name}", ${column.uncapCamelName});
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void set${column.capCamelName}_Terms(Collection<$javaNative> ${column.uncapCamelName}List) {
+        set${column.capCamelName}_Terms(${column.uncapCamelName}List, null);
+    }
+
+    public void set${column.capCamelName}_Terms(Collection<$javaNative> ${column.uncapCamelName}List, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        TermsFilterBuilder builder = regTermsF("${column.name}", ${column.uncapCamelName}List);
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void set${column.capCamelName}_InScope(Collection<$javaNative> ${column.uncapCamelName}List) {
+        set${column.capCamelName}_Terms(${column.uncapCamelName}List, null);
+    }
+
+    public void set${column.capCamelName}_InScope(Collection<$javaNative> ${column.uncapCamelName}List, ConditionOptionCall<TermsFilterBuilder> opLambda) {
+        set${column.capCamelName}_Terms(${column.uncapCamelName}List, opLambda);
+    }
+
+#if ($javaNative == "String")
+    public void set${column.capCamelName}_Prefix($javaNative ${column.uncapCamelName}) {
+        set${column.capCamelName}_Prefix(${column.uncapCamelName}, null);
+    }
+
+    public void set${column.capCamelName}_Prefix($javaNative ${column.uncapCamelName}, ConditionOptionCall<PrefixFilterBuilder> opLambda) {
+        PrefixFilterBuilder builder = regPrefixF("${column.name}", ${column.uncapCamelName});
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+#end
+    public void set${column.capCamelName}_Exists() {
+        set${column.capCamelName}_Exists(null);
+    }
+
+    public void set${column.capCamelName}_Exists(ConditionOptionCall<ExistsFilterBuilder> opLambda) {
+        ExistsFilterBuilder builder = regExistsF("${column.name}");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void set${column.capCamelName}_Missing() {
+        set${column.capCamelName}_Missing(null);
+    }
+
+    public void set${column.capCamelName}_Missing(ConditionOptionCall<MissingFilterBuilder> opLambda) {
+        MissingFilterBuilder builder = regMissingF("${column.name}");
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void set${column.capCamelName}_GreaterThan($javaNative ${column.uncapCamelName}) {
+        set${column.capCamelName}_GreaterThan(${column.uncapCamelName}, null);
+    }
+
+    public void set${column.capCamelName}_GreaterThan($javaNative ${column.uncapCamelName}, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("${column.name}", ConditionKey.CK_GREATER_THAN, ${column.uncapCamelName});
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void set${column.capCamelName}_LessThan($javaNative ${column.uncapCamelName}) {
+        set${column.capCamelName}_LessThan(${column.uncapCamelName}, null);
+    }
+
+    public void set${column.capCamelName}_LessThan($javaNative ${column.uncapCamelName}, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("${column.name}", ConditionKey.CK_LESS_THAN, ${column.uncapCamelName});
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void set${column.capCamelName}_GreaterEqual($javaNative ${column.uncapCamelName}) {
+        set${column.capCamelName}_GreaterEqual(${column.uncapCamelName}, null);
+    }
+
+    public void set${column.capCamelName}_GreaterEqual($javaNative ${column.uncapCamelName}, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("${column.name}", ConditionKey.CK_GREATER_EQUAL, ${column.uncapCamelName});
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+    public void set${column.capCamelName}_LessEqual($javaNative ${column.uncapCamelName}) {
+        set${column.capCamelName}_LessEqual(${column.uncapCamelName}, null);
+    }
+
+    public void set${column.capCamelName}_LessEqual($javaNative ${column.uncapCamelName}, ConditionOptionCall<RangeFilterBuilder> opLambda) {
+        RangeFilterBuilder builder = regRangeF("${column.name}", ConditionKey.CK_LESS_EQUAL, ${column.uncapCamelName});
+        if (opLambda != null) {
+            opLambda.callback(builder);
+        }
+    }
+
+#end
+#end
+}

dbflute_fess/freegen/elasticsearch/BsConditionQuery.vm

@@ -3,6 +3,7 @@ package ${request.package}.cbean.cq.bs;
 import java.util.Collection;
 
 import ${request.package}.cbean.cq.${table.camelizedName}CQ;
+import ${request.package}.cbean.cf.${table.camelizedName}CF;
 import org.dbflute.cbean.ckey.ConditionKey;
 import org.elasticsearch.index.query.BoolQueryBuilder;
 import org.elasticsearch.index.query.FilteredQueryBuilder;
@@ -28,16 +29,17 @@ public abstract class Bs${table.camelizedName}CQ extends AbstractConditionQuery
         return "${table.name}";
     }
 
-    public void filtered(FilteredCall<${table.camelizedName}CQ> filteredLambda) {
+    public void filtered(FilteredCall<${table.camelizedName}CQ, ${table.camelizedName}CF> filteredLambda) {
         filtered(filteredLambda, null);
     }
 
-    public void filtered(FilteredCall<${table.camelizedName}CQ> filteredLambda, ConditionOptionCall<FilteredQueryBuilder> opLambda) {
+    public void filtered(FilteredCall<${table.camelizedName}CQ, ${table.camelizedName}CF> filteredLambda,
+            ConditionOptionCall<FilteredQueryBuilder> opLambda) {
         ${table.camelizedName}CQ query = new ${table.camelizedName}CQ();
-        filteredLambda.callback(query);
-        if (!query.queryBuilderList.isEmpty()) {
-            // TODO filter
-            FilteredQueryBuilder builder = reqFilteredQ(query.getQuery(), null);
+        ${table.camelizedName}CF filter = new ${table.camelizedName}CF();
+        filteredLambda.callback(query, filter);
+        if (query.hasQueries()) {
+            FilteredQueryBuilder builder = regFilteredQ(query.getQuery(), filter.getFilter());
             if (opLambda != null) {
                 opLambda.callback(builder);
             }
@@ -53,8 +55,8 @@ public abstract class Bs${table.camelizedName}CQ extends AbstractConditionQuery
         ${table.camelizedName}CQ shouldQuery = new ${table.camelizedName}CQ();
         ${table.camelizedName}CQ mustNotQuery = new ${table.camelizedName}CQ();
         boolLambda.callback(mustQuery, shouldQuery, mustNotQuery);
-        if (!mustQuery.queryBuilderList.isEmpty() || !shouldQuery.queryBuilderList.isEmpty() || !mustNotQuery.queryBuilderList.isEmpty()) {
-            BoolQueryBuilder builder = reqBoolCQ(mustQuery.queryBuilderList, shouldQuery.queryBuilderList, mustNotQuery.queryBuilderList);
+        if (mustQuery.hasQueries() || shouldQuery.hasQueries() || mustNotQuery.hasQueries()) {
+            BoolQueryBuilder builder = regBoolCQ(mustQuery.queryBuilderList, shouldQuery.queryBuilderList, mustNotQuery.queryBuilderList);
             if (opLambda != null) {
                 opLambda.callback(builder);
             }
@@ -69,29 +71,29 @@ public abstract class Bs${table.camelizedName}CQ extends AbstractConditionQuery
     }
 
     public void set${column.capCamelName}_Term($javaNative ${column.uncapCamelName}, ConditionOptionCall<TermQueryBuilder> opLambda) {
-        TermQueryBuilder builder = reqTermQ("${column.name}", ${column.uncapCamelName});
+        TermQueryBuilder builder = regTermQ("${column.name}", ${column.uncapCamelName});
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void set${column.capCamelName}_Terms(Collection<$javaNative> ${column.uncapCamelName}List) {
-        set${column.capCamelName}_MatchPhrasePrefix(${column.uncapCamelName}List, null);
+        set${column.capCamelName}_Terms(${column.uncapCamelName}List, null);
     }
 
-    public void set${column.capCamelName}_MatchPhrasePrefix(Collection<$javaNative> ${column.uncapCamelName}List, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        TermsQueryBuilder builder = reqTermsQ("${column.name}", ${column.uncapCamelName}List);
+    public void set${column.capCamelName}_Terms(Collection<$javaNative> ${column.uncapCamelName}List, ConditionOptionCall<TermsQueryBuilder> opLambda) {
+        TermsQueryBuilder builder = regTermsQ("${column.name}", ${column.uncapCamelName}List);
         if (opLambda != null) {
             opLambda.callback(builder);
         }
     }
 
     public void set${column.capCamelName}_InScope(Collection<$javaNative> ${column.uncapCamelName}List) {
-        set${column.capCamelName}_MatchPhrasePrefix(${column.uncapCamelName}List, null);
+        set${column.capCamelName}_Terms(${column.uncapCamelName}List, null);
     }
 
     public void set${column.capCamelName}_InScope(Collection<$javaNative> ${column.uncapCamelName}List, ConditionOptionCall<TermsQueryBuilder> opLambda) {
-        set${column.capCamelName}_MatchPhrasePrefix(${column.uncapCamelName}List, opLambda);
+        set${column.capCamelName}_Terms(${column.uncapCamelName}List, opLambda);
     }
 
     public void set${column.capCamelName}_Match($javaNative ${column.uncapCamelName}) {
@@ -99,7 +101,7 @@ public abstract class Bs${table.camelizedName}CQ extends AbstractConditionQuery
     }
 
     public void set${column.capCamelName}_Match($javaNative ${column.uncapCamelName}, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchQ("${column.name}", ${column.uncapCamelName});
+        MatchQueryBuilder builder = regMatchQ("${column.name}", ${column.uncapCamelName});
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -110,7 +112,7 @@ public abstract class Bs${table.camelizedName}CQ extends AbstractConditionQuery
     }
 
     public void set${column.capCamelName}_MatchPhrase($javaNative ${column.uncapCamelName}, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhraseQ("${column.name}", ${column.uncapCamelName});
+        MatchQueryBuilder builder = regMatchPhraseQ("${column.name}", ${column.uncapCamelName});
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -121,7 +123,7 @@ public abstract class Bs${table.camelizedName}CQ extends AbstractConditionQuery
     }
 
     public void set${column.capCamelName}_MatchPhrasePrefix($javaNative ${column.uncapCamelName}, ConditionOptionCall<MatchQueryBuilder> opLambda) {
-        MatchQueryBuilder builder = reqMatchPhrasePrefixQ("${column.name}", ${column.uncapCamelName});
+        MatchQueryBuilder builder = regMatchPhrasePrefixQ("${column.name}", ${column.uncapCamelName});
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -132,7 +134,7 @@ public abstract class Bs${table.camelizedName}CQ extends AbstractConditionQuery
     }
 
     public void set${column.capCamelName}_Fuzzy($javaNative ${column.uncapCamelName}, ConditionOptionCall<FuzzyQueryBuilder> opLambda) {
-        FuzzyQueryBuilder builder = reqFuzzyQ("${column.name}", ${column.uncapCamelName});
+        FuzzyQueryBuilder builder = regFuzzyQ("${column.name}", ${column.uncapCamelName});
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -144,7 +146,7 @@ public abstract class Bs${table.camelizedName}CQ extends AbstractConditionQuery
     }
 
     public void set${column.capCamelName}_Prefix($javaNative ${column.uncapCamelName}, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
-        PrefixQueryBuilder builder = reqPrefixQ("${column.name}", ${column.uncapCamelName});
+        PrefixQueryBuilder builder = regPrefixQ("${column.name}", ${column.uncapCamelName});
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -156,7 +158,7 @@ public abstract class Bs${table.camelizedName}CQ extends AbstractConditionQuery
     }
 
     public void set${column.capCamelName}_GreaterThan($javaNative ${column.uncapCamelName}, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("${column.name}", ConditionKey.CK_GREATER_THAN, ${column.uncapCamelName});
+        RangeQueryBuilder builder = regRangeQ("${column.name}", ConditionKey.CK_GREATER_THAN, ${column.uncapCamelName});
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -167,7 +169,7 @@ public abstract class Bs${table.camelizedName}CQ extends AbstractConditionQuery
     }
 
     public void set${column.capCamelName}_LessThan($javaNative ${column.uncapCamelName}, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("${column.name}", ConditionKey.CK_LESS_THAN, ${column.uncapCamelName});
+        RangeQueryBuilder builder = regRangeQ("${column.name}", ConditionKey.CK_LESS_THAN, ${column.uncapCamelName});
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -178,7 +180,7 @@ public abstract class Bs${table.camelizedName}CQ extends AbstractConditionQuery
     }
 
     public void set${column.capCamelName}_GreaterEqual($javaNative ${column.uncapCamelName}, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("${column.name}", ConditionKey.CK_GREATER_EQUAL, ${column.uncapCamelName});
+        RangeQueryBuilder builder = regRangeQ("${column.name}", ConditionKey.CK_GREATER_EQUAL, ${column.uncapCamelName});
         if (opLambda != null) {
             opLambda.callback(builder);
         }
@@ -189,7 +191,7 @@ public abstract class Bs${table.camelizedName}CQ extends AbstractConditionQuery
     }
 
     public void set${column.capCamelName}_LessEqual($javaNative ${column.uncapCamelName}, ConditionOptionCall<RangeQueryBuilder> opLambda) {
-        RangeQueryBuilder builder = reqRangeQ("${column.name}", ConditionKey.CK_LESS_EQUAL, ${column.uncapCamelName});
+        RangeQueryBuilder builder = regRangeQ("${column.name}", ConditionKey.CK_LESS_EQUAL, ${column.uncapCamelName});
         if (opLambda != null) {
             opLambda.callback(builder);
         }

dbflute_fess/freegen/elasticsearch/ExConditionFilter.vm

@@ -0,0 +1,9 @@
+package ${request.package}.cbean.cf;
+
+import ${request.package}.cbean.cf.bs.Bs${table.camelizedName}CF;
+
+/**
+ * @author FreeGen
+ */
+public class ${table.camelizedName}CF extends Bs${table.camelizedName}CF {
+}