diff --git a/dbflute_fess/freegen/ControlFreeGen.vm b/dbflute_fess/freegen/ControlFreeGen.vm index 51b6ba0f5..9989e6a44 100644 --- a/dbflute_fess/freegen/ControlFreeGen.vm +++ b/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}')") diff --git a/dbflute_fess/freegen/elasticsearch/AbstractConditionBean.vm b/dbflute_fess/freegen/elasticsearch/AbstractConditionBean.vm index 82aad5fb2..90b3e62ef 100644 --- a/dbflute_fess/freegen/elasticsearch/AbstractConditionBean.vm +++ b/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; + } + } } diff --git a/dbflute_fess/freegen/elasticsearch/AbstractConditionFilter.vm b/dbflute_fess/freegen/elasticsearch/AbstractConditionFilter.vm new file mode 100644 index 000000000..e86c2165a --- /dev/null +++ b/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 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 idList) { + setIds_Equal(idList, null); + } + + public void setIds_Equal(Collection idList, ConditionOptionCall opLambda) { + IdsFilterBuilder builder = regIdsF(idList); + if (opLambda != null) { + opLambda.callback(builder); + } + } + + public void matchAll() { + matchAll(null); + } + + public void matchAll(ConditionOptionCall 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 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 mustList, List shouldList, List 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 filterList) { + AndFilterBuilder andFilter = FilterBuilders.andFilter(filterList.toArray(new FilterBuilder[filterList.size()])); + regF(andFilter); + return andFilter; + } + + protected OrFilterBuilder regOrF(List 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 { + + /** + * @param op The option of condition to be set up. (NotNull) + */ + void callback(OP op); + } + + @FunctionalInterface + public interface BoolCall { + + void callback(CF must, CF should, CF mustNot); + } + + @FunctionalInterface + public interface OperatorCall { + + void callback(CF and); + } +} + diff --git a/dbflute_fess/freegen/elasticsearch/AbstractConditionQuery.vm b/dbflute_fess/freegen/elasticsearch/AbstractConditionQuery.vm index e8c37f63b..857218e2a 100644 --- a/dbflute_fess/freegen/elasticsearch/AbstractConditionQuery.vm +++ b/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 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 mustList, List shouldList, List mustNotList) { + protected BoolQueryBuilder regBoolCQ(List mustList, List shouldList, List 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 { + public interface FilteredCall { - void callback(CQ query); + void callback(CQ query, CF filter); + } + + @FunctionalInterface + public interface OperatorCall { + + void callback(CQ and); } } - diff --git a/dbflute_fess/freegen/elasticsearch/BsConditionFilter.vm b/dbflute_fess/freegen/elasticsearch/BsConditionFilter.vm new file mode 100644 index 000000000..e6ba6190e --- /dev/null +++ b/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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 opLambda) { + RangeFilterBuilder builder = regRangeF("${column.name}", ConditionKey.CK_LESS_EQUAL, ${column.uncapCamelName}); + if (opLambda != null) { + opLambda.callback(builder); + } + } + +#end +#end +} diff --git a/dbflute_fess/freegen/elasticsearch/BsConditionQuery.vm b/dbflute_fess/freegen/elasticsearch/BsConditionQuery.vm index a27f9d86b..c0690fc50 100644 --- a/dbflute_fess/freegen/elasticsearch/BsConditionQuery.vm +++ b/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 opLambda) { + public void filtered(FilteredCall<${table.camelizedName}CQ, ${table.camelizedName}CF> filteredLambda, + ConditionOptionCall 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 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 opLambda) { - TermsQueryBuilder builder = reqTermsQ("${column.name}", ${column.uncapCamelName}List); + public void set${column.capCamelName}_Terms(Collection<$javaNative> ${column.uncapCamelName}List, ConditionOptionCall 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 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 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 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 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 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 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 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 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 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 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); } diff --git a/dbflute_fess/freegen/elasticsearch/ExConditionFilter.vm b/dbflute_fess/freegen/elasticsearch/ExConditionFilter.vm new file mode 100644 index 000000000..14804e81d --- /dev/null +++ b/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 { +}