View Javadoc
1   /*
2    * Copyright 2012-2019 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.log.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.log.allcommon.EsAbstractConditionQuery;
23  import org.codelibs.fess.es.log.cbean.cq.FavoriteLogCQ;
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 BsFavoriteLogCQ 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 "favorite_log";
55      }
56  
57      @Override
58      public String xgetAliasName() {
59          return "favorite_log";
60      }
61  
62      // ===================================================================================
63      //                                                                       Query Control
64      //                                                                       =============
65      public void functionScore(OperatorCall<FavoriteLogCQ> queryLambda,
66              ScoreFunctionCall<ScoreFunctionCreator<FavoriteLogCQ>> functionsLambda,
67              final ConditionOptionCall<FunctionScoreQueryBuilder> opLambda) {
68          FavoriteLogCQs/log/cbean/cq/FavoriteLogCQ.html#FavoriteLogCQ">FavoriteLogCQ cq = new FavoriteLogCQ();
69          queryLambda.callback(cq);
70          final Collection<FilterFunctionBuilder> list = new ArrayList<>();
71          if (functionsLambda != null) {
72              functionsLambda.callback((cqLambda, scoreFunctionBuilder) -> {
73                  FavoriteLogCQs/log/cbean/cq/FavoriteLogCQ.html#FavoriteLogCQ">FavoriteLogCQ cf = new FavoriteLogCQ();
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<FavoriteLogCQ, FavoriteLogCQ> filteredLambda) {
85          filtered(filteredLambda, null);
86      }
87  
88      public void filtered(FilteredCall<FavoriteLogCQ, FavoriteLogCQ> filteredLambda, ConditionOptionCall<BoolQueryBuilder> opLambda) {
89          bool((must, should, mustNot, filter) -> {
90              filteredLambda.callback(must, filter);
91          }, opLambda);
92      }
93  
94      public void not(OperatorCall<FavoriteLogCQ> notLambda) {
95          not(notLambda, null);
96      }
97  
98      public void not(final OperatorCall<FavoriteLogCQ> notLambda, final ConditionOptionCall<BoolQueryBuilder> opLambda) {
99          bool((must, should, mustNot, filter) -> notLambda.callback(mustNot), opLambda);
100     }
101 
102     public void bool(BoolCall<FavoriteLogCQ> boolLambda) {
103         bool(boolLambda, null);
104     }
105 
106     public void bool(BoolCall<FavoriteLogCQ> boolLambda, ConditionOptionCall<BoolQueryBuilder> opLambda) {
107         FavoriteLogCQbean/cq/FavoriteLogCQ.html#FavoriteLogCQ">FavoriteLogCQ mustQuery = new FavoriteLogCQ();
108         FavoriteLogCQan/cq/FavoriteLogCQ.html#FavoriteLogCQ">FavoriteLogCQ shouldQuery = new FavoriteLogCQ();
109         FavoriteLogCQn/cq/FavoriteLogCQ.html#FavoriteLogCQ">FavoriteLogCQ mustNotQuery = new FavoriteLogCQ();
110         FavoriteLogCQan/cq/FavoriteLogCQ.html#FavoriteLogCQ">FavoriteLogCQ filterQuery = new FavoriteLogCQ();
111         boolLambda.callback(mustQuery, shouldQuery, mustNotQuery, filterQuery);
112         if (mustQuery.hasQueries() || shouldQuery.hasQueries() || mustNotQuery.hasQueries() || filterQuery.hasQueries()) {
113             BoolQueryBuilder builder =
114                     regBoolCQ(mustQuery.getQueryBuilderList(), shouldQuery.getQueryBuilderList(), mustNotQuery.getQueryBuilderList(),
115                             filterQuery.getQueryBuilderList());
116             if (opLambda != null) {
117                 opLambda.callback(builder);
118             }
119         }
120     }
121 
122     // ===================================================================================
123     //                                                                           Query Set
124     //                                                                           =========
125     public void setId_Equal(String id) {
126         setId_Term(id, null);
127     }
128 
129     public void setId_Equal(String id, ConditionOptionCall<TermQueryBuilder> opLambda) {
130         setId_Term(id, opLambda);
131     }
132 
133     public void setId_Term(String id) {
134         setId_Term(id, null);
135     }
136 
137     public void setId_Term(String id, ConditionOptionCall<TermQueryBuilder> opLambda) {
138         TermQueryBuilder builder = regTermQ("_id", id);
139         if (opLambda != null) {
140             opLambda.callback(builder);
141         }
142     }
143 
144     public void setId_NotEqual(String id) {
145         setId_NotTerm(id, null);
146     }
147 
148     public void setId_NotTerm(String id) {
149         setId_NotTerm(id, null);
150     }
151 
152     public void setId_NotEqual(String id, ConditionOptionCall<BoolQueryBuilder> opLambda) {
153         setId_NotTerm(id, opLambda);
154     }
155 
156     public void setId_NotTerm(String id, ConditionOptionCall<BoolQueryBuilder> opLambda) {
157         not(not -> not.setId_Term(id), opLambda);
158     }
159 
160     public void setId_Terms(Collection<String> idList) {
161         setId_Terms(idList, null);
162     }
163 
164     public void setId_Terms(Collection<String> idList, ConditionOptionCall<IdsQueryBuilder> opLambda) {
165         IdsQueryBuilder builder = regIdsQ(idList);
166         if (opLambda != null) {
167             opLambda.callback(builder);
168         }
169     }
170 
171     public void setId_InScope(Collection<String> idList) {
172         setId_Terms(idList, null);
173     }
174 
175     public void setId_InScope(Collection<String> idList, ConditionOptionCall<IdsQueryBuilder> opLambda) {
176         setId_Terms(idList, opLambda);
177     }
178 
179     public BsFavoriteLogCQ addOrderBy_Id_Asc() {
180         regOBA("_id");
181         return this;
182     }
183 
184     public BsFavoriteLogCQ addOrderBy_Id_Desc() {
185         regOBD("_id");
186         return this;
187     }
188 
189     public void setCreatedAt_Equal(LocalDateTime createdAt) {
190         setCreatedAt_Term(createdAt, null);
191     }
192 
193     public void setCreatedAt_Equal(LocalDateTime createdAt, ConditionOptionCall<TermQueryBuilder> opLambda) {
194         setCreatedAt_Term(createdAt, opLambda);
195     }
196 
197     public void setCreatedAt_Term(LocalDateTime createdAt) {
198         setCreatedAt_Term(createdAt, null);
199     }
200 
201     public void setCreatedAt_Term(LocalDateTime createdAt, ConditionOptionCall<TermQueryBuilder> opLambda) {
202         TermQueryBuilder builder = regTermQ("createdAt", createdAt);
203         if (opLambda != null) {
204             opLambda.callback(builder);
205         }
206     }
207 
208     public void setCreatedAt_NotEqual(LocalDateTime createdAt) {
209         setCreatedAt_NotTerm(createdAt, null);
210     }
211 
212     public void setCreatedAt_NotTerm(LocalDateTime createdAt) {
213         setCreatedAt_NotTerm(createdAt, null);
214     }
215 
216     public void setCreatedAt_NotEqual(LocalDateTime createdAt, ConditionOptionCall<BoolQueryBuilder> opLambda) {
217         setCreatedAt_NotTerm(createdAt, opLambda);
218     }
219 
220     public void setCreatedAt_NotTerm(LocalDateTime createdAt, ConditionOptionCall<BoolQueryBuilder> opLambda) {
221         not(not -> not.setCreatedAt_Term(createdAt), opLambda);
222     }
223 
224     public void setCreatedAt_Terms(Collection<LocalDateTime> createdAtList) {
225         setCreatedAt_Terms(createdAtList, null);
226     }
227 
228     public void setCreatedAt_Terms(Collection<LocalDateTime> createdAtList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
229         TermsQueryBuilder builder = regTermsQ("createdAt", createdAtList);
230         if (opLambda != null) {
231             opLambda.callback(builder);
232         }
233     }
234 
235     public void setCreatedAt_InScope(Collection<LocalDateTime> createdAtList) {
236         setCreatedAt_Terms(createdAtList, null);
237     }
238 
239     public void setCreatedAt_InScope(Collection<LocalDateTime> createdAtList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
240         setCreatedAt_Terms(createdAtList, opLambda);
241     }
242 
243     public void setCreatedAt_Match(LocalDateTime createdAt) {
244         setCreatedAt_Match(createdAt, null);
245     }
246 
247     public void setCreatedAt_Match(LocalDateTime createdAt, ConditionOptionCall<MatchQueryBuilder> opLambda) {
248         MatchQueryBuilder builder = regMatchQ("createdAt", createdAt);
249         if (opLambda != null) {
250             opLambda.callback(builder);
251         }
252     }
253 
254     public void setCreatedAt_MatchPhrase(LocalDateTime createdAt) {
255         setCreatedAt_MatchPhrase(createdAt, null);
256     }
257 
258     public void setCreatedAt_MatchPhrase(LocalDateTime createdAt, ConditionOptionCall<MatchPhraseQueryBuilder> opLambda) {
259         MatchPhraseQueryBuilder builder = regMatchPhraseQ("createdAt", createdAt);
260         if (opLambda != null) {
261             opLambda.callback(builder);
262         }
263     }
264 
265     public void setCreatedAt_MatchPhrasePrefix(LocalDateTime createdAt) {
266         setCreatedAt_MatchPhrasePrefix(createdAt, null);
267     }
268 
269     public void setCreatedAt_MatchPhrasePrefix(LocalDateTime createdAt, ConditionOptionCall<MatchPhrasePrefixQueryBuilder> opLambda) {
270         MatchPhrasePrefixQueryBuilder builder = regMatchPhrasePrefixQ("createdAt", createdAt);
271         if (opLambda != null) {
272             opLambda.callback(builder);
273         }
274     }
275 
276     public void setCreatedAt_Fuzzy(LocalDateTime createdAt) {
277         setCreatedAt_Fuzzy(createdAt, null);
278     }
279 
280     public void setCreatedAt_Fuzzy(LocalDateTime createdAt, ConditionOptionCall<MatchQueryBuilder> opLambda) {
281         MatchQueryBuilder builder = regFuzzyQ("createdAt", createdAt);
282         if (opLambda != null) {
283             opLambda.callback(builder);
284         }
285     }
286 
287     public void setCreatedAt_GreaterThan(LocalDateTime createdAt) {
288         setCreatedAt_GreaterThan(createdAt, null);
289     }
290 
291     public void setCreatedAt_GreaterThan(LocalDateTime createdAt, ConditionOptionCall<RangeQueryBuilder> opLambda) {
292         final Object _value = toRangeLocalDateTimeString(createdAt, "date_optional_time");
293         RangeQueryBuilder builder = regRangeQ("createdAt", ConditionKey.CK_GREATER_THAN, _value);
294         if (opLambda != null) {
295             opLambda.callback(builder);
296         }
297     }
298 
299     public void setCreatedAt_LessThan(LocalDateTime createdAt) {
300         setCreatedAt_LessThan(createdAt, null);
301     }
302 
303     public void setCreatedAt_LessThan(LocalDateTime createdAt, ConditionOptionCall<RangeQueryBuilder> opLambda) {
304         final Object _value = toRangeLocalDateTimeString(createdAt, "date_optional_time");
305         RangeQueryBuilder builder = regRangeQ("createdAt", ConditionKey.CK_LESS_THAN, _value);
306         if (opLambda != null) {
307             opLambda.callback(builder);
308         }
309     }
310 
311     public void setCreatedAt_GreaterEqual(LocalDateTime createdAt) {
312         setCreatedAt_GreaterEqual(createdAt, null);
313     }
314 
315     public void setCreatedAt_GreaterEqual(LocalDateTime createdAt, ConditionOptionCall<RangeQueryBuilder> opLambda) {
316         final Object _value = toRangeLocalDateTimeString(createdAt, "date_optional_time");
317         RangeQueryBuilder builder = regRangeQ("createdAt", ConditionKey.CK_GREATER_EQUAL, _value);
318         if (opLambda != null) {
319             opLambda.callback(builder);
320         }
321     }
322 
323     public void setCreatedAt_LessEqual(LocalDateTime createdAt) {
324         setCreatedAt_LessEqual(createdAt, null);
325     }
326 
327     public void setCreatedAt_LessEqual(LocalDateTime createdAt, ConditionOptionCall<RangeQueryBuilder> opLambda) {
328         final Object _value = toRangeLocalDateTimeString(createdAt, "date_optional_time");
329         RangeQueryBuilder builder = regRangeQ("createdAt", ConditionKey.CK_LESS_EQUAL, _value);
330         if (opLambda != null) {
331             opLambda.callback(builder);
332         }
333     }
334 
335     public void setCreatedAt_Exists() {
336         setCreatedAt_Exists(null);
337     }
338 
339     public void setCreatedAt_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
340         ExistsQueryBuilder builder = regExistsQ("createdAt");
341         if (opLambda != null) {
342             opLambda.callback(builder);
343         }
344     }
345 
346     public void setCreatedAt_CommonTerms(LocalDateTime createdAt) {
347         setCreatedAt_CommonTerms(createdAt, null);
348     }
349 
350     public void setCreatedAt_CommonTerms(LocalDateTime createdAt, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
351         CommonTermsQueryBuilder builder = regCommonTermsQ("createdAt", createdAt);
352         if (opLambda != null) {
353             opLambda.callback(builder);
354         }
355     }
356 
357     public BsFavoriteLogCQ addOrderBy_CreatedAt_Asc() {
358         regOBA("createdAt");
359         return this;
360     }
361 
362     public BsFavoriteLogCQ addOrderBy_CreatedAt_Desc() {
363         regOBD("createdAt");
364         return this;
365     }
366 
367     public void setDocId_Equal(String docId) {
368         setDocId_Term(docId, null);
369     }
370 
371     public void setDocId_Equal(String docId, ConditionOptionCall<TermQueryBuilder> opLambda) {
372         setDocId_Term(docId, opLambda);
373     }
374 
375     public void setDocId_Term(String docId) {
376         setDocId_Term(docId, null);
377     }
378 
379     public void setDocId_Term(String docId, ConditionOptionCall<TermQueryBuilder> opLambda) {
380         TermQueryBuilder builder = regTermQ("docId", docId);
381         if (opLambda != null) {
382             opLambda.callback(builder);
383         }
384     }
385 
386     public void setDocId_NotEqual(String docId) {
387         setDocId_NotTerm(docId, null);
388     }
389 
390     public void setDocId_NotTerm(String docId) {
391         setDocId_NotTerm(docId, null);
392     }
393 
394     public void setDocId_NotEqual(String docId, ConditionOptionCall<BoolQueryBuilder> opLambda) {
395         setDocId_NotTerm(docId, opLambda);
396     }
397 
398     public void setDocId_NotTerm(String docId, ConditionOptionCall<BoolQueryBuilder> opLambda) {
399         not(not -> not.setDocId_Term(docId), opLambda);
400     }
401 
402     public void setDocId_Terms(Collection<String> docIdList) {
403         setDocId_Terms(docIdList, null);
404     }
405 
406     public void setDocId_Terms(Collection<String> docIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
407         TermsQueryBuilder builder = regTermsQ("docId", docIdList);
408         if (opLambda != null) {
409             opLambda.callback(builder);
410         }
411     }
412 
413     public void setDocId_InScope(Collection<String> docIdList) {
414         setDocId_Terms(docIdList, null);
415     }
416 
417     public void setDocId_InScope(Collection<String> docIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
418         setDocId_Terms(docIdList, opLambda);
419     }
420 
421     public void setDocId_Match(String docId) {
422         setDocId_Match(docId, null);
423     }
424 
425     public void setDocId_Match(String docId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
426         MatchQueryBuilder builder = regMatchQ("docId", docId);
427         if (opLambda != null) {
428             opLambda.callback(builder);
429         }
430     }
431 
432     public void setDocId_MatchPhrase(String docId) {
433         setDocId_MatchPhrase(docId, null);
434     }
435 
436     public void setDocId_MatchPhrase(String docId, ConditionOptionCall<MatchPhraseQueryBuilder> opLambda) {
437         MatchPhraseQueryBuilder builder = regMatchPhraseQ("docId", docId);
438         if (opLambda != null) {
439             opLambda.callback(builder);
440         }
441     }
442 
443     public void setDocId_MatchPhrasePrefix(String docId) {
444         setDocId_MatchPhrasePrefix(docId, null);
445     }
446 
447     public void setDocId_MatchPhrasePrefix(String docId, ConditionOptionCall<MatchPhrasePrefixQueryBuilder> opLambda) {
448         MatchPhrasePrefixQueryBuilder builder = regMatchPhrasePrefixQ("docId", docId);
449         if (opLambda != null) {
450             opLambda.callback(builder);
451         }
452     }
453 
454     public void setDocId_Fuzzy(String docId) {
455         setDocId_Fuzzy(docId, null);
456     }
457 
458     public void setDocId_Fuzzy(String docId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
459         MatchQueryBuilder builder = regFuzzyQ("docId", docId);
460         if (opLambda != null) {
461             opLambda.callback(builder);
462         }
463     }
464 
465     public void setDocId_Prefix(String docId) {
466         setDocId_Prefix(docId, null);
467     }
468 
469     public void setDocId_Prefix(String docId, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
470         PrefixQueryBuilder builder = regPrefixQ("docId", docId);
471         if (opLambda != null) {
472             opLambda.callback(builder);
473         }
474     }
475 
476     public void setDocId_Wildcard(String docId) {
477         setDocId_Wildcard(docId, null);
478     }
479 
480     public void setDocId_Wildcard(String docId, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
481         WildcardQueryBuilder builder = regWildcardQ("docId", docId);
482         if (opLambda != null) {
483             opLambda.callback(builder);
484         }
485     }
486 
487     public void setDocId_Regexp(String docId) {
488         setDocId_Regexp(docId, null);
489     }
490 
491     public void setDocId_Regexp(String docId, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
492         RegexpQueryBuilder builder = regRegexpQ("docId", docId);
493         if (opLambda != null) {
494             opLambda.callback(builder);
495         }
496     }
497 
498     public void setDocId_SpanTerm(String docId) {
499         setDocId_SpanTerm("docId", null);
500     }
501 
502     public void setDocId_SpanTerm(String docId, ConditionOptionCall<SpanTermQueryBuilder> opLambda) {
503         SpanTermQueryBuilder builder = regSpanTermQ("docId", docId);
504         if (opLambda != null) {
505             opLambda.callback(builder);
506         }
507     }
508 
509     public void setDocId_GreaterThan(String docId) {
510         setDocId_GreaterThan(docId, null);
511     }
512 
513     public void setDocId_GreaterThan(String docId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
514         final Object _value = docId;
515         RangeQueryBuilder builder = regRangeQ("docId", ConditionKey.CK_GREATER_THAN, _value);
516         if (opLambda != null) {
517             opLambda.callback(builder);
518         }
519     }
520 
521     public void setDocId_LessThan(String docId) {
522         setDocId_LessThan(docId, null);
523     }
524 
525     public void setDocId_LessThan(String docId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
526         final Object _value = docId;
527         RangeQueryBuilder builder = regRangeQ("docId", ConditionKey.CK_LESS_THAN, _value);
528         if (opLambda != null) {
529             opLambda.callback(builder);
530         }
531     }
532 
533     public void setDocId_GreaterEqual(String docId) {
534         setDocId_GreaterEqual(docId, null);
535     }
536 
537     public void setDocId_GreaterEqual(String docId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
538         final Object _value = docId;
539         RangeQueryBuilder builder = regRangeQ("docId", ConditionKey.CK_GREATER_EQUAL, _value);
540         if (opLambda != null) {
541             opLambda.callback(builder);
542         }
543     }
544 
545     public void setDocId_LessEqual(String docId) {
546         setDocId_LessEqual(docId, null);
547     }
548 
549     public void setDocId_LessEqual(String docId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
550         final Object _value = docId;
551         RangeQueryBuilder builder = regRangeQ("docId", ConditionKey.CK_LESS_EQUAL, _value);
552         if (opLambda != null) {
553             opLambda.callback(builder);
554         }
555     }
556 
557     public void setDocId_Exists() {
558         setDocId_Exists(null);
559     }
560 
561     public void setDocId_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
562         ExistsQueryBuilder builder = regExistsQ("docId");
563         if (opLambda != null) {
564             opLambda.callback(builder);
565         }
566     }
567 
568     public void setDocId_CommonTerms(String docId) {
569         setDocId_CommonTerms(docId, null);
570     }
571 
572     public void setDocId_CommonTerms(String docId, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
573         CommonTermsQueryBuilder builder = regCommonTermsQ("docId", docId);
574         if (opLambda != null) {
575             opLambda.callback(builder);
576         }
577     }
578 
579     public BsFavoriteLogCQ addOrderBy_DocId_Asc() {
580         regOBA("docId");
581         return this;
582     }
583 
584     public BsFavoriteLogCQ addOrderBy_DocId_Desc() {
585         regOBD("docId");
586         return this;
587     }
588 
589     public void setQueryId_Equal(String queryId) {
590         setQueryId_Term(queryId, null);
591     }
592 
593     public void setQueryId_Equal(String queryId, ConditionOptionCall<TermQueryBuilder> opLambda) {
594         setQueryId_Term(queryId, opLambda);
595     }
596 
597     public void setQueryId_Term(String queryId) {
598         setQueryId_Term(queryId, null);
599     }
600 
601     public void setQueryId_Term(String queryId, ConditionOptionCall<TermQueryBuilder> opLambda) {
602         TermQueryBuilder builder = regTermQ("queryId", queryId);
603         if (opLambda != null) {
604             opLambda.callback(builder);
605         }
606     }
607 
608     public void setQueryId_NotEqual(String queryId) {
609         setQueryId_NotTerm(queryId, null);
610     }
611 
612     public void setQueryId_NotTerm(String queryId) {
613         setQueryId_NotTerm(queryId, null);
614     }
615 
616     public void setQueryId_NotEqual(String queryId, ConditionOptionCall<BoolQueryBuilder> opLambda) {
617         setQueryId_NotTerm(queryId, opLambda);
618     }
619 
620     public void setQueryId_NotTerm(String queryId, ConditionOptionCall<BoolQueryBuilder> opLambda) {
621         not(not -> not.setQueryId_Term(queryId), opLambda);
622     }
623 
624     public void setQueryId_Terms(Collection<String> queryIdList) {
625         setQueryId_Terms(queryIdList, null);
626     }
627 
628     public void setQueryId_Terms(Collection<String> queryIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
629         TermsQueryBuilder builder = regTermsQ("queryId", queryIdList);
630         if (opLambda != null) {
631             opLambda.callback(builder);
632         }
633     }
634 
635     public void setQueryId_InScope(Collection<String> queryIdList) {
636         setQueryId_Terms(queryIdList, null);
637     }
638 
639     public void setQueryId_InScope(Collection<String> queryIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
640         setQueryId_Terms(queryIdList, opLambda);
641     }
642 
643     public void setQueryId_Match(String queryId) {
644         setQueryId_Match(queryId, null);
645     }
646 
647     public void setQueryId_Match(String queryId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
648         MatchQueryBuilder builder = regMatchQ("queryId", queryId);
649         if (opLambda != null) {
650             opLambda.callback(builder);
651         }
652     }
653 
654     public void setQueryId_MatchPhrase(String queryId) {
655         setQueryId_MatchPhrase(queryId, null);
656     }
657 
658     public void setQueryId_MatchPhrase(String queryId, ConditionOptionCall<MatchPhraseQueryBuilder> opLambda) {
659         MatchPhraseQueryBuilder builder = regMatchPhraseQ("queryId", queryId);
660         if (opLambda != null) {
661             opLambda.callback(builder);
662         }
663     }
664 
665     public void setQueryId_MatchPhrasePrefix(String queryId) {
666         setQueryId_MatchPhrasePrefix(queryId, null);
667     }
668 
669     public void setQueryId_MatchPhrasePrefix(String queryId, ConditionOptionCall<MatchPhrasePrefixQueryBuilder> opLambda) {
670         MatchPhrasePrefixQueryBuilder builder = regMatchPhrasePrefixQ("queryId", queryId);
671         if (opLambda != null) {
672             opLambda.callback(builder);
673         }
674     }
675 
676     public void setQueryId_Fuzzy(String queryId) {
677         setQueryId_Fuzzy(queryId, null);
678     }
679 
680     public void setQueryId_Fuzzy(String queryId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
681         MatchQueryBuilder builder = regFuzzyQ("queryId", queryId);
682         if (opLambda != null) {
683             opLambda.callback(builder);
684         }
685     }
686 
687     public void setQueryId_Prefix(String queryId) {
688         setQueryId_Prefix(queryId, null);
689     }
690 
691     public void setQueryId_Prefix(String queryId, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
692         PrefixQueryBuilder builder = regPrefixQ("queryId", queryId);
693         if (opLambda != null) {
694             opLambda.callback(builder);
695         }
696     }
697 
698     public void setQueryId_Wildcard(String queryId) {
699         setQueryId_Wildcard(queryId, null);
700     }
701 
702     public void setQueryId_Wildcard(String queryId, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
703         WildcardQueryBuilder builder = regWildcardQ("queryId", queryId);
704         if (opLambda != null) {
705             opLambda.callback(builder);
706         }
707     }
708 
709     public void setQueryId_Regexp(String queryId) {
710         setQueryId_Regexp(queryId, null);
711     }
712 
713     public void setQueryId_Regexp(String queryId, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
714         RegexpQueryBuilder builder = regRegexpQ("queryId", queryId);
715         if (opLambda != null) {
716             opLambda.callback(builder);
717         }
718     }
719 
720     public void setQueryId_SpanTerm(String queryId) {
721         setQueryId_SpanTerm("queryId", null);
722     }
723 
724     public void setQueryId_SpanTerm(String queryId, ConditionOptionCall<SpanTermQueryBuilder> opLambda) {
725         SpanTermQueryBuilder builder = regSpanTermQ("queryId", queryId);
726         if (opLambda != null) {
727             opLambda.callback(builder);
728         }
729     }
730 
731     public void setQueryId_GreaterThan(String queryId) {
732         setQueryId_GreaterThan(queryId, null);
733     }
734 
735     public void setQueryId_GreaterThan(String queryId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
736         final Object _value = queryId;
737         RangeQueryBuilder builder = regRangeQ("queryId", ConditionKey.CK_GREATER_THAN, _value);
738         if (opLambda != null) {
739             opLambda.callback(builder);
740         }
741     }
742 
743     public void setQueryId_LessThan(String queryId) {
744         setQueryId_LessThan(queryId, null);
745     }
746 
747     public void setQueryId_LessThan(String queryId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
748         final Object _value = queryId;
749         RangeQueryBuilder builder = regRangeQ("queryId", ConditionKey.CK_LESS_THAN, _value);
750         if (opLambda != null) {
751             opLambda.callback(builder);
752         }
753     }
754 
755     public void setQueryId_GreaterEqual(String queryId) {
756         setQueryId_GreaterEqual(queryId, null);
757     }
758 
759     public void setQueryId_GreaterEqual(String queryId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
760         final Object _value = queryId;
761         RangeQueryBuilder builder = regRangeQ("queryId", ConditionKey.CK_GREATER_EQUAL, _value);
762         if (opLambda != null) {
763             opLambda.callback(builder);
764         }
765     }
766 
767     public void setQueryId_LessEqual(String queryId) {
768         setQueryId_LessEqual(queryId, null);
769     }
770 
771     public void setQueryId_LessEqual(String queryId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
772         final Object _value = queryId;
773         RangeQueryBuilder builder = regRangeQ("queryId", ConditionKey.CK_LESS_EQUAL, _value);
774         if (opLambda != null) {
775             opLambda.callback(builder);
776         }
777     }
778 
779     public void setQueryId_Exists() {
780         setQueryId_Exists(null);
781     }
782 
783     public void setQueryId_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
784         ExistsQueryBuilder builder = regExistsQ("queryId");
785         if (opLambda != null) {
786             opLambda.callback(builder);
787         }
788     }
789 
790     public void setQueryId_CommonTerms(String queryId) {
791         setQueryId_CommonTerms(queryId, null);
792     }
793 
794     public void setQueryId_CommonTerms(String queryId, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
795         CommonTermsQueryBuilder builder = regCommonTermsQ("queryId", queryId);
796         if (opLambda != null) {
797             opLambda.callback(builder);
798         }
799     }
800 
801     public BsFavoriteLogCQ addOrderBy_QueryId_Asc() {
802         regOBA("queryId");
803         return this;
804     }
805 
806     public BsFavoriteLogCQ addOrderBy_QueryId_Desc() {
807         regOBD("queryId");
808         return this;
809     }
810 
811     public void setUrl_Equal(String url) {
812         setUrl_Term(url, null);
813     }
814 
815     public void setUrl_Equal(String url, ConditionOptionCall<TermQueryBuilder> opLambda) {
816         setUrl_Term(url, opLambda);
817     }
818 
819     public void setUrl_Term(String url) {
820         setUrl_Term(url, null);
821     }
822 
823     public void setUrl_Term(String url, ConditionOptionCall<TermQueryBuilder> opLambda) {
824         TermQueryBuilder builder = regTermQ("url", url);
825         if (opLambda != null) {
826             opLambda.callback(builder);
827         }
828     }
829 
830     public void setUrl_NotEqual(String url) {
831         setUrl_NotTerm(url, null);
832     }
833 
834     public void setUrl_NotTerm(String url) {
835         setUrl_NotTerm(url, null);
836     }
837 
838     public void setUrl_NotEqual(String url, ConditionOptionCall<BoolQueryBuilder> opLambda) {
839         setUrl_NotTerm(url, opLambda);
840     }
841 
842     public void setUrl_NotTerm(String url, ConditionOptionCall<BoolQueryBuilder> opLambda) {
843         not(not -> not.setUrl_Term(url), opLambda);
844     }
845 
846     public void setUrl_Terms(Collection<String> urlList) {
847         setUrl_Terms(urlList, null);
848     }
849 
850     public void setUrl_Terms(Collection<String> urlList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
851         TermsQueryBuilder builder = regTermsQ("url", urlList);
852         if (opLambda != null) {
853             opLambda.callback(builder);
854         }
855     }
856 
857     public void setUrl_InScope(Collection<String> urlList) {
858         setUrl_Terms(urlList, null);
859     }
860 
861     public void setUrl_InScope(Collection<String> urlList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
862         setUrl_Terms(urlList, opLambda);
863     }
864 
865     public void setUrl_Match(String url) {
866         setUrl_Match(url, null);
867     }
868 
869     public void setUrl_Match(String url, ConditionOptionCall<MatchQueryBuilder> opLambda) {
870         MatchQueryBuilder builder = regMatchQ("url", url);
871         if (opLambda != null) {
872             opLambda.callback(builder);
873         }
874     }
875 
876     public void setUrl_MatchPhrase(String url) {
877         setUrl_MatchPhrase(url, null);
878     }
879 
880     public void setUrl_MatchPhrase(String url, ConditionOptionCall<MatchPhraseQueryBuilder> opLambda) {
881         MatchPhraseQueryBuilder builder = regMatchPhraseQ("url", url);
882         if (opLambda != null) {
883             opLambda.callback(builder);
884         }
885     }
886 
887     public void setUrl_MatchPhrasePrefix(String url) {
888         setUrl_MatchPhrasePrefix(url, null);
889     }
890 
891     public void setUrl_MatchPhrasePrefix(String url, ConditionOptionCall<MatchPhrasePrefixQueryBuilder> opLambda) {
892         MatchPhrasePrefixQueryBuilder builder = regMatchPhrasePrefixQ("url", url);
893         if (opLambda != null) {
894             opLambda.callback(builder);
895         }
896     }
897 
898     public void setUrl_Fuzzy(String url) {
899         setUrl_Fuzzy(url, null);
900     }
901 
902     public void setUrl_Fuzzy(String url, ConditionOptionCall<MatchQueryBuilder> opLambda) {
903         MatchQueryBuilder builder = regFuzzyQ("url", url);
904         if (opLambda != null) {
905             opLambda.callback(builder);
906         }
907     }
908 
909     public void setUrl_Prefix(String url) {
910         setUrl_Prefix(url, null);
911     }
912 
913     public void setUrl_Prefix(String url, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
914         PrefixQueryBuilder builder = regPrefixQ("url", url);
915         if (opLambda != null) {
916             opLambda.callback(builder);
917         }
918     }
919 
920     public void setUrl_Wildcard(String url) {
921         setUrl_Wildcard(url, null);
922     }
923 
924     public void setUrl_Wildcard(String url, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
925         WildcardQueryBuilder builder = regWildcardQ("url", url);
926         if (opLambda != null) {
927             opLambda.callback(builder);
928         }
929     }
930 
931     public void setUrl_Regexp(String url) {
932         setUrl_Regexp(url, null);
933     }
934 
935     public void setUrl_Regexp(String url, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
936         RegexpQueryBuilder builder = regRegexpQ("url", url);
937         if (opLambda != null) {
938             opLambda.callback(builder);
939         }
940     }
941 
942     public void setUrl_SpanTerm(String url) {
943         setUrl_SpanTerm("url", null);
944     }
945 
946     public void setUrl_SpanTerm(String url, ConditionOptionCall<SpanTermQueryBuilder> opLambda) {
947         SpanTermQueryBuilder builder = regSpanTermQ("url", url);
948         if (opLambda != null) {
949             opLambda.callback(builder);
950         }
951     }
952 
953     public void setUrl_GreaterThan(String url) {
954         setUrl_GreaterThan(url, null);
955     }
956 
957     public void setUrl_GreaterThan(String url, ConditionOptionCall<RangeQueryBuilder> opLambda) {
958         final Object _value = url;
959         RangeQueryBuilder builder = regRangeQ("url", ConditionKey.CK_GREATER_THAN, _value);
960         if (opLambda != null) {
961             opLambda.callback(builder);
962         }
963     }
964 
965     public void setUrl_LessThan(String url) {
966         setUrl_LessThan(url, null);
967     }
968 
969     public void setUrl_LessThan(String url, ConditionOptionCall<RangeQueryBuilder> opLambda) {
970         final Object _value = url;
971         RangeQueryBuilder builder = regRangeQ("url", ConditionKey.CK_LESS_THAN, _value);
972         if (opLambda != null) {
973             opLambda.callback(builder);
974         }
975     }
976 
977     public void setUrl_GreaterEqual(String url) {
978         setUrl_GreaterEqual(url, null);
979     }
980 
981     public void setUrl_GreaterEqual(String url, ConditionOptionCall<RangeQueryBuilder> opLambda) {
982         final Object _value = url;
983         RangeQueryBuilder builder = regRangeQ("url", ConditionKey.CK_GREATER_EQUAL, _value);
984         if (opLambda != null) {
985             opLambda.callback(builder);
986         }
987     }
988 
989     public void setUrl_LessEqual(String url) {
990         setUrl_LessEqual(url, null);
991     }
992 
993     public void setUrl_LessEqual(String url, ConditionOptionCall<RangeQueryBuilder> opLambda) {
994         final Object _value = url;
995         RangeQueryBuilder builder = regRangeQ("url", ConditionKey.CK_LESS_EQUAL, _value);
996         if (opLambda != null) {
997             opLambda.callback(builder);
998         }
999     }
1000 
1001     public void setUrl_Exists() {
1002         setUrl_Exists(null);
1003     }
1004 
1005     public void setUrl_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
1006         ExistsQueryBuilder builder = regExistsQ("url");
1007         if (opLambda != null) {
1008             opLambda.callback(builder);
1009         }
1010     }
1011 
1012     public void setUrl_CommonTerms(String url) {
1013         setUrl_CommonTerms(url, null);
1014     }
1015 
1016     public void setUrl_CommonTerms(String url, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
1017         CommonTermsQueryBuilder builder = regCommonTermsQ("url", url);
1018         if (opLambda != null) {
1019             opLambda.callback(builder);
1020         }
1021     }
1022 
1023     public BsFavoriteLogCQ addOrderBy_Url_Asc() {
1024         regOBA("url");
1025         return this;
1026     }
1027 
1028     public BsFavoriteLogCQ addOrderBy_Url_Desc() {
1029         regOBD("url");
1030         return this;
1031     }
1032 
1033     public void setUserInfoId_Equal(String userInfoId) {
1034         setUserInfoId_Term(userInfoId, null);
1035     }
1036 
1037     public void setUserInfoId_Equal(String userInfoId, ConditionOptionCall<TermQueryBuilder> opLambda) {
1038         setUserInfoId_Term(userInfoId, opLambda);
1039     }
1040 
1041     public void setUserInfoId_Term(String userInfoId) {
1042         setUserInfoId_Term(userInfoId, null);
1043     }
1044 
1045     public void setUserInfoId_Term(String userInfoId, ConditionOptionCall<TermQueryBuilder> opLambda) {
1046         TermQueryBuilder builder = regTermQ("userInfoId", userInfoId);
1047         if (opLambda != null) {
1048             opLambda.callback(builder);
1049         }
1050     }
1051 
1052     public void setUserInfoId_NotEqual(String userInfoId) {
1053         setUserInfoId_NotTerm(userInfoId, null);
1054     }
1055 
1056     public void setUserInfoId_NotTerm(String userInfoId) {
1057         setUserInfoId_NotTerm(userInfoId, null);
1058     }
1059 
1060     public void setUserInfoId_NotEqual(String userInfoId, ConditionOptionCall<BoolQueryBuilder> opLambda) {
1061         setUserInfoId_NotTerm(userInfoId, opLambda);
1062     }
1063 
1064     public void setUserInfoId_NotTerm(String userInfoId, ConditionOptionCall<BoolQueryBuilder> opLambda) {
1065         not(not -> not.setUserInfoId_Term(userInfoId), opLambda);
1066     }
1067 
1068     public void setUserInfoId_Terms(Collection<String> userInfoIdList) {
1069         setUserInfoId_Terms(userInfoIdList, null);
1070     }
1071 
1072     public void setUserInfoId_Terms(Collection<String> userInfoIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
1073         TermsQueryBuilder builder = regTermsQ("userInfoId", userInfoIdList);
1074         if (opLambda != null) {
1075             opLambda.callback(builder);
1076         }
1077     }
1078 
1079     public void setUserInfoId_InScope(Collection<String> userInfoIdList) {
1080         setUserInfoId_Terms(userInfoIdList, null);
1081     }
1082 
1083     public void setUserInfoId_InScope(Collection<String> userInfoIdList, ConditionOptionCall<TermsQueryBuilder> opLambda) {
1084         setUserInfoId_Terms(userInfoIdList, opLambda);
1085     }
1086 
1087     public void setUserInfoId_Match(String userInfoId) {
1088         setUserInfoId_Match(userInfoId, null);
1089     }
1090 
1091     public void setUserInfoId_Match(String userInfoId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
1092         MatchQueryBuilder builder = regMatchQ("userInfoId", userInfoId);
1093         if (opLambda != null) {
1094             opLambda.callback(builder);
1095         }
1096     }
1097 
1098     public void setUserInfoId_MatchPhrase(String userInfoId) {
1099         setUserInfoId_MatchPhrase(userInfoId, null);
1100     }
1101 
1102     public void setUserInfoId_MatchPhrase(String userInfoId, ConditionOptionCall<MatchPhraseQueryBuilder> opLambda) {
1103         MatchPhraseQueryBuilder builder = regMatchPhraseQ("userInfoId", userInfoId);
1104         if (opLambda != null) {
1105             opLambda.callback(builder);
1106         }
1107     }
1108 
1109     public void setUserInfoId_MatchPhrasePrefix(String userInfoId) {
1110         setUserInfoId_MatchPhrasePrefix(userInfoId, null);
1111     }
1112 
1113     public void setUserInfoId_MatchPhrasePrefix(String userInfoId, ConditionOptionCall<MatchPhrasePrefixQueryBuilder> opLambda) {
1114         MatchPhrasePrefixQueryBuilder builder = regMatchPhrasePrefixQ("userInfoId", userInfoId);
1115         if (opLambda != null) {
1116             opLambda.callback(builder);
1117         }
1118     }
1119 
1120     public void setUserInfoId_Fuzzy(String userInfoId) {
1121         setUserInfoId_Fuzzy(userInfoId, null);
1122     }
1123 
1124     public void setUserInfoId_Fuzzy(String userInfoId, ConditionOptionCall<MatchQueryBuilder> opLambda) {
1125         MatchQueryBuilder builder = regFuzzyQ("userInfoId", userInfoId);
1126         if (opLambda != null) {
1127             opLambda.callback(builder);
1128         }
1129     }
1130 
1131     public void setUserInfoId_Prefix(String userInfoId) {
1132         setUserInfoId_Prefix(userInfoId, null);
1133     }
1134 
1135     public void setUserInfoId_Prefix(String userInfoId, ConditionOptionCall<PrefixQueryBuilder> opLambda) {
1136         PrefixQueryBuilder builder = regPrefixQ("userInfoId", userInfoId);
1137         if (opLambda != null) {
1138             opLambda.callback(builder);
1139         }
1140     }
1141 
1142     public void setUserInfoId_Wildcard(String userInfoId) {
1143         setUserInfoId_Wildcard(userInfoId, null);
1144     }
1145 
1146     public void setUserInfoId_Wildcard(String userInfoId, ConditionOptionCall<WildcardQueryBuilder> opLambda) {
1147         WildcardQueryBuilder builder = regWildcardQ("userInfoId", userInfoId);
1148         if (opLambda != null) {
1149             opLambda.callback(builder);
1150         }
1151     }
1152 
1153     public void setUserInfoId_Regexp(String userInfoId) {
1154         setUserInfoId_Regexp(userInfoId, null);
1155     }
1156 
1157     public void setUserInfoId_Regexp(String userInfoId, ConditionOptionCall<RegexpQueryBuilder> opLambda) {
1158         RegexpQueryBuilder builder = regRegexpQ("userInfoId", userInfoId);
1159         if (opLambda != null) {
1160             opLambda.callback(builder);
1161         }
1162     }
1163 
1164     public void setUserInfoId_SpanTerm(String userInfoId) {
1165         setUserInfoId_SpanTerm("userInfoId", null);
1166     }
1167 
1168     public void setUserInfoId_SpanTerm(String userInfoId, ConditionOptionCall<SpanTermQueryBuilder> opLambda) {
1169         SpanTermQueryBuilder builder = regSpanTermQ("userInfoId", userInfoId);
1170         if (opLambda != null) {
1171             opLambda.callback(builder);
1172         }
1173     }
1174 
1175     public void setUserInfoId_GreaterThan(String userInfoId) {
1176         setUserInfoId_GreaterThan(userInfoId, null);
1177     }
1178 
1179     public void setUserInfoId_GreaterThan(String userInfoId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1180         final Object _value = userInfoId;
1181         RangeQueryBuilder builder = regRangeQ("userInfoId", ConditionKey.CK_GREATER_THAN, _value);
1182         if (opLambda != null) {
1183             opLambda.callback(builder);
1184         }
1185     }
1186 
1187     public void setUserInfoId_LessThan(String userInfoId) {
1188         setUserInfoId_LessThan(userInfoId, null);
1189     }
1190 
1191     public void setUserInfoId_LessThan(String userInfoId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1192         final Object _value = userInfoId;
1193         RangeQueryBuilder builder = regRangeQ("userInfoId", ConditionKey.CK_LESS_THAN, _value);
1194         if (opLambda != null) {
1195             opLambda.callback(builder);
1196         }
1197     }
1198 
1199     public void setUserInfoId_GreaterEqual(String userInfoId) {
1200         setUserInfoId_GreaterEqual(userInfoId, null);
1201     }
1202 
1203     public void setUserInfoId_GreaterEqual(String userInfoId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1204         final Object _value = userInfoId;
1205         RangeQueryBuilder builder = regRangeQ("userInfoId", ConditionKey.CK_GREATER_EQUAL, _value);
1206         if (opLambda != null) {
1207             opLambda.callback(builder);
1208         }
1209     }
1210 
1211     public void setUserInfoId_LessEqual(String userInfoId) {
1212         setUserInfoId_LessEqual(userInfoId, null);
1213     }
1214 
1215     public void setUserInfoId_LessEqual(String userInfoId, ConditionOptionCall<RangeQueryBuilder> opLambda) {
1216         final Object _value = userInfoId;
1217         RangeQueryBuilder builder = regRangeQ("userInfoId", ConditionKey.CK_LESS_EQUAL, _value);
1218         if (opLambda != null) {
1219             opLambda.callback(builder);
1220         }
1221     }
1222 
1223     public void setUserInfoId_Exists() {
1224         setUserInfoId_Exists(null);
1225     }
1226 
1227     public void setUserInfoId_Exists(ConditionOptionCall<ExistsQueryBuilder> opLambda) {
1228         ExistsQueryBuilder builder = regExistsQ("userInfoId");
1229         if (opLambda != null) {
1230             opLambda.callback(builder);
1231         }
1232     }
1233 
1234     public void setUserInfoId_CommonTerms(String userInfoId) {
1235         setUserInfoId_CommonTerms(userInfoId, null);
1236     }
1237 
1238     public void setUserInfoId_CommonTerms(String userInfoId, ConditionOptionCall<CommonTermsQueryBuilder> opLambda) {
1239         CommonTermsQueryBuilder builder = regCommonTermsQ("userInfoId", userInfoId);
1240         if (opLambda != null) {
1241             opLambda.callback(builder);
1242         }
1243     }
1244 
1245     public BsFavoriteLogCQ addOrderBy_UserInfoId_Asc() {
1246         regOBA("userInfoId");
1247         return this;
1248     }
1249 
1250     public BsFavoriteLogCQ addOrderBy_UserInfoId_Desc() {
1251         regOBD("userInfoId");
1252         return this;
1253     }
1254 
1255 }