View Javadoc
1   /*
2    * Copyright 2012-2025 CodeLibs Project and the Others.
3    *
4    * Licensed under the Apache License, Version 2.0 (the "License");
5    * you may not use this file except in compliance with the License.
6    * You may obtain a copy of the License at
7    *
8    *     http://www.apache.org/licenses/LICENSE-2.0
9    *
10   * Unless required by applicable law or agreed to in writing, software
11   * distributed under the License is distributed on an "AS IS" BASIS,
12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
13   * either express or implied. See the License for the specific language
14   * governing permissions and limitations under the License.
15   */
16  package org.codelibs.fess.opensearch.config.cbean.cq.bs;
17  
18  import java.time.LocalDateTime;
19  import java.util.ArrayList;
20  import java.util.Collection;
21  
22  import org.codelibs.fess.opensearch.config.allcommon.EsAbstractConditionQuery;
23  import org.codelibs.fess.opensearch.config.cbean.cq.KeyMatchCQ;
24  import org.dbflute.cbean.ckey.ConditionKey;
25  import org.opensearch.index.query.BoolQueryBuilder;
26  import org.opensearch.index.query.CommonTermsQueryBuilder;
27  import org.opensearch.index.query.ExistsQueryBuilder;
28  import org.opensearch.index.query.IdsQueryBuilder;
29  import org.opensearch.index.query.MatchPhrasePrefixQueryBuilder;
30  import org.opensearch.index.query.MatchPhraseQueryBuilder;
31  import org.opensearch.index.query.MatchQueryBuilder;
32  import org.opensearch.index.query.PrefixQueryBuilder;
33  import org.opensearch.index.query.RangeQueryBuilder;
34  import org.opensearch.index.query.RegexpQueryBuilder;
35  import org.opensearch.index.query.SpanTermQueryBuilder;
36  import org.opensearch.index.query.TermQueryBuilder;
37  import org.opensearch.index.query.TermsQueryBuilder;
38  import org.opensearch.index.query.WildcardQueryBuilder;
39  import org.opensearch.index.query.functionscore.FunctionScoreQueryBuilder;
40  import org.opensearch.index.query.functionscore.FunctionScoreQueryBuilder.FilterFunctionBuilder;
41  
42  /**
43   * @author ESFlute (using FreeGen)
44   */
45  public abstract class BsKeyMatchCQ extends EsAbstractConditionQuery {
46  
47      protected static final Class<?> suppressUnusedImportLocalDateTime = LocalDateTime.class;
48  
49      // ===================================================================================
50      //                                                                       Name Override
51      //                                                                       =============
52      @Override
53      public String asTableDbName() {
54          return "key_match";
55      }
56  
57      @Override
58      public String xgetAliasName() {
59          return "key_match";
60      }
61  
62      // ===================================================================================
63      //                                                                       Query Control
64      //                                                                       =============
65      public void functionScore(OperatorCall<KeyMatchCQ> queryLambda, ScoreFunctionCall<ScoreFunctionCreator<KeyMatchCQ>> functionsLambda,
66              final ConditionOptionCall<FunctionScoreQueryBuilder> opLambda) {
67          KeyMatchCQ cq = new KeyMatchCQ();
68          queryLambda.callback(cq);
69          final Collection<FilterFunctionBuilder> list = new ArrayList<>();
70          if (functionsLambda != null) {
71              functionsLambda.callback((cqLambda, scoreFunctionBuilder) -> {
72                  KeyMatchCQ cf = new KeyMatchCQ();
73                  cqLambda.callback(cf);
74                  list.add(new FilterFunctionBuilder(cf.getQuery(), scoreFunctionBuilder));
75              });
76          }
77          final FunctionScoreQueryBuilder builder = regFunctionScoreQ(cq.getQuery(), list);
78          if (opLambda != null) {
79              opLambda.callback(builder);
80          }
81      }
82  
83      public void filtered(FilteredCall<KeyMatchCQ, KeyMatchCQ> filteredLambda) {
84          filtered(filteredLambda, null);
85      }
86  
87      public void filtered(FilteredCall<KeyMatchCQ, KeyMatchCQ> filteredLambda, ConditionOptionCall<BoolQueryBuilder> opLambda) {
88          bool((must, should, mustNot, filter) -> {
89              filteredLambda.callback(must, filter);
90          }, opLambda);
91      }
92  
93      public void not(OperatorCall<KeyMatchCQ> notLambda) {
94          not(notLambda, null);
95      }
96  
97      public void not(final OperatorCall<KeyMatchCQ> notLambda, final ConditionOptionCall<BoolQueryBuilder> opLambda) {
98          bool((must, should, mustNot, filter) -> notLambda.callback(mustNot), opLambda);
99      }
100 
101     public void bool(BoolCall<KeyMatchCQ> boolLambda) {
102         bool(boolLambda, null);
103     }
104 
105     public void bool(BoolCall<KeyMatchCQ> boolLambda, ConditionOptionCall<BoolQueryBuilder> opLambda) {
106         KeyMatchCQ mustQuery = new KeyMatchCQ();
107         KeyMatchCQ shouldQuery = new KeyMatchCQ();
108         KeyMatchCQ mustNotQuery = new KeyMatchCQ();
109         KeyMatchCQ filterQuery = new KeyMatchCQ();
110         boolLambda.callback(mustQuery, shouldQuery, mustNotQuery, filterQuery);
111         if (mustQuery.hasQueries() || shouldQuery.hasQueries() || mustNotQuery.hasQueries() || filterQuery.hasQueries()) {
112             BoolQueryBuilder builder = regBoolCQ(mustQuery.getQueryBuilderList(), shouldQuery.getQueryBuilderList(),
113                     mustNotQuery.getQueryBuilderList(), filterQuery.getQueryBuilderList());
114             if (opLambda != null) {
115                 opLambda.callback(builder);
116             }
117         }
118     }
119 
120     // ===================================================================================
121     //                                                                           Query Set
122     //                                                                           =========
123     public void setId_Equal(String id) {
124         setId_Term(id, null);
125     }
126 
127     public void setId_Equal(String id, ConditionOptionCall<TermQueryBuilder> opLambda) {
128         setId_Term(id, opLambda);
129     }
130 
131     public void setId_Term(String id) {
132         setId_Term(id, null);
133     }
134 
135     public void setId_Term(String id, ConditionOptionCall<TermQueryBuilder> opLambda) {
136         TermQueryBuilder builder = regTermQ("_id", id);
137         if (opLambda != null) {
138             opLambda.callback(builder);
139         }
140     }
141 
142     public void setId_NotEqual(String id) {
143         setId_NotTerm(id, null);
144     }
145 
146     public void setId_NotTerm(String id) {
147         setId_NotTerm(id, null);
148     }
149 
150     public void setId_NotEqual(String id, ConditionOptionCall<BoolQueryBuilder> opLambda) {
151         setId_NotTerm(id, opLambda);
152     }
153 
154     public void setId_NotTerm(String id, ConditionOptionCall<BoolQueryBuilder> opLambda) {
155         not(not -> not.setId_Term(id), opLambda);
156     }
157 
158     public void setId_Terms(Collection<String> idList) {
159         setId_Terms(idList, null);
160     }
161 
162     public void setId_Terms(Collection<String> idList, ConditionOptionCall<IdsQueryBuilder> opLambda) {
163         IdsQueryBuilder builder = regIdsQ(idList);
164         if (opLambda != null) {
165             opLambda.callback(builder);
166         }
167     }
168 
169     public void setId_InScope(Collection<String> idList) {
170         setId_Terms(idList, null);
171     }
172 
173     public void setId_InScope(Collection<String> idList, ConditionOptionCall<IdsQueryBuilder> opLambda) {
174         setId_Terms(idList, opLambda);
175     }
176 
177     @Deprecated
178     public BsKeyMatchCQ addOrderBy_Id_Asc() {
179         regOBA("_id");
180         return this;
181     }
182 
183     @Deprecated
184     public BsKeyMatchCQ addOrderBy_Id_Desc() {
185         regOBD("_id");
186         return this;
187     }
188 
189     public void setBoost_Equal(Float boost) {
190         setBoost_Term(boost, null);
191     }
192 
193     public void setBoost_Equal(Float boost, ConditionOptionCall<TermQueryBuilder> opLambda) {
194         setBoost_Term(boost, opLambda);
195     }
196 
197     public void setBoost_Term(Float boost) {
198         setBoost_Term(boost, null);
199     }
200 
201     public void setBoost_Term(Float boost, ConditionOptionCall<TermQueryBuilder> opLambda) {
202         TermQueryBuilder builder = regTermQ("boost", boost);
203         if (opLambda != null) {
204             opLambda.callback(builder);
205         }
206     }
207 
208     public void setBoost_NotEqual(Float boost) {
209         setBoost_NotTerm(boost, null);
210     }
211 
212     public void setBoost_NotTerm(Float boost) {
213         setBoost_NotTerm(boost, null);
214     }
215 
216     public void setBoost_NotEqual(Float boost, ConditionOptionCall<BoolQueryBuilder> opLambda) {
217         setBoost_NotTerm(boost, opLambda);
218     }
219 
220     public void setBoost_NotTerm(Float boost, ConditionOptionCall<BoolQueryBuilder> opLambda) {
221         not(not -> not.setBoost_Term(boost), opLambda);
222     }
223 
224     public void setBoost_Terms(Collection<Float> boostList) {
225         setBoost_Terms(boostList, null);
226     }
227 
228     public void setBoost_Terms(Collection<Float> boostList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
229         TermsQueryBuilder builder = regTermsQ("boost", boostList);
230         if (opLambda != null) {
231             opLambda.callback(builder);
232         }
233     }
234 
235     public void setBoost_InScope(Collection<Float> boostList) {
236         setBoost_Terms(boostList, null);
237     }
238 
239     public void setBoost_InScope(Collection<Float> boostList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
240         setBoost_Terms(boostList, opLambda);
241     }
242 
243     public void setBoost_Match(Float boost) {
244         setBoost_Match(boost, null);
245     }
246 
247     public void setBoost_Match(Float boost, ConditionOptionCall<MatchQueryBuilder> opLambda) {
248         MatchQueryBuilder builder = regMatchQ("boost", boost);
249         if (opLambda != null) {
250             opLambda.callback(builder);
251         }
252     }
253 
254     public void setBoost_MatchPhrase(Float boost) {
255         setBoost_MatchPhrase(boost, null);
256     }
257 
258     public void setBoost_MatchPhrase(Float boost, ConditionOptionCall<MatchPhraseQueryBuilder> opLambda) {
259         MatchPhraseQueryBuilder builder = regMatchPhraseQ("boost", boost);
260         if (opLambda != null) {
261             opLambda.callback(builder);
262         }
263     }
264 
265     public void setBoost_MatchPhrasePrefix(Float boost) {
266         setBoost_MatchPhrasePrefix(boost, null);
267     }
268 
269     public void setBoost_MatchPhrasePrefix(Float boost, ConditionOptionCall<MatchPhrasePrefixQueryBuilder> opLambda) {
270         MatchPhrasePrefixQueryBuilder builder = regMatchPhrasePrefixQ("boost", boost);
271         if (opLambda != null) {
272             opLambda.callback(builder);
273         }
274     }
275 
276     public void setBoost_Fuzzy(Float boost) {
277         setBoost_Fuzzy(boost, null);
278     }
279 
280     public void setBoost_Fuzzy(Float boost, ConditionOptionCall<MatchQueryBuilder> opLambda) {
281         MatchQueryBuilder builder = regFuzzyQ("boost", boost);
282         if (opLambda != null) {
283             opLambda.callback(builder);
284         }
285     }
286 
287     public void setBoost_GreaterThan(Float boost) {
288         setBoost_GreaterThan(boost, null);
289     }
290 
291     public void setBoost_GreaterThan(Float boost, ConditionOptionCall<RangeQueryBuilder> opLambda) {
292         final Object _value = boost;
293         RangeQueryBuilder builder = regRangeQ("boost", ConditionKey.CK_GREATER_THAN, _value);
294         if (opLambda != null) {
295             opLambda.callback(builder);
296         }
297     }
298 
299     public void setBoost_LessThan(Float boost) {
300         setBoost_LessThan(boost, null);
301     }
302 
303     public void setBoost_LessThan(Float boost, ConditionOptionCall<RangeQueryBuilder> opLambda) {
304         final Object _value = boost;
305         RangeQueryBuilder builder = regRangeQ("boost", ConditionKey.CK_LESS_THAN, _value);
306         if (opLambda != null) {
307             opLambda.callback(builder);
308         }
309     }
310 
311     public void setBoost_GreaterEqual(Float boost) {
312         setBoost_GreaterEqual(boost, null);
313     }
314 
315     public void setBoost_GreaterEqual(Float boost, ConditionOptionCall<RangeQueryBuilder> opLambda) {
316         final Object _value = boost;
317         RangeQueryBuilder builder = regRangeQ("boost", ConditionKey.CK_GREATER_EQUAL, _value);
318         if (opLambda != null) {
319             opLambda.callback(builder);
320         }
321     }
322 
323     public void setBoost_LessEqual(Float boost) {
324         setBoost_LessEqual(boost, null);
325     }
326 
327     public void setBoost_LessEqual(Float boost, ConditionOptionCall<RangeQueryBuilder> opLambda) {
328         final Object _value = boost;
329         RangeQueryBuilder builder = regRangeQ("boost", ConditionKey.CK_LESS_EQUAL, _value);
330         if (opLambda != null) {
331             opLambda.callback(builder);
332         }
333     }
334 
335     public void setBoost_Exists() {
336         setBoost_Exists(null);
337     }
338 
339     public void setBoost_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
340         ExistsQueryBuilder builder = regExistsQ("boost");
341         if (opLambda != null) {
342             opLambda.callback(builder);
343         }
344     }
345 
346     @Deprecated
347     public void setBoost_CommonTerms(Float boost) {
348         setBoost_CommonTerms(boost, null);
349     }
350 
351     @Deprecated
352     public void setBoost_CommonTerms(Float boost, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
353         CommonTermsQueryBuilder builder = regCommonTermsQ("boost", boost);
354         if (opLambda != null) {
355             opLambda.callback(builder);
356         }
357     }
358 
359     public BsKeyMatchCQ addOrderBy_Boost_Asc() {
360         regOBA("boost");
361         return this;
362     }
363 
364     public BsKeyMatchCQ addOrderBy_Boost_Desc() {
365         regOBD("boost");
366         return this;
367     }
368 
369     public void setCreatedBy_Equal(String createdBy) {
370         setCreatedBy_Term(createdBy, null);
371     }
372 
373     public void setCreatedBy_Equal(String createdBy, ConditionOptionCall<TermQueryBuilder> opLambda) {
374         setCreatedBy_Term(createdBy, opLambda);
375     }
376 
377     public void setCreatedBy_Term(String createdBy) {
378         setCreatedBy_Term(createdBy, null);
379     }
380 
381     public void setCreatedBy_Term(String createdBy, ConditionOptionCall<TermQueryBuilder> opLambda) {
382         TermQueryBuilder builder = regTermQ("createdBy", createdBy);
383         if (opLambda != null) {
384             opLambda.callback(builder);
385         }
386     }
387 
388     public void setCreatedBy_NotEqual(String createdBy) {
389         setCreatedBy_NotTerm(createdBy, null);
390     }
391 
392     public void setCreatedBy_NotTerm(String createdBy) {
393         setCreatedBy_NotTerm(createdBy, null);
394     }
395 
396     public void setCreatedBy_NotEqual(String createdBy, ConditionOptionCall<BoolQueryBuilder> opLambda) {
397         setCreatedBy_NotTerm(createdBy, opLambda);
398     }
399 
400     public void setCreatedBy_NotTerm(String createdBy, ConditionOptionCall<BoolQueryBuilder> opLambda) {
401         not(not -> not.setCreatedBy_Term(createdBy), opLambda);
402     }
403 
404     public void setCreatedBy_Terms(Collection<String> createdByList) {
405         setCreatedBy_Terms(createdByList, null);
406     }
407 
408     public void setCreatedBy_Terms(Collection<String> createdByList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
409         TermsQueryBuilder builder = regTermsQ("createdBy", createdByList);
410         if (opLambda != null) {
411             opLambda.callback(builder);
412         }
413     }
414 
415     public void setCreatedBy_InScope(Collection<String> createdByList) {
416         setCreatedBy_Terms(createdByList, null);
417     }
418 
419     public void setCreatedBy_InScope(Collection<String> createdByList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
420         setCreatedBy_Terms(createdByList, opLambda);
421     }
422 
423     public void setCreatedBy_Match(String createdBy) {
424         setCreatedBy_Match(createdBy, null);
425     }
426 
427     public void setCreatedBy_Match(String createdBy, ConditionOptionCall<MatchQueryBuilder> opLambda) {
428         MatchQueryBuilder builder = regMatchQ("createdBy", createdBy);
429         if (opLambda != null) {
430             opLambda.callback(builder);
431         }
432     }
433 
434     public void setCreatedBy_MatchPhrase(String createdBy) {
435         setCreatedBy_MatchPhrase(createdBy, null);
436     }
437 
438     public void setCreatedBy_MatchPhrase(String createdBy, ConditionOptionCall<MatchPhraseQueryBuilder> opLambda) {
439         MatchPhraseQueryBuilder builder = regMatchPhraseQ("createdBy", createdBy);
440         if (opLambda != null) {
441             opLambda.callback(builder);
442         }
443     }
444 
445     public void setCreatedBy_MatchPhrasePrefix(String createdBy) {
446         setCreatedBy_MatchPhrasePrefix(createdBy, null);
447     }
448 
449     public void setCreatedBy_MatchPhrasePrefix(String createdBy, ConditionOptionCall<MatchPhrasePrefixQueryBuilder> opLambda) {
450         MatchPhrasePrefixQueryBuilder builder = regMatchPhrasePrefixQ("createdBy", createdBy);
451         if (opLambda != null) {
452             opLambda.callback(builder);
453         }
454     }
455 
456     public void setCreatedBy_Fuzzy(String createdBy) {
457         setCreatedBy_Fuzzy(createdBy, null);
458     }
459 
460     public void setCreatedBy_Fuzzy(String createdBy, ConditionOptionCall<MatchQueryBuilder> opLambda) {
461         MatchQueryBuilder builder = regFuzzyQ("createdBy", createdBy);
462         if (opLambda != null) {
463             opLambda.callback(builder);
464         }
465     }
466 
467     public void setCreatedBy_Prefix(String createdBy) {
468         setCreatedBy_Prefix(createdBy, null);
469     }
470 
471     public void setCreatedBy_Prefix(String createdBy, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
472         PrefixQueryBuilder builder = regPrefixQ("createdBy", createdBy);
473         if (opLambda != null) {
474             opLambda.callback(builder);
475         }
476     }
477 
478     public void setCreatedBy_Wildcard(String createdBy) {
479         setCreatedBy_Wildcard(createdBy, null);
480     }
481 
482     public void setCreatedBy_Wildcard(String createdBy, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
483         WildcardQueryBuilder builder = regWildcardQ("createdBy", createdBy);
484         if (opLambda != null) {
485             opLambda.callback(builder);
486         }
487     }
488 
489     public void setCreatedBy_Regexp(String createdBy) {
490         setCreatedBy_Regexp(createdBy, null);
491     }
492 
493     public void setCreatedBy_Regexp(String createdBy, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
494         RegexpQueryBuilder builder = regRegexpQ("createdBy", createdBy);
495         if (opLambda != null) {
496             opLambda.callback(builder);
497         }
498     }
499 
500     public void setCreatedBy_SpanTerm(String createdBy) {
501         setCreatedBy_SpanTerm("createdBy", null);
502     }
503 
504     public void setCreatedBy_SpanTerm(String createdBy, ConditionOptionCall<SpanTermQueryBuilder> opLambda) {
505         SpanTermQueryBuilder builder = regSpanTermQ("createdBy", createdBy);
506         if (opLambda != null) {
507             opLambda.callback(builder);
508         }
509     }
510 
511     public void setCreatedBy_GreaterThan(String createdBy) {
512         setCreatedBy_GreaterThan(createdBy, null);
513     }
514 
515     public void setCreatedBy_GreaterThan(String createdBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
516         final Object _value = createdBy;
517         RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_GREATER_THAN, _value);
518         if (opLambda != null) {
519             opLambda.callback(builder);
520         }
521     }
522 
523     public void setCreatedBy_LessThan(String createdBy) {
524         setCreatedBy_LessThan(createdBy, null);
525     }
526 
527     public void setCreatedBy_LessThan(String createdBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
528         final Object _value = createdBy;
529         RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_LESS_THAN, _value);
530         if (opLambda != null) {
531             opLambda.callback(builder);
532         }
533     }
534 
535     public void setCreatedBy_GreaterEqual(String createdBy) {
536         setCreatedBy_GreaterEqual(createdBy, null);
537     }
538 
539     public void setCreatedBy_GreaterEqual(String createdBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
540         final Object _value = createdBy;
541         RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_GREATER_EQUAL, _value);
542         if (opLambda != null) {
543             opLambda.callback(builder);
544         }
545     }
546 
547     public void setCreatedBy_LessEqual(String createdBy) {
548         setCreatedBy_LessEqual(createdBy, null);
549     }
550 
551     public void setCreatedBy_LessEqual(String createdBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
552         final Object _value = createdBy;
553         RangeQueryBuilder builder = regRangeQ("createdBy", ConditionKey.CK_LESS_EQUAL, _value);
554         if (opLambda != null) {
555             opLambda.callback(builder);
556         }
557     }
558 
559     public void setCreatedBy_Exists() {
560         setCreatedBy_Exists(null);
561     }
562 
563     public void setCreatedBy_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
564         ExistsQueryBuilder builder = regExistsQ("createdBy");
565         if (opLambda != null) {
566             opLambda.callback(builder);
567         }
568     }
569 
570     @Deprecated
571     public void setCreatedBy_CommonTerms(String createdBy) {
572         setCreatedBy_CommonTerms(createdBy, null);
573     }
574 
575     @Deprecated
576     public void setCreatedBy_CommonTerms(String createdBy, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
577         CommonTermsQueryBuilder builder = regCommonTermsQ("createdBy", createdBy);
578         if (opLambda != null) {
579             opLambda.callback(builder);
580         }
581     }
582 
583     public BsKeyMatchCQ addOrderBy_CreatedBy_Asc() {
584         regOBA("createdBy");
585         return this;
586     }
587 
588     public BsKeyMatchCQ addOrderBy_CreatedBy_Desc() {
589         regOBD("createdBy");
590         return this;
591     }
592 
593     public void setCreatedTime_Equal(Long createdTime) {
594         setCreatedTime_Term(createdTime, null);
595     }
596 
597     public void setCreatedTime_Equal(Long createdTime, ConditionOptionCall<TermQueryBuilder> opLambda) {
598         setCreatedTime_Term(createdTime, opLambda);
599     }
600 
601     public void setCreatedTime_Term(Long createdTime) {
602         setCreatedTime_Term(createdTime, null);
603     }
604 
605     public void setCreatedTime_Term(Long createdTime, ConditionOptionCall<TermQueryBuilder> opLambda) {
606         TermQueryBuilder builder = regTermQ("createdTime", createdTime);
607         if (opLambda != null) {
608             opLambda.callback(builder);
609         }
610     }
611 
612     public void setCreatedTime_NotEqual(Long createdTime) {
613         setCreatedTime_NotTerm(createdTime, null);
614     }
615 
616     public void setCreatedTime_NotTerm(Long createdTime) {
617         setCreatedTime_NotTerm(createdTime, null);
618     }
619 
620     public void setCreatedTime_NotEqual(Long createdTime, ConditionOptionCall<BoolQueryBuilder> opLambda) {
621         setCreatedTime_NotTerm(createdTime, opLambda);
622     }
623 
624     public void setCreatedTime_NotTerm(Long createdTime, ConditionOptionCall<BoolQueryBuilder> opLambda) {
625         not(not -> not.setCreatedTime_Term(createdTime), opLambda);
626     }
627 
628     public void setCreatedTime_Terms(Collection<Long> createdTimeList) {
629         setCreatedTime_Terms(createdTimeList, null);
630     }
631 
632     public void setCreatedTime_Terms(Collection<Long> createdTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
633         TermsQueryBuilder builder = regTermsQ("createdTime", createdTimeList);
634         if (opLambda != null) {
635             opLambda.callback(builder);
636         }
637     }
638 
639     public void setCreatedTime_InScope(Collection<Long> createdTimeList) {
640         setCreatedTime_Terms(createdTimeList, null);
641     }
642 
643     public void setCreatedTime_InScope(Collection<Long> createdTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
644         setCreatedTime_Terms(createdTimeList, opLambda);
645     }
646 
647     public void setCreatedTime_Match(Long createdTime) {
648         setCreatedTime_Match(createdTime, null);
649     }
650 
651     public void setCreatedTime_Match(Long createdTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
652         MatchQueryBuilder builder = regMatchQ("createdTime", createdTime);
653         if (opLambda != null) {
654             opLambda.callback(builder);
655         }
656     }
657 
658     public void setCreatedTime_MatchPhrase(Long createdTime) {
659         setCreatedTime_MatchPhrase(createdTime, null);
660     }
661 
662     public void setCreatedTime_MatchPhrase(Long createdTime, ConditionOptionCall<MatchPhraseQueryBuilder> opLambda) {
663         MatchPhraseQueryBuilder builder = regMatchPhraseQ("createdTime", createdTime);
664         if (opLambda != null) {
665             opLambda.callback(builder);
666         }
667     }
668 
669     public void setCreatedTime_MatchPhrasePrefix(Long createdTime) {
670         setCreatedTime_MatchPhrasePrefix(createdTime, null);
671     }
672 
673     public void setCreatedTime_MatchPhrasePrefix(Long createdTime, ConditionOptionCall<MatchPhrasePrefixQueryBuilder> opLambda) {
674         MatchPhrasePrefixQueryBuilder builder = regMatchPhrasePrefixQ("createdTime", createdTime);
675         if (opLambda != null) {
676             opLambda.callback(builder);
677         }
678     }
679 
680     public void setCreatedTime_Fuzzy(Long createdTime) {
681         setCreatedTime_Fuzzy(createdTime, null);
682     }
683 
684     public void setCreatedTime_Fuzzy(Long createdTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
685         MatchQueryBuilder builder = regFuzzyQ("createdTime", createdTime);
686         if (opLambda != null) {
687             opLambda.callback(builder);
688         }
689     }
690 
691     public void setCreatedTime_GreaterThan(Long createdTime) {
692         setCreatedTime_GreaterThan(createdTime, null);
693     }
694 
695     public void setCreatedTime_GreaterThan(Long createdTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
696         final Object _value = createdTime;
697         RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_THAN, _value);
698         if (opLambda != null) {
699             opLambda.callback(builder);
700         }
701     }
702 
703     public void setCreatedTime_LessThan(Long createdTime) {
704         setCreatedTime_LessThan(createdTime, null);
705     }
706 
707     public void setCreatedTime_LessThan(Long createdTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
708         final Object _value = createdTime;
709         RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_THAN, _value);
710         if (opLambda != null) {
711             opLambda.callback(builder);
712         }
713     }
714 
715     public void setCreatedTime_GreaterEqual(Long createdTime) {
716         setCreatedTime_GreaterEqual(createdTime, null);
717     }
718 
719     public void setCreatedTime_GreaterEqual(Long createdTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
720         final Object _value = createdTime;
721         RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_GREATER_EQUAL, _value);
722         if (opLambda != null) {
723             opLambda.callback(builder);
724         }
725     }
726 
727     public void setCreatedTime_LessEqual(Long createdTime) {
728         setCreatedTime_LessEqual(createdTime, null);
729     }
730 
731     public void setCreatedTime_LessEqual(Long createdTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
732         final Object _value = createdTime;
733         RangeQueryBuilder builder = regRangeQ("createdTime", ConditionKey.CK_LESS_EQUAL, _value);
734         if (opLambda != null) {
735             opLambda.callback(builder);
736         }
737     }
738 
739     public void setCreatedTime_Exists() {
740         setCreatedTime_Exists(null);
741     }
742 
743     public void setCreatedTime_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
744         ExistsQueryBuilder builder = regExistsQ("createdTime");
745         if (opLambda != null) {
746             opLambda.callback(builder);
747         }
748     }
749 
750     @Deprecated
751     public void setCreatedTime_CommonTerms(Long createdTime) {
752         setCreatedTime_CommonTerms(createdTime, null);
753     }
754 
755     @Deprecated
756     public void setCreatedTime_CommonTerms(Long createdTime, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
757         CommonTermsQueryBuilder builder = regCommonTermsQ("createdTime", createdTime);
758         if (opLambda != null) {
759             opLambda.callback(builder);
760         }
761     }
762 
763     public BsKeyMatchCQ addOrderBy_CreatedTime_Asc() {
764         regOBA("createdTime");
765         return this;
766     }
767 
768     public BsKeyMatchCQ addOrderBy_CreatedTime_Desc() {
769         regOBD("createdTime");
770         return this;
771     }
772 
773     public void setMaxSize_Equal(Integer maxSize) {
774         setMaxSize_Term(maxSize, null);
775     }
776 
777     public void setMaxSize_Equal(Integer maxSize, ConditionOptionCall<TermQueryBuilder> opLambda) {
778         setMaxSize_Term(maxSize, opLambda);
779     }
780 
781     public void setMaxSize_Term(Integer maxSize) {
782         setMaxSize_Term(maxSize, null);
783     }
784 
785     public void setMaxSize_Term(Integer maxSize, ConditionOptionCall<TermQueryBuilder> opLambda) {
786         TermQueryBuilder builder = regTermQ("maxSize", maxSize);
787         if (opLambda != null) {
788             opLambda.callback(builder);
789         }
790     }
791 
792     public void setMaxSize_NotEqual(Integer maxSize) {
793         setMaxSize_NotTerm(maxSize, null);
794     }
795 
796     public void setMaxSize_NotTerm(Integer maxSize) {
797         setMaxSize_NotTerm(maxSize, null);
798     }
799 
800     public void setMaxSize_NotEqual(Integer maxSize, ConditionOptionCall<BoolQueryBuilder> opLambda) {
801         setMaxSize_NotTerm(maxSize, opLambda);
802     }
803 
804     public void setMaxSize_NotTerm(Integer maxSize, ConditionOptionCall<BoolQueryBuilder> opLambda) {
805         not(not -> not.setMaxSize_Term(maxSize), opLambda);
806     }
807 
808     public void setMaxSize_Terms(Collection<Integer> maxSizeList) {
809         setMaxSize_Terms(maxSizeList, null);
810     }
811 
812     public void setMaxSize_Terms(Collection<Integer> maxSizeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
813         TermsQueryBuilder builder = regTermsQ("maxSize", maxSizeList);
814         if (opLambda != null) {
815             opLambda.callback(builder);
816         }
817     }
818 
819     public void setMaxSize_InScope(Collection<Integer> maxSizeList) {
820         setMaxSize_Terms(maxSizeList, null);
821     }
822 
823     public void setMaxSize_InScope(Collection<Integer> maxSizeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
824         setMaxSize_Terms(maxSizeList, opLambda);
825     }
826 
827     public void setMaxSize_Match(Integer maxSize) {
828         setMaxSize_Match(maxSize, null);
829     }
830 
831     public void setMaxSize_Match(Integer maxSize, ConditionOptionCall<MatchQueryBuilder> opLambda) {
832         MatchQueryBuilder builder = regMatchQ("maxSize", maxSize);
833         if (opLambda != null) {
834             opLambda.callback(builder);
835         }
836     }
837 
838     public void setMaxSize_MatchPhrase(Integer maxSize) {
839         setMaxSize_MatchPhrase(maxSize, null);
840     }
841 
842     public void setMaxSize_MatchPhrase(Integer maxSize, ConditionOptionCall<MatchPhraseQueryBuilder> opLambda) {
843         MatchPhraseQueryBuilder builder = regMatchPhraseQ("maxSize", maxSize);
844         if (opLambda != null) {
845             opLambda.callback(builder);
846         }
847     }
848 
849     public void setMaxSize_MatchPhrasePrefix(Integer maxSize) {
850         setMaxSize_MatchPhrasePrefix(maxSize, null);
851     }
852 
853     public void setMaxSize_MatchPhrasePrefix(Integer maxSize, ConditionOptionCall<MatchPhrasePrefixQueryBuilder> opLambda) {
854         MatchPhrasePrefixQueryBuilder builder = regMatchPhrasePrefixQ("maxSize", maxSize);
855         if (opLambda != null) {
856             opLambda.callback(builder);
857         }
858     }
859 
860     public void setMaxSize_Fuzzy(Integer maxSize) {
861         setMaxSize_Fuzzy(maxSize, null);
862     }
863 
864     public void setMaxSize_Fuzzy(Integer maxSize, ConditionOptionCall<MatchQueryBuilder> opLambda) {
865         MatchQueryBuilder builder = regFuzzyQ("maxSize", maxSize);
866         if (opLambda != null) {
867             opLambda.callback(builder);
868         }
869     }
870 
871     public void setMaxSize_GreaterThan(Integer maxSize) {
872         setMaxSize_GreaterThan(maxSize, null);
873     }
874 
875     public void setMaxSize_GreaterThan(Integer maxSize, ConditionOptionCall<RangeQueryBuilder> opLambda) {
876         final Object _value = maxSize;
877         RangeQueryBuilder builder = regRangeQ("maxSize", ConditionKey.CK_GREATER_THAN, _value);
878         if (opLambda != null) {
879             opLambda.callback(builder);
880         }
881     }
882 
883     public void setMaxSize_LessThan(Integer maxSize) {
884         setMaxSize_LessThan(maxSize, null);
885     }
886 
887     public void setMaxSize_LessThan(Integer maxSize, ConditionOptionCall<RangeQueryBuilder> opLambda) {
888         final Object _value = maxSize;
889         RangeQueryBuilder builder = regRangeQ("maxSize", ConditionKey.CK_LESS_THAN, _value);
890         if (opLambda != null) {
891             opLambda.callback(builder);
892         }
893     }
894 
895     public void setMaxSize_GreaterEqual(Integer maxSize) {
896         setMaxSize_GreaterEqual(maxSize, null);
897     }
898 
899     public void setMaxSize_GreaterEqual(Integer maxSize, ConditionOptionCall<RangeQueryBuilder> opLambda) {
900         final Object _value = maxSize;
901         RangeQueryBuilder builder = regRangeQ("maxSize", ConditionKey.CK_GREATER_EQUAL, _value);
902         if (opLambda != null) {
903             opLambda.callback(builder);
904         }
905     }
906 
907     public void setMaxSize_LessEqual(Integer maxSize) {
908         setMaxSize_LessEqual(maxSize, null);
909     }
910 
911     public void setMaxSize_LessEqual(Integer maxSize, ConditionOptionCall<RangeQueryBuilder> opLambda) {
912         final Object _value = maxSize;
913         RangeQueryBuilder builder = regRangeQ("maxSize", ConditionKey.CK_LESS_EQUAL, _value);
914         if (opLambda != null) {
915             opLambda.callback(builder);
916         }
917     }
918 
919     public void setMaxSize_Exists() {
920         setMaxSize_Exists(null);
921     }
922 
923     public void setMaxSize_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
924         ExistsQueryBuilder builder = regExistsQ("maxSize");
925         if (opLambda != null) {
926             opLambda.callback(builder);
927         }
928     }
929 
930     @Deprecated
931     public void setMaxSize_CommonTerms(Integer maxSize) {
932         setMaxSize_CommonTerms(maxSize, null);
933     }
934 
935     @Deprecated
936     public void setMaxSize_CommonTerms(Integer maxSize, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
937         CommonTermsQueryBuilder builder = regCommonTermsQ("maxSize", maxSize);
938         if (opLambda != null) {
939             opLambda.callback(builder);
940         }
941     }
942 
943     public BsKeyMatchCQ addOrderBy_MaxSize_Asc() {
944         regOBA("maxSize");
945         return this;
946     }
947 
948     public BsKeyMatchCQ addOrderBy_MaxSize_Desc() {
949         regOBD("maxSize");
950         return this;
951     }
952 
953     public void setQuery_Equal(String query) {
954         setQuery_Term(query, null);
955     }
956 
957     public void setQuery_Equal(String query, ConditionOptionCall<TermQueryBuilder> opLambda) {
958         setQuery_Term(query, opLambda);
959     }
960 
961     public void setQuery_Term(String query) {
962         setQuery_Term(query, null);
963     }
964 
965     public void setQuery_Term(String query, ConditionOptionCall<TermQueryBuilder> opLambda) {
966         TermQueryBuilder builder = regTermQ("query", query);
967         if (opLambda != null) {
968             opLambda.callback(builder);
969         }
970     }
971 
972     public void setQuery_NotEqual(String query) {
973         setQuery_NotTerm(query, null);
974     }
975 
976     public void setQuery_NotTerm(String query) {
977         setQuery_NotTerm(query, null);
978     }
979 
980     public void setQuery_NotEqual(String query, ConditionOptionCall<BoolQueryBuilder> opLambda) {
981         setQuery_NotTerm(query, opLambda);
982     }
983 
984     public void setQuery_NotTerm(String query, ConditionOptionCall<BoolQueryBuilder> opLambda) {
985         not(not -> not.setQuery_Term(query), opLambda);
986     }
987 
988     public void setQuery_Terms(Collection<String> queryList) {
989         setQuery_Terms(queryList, null);
990     }
991 
992     public void setQuery_Terms(Collection<String> queryList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
993         TermsQueryBuilder builder = regTermsQ("query", queryList);
994         if (opLambda != null) {
995             opLambda.callback(builder);
996         }
997     }
998 
999     public void setQuery_InScope(Collection<String> queryList) {
1000         setQuery_Terms(queryList, null);
1001     }
1002 
1003     public void setQuery_InScope(Collection<String> queryList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
1004         setQuery_Terms(queryList, opLambda);
1005     }
1006 
1007     public void setQuery_Match(String query) {
1008         setQuery_Match(query, null);
1009     }
1010 
1011     public void setQuery_Match(String query, ConditionOptionCall<MatchQueryBuilder> opLambda) {
1012         MatchQueryBuilder builder = regMatchQ("query", query);
1013         if (opLambda != null) {
1014             opLambda.callback(builder);
1015         }
1016     }
1017 
1018     public void setQuery_MatchPhrase(String query) {
1019         setQuery_MatchPhrase(query, null);
1020     }
1021 
1022     public void setQuery_MatchPhrase(String query, ConditionOptionCall<MatchPhraseQueryBuilder> opLambda) {
1023         MatchPhraseQueryBuilder builder = regMatchPhraseQ("query", query);
1024         if (opLambda != null) {
1025             opLambda.callback(builder);
1026         }
1027     }
1028 
1029     public void setQuery_MatchPhrasePrefix(String query) {
1030         setQuery_MatchPhrasePrefix(query, null);
1031     }
1032 
1033     public void setQuery_MatchPhrasePrefix(String query, ConditionOptionCall<MatchPhrasePrefixQueryBuilder> opLambda) {
1034         MatchPhrasePrefixQueryBuilder builder = regMatchPhrasePrefixQ("query", query);
1035         if (opLambda != null) {
1036             opLambda.callback(builder);
1037         }
1038     }
1039 
1040     public void setQuery_Fuzzy(String query) {
1041         setQuery_Fuzzy(query, null);
1042     }
1043 
1044     public void setQuery_Fuzzy(String query, ConditionOptionCall<MatchQueryBuilder> opLambda) {
1045         MatchQueryBuilder builder = regFuzzyQ("query", query);
1046         if (opLambda != null) {
1047             opLambda.callback(builder);
1048         }
1049     }
1050 
1051     public void setQuery_Prefix(String query) {
1052         setQuery_Prefix(query, null);
1053     }
1054 
1055     public void setQuery_Prefix(String query, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
1056         PrefixQueryBuilder builder = regPrefixQ("query", query);
1057         if (opLambda != null) {
1058             opLambda.callback(builder);
1059         }
1060     }
1061 
1062     public void setQuery_Wildcard(String query) {
1063         setQuery_Wildcard(query, null);
1064     }
1065 
1066     public void setQuery_Wildcard(String query, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
1067         WildcardQueryBuilder builder = regWildcardQ("query", query);
1068         if (opLambda != null) {
1069             opLambda.callback(builder);
1070         }
1071     }
1072 
1073     public void setQuery_Regexp(String query) {
1074         setQuery_Regexp(query, null);
1075     }
1076 
1077     public void setQuery_Regexp(String query, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
1078         RegexpQueryBuilder builder = regRegexpQ("query", query);
1079         if (opLambda != null) {
1080             opLambda.callback(builder);
1081         }
1082     }
1083 
1084     public void setQuery_SpanTerm(String query) {
1085         setQuery_SpanTerm("query", null);
1086     }
1087 
1088     public void setQuery_SpanTerm(String query, ConditionOptionCall<SpanTermQueryBuilder> opLambda) {
1089         SpanTermQueryBuilder builder = regSpanTermQ("query", query);
1090         if (opLambda != null) {
1091             opLambda.callback(builder);
1092         }
1093     }
1094 
1095     public void setQuery_GreaterThan(String query) {
1096         setQuery_GreaterThan(query, null);
1097     }
1098 
1099     public void setQuery_GreaterThan(String query, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1100         final Object _value = query;
1101         RangeQueryBuilder builder = regRangeQ("query", ConditionKey.CK_GREATER_THAN, _value);
1102         if (opLambda != null) {
1103             opLambda.callback(builder);
1104         }
1105     }
1106 
1107     public void setQuery_LessThan(String query) {
1108         setQuery_LessThan(query, null);
1109     }
1110 
1111     public void setQuery_LessThan(String query, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1112         final Object _value = query;
1113         RangeQueryBuilder builder = regRangeQ("query", ConditionKey.CK_LESS_THAN, _value);
1114         if (opLambda != null) {
1115             opLambda.callback(builder);
1116         }
1117     }
1118 
1119     public void setQuery_GreaterEqual(String query) {
1120         setQuery_GreaterEqual(query, null);
1121     }
1122 
1123     public void setQuery_GreaterEqual(String query, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1124         final Object _value = query;
1125         RangeQueryBuilder builder = regRangeQ("query", ConditionKey.CK_GREATER_EQUAL, _value);
1126         if (opLambda != null) {
1127             opLambda.callback(builder);
1128         }
1129     }
1130 
1131     public void setQuery_LessEqual(String query) {
1132         setQuery_LessEqual(query, null);
1133     }
1134 
1135     public void setQuery_LessEqual(String query, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1136         final Object _value = query;
1137         RangeQueryBuilder builder = regRangeQ("query", ConditionKey.CK_LESS_EQUAL, _value);
1138         if (opLambda != null) {
1139             opLambda.callback(builder);
1140         }
1141     }
1142 
1143     public void setQuery_Exists() {
1144         setQuery_Exists(null);
1145     }
1146 
1147     public void setQuery_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
1148         ExistsQueryBuilder builder = regExistsQ("query");
1149         if (opLambda != null) {
1150             opLambda.callback(builder);
1151         }
1152     }
1153 
1154     @Deprecated
1155     public void setQuery_CommonTerms(String query) {
1156         setQuery_CommonTerms(query, null);
1157     }
1158 
1159     @Deprecated
1160     public void setQuery_CommonTerms(String query, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
1161         CommonTermsQueryBuilder builder = regCommonTermsQ("query", query);
1162         if (opLambda != null) {
1163             opLambda.callback(builder);
1164         }
1165     }
1166 
1167     public BsKeyMatchCQ addOrderBy_Query_Asc() {
1168         regOBA("query");
1169         return this;
1170     }
1171 
1172     public BsKeyMatchCQ addOrderBy_Query_Desc() {
1173         regOBD("query");
1174         return this;
1175     }
1176 
1177     public void setTerm_Equal(String term) {
1178         setTerm_Term(term, null);
1179     }
1180 
1181     public void setTerm_Equal(String term, ConditionOptionCall<TermQueryBuilder> opLambda) {
1182         setTerm_Term(term, opLambda);
1183     }
1184 
1185     public void setTerm_Term(String term) {
1186         setTerm_Term(term, null);
1187     }
1188 
1189     public void setTerm_Term(String term, ConditionOptionCall<TermQueryBuilder> opLambda) {
1190         TermQueryBuilder builder = regTermQ("term", term);
1191         if (opLambda != null) {
1192             opLambda.callback(builder);
1193         }
1194     }
1195 
1196     public void setTerm_NotEqual(String term) {
1197         setTerm_NotTerm(term, null);
1198     }
1199 
1200     public void setTerm_NotTerm(String term) {
1201         setTerm_NotTerm(term, null);
1202     }
1203 
1204     public void setTerm_NotEqual(String term, ConditionOptionCall<BoolQueryBuilder> opLambda) {
1205         setTerm_NotTerm(term, opLambda);
1206     }
1207 
1208     public void setTerm_NotTerm(String term, ConditionOptionCall<BoolQueryBuilder> opLambda) {
1209         not(not -> not.setTerm_Term(term), opLambda);
1210     }
1211 
1212     public void setTerm_Terms(Collection<String> termList) {
1213         setTerm_Terms(termList, null);
1214     }
1215 
1216     public void setTerm_Terms(Collection<String> termList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
1217         TermsQueryBuilder builder = regTermsQ("term", termList);
1218         if (opLambda != null) {
1219             opLambda.callback(builder);
1220         }
1221     }
1222 
1223     public void setTerm_InScope(Collection<String> termList) {
1224         setTerm_Terms(termList, null);
1225     }
1226 
1227     public void setTerm_InScope(Collection<String> termList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
1228         setTerm_Terms(termList, opLambda);
1229     }
1230 
1231     public void setTerm_Match(String term) {
1232         setTerm_Match(term, null);
1233     }
1234 
1235     public void setTerm_Match(String term, ConditionOptionCall<MatchQueryBuilder> opLambda) {
1236         MatchQueryBuilder builder = regMatchQ("term", term);
1237         if (opLambda != null) {
1238             opLambda.callback(builder);
1239         }
1240     }
1241 
1242     public void setTerm_MatchPhrase(String term) {
1243         setTerm_MatchPhrase(term, null);
1244     }
1245 
1246     public void setTerm_MatchPhrase(String term, ConditionOptionCall<MatchPhraseQueryBuilder> opLambda) {
1247         MatchPhraseQueryBuilder builder = regMatchPhraseQ("term", term);
1248         if (opLambda != null) {
1249             opLambda.callback(builder);
1250         }
1251     }
1252 
1253     public void setTerm_MatchPhrasePrefix(String term) {
1254         setTerm_MatchPhrasePrefix(term, null);
1255     }
1256 
1257     public void setTerm_MatchPhrasePrefix(String term, ConditionOptionCall<MatchPhrasePrefixQueryBuilder> opLambda) {
1258         MatchPhrasePrefixQueryBuilder builder = regMatchPhrasePrefixQ("term", term);
1259         if (opLambda != null) {
1260             opLambda.callback(builder);
1261         }
1262     }
1263 
1264     public void setTerm_Fuzzy(String term) {
1265         setTerm_Fuzzy(term, null);
1266     }
1267 
1268     public void setTerm_Fuzzy(String term, ConditionOptionCall<MatchQueryBuilder> opLambda) {
1269         MatchQueryBuilder builder = regFuzzyQ("term", term);
1270         if (opLambda != null) {
1271             opLambda.callback(builder);
1272         }
1273     }
1274 
1275     public void setTerm_Prefix(String term) {
1276         setTerm_Prefix(term, null);
1277     }
1278 
1279     public void setTerm_Prefix(String term, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
1280         PrefixQueryBuilder builder = regPrefixQ("term", term);
1281         if (opLambda != null) {
1282             opLambda.callback(builder);
1283         }
1284     }
1285 
1286     public void setTerm_Wildcard(String term) {
1287         setTerm_Wildcard(term, null);
1288     }
1289 
1290     public void setTerm_Wildcard(String term, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
1291         WildcardQueryBuilder builder = regWildcardQ("term", term);
1292         if (opLambda != null) {
1293             opLambda.callback(builder);
1294         }
1295     }
1296 
1297     public void setTerm_Regexp(String term) {
1298         setTerm_Regexp(term, null);
1299     }
1300 
1301     public void setTerm_Regexp(String term, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
1302         RegexpQueryBuilder builder = regRegexpQ("term", term);
1303         if (opLambda != null) {
1304             opLambda.callback(builder);
1305         }
1306     }
1307 
1308     public void setTerm_SpanTerm(String term) {
1309         setTerm_SpanTerm("term", null);
1310     }
1311 
1312     public void setTerm_SpanTerm(String term, ConditionOptionCall<SpanTermQueryBuilder> opLambda) {
1313         SpanTermQueryBuilder builder = regSpanTermQ("term", term);
1314         if (opLambda != null) {
1315             opLambda.callback(builder);
1316         }
1317     }
1318 
1319     public void setTerm_GreaterThan(String term) {
1320         setTerm_GreaterThan(term, null);
1321     }
1322 
1323     public void setTerm_GreaterThan(String term, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1324         final Object _value = term;
1325         RangeQueryBuilder builder = regRangeQ("term", ConditionKey.CK_GREATER_THAN, _value);
1326         if (opLambda != null) {
1327             opLambda.callback(builder);
1328         }
1329     }
1330 
1331     public void setTerm_LessThan(String term) {
1332         setTerm_LessThan(term, null);
1333     }
1334 
1335     public void setTerm_LessThan(String term, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1336         final Object _value = term;
1337         RangeQueryBuilder builder = regRangeQ("term", ConditionKey.CK_LESS_THAN, _value);
1338         if (opLambda != null) {
1339             opLambda.callback(builder);
1340         }
1341     }
1342 
1343     public void setTerm_GreaterEqual(String term) {
1344         setTerm_GreaterEqual(term, null);
1345     }
1346 
1347     public void setTerm_GreaterEqual(String term, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1348         final Object _value = term;
1349         RangeQueryBuilder builder = regRangeQ("term", ConditionKey.CK_GREATER_EQUAL, _value);
1350         if (opLambda != null) {
1351             opLambda.callback(builder);
1352         }
1353     }
1354 
1355     public void setTerm_LessEqual(String term) {
1356         setTerm_LessEqual(term, null);
1357     }
1358 
1359     public void setTerm_LessEqual(String term, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1360         final Object _value = term;
1361         RangeQueryBuilder builder = regRangeQ("term", ConditionKey.CK_LESS_EQUAL, _value);
1362         if (opLambda != null) {
1363             opLambda.callback(builder);
1364         }
1365     }
1366 
1367     public void setTerm_Exists() {
1368         setTerm_Exists(null);
1369     }
1370 
1371     public void setTerm_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
1372         ExistsQueryBuilder builder = regExistsQ("term");
1373         if (opLambda != null) {
1374             opLambda.callback(builder);
1375         }
1376     }
1377 
1378     @Deprecated
1379     public void setTerm_CommonTerms(String term) {
1380         setTerm_CommonTerms(term, null);
1381     }
1382 
1383     @Deprecated
1384     public void setTerm_CommonTerms(String term, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
1385         CommonTermsQueryBuilder builder = regCommonTermsQ("term", term);
1386         if (opLambda != null) {
1387             opLambda.callback(builder);
1388         }
1389     }
1390 
1391     public BsKeyMatchCQ addOrderBy_Term_Asc() {
1392         regOBA("term");
1393         return this;
1394     }
1395 
1396     public BsKeyMatchCQ addOrderBy_Term_Desc() {
1397         regOBD("term");
1398         return this;
1399     }
1400 
1401     public void setUpdatedBy_Equal(String updatedBy) {
1402         setUpdatedBy_Term(updatedBy, null);
1403     }
1404 
1405     public void setUpdatedBy_Equal(String updatedBy, ConditionOptionCall<TermQueryBuilder> opLambda) {
1406         setUpdatedBy_Term(updatedBy, opLambda);
1407     }
1408 
1409     public void setUpdatedBy_Term(String updatedBy) {
1410         setUpdatedBy_Term(updatedBy, null);
1411     }
1412 
1413     public void setUpdatedBy_Term(String updatedBy, ConditionOptionCall<TermQueryBuilder> opLambda) {
1414         TermQueryBuilder builder = regTermQ("updatedBy", updatedBy);
1415         if (opLambda != null) {
1416             opLambda.callback(builder);
1417         }
1418     }
1419 
1420     public void setUpdatedBy_NotEqual(String updatedBy) {
1421         setUpdatedBy_NotTerm(updatedBy, null);
1422     }
1423 
1424     public void setUpdatedBy_NotTerm(String updatedBy) {
1425         setUpdatedBy_NotTerm(updatedBy, null);
1426     }
1427 
1428     public void setUpdatedBy_NotEqual(String updatedBy, ConditionOptionCall<BoolQueryBuilder> opLambda) {
1429         setUpdatedBy_NotTerm(updatedBy, opLambda);
1430     }
1431 
1432     public void setUpdatedBy_NotTerm(String updatedBy, ConditionOptionCall<BoolQueryBuilder> opLambda) {
1433         not(not -> not.setUpdatedBy_Term(updatedBy), opLambda);
1434     }
1435 
1436     public void setUpdatedBy_Terms(Collection<String> updatedByList) {
1437         setUpdatedBy_Terms(updatedByList, null);
1438     }
1439 
1440     public void setUpdatedBy_Terms(Collection<String> updatedByList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
1441         TermsQueryBuilder builder = regTermsQ("updatedBy", updatedByList);
1442         if (opLambda != null) {
1443             opLambda.callback(builder);
1444         }
1445     }
1446 
1447     public void setUpdatedBy_InScope(Collection<String> updatedByList) {
1448         setUpdatedBy_Terms(updatedByList, null);
1449     }
1450 
1451     public void setUpdatedBy_InScope(Collection<String> updatedByList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
1452         setUpdatedBy_Terms(updatedByList, opLambda);
1453     }
1454 
1455     public void setUpdatedBy_Match(String updatedBy) {
1456         setUpdatedBy_Match(updatedBy, null);
1457     }
1458 
1459     public void setUpdatedBy_Match(String updatedBy, ConditionOptionCall<MatchQueryBuilder> opLambda) {
1460         MatchQueryBuilder builder = regMatchQ("updatedBy", updatedBy);
1461         if (opLambda != null) {
1462             opLambda.callback(builder);
1463         }
1464     }
1465 
1466     public void setUpdatedBy_MatchPhrase(String updatedBy) {
1467         setUpdatedBy_MatchPhrase(updatedBy, null);
1468     }
1469 
1470     public void setUpdatedBy_MatchPhrase(String updatedBy, ConditionOptionCall<MatchPhraseQueryBuilder> opLambda) {
1471         MatchPhraseQueryBuilder builder = regMatchPhraseQ("updatedBy", updatedBy);
1472         if (opLambda != null) {
1473             opLambda.callback(builder);
1474         }
1475     }
1476 
1477     public void setUpdatedBy_MatchPhrasePrefix(String updatedBy) {
1478         setUpdatedBy_MatchPhrasePrefix(updatedBy, null);
1479     }
1480 
1481     public void setUpdatedBy_MatchPhrasePrefix(String updatedBy, ConditionOptionCall<MatchPhrasePrefixQueryBuilder> opLambda) {
1482         MatchPhrasePrefixQueryBuilder builder = regMatchPhrasePrefixQ("updatedBy", updatedBy);
1483         if (opLambda != null) {
1484             opLambda.callback(builder);
1485         }
1486     }
1487 
1488     public void setUpdatedBy_Fuzzy(String updatedBy) {
1489         setUpdatedBy_Fuzzy(updatedBy, null);
1490     }
1491 
1492     public void setUpdatedBy_Fuzzy(String updatedBy, ConditionOptionCall<MatchQueryBuilder> opLambda) {
1493         MatchQueryBuilder builder = regFuzzyQ("updatedBy", updatedBy);
1494         if (opLambda != null) {
1495             opLambda.callback(builder);
1496         }
1497     }
1498 
1499     public void setUpdatedBy_Prefix(String updatedBy) {
1500         setUpdatedBy_Prefix(updatedBy, null);
1501     }
1502 
1503     public void setUpdatedBy_Prefix(String updatedBy, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
1504         PrefixQueryBuilder builder = regPrefixQ("updatedBy", updatedBy);
1505         if (opLambda != null) {
1506             opLambda.callback(builder);
1507         }
1508     }
1509 
1510     public void setUpdatedBy_Wildcard(String updatedBy) {
1511         setUpdatedBy_Wildcard(updatedBy, null);
1512     }
1513 
1514     public void setUpdatedBy_Wildcard(String updatedBy, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
1515         WildcardQueryBuilder builder = regWildcardQ("updatedBy", updatedBy);
1516         if (opLambda != null) {
1517             opLambda.callback(builder);
1518         }
1519     }
1520 
1521     public void setUpdatedBy_Regexp(String updatedBy) {
1522         setUpdatedBy_Regexp(updatedBy, null);
1523     }
1524 
1525     public void setUpdatedBy_Regexp(String updatedBy, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
1526         RegexpQueryBuilder builder = regRegexpQ("updatedBy", updatedBy);
1527         if (opLambda != null) {
1528             opLambda.callback(builder);
1529         }
1530     }
1531 
1532     public void setUpdatedBy_SpanTerm(String updatedBy) {
1533         setUpdatedBy_SpanTerm("updatedBy", null);
1534     }
1535 
1536     public void setUpdatedBy_SpanTerm(String updatedBy, ConditionOptionCall<SpanTermQueryBuilder> opLambda) {
1537         SpanTermQueryBuilder builder = regSpanTermQ("updatedBy", updatedBy);
1538         if (opLambda != null) {
1539             opLambda.callback(builder);
1540         }
1541     }
1542 
1543     public void setUpdatedBy_GreaterThan(String updatedBy) {
1544         setUpdatedBy_GreaterThan(updatedBy, null);
1545     }
1546 
1547     public void setUpdatedBy_GreaterThan(String updatedBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1548         final Object _value = updatedBy;
1549         RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_GREATER_THAN, _value);
1550         if (opLambda != null) {
1551             opLambda.callback(builder);
1552         }
1553     }
1554 
1555     public void setUpdatedBy_LessThan(String updatedBy) {
1556         setUpdatedBy_LessThan(updatedBy, null);
1557     }
1558 
1559     public void setUpdatedBy_LessThan(String updatedBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1560         final Object _value = updatedBy;
1561         RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_LESS_THAN, _value);
1562         if (opLambda != null) {
1563             opLambda.callback(builder);
1564         }
1565     }
1566 
1567     public void setUpdatedBy_GreaterEqual(String updatedBy) {
1568         setUpdatedBy_GreaterEqual(updatedBy, null);
1569     }
1570 
1571     public void setUpdatedBy_GreaterEqual(String updatedBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1572         final Object _value = updatedBy;
1573         RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_GREATER_EQUAL, _value);
1574         if (opLambda != null) {
1575             opLambda.callback(builder);
1576         }
1577     }
1578 
1579     public void setUpdatedBy_LessEqual(String updatedBy) {
1580         setUpdatedBy_LessEqual(updatedBy, null);
1581     }
1582 
1583     public void setUpdatedBy_LessEqual(String updatedBy, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1584         final Object _value = updatedBy;
1585         RangeQueryBuilder builder = regRangeQ("updatedBy", ConditionKey.CK_LESS_EQUAL, _value);
1586         if (opLambda != null) {
1587             opLambda.callback(builder);
1588         }
1589     }
1590 
1591     public void setUpdatedBy_Exists() {
1592         setUpdatedBy_Exists(null);
1593     }
1594 
1595     public void setUpdatedBy_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
1596         ExistsQueryBuilder builder = regExistsQ("updatedBy");
1597         if (opLambda != null) {
1598             opLambda.callback(builder);
1599         }
1600     }
1601 
1602     @Deprecated
1603     public void setUpdatedBy_CommonTerms(String updatedBy) {
1604         setUpdatedBy_CommonTerms(updatedBy, null);
1605     }
1606 
1607     @Deprecated
1608     public void setUpdatedBy_CommonTerms(String updatedBy, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
1609         CommonTermsQueryBuilder builder = regCommonTermsQ("updatedBy", updatedBy);
1610         if (opLambda != null) {
1611             opLambda.callback(builder);
1612         }
1613     }
1614 
1615     public BsKeyMatchCQ addOrderBy_UpdatedBy_Asc() {
1616         regOBA("updatedBy");
1617         return this;
1618     }
1619 
1620     public BsKeyMatchCQ addOrderBy_UpdatedBy_Desc() {
1621         regOBD("updatedBy");
1622         return this;
1623     }
1624 
1625     public void setUpdatedTime_Equal(Long updatedTime) {
1626         setUpdatedTime_Term(updatedTime, null);
1627     }
1628 
1629     public void setUpdatedTime_Equal(Long updatedTime, ConditionOptionCall<TermQueryBuilder> opLambda) {
1630         setUpdatedTime_Term(updatedTime, opLambda);
1631     }
1632 
1633     public void setUpdatedTime_Term(Long updatedTime) {
1634         setUpdatedTime_Term(updatedTime, null);
1635     }
1636 
1637     public void setUpdatedTime_Term(Long updatedTime, ConditionOptionCall<TermQueryBuilder> opLambda) {
1638         TermQueryBuilder builder = regTermQ("updatedTime", updatedTime);
1639         if (opLambda != null) {
1640             opLambda.callback(builder);
1641         }
1642     }
1643 
1644     public void setUpdatedTime_NotEqual(Long updatedTime) {
1645         setUpdatedTime_NotTerm(updatedTime, null);
1646     }
1647 
1648     public void setUpdatedTime_NotTerm(Long updatedTime) {
1649         setUpdatedTime_NotTerm(updatedTime, null);
1650     }
1651 
1652     public void setUpdatedTime_NotEqual(Long updatedTime, ConditionOptionCall<BoolQueryBuilder> opLambda) {
1653         setUpdatedTime_NotTerm(updatedTime, opLambda);
1654     }
1655 
1656     public void setUpdatedTime_NotTerm(Long updatedTime, ConditionOptionCall<BoolQueryBuilder> opLambda) {
1657         not(not -> not.setUpdatedTime_Term(updatedTime), opLambda);
1658     }
1659 
1660     public void setUpdatedTime_Terms(Collection<Long> updatedTimeList) {
1661         setUpdatedTime_Terms(updatedTimeList, null);
1662     }
1663 
1664     public void setUpdatedTime_Terms(Collection<Long> updatedTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
1665         TermsQueryBuilder builder = regTermsQ("updatedTime", updatedTimeList);
1666         if (opLambda != null) {
1667             opLambda.callback(builder);
1668         }
1669     }
1670 
1671     public void setUpdatedTime_InScope(Collection<Long> updatedTimeList) {
1672         setUpdatedTime_Terms(updatedTimeList, null);
1673     }
1674 
1675     public void setUpdatedTime_InScope(Collection<Long> updatedTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
1676         setUpdatedTime_Terms(updatedTimeList, opLambda);
1677     }
1678 
1679     public void setUpdatedTime_Match(Long updatedTime) {
1680         setUpdatedTime_Match(updatedTime, null);
1681     }
1682 
1683     public void setUpdatedTime_Match(Long updatedTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
1684         MatchQueryBuilder builder = regMatchQ("updatedTime", updatedTime);
1685         if (opLambda != null) {
1686             opLambda.callback(builder);
1687         }
1688     }
1689 
1690     public void setUpdatedTime_MatchPhrase(Long updatedTime) {
1691         setUpdatedTime_MatchPhrase(updatedTime, null);
1692     }
1693 
1694     public void setUpdatedTime_MatchPhrase(Long updatedTime, ConditionOptionCall<MatchPhraseQueryBuilder> opLambda) {
1695         MatchPhraseQueryBuilder builder = regMatchPhraseQ("updatedTime", updatedTime);
1696         if (opLambda != null) {
1697             opLambda.callback(builder);
1698         }
1699     }
1700 
1701     public void setUpdatedTime_MatchPhrasePrefix(Long updatedTime) {
1702         setUpdatedTime_MatchPhrasePrefix(updatedTime, null);
1703     }
1704 
1705     public void setUpdatedTime_MatchPhrasePrefix(Long updatedTime, ConditionOptionCall<MatchPhrasePrefixQueryBuilder> opLambda) {
1706         MatchPhrasePrefixQueryBuilder builder = regMatchPhrasePrefixQ("updatedTime", updatedTime);
1707         if (opLambda != null) {
1708             opLambda.callback(builder);
1709         }
1710     }
1711 
1712     public void setUpdatedTime_Fuzzy(Long updatedTime) {
1713         setUpdatedTime_Fuzzy(updatedTime, null);
1714     }
1715 
1716     public void setUpdatedTime_Fuzzy(Long updatedTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
1717         MatchQueryBuilder builder = regFuzzyQ("updatedTime", updatedTime);
1718         if (opLambda != null) {
1719             opLambda.callback(builder);
1720         }
1721     }
1722 
1723     public void setUpdatedTime_GreaterThan(Long updatedTime) {
1724         setUpdatedTime_GreaterThan(updatedTime, null);
1725     }
1726 
1727     public void setUpdatedTime_GreaterThan(Long updatedTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1728         final Object _value = updatedTime;
1729         RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_GREATER_THAN, _value);
1730         if (opLambda != null) {
1731             opLambda.callback(builder);
1732         }
1733     }
1734 
1735     public void setUpdatedTime_LessThan(Long updatedTime) {
1736         setUpdatedTime_LessThan(updatedTime, null);
1737     }
1738 
1739     public void setUpdatedTime_LessThan(Long updatedTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1740         final Object _value = updatedTime;
1741         RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_LESS_THAN, _value);
1742         if (opLambda != null) {
1743             opLambda.callback(builder);
1744         }
1745     }
1746 
1747     public void setUpdatedTime_GreaterEqual(Long updatedTime) {
1748         setUpdatedTime_GreaterEqual(updatedTime, null);
1749     }
1750 
1751     public void setUpdatedTime_GreaterEqual(Long updatedTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1752         final Object _value = updatedTime;
1753         RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_GREATER_EQUAL, _value);
1754         if (opLambda != null) {
1755             opLambda.callback(builder);
1756         }
1757     }
1758 
1759     public void setUpdatedTime_LessEqual(Long updatedTime) {
1760         setUpdatedTime_LessEqual(updatedTime, null);
1761     }
1762 
1763     public void setUpdatedTime_LessEqual(Long updatedTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1764         final Object _value = updatedTime;
1765         RangeQueryBuilder builder = regRangeQ("updatedTime", ConditionKey.CK_LESS_EQUAL, _value);
1766         if (opLambda != null) {
1767             opLambda.callback(builder);
1768         }
1769     }
1770 
1771     public void setUpdatedTime_Exists() {
1772         setUpdatedTime_Exists(null);
1773     }
1774 
1775     public void setUpdatedTime_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
1776         ExistsQueryBuilder builder = regExistsQ("updatedTime");
1777         if (opLambda != null) {
1778             opLambda.callback(builder);
1779         }
1780     }
1781 
1782     @Deprecated
1783     public void setUpdatedTime_CommonTerms(Long updatedTime) {
1784         setUpdatedTime_CommonTerms(updatedTime, null);
1785     }
1786 
1787     @Deprecated
1788     public void setUpdatedTime_CommonTerms(Long updatedTime, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
1789         CommonTermsQueryBuilder builder = regCommonTermsQ("updatedTime", updatedTime);
1790         if (opLambda != null) {
1791             opLambda.callback(builder);
1792         }
1793     }
1794 
1795     public BsKeyMatchCQ addOrderBy_UpdatedTime_Asc() {
1796         regOBA("updatedTime");
1797         return this;
1798     }
1799 
1800     public BsKeyMatchCQ addOrderBy_UpdatedTime_Desc() {
1801         regOBD("updatedTime");
1802         return this;
1803     }
1804 
1805     public void setVirtualHost_Equal(String virtualHost) {
1806         setVirtualHost_Term(virtualHost, null);
1807     }
1808 
1809     public void setVirtualHost_Equal(String virtualHost, ConditionOptionCall<TermQueryBuilder> opLambda) {
1810         setVirtualHost_Term(virtualHost, opLambda);
1811     }
1812 
1813     public void setVirtualHost_Term(String virtualHost) {
1814         setVirtualHost_Term(virtualHost, null);
1815     }
1816 
1817     public void setVirtualHost_Term(String virtualHost, ConditionOptionCall<TermQueryBuilder> opLambda) {
1818         TermQueryBuilder builder = regTermQ("virtualHost", virtualHost);
1819         if (opLambda != null) {
1820             opLambda.callback(builder);
1821         }
1822     }
1823 
1824     public void setVirtualHost_NotEqual(String virtualHost) {
1825         setVirtualHost_NotTerm(virtualHost, null);
1826     }
1827 
1828     public void setVirtualHost_NotTerm(String virtualHost) {
1829         setVirtualHost_NotTerm(virtualHost, null);
1830     }
1831 
1832     public void setVirtualHost_NotEqual(String virtualHost, ConditionOptionCall<BoolQueryBuilder> opLambda) {
1833         setVirtualHost_NotTerm(virtualHost, opLambda);
1834     }
1835 
1836     public void setVirtualHost_NotTerm(String virtualHost, ConditionOptionCall<BoolQueryBuilder> opLambda) {
1837         not(not -> not.setVirtualHost_Term(virtualHost), opLambda);
1838     }
1839 
1840     public void setVirtualHost_Terms(Collection<String> virtualHostList) {
1841         setVirtualHost_Terms(virtualHostList, null);
1842     }
1843 
1844     public void setVirtualHost_Terms(Collection<String> virtualHostList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
1845         TermsQueryBuilder builder = regTermsQ("virtualHost", virtualHostList);
1846         if (opLambda != null) {
1847             opLambda.callback(builder);
1848         }
1849     }
1850 
1851     public void setVirtualHost_InScope(Collection<String> virtualHostList) {
1852         setVirtualHost_Terms(virtualHostList, null);
1853     }
1854 
1855     public void setVirtualHost_InScope(Collection<String> virtualHostList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
1856         setVirtualHost_Terms(virtualHostList, opLambda);
1857     }
1858 
1859     public void setVirtualHost_Match(String virtualHost) {
1860         setVirtualHost_Match(virtualHost, null);
1861     }
1862 
1863     public void setVirtualHost_Match(String virtualHost, ConditionOptionCall<MatchQueryBuilder> opLambda) {
1864         MatchQueryBuilder builder = regMatchQ("virtualHost", virtualHost);
1865         if (opLambda != null) {
1866             opLambda.callback(builder);
1867         }
1868     }
1869 
1870     public void setVirtualHost_MatchPhrase(String virtualHost) {
1871         setVirtualHost_MatchPhrase(virtualHost, null);
1872     }
1873 
1874     public void setVirtualHost_MatchPhrase(String virtualHost, ConditionOptionCall<MatchPhraseQueryBuilder> opLambda) {
1875         MatchPhraseQueryBuilder builder = regMatchPhraseQ("virtualHost", virtualHost);
1876         if (opLambda != null) {
1877             opLambda.callback(builder);
1878         }
1879     }
1880 
1881     public void setVirtualHost_MatchPhrasePrefix(String virtualHost) {
1882         setVirtualHost_MatchPhrasePrefix(virtualHost, null);
1883     }
1884 
1885     public void setVirtualHost_MatchPhrasePrefix(String virtualHost, ConditionOptionCall<MatchPhrasePrefixQueryBuilder> opLambda) {
1886         MatchPhrasePrefixQueryBuilder builder = regMatchPhrasePrefixQ("virtualHost", virtualHost);
1887         if (opLambda != null) {
1888             opLambda.callback(builder);
1889         }
1890     }
1891 
1892     public void setVirtualHost_Fuzzy(String virtualHost) {
1893         setVirtualHost_Fuzzy(virtualHost, null);
1894     }
1895 
1896     public void setVirtualHost_Fuzzy(String virtualHost, ConditionOptionCall<MatchQueryBuilder> opLambda) {
1897         MatchQueryBuilder builder = regFuzzyQ("virtualHost", virtualHost);
1898         if (opLambda != null) {
1899             opLambda.callback(builder);
1900         }
1901     }
1902 
1903     public void setVirtualHost_Prefix(String virtualHost) {
1904         setVirtualHost_Prefix(virtualHost, null);
1905     }
1906 
1907     public void setVirtualHost_Prefix(String virtualHost, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
1908         PrefixQueryBuilder builder = regPrefixQ("virtualHost", virtualHost);
1909         if (opLambda != null) {
1910             opLambda.callback(builder);
1911         }
1912     }
1913 
1914     public void setVirtualHost_Wildcard(String virtualHost) {
1915         setVirtualHost_Wildcard(virtualHost, null);
1916     }
1917 
1918     public void setVirtualHost_Wildcard(String virtualHost, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
1919         WildcardQueryBuilder builder = regWildcardQ("virtualHost", virtualHost);
1920         if (opLambda != null) {
1921             opLambda.callback(builder);
1922         }
1923     }
1924 
1925     public void setVirtualHost_Regexp(String virtualHost) {
1926         setVirtualHost_Regexp(virtualHost, null);
1927     }
1928 
1929     public void setVirtualHost_Regexp(String virtualHost, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
1930         RegexpQueryBuilder builder = regRegexpQ("virtualHost", virtualHost);
1931         if (opLambda != null) {
1932             opLambda.callback(builder);
1933         }
1934     }
1935 
1936     public void setVirtualHost_SpanTerm(String virtualHost) {
1937         setVirtualHost_SpanTerm("virtualHost", null);
1938     }
1939 
1940     public void setVirtualHost_SpanTerm(String virtualHost, ConditionOptionCall<SpanTermQueryBuilder> opLambda) {
1941         SpanTermQueryBuilder builder = regSpanTermQ("virtualHost", virtualHost);
1942         if (opLambda != null) {
1943             opLambda.callback(builder);
1944         }
1945     }
1946 
1947     public void setVirtualHost_GreaterThan(String virtualHost) {
1948         setVirtualHost_GreaterThan(virtualHost, null);
1949     }
1950 
1951     public void setVirtualHost_GreaterThan(String virtualHost, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1952         final Object _value = virtualHost;
1953         RangeQueryBuilder builder = regRangeQ("virtualHost", ConditionKey.CK_GREATER_THAN, _value);
1954         if (opLambda != null) {
1955             opLambda.callback(builder);
1956         }
1957     }
1958 
1959     public void setVirtualHost_LessThan(String virtualHost) {
1960         setVirtualHost_LessThan(virtualHost, null);
1961     }
1962 
1963     public void setVirtualHost_LessThan(String virtualHost, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1964         final Object _value = virtualHost;
1965         RangeQueryBuilder builder = regRangeQ("virtualHost", ConditionKey.CK_LESS_THAN, _value);
1966         if (opLambda != null) {
1967             opLambda.callback(builder);
1968         }
1969     }
1970 
1971     public void setVirtualHost_GreaterEqual(String virtualHost) {
1972         setVirtualHost_GreaterEqual(virtualHost, null);
1973     }
1974 
1975     public void setVirtualHost_GreaterEqual(String virtualHost, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1976         final Object _value = virtualHost;
1977         RangeQueryBuilder builder = regRangeQ("virtualHost", ConditionKey.CK_GREATER_EQUAL, _value);
1978         if (opLambda != null) {
1979             opLambda.callback(builder);
1980         }
1981     }
1982 
1983     public void setVirtualHost_LessEqual(String virtualHost) {
1984         setVirtualHost_LessEqual(virtualHost, null);
1985     }
1986 
1987     public void setVirtualHost_LessEqual(String virtualHost, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1988         final Object _value = virtualHost;
1989         RangeQueryBuilder builder = regRangeQ("virtualHost", ConditionKey.CK_LESS_EQUAL, _value);
1990         if (opLambda != null) {
1991             opLambda.callback(builder);
1992         }
1993     }
1994 
1995     public void setVirtualHost_Exists() {
1996         setVirtualHost_Exists(null);
1997     }
1998 
1999     public void setVirtualHost_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
2000         ExistsQueryBuilder builder = regExistsQ("virtualHost");
2001         if (opLambda != null) {
2002             opLambda.callback(builder);
2003         }
2004     }
2005 
2006     @Deprecated
2007     public void setVirtualHost_CommonTerms(String virtualHost) {
2008         setVirtualHost_CommonTerms(virtualHost, null);
2009     }
2010 
2011     @Deprecated
2012     public void setVirtualHost_CommonTerms(String virtualHost, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
2013         CommonTermsQueryBuilder builder = regCommonTermsQ("virtualHost", virtualHost);
2014         if (opLambda != null) {
2015             opLambda.callback(builder);
2016         }
2017     }
2018 
2019     public BsKeyMatchCQ addOrderBy_VirtualHost_Asc() {
2020         regOBA("virtualHost");
2021         return this;
2022     }
2023 
2024     public BsKeyMatchCQ addOrderBy_VirtualHost_Desc() {
2025         regOBD("virtualHost");
2026         return this;
2027     }
2028 
2029 }