This is a cache of https://fess.codelibs.org/xref/org/codelibs/fess/es/config/cbean/cq/bs/BsElevateWordToLabelCQ.html. It is a snapshot of the page at 2020-10-25T01:19:46.351+0000.
BsElevateWordToLabelCQ xref
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.ElevateWordToLabelCQ;
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 BsElevateWordToLabelCQ extends EsAbstractConditionQuery {
46  
47      protected static final Class<?&gt; suppressUnusedImportLocalDateTime = LocalDateTime.class;
48  
49      // ===================================================================================
50      //                                                                       Name Override
51      //                                                                       =============
52      @Override
53      public String asTableDbName() {
54          return "elevate_word_to_label";
55      }
56  
57      @Override
58      public String xgetAliasName() {
59          return "elevate_word_to_label";
60      }
61  
62      // ===================================================================================
63      //                                                                       Query Control
64      //                                                                       =============
65      public void functionScore(OperatorCall<ElevateWordToLabelCQ&gt; queryLambda,
66              ScoreFunctionCall<ScoreFunctionCreator<ElevateWordToLabelCQ&gt;&gt; functionsLambda,
67              final ConditionOptionCall<FunctionScoreQueryBuilder&gt; opLambda) {
68          ElevateWordToLabelCQg/cbean/cq/ElevateWordToLabelCQ.html#ElevateWordToLabelCQ">ElevateWordToLabelCQ cq = new ElevateWordToLabelCQ();
69          queryLambda.callback(cq);
70          final Collection<FilterFunctionBuilder&gt; list = new ArrayList<&gt;();
71          if (functionsLambda != null) {
72              functionsLambda.callback((cqLambda, scoreFunctionBuilder) -&gt; {
73                  ElevateWordToLabelCQg/cbean/cq/ElevateWordToLabelCQ.html#ElevateWordToLabelCQ">ElevateWordToLabelCQ cf = new ElevateWordToLabelCQ();
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<ElevateWordToLabelCQ, ElevateWordToLabelCQ&gt; filteredLambda) {
85          filtered(filteredLambda, null);
86      }
87  
88      public void filtered(FilteredCall<ElevateWordToLabelCQ, ElevateWordToLabelCQ&gt; filteredLambda,
89              ConditionOptionCall<BoolQueryBuilder&gt; opLambda) {
90          bool((must, should, mustNot, filter) -&gt; {
91              filteredLambda.callback(must, filter);
92          }, opLambda);
93      }
94  
95      public void not(OperatorCall<ElevateWordToLabelCQ&gt; notLambda) {
96          not(notLambda, null);
97      }
98  
99      public void not(final OperatorCall<ElevateWordToLabelCQ&gt; notLambda, final ConditionOptionCall<BoolQueryBuilder&gt; opLambda) {
100         bool((must, should, mustNot, filter) -&gt; notLambda.callback(mustNot), opLambda);
101     }
102 
103     public void bool(BoolCall<ElevateWordToLabelCQ&gt; boolLambda) {
104         bool(boolLambda, null);
105     }
106 
107     public void bool(BoolCall<ElevateWordToLabelCQ&gt; boolLambda, ConditionOptionCall<BoolQueryBuilder&gt; opLambda) {
108         ElevateWordToLabelCQ/cq/ElevateWordToLabelCQ.html#ElevateWordToLabelCQ">ElevateWordToLabelCQ mustQuery = new ElevateWordToLabelCQ();
109         ElevateWordToLabelCQq/ElevateWordToLabelCQ.html#ElevateWordToLabelCQ">ElevateWordToLabelCQ shouldQuery = new ElevateWordToLabelCQ();
110         ElevateWordToLabelCQ/ElevateWordToLabelCQ.html#ElevateWordToLabelCQ">ElevateWordToLabelCQ mustNotQuery = new ElevateWordToLabelCQ();
111         ElevateWordToLabelCQq/ElevateWordToLabelCQ.html#ElevateWordToLabelCQ">ElevateWordToLabelCQ filterQuery = new ElevateWordToLabelCQ();
112         boolLambda.callback(mustQuery, shouldQuery, mustNotQuery, filterQuery);
113         if (mustQuery.hasQueries() || shouldQuery.hasQueries() || mustNotQuery.hasQueries() || filterQuery.hasQueries()) {
114             BoolQueryBuilder builder =
115                     regBoolCQ(mustQuery.getQueryBuilderList(), shouldQuery.getQueryBuilderList(), mustNotQuery.getQueryBuilderList(),
116                             filterQuery.getQueryBuilderList());
117             if (opLambda != null) {
118                 opLambda.callback(builder);
119             }
120         }
121     }
122 
123     // ===================================================================================
124     //                                                                           Query Set
125     //                                                                           =========
126     public void setId_Equal(String id) {
127         setId_Term(id, null);
128     }
129 
130     public void setId_Equal(String id, ConditionOptionCall<TermQueryBuilder&gt; opLambda) {
131         setId_Term(id, opLambda);
132     }
133 
134     public void setId_Term(String id) {
135         setId_Term(id, null);
136     }
137 
138     public void setId_Term(String id, ConditionOptionCall<TermQueryBuilder&gt; opLambda) {
139         TermQueryBuilder builder = regTermQ("_id", id);
140         if (opLambda != null) {
141             opLambda.callback(builder);
142         }
143     }
144 
145     public void setId_NotEqual(String id) {
146         setId_NotTerm(id, null);
147     }
148 
149     public void setId_NotTerm(String id) {
150         setId_NotTerm(id, null);
151     }
152 
153     public void setId_NotEqual(String id, ConditionOptionCall<BoolQueryBuilder&gt; opLambda) {
154         setId_NotTerm(id, opLambda);
155     }
156 
157     public void setId_NotTerm(String id, ConditionOptionCall<BoolQueryBuilder&gt; opLambda) {
158         not(not -&gt; not.setId_Term(id), opLambda);
159     }
160 
161     public void setId_Terms(Collection<String&gt; idList) {
162         setId_Terms(idList, null);
163     }
164 
165     public void setId_Terms(Collection<String&gt; idList, ConditionOptionCall<IdsQueryBuilder&gt; opLambda) {
166         IdsQueryBuilder builder = regIdsQ(idList);
167         if (opLambda != null) {
168             opLambda.callback(builder);
169         }
170     }
171 
172     public void setId_InScope(Collection<String&gt; idList) {
173         setId_Terms(idList, null);
174     }
175 
176     public void setId_InScope(Collection<String&gt; idList, ConditionOptionCall<IdsQueryBuilder&gt; opLambda) {
177         setId_Terms(idList, opLambda);
178     }
179 
180     public BsElevateWordToLabelCQ addOrderBy_Id_Asc() {
181         regOBA("_id");
182         return this;
183     }
184 
185     public BsElevateWordToLabelCQ addOrderBy_Id_Desc() {
186         regOBD("_id");
187         return this;
188     }
189 
190     public void setElevateWordId_Equal(String elevateWordId) {
191         setElevateWordId_Term(elevateWordId, null);
192     }
193 
194     public void setElevateWordId_Equal(String elevateWordId, ConditionOptionCall<TermQueryBuilder&gt; opLambda) {
195         setElevateWordId_Term(elevateWordId, opLambda);
196     }
197 
198     public void setElevateWordId_Term(String elevateWordId) {
199         setElevateWordId_Term(elevateWordId, null);
200     }
201 
202     public void setElevateWordId_Term(String elevateWordId, ConditionOptionCall<TermQueryBuilder&gt; opLambda) {
203         TermQueryBuilder builder = regTermQ("elevateWordId", elevateWordId);
204         if (opLambda != null) {
205             opLambda.callback(builder);
206         }
207     }
208 
209     public void setElevateWordId_NotEqual(String elevateWordId) {
210         setElevateWordId_NotTerm(elevateWordId, null);
211     }
212 
213     public void setElevateWordId_NotTerm(String elevateWordId) {
214         setElevateWordId_NotTerm(elevateWordId, null);
215     }
216 
217     public void setElevateWordId_NotEqual(String elevateWordId, ConditionOptionCall<BoolQueryBuilder&gt; opLambda) {
218         setElevateWordId_NotTerm(elevateWordId, opLambda);
219     }
220 
221     public void setElevateWordId_NotTerm(String elevateWordId, ConditionOptionCall<BoolQueryBuilder&gt; opLambda) {
222         not(not -&gt; not.setElevateWordId_Term(elevateWordId), opLambda);
223     }
224 
225     public void setElevateWordId_Terms(Collection<String&gt; elevateWordIdList) {
226         setElevateWordId_Terms(elevateWordIdList, null);
227     }
228 
229     public void setElevateWordId_Terms(Collection<String&gt; elevateWordIdList, ConditionOptionCall<TermsQueryBuilder&gt; opLambda) {
230         TermsQueryBuilder builder = regTermsQ("elevateWordId", elevateWordIdList);
231         if (opLambda != null) {
232             opLambda.callback(builder);
233         }
234     }
235 
236     public void setElevateWordId_InScope(Collection<String&gt; elevateWordIdList) {
237         setElevateWordId_Terms(elevateWordIdList, null);
238     }
239 
240     public void setElevateWordId_InScope(Collection<String&gt; elevateWordIdList, ConditionOptionCall<TermsQueryBuilder&gt; opLambda) {
241         setElevateWordId_Terms(elevateWordIdList, opLambda);
242     }
243 
244     public void setElevateWordId_Match(String elevateWordId) {
245         setElevateWordId_Match(elevateWordId, null);
246     }
247 
248     public void setElevateWordId_Match(String elevateWordId, ConditionOptionCall<MatchQueryBuilder&gt; opLambda) {
249         MatchQueryBuilder builder = regMatchQ("elevateWordId", elevateWordId);
250         if (opLambda != null) {
251             opLambda.callback(builder);
252         }
253     }
254 
255     public void setElevateWordId_MatchPhrase(String elevateWordId) {
256         setElevateWordId_MatchPhrase(elevateWordId, null);
257     }
258 
259     public void setElevateWordId_MatchPhrase(String elevateWordId, ConditionOptionCall<MatchPhraseQueryBuilder&gt; opLambda) {
260         MatchPhraseQueryBuilder builder = regMatchPhraseQ("elevateWordId", elevateWordId);
261         if (opLambda != null) {
262             opLambda.callback(builder);
263         }
264     }
265 
266     public void setElevateWordId_MatchPhrasePrefix(String elevateWordId) {
267         setElevateWordId_MatchPhrasePrefix(elevateWordId, null);
268     }
269 
270     public void setElevateWordId_MatchPhrasePrefix(String elevateWordId, ConditionOptionCall<MatchPhrasePrefixQueryBuilder&gt; opLambda) {
271         MatchPhrasePrefixQueryBuilder builder = regMatchPhrasePrefixQ("elevateWordId", elevateWordId);
272         if (opLambda != null) {
273             opLambda.callback(builder);
274         }
275     }
276 
277     public void setElevateWordId_Fuzzy(String elevateWordId) {
278         setElevateWordId_Fuzzy(elevateWordId, null);
279     }
280 
281     public void setElevateWordId_Fuzzy(String elevateWordId, ConditionOptionCall<MatchQueryBuilder&gt; opLambda) {
282         MatchQueryBuilder builder = regFuzzyQ("elevateWordId", elevateWordId);
283         if (opLambda != null) {
284             opLambda.callback(builder);
285         }
286     }
287 
288     public void setElevateWordId_Prefix(String elevateWordId) {
289         setElevateWordId_Prefix(elevateWordId, null);
290     }
291 
292     public void setElevateWordId_Prefix(String elevateWordId, ConditionOptionCall<PrefixQueryBuilder&gt; opLambda) {
293         PrefixQueryBuilder builder = regPrefixQ("elevateWordId", elevateWordId);
294         if (opLambda != null) {
295             opLambda.callback(builder);
296         }
297     }
298 
299     public void setElevateWordId_Wildcard(String elevateWordId) {
300         setElevateWordId_Wildcard(elevateWordId, null);
301     }
302 
303     public void setElevateWordId_Wildcard(String elevateWordId, ConditionOptionCall<WildcardQueryBuilder&gt; opLambda) {
304         WildcardQueryBuilder builder = regWildcardQ("elevateWordId", elevateWordId);
305         if (opLambda != null) {
306             opLambda.callback(builder);
307         }
308     }
309 
310     public void setElevateWordId_Regexp(String elevateWordId) {
311         setElevateWordId_Regexp(elevateWordId, null);
312     }
313 
314     public void setElevateWordId_Regexp(String elevateWordId, ConditionOptionCall<RegexpQueryBuilder&gt; opLambda) {
315         RegexpQueryBuilder builder = regRegexpQ("elevateWordId", elevateWordId);
316         if (opLambda != null) {
317             opLambda.callback(builder);
318         }
319     }
320 
321     public void setElevateWordId_SpanTerm(String elevateWordId) {
322         setElevateWordId_SpanTerm("elevateWordId", null);
323     }
324 
325     public void setElevateWordId_SpanTerm(String elevateWordId, ConditionOptionCall<SpanTermQueryBuilder&gt; opLambda) {
326         SpanTermQueryBuilder builder = regSpanTermQ("elevateWordId", elevateWordId);
327         if (opLambda != null) {
328             opLambda.callback(builder);
329         }
330     }
331 
332     public void setElevateWordId_greaterThan(String elevateWordId) {
333         setElevateWordId_greaterThan(elevateWordId, null);
334     }
335 
336     public void setElevateWordId_greaterThan(String elevateWordId, ConditionOptionCall<RangeQueryBuilder&gt; opLambda) {
337         final Object _value = elevateWordId;
338         RangeQueryBuilder builder = regRangeQ("elevateWordId", ConditionKey.CK_gREATER_THAN, _value);
339         if (opLambda != null) {
340             opLambda.callback(builder);
341         }
342     }
343 
344     public void setElevateWordId_LessThan(String elevateWordId) {
345         setElevateWordId_LessThan(elevateWordId, null);
346     }
347 
348     public void setElevateWordId_LessThan(String elevateWordId, ConditionOptionCall<RangeQueryBuilder&gt; opLambda) {
349         final Object _value = elevateWordId;
350         RangeQueryBuilder builder = regRangeQ("elevateWordId", ConditionKey.CK_LESS_THAN, _value);
351         if (opLambda != null) {
352             opLambda.callback(builder);
353         }
354     }
355 
356     public void setElevateWordId_greaterEqual(String elevateWordId) {
357         setElevateWordId_greaterEqual(elevateWordId, null);
358     }
359 
360     public void setElevateWordId_greaterEqual(String elevateWordId, ConditionOptionCall<RangeQueryBuilder&gt; opLambda) {
361         final Object _value = elevateWordId;
362         RangeQueryBuilder builder = regRangeQ("elevateWordId", ConditionKey.CK_gREATER_EQUAL, _value);
363         if (opLambda != null) {
364             opLambda.callback(builder);
365         }
366     }
367 
368     public void setElevateWordId_LessEqual(String elevateWordId) {
369         setElevateWordId_LessEqual(elevateWordId, null);
370     }
371 
372     public void setElevateWordId_LessEqual(String elevateWordId, ConditionOptionCall<RangeQueryBuilder&gt; opLambda) {
373         final Object _value = elevateWordId;
374         RangeQueryBuilder builder = regRangeQ("elevateWordId", ConditionKey.CK_LESS_EQUAL, _value);
375         if (opLambda != null) {
376             opLambda.callback(builder);
377         }
378     }
379 
380     public void setElevateWordId_Exists() {
381         setElevateWordId_Exists(null);
382     }
383 
384     public void setElevateWordId_Exists(ConditionOptionCall<ExistsQueryBuilder&gt; opLambda) {
385         ExistsQueryBuilder builder = regExistsQ("elevateWordId");
386         if (opLambda != null) {
387             opLambda.callback(builder);
388         }
389     }
390 
391     public void setElevateWordId_CommonTerms(String elevateWordId) {
392         setElevateWordId_CommonTerms(elevateWordId, null);
393     }
394 
395     public void setElevateWordId_CommonTerms(String elevateWordId, ConditionOptionCall<CommonTermsQueryBuilder&gt; opLambda) {
396         CommonTermsQueryBuilder builder = regCommonTermsQ("elevateWordId", elevateWordId);
397         if (opLambda != null) {
398             opLambda.callback(builder);
399         }
400     }
401 
402     public BsElevateWordToLabelCQ addOrderBy_ElevateWordId_Asc() {
403         regOBA("elevateWordId");
404         return this;
405     }
406 
407     public BsElevateWordToLabelCQ addOrderBy_ElevateWordId_Desc() {
408         regOBD("elevateWordId");
409         return this;
410     }
411 
412     public void setLabelTypeId_Equal(String labelTypeId) {
413         setLabelTypeId_Term(labelTypeId, null);
414     }
415 
416     public void setLabelTypeId_Equal(String labelTypeId, ConditionOptionCall<TermQueryBuilder&gt; opLambda) {
417         setLabelTypeId_Term(labelTypeId, opLambda);
418     }
419 
420     public void setLabelTypeId_Term(String labelTypeId) {
421         setLabelTypeId_Term(labelTypeId, null);
422     }
423 
424     public void setLabelTypeId_Term(String labelTypeId, ConditionOptionCall<TermQueryBuilder&gt; opLambda) {
425         TermQueryBuilder builder = regTermQ("labelTypeId", labelTypeId);
426         if (opLambda != null) {
427             opLambda.callback(builder);
428         }
429     }
430 
431     public void setLabelTypeId_NotEqual(String labelTypeId) {
432         setLabelTypeId_NotTerm(labelTypeId, null);
433     }
434 
435     public void setLabelTypeId_NotTerm(String labelTypeId) {
436         setLabelTypeId_NotTerm(labelTypeId, null);
437     }
438 
439     public void setLabelTypeId_NotEqual(String labelTypeId, ConditionOptionCall<BoolQueryBuilder&gt; opLambda) {
440         setLabelTypeId_NotTerm(labelTypeId, opLambda);
441     }
442 
443     public void setLabelTypeId_NotTerm(String labelTypeId, ConditionOptionCall<BoolQueryBuilder&gt; opLambda) {
444         not(not -&gt; not.setLabelTypeId_Term(labelTypeId), opLambda);
445     }
446 
447     public void setLabelTypeId_Terms(Collection<String&gt; labelTypeIdList) {
448         setLabelTypeId_Terms(labelTypeIdList, null);
449     }
450 
451     public void setLabelTypeId_Terms(Collection<String&gt; labelTypeIdList, ConditionOptionCall<TermsQueryBuilder&gt; opLambda) {
452         TermsQueryBuilder builder = regTermsQ("labelTypeId", labelTypeIdList);
453         if (opLambda != null) {
454             opLambda.callback(builder);
455         }
456     }
457 
458     public void setLabelTypeId_InScope(Collection<String&gt; labelTypeIdList) {
459         setLabelTypeId_Terms(labelTypeIdList, null);
460     }
461 
462     public void setLabelTypeId_InScope(Collection<String&gt; labelTypeIdList, ConditionOptionCall<TermsQueryBuilder&gt; opLambda) {
463         setLabelTypeId_Terms(labelTypeIdList, opLambda);
464     }
465 
466     public void setLabelTypeId_Match(String labelTypeId) {
467         setLabelTypeId_Match(labelTypeId, null);
468     }
469 
470     public void setLabelTypeId_Match(String labelTypeId, ConditionOptionCall<MatchQueryBuilder&gt; opLambda) {
471         MatchQueryBuilder builder = regMatchQ("labelTypeId", labelTypeId);
472         if (opLambda != null) {
473             opLambda.callback(builder);
474         }
475     }
476 
477     public void setLabelTypeId_MatchPhrase(String labelTypeId) {
478         setLabelTypeId_MatchPhrase(labelTypeId, null);
479     }
480 
481     public void setLabelTypeId_MatchPhrase(String labelTypeId, ConditionOptionCall<MatchPhraseQueryBuilder&gt; opLambda) {
482         MatchPhraseQueryBuilder builder = regMatchPhraseQ("labelTypeId", labelTypeId);
483         if (opLambda != null) {
484             opLambda.callback(builder);
485         }
486     }
487 
488     public void setLabelTypeId_MatchPhrasePrefix(String labelTypeId) {
489         setLabelTypeId_MatchPhrasePrefix(labelTypeId, null);
490     }
491 
492     public void setLabelTypeId_MatchPhrasePrefix(String labelTypeId, ConditionOptionCall<MatchPhrasePrefixQueryBuilder&gt; opLambda) {
493         MatchPhrasePrefixQueryBuilder builder = regMatchPhrasePrefixQ("labelTypeId", labelTypeId);
494         if (opLambda != null) {
495             opLambda.callback(builder);
496         }
497     }
498 
499     public void setLabelTypeId_Fuzzy(String labelTypeId) {
500         setLabelTypeId_Fuzzy(labelTypeId, null);
501     }
502 
503     public void setLabelTypeId_Fuzzy(String labelTypeId, ConditionOptionCall<MatchQueryBuilder&gt; opLambda) {
504         MatchQueryBuilder builder = regFuzzyQ("labelTypeId", labelTypeId);
505         if (opLambda != null) {
506             opLambda.callback(builder);
507         }
508     }
509 
510     public void setLabelTypeId_Prefix(String labelTypeId) {
511         setLabelTypeId_Prefix(labelTypeId, null);
512     }
513 
514     public void setLabelTypeId_Prefix(String labelTypeId, ConditionOptionCall<PrefixQueryBuilder&gt; opLambda) {
515         PrefixQueryBuilder builder = regPrefixQ("labelTypeId", labelTypeId);
516         if (opLambda != null) {
517             opLambda.callback(builder);
518         }
519     }
520 
521     public void setLabelTypeId_Wildcard(String labelTypeId) {
522         setLabelTypeId_Wildcard(labelTypeId, null);
523     }
524 
525     public void setLabelTypeId_Wildcard(String labelTypeId, ConditionOptionCall<WildcardQueryBuilder&gt; opLambda) {
526         WildcardQueryBuilder builder = regWildcardQ("labelTypeId", labelTypeId);
527         if (opLambda != null) {
528             opLambda.callback(builder);
529         }
530     }
531 
532     public void setLabelTypeId_Regexp(String labelTypeId) {
533         setLabelTypeId_Regexp(labelTypeId, null);
534     }
535 
536     public void setLabelTypeId_Regexp(String labelTypeId, ConditionOptionCall<RegexpQueryBuilder&gt; opLambda) {
537         RegexpQueryBuilder builder = regRegexpQ("labelTypeId", labelTypeId);
538         if (opLambda != null) {
539             opLambda.callback(builder);
540         }
541     }
542 
543     public void setLabelTypeId_SpanTerm(String labelTypeId) {
544         setLabelTypeId_SpanTerm("labelTypeId", null);
545     }
546 
547     public void setLabelTypeId_SpanTerm(String labelTypeId, ConditionOptionCall<SpanTermQueryBuilder&gt; opLambda) {
548         SpanTermQueryBuilder builder = regSpanTermQ("labelTypeId", labelTypeId);
549         if (opLambda != null) {
550             opLambda.callback(builder);
551         }
552     }
553 
554     public void setLabelTypeId_greaterThan(String labelTypeId) {
555         setLabelTypeId_greaterThan(labelTypeId, null);
556     }
557 
558     public void setLabelTypeId_greaterThan(String labelTypeId, ConditionOptionCall<RangeQueryBuilder&gt; opLambda) {
559         final Object _value = labelTypeId;
560         RangeQueryBuilder builder = regRangeQ("labelTypeId", ConditionKey.CK_gREATER_THAN, _value);
561         if (opLambda != null) {
562             opLambda.callback(builder);
563         }
564     }
565 
566     public void setLabelTypeId_LessThan(String labelTypeId) {
567         setLabelTypeId_LessThan(labelTypeId, null);
568     }
569 
570     public void setLabelTypeId_LessThan(String labelTypeId, ConditionOptionCall<RangeQueryBuilder&gt; opLambda) {
571         final Object _value = labelTypeId;
572         RangeQueryBuilder builder = regRangeQ("labelTypeId", ConditionKey.CK_LESS_THAN, _value);
573         if (opLambda != null) {
574             opLambda.callback(builder);
575         }
576     }
577 
578     public void setLabelTypeId_greaterEqual(String labelTypeId) {
579         setLabelTypeId_greaterEqual(labelTypeId, null);
580     }
581 
582     public void setLabelTypeId_greaterEqual(String labelTypeId, ConditionOptionCall<RangeQueryBuilder&gt; opLambda) {
583         final Object _value = labelTypeId;
584         RangeQueryBuilder builder = regRangeQ("labelTypeId", ConditionKey.CK_gREATER_EQUAL, _value);
585         if (opLambda != null) {
586             opLambda.callback(builder);
587         }
588     }
589 
590     public void setLabelTypeId_LessEqual(String labelTypeId) {
591         setLabelTypeId_LessEqual(labelTypeId, null);
592     }
593 
594     public void setLabelTypeId_LessEqual(String labelTypeId, ConditionOptionCall<RangeQueryBuilder&gt; opLambda) {
595         final Object _value = labelTypeId;
596         RangeQueryBuilder builder = regRangeQ("labelTypeId", ConditionKey.CK_LESS_EQUAL, _value);
597         if (opLambda != null) {
598             opLambda.callback(builder);
599         }
600     }
601 
602     public void setLabelTypeId_Exists() {
603         setLabelTypeId_Exists(null);
604     }
605 
606     public void setLabelTypeId_Exists(ConditionOptionCall<ExistsQueryBuilder&gt; opLambda) {
607         ExistsQueryBuilder builder = regExistsQ("labelTypeId");
608         if (opLambda != null) {
609             opLambda.callback(builder);
610         }
611     }
612 
613     public void setLabelTypeId_CommonTerms(String labelTypeId) {
614         setLabelTypeId_CommonTerms(labelTypeId, null);
615     }
616 
617     public void setLabelTypeId_CommonTerms(String labelTypeId, ConditionOptionCall<CommonTermsQueryBuilder&gt; opLambda) {
618         CommonTermsQueryBuilder builder = regCommonTermsQ("labelTypeId", labelTypeId);
619         if (opLambda != null) {
620             opLambda.callback(builder);
621         }
622     }
623 
624     public BsElevateWordToLabelCQ addOrderBy_LabelTypeId_Asc() {
625         regOBA("labelTypeId");
626         return this;
627     }
628 
629     public BsElevateWordToLabelCQ addOrderBy_LabelTypeId_Desc() {
630         regOBD("labelTypeId");
631         return this;
632     }
633 
634 }