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.JobLogCQ;
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 BsJobLogCQ 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 "job_log";
55      }
56  
57      @Override
58      public String xgetAliasName() {
59          return "job_log";
60      }
61  
62      // ===================================================================================
63      //                                                                       Query Control
64      //                                                                       =============
65      public void functionScore(OperatorCall<JobLogCQ> queryLambda, ScoreFunctionCall<ScoreFunctionCreator<JobLogCQ>> functionsLambda,
66              final ConditionOptionCall<FunctionScoreQueryBuilder> opLambda) {
67          JobLogCQ cq = new JobLogCQ();
68          queryLambda.callback(cq);
69          final Collection<FilterFunctionBuilder> list = new ArrayList<>();
70          if (functionsLambda != null) {
71              functionsLambda.callback((cqLambda, scoreFunctionBuilder) -> {
72                  JobLogCQ cf = new JobLogCQ();
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<JobLogCQ, JobLogCQ> filteredLambda) {
84          filtered(filteredLambda, null);
85      }
86  
87      public void filtered(FilteredCall<JobLogCQ, JobLogCQ> filteredLambda, ConditionOptionCall<BoolQueryBuilder> opLambda) {
88          bool((must, should, mustNot, filter) -> {
89              filteredLambda.callback(must, filter);
90          }, opLambda);
91      }
92  
93      public void not(OperatorCall<JobLogCQ> notLambda) {
94          not(notLambda, null);
95      }
96  
97      public void not(final OperatorCall<JobLogCQ> notLambda, final ConditionOptionCall<BoolQueryBuilder> opLambda) {
98          bool((must, should, mustNot, filter) -> notLambda.callback(mustNot), opLambda);
99      }
100 
101     public void bool(BoolCall<JobLogCQ> boolLambda) {
102         bool(boolLambda, null);
103     }
104 
105     public void bool(BoolCall<JobLogCQ> boolLambda, ConditionOptionCall<BoolQueryBuilder> opLambda) {
106         JobLogCQ mustQuery = new JobLogCQ();
107         JobLogCQ shouldQuery = new JobLogCQ();
108         JobLogCQ mustNotQuery = new JobLogCQ();
109         JobLogCQ filterQuery = new JobLogCQ();
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 BsJobLogCQ addOrderBy_Id_Asc() {
179         regOBA("_id");
180         return this;
181     }
182 
183     @Deprecated
184     public BsJobLogCQ addOrderBy_Id_Desc() {
185         regOBD("_id");
186         return this;
187     }
188 
189     public void setEndTime_Equal(Long endTime) {
190         setEndTime_Term(endTime, null);
191     }
192 
193     public void setEndTime_Equal(Long endTime, ConditionOptionCall<TermQueryBuilder> opLambda) {
194         setEndTime_Term(endTime, opLambda);
195     }
196 
197     public void setEndTime_Term(Long endTime) {
198         setEndTime_Term(endTime, null);
199     }
200 
201     public void setEndTime_Term(Long endTime, ConditionOptionCall<TermQueryBuilder> opLambda) {
202         TermQueryBuilder builder = regTermQ("endTime", endTime);
203         if (opLambda != null) {
204             opLambda.callback(builder);
205         }
206     }
207 
208     public void setEndTime_NotEqual(Long endTime) {
209         setEndTime_NotTerm(endTime, null);
210     }
211 
212     public void setEndTime_NotTerm(Long endTime) {
213         setEndTime_NotTerm(endTime, null);
214     }
215 
216     public void setEndTime_NotEqual(Long endTime, ConditionOptionCall<BoolQueryBuilder> opLambda) {
217         setEndTime_NotTerm(endTime, opLambda);
218     }
219 
220     public void setEndTime_NotTerm(Long endTime, ConditionOptionCall<BoolQueryBuilder> opLambda) {
221         not(not -> not.setEndTime_Term(endTime), opLambda);
222     }
223 
224     public void setEndTime_Terms(Collection<Long> endTimeList) {
225         setEndTime_Terms(endTimeList, null);
226     }
227 
228     public void setEndTime_Terms(Collection<Long> endTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
229         TermsQueryBuilder builder = regTermsQ("endTime", endTimeList);
230         if (opLambda != null) {
231             opLambda.callback(builder);
232         }
233     }
234 
235     public void setEndTime_InScope(Collection<Long> endTimeList) {
236         setEndTime_Terms(endTimeList, null);
237     }
238 
239     public void setEndTime_InScope(Collection<Long> endTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
240         setEndTime_Terms(endTimeList, opLambda);
241     }
242 
243     public void setEndTime_Match(Long endTime) {
244         setEndTime_Match(endTime, null);
245     }
246 
247     public void setEndTime_Match(Long endTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
248         MatchQueryBuilder builder = regMatchQ("endTime", endTime);
249         if (opLambda != null) {
250             opLambda.callback(builder);
251         }
252     }
253 
254     public void setEndTime_MatchPhrase(Long endTime) {
255         setEndTime_MatchPhrase(endTime, null);
256     }
257 
258     public void setEndTime_MatchPhrase(Long endTime, ConditionOptionCall<MatchPhraseQueryBuilder> opLambda) {
259         MatchPhraseQueryBuilder builder = regMatchPhraseQ("endTime", endTime);
260         if (opLambda != null) {
261             opLambda.callback(builder);
262         }
263     }
264 
265     public void setEndTime_MatchPhrasePrefix(Long endTime) {
266         setEndTime_MatchPhrasePrefix(endTime, null);
267     }
268 
269     public void setEndTime_MatchPhrasePrefix(Long endTime, ConditionOptionCall<MatchPhrasePrefixQueryBuilder> opLambda) {
270         MatchPhrasePrefixQueryBuilder builder = regMatchPhrasePrefixQ("endTime", endTime);
271         if (opLambda != null) {
272             opLambda.callback(builder);
273         }
274     }
275 
276     public void setEndTime_Fuzzy(Long endTime) {
277         setEndTime_Fuzzy(endTime, null);
278     }
279 
280     public void setEndTime_Fuzzy(Long endTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
281         MatchQueryBuilder builder = regFuzzyQ("endTime", endTime);
282         if (opLambda != null) {
283             opLambda.callback(builder);
284         }
285     }
286 
287     public void setEndTime_GreaterThan(Long endTime) {
288         setEndTime_GreaterThan(endTime, null);
289     }
290 
291     public void setEndTime_GreaterThan(Long endTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
292         final Object _value = endTime;
293         RangeQueryBuilder builder = regRangeQ("endTime", ConditionKey.CK_GREATER_THAN, _value);
294         if (opLambda != null) {
295             opLambda.callback(builder);
296         }
297     }
298 
299     public void setEndTime_LessThan(Long endTime) {
300         setEndTime_LessThan(endTime, null);
301     }
302 
303     public void setEndTime_LessThan(Long endTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
304         final Object _value = endTime;
305         RangeQueryBuilder builder = regRangeQ("endTime", ConditionKey.CK_LESS_THAN, _value);
306         if (opLambda != null) {
307             opLambda.callback(builder);
308         }
309     }
310 
311     public void setEndTime_GreaterEqual(Long endTime) {
312         setEndTime_GreaterEqual(endTime, null);
313     }
314 
315     public void setEndTime_GreaterEqual(Long endTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
316         final Object _value = endTime;
317         RangeQueryBuilder builder = regRangeQ("endTime", ConditionKey.CK_GREATER_EQUAL, _value);
318         if (opLambda != null) {
319             opLambda.callback(builder);
320         }
321     }
322 
323     public void setEndTime_LessEqual(Long endTime) {
324         setEndTime_LessEqual(endTime, null);
325     }
326 
327     public void setEndTime_LessEqual(Long endTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
328         final Object _value = endTime;
329         RangeQueryBuilder builder = regRangeQ("endTime", ConditionKey.CK_LESS_EQUAL, _value);
330         if (opLambda != null) {
331             opLambda.callback(builder);
332         }
333     }
334 
335     public void setEndTime_Exists() {
336         setEndTime_Exists(null);
337     }
338 
339     public void setEndTime_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
340         ExistsQueryBuilder builder = regExistsQ("endTime");
341         if (opLambda != null) {
342             opLambda.callback(builder);
343         }
344     }
345 
346     @Deprecated
347     public void setEndTime_CommonTerms(Long endTime) {
348         setEndTime_CommonTerms(endTime, null);
349     }
350 
351     @Deprecated
352     public void setEndTime_CommonTerms(Long endTime, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
353         CommonTermsQueryBuilder builder = regCommonTermsQ("endTime", endTime);
354         if (opLambda != null) {
355             opLambda.callback(builder);
356         }
357     }
358 
359     public BsJobLogCQ addOrderBy_EndTime_Asc() {
360         regOBA("endTime");
361         return this;
362     }
363 
364     public BsJobLogCQ addOrderBy_EndTime_Desc() {
365         regOBD("endTime");
366         return this;
367     }
368 
369     public void setJobName_Equal(String jobName) {
370         setJobName_Term(jobName, null);
371     }
372 
373     public void setJobName_Equal(String jobName, ConditionOptionCall<TermQueryBuilder> opLambda) {
374         setJobName_Term(jobName, opLambda);
375     }
376 
377     public void setJobName_Term(String jobName) {
378         setJobName_Term(jobName, null);
379     }
380 
381     public void setJobName_Term(String jobName, ConditionOptionCall<TermQueryBuilder> opLambda) {
382         TermQueryBuilder builder = regTermQ("jobName", jobName);
383         if (opLambda != null) {
384             opLambda.callback(builder);
385         }
386     }
387 
388     public void setJobName_NotEqual(String jobName) {
389         setJobName_NotTerm(jobName, null);
390     }
391 
392     public void setJobName_NotTerm(String jobName) {
393         setJobName_NotTerm(jobName, null);
394     }
395 
396     public void setJobName_NotEqual(String jobName, ConditionOptionCall<BoolQueryBuilder> opLambda) {
397         setJobName_NotTerm(jobName, opLambda);
398     }
399 
400     public void setJobName_NotTerm(String jobName, ConditionOptionCall<BoolQueryBuilder> opLambda) {
401         not(not -> not.setJobName_Term(jobName), opLambda);
402     }
403 
404     public void setJobName_Terms(Collection<String> jobNameList) {
405         setJobName_Terms(jobNameList, null);
406     }
407 
408     public void setJobName_Terms(Collection<String> jobNameList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
409         TermsQueryBuilder builder = regTermsQ("jobName", jobNameList);
410         if (opLambda != null) {
411             opLambda.callback(builder);
412         }
413     }
414 
415     public void setJobName_InScope(Collection<String> jobNameList) {
416         setJobName_Terms(jobNameList, null);
417     }
418 
419     public void setJobName_InScope(Collection<String> jobNameList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
420         setJobName_Terms(jobNameList, opLambda);
421     }
422 
423     public void setJobName_Match(String jobName) {
424         setJobName_Match(jobName, null);
425     }
426 
427     public void setJobName_Match(String jobName, ConditionOptionCall<MatchQueryBuilder> opLambda) {
428         MatchQueryBuilder builder = regMatchQ("jobName", jobName);
429         if (opLambda != null) {
430             opLambda.callback(builder);
431         }
432     }
433 
434     public void setJobName_MatchPhrase(String jobName) {
435         setJobName_MatchPhrase(jobName, null);
436     }
437 
438     public void setJobName_MatchPhrase(String jobName, ConditionOptionCall<MatchPhraseQueryBuilder> opLambda) {
439         MatchPhraseQueryBuilder builder = regMatchPhraseQ("jobName", jobName);
440         if (opLambda != null) {
441             opLambda.callback(builder);
442         }
443     }
444 
445     public void setJobName_MatchPhrasePrefix(String jobName) {
446         setJobName_MatchPhrasePrefix(jobName, null);
447     }
448 
449     public void setJobName_MatchPhrasePrefix(String jobName, ConditionOptionCall<MatchPhrasePrefixQueryBuilder> opLambda) {
450         MatchPhrasePrefixQueryBuilder builder = regMatchPhrasePrefixQ("jobName", jobName);
451         if (opLambda != null) {
452             opLambda.callback(builder);
453         }
454     }
455 
456     public void setJobName_Fuzzy(String jobName) {
457         setJobName_Fuzzy(jobName, null);
458     }
459 
460     public void setJobName_Fuzzy(String jobName, ConditionOptionCall<MatchQueryBuilder> opLambda) {
461         MatchQueryBuilder builder = regFuzzyQ("jobName", jobName);
462         if (opLambda != null) {
463             opLambda.callback(builder);
464         }
465     }
466 
467     public void setJobName_Prefix(String jobName) {
468         setJobName_Prefix(jobName, null);
469     }
470 
471     public void setJobName_Prefix(String jobName, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
472         PrefixQueryBuilder builder = regPrefixQ("jobName", jobName);
473         if (opLambda != null) {
474             opLambda.callback(builder);
475         }
476     }
477 
478     public void setJobName_Wildcard(String jobName) {
479         setJobName_Wildcard(jobName, null);
480     }
481 
482     public void setJobName_Wildcard(String jobName, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
483         WildcardQueryBuilder builder = regWildcardQ("jobName", jobName);
484         if (opLambda != null) {
485             opLambda.callback(builder);
486         }
487     }
488 
489     public void setJobName_Regexp(String jobName) {
490         setJobName_Regexp(jobName, null);
491     }
492 
493     public void setJobName_Regexp(String jobName, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
494         RegexpQueryBuilder builder = regRegexpQ("jobName", jobName);
495         if (opLambda != null) {
496             opLambda.callback(builder);
497         }
498     }
499 
500     public void setJobName_SpanTerm(String jobName) {
501         setJobName_SpanTerm("jobName", null);
502     }
503 
504     public void setJobName_SpanTerm(String jobName, ConditionOptionCall<SpanTermQueryBuilder> opLambda) {
505         SpanTermQueryBuilder builder = regSpanTermQ("jobName", jobName);
506         if (opLambda != null) {
507             opLambda.callback(builder);
508         }
509     }
510 
511     public void setJobName_GreaterThan(String jobName) {
512         setJobName_GreaterThan(jobName, null);
513     }
514 
515     public void setJobName_GreaterThan(String jobName, ConditionOptionCall<RangeQueryBuilder> opLambda) {
516         final Object _value = jobName;
517         RangeQueryBuilder builder = regRangeQ("jobName", ConditionKey.CK_GREATER_THAN, _value);
518         if (opLambda != null) {
519             opLambda.callback(builder);
520         }
521     }
522 
523     public void setJobName_LessThan(String jobName) {
524         setJobName_LessThan(jobName, null);
525     }
526 
527     public void setJobName_LessThan(String jobName, ConditionOptionCall<RangeQueryBuilder> opLambda) {
528         final Object _value = jobName;
529         RangeQueryBuilder builder = regRangeQ("jobName", ConditionKey.CK_LESS_THAN, _value);
530         if (opLambda != null) {
531             opLambda.callback(builder);
532         }
533     }
534 
535     public void setJobName_GreaterEqual(String jobName) {
536         setJobName_GreaterEqual(jobName, null);
537     }
538 
539     public void setJobName_GreaterEqual(String jobName, ConditionOptionCall<RangeQueryBuilder> opLambda) {
540         final Object _value = jobName;
541         RangeQueryBuilder builder = regRangeQ("jobName", ConditionKey.CK_GREATER_EQUAL, _value);
542         if (opLambda != null) {
543             opLambda.callback(builder);
544         }
545     }
546 
547     public void setJobName_LessEqual(String jobName) {
548         setJobName_LessEqual(jobName, null);
549     }
550 
551     public void setJobName_LessEqual(String jobName, ConditionOptionCall<RangeQueryBuilder> opLambda) {
552         final Object _value = jobName;
553         RangeQueryBuilder builder = regRangeQ("jobName", ConditionKey.CK_LESS_EQUAL, _value);
554         if (opLambda != null) {
555             opLambda.callback(builder);
556         }
557     }
558 
559     public void setJobName_Exists() {
560         setJobName_Exists(null);
561     }
562 
563     public void setJobName_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
564         ExistsQueryBuilder builder = regExistsQ("jobName");
565         if (opLambda != null) {
566             opLambda.callback(builder);
567         }
568     }
569 
570     @Deprecated
571     public void setJobName_CommonTerms(String jobName) {
572         setJobName_CommonTerms(jobName, null);
573     }
574 
575     @Deprecated
576     public void setJobName_CommonTerms(String jobName, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
577         CommonTermsQueryBuilder builder = regCommonTermsQ("jobName", jobName);
578         if (opLambda != null) {
579             opLambda.callback(builder);
580         }
581     }
582 
583     public BsJobLogCQ addOrderBy_JobName_Asc() {
584         regOBA("jobName");
585         return this;
586     }
587 
588     public BsJobLogCQ addOrderBy_JobName_Desc() {
589         regOBD("jobName");
590         return this;
591     }
592 
593     public void setJobStatus_Equal(String jobStatus) {
594         setJobStatus_Term(jobStatus, null);
595     }
596 
597     public void setJobStatus_Equal(String jobStatus, ConditionOptionCall<TermQueryBuilder> opLambda) {
598         setJobStatus_Term(jobStatus, opLambda);
599     }
600 
601     public void setJobStatus_Term(String jobStatus) {
602         setJobStatus_Term(jobStatus, null);
603     }
604 
605     public void setJobStatus_Term(String jobStatus, ConditionOptionCall<TermQueryBuilder> opLambda) {
606         TermQueryBuilder builder = regTermQ("jobStatus", jobStatus);
607         if (opLambda != null) {
608             opLambda.callback(builder);
609         }
610     }
611 
612     public void setJobStatus_NotEqual(String jobStatus) {
613         setJobStatus_NotTerm(jobStatus, null);
614     }
615 
616     public void setJobStatus_NotTerm(String jobStatus) {
617         setJobStatus_NotTerm(jobStatus, null);
618     }
619 
620     public void setJobStatus_NotEqual(String jobStatus, ConditionOptionCall<BoolQueryBuilder> opLambda) {
621         setJobStatus_NotTerm(jobStatus, opLambda);
622     }
623 
624     public void setJobStatus_NotTerm(String jobStatus, ConditionOptionCall<BoolQueryBuilder> opLambda) {
625         not(not -> not.setJobStatus_Term(jobStatus), opLambda);
626     }
627 
628     public void setJobStatus_Terms(Collection<String> jobStatusList) {
629         setJobStatus_Terms(jobStatusList, null);
630     }
631 
632     public void setJobStatus_Terms(Collection<String> jobStatusList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
633         TermsQueryBuilder builder = regTermsQ("jobStatus", jobStatusList);
634         if (opLambda != null) {
635             opLambda.callback(builder);
636         }
637     }
638 
639     public void setJobStatus_InScope(Collection<String> jobStatusList) {
640         setJobStatus_Terms(jobStatusList, null);
641     }
642 
643     public void setJobStatus_InScope(Collection<String> jobStatusList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
644         setJobStatus_Terms(jobStatusList, opLambda);
645     }
646 
647     public void setJobStatus_Match(String jobStatus) {
648         setJobStatus_Match(jobStatus, null);
649     }
650 
651     public void setJobStatus_Match(String jobStatus, ConditionOptionCall<MatchQueryBuilder> opLambda) {
652         MatchQueryBuilder builder = regMatchQ("jobStatus", jobStatus);
653         if (opLambda != null) {
654             opLambda.callback(builder);
655         }
656     }
657 
658     public void setJobStatus_MatchPhrase(String jobStatus) {
659         setJobStatus_MatchPhrase(jobStatus, null);
660     }
661 
662     public void setJobStatus_MatchPhrase(String jobStatus, ConditionOptionCall<MatchPhraseQueryBuilder> opLambda) {
663         MatchPhraseQueryBuilder builder = regMatchPhraseQ("jobStatus", jobStatus);
664         if (opLambda != null) {
665             opLambda.callback(builder);
666         }
667     }
668 
669     public void setJobStatus_MatchPhrasePrefix(String jobStatus) {
670         setJobStatus_MatchPhrasePrefix(jobStatus, null);
671     }
672 
673     public void setJobStatus_MatchPhrasePrefix(String jobStatus, ConditionOptionCall<MatchPhrasePrefixQueryBuilder> opLambda) {
674         MatchPhrasePrefixQueryBuilder builder = regMatchPhrasePrefixQ("jobStatus", jobStatus);
675         if (opLambda != null) {
676             opLambda.callback(builder);
677         }
678     }
679 
680     public void setJobStatus_Fuzzy(String jobStatus) {
681         setJobStatus_Fuzzy(jobStatus, null);
682     }
683 
684     public void setJobStatus_Fuzzy(String jobStatus, ConditionOptionCall<MatchQueryBuilder> opLambda) {
685         MatchQueryBuilder builder = regFuzzyQ("jobStatus", jobStatus);
686         if (opLambda != null) {
687             opLambda.callback(builder);
688         }
689     }
690 
691     public void setJobStatus_Prefix(String jobStatus) {
692         setJobStatus_Prefix(jobStatus, null);
693     }
694 
695     public void setJobStatus_Prefix(String jobStatus, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
696         PrefixQueryBuilder builder = regPrefixQ("jobStatus", jobStatus);
697         if (opLambda != null) {
698             opLambda.callback(builder);
699         }
700     }
701 
702     public void setJobStatus_Wildcard(String jobStatus) {
703         setJobStatus_Wildcard(jobStatus, null);
704     }
705 
706     public void setJobStatus_Wildcard(String jobStatus, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
707         WildcardQueryBuilder builder = regWildcardQ("jobStatus", jobStatus);
708         if (opLambda != null) {
709             opLambda.callback(builder);
710         }
711     }
712 
713     public void setJobStatus_Regexp(String jobStatus) {
714         setJobStatus_Regexp(jobStatus, null);
715     }
716 
717     public void setJobStatus_Regexp(String jobStatus, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
718         RegexpQueryBuilder builder = regRegexpQ("jobStatus", jobStatus);
719         if (opLambda != null) {
720             opLambda.callback(builder);
721         }
722     }
723 
724     public void setJobStatus_SpanTerm(String jobStatus) {
725         setJobStatus_SpanTerm("jobStatus", null);
726     }
727 
728     public void setJobStatus_SpanTerm(String jobStatus, ConditionOptionCall<SpanTermQueryBuilder> opLambda) {
729         SpanTermQueryBuilder builder = regSpanTermQ("jobStatus", jobStatus);
730         if (opLambda != null) {
731             opLambda.callback(builder);
732         }
733     }
734 
735     public void setJobStatus_GreaterThan(String jobStatus) {
736         setJobStatus_GreaterThan(jobStatus, null);
737     }
738 
739     public void setJobStatus_GreaterThan(String jobStatus, ConditionOptionCall<RangeQueryBuilder> opLambda) {
740         final Object _value = jobStatus;
741         RangeQueryBuilder builder = regRangeQ("jobStatus", ConditionKey.CK_GREATER_THAN, _value);
742         if (opLambda != null) {
743             opLambda.callback(builder);
744         }
745     }
746 
747     public void setJobStatus_LessThan(String jobStatus) {
748         setJobStatus_LessThan(jobStatus, null);
749     }
750 
751     public void setJobStatus_LessThan(String jobStatus, ConditionOptionCall<RangeQueryBuilder> opLambda) {
752         final Object _value = jobStatus;
753         RangeQueryBuilder builder = regRangeQ("jobStatus", ConditionKey.CK_LESS_THAN, _value);
754         if (opLambda != null) {
755             opLambda.callback(builder);
756         }
757     }
758 
759     public void setJobStatus_GreaterEqual(String jobStatus) {
760         setJobStatus_GreaterEqual(jobStatus, null);
761     }
762 
763     public void setJobStatus_GreaterEqual(String jobStatus, ConditionOptionCall<RangeQueryBuilder> opLambda) {
764         final Object _value = jobStatus;
765         RangeQueryBuilder builder = regRangeQ("jobStatus", ConditionKey.CK_GREATER_EQUAL, _value);
766         if (opLambda != null) {
767             opLambda.callback(builder);
768         }
769     }
770 
771     public void setJobStatus_LessEqual(String jobStatus) {
772         setJobStatus_LessEqual(jobStatus, null);
773     }
774 
775     public void setJobStatus_LessEqual(String jobStatus, ConditionOptionCall<RangeQueryBuilder> opLambda) {
776         final Object _value = jobStatus;
777         RangeQueryBuilder builder = regRangeQ("jobStatus", ConditionKey.CK_LESS_EQUAL, _value);
778         if (opLambda != null) {
779             opLambda.callback(builder);
780         }
781     }
782 
783     public void setJobStatus_Exists() {
784         setJobStatus_Exists(null);
785     }
786 
787     public void setJobStatus_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
788         ExistsQueryBuilder builder = regExistsQ("jobStatus");
789         if (opLambda != null) {
790             opLambda.callback(builder);
791         }
792     }
793 
794     @Deprecated
795     public void setJobStatus_CommonTerms(String jobStatus) {
796         setJobStatus_CommonTerms(jobStatus, null);
797     }
798 
799     @Deprecated
800     public void setJobStatus_CommonTerms(String jobStatus, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
801         CommonTermsQueryBuilder builder = regCommonTermsQ("jobStatus", jobStatus);
802         if (opLambda != null) {
803             opLambda.callback(builder);
804         }
805     }
806 
807     public BsJobLogCQ addOrderBy_JobStatus_Asc() {
808         regOBA("jobStatus");
809         return this;
810     }
811 
812     public BsJobLogCQ addOrderBy_JobStatus_Desc() {
813         regOBD("jobStatus");
814         return this;
815     }
816 
817     public void setLastUpdated_Equal(Long lastUpdated) {
818         setLastUpdated_Term(lastUpdated, null);
819     }
820 
821     public void setLastUpdated_Equal(Long lastUpdated, ConditionOptionCall<TermQueryBuilder> opLambda) {
822         setLastUpdated_Term(lastUpdated, opLambda);
823     }
824 
825     public void setLastUpdated_Term(Long lastUpdated) {
826         setLastUpdated_Term(lastUpdated, null);
827     }
828 
829     public void setLastUpdated_Term(Long lastUpdated, ConditionOptionCall<TermQueryBuilder> opLambda) {
830         TermQueryBuilder builder = regTermQ("lastUpdated", lastUpdated);
831         if (opLambda != null) {
832             opLambda.callback(builder);
833         }
834     }
835 
836     public void setLastUpdated_NotEqual(Long lastUpdated) {
837         setLastUpdated_NotTerm(lastUpdated, null);
838     }
839 
840     public void setLastUpdated_NotTerm(Long lastUpdated) {
841         setLastUpdated_NotTerm(lastUpdated, null);
842     }
843 
844     public void setLastUpdated_NotEqual(Long lastUpdated, ConditionOptionCall<BoolQueryBuilder> opLambda) {
845         setLastUpdated_NotTerm(lastUpdated, opLambda);
846     }
847 
848     public void setLastUpdated_NotTerm(Long lastUpdated, ConditionOptionCall<BoolQueryBuilder> opLambda) {
849         not(not -> not.setLastUpdated_Term(lastUpdated), opLambda);
850     }
851 
852     public void setLastUpdated_Terms(Collection<Long> lastUpdatedList) {
853         setLastUpdated_Terms(lastUpdatedList, null);
854     }
855 
856     public void setLastUpdated_Terms(Collection<Long> lastUpdatedList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
857         TermsQueryBuilder builder = regTermsQ("lastUpdated", lastUpdatedList);
858         if (opLambda != null) {
859             opLambda.callback(builder);
860         }
861     }
862 
863     public void setLastUpdated_InScope(Collection<Long> lastUpdatedList) {
864         setLastUpdated_Terms(lastUpdatedList, null);
865     }
866 
867     public void setLastUpdated_InScope(Collection<Long> lastUpdatedList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
868         setLastUpdated_Terms(lastUpdatedList, opLambda);
869     }
870 
871     public void setLastUpdated_Match(Long lastUpdated) {
872         setLastUpdated_Match(lastUpdated, null);
873     }
874 
875     public void setLastUpdated_Match(Long lastUpdated, ConditionOptionCall<MatchQueryBuilder> opLambda) {
876         MatchQueryBuilder builder = regMatchQ("lastUpdated", lastUpdated);
877         if (opLambda != null) {
878             opLambda.callback(builder);
879         }
880     }
881 
882     public void setLastUpdated_MatchPhrase(Long lastUpdated) {
883         setLastUpdated_MatchPhrase(lastUpdated, null);
884     }
885 
886     public void setLastUpdated_MatchPhrase(Long lastUpdated, ConditionOptionCall<MatchPhraseQueryBuilder> opLambda) {
887         MatchPhraseQueryBuilder builder = regMatchPhraseQ("lastUpdated", lastUpdated);
888         if (opLambda != null) {
889             opLambda.callback(builder);
890         }
891     }
892 
893     public void setLastUpdated_MatchPhrasePrefix(Long lastUpdated) {
894         setLastUpdated_MatchPhrasePrefix(lastUpdated, null);
895     }
896 
897     public void setLastUpdated_MatchPhrasePrefix(Long lastUpdated, ConditionOptionCall<MatchPhrasePrefixQueryBuilder> opLambda) {
898         MatchPhrasePrefixQueryBuilder builder = regMatchPhrasePrefixQ("lastUpdated", lastUpdated);
899         if (opLambda != null) {
900             opLambda.callback(builder);
901         }
902     }
903 
904     public void setLastUpdated_Fuzzy(Long lastUpdated) {
905         setLastUpdated_Fuzzy(lastUpdated, null);
906     }
907 
908     public void setLastUpdated_Fuzzy(Long lastUpdated, ConditionOptionCall<MatchQueryBuilder> opLambda) {
909         MatchQueryBuilder builder = regFuzzyQ("lastUpdated", lastUpdated);
910         if (opLambda != null) {
911             opLambda.callback(builder);
912         }
913     }
914 
915     public void setLastUpdated_GreaterThan(Long lastUpdated) {
916         setLastUpdated_GreaterThan(lastUpdated, null);
917     }
918 
919     public void setLastUpdated_GreaterThan(Long lastUpdated, ConditionOptionCall<RangeQueryBuilder> opLambda) {
920         final Object _value = lastUpdated;
921         RangeQueryBuilder builder = regRangeQ("lastUpdated", ConditionKey.CK_GREATER_THAN, _value);
922         if (opLambda != null) {
923             opLambda.callback(builder);
924         }
925     }
926 
927     public void setLastUpdated_LessThan(Long lastUpdated) {
928         setLastUpdated_LessThan(lastUpdated, null);
929     }
930 
931     public void setLastUpdated_LessThan(Long lastUpdated, ConditionOptionCall<RangeQueryBuilder> opLambda) {
932         final Object _value = lastUpdated;
933         RangeQueryBuilder builder = regRangeQ("lastUpdated", ConditionKey.CK_LESS_THAN, _value);
934         if (opLambda != null) {
935             opLambda.callback(builder);
936         }
937     }
938 
939     public void setLastUpdated_GreaterEqual(Long lastUpdated) {
940         setLastUpdated_GreaterEqual(lastUpdated, null);
941     }
942 
943     public void setLastUpdated_GreaterEqual(Long lastUpdated, ConditionOptionCall<RangeQueryBuilder> opLambda) {
944         final Object _value = lastUpdated;
945         RangeQueryBuilder builder = regRangeQ("lastUpdated", ConditionKey.CK_GREATER_EQUAL, _value);
946         if (opLambda != null) {
947             opLambda.callback(builder);
948         }
949     }
950 
951     public void setLastUpdated_LessEqual(Long lastUpdated) {
952         setLastUpdated_LessEqual(lastUpdated, null);
953     }
954 
955     public void setLastUpdated_LessEqual(Long lastUpdated, ConditionOptionCall<RangeQueryBuilder> opLambda) {
956         final Object _value = lastUpdated;
957         RangeQueryBuilder builder = regRangeQ("lastUpdated", ConditionKey.CK_LESS_EQUAL, _value);
958         if (opLambda != null) {
959             opLambda.callback(builder);
960         }
961     }
962 
963     public void setLastUpdated_Exists() {
964         setLastUpdated_Exists(null);
965     }
966 
967     public void setLastUpdated_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
968         ExistsQueryBuilder builder = regExistsQ("lastUpdated");
969         if (opLambda != null) {
970             opLambda.callback(builder);
971         }
972     }
973 
974     @Deprecated
975     public void setLastUpdated_CommonTerms(Long lastUpdated) {
976         setLastUpdated_CommonTerms(lastUpdated, null);
977     }
978 
979     @Deprecated
980     public void setLastUpdated_CommonTerms(Long lastUpdated, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
981         CommonTermsQueryBuilder builder = regCommonTermsQ("lastUpdated", lastUpdated);
982         if (opLambda != null) {
983             opLambda.callback(builder);
984         }
985     }
986 
987     public BsJobLogCQ addOrderBy_LastUpdated_Asc() {
988         regOBA("lastUpdated");
989         return this;
990     }
991 
992     public BsJobLogCQ addOrderBy_LastUpdated_Desc() {
993         regOBD("lastUpdated");
994         return this;
995     }
996 
997     public void setScriptData_Equal(String scriptData) {
998         setScriptData_Term(scriptData, null);
999     }
1000 
1001     public void setScriptData_Equal(String scriptData, ConditionOptionCall<TermQueryBuilder> opLambda) {
1002         setScriptData_Term(scriptData, opLambda);
1003     }
1004 
1005     public void setScriptData_Term(String scriptData) {
1006         setScriptData_Term(scriptData, null);
1007     }
1008 
1009     public void setScriptData_Term(String scriptData, ConditionOptionCall<TermQueryBuilder> opLambda) {
1010         TermQueryBuilder builder = regTermQ("scriptData", scriptData);
1011         if (opLambda != null) {
1012             opLambda.callback(builder);
1013         }
1014     }
1015 
1016     public void setScriptData_NotEqual(String scriptData) {
1017         setScriptData_NotTerm(scriptData, null);
1018     }
1019 
1020     public void setScriptData_NotTerm(String scriptData) {
1021         setScriptData_NotTerm(scriptData, null);
1022     }
1023 
1024     public void setScriptData_NotEqual(String scriptData, ConditionOptionCall<BoolQueryBuilder> opLambda) {
1025         setScriptData_NotTerm(scriptData, opLambda);
1026     }
1027 
1028     public void setScriptData_NotTerm(String scriptData, ConditionOptionCall<BoolQueryBuilder> opLambda) {
1029         not(not -> not.setScriptData_Term(scriptData), opLambda);
1030     }
1031 
1032     public void setScriptData_Terms(Collection<String> scriptDataList) {
1033         setScriptData_Terms(scriptDataList, null);
1034     }
1035 
1036     public void setScriptData_Terms(Collection<String> scriptDataList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
1037         TermsQueryBuilder builder = regTermsQ("scriptData", scriptDataList);
1038         if (opLambda != null) {
1039             opLambda.callback(builder);
1040         }
1041     }
1042 
1043     public void setScriptData_InScope(Collection<String> scriptDataList) {
1044         setScriptData_Terms(scriptDataList, null);
1045     }
1046 
1047     public void setScriptData_InScope(Collection<String> scriptDataList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
1048         setScriptData_Terms(scriptDataList, opLambda);
1049     }
1050 
1051     public void setScriptData_Match(String scriptData) {
1052         setScriptData_Match(scriptData, null);
1053     }
1054 
1055     public void setScriptData_Match(String scriptData, ConditionOptionCall<MatchQueryBuilder> opLambda) {
1056         MatchQueryBuilder builder = regMatchQ("scriptData", scriptData);
1057         if (opLambda != null) {
1058             opLambda.callback(builder);
1059         }
1060     }
1061 
1062     public void setScriptData_MatchPhrase(String scriptData) {
1063         setScriptData_MatchPhrase(scriptData, null);
1064     }
1065 
1066     public void setScriptData_MatchPhrase(String scriptData, ConditionOptionCall<MatchPhraseQueryBuilder> opLambda) {
1067         MatchPhraseQueryBuilder builder = regMatchPhraseQ("scriptData", scriptData);
1068         if (opLambda != null) {
1069             opLambda.callback(builder);
1070         }
1071     }
1072 
1073     public void setScriptData_MatchPhrasePrefix(String scriptData) {
1074         setScriptData_MatchPhrasePrefix(scriptData, null);
1075     }
1076 
1077     public void setScriptData_MatchPhrasePrefix(String scriptData, ConditionOptionCall<MatchPhrasePrefixQueryBuilder> opLambda) {
1078         MatchPhrasePrefixQueryBuilder builder = regMatchPhrasePrefixQ("scriptData", scriptData);
1079         if (opLambda != null) {
1080             opLambda.callback(builder);
1081         }
1082     }
1083 
1084     public void setScriptData_Fuzzy(String scriptData) {
1085         setScriptData_Fuzzy(scriptData, null);
1086     }
1087 
1088     public void setScriptData_Fuzzy(String scriptData, ConditionOptionCall<MatchQueryBuilder> opLambda) {
1089         MatchQueryBuilder builder = regFuzzyQ("scriptData", scriptData);
1090         if (opLambda != null) {
1091             opLambda.callback(builder);
1092         }
1093     }
1094 
1095     public void setScriptData_Prefix(String scriptData) {
1096         setScriptData_Prefix(scriptData, null);
1097     }
1098 
1099     public void setScriptData_Prefix(String scriptData, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
1100         PrefixQueryBuilder builder = regPrefixQ("scriptData", scriptData);
1101         if (opLambda != null) {
1102             opLambda.callback(builder);
1103         }
1104     }
1105 
1106     public void setScriptData_Wildcard(String scriptData) {
1107         setScriptData_Wildcard(scriptData, null);
1108     }
1109 
1110     public void setScriptData_Wildcard(String scriptData, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
1111         WildcardQueryBuilder builder = regWildcardQ("scriptData", scriptData);
1112         if (opLambda != null) {
1113             opLambda.callback(builder);
1114         }
1115     }
1116 
1117     public void setScriptData_Regexp(String scriptData) {
1118         setScriptData_Regexp(scriptData, null);
1119     }
1120 
1121     public void setScriptData_Regexp(String scriptData, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
1122         RegexpQueryBuilder builder = regRegexpQ("scriptData", scriptData);
1123         if (opLambda != null) {
1124             opLambda.callback(builder);
1125         }
1126     }
1127 
1128     public void setScriptData_SpanTerm(String scriptData) {
1129         setScriptData_SpanTerm("scriptData", null);
1130     }
1131 
1132     public void setScriptData_SpanTerm(String scriptData, ConditionOptionCall<SpanTermQueryBuilder> opLambda) {
1133         SpanTermQueryBuilder builder = regSpanTermQ("scriptData", scriptData);
1134         if (opLambda != null) {
1135             opLambda.callback(builder);
1136         }
1137     }
1138 
1139     public void setScriptData_GreaterThan(String scriptData) {
1140         setScriptData_GreaterThan(scriptData, null);
1141     }
1142 
1143     public void setScriptData_GreaterThan(String scriptData, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1144         final Object _value = scriptData;
1145         RangeQueryBuilder builder = regRangeQ("scriptData", ConditionKey.CK_GREATER_THAN, _value);
1146         if (opLambda != null) {
1147             opLambda.callback(builder);
1148         }
1149     }
1150 
1151     public void setScriptData_LessThan(String scriptData) {
1152         setScriptData_LessThan(scriptData, null);
1153     }
1154 
1155     public void setScriptData_LessThan(String scriptData, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1156         final Object _value = scriptData;
1157         RangeQueryBuilder builder = regRangeQ("scriptData", ConditionKey.CK_LESS_THAN, _value);
1158         if (opLambda != null) {
1159             opLambda.callback(builder);
1160         }
1161     }
1162 
1163     public void setScriptData_GreaterEqual(String scriptData) {
1164         setScriptData_GreaterEqual(scriptData, null);
1165     }
1166 
1167     public void setScriptData_GreaterEqual(String scriptData, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1168         final Object _value = scriptData;
1169         RangeQueryBuilder builder = regRangeQ("scriptData", ConditionKey.CK_GREATER_EQUAL, _value);
1170         if (opLambda != null) {
1171             opLambda.callback(builder);
1172         }
1173     }
1174 
1175     public void setScriptData_LessEqual(String scriptData) {
1176         setScriptData_LessEqual(scriptData, null);
1177     }
1178 
1179     public void setScriptData_LessEqual(String scriptData, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1180         final Object _value = scriptData;
1181         RangeQueryBuilder builder = regRangeQ("scriptData", ConditionKey.CK_LESS_EQUAL, _value);
1182         if (opLambda != null) {
1183             opLambda.callback(builder);
1184         }
1185     }
1186 
1187     public void setScriptData_Exists() {
1188         setScriptData_Exists(null);
1189     }
1190 
1191     public void setScriptData_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
1192         ExistsQueryBuilder builder = regExistsQ("scriptData");
1193         if (opLambda != null) {
1194             opLambda.callback(builder);
1195         }
1196     }
1197 
1198     @Deprecated
1199     public void setScriptData_CommonTerms(String scriptData) {
1200         setScriptData_CommonTerms(scriptData, null);
1201     }
1202 
1203     @Deprecated
1204     public void setScriptData_CommonTerms(String scriptData, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
1205         CommonTermsQueryBuilder builder = regCommonTermsQ("scriptData", scriptData);
1206         if (opLambda != null) {
1207             opLambda.callback(builder);
1208         }
1209     }
1210 
1211     public BsJobLogCQ addOrderBy_ScriptData_Asc() {
1212         regOBA("scriptData");
1213         return this;
1214     }
1215 
1216     public BsJobLogCQ addOrderBy_ScriptData_Desc() {
1217         regOBD("scriptData");
1218         return this;
1219     }
1220 
1221     public void setScriptResult_Equal(String scriptResult) {
1222         setScriptResult_Term(scriptResult, null);
1223     }
1224 
1225     public void setScriptResult_Equal(String scriptResult, ConditionOptionCall<TermQueryBuilder> opLambda) {
1226         setScriptResult_Term(scriptResult, opLambda);
1227     }
1228 
1229     public void setScriptResult_Term(String scriptResult) {
1230         setScriptResult_Term(scriptResult, null);
1231     }
1232 
1233     public void setScriptResult_Term(String scriptResult, ConditionOptionCall<TermQueryBuilder> opLambda) {
1234         TermQueryBuilder builder = regTermQ("scriptResult", scriptResult);
1235         if (opLambda != null) {
1236             opLambda.callback(builder);
1237         }
1238     }
1239 
1240     public void setScriptResult_NotEqual(String scriptResult) {
1241         setScriptResult_NotTerm(scriptResult, null);
1242     }
1243 
1244     public void setScriptResult_NotTerm(String scriptResult) {
1245         setScriptResult_NotTerm(scriptResult, null);
1246     }
1247 
1248     public void setScriptResult_NotEqual(String scriptResult, ConditionOptionCall<BoolQueryBuilder> opLambda) {
1249         setScriptResult_NotTerm(scriptResult, opLambda);
1250     }
1251 
1252     public void setScriptResult_NotTerm(String scriptResult, ConditionOptionCall<BoolQueryBuilder> opLambda) {
1253         not(not -> not.setScriptResult_Term(scriptResult), opLambda);
1254     }
1255 
1256     public void setScriptResult_Terms(Collection<String> scriptResultList) {
1257         setScriptResult_Terms(scriptResultList, null);
1258     }
1259 
1260     public void setScriptResult_Terms(Collection<String> scriptResultList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
1261         TermsQueryBuilder builder = regTermsQ("scriptResult", scriptResultList);
1262         if (opLambda != null) {
1263             opLambda.callback(builder);
1264         }
1265     }
1266 
1267     public void setScriptResult_InScope(Collection<String> scriptResultList) {
1268         setScriptResult_Terms(scriptResultList, null);
1269     }
1270 
1271     public void setScriptResult_InScope(Collection<String> scriptResultList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
1272         setScriptResult_Terms(scriptResultList, opLambda);
1273     }
1274 
1275     public void setScriptResult_Match(String scriptResult) {
1276         setScriptResult_Match(scriptResult, null);
1277     }
1278 
1279     public void setScriptResult_Match(String scriptResult, ConditionOptionCall<MatchQueryBuilder> opLambda) {
1280         MatchQueryBuilder builder = regMatchQ("scriptResult", scriptResult);
1281         if (opLambda != null) {
1282             opLambda.callback(builder);
1283         }
1284     }
1285 
1286     public void setScriptResult_MatchPhrase(String scriptResult) {
1287         setScriptResult_MatchPhrase(scriptResult, null);
1288     }
1289 
1290     public void setScriptResult_MatchPhrase(String scriptResult, ConditionOptionCall<MatchPhraseQueryBuilder> opLambda) {
1291         MatchPhraseQueryBuilder builder = regMatchPhraseQ("scriptResult", scriptResult);
1292         if (opLambda != null) {
1293             opLambda.callback(builder);
1294         }
1295     }
1296 
1297     public void setScriptResult_MatchPhrasePrefix(String scriptResult) {
1298         setScriptResult_MatchPhrasePrefix(scriptResult, null);
1299     }
1300 
1301     public void setScriptResult_MatchPhrasePrefix(String scriptResult, ConditionOptionCall<MatchPhrasePrefixQueryBuilder> opLambda) {
1302         MatchPhrasePrefixQueryBuilder builder = regMatchPhrasePrefixQ("scriptResult", scriptResult);
1303         if (opLambda != null) {
1304             opLambda.callback(builder);
1305         }
1306     }
1307 
1308     public void setScriptResult_Fuzzy(String scriptResult) {
1309         setScriptResult_Fuzzy(scriptResult, null);
1310     }
1311 
1312     public void setScriptResult_Fuzzy(String scriptResult, ConditionOptionCall<MatchQueryBuilder> opLambda) {
1313         MatchQueryBuilder builder = regFuzzyQ("scriptResult", scriptResult);
1314         if (opLambda != null) {
1315             opLambda.callback(builder);
1316         }
1317     }
1318 
1319     public void setScriptResult_Prefix(String scriptResult) {
1320         setScriptResult_Prefix(scriptResult, null);
1321     }
1322 
1323     public void setScriptResult_Prefix(String scriptResult, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
1324         PrefixQueryBuilder builder = regPrefixQ("scriptResult", scriptResult);
1325         if (opLambda != null) {
1326             opLambda.callback(builder);
1327         }
1328     }
1329 
1330     public void setScriptResult_Wildcard(String scriptResult) {
1331         setScriptResult_Wildcard(scriptResult, null);
1332     }
1333 
1334     public void setScriptResult_Wildcard(String scriptResult, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
1335         WildcardQueryBuilder builder = regWildcardQ("scriptResult", scriptResult);
1336         if (opLambda != null) {
1337             opLambda.callback(builder);
1338         }
1339     }
1340 
1341     public void setScriptResult_Regexp(String scriptResult) {
1342         setScriptResult_Regexp(scriptResult, null);
1343     }
1344 
1345     public void setScriptResult_Regexp(String scriptResult, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
1346         RegexpQueryBuilder builder = regRegexpQ("scriptResult", scriptResult);
1347         if (opLambda != null) {
1348             opLambda.callback(builder);
1349         }
1350     }
1351 
1352     public void setScriptResult_SpanTerm(String scriptResult) {
1353         setScriptResult_SpanTerm("scriptResult", null);
1354     }
1355 
1356     public void setScriptResult_SpanTerm(String scriptResult, ConditionOptionCall<SpanTermQueryBuilder> opLambda) {
1357         SpanTermQueryBuilder builder = regSpanTermQ("scriptResult", scriptResult);
1358         if (opLambda != null) {
1359             opLambda.callback(builder);
1360         }
1361     }
1362 
1363     public void setScriptResult_GreaterThan(String scriptResult) {
1364         setScriptResult_GreaterThan(scriptResult, null);
1365     }
1366 
1367     public void setScriptResult_GreaterThan(String scriptResult, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1368         final Object _value = scriptResult;
1369         RangeQueryBuilder builder = regRangeQ("scriptResult", ConditionKey.CK_GREATER_THAN, _value);
1370         if (opLambda != null) {
1371             opLambda.callback(builder);
1372         }
1373     }
1374 
1375     public void setScriptResult_LessThan(String scriptResult) {
1376         setScriptResult_LessThan(scriptResult, null);
1377     }
1378 
1379     public void setScriptResult_LessThan(String scriptResult, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1380         final Object _value = scriptResult;
1381         RangeQueryBuilder builder = regRangeQ("scriptResult", ConditionKey.CK_LESS_THAN, _value);
1382         if (opLambda != null) {
1383             opLambda.callback(builder);
1384         }
1385     }
1386 
1387     public void setScriptResult_GreaterEqual(String scriptResult) {
1388         setScriptResult_GreaterEqual(scriptResult, null);
1389     }
1390 
1391     public void setScriptResult_GreaterEqual(String scriptResult, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1392         final Object _value = scriptResult;
1393         RangeQueryBuilder builder = regRangeQ("scriptResult", ConditionKey.CK_GREATER_EQUAL, _value);
1394         if (opLambda != null) {
1395             opLambda.callback(builder);
1396         }
1397     }
1398 
1399     public void setScriptResult_LessEqual(String scriptResult) {
1400         setScriptResult_LessEqual(scriptResult, null);
1401     }
1402 
1403     public void setScriptResult_LessEqual(String scriptResult, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1404         final Object _value = scriptResult;
1405         RangeQueryBuilder builder = regRangeQ("scriptResult", ConditionKey.CK_LESS_EQUAL, _value);
1406         if (opLambda != null) {
1407             opLambda.callback(builder);
1408         }
1409     }
1410 
1411     public void setScriptResult_Exists() {
1412         setScriptResult_Exists(null);
1413     }
1414 
1415     public void setScriptResult_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
1416         ExistsQueryBuilder builder = regExistsQ("scriptResult");
1417         if (opLambda != null) {
1418             opLambda.callback(builder);
1419         }
1420     }
1421 
1422     @Deprecated
1423     public void setScriptResult_CommonTerms(String scriptResult) {
1424         setScriptResult_CommonTerms(scriptResult, null);
1425     }
1426 
1427     @Deprecated
1428     public void setScriptResult_CommonTerms(String scriptResult, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
1429         CommonTermsQueryBuilder builder = regCommonTermsQ("scriptResult", scriptResult);
1430         if (opLambda != null) {
1431             opLambda.callback(builder);
1432         }
1433     }
1434 
1435     public BsJobLogCQ addOrderBy_ScriptResult_Asc() {
1436         regOBA("scriptResult");
1437         return this;
1438     }
1439 
1440     public BsJobLogCQ addOrderBy_ScriptResult_Desc() {
1441         regOBD("scriptResult");
1442         return this;
1443     }
1444 
1445     public void setScriptType_Equal(String scriptType) {
1446         setScriptType_Term(scriptType, null);
1447     }
1448 
1449     public void setScriptType_Equal(String scriptType, ConditionOptionCall<TermQueryBuilder> opLambda) {
1450         setScriptType_Term(scriptType, opLambda);
1451     }
1452 
1453     public void setScriptType_Term(String scriptType) {
1454         setScriptType_Term(scriptType, null);
1455     }
1456 
1457     public void setScriptType_Term(String scriptType, ConditionOptionCall<TermQueryBuilder> opLambda) {
1458         TermQueryBuilder builder = regTermQ("scriptType", scriptType);
1459         if (opLambda != null) {
1460             opLambda.callback(builder);
1461         }
1462     }
1463 
1464     public void setScriptType_NotEqual(String scriptType) {
1465         setScriptType_NotTerm(scriptType, null);
1466     }
1467 
1468     public void setScriptType_NotTerm(String scriptType) {
1469         setScriptType_NotTerm(scriptType, null);
1470     }
1471 
1472     public void setScriptType_NotEqual(String scriptType, ConditionOptionCall<BoolQueryBuilder> opLambda) {
1473         setScriptType_NotTerm(scriptType, opLambda);
1474     }
1475 
1476     public void setScriptType_NotTerm(String scriptType, ConditionOptionCall<BoolQueryBuilder> opLambda) {
1477         not(not -> not.setScriptType_Term(scriptType), opLambda);
1478     }
1479 
1480     public void setScriptType_Terms(Collection<String> scriptTypeList) {
1481         setScriptType_Terms(scriptTypeList, null);
1482     }
1483 
1484     public void setScriptType_Terms(Collection<String> scriptTypeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
1485         TermsQueryBuilder builder = regTermsQ("scriptType", scriptTypeList);
1486         if (opLambda != null) {
1487             opLambda.callback(builder);
1488         }
1489     }
1490 
1491     public void setScriptType_InScope(Collection<String> scriptTypeList) {
1492         setScriptType_Terms(scriptTypeList, null);
1493     }
1494 
1495     public void setScriptType_InScope(Collection<String> scriptTypeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
1496         setScriptType_Terms(scriptTypeList, opLambda);
1497     }
1498 
1499     public void setScriptType_Match(String scriptType) {
1500         setScriptType_Match(scriptType, null);
1501     }
1502 
1503     public void setScriptType_Match(String scriptType, ConditionOptionCall<MatchQueryBuilder> opLambda) {
1504         MatchQueryBuilder builder = regMatchQ("scriptType", scriptType);
1505         if (opLambda != null) {
1506             opLambda.callback(builder);
1507         }
1508     }
1509 
1510     public void setScriptType_MatchPhrase(String scriptType) {
1511         setScriptType_MatchPhrase(scriptType, null);
1512     }
1513 
1514     public void setScriptType_MatchPhrase(String scriptType, ConditionOptionCall<MatchPhraseQueryBuilder> opLambda) {
1515         MatchPhraseQueryBuilder builder = regMatchPhraseQ("scriptType", scriptType);
1516         if (opLambda != null) {
1517             opLambda.callback(builder);
1518         }
1519     }
1520 
1521     public void setScriptType_MatchPhrasePrefix(String scriptType) {
1522         setScriptType_MatchPhrasePrefix(scriptType, null);
1523     }
1524 
1525     public void setScriptType_MatchPhrasePrefix(String scriptType, ConditionOptionCall<MatchPhrasePrefixQueryBuilder> opLambda) {
1526         MatchPhrasePrefixQueryBuilder builder = regMatchPhrasePrefixQ("scriptType", scriptType);
1527         if (opLambda != null) {
1528             opLambda.callback(builder);
1529         }
1530     }
1531 
1532     public void setScriptType_Fuzzy(String scriptType) {
1533         setScriptType_Fuzzy(scriptType, null);
1534     }
1535 
1536     public void setScriptType_Fuzzy(String scriptType, ConditionOptionCall<MatchQueryBuilder> opLambda) {
1537         MatchQueryBuilder builder = regFuzzyQ("scriptType", scriptType);
1538         if (opLambda != null) {
1539             opLambda.callback(builder);
1540         }
1541     }
1542 
1543     public void setScriptType_Prefix(String scriptType) {
1544         setScriptType_Prefix(scriptType, null);
1545     }
1546 
1547     public void setScriptType_Prefix(String scriptType, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
1548         PrefixQueryBuilder builder = regPrefixQ("scriptType", scriptType);
1549         if (opLambda != null) {
1550             opLambda.callback(builder);
1551         }
1552     }
1553 
1554     public void setScriptType_Wildcard(String scriptType) {
1555         setScriptType_Wildcard(scriptType, null);
1556     }
1557 
1558     public void setScriptType_Wildcard(String scriptType, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
1559         WildcardQueryBuilder builder = regWildcardQ("scriptType", scriptType);
1560         if (opLambda != null) {
1561             opLambda.callback(builder);
1562         }
1563     }
1564 
1565     public void setScriptType_Regexp(String scriptType) {
1566         setScriptType_Regexp(scriptType, null);
1567     }
1568 
1569     public void setScriptType_Regexp(String scriptType, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
1570         RegexpQueryBuilder builder = regRegexpQ("scriptType", scriptType);
1571         if (opLambda != null) {
1572             opLambda.callback(builder);
1573         }
1574     }
1575 
1576     public void setScriptType_SpanTerm(String scriptType) {
1577         setScriptType_SpanTerm("scriptType", null);
1578     }
1579 
1580     public void setScriptType_SpanTerm(String scriptType, ConditionOptionCall<SpanTermQueryBuilder> opLambda) {
1581         SpanTermQueryBuilder builder = regSpanTermQ("scriptType", scriptType);
1582         if (opLambda != null) {
1583             opLambda.callback(builder);
1584         }
1585     }
1586 
1587     public void setScriptType_GreaterThan(String scriptType) {
1588         setScriptType_GreaterThan(scriptType, null);
1589     }
1590 
1591     public void setScriptType_GreaterThan(String scriptType, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1592         final Object _value = scriptType;
1593         RangeQueryBuilder builder = regRangeQ("scriptType", ConditionKey.CK_GREATER_THAN, _value);
1594         if (opLambda != null) {
1595             opLambda.callback(builder);
1596         }
1597     }
1598 
1599     public void setScriptType_LessThan(String scriptType) {
1600         setScriptType_LessThan(scriptType, null);
1601     }
1602 
1603     public void setScriptType_LessThan(String scriptType, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1604         final Object _value = scriptType;
1605         RangeQueryBuilder builder = regRangeQ("scriptType", ConditionKey.CK_LESS_THAN, _value);
1606         if (opLambda != null) {
1607             opLambda.callback(builder);
1608         }
1609     }
1610 
1611     public void setScriptType_GreaterEqual(String scriptType) {
1612         setScriptType_GreaterEqual(scriptType, null);
1613     }
1614 
1615     public void setScriptType_GreaterEqual(String scriptType, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1616         final Object _value = scriptType;
1617         RangeQueryBuilder builder = regRangeQ("scriptType", ConditionKey.CK_GREATER_EQUAL, _value);
1618         if (opLambda != null) {
1619             opLambda.callback(builder);
1620         }
1621     }
1622 
1623     public void setScriptType_LessEqual(String scriptType) {
1624         setScriptType_LessEqual(scriptType, null);
1625     }
1626 
1627     public void setScriptType_LessEqual(String scriptType, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1628         final Object _value = scriptType;
1629         RangeQueryBuilder builder = regRangeQ("scriptType", ConditionKey.CK_LESS_EQUAL, _value);
1630         if (opLambda != null) {
1631             opLambda.callback(builder);
1632         }
1633     }
1634 
1635     public void setScriptType_Exists() {
1636         setScriptType_Exists(null);
1637     }
1638 
1639     public void setScriptType_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
1640         ExistsQueryBuilder builder = regExistsQ("scriptType");
1641         if (opLambda != null) {
1642             opLambda.callback(builder);
1643         }
1644     }
1645 
1646     @Deprecated
1647     public void setScriptType_CommonTerms(String scriptType) {
1648         setScriptType_CommonTerms(scriptType, null);
1649     }
1650 
1651     @Deprecated
1652     public void setScriptType_CommonTerms(String scriptType, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
1653         CommonTermsQueryBuilder builder = regCommonTermsQ("scriptType", scriptType);
1654         if (opLambda != null) {
1655             opLambda.callback(builder);
1656         }
1657     }
1658 
1659     public BsJobLogCQ addOrderBy_ScriptType_Asc() {
1660         regOBA("scriptType");
1661         return this;
1662     }
1663 
1664     public BsJobLogCQ addOrderBy_ScriptType_Desc() {
1665         regOBD("scriptType");
1666         return this;
1667     }
1668 
1669     public void setStartTime_Equal(Long startTime) {
1670         setStartTime_Term(startTime, null);
1671     }
1672 
1673     public void setStartTime_Equal(Long startTime, ConditionOptionCall<TermQueryBuilder> opLambda) {
1674         setStartTime_Term(startTime, opLambda);
1675     }
1676 
1677     public void setStartTime_Term(Long startTime) {
1678         setStartTime_Term(startTime, null);
1679     }
1680 
1681     public void setStartTime_Term(Long startTime, ConditionOptionCall<TermQueryBuilder> opLambda) {
1682         TermQueryBuilder builder = regTermQ("startTime", startTime);
1683         if (opLambda != null) {
1684             opLambda.callback(builder);
1685         }
1686     }
1687 
1688     public void setStartTime_NotEqual(Long startTime) {
1689         setStartTime_NotTerm(startTime, null);
1690     }
1691 
1692     public void setStartTime_NotTerm(Long startTime) {
1693         setStartTime_NotTerm(startTime, null);
1694     }
1695 
1696     public void setStartTime_NotEqual(Long startTime, ConditionOptionCall<BoolQueryBuilder> opLambda) {
1697         setStartTime_NotTerm(startTime, opLambda);
1698     }
1699 
1700     public void setStartTime_NotTerm(Long startTime, ConditionOptionCall<BoolQueryBuilder> opLambda) {
1701         not(not -> not.setStartTime_Term(startTime), opLambda);
1702     }
1703 
1704     public void setStartTime_Terms(Collection<Long> startTimeList) {
1705         setStartTime_Terms(startTimeList, null);
1706     }
1707 
1708     public void setStartTime_Terms(Collection<Long> startTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
1709         TermsQueryBuilder builder = regTermsQ("startTime", startTimeList);
1710         if (opLambda != null) {
1711             opLambda.callback(builder);
1712         }
1713     }
1714 
1715     public void setStartTime_InScope(Collection<Long> startTimeList) {
1716         setStartTime_Terms(startTimeList, null);
1717     }
1718 
1719     public void setStartTime_InScope(Collection<Long> startTimeList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
1720         setStartTime_Terms(startTimeList, opLambda);
1721     }
1722 
1723     public void setStartTime_Match(Long startTime) {
1724         setStartTime_Match(startTime, null);
1725     }
1726 
1727     public void setStartTime_Match(Long startTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
1728         MatchQueryBuilder builder = regMatchQ("startTime", startTime);
1729         if (opLambda != null) {
1730             opLambda.callback(builder);
1731         }
1732     }
1733 
1734     public void setStartTime_MatchPhrase(Long startTime) {
1735         setStartTime_MatchPhrase(startTime, null);
1736     }
1737 
1738     public void setStartTime_MatchPhrase(Long startTime, ConditionOptionCall<MatchPhraseQueryBuilder> opLambda) {
1739         MatchPhraseQueryBuilder builder = regMatchPhraseQ("startTime", startTime);
1740         if (opLambda != null) {
1741             opLambda.callback(builder);
1742         }
1743     }
1744 
1745     public void setStartTime_MatchPhrasePrefix(Long startTime) {
1746         setStartTime_MatchPhrasePrefix(startTime, null);
1747     }
1748 
1749     public void setStartTime_MatchPhrasePrefix(Long startTime, ConditionOptionCall<MatchPhrasePrefixQueryBuilder> opLambda) {
1750         MatchPhrasePrefixQueryBuilder builder = regMatchPhrasePrefixQ("startTime", startTime);
1751         if (opLambda != null) {
1752             opLambda.callback(builder);
1753         }
1754     }
1755 
1756     public void setStartTime_Fuzzy(Long startTime) {
1757         setStartTime_Fuzzy(startTime, null);
1758     }
1759 
1760     public void setStartTime_Fuzzy(Long startTime, ConditionOptionCall<MatchQueryBuilder> opLambda) {
1761         MatchQueryBuilder builder = regFuzzyQ("startTime", startTime);
1762         if (opLambda != null) {
1763             opLambda.callback(builder);
1764         }
1765     }
1766 
1767     public void setStartTime_GreaterThan(Long startTime) {
1768         setStartTime_GreaterThan(startTime, null);
1769     }
1770 
1771     public void setStartTime_GreaterThan(Long startTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1772         final Object _value = startTime;
1773         RangeQueryBuilder builder = regRangeQ("startTime", ConditionKey.CK_GREATER_THAN, _value);
1774         if (opLambda != null) {
1775             opLambda.callback(builder);
1776         }
1777     }
1778 
1779     public void setStartTime_LessThan(Long startTime) {
1780         setStartTime_LessThan(startTime, null);
1781     }
1782 
1783     public void setStartTime_LessThan(Long startTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1784         final Object _value = startTime;
1785         RangeQueryBuilder builder = regRangeQ("startTime", ConditionKey.CK_LESS_THAN, _value);
1786         if (opLambda != null) {
1787             opLambda.callback(builder);
1788         }
1789     }
1790 
1791     public void setStartTime_GreaterEqual(Long startTime) {
1792         setStartTime_GreaterEqual(startTime, null);
1793     }
1794 
1795     public void setStartTime_GreaterEqual(Long startTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1796         final Object _value = startTime;
1797         RangeQueryBuilder builder = regRangeQ("startTime", ConditionKey.CK_GREATER_EQUAL, _value);
1798         if (opLambda != null) {
1799             opLambda.callback(builder);
1800         }
1801     }
1802 
1803     public void setStartTime_LessEqual(Long startTime) {
1804         setStartTime_LessEqual(startTime, null);
1805     }
1806 
1807     public void setStartTime_LessEqual(Long startTime, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1808         final Object _value = startTime;
1809         RangeQueryBuilder builder = regRangeQ("startTime", ConditionKey.CK_LESS_EQUAL, _value);
1810         if (opLambda != null) {
1811             opLambda.callback(builder);
1812         }
1813     }
1814 
1815     public void setStartTime_Exists() {
1816         setStartTime_Exists(null);
1817     }
1818 
1819     public void setStartTime_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
1820         ExistsQueryBuilder builder = regExistsQ("startTime");
1821         if (opLambda != null) {
1822             opLambda.callback(builder);
1823         }
1824     }
1825 
1826     @Deprecated
1827     public void setStartTime_CommonTerms(Long startTime) {
1828         setStartTime_CommonTerms(startTime, null);
1829     }
1830 
1831     @Deprecated
1832     public void setStartTime_CommonTerms(Long startTime, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
1833         CommonTermsQueryBuilder builder = regCommonTermsQ("startTime", startTime);
1834         if (opLambda != null) {
1835             opLambda.callback(builder);
1836         }
1837     }
1838 
1839     public BsJobLogCQ addOrderBy_StartTime_Asc() {
1840         regOBA("startTime");
1841         return this;
1842     }
1843 
1844     public BsJobLogCQ addOrderBy_StartTime_Desc() {
1845         regOBD("startTime");
1846         return this;
1847     }
1848 
1849     public void setTarget_Equal(String target) {
1850         setTarget_Term(target, null);
1851     }
1852 
1853     public void setTarget_Equal(String target, ConditionOptionCall<TermQueryBuilder> opLambda) {
1854         setTarget_Term(target, opLambda);
1855     }
1856 
1857     public void setTarget_Term(String target) {
1858         setTarget_Term(target, null);
1859     }
1860 
1861     public void setTarget_Term(String target, ConditionOptionCall<TermQueryBuilder> opLambda) {
1862         TermQueryBuilder builder = regTermQ("target", target);
1863         if (opLambda != null) {
1864             opLambda.callback(builder);
1865         }
1866     }
1867 
1868     public void setTarget_NotEqual(String target) {
1869         setTarget_NotTerm(target, null);
1870     }
1871 
1872     public void setTarget_NotTerm(String target) {
1873         setTarget_NotTerm(target, null);
1874     }
1875 
1876     public void setTarget_NotEqual(String target, ConditionOptionCall<BoolQueryBuilder> opLambda) {
1877         setTarget_NotTerm(target, opLambda);
1878     }
1879 
1880     public void setTarget_NotTerm(String target, ConditionOptionCall<BoolQueryBuilder> opLambda) {
1881         not(not -> not.setTarget_Term(target), opLambda);
1882     }
1883 
1884     public void setTarget_Terms(Collection<String> targetList) {
1885         setTarget_Terms(targetList, null);
1886     }
1887 
1888     public void setTarget_Terms(Collection<String> targetList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
1889         TermsQueryBuilder builder = regTermsQ("target", targetList);
1890         if (opLambda != null) {
1891             opLambda.callback(builder);
1892         }
1893     }
1894 
1895     public void setTarget_InScope(Collection<String> targetList) {
1896         setTarget_Terms(targetList, null);
1897     }
1898 
1899     public void setTarget_InScope(Collection<String> targetList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
1900         setTarget_Terms(targetList, opLambda);
1901     }
1902 
1903     public void setTarget_Match(String target) {
1904         setTarget_Match(target, null);
1905     }
1906 
1907     public void setTarget_Match(String target, ConditionOptionCall<MatchQueryBuilder> opLambda) {
1908         MatchQueryBuilder builder = regMatchQ("target", target);
1909         if (opLambda != null) {
1910             opLambda.callback(builder);
1911         }
1912     }
1913 
1914     public void setTarget_MatchPhrase(String target) {
1915         setTarget_MatchPhrase(target, null);
1916     }
1917 
1918     public void setTarget_MatchPhrase(String target, ConditionOptionCall<MatchPhraseQueryBuilder> opLambda) {
1919         MatchPhraseQueryBuilder builder = regMatchPhraseQ("target", target);
1920         if (opLambda != null) {
1921             opLambda.callback(builder);
1922         }
1923     }
1924 
1925     public void setTarget_MatchPhrasePrefix(String target) {
1926         setTarget_MatchPhrasePrefix(target, null);
1927     }
1928 
1929     public void setTarget_MatchPhrasePrefix(String target, ConditionOptionCall<MatchPhrasePrefixQueryBuilder> opLambda) {
1930         MatchPhrasePrefixQueryBuilder builder = regMatchPhrasePrefixQ("target", target);
1931         if (opLambda != null) {
1932             opLambda.callback(builder);
1933         }
1934     }
1935 
1936     public void setTarget_Fuzzy(String target) {
1937         setTarget_Fuzzy(target, null);
1938     }
1939 
1940     public void setTarget_Fuzzy(String target, ConditionOptionCall<MatchQueryBuilder> opLambda) {
1941         MatchQueryBuilder builder = regFuzzyQ("target", target);
1942         if (opLambda != null) {
1943             opLambda.callback(builder);
1944         }
1945     }
1946 
1947     public void setTarget_Prefix(String target) {
1948         setTarget_Prefix(target, null);
1949     }
1950 
1951     public void setTarget_Prefix(String target, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
1952         PrefixQueryBuilder builder = regPrefixQ("target", target);
1953         if (opLambda != null) {
1954             opLambda.callback(builder);
1955         }
1956     }
1957 
1958     public void setTarget_Wildcard(String target) {
1959         setTarget_Wildcard(target, null);
1960     }
1961 
1962     public void setTarget_Wildcard(String target, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
1963         WildcardQueryBuilder builder = regWildcardQ("target", target);
1964         if (opLambda != null) {
1965             opLambda.callback(builder);
1966         }
1967     }
1968 
1969     public void setTarget_Regexp(String target) {
1970         setTarget_Regexp(target, null);
1971     }
1972 
1973     public void setTarget_Regexp(String target, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
1974         RegexpQueryBuilder builder = regRegexpQ("target", target);
1975         if (opLambda != null) {
1976             opLambda.callback(builder);
1977         }
1978     }
1979 
1980     public void setTarget_SpanTerm(String target) {
1981         setTarget_SpanTerm("target", null);
1982     }
1983 
1984     public void setTarget_SpanTerm(String target, ConditionOptionCall<SpanTermQueryBuilder> opLambda) {
1985         SpanTermQueryBuilder builder = regSpanTermQ("target", target);
1986         if (opLambda != null) {
1987             opLambda.callback(builder);
1988         }
1989     }
1990 
1991     public void setTarget_GreaterThan(String target) {
1992         setTarget_GreaterThan(target, null);
1993     }
1994 
1995     public void setTarget_GreaterThan(String target, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1996         final Object _value = target;
1997         RangeQueryBuilder builder = regRangeQ("target", ConditionKey.CK_GREATER_THAN, _value);
1998         if (opLambda != null) {
1999             opLambda.callback(builder);
2000         }
2001     }
2002 
2003     public void setTarget_LessThan(String target) {
2004         setTarget_LessThan(target, null);
2005     }
2006 
2007     public void setTarget_LessThan(String target, ConditionOptionCall<RangeQueryBuilder> opLambda) {
2008         final Object _value = target;
2009         RangeQueryBuilder builder = regRangeQ("target", ConditionKey.CK_LESS_THAN, _value);
2010         if (opLambda != null) {
2011             opLambda.callback(builder);
2012         }
2013     }
2014 
2015     public void setTarget_GreaterEqual(String target) {
2016         setTarget_GreaterEqual(target, null);
2017     }
2018 
2019     public void setTarget_GreaterEqual(String target, ConditionOptionCall<RangeQueryBuilder> opLambda) {
2020         final Object _value = target;
2021         RangeQueryBuilder builder = regRangeQ("target", ConditionKey.CK_GREATER_EQUAL, _value);
2022         if (opLambda != null) {
2023             opLambda.callback(builder);
2024         }
2025     }
2026 
2027     public void setTarget_LessEqual(String target) {
2028         setTarget_LessEqual(target, null);
2029     }
2030 
2031     public void setTarget_LessEqual(String target, ConditionOptionCall<RangeQueryBuilder> opLambda) {
2032         final Object _value = target;
2033         RangeQueryBuilder builder = regRangeQ("target", ConditionKey.CK_LESS_EQUAL, _value);
2034         if (opLambda != null) {
2035             opLambda.callback(builder);
2036         }
2037     }
2038 
2039     public void setTarget_Exists() {
2040         setTarget_Exists(null);
2041     }
2042 
2043     public void setTarget_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
2044         ExistsQueryBuilder builder = regExistsQ("target");
2045         if (opLambda != null) {
2046             opLambda.callback(builder);
2047         }
2048     }
2049 
2050     @Deprecated
2051     public void setTarget_CommonTerms(String target) {
2052         setTarget_CommonTerms(target, null);
2053     }
2054 
2055     @Deprecated
2056     public void setTarget_CommonTerms(String target, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
2057         CommonTermsQueryBuilder builder = regCommonTermsQ("target", target);
2058         if (opLambda != null) {
2059             opLambda.callback(builder);
2060         }
2061     }
2062 
2063     public BsJobLogCQ addOrderBy_Target_Asc() {
2064         regOBA("target");
2065         return this;
2066     }
2067 
2068     public BsJobLogCQ addOrderBy_Target_Desc() {
2069         regOBD("target");
2070         return this;
2071     }
2072 
2073 }