View Javadoc
1   /*
2    * Copyright 2012-2020 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.es.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.es.config.allcommon.EsAbstractConditionQuery;
23  import org.codelibs.fess.es.config.cbean.cq.FailureUrlCQ;
24  import org.dbflute.cbean.ckey.ConditionKey;
25  import org.elasticsearch.index.query.BoolQueryBuilder;
26  import org.elasticsearch.index.query.CommonTermsQueryBuilder;
27  import org.elasticsearch.index.query.ExistsQueryBuilder;
28  import org.elasticsearch.index.query.IdsQueryBuilder;
29  import org.elasticsearch.index.query.MatchPhrasePrefixQueryBuilder;
30  import org.elasticsearch.index.query.MatchPhraseQueryBuilder;
31  import org.elasticsearch.index.query.MatchQueryBuilder;
32  import org.elasticsearch.index.query.PrefixQueryBuilder;
33  import org.elasticsearch.index.query.RangeQueryBuilder;
34  import org.elasticsearch.index.query.RegexpQueryBuilder;
35  import org.elasticsearch.index.query.SpanTermQueryBuilder;
36  import org.elasticsearch.index.query.TermQueryBuilder;
37  import org.elasticsearch.index.query.TermsQueryBuilder;
38  import org.elasticsearch.index.query.WildcardQueryBuilder;
39  import org.elasticsearch.index.query.functionscore.FunctionScoreQueryBuilder;
40  import org.elasticsearch.index.query.functionscore.FunctionScoreQueryBuilder.FilterFunctionBuilder;
41  
42  /**
43   * @author ESFlute (using FreeGen)
44   */
45  public abstract class BsFailureUrlCQ 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 "failure_url";
55      }
56  
57      @Override
58      public String xgetAliasName() {
59          return "failure_url";
60      }
61  
62      // ===================================================================================
63      //                                                                       Query Control
64      //                                                                       =============
65      public void functionScore(OperatorCall<FailureUrlCQ> queryLambda,
66              ScoreFunctionCall<ScoreFunctionCreator<FailureUrlCQ>> functionsLambda,
67              final ConditionOptionCall<FunctionScoreQueryBuilder> opLambda) {
68          FailureUrlCQes/config/cbean/cq/FailureUrlCQ.html#FailureUrlCQ">FailureUrlCQ cq = new FailureUrlCQ();
69          queryLambda.callback(cq);
70          final Collection<FilterFunctionBuilder> list = new ArrayList<>();
71          if (functionsLambda != null) {
72              functionsLambda.callback((cqLambda, scoreFunctionBuilder) -> {
73                  FailureUrlCQes/config/cbean/cq/FailureUrlCQ.html#FailureUrlCQ">FailureUrlCQ cf = new FailureUrlCQ();
74                  cqLambda.callback(cf);
75                  list.add(new FilterFunctionBuilder(cf.getQuery(), scoreFunctionBuilder));
76              });
77          }
78          final FunctionScoreQueryBuilder builder = regFunctionScoreQ(cq.getQuery(), list);
79          if (opLambda != null) {
80              opLambda.callback(builder);
81          }
82      }
83  
84      public void filtered(FilteredCall<FailureUrlCQ, FailureUrlCQ> filteredLambda) {
85          filtered(filteredLambda, null);
86      }
87  
88      public void filtered(FilteredCall<FailureUrlCQ, FailureUrlCQ> filteredLambda, ConditionOptionCall<BoolQueryBuilder> opLambda) {
89          bool((must, should, mustNot, filter) -> {
90              filteredLambda.callback(must, filter);
91          }, opLambda);
92      }
93  
94      public void not(OperatorCall<FailureUrlCQ> notLambda) {
95          not(notLambda, null);
96      }
97  
98      public void not(final OperatorCall<FailureUrlCQ> notLambda, final ConditionOptionCall<BoolQueryBuilder> opLambda) {
99          bool((must, should, mustNot, filter) -> notLambda.callback(mustNot), opLambda);
100     }
101 
102     public void bool(BoolCall<FailureUrlCQ> boolLambda) {
103         bool(boolLambda, null);
104     }
105 
106     public void bool(BoolCall<FailureUrlCQ> boolLambda, ConditionOptionCall<BoolQueryBuilder> opLambda) {
107         FailureUrlCQig/cbean/cq/FailureUrlCQ.html#FailureUrlCQ">FailureUrlCQ mustQuery = new FailureUrlCQ();
108         FailureUrlCQ/cbean/cq/FailureUrlCQ.html#FailureUrlCQ">FailureUrlCQ shouldQuery = new FailureUrlCQ();
109         FailureUrlCQcbean/cq/FailureUrlCQ.html#FailureUrlCQ">FailureUrlCQ mustNotQuery = new FailureUrlCQ();
110         FailureUrlCQ/cbean/cq/FailureUrlCQ.html#FailureUrlCQ">FailureUrlCQ filterQuery = new FailureUrlCQ();
111         boolLambda.callback(mustQuery, shouldQuery, mustNotQuery, filterQuery);
112         if (mustQuery.hasQueries() || shouldQuery.hasQueries() || mustNotQuery.hasQueries() || filterQuery.hasQueries()) {
113             BoolQueryBuilder builder =
114                     regBoolCQ(mustQuery.getQueryBuilderList(), shouldQuery.getQueryBuilderList(), mustNotQuery.getQueryBuilderList(),
115                             filterQuery.getQueryBuilderList());
116             if (opLambda != null) {
117                 opLambda.callback(builder);
118             }
119         }
120     }
121 
122     // ===================================================================================
123     //                                                                           Query Set
124     //                                                                           =========
125     public void setId_Equal(String id) {
126         setId_Term(id, null);
127     }
128 
129     public void setId_Equal(String id, ConditionOptionCall<TermQueryBuilder> opLambda) {
130         setId_Term(id, opLambda);
131     }
132 
133     public void setId_Term(String id) {
134         setId_Term(id, null);
135     }
136 
137     public void setId_Term(String id, ConditionOptionCall<TermQueryBuilder> opLambda) {
138         TermQueryBuilder builder = regTermQ("_id", id);
139         if (opLambda != null) {
140             opLambda.callback(builder);
141         }
142     }
143 
144     public void setId_NotEqual(String id) {
145         setId_NotTerm(id, null);
146     }
147 
148     public void setId_NotTerm(String id) {
149         setId_NotTerm(id, null);
150     }
151 
152     public void setId_NotEqual(String id, ConditionOptionCall<BoolQueryBuilder> opLambda) {
153         setId_NotTerm(id, opLambda);
154     }
155 
156     public void setId_NotTerm(String id, ConditionOptionCall<BoolQueryBuilder> opLambda) {
157         not(not -> not.setId_Term(id), opLambda);
158     }
159 
160     public void setId_Terms(Collection<String> idList) {
161         setId_Terms(idList, null);
162     }
163 
164     public void setId_Terms(Collection<String> idList, ConditionOptionCall<IdsQueryBuilder> opLambda) {
165         IdsQueryBuilder builder = regIdsQ(idList);
166         if (opLambda != null) {
167             opLambda.callback(builder);
168         }
169     }
170 
171     public void setId_InScope(Collection<String> idList) {
172         setId_Terms(idList, null);
173     }
174 
175     public void setId_InScope(Collection<String> idList, ConditionOptionCall<IdsQueryBuilder> opLambda) {
176         setId_Terms(idList, opLambda);
177     }
178 
179     public BsFailureUrlCQ addOrderBy_Id_Asc() {
180         regOBA("_id");
181         return this;
182     }
183 
184     public BsFailureUrlCQ addOrderBy_Id_Desc() {
185         regOBD("_id");
186         return this;
187     }
188 
189     public void setConfigId_Equal(String configId) {
190         setConfigId_Term(configId, null);
191     }
192 
193     public void setConfigId_Equal(String configId, ConditionOptionCall<TermQueryBuilder> opLambda) {
194         setConfigId_Term(configId, opLambda);
195     }
196 
197     public void setConfigId_Term(String configId) {
198         setConfigId_Term(configId, null);
199     }
200 
201     public void setConfigId_Term(String configId, ConditionOptionCall<TermQueryBuilder> opLambda) {
202         TermQueryBuilder builder = regTermQ("configId", configId);
203         if (opLambda != null) {
204             opLambda.callback(builder);
205         }
206     }
207 
208     public void setConfigId_NotEqual(String configId) {
209         setConfigId_NotTerm(configId, null);
210     }
211 
212     public void setConfigId_NotTerm(String configId) {
213         setConfigId_NotTerm(configId, null);
214     }
215 
216     public void setConfigId_NotEqual(String configId, ConditionOptionCall<BoolQueryBuilder> opLambda) {
217         setConfigId_NotTerm(configId, opLambda);
218     }
219 
220     public void setConfigId_NotTerm(String configId, ConditionOptionCall<BoolQueryBuilder> opLambda) {
221         not(not -> not.setConfigId_Term(configId), opLambda);
222     }
223 
224     public void setConfigId_Terms(Collection<String> configIdList) {
225         setConfigId_Terms(configIdList, null);
226     }
227 
228     public void setConfigId_Terms(Collection<String> configIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
229         TermsQueryBuilder builder = regTermsQ("configId", configIdList);
230         if (opLambda != null) {
231             opLambda.callback(builder);
232         }
233     }
234 
235     public void setConfigId_InScope(Collection<String> configIdList) {
236         setConfigId_Terms(configIdList, null);
237     }
238 
239     public void setConfigId_InScope(Collection<String> configIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
240         setConfigId_Terms(configIdList, opLambda);
241     }
242 
243     public void setConfigId_Match(String configId) {
244         setConfigId_Match(configId, null);
245     }
246 
247     public void setConfigId_Match(String configId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
248         MatchQueryBuilder builder = regMatchQ("configId", configId);
249         if (opLambda != null) {
250             opLambda.callback(builder);
251         }
252     }
253 
254     public void setConfigId_MatchPhrase(String configId) {
255         setConfigId_MatchPhrase(configId, null);
256     }
257 
258     public void setConfigId_MatchPhrase(String configId, ConditionOptionCall<MatchPhraseQueryBuilder> opLambda) {
259         MatchPhraseQueryBuilder builder = regMatchPhraseQ("configId", configId);
260         if (opLambda != null) {
261             opLambda.callback(builder);
262         }
263     }
264 
265     public void setConfigId_MatchPhrasePrefix(String configId) {
266         setConfigId_MatchPhrasePrefix(configId, null);
267     }
268 
269     public void setConfigId_MatchPhrasePrefix(String configId, ConditionOptionCall<MatchPhrasePrefixQueryBuilder> opLambda) {
270         MatchPhrasePrefixQueryBuilder builder = regMatchPhrasePrefixQ("configId", configId);
271         if (opLambda != null) {
272             opLambda.callback(builder);
273         }
274     }
275 
276     public void setConfigId_Fuzzy(String configId) {
277         setConfigId_Fuzzy(configId, null);
278     }
279 
280     public void setConfigId_Fuzzy(String configId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
281         MatchQueryBuilder builder = regFuzzyQ("configId", configId);
282         if (opLambda != null) {
283             opLambda.callback(builder);
284         }
285     }
286 
287     public void setConfigId_Prefix(String configId) {
288         setConfigId_Prefix(configId, null);
289     }
290 
291     public void setConfigId_Prefix(String configId, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
292         PrefixQueryBuilder builder = regPrefixQ("configId", configId);
293         if (opLambda != null) {
294             opLambda.callback(builder);
295         }
296     }
297 
298     public void setConfigId_Wildcard(String configId) {
299         setConfigId_Wildcard(configId, null);
300     }
301 
302     public void setConfigId_Wildcard(String configId, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
303         WildcardQueryBuilder builder = regWildcardQ("configId", configId);
304         if (opLambda != null) {
305             opLambda.callback(builder);
306         }
307     }
308 
309     public void setConfigId_Regexp(String configId) {
310         setConfigId_Regexp(configId, null);
311     }
312 
313     public void setConfigId_Regexp(String configId, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
314         RegexpQueryBuilder builder = regRegexpQ("configId", configId);
315         if (opLambda != null) {
316             opLambda.callback(builder);
317         }
318     }
319 
320     public void setConfigId_SpanTerm(String configId) {
321         setConfigId_SpanTerm("configId", null);
322     }
323 
324     public void setConfigId_SpanTerm(String configId, ConditionOptionCall<SpanTermQueryBuilder> opLambda) {
325         SpanTermQueryBuilder builder = regSpanTermQ("configId", configId);
326         if (opLambda != null) {
327             opLambda.callback(builder);
328         }
329     }
330 
331     public void setConfigId_GreaterThan(String configId) {
332         setConfigId_GreaterThan(configId, null);
333     }
334 
335     public void setConfigId_GreaterThan(String configId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
336         final Object _value = configId;
337         RangeQueryBuilder builder = regRangeQ("configId", ConditionKey.CK_GREATER_THAN, _value);
338         if (opLambda != null) {
339             opLambda.callback(builder);
340         }
341     }
342 
343     public void setConfigId_LessThan(String configId) {
344         setConfigId_LessThan(configId, null);
345     }
346 
347     public void setConfigId_LessThan(String configId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
348         final Object _value = configId;
349         RangeQueryBuilder builder = regRangeQ("configId", ConditionKey.CK_LESS_THAN, _value);
350         if (opLambda != null) {
351             opLambda.callback(builder);
352         }
353     }
354 
355     public void setConfigId_GreaterEqual(String configId) {
356         setConfigId_GreaterEqual(configId, null);
357     }
358 
359     public void setConfigId_GreaterEqual(String configId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
360         final Object _value = configId;
361         RangeQueryBuilder builder = regRangeQ("configId", ConditionKey.CK_GREATER_EQUAL, _value);
362         if (opLambda != null) {
363             opLambda.callback(builder);
364         }
365     }
366 
367     public void setConfigId_LessEqual(String configId) {
368         setConfigId_LessEqual(configId, null);
369     }
370 
371     public void setConfigId_LessEqual(String configId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
372         final Object _value = configId;
373         RangeQueryBuilder builder = regRangeQ("configId", ConditionKey.CK_LESS_EQUAL, _value);
374         if (opLambda != null) {
375             opLambda.callback(builder);
376         }
377     }
378 
379     public void setConfigId_Exists() {
380         setConfigId_Exists(null);
381     }
382 
383     public void setConfigId_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
384         ExistsQueryBuilder builder = regExistsQ("configId");
385         if (opLambda != null) {
386             opLambda.callback(builder);
387         }
388     }
389 
390     public void setConfigId_CommonTerms(String configId) {
391         setConfigId_CommonTerms(configId, null);
392     }
393 
394     public void setConfigId_CommonTerms(String configId, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
395         CommonTermsQueryBuilder builder = regCommonTermsQ("configId", configId);
396         if (opLambda != null) {
397             opLambda.callback(builder);
398         }
399     }
400 
401     public BsFailureUrlCQ addOrderBy_ConfigId_Asc() {
402         regOBA("configId");
403         return this;
404     }
405 
406     public BsFailureUrlCQ addOrderBy_ConfigId_Desc() {
407         regOBD("configId");
408         return this;
409     }
410 
411     public void setErrorCount_Equal(Integer errorCount) {
412         setErrorCount_Term(errorCount, null);
413     }
414 
415     public void setErrorCount_Equal(Integer errorCount, ConditionOptionCall<TermQueryBuilder> opLambda) {
416         setErrorCount_Term(errorCount, opLambda);
417     }
418 
419     public void setErrorCount_Term(Integer errorCount) {
420         setErrorCount_Term(errorCount, null);
421     }
422 
423     public void setErrorCount_Term(Integer errorCount, ConditionOptionCall<TermQueryBuilder> opLambda) {
424         TermQueryBuilder builder = regTermQ("errorCount", errorCount);
425         if (opLambda != null) {
426             opLambda.callback(builder);
427         }
428     }
429 
430     public void setErrorCount_NotEqual(Integer errorCount) {
431         setErrorCount_NotTerm(errorCount, null);
432     }
433 
434     public void setErrorCount_NotTerm(Integer errorCount) {
435         setErrorCount_NotTerm(errorCount, null);
436     }
437 
438     public void setErrorCount_NotEqual(Integer errorCount, ConditionOptionCall<BoolQueryBuilder> opLambda) {
439         setErrorCount_NotTerm(errorCount, opLambda);
440     }
441 
442     public void setErrorCount_NotTerm(Integer errorCount, ConditionOptionCall<BoolQueryBuilder> opLambda) {
443         not(not -> not.setErrorCount_Term(errorCount), opLambda);
444     }
445 
446     public void setErrorCount_Terms(Collection<Integer> errorCountList) {
447         setErrorCount_Terms(errorCountList, null);
448     }
449 
450     public void setErrorCount_Terms(Collection<Integer> errorCountList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
451         TermsQueryBuilder builder = regTermsQ("errorCount", errorCountList);
452         if (opLambda != null) {
453             opLambda.callback(builder);
454         }
455     }
456 
457     public void setErrorCount_InScope(Collection<Integer> errorCountList) {
458         setErrorCount_Terms(errorCountList, null);
459     }
460 
461     public void setErrorCount_InScope(Collection<Integer> errorCountList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
462         setErrorCount_Terms(errorCountList, opLambda);
463     }
464 
465     public void setErrorCount_Match(Integer errorCount) {
466         setErrorCount_Match(errorCount, null);
467     }
468 
469     public void setErrorCount_Match(Integer errorCount, ConditionOptionCall<MatchQueryBuilder> opLambda) {
470         MatchQueryBuilder builder = regMatchQ("errorCount", errorCount);
471         if (opLambda != null) {
472             opLambda.callback(builder);
473         }
474     }
475 
476     public void setErrorCount_MatchPhrase(Integer errorCount) {
477         setErrorCount_MatchPhrase(errorCount, null);
478     }
479 
480     public void setErrorCount_MatchPhrase(Integer errorCount, ConditionOptionCall<MatchPhraseQueryBuilder> opLambda) {
481         MatchPhraseQueryBuilder builder = regMatchPhraseQ("errorCount", errorCount);
482         if (opLambda != null) {
483             opLambda.callback(builder);
484         }
485     }
486 
487     public void setErrorCount_MatchPhrasePrefix(Integer errorCount) {
488         setErrorCount_MatchPhrasePrefix(errorCount, null);
489     }
490 
491     public void setErrorCount_MatchPhrasePrefix(Integer errorCount, ConditionOptionCall<MatchPhrasePrefixQueryBuilder> opLambda) {
492         MatchPhrasePrefixQueryBuilder builder = regMatchPhrasePrefixQ("errorCount", errorCount);
493         if (opLambda != null) {
494             opLambda.callback(builder);
495         }
496     }
497 
498     public void setErrorCount_Fuzzy(Integer errorCount) {
499         setErrorCount_Fuzzy(errorCount, null);
500     }
501 
502     public void setErrorCount_Fuzzy(Integer errorCount, ConditionOptionCall<MatchQueryBuilder> opLambda) {
503         MatchQueryBuilder builder = regFuzzyQ("errorCount", errorCount);
504         if (opLambda != null) {
505             opLambda.callback(builder);
506         }
507     }
508 
509     public void setErrorCount_GreaterThan(Integer errorCount) {
510         setErrorCount_GreaterThan(errorCount, null);
511     }
512 
513     public void setErrorCount_GreaterThan(Integer errorCount, ConditionOptionCall<RangeQueryBuilder> opLambda) {
514         final Object _value = errorCount;
515         RangeQueryBuilder builder = regRangeQ("errorCount", ConditionKey.CK_GREATER_THAN, _value);
516         if (opLambda != null) {
517             opLambda.callback(builder);
518         }
519     }
520 
521     public void setErrorCount_LessThan(Integer errorCount) {
522         setErrorCount_LessThan(errorCount, null);
523     }
524 
525     public void setErrorCount_LessThan(Integer errorCount, ConditionOptionCall<RangeQueryBuilder> opLambda) {
526         final Object _value = errorCount;
527         RangeQueryBuilder builder = regRangeQ("errorCount", ConditionKey.CK_LESS_THAN, _value);
528         if (opLambda != null) {
529             opLambda.callback(builder);
530         }
531     }
532 
533     public void setErrorCount_GreaterEqual(Integer errorCount) {
534         setErrorCount_GreaterEqual(errorCount, null);
535     }
536 
537     public void setErrorCount_GreaterEqual(Integer errorCount, ConditionOptionCall<RangeQueryBuilder> opLambda) {
538         final Object _value = errorCount;
539         RangeQueryBuilder builder = regRangeQ("errorCount", ConditionKey.CK_GREATER_EQUAL, _value);
540         if (opLambda != null) {
541             opLambda.callback(builder);
542         }
543     }
544 
545     public void setErrorCount_LessEqual(Integer errorCount) {
546         setErrorCount_LessEqual(errorCount, null);
547     }
548 
549     public void setErrorCount_LessEqual(Integer errorCount, ConditionOptionCall<RangeQueryBuilder> opLambda) {
550         final Object _value = errorCount;
551         RangeQueryBuilder builder = regRangeQ("errorCount", ConditionKey.CK_LESS_EQUAL, _value);
552         if (opLambda != null) {
553             opLambda.callback(builder);
554         }
555     }
556 
557     public void setErrorCount_Exists() {
558         setErrorCount_Exists(null);
559     }
560 
561     public void setErrorCount_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
562         ExistsQueryBuilder builder = regExistsQ("errorCount");
563         if (opLambda != null) {
564             opLambda.callback(builder);
565         }
566     }
567 
568     public void setErrorCount_CommonTerms(Integer errorCount) {
569         setErrorCount_CommonTerms(errorCount, null);
570     }
571 
572     public void setErrorCount_CommonTerms(Integer errorCount, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
573         CommonTermsQueryBuilder builder = regCommonTermsQ("errorCount", errorCount);
574         if (opLambda != null) {
575             opLambda.callback(builder);
576         }
577     }
578 
579     public BsFailureUrlCQ addOrderBy_ErrorCount_Asc() {
580         regOBA("errorCount");
581         return this;
582     }
583 
584     public BsFailureUrlCQ addOrderBy_ErrorCount_Desc() {
585         regOBD("errorCount");
586         return this;
587     }
588 
589     public void setErrorLog_Equal(String errorLog) {
590         setErrorLog_Term(errorLog, null);
591     }
592 
593     public void setErrorLog_Equal(String errorLog, ConditionOptionCall<TermQueryBuilder> opLambda) {
594         setErrorLog_Term(errorLog, opLambda);
595     }
596 
597     public void setErrorLog_Term(String errorLog) {
598         setErrorLog_Term(errorLog, null);
599     }
600 
601     public void setErrorLog_Term(String errorLog, ConditionOptionCall<TermQueryBuilder> opLambda) {
602         TermQueryBuilder builder = regTermQ("errorLog", errorLog);
603         if (opLambda != null) {
604             opLambda.callback(builder);
605         }
606     }
607 
608     public void setErrorLog_NotEqual(String errorLog) {
609         setErrorLog_NotTerm(errorLog, null);
610     }
611 
612     public void setErrorLog_NotTerm(String errorLog) {
613         setErrorLog_NotTerm(errorLog, null);
614     }
615 
616     public void setErrorLog_NotEqual(String errorLog, ConditionOptionCall<BoolQueryBuilder> opLambda) {
617         setErrorLog_NotTerm(errorLog, opLambda);
618     }
619 
620     public void setErrorLog_NotTerm(String errorLog, ConditionOptionCall<BoolQueryBuilder> opLambda) {
621         not(not -> not.setErrorLog_Term(errorLog), opLambda);
622     }
623 
624     public void setErrorLog_Terms(Collection<String> errorLogList) {
625         setErrorLog_Terms(errorLogList, null);
626     }
627 
628     public void setErrorLog_Terms(Collection<String> errorLogList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
629         TermsQueryBuilder builder = regTermsQ("errorLog", errorLogList);
630         if (opLambda != null) {
631             opLambda.callback(builder);
632         }
633     }
634 
635     public void setErrorLog_InScope(Collection<String> errorLogList) {
636         setErrorLog_Terms(errorLogList, null);
637     }
638 
639     public void setErrorLog_InScope(Collection<String> errorLogList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
640         setErrorLog_Terms(errorLogList, opLambda);
641     }
642 
643     public void setErrorLog_Match(String errorLog) {
644         setErrorLog_Match(errorLog, null);
645     }
646 
647     public void setErrorLog_Match(String errorLog, ConditionOptionCall<MatchQueryBuilder> opLambda) {
648         MatchQueryBuilder builder = regMatchQ("errorLog", errorLog);
649         if (opLambda != null) {
650             opLambda.callback(builder);
651         }
652     }
653 
654     public void setErrorLog_MatchPhrase(String errorLog) {
655         setErrorLog_MatchPhrase(errorLog, null);
656     }
657 
658     public void setErrorLog_MatchPhrase(String errorLog, ConditionOptionCall<MatchPhraseQueryBuilder> opLambda) {
659         MatchPhraseQueryBuilder builder = regMatchPhraseQ("errorLog", errorLog);
660         if (opLambda != null) {
661             opLambda.callback(builder);
662         }
663     }
664 
665     public void setErrorLog_MatchPhrasePrefix(String errorLog) {
666         setErrorLog_MatchPhrasePrefix(errorLog, null);
667     }
668 
669     public void setErrorLog_MatchPhrasePrefix(String errorLog, ConditionOptionCall<MatchPhrasePrefixQueryBuilder> opLambda) {
670         MatchPhrasePrefixQueryBuilder builder = regMatchPhrasePrefixQ("errorLog", errorLog);
671         if (opLambda != null) {
672             opLambda.callback(builder);
673         }
674     }
675 
676     public void setErrorLog_Fuzzy(String errorLog) {
677         setErrorLog_Fuzzy(errorLog, null);
678     }
679 
680     public void setErrorLog_Fuzzy(String errorLog, ConditionOptionCall<MatchQueryBuilder> opLambda) {
681         MatchQueryBuilder builder = regFuzzyQ("errorLog", errorLog);
682         if (opLambda != null) {
683             opLambda.callback(builder);
684         }
685     }
686 
687     public void setErrorLog_Prefix(String errorLog) {
688         setErrorLog_Prefix(errorLog, null);
689     }
690 
691     public void setErrorLog_Prefix(String errorLog, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
692         PrefixQueryBuilder builder = regPrefixQ("errorLog", errorLog);
693         if (opLambda != null) {
694             opLambda.callback(builder);
695         }
696     }
697 
698     public void setErrorLog_Wildcard(String errorLog) {
699         setErrorLog_Wildcard(errorLog, null);
700     }
701 
702     public void setErrorLog_Wildcard(String errorLog, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
703         WildcardQueryBuilder builder = regWildcardQ("errorLog", errorLog);
704         if (opLambda != null) {
705             opLambda.callback(builder);
706         }
707     }
708 
709     public void setErrorLog_Regexp(String errorLog) {
710         setErrorLog_Regexp(errorLog, null);
711     }
712 
713     public void setErrorLog_Regexp(String errorLog, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
714         RegexpQueryBuilder builder = regRegexpQ("errorLog", errorLog);
715         if (opLambda != null) {
716             opLambda.callback(builder);
717         }
718     }
719 
720     public void setErrorLog_SpanTerm(String errorLog) {
721         setErrorLog_SpanTerm("errorLog", null);
722     }
723 
724     public void setErrorLog_SpanTerm(String errorLog, ConditionOptionCall<SpanTermQueryBuilder> opLambda) {
725         SpanTermQueryBuilder builder = regSpanTermQ("errorLog", errorLog);
726         if (opLambda != null) {
727             opLambda.callback(builder);
728         }
729     }
730 
731     public void setErrorLog_GreaterThan(String errorLog) {
732         setErrorLog_GreaterThan(errorLog, null);
733     }
734 
735     public void setErrorLog_GreaterThan(String errorLog, ConditionOptionCall<RangeQueryBuilder> opLambda) {
736         final Object _value = errorLog;
737         RangeQueryBuilder builder = regRangeQ("errorLog", ConditionKey.CK_GREATER_THAN, _value);
738         if (opLambda != null) {
739             opLambda.callback(builder);
740         }
741     }
742 
743     public void setErrorLog_LessThan(String errorLog) {
744         setErrorLog_LessThan(errorLog, null);
745     }
746 
747     public void setErrorLog_LessThan(String errorLog, ConditionOptionCall<RangeQueryBuilder> opLambda) {
748         final Object _value = errorLog;
749         RangeQueryBuilder builder = regRangeQ("errorLog", ConditionKey.CK_LESS_THAN, _value);
750         if (opLambda != null) {
751             opLambda.callback(builder);
752         }
753     }
754 
755     public void setErrorLog_GreaterEqual(String errorLog) {
756         setErrorLog_GreaterEqual(errorLog, null);
757     }
758 
759     public void setErrorLog_GreaterEqual(String errorLog, ConditionOptionCall<RangeQueryBuilder> opLambda) {
760         final Object _value = errorLog;
761         RangeQueryBuilder builder = regRangeQ("errorLog", ConditionKey.CK_GREATER_EQUAL, _value);
762         if (opLambda != null) {
763             opLambda.callback(builder);
764         }
765     }
766 
767     public void setErrorLog_LessEqual(String errorLog) {
768         setErrorLog_LessEqual(errorLog, null);
769     }
770 
771     public void setErrorLog_LessEqual(String errorLog, ConditionOptionCall<RangeQueryBuilder> opLambda) {
772         final Object _value = errorLog;
773         RangeQueryBuilder builder = regRangeQ("errorLog", ConditionKey.CK_LESS_EQUAL, _value);
774         if (opLambda != null) {
775             opLambda.callback(builder);
776         }
777     }
778 
779     public void setErrorLog_Exists() {
780         setErrorLog_Exists(null);
781     }
782 
783     public void setErrorLog_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
784         ExistsQueryBuilder builder = regExistsQ("errorLog");
785         if (opLambda != null) {
786             opLambda.callback(builder);
787         }
788     }
789 
790     public void setErrorLog_CommonTerms(String errorLog) {
791         setErrorLog_CommonTerms(errorLog, null);
792     }
793 
794     public void setErrorLog_CommonTerms(String errorLog, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
795         CommonTermsQueryBuilder builder = regCommonTermsQ("errorLog", errorLog);
796         if (opLambda != null) {
797             opLambda.callback(builder);
798         }
799     }
800 
801     public BsFailureUrlCQ addOrderBy_ErrorLog_Asc() {
802         regOBA("errorLog");
803         return this;
804     }
805 
806     public BsFailureUrlCQ addOrderBy_ErrorLog_Desc() {
807         regOBD("errorLog");
808         return this;
809     }
810 
811     public void setErrorName_Equal(String errorName) {
812         setErrorName_Term(errorName, null);
813     }
814 
815     public void setErrorName_Equal(String errorName, ConditionOptionCall<TermQueryBuilder> opLambda) {
816         setErrorName_Term(errorName, opLambda);
817     }
818 
819     public void setErrorName_Term(String errorName) {
820         setErrorName_Term(errorName, null);
821     }
822 
823     public void setErrorName_Term(String errorName, ConditionOptionCall<TermQueryBuilder> opLambda) {
824         TermQueryBuilder builder = regTermQ("errorName", errorName);
825         if (opLambda != null) {
826             opLambda.callback(builder);
827         }
828     }
829 
830     public void setErrorName_NotEqual(String errorName) {
831         setErrorName_NotTerm(errorName, null);
832     }
833 
834     public void setErrorName_NotTerm(String errorName) {
835         setErrorName_NotTerm(errorName, null);
836     }
837 
838     public void setErrorName_NotEqual(String errorName, ConditionOptionCall<BoolQueryBuilder> opLambda) {
839         setErrorName_NotTerm(errorName, opLambda);
840     }
841 
842     public void setErrorName_NotTerm(String errorName, ConditionOptionCall<BoolQueryBuilder> opLambda) {
843         not(not -> not.setErrorName_Term(errorName), opLambda);
844     }
845 
846     public void setErrorName_Terms(Collection<String> errorNameList) {
847         setErrorName_Terms(errorNameList, null);
848     }
849 
850     public void setErrorName_Terms(Collection<String> errorNameList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
851         TermsQueryBuilder builder = regTermsQ("errorName", errorNameList);
852         if (opLambda != null) {
853             opLambda.callback(builder);
854         }
855     }
856 
857     public void setErrorName_InScope(Collection<String> errorNameList) {
858         setErrorName_Terms(errorNameList, null);
859     }
860 
861     public void setErrorName_InScope(Collection<String> errorNameList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
862         setErrorName_Terms(errorNameList, opLambda);
863     }
864 
865     public void setErrorName_Match(String errorName) {
866         setErrorName_Match(errorName, null);
867     }
868 
869     public void setErrorName_Match(String errorName, ConditionOptionCall<MatchQueryBuilder> opLambda) {
870         MatchQueryBuilder builder = regMatchQ("errorName", errorName);
871         if (opLambda != null) {
872             opLambda.callback(builder);
873         }
874     }
875 
876     public void setErrorName_MatchPhrase(String errorName) {
877         setErrorName_MatchPhrase(errorName, null);
878     }
879 
880     public void setErrorName_MatchPhrase(String errorName, ConditionOptionCall<MatchPhraseQueryBuilder> opLambda) {
881         MatchPhraseQueryBuilder builder = regMatchPhraseQ("errorName", errorName);
882         if (opLambda != null) {
883             opLambda.callback(builder);
884         }
885     }
886 
887     public void setErrorName_MatchPhrasePrefix(String errorName) {
888         setErrorName_MatchPhrasePrefix(errorName, null);
889     }
890 
891     public void setErrorName_MatchPhrasePrefix(String errorName, ConditionOptionCall<MatchPhrasePrefixQueryBuilder> opLambda) {
892         MatchPhrasePrefixQueryBuilder builder = regMatchPhrasePrefixQ("errorName", errorName);
893         if (opLambda != null) {
894             opLambda.callback(builder);
895         }
896     }
897 
898     public void setErrorName_Fuzzy(String errorName) {
899         setErrorName_Fuzzy(errorName, null);
900     }
901 
902     public void setErrorName_Fuzzy(String errorName, ConditionOptionCall<MatchQueryBuilder> opLambda) {
903         MatchQueryBuilder builder = regFuzzyQ("errorName", errorName);
904         if (opLambda != null) {
905             opLambda.callback(builder);
906         }
907     }
908 
909     public void setErrorName_Prefix(String errorName) {
910         setErrorName_Prefix(errorName, null);
911     }
912 
913     public void setErrorName_Prefix(String errorName, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
914         PrefixQueryBuilder builder = regPrefixQ("errorName", errorName);
915         if (opLambda != null) {
916             opLambda.callback(builder);
917         }
918     }
919 
920     public void setErrorName_Wildcard(String errorName) {
921         setErrorName_Wildcard(errorName, null);
922     }
923 
924     public void setErrorName_Wildcard(String errorName, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
925         WildcardQueryBuilder builder = regWildcardQ("errorName", errorName);
926         if (opLambda != null) {
927             opLambda.callback(builder);
928         }
929     }
930 
931     public void setErrorName_Regexp(String errorName) {
932         setErrorName_Regexp(errorName, null);
933     }
934 
935     public void setErrorName_Regexp(String errorName, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
936         RegexpQueryBuilder builder = regRegexpQ("errorName", errorName);
937         if (opLambda != null) {
938             opLambda.callback(builder);
939         }
940     }
941 
942     public void setErrorName_SpanTerm(String errorName) {
943         setErrorName_SpanTerm("errorName", null);
944     }
945 
946     public void setErrorName_SpanTerm(String errorName, ConditionOptionCall<SpanTermQueryBuilder> opLambda) {
947         SpanTermQueryBuilder builder = regSpanTermQ("errorName", errorName);
948         if (opLambda != null) {
949             opLambda.callback(builder);
950         }
951     }
952 
953     public void setErrorName_GreaterThan(String errorName) {
954         setErrorName_GreaterThan(errorName, null);
955     }
956 
957     public void setErrorName_GreaterThan(String errorName, ConditionOptionCall<RangeQueryBuilder> opLambda) {
958         final Object _value = errorName;
959         RangeQueryBuilder builder = regRangeQ("errorName", ConditionKey.CK_GREATER_THAN, _value);
960         if (opLambda != null) {
961             opLambda.callback(builder);
962         }
963     }
964 
965     public void setErrorName_LessThan(String errorName) {
966         setErrorName_LessThan(errorName, null);
967     }
968 
969     public void setErrorName_LessThan(String errorName, ConditionOptionCall<RangeQueryBuilder> opLambda) {
970         final Object _value = errorName;
971         RangeQueryBuilder builder = regRangeQ("errorName", ConditionKey.CK_LESS_THAN, _value);
972         if (opLambda != null) {
973             opLambda.callback(builder);
974         }
975     }
976 
977     public void setErrorName_GreaterEqual(String errorName) {
978         setErrorName_GreaterEqual(errorName, null);
979     }
980 
981     public void setErrorName_GreaterEqual(String errorName, ConditionOptionCall<RangeQueryBuilder> opLambda) {
982         final Object _value = errorName;
983         RangeQueryBuilder builder = regRangeQ("errorName", ConditionKey.CK_GREATER_EQUAL, _value);
984         if (opLambda != null) {
985             opLambda.callback(builder);
986         }
987     }
988 
989     public void setErrorName_LessEqual(String errorName) {
990         setErrorName_LessEqual(errorName, null);
991     }
992 
993     public void setErrorName_LessEqual(String errorName, ConditionOptionCall<RangeQueryBuilder> opLambda) {
994         final Object _value = errorName;
995         RangeQueryBuilder builder = regRangeQ("errorName", ConditionKey.CK_LESS_EQUAL, _value);
996         if (opLambda != null) {
997             opLambda.callback(builder);
998         }
999     }
1000 
1001     public void setErrorName_Exists() {
1002         setErrorName_Exists(null);
1003     }
1004 
1005     public void setErrorName_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
1006         ExistsQueryBuilder builder = regExistsQ("errorName");
1007         if (opLambda != null) {
1008             opLambda.callback(builder);
1009         }
1010     }
1011 
1012     public void setErrorName_CommonTerms(String errorName) {
1013         setErrorName_CommonTerms(errorName, null);
1014     }
1015 
1016     public void setErrorName_CommonTerms(String errorName, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
1017         CommonTermsQueryBuilder builder = regCommonTermsQ("errorName", errorName);
1018         if (opLambda != null) {
1019             opLambda.callback(builder);
1020         }
1021     }
1022 
1023     public BsFailureUrlCQ addOrderBy_ErrorName_Asc() {
1024         regOBA("errorName");
1025         return this;
1026     }
1027 
1028     public BsFailureUrlCQ addOrderBy_ErrorName_Desc() {
1029         regOBD("errorName");
1030         return this;
1031     }
1032 
1033     public void setLastAccessTime_Equal(Long lastAccessTime) {
1034         setLastAccessTime_Term(lastAccessTime, null);
1035     }
1036 
1037     public void setLastAccessTime_Equal(Long lastAccessTime, ConditionOptionCall<TermQueryBuilder> opLambda) {
1038         setLastAccessTime_Term(lastAccessTime, opLambda);
1039     }
1040 
1041     public void setLastAccessTime_Term(Long lastAccessTime) {
1042         setLastAccessTime_Term(lastAccessTime, null);
1043     }
1044 
1045     public void setLastAccessTime_Term(Long lastAccessTime, ConditionOptionCall<TermQueryBuilder> opLambda) {
1046         TermQueryBuilder builder = regTermQ("lastAccessTime", lastAccessTime);
1047         if (opLambda != null) {
1048             opLambda.callback(builder);
1049         }
1050     }
1051 
1052     public void setLastAccessTime_NotEqual(Long lastAccessTime) {
1053         setLastAccessTime_NotTerm(lastAccessTime, null);
1054     }
1055 
1056     public void setLastAccessTime_NotTerm(Long lastAccessTime) {
1057         setLastAccessTime_NotTerm(lastAccessTime, null);
1058     }
1059 
1060     public void setLastAccessTime_NotEqual(Long lastAccessTime, ConditionOptionCall<BoolQueryBuilder> opLambda) {
1061         setLastAccessTime_NotTerm(lastAccessTime, opLambda);
1062     }
1063 
1064     public void setLastAccessTime_NotTerm(Long lastAccessTime, ConditionOptionCall<BoolQueryBuilder> opLambda) {
1065         not(not -> not.setLastAccessTime_Term(lastAccessTime), opLambda);
1066     }
1067 
1068     public void setLastAccessTime_Terms(Collection<Long> lastAccessTimeList) {
1069         setLastAccessTime_Terms(lastAccessTimeList, null);
1070     }
1071 
1072     public void setLastAccessTime_Terms(Collection<Long> lastAccessTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
1073         TermsQueryBuilder builder = regTermsQ("lastAccessTime", lastAccessTimeList);
1074         if (opLambda != null) {
1075             opLambda.callback(builder);
1076         }
1077     }
1078 
1079     public void setLastAccessTime_InScope(Collection<Long> lastAccessTimeList) {
1080         setLastAccessTime_Terms(lastAccessTimeList, null);
1081     }
1082 
1083     public void setLastAccessTime_InScope(Collection<Long> lastAccessTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
1084         setLastAccessTime_Terms(lastAccessTimeList, opLambda);
1085     }
1086 
1087     public void setLastAccessTime_Match(Long lastAccessTime) {
1088         setLastAccessTime_Match(lastAccessTime, null);
1089     }
1090 
1091     public void setLastAccessTime_Match(Long lastAccessTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
1092         MatchQueryBuilder builder = regMatchQ("lastAccessTime", lastAccessTime);
1093         if (opLambda != null) {
1094             opLambda.callback(builder);
1095         }
1096     }
1097 
1098     public void setLastAccessTime_MatchPhrase(Long lastAccessTime) {
1099         setLastAccessTime_MatchPhrase(lastAccessTime, null);
1100     }
1101 
1102     public void setLastAccessTime_MatchPhrase(Long lastAccessTime, ConditionOptionCall<MatchPhraseQueryBuilder> opLambda) {
1103         MatchPhraseQueryBuilder builder = regMatchPhraseQ("lastAccessTime", lastAccessTime);
1104         if (opLambda != null) {
1105             opLambda.callback(builder);
1106         }
1107     }
1108 
1109     public void setLastAccessTime_MatchPhrasePrefix(Long lastAccessTime) {
1110         setLastAccessTime_MatchPhrasePrefix(lastAccessTime, null);
1111     }
1112 
1113     public void setLastAccessTime_MatchPhrasePrefix(Long lastAccessTime, ConditionOptionCall<MatchPhrasePrefixQueryBuilder> opLambda) {
1114         MatchPhrasePrefixQueryBuilder builder = regMatchPhrasePrefixQ("lastAccessTime", lastAccessTime);
1115         if (opLambda != null) {
1116             opLambda.callback(builder);
1117         }
1118     }
1119 
1120     public void setLastAccessTime_Fuzzy(Long lastAccessTime) {
1121         setLastAccessTime_Fuzzy(lastAccessTime, null);
1122     }
1123 
1124     public void setLastAccessTime_Fuzzy(Long lastAccessTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
1125         MatchQueryBuilder builder = regFuzzyQ("lastAccessTime", lastAccessTime);
1126         if (opLambda != null) {
1127             opLambda.callback(builder);
1128         }
1129     }
1130 
1131     public void setLastAccessTime_GreaterThan(Long lastAccessTime) {
1132         setLastAccessTime_GreaterThan(lastAccessTime, null);
1133     }
1134 
1135     public void setLastAccessTime_GreaterThan(Long lastAccessTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1136         final Object _value = lastAccessTime;
1137         RangeQueryBuilder builder = regRangeQ("lastAccessTime", ConditionKey.CK_GREATER_THAN, _value);
1138         if (opLambda != null) {
1139             opLambda.callback(builder);
1140         }
1141     }
1142 
1143     public void setLastAccessTime_LessThan(Long lastAccessTime) {
1144         setLastAccessTime_LessThan(lastAccessTime, null);
1145     }
1146 
1147     public void setLastAccessTime_LessThan(Long lastAccessTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1148         final Object _value = lastAccessTime;
1149         RangeQueryBuilder builder = regRangeQ("lastAccessTime", ConditionKey.CK_LESS_THAN, _value);
1150         if (opLambda != null) {
1151             opLambda.callback(builder);
1152         }
1153     }
1154 
1155     public void setLastAccessTime_GreaterEqual(Long lastAccessTime) {
1156         setLastAccessTime_GreaterEqual(lastAccessTime, null);
1157     }
1158 
1159     public void setLastAccessTime_GreaterEqual(Long lastAccessTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1160         final Object _value = lastAccessTime;
1161         RangeQueryBuilder builder = regRangeQ("lastAccessTime", ConditionKey.CK_GREATER_EQUAL, _value);
1162         if (opLambda != null) {
1163             opLambda.callback(builder);
1164         }
1165     }
1166 
1167     public void setLastAccessTime_LessEqual(Long lastAccessTime) {
1168         setLastAccessTime_LessEqual(lastAccessTime, null);
1169     }
1170 
1171     public void setLastAccessTime_LessEqual(Long lastAccessTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1172         final Object _value = lastAccessTime;
1173         RangeQueryBuilder builder = regRangeQ("lastAccessTime", ConditionKey.CK_LESS_EQUAL, _value);
1174         if (opLambda != null) {
1175             opLambda.callback(builder);
1176         }
1177     }
1178 
1179     public void setLastAccessTime_Exists() {
1180         setLastAccessTime_Exists(null);
1181     }
1182 
1183     public void setLastAccessTime_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
1184         ExistsQueryBuilder builder = regExistsQ("lastAccessTime");
1185         if (opLambda != null) {
1186             opLambda.callback(builder);
1187         }
1188     }
1189 
1190     public void setLastAccessTime_CommonTerms(Long lastAccessTime) {
1191         setLastAccessTime_CommonTerms(lastAccessTime, null);
1192     }
1193 
1194     public void setLastAccessTime_CommonTerms(Long lastAccessTime, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
1195         CommonTermsQueryBuilder builder = regCommonTermsQ("lastAccessTime", lastAccessTime);
1196         if (opLambda != null) {
1197             opLambda.callback(builder);
1198         }
1199     }
1200 
1201     public BsFailureUrlCQ addOrderBy_LastAccessTime_Asc() {
1202         regOBA("lastAccessTime");
1203         return this;
1204     }
1205 
1206     public BsFailureUrlCQ addOrderBy_LastAccessTime_Desc() {
1207         regOBD("lastAccessTime");
1208         return this;
1209     }
1210 
1211     public void setThreadName_Equal(String threadName) {
1212         setThreadName_Term(threadName, null);
1213     }
1214 
1215     public void setThreadName_Equal(String threadName, ConditionOptionCall<TermQueryBuilder> opLambda) {
1216         setThreadName_Term(threadName, opLambda);
1217     }
1218 
1219     public void setThreadName_Term(String threadName) {
1220         setThreadName_Term(threadName, null);
1221     }
1222 
1223     public void setThreadName_Term(String threadName, ConditionOptionCall<TermQueryBuilder> opLambda) {
1224         TermQueryBuilder builder = regTermQ("threadName", threadName);
1225         if (opLambda != null) {
1226             opLambda.callback(builder);
1227         }
1228     }
1229 
1230     public void setThreadName_NotEqual(String threadName) {
1231         setThreadName_NotTerm(threadName, null);
1232     }
1233 
1234     public void setThreadName_NotTerm(String threadName) {
1235         setThreadName_NotTerm(threadName, null);
1236     }
1237 
1238     public void setThreadName_NotEqual(String threadName, ConditionOptionCall<BoolQueryBuilder> opLambda) {
1239         setThreadName_NotTerm(threadName, opLambda);
1240     }
1241 
1242     public void setThreadName_NotTerm(String threadName, ConditionOptionCall<BoolQueryBuilder> opLambda) {
1243         not(not -> not.setThreadName_Term(threadName), opLambda);
1244     }
1245 
1246     public void setThreadName_Terms(Collection<String> threadNameList) {
1247         setThreadName_Terms(threadNameList, null);
1248     }
1249 
1250     public void setThreadName_Terms(Collection<String> threadNameList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
1251         TermsQueryBuilder builder = regTermsQ("threadName", threadNameList);
1252         if (opLambda != null) {
1253             opLambda.callback(builder);
1254         }
1255     }
1256 
1257     public void setThreadName_InScope(Collection<String> threadNameList) {
1258         setThreadName_Terms(threadNameList, null);
1259     }
1260 
1261     public void setThreadName_InScope(Collection<String> threadNameList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
1262         setThreadName_Terms(threadNameList, opLambda);
1263     }
1264 
1265     public void setThreadName_Match(String threadName) {
1266         setThreadName_Match(threadName, null);
1267     }
1268 
1269     public void setThreadName_Match(String threadName, ConditionOptionCall<MatchQueryBuilder> opLambda) {
1270         MatchQueryBuilder builder = regMatchQ("threadName", threadName);
1271         if (opLambda != null) {
1272             opLambda.callback(builder);
1273         }
1274     }
1275 
1276     public void setThreadName_MatchPhrase(String threadName) {
1277         setThreadName_MatchPhrase(threadName, null);
1278     }
1279 
1280     public void setThreadName_MatchPhrase(String threadName, ConditionOptionCall<MatchPhraseQueryBuilder> opLambda) {
1281         MatchPhraseQueryBuilder builder = regMatchPhraseQ("threadName", threadName);
1282         if (opLambda != null) {
1283             opLambda.callback(builder);
1284         }
1285     }
1286 
1287     public void setThreadName_MatchPhrasePrefix(String threadName) {
1288         setThreadName_MatchPhrasePrefix(threadName, null);
1289     }
1290 
1291     public void setThreadName_MatchPhrasePrefix(String threadName, ConditionOptionCall<MatchPhrasePrefixQueryBuilder> opLambda) {
1292         MatchPhrasePrefixQueryBuilder builder = regMatchPhrasePrefixQ("threadName", threadName);
1293         if (opLambda != null) {
1294             opLambda.callback(builder);
1295         }
1296     }
1297 
1298     public void setThreadName_Fuzzy(String threadName) {
1299         setThreadName_Fuzzy(threadName, null);
1300     }
1301 
1302     public void setThreadName_Fuzzy(String threadName, ConditionOptionCall<MatchQueryBuilder> opLambda) {
1303         MatchQueryBuilder builder = regFuzzyQ("threadName", threadName);
1304         if (opLambda != null) {
1305             opLambda.callback(builder);
1306         }
1307     }
1308 
1309     public void setThreadName_Prefix(String threadName) {
1310         setThreadName_Prefix(threadName, null);
1311     }
1312 
1313     public void setThreadName_Prefix(String threadName, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
1314         PrefixQueryBuilder builder = regPrefixQ("threadName", threadName);
1315         if (opLambda != null) {
1316             opLambda.callback(builder);
1317         }
1318     }
1319 
1320     public void setThreadName_Wildcard(String threadName) {
1321         setThreadName_Wildcard(threadName, null);
1322     }
1323 
1324     public void setThreadName_Wildcard(String threadName, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
1325         WildcardQueryBuilder builder = regWildcardQ("threadName", threadName);
1326         if (opLambda != null) {
1327             opLambda.callback(builder);
1328         }
1329     }
1330 
1331     public void setThreadName_Regexp(String threadName) {
1332         setThreadName_Regexp(threadName, null);
1333     }
1334 
1335     public void setThreadName_Regexp(String threadName, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
1336         RegexpQueryBuilder builder = regRegexpQ("threadName", threadName);
1337         if (opLambda != null) {
1338             opLambda.callback(builder);
1339         }
1340     }
1341 
1342     public void setThreadName_SpanTerm(String threadName) {
1343         setThreadName_SpanTerm("threadName", null);
1344     }
1345 
1346     public void setThreadName_SpanTerm(String threadName, ConditionOptionCall<SpanTermQueryBuilder> opLambda) {
1347         SpanTermQueryBuilder builder = regSpanTermQ("threadName", threadName);
1348         if (opLambda != null) {
1349             opLambda.callback(builder);
1350         }
1351     }
1352 
1353     public void setThreadName_GreaterThan(String threadName) {
1354         setThreadName_GreaterThan(threadName, null);
1355     }
1356 
1357     public void setThreadName_GreaterThan(String threadName, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1358         final Object _value = threadName;
1359         RangeQueryBuilder builder = regRangeQ("threadName", ConditionKey.CK_GREATER_THAN, _value);
1360         if (opLambda != null) {
1361             opLambda.callback(builder);
1362         }
1363     }
1364 
1365     public void setThreadName_LessThan(String threadName) {
1366         setThreadName_LessThan(threadName, null);
1367     }
1368 
1369     public void setThreadName_LessThan(String threadName, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1370         final Object _value = threadName;
1371         RangeQueryBuilder builder = regRangeQ("threadName", ConditionKey.CK_LESS_THAN, _value);
1372         if (opLambda != null) {
1373             opLambda.callback(builder);
1374         }
1375     }
1376 
1377     public void setThreadName_GreaterEqual(String threadName) {
1378         setThreadName_GreaterEqual(threadName, null);
1379     }
1380 
1381     public void setThreadName_GreaterEqual(String threadName, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1382         final Object _value = threadName;
1383         RangeQueryBuilder builder = regRangeQ("threadName", ConditionKey.CK_GREATER_EQUAL, _value);
1384         if (opLambda != null) {
1385             opLambda.callback(builder);
1386         }
1387     }
1388 
1389     public void setThreadName_LessEqual(String threadName) {
1390         setThreadName_LessEqual(threadName, null);
1391     }
1392 
1393     public void setThreadName_LessEqual(String threadName, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1394         final Object _value = threadName;
1395         RangeQueryBuilder builder = regRangeQ("threadName", ConditionKey.CK_LESS_EQUAL, _value);
1396         if (opLambda != null) {
1397             opLambda.callback(builder);
1398         }
1399     }
1400 
1401     public void setThreadName_Exists() {
1402         setThreadName_Exists(null);
1403     }
1404 
1405     public void setThreadName_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
1406         ExistsQueryBuilder builder = regExistsQ("threadName");
1407         if (opLambda != null) {
1408             opLambda.callback(builder);
1409         }
1410     }
1411 
1412     public void setThreadName_CommonTerms(String threadName) {
1413         setThreadName_CommonTerms(threadName, null);
1414     }
1415 
1416     public void setThreadName_CommonTerms(String threadName, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
1417         CommonTermsQueryBuilder builder = regCommonTermsQ("threadName", threadName);
1418         if (opLambda != null) {
1419             opLambda.callback(builder);
1420         }
1421     }
1422 
1423     public BsFailureUrlCQ addOrderBy_ThreadName_Asc() {
1424         regOBA("threadName");
1425         return this;
1426     }
1427 
1428     public BsFailureUrlCQ addOrderBy_ThreadName_Desc() {
1429         regOBD("threadName");
1430         return this;
1431     }
1432 
1433     public void setUrl_Equal(String url) {
1434         setUrl_Term(url, null);
1435     }
1436 
1437     public void setUrl_Equal(String url, ConditionOptionCall<TermQueryBuilder> opLambda) {
1438         setUrl_Term(url, opLambda);
1439     }
1440 
1441     public void setUrl_Term(String url) {
1442         setUrl_Term(url, null);
1443     }
1444 
1445     public void setUrl_Term(String url, ConditionOptionCall<TermQueryBuilder> opLambda) {
1446         TermQueryBuilder builder = regTermQ("url", url);
1447         if (opLambda != null) {
1448             opLambda.callback(builder);
1449         }
1450     }
1451 
1452     public void setUrl_NotEqual(String url) {
1453         setUrl_NotTerm(url, null);
1454     }
1455 
1456     public void setUrl_NotTerm(String url) {
1457         setUrl_NotTerm(url, null);
1458     }
1459 
1460     public void setUrl_NotEqual(String url, ConditionOptionCall<BoolQueryBuilder> opLambda) {
1461         setUrl_NotTerm(url, opLambda);
1462     }
1463 
1464     public void setUrl_NotTerm(String url, ConditionOptionCall<BoolQueryBuilder> opLambda) {
1465         not(not -> not.setUrl_Term(url), opLambda);
1466     }
1467 
1468     public void setUrl_Terms(Collection<String> urlList) {
1469         setUrl_Terms(urlList, null);
1470     }
1471 
1472     public void setUrl_Terms(Collection<String> urlList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
1473         TermsQueryBuilder builder = regTermsQ("url", urlList);
1474         if (opLambda != null) {
1475             opLambda.callback(builder);
1476         }
1477     }
1478 
1479     public void setUrl_InScope(Collection<String> urlList) {
1480         setUrl_Terms(urlList, null);
1481     }
1482 
1483     public void setUrl_InScope(Collection<String> urlList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
1484         setUrl_Terms(urlList, opLambda);
1485     }
1486 
1487     public void setUrl_Match(String url) {
1488         setUrl_Match(url, null);
1489     }
1490 
1491     public void setUrl_Match(String url, ConditionOptionCall<MatchQueryBuilder> opLambda) {
1492         MatchQueryBuilder builder = regMatchQ("url", url);
1493         if (opLambda != null) {
1494             opLambda.callback(builder);
1495         }
1496     }
1497 
1498     public void setUrl_MatchPhrase(String url) {
1499         setUrl_MatchPhrase(url, null);
1500     }
1501 
1502     public void setUrl_MatchPhrase(String url, ConditionOptionCall<MatchPhraseQueryBuilder> opLambda) {
1503         MatchPhraseQueryBuilder builder = regMatchPhraseQ("url", url);
1504         if (opLambda != null) {
1505             opLambda.callback(builder);
1506         }
1507     }
1508 
1509     public void setUrl_MatchPhrasePrefix(String url) {
1510         setUrl_MatchPhrasePrefix(url, null);
1511     }
1512 
1513     public void setUrl_MatchPhrasePrefix(String url, ConditionOptionCall<MatchPhrasePrefixQueryBuilder> opLambda) {
1514         MatchPhrasePrefixQueryBuilder builder = regMatchPhrasePrefixQ("url", url);
1515         if (opLambda != null) {
1516             opLambda.callback(builder);
1517         }
1518     }
1519 
1520     public void setUrl_Fuzzy(String url) {
1521         setUrl_Fuzzy(url, null);
1522     }
1523 
1524     public void setUrl_Fuzzy(String url, ConditionOptionCall<MatchQueryBuilder> opLambda) {
1525         MatchQueryBuilder builder = regFuzzyQ("url", url);
1526         if (opLambda != null) {
1527             opLambda.callback(builder);
1528         }
1529     }
1530 
1531     public void setUrl_Prefix(String url) {
1532         setUrl_Prefix(url, null);
1533     }
1534 
1535     public void setUrl_Prefix(String url, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
1536         PrefixQueryBuilder builder = regPrefixQ("url", url);
1537         if (opLambda != null) {
1538             opLambda.callback(builder);
1539         }
1540     }
1541 
1542     public void setUrl_Wildcard(String url) {
1543         setUrl_Wildcard(url, null);
1544     }
1545 
1546     public void setUrl_Wildcard(String url, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
1547         WildcardQueryBuilder builder = regWildcardQ("url", url);
1548         if (opLambda != null) {
1549             opLambda.callback(builder);
1550         }
1551     }
1552 
1553     public void setUrl_Regexp(String url) {
1554         setUrl_Regexp(url, null);
1555     }
1556 
1557     public void setUrl_Regexp(String url, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
1558         RegexpQueryBuilder builder = regRegexpQ("url", url);
1559         if (opLambda != null) {
1560             opLambda.callback(builder);
1561         }
1562     }
1563 
1564     public void setUrl_SpanTerm(String url) {
1565         setUrl_SpanTerm("url", null);
1566     }
1567 
1568     public void setUrl_SpanTerm(String url, ConditionOptionCall<SpanTermQueryBuilder> opLambda) {
1569         SpanTermQueryBuilder builder = regSpanTermQ("url", url);
1570         if (opLambda != null) {
1571             opLambda.callback(builder);
1572         }
1573     }
1574 
1575     public void setUrl_GreaterThan(String url) {
1576         setUrl_GreaterThan(url, null);
1577     }
1578 
1579     public void setUrl_GreaterThan(String url, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1580         final Object _value = url;
1581         RangeQueryBuilder builder = regRangeQ("url", ConditionKey.CK_GREATER_THAN, _value);
1582         if (opLambda != null) {
1583             opLambda.callback(builder);
1584         }
1585     }
1586 
1587     public void setUrl_LessThan(String url) {
1588         setUrl_LessThan(url, null);
1589     }
1590 
1591     public void setUrl_LessThan(String url, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1592         final Object _value = url;
1593         RangeQueryBuilder builder = regRangeQ("url", ConditionKey.CK_LESS_THAN, _value);
1594         if (opLambda != null) {
1595             opLambda.callback(builder);
1596         }
1597     }
1598 
1599     public void setUrl_GreaterEqual(String url) {
1600         setUrl_GreaterEqual(url, null);
1601     }
1602 
1603     public void setUrl_GreaterEqual(String url, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1604         final Object _value = url;
1605         RangeQueryBuilder builder = regRangeQ("url", ConditionKey.CK_GREATER_EQUAL, _value);
1606         if (opLambda != null) {
1607             opLambda.callback(builder);
1608         }
1609     }
1610 
1611     public void setUrl_LessEqual(String url) {
1612         setUrl_LessEqual(url, null);
1613     }
1614 
1615     public void setUrl_LessEqual(String url, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1616         final Object _value = url;
1617         RangeQueryBuilder builder = regRangeQ("url", ConditionKey.CK_LESS_EQUAL, _value);
1618         if (opLambda != null) {
1619             opLambda.callback(builder);
1620         }
1621     }
1622 
1623     public void setUrl_Exists() {
1624         setUrl_Exists(null);
1625     }
1626 
1627     public void setUrl_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
1628         ExistsQueryBuilder builder = regExistsQ("url");
1629         if (opLambda != null) {
1630             opLambda.callback(builder);
1631         }
1632     }
1633 
1634     public void setUrl_CommonTerms(String url) {
1635         setUrl_CommonTerms(url, null);
1636     }
1637 
1638     public void setUrl_CommonTerms(String url, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
1639         CommonTermsQueryBuilder builder = regCommonTermsQ("url", url);
1640         if (opLambda != null) {
1641             opLambda.callback(builder);
1642         }
1643     }
1644 
1645     public BsFailureUrlCQ addOrderBy_Url_Asc() {
1646         regOBA("url");
1647         return this;
1648     }
1649 
1650     public BsFailureUrlCQ addOrderBy_Url_Desc() {
1651         regOBD("url");
1652         return this;
1653     }
1654 
1655 }