1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 package org.codelibs.fess.es.log.cbean.ca.bs;
17
18 import org.codelibs.fess.es.log.allcommon.EsAbstractConditionAggregation;
19 import org.codelibs.fess.es.log.allcommon.EsAbstractConditionQuery;
20 import org.codelibs.fess.es.log.cbean.ca.FavoriteLogCA;
21 import org.codelibs.fess.es.log.cbean.cq.FavoriteLogCQ;
22 import org.codelibs.fess.es.log.cbean.cq.bs.BsFavoriteLogCQ;
23 import org.elasticsearch.search.aggregations.bucket.filter.FilterAggregationBuilder;
24 import org.elasticsearch.search.aggregations.bucket.global.GlobalAggregationBuilder;
25 import org.elasticsearch.search.aggregations.bucket.histogram.DateHistogramAggregationBuilder;
26 import org.elasticsearch.search.aggregations.bucket.missing.MissingAggregationBuilder;
27 import org.elasticsearch.search.aggregations.bucket.range.date.DateRangeAggregationBuilder;
28 import org.elasticsearch.search.aggregations.bucket.range.ip.IpRangeAggregationBuilder;
29 import org.elasticsearch.search.aggregations.bucket.sampler.SamplerAggregationBuilder;
30 import org.elasticsearch.search.aggregations.bucket.significant.SignificantTermsAggregationBuilder;
31 import org.elasticsearch.search.aggregations.bucket.terms.TermsAggregationBuilder;
32 import org.elasticsearch.search.aggregations.metrics.cardinality.CardinalityAggregationBuilder;
33 import org.elasticsearch.search.aggregations.metrics.scripted.ScriptedMetricAggregationBuilder;
34 import org.elasticsearch.search.aggregations.metrics.tophits.TopHitsAggregationBuilder;
35 import org.elasticsearch.search.aggregations.metrics.valuecount.ValueCountAggregationBuilder;
36
37
38
39
40 public abstract class BsFavoriteLogCA extends EsAbstractConditionAggregation {
41
42
43
44
45
46 public void filter(String name, EsAbstractConditionQuery.OperatorCall<BsFavoriteLogCQ> queryLambda,
47 ConditionOptionCall<FilterAggregationBuilder> opLambda, OperatorCall<BsFavoriteLogCA> aggsLambda) {
48 FavoriteLogCQ cq = new FavoriteLogCQ();
49 if (queryLambda != null) {
50 queryLambda.callback(cq);
51 }
52 FilterAggregationBuilder builder = regFilterA(name, cq.getQuery());
53 if (opLambda != null) {
54 opLambda.callback(builder);
55 }
56 if (aggsLambda != null) {
57 FavoriteLogCA ca = new FavoriteLogCA();
58 aggsLambda.callback(ca);
59 ca.getAggregationBuilderList().forEach(builder::subAggregation);
60 }
61 }
62
63 public void global(String name, ConditionOptionCall<GlobalAggregationBuilder> opLambda, OperatorCall<BsFavoriteLogCA> aggsLambda) {
64 GlobalAggregationBuilder builder = regGlobalA(name);
65 if (opLambda != null) {
66 opLambda.callback(builder);
67 }
68 if (aggsLambda != null) {
69 FavoriteLogCA ca = new FavoriteLogCA();
70 aggsLambda.callback(ca);
71 ca.getAggregationBuilderList().forEach(builder::subAggregation);
72 }
73 }
74
75 public void sampler(String name, ConditionOptionCall<SamplerAggregationBuilder> opLambda, OperatorCall<BsFavoriteLogCA> aggsLambda) {
76 SamplerAggregationBuilder builder = regSamplerA(name);
77 if (opLambda != null) {
78 opLambda.callback(builder);
79 }
80 if (aggsLambda != null) {
81 FavoriteLogCA ca = new FavoriteLogCA();
82 aggsLambda.callback(ca);
83 ca.getAggregationBuilderList().forEach(builder::subAggregation);
84 }
85 }
86
87 public void scriptedMetric(String name, ConditionOptionCall<ScriptedMetricAggregationBuilder> opLambda) {
88 ScriptedMetricAggregationBuilder builder = regScriptedMetricA(name);
89 if (opLambda != null) {
90 opLambda.callback(builder);
91 }
92 }
93
94 public void topHits(String name, ConditionOptionCall<TopHitsAggregationBuilder> opLambda) {
95 TopHitsAggregationBuilder builder = regTopHitsA(name);
96 if (opLambda != null) {
97 opLambda.callback(builder);
98 }
99 }
100
101 public void setCreatedAt_DateRange() {
102 setCreatedAt_DateRange(null);
103 }
104
105 public void setCreatedAt_DateRange(ConditionOptionCall<DateRangeAggregationBuilder> opLambda) {
106 setCreatedAt_DateRange("createdAt", opLambda, null);
107 }
108
109 public void setCreatedAt_DateRange(ConditionOptionCall<DateRangeAggregationBuilder> opLambda, OperatorCall<BsFavoriteLogCA> aggsLambda) {
110 setCreatedAt_DateRange("createdAt", opLambda, aggsLambda);
111 }
112
113 public void setCreatedAt_DateRange(String name, ConditionOptionCall<DateRangeAggregationBuilder> opLambda,
114 OperatorCall<BsFavoriteLogCA> aggsLambda) {
115 DateRangeAggregationBuilder builder = regDateRangeA(name, "createdAt");
116 if (opLambda != null) {
117 opLambda.callback(builder);
118 }
119 if (aggsLambda != null) {
120 FavoriteLogCA ca = new FavoriteLogCA();
121 aggsLambda.callback(ca);
122 ca.getAggregationBuilderList().forEach(builder::subAggregation);
123 }
124 }
125
126 public void setCreatedAt_DateHistogram() {
127 setCreatedAt_DateHistogram(null);
128 }
129
130 public void setCreatedAt_DateHistogram(ConditionOptionCall<DateHistogramAggregationBuilder> opLambda) {
131 setCreatedAt_DateHistogram("createdAt", opLambda, null);
132 }
133
134 public void setCreatedAt_DateHistogram(ConditionOptionCall<DateHistogramAggregationBuilder> opLambda,
135 OperatorCall<BsFavoriteLogCA> aggsLambda) {
136 setCreatedAt_DateHistogram("createdAt", opLambda, aggsLambda);
137 }
138
139 public void setCreatedAt_DateHistogram(String name, ConditionOptionCall<DateHistogramAggregationBuilder> opLambda,
140 OperatorCall<BsFavoriteLogCA> aggsLambda) {
141 DateHistogramAggregationBuilder builder = regDateHistogramA(name, "createdAt");
142 if (opLambda != null) {
143 opLambda.callback(builder);
144 }
145 if (aggsLambda != null) {
146 FavoriteLogCA ca = new FavoriteLogCA();
147 aggsLambda.callback(ca);
148 ca.getAggregationBuilderList().forEach(builder::subAggregation);
149 }
150 }
151
152 public void setCreatedAt_Count() {
153 setCreatedAt_Count(null);
154 }
155
156 public void setCreatedAt_Count(ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
157 setCreatedAt_Count("createdAt", opLambda);
158 }
159
160 public void setCreatedAt_Count(String name, ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
161 ValueCountAggregationBuilder builder = regCountA(name, "createdAt");
162 if (opLambda != null) {
163 opLambda.callback(builder);
164 }
165 }
166
167 public void setCreatedAt_Cardinality() {
168 setCreatedAt_Cardinality(null);
169 }
170
171 public void setCreatedAt_Cardinality(ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
172 setCreatedAt_Cardinality("createdAt", opLambda);
173 }
174
175 public void setCreatedAt_Cardinality(String name, ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
176 CardinalityAggregationBuilder builder = regCardinalityA(name, "createdAt");
177 if (opLambda != null) {
178 opLambda.callback(builder);
179 }
180 }
181
182 public void setCreatedAt_Missing() {
183 setCreatedAt_Missing(null);
184 }
185
186 public void setCreatedAt_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda) {
187 setCreatedAt_Missing("createdAt", opLambda, null);
188 }
189
190 public void setCreatedAt_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda, OperatorCall<BsFavoriteLogCA> aggsLambda) {
191 setCreatedAt_Missing("createdAt", opLambda, aggsLambda);
192 }
193
194 public void setCreatedAt_Missing(String name, ConditionOptionCall<MissingAggregationBuilder> opLambda,
195 OperatorCall<BsFavoriteLogCA> aggsLambda) {
196 MissingAggregationBuilder builder = regMissingA(name, "createdAt");
197 if (opLambda != null) {
198 opLambda.callback(builder);
199 }
200 if (aggsLambda != null) {
201 FavoriteLogCA ca = new FavoriteLogCA();
202 aggsLambda.callback(ca);
203 ca.getAggregationBuilderList().forEach(builder::subAggregation);
204 }
205 }
206
207 public void setUrl_Terms() {
208 setUrl_Terms(null);
209 }
210
211 public void setUrl_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda) {
212 setUrl_Terms("url", opLambda, null);
213 }
214
215 public void setUrl_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda, OperatorCall<BsFavoriteLogCA> aggsLambda) {
216 setUrl_Terms("url", opLambda, aggsLambda);
217 }
218
219 public void setUrl_Terms(String name, ConditionOptionCall<TermsAggregationBuilder> opLambda, OperatorCall<BsFavoriteLogCA> aggsLambda) {
220 TermsAggregationBuilder builder = regTermsA(name, "url");
221 if (opLambda != null) {
222 opLambda.callback(builder);
223 }
224 if (aggsLambda != null) {
225 FavoriteLogCA ca = new FavoriteLogCA();
226 aggsLambda.callback(ca);
227 ca.getAggregationBuilderList().forEach(builder::subAggregation);
228 }
229 }
230
231 public void setUrl_SignificantTerms() {
232 setUrl_SignificantTerms(null);
233 }
234
235 public void setUrl_SignificantTerms(ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda) {
236 setUrl_SignificantTerms("url", opLambda, null);
237 }
238
239 public void setUrl_SignificantTerms(ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda,
240 OperatorCall<BsFavoriteLogCA> aggsLambda) {
241 setUrl_SignificantTerms("url", opLambda, aggsLambda);
242 }
243
244 public void setUrl_SignificantTerms(String name, ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda,
245 OperatorCall<BsFavoriteLogCA> aggsLambda) {
246 SignificantTermsAggregationBuilder builder = regSignificantTermsA(name, "url");
247 if (opLambda != null) {
248 opLambda.callback(builder);
249 }
250 if (aggsLambda != null) {
251 FavoriteLogCA ca = new FavoriteLogCA();
252 aggsLambda.callback(ca);
253 ca.getAggregationBuilderList().forEach(builder::subAggregation);
254 }
255 }
256
257 public void setUrl_IpRange() {
258 setUrl_IpRange(null);
259 }
260
261 public void setUrl_IpRange(ConditionOptionCall<IpRangeAggregationBuilder> opLambda) {
262 setUrl_IpRange("url", opLambda, null);
263 }
264
265 public void setUrl_IpRange(ConditionOptionCall<IpRangeAggregationBuilder> opLambda, OperatorCall<BsFavoriteLogCA> aggsLambda) {
266 setUrl_IpRange("url", opLambda, aggsLambda);
267 }
268
269 public void setUrl_IpRange(String name, ConditionOptionCall<IpRangeAggregationBuilder> opLambda,
270 OperatorCall<BsFavoriteLogCA> aggsLambda) {
271 IpRangeAggregationBuilder builder = regIpRangeA(name, "url");
272 if (opLambda != null) {
273 opLambda.callback(builder);
274 }
275 if (aggsLambda != null) {
276 FavoriteLogCA ca = new FavoriteLogCA();
277 aggsLambda.callback(ca);
278 ca.getAggregationBuilderList().forEach(builder::subAggregation);
279 }
280 }
281
282 public void setUrl_Count() {
283 setUrl_Count(null);
284 }
285
286 public void setUrl_Count(ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
287 setUrl_Count("url", opLambda);
288 }
289
290 public void setUrl_Count(String name, ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
291 ValueCountAggregationBuilder builder = regCountA(name, "url");
292 if (opLambda != null) {
293 opLambda.callback(builder);
294 }
295 }
296
297 public void setUrl_Cardinality() {
298 setUrl_Cardinality(null);
299 }
300
301 public void setUrl_Cardinality(ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
302 setUrl_Cardinality("url", opLambda);
303 }
304
305 public void setUrl_Cardinality(String name, ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
306 CardinalityAggregationBuilder builder = regCardinalityA(name, "url");
307 if (opLambda != null) {
308 opLambda.callback(builder);
309 }
310 }
311
312 public void setUrl_Missing() {
313 setUrl_Missing(null);
314 }
315
316 public void setUrl_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda) {
317 setUrl_Missing("url", opLambda, null);
318 }
319
320 public void setUrl_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda, OperatorCall<BsFavoriteLogCA> aggsLambda) {
321 setUrl_Missing("url", opLambda, aggsLambda);
322 }
323
324 public void setUrl_Missing(String name, ConditionOptionCall<MissingAggregationBuilder> opLambda,
325 OperatorCall<BsFavoriteLogCA> aggsLambda) {
326 MissingAggregationBuilder builder = regMissingA(name, "url");
327 if (opLambda != null) {
328 opLambda.callback(builder);
329 }
330 if (aggsLambda != null) {
331 FavoriteLogCA ca = new FavoriteLogCA();
332 aggsLambda.callback(ca);
333 ca.getAggregationBuilderList().forEach(builder::subAggregation);
334 }
335 }
336
337 public void setDocId_Terms() {
338 setDocId_Terms(null);
339 }
340
341 public void setDocId_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda) {
342 setDocId_Terms("docId", opLambda, null);
343 }
344
345 public void setDocId_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda, OperatorCall<BsFavoriteLogCA> aggsLambda) {
346 setDocId_Terms("docId", opLambda, aggsLambda);
347 }
348
349 public void setDocId_Terms(String name, ConditionOptionCall<TermsAggregationBuilder> opLambda, OperatorCall<BsFavoriteLogCA> aggsLambda) {
350 TermsAggregationBuilder builder = regTermsA(name, "docId");
351 if (opLambda != null) {
352 opLambda.callback(builder);
353 }
354 if (aggsLambda != null) {
355 FavoriteLogCA ca = new FavoriteLogCA();
356 aggsLambda.callback(ca);
357 ca.getAggregationBuilderList().forEach(builder::subAggregation);
358 }
359 }
360
361 public void setDocId_SignificantTerms() {
362 setDocId_SignificantTerms(null);
363 }
364
365 public void setDocId_SignificantTerms(ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda) {
366 setDocId_SignificantTerms("docId", opLambda, null);
367 }
368
369 public void setDocId_SignificantTerms(ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda,
370 OperatorCall<BsFavoriteLogCA> aggsLambda) {
371 setDocId_SignificantTerms("docId", opLambda, aggsLambda);
372 }
373
374 public void setDocId_SignificantTerms(String name, ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda,
375 OperatorCall<BsFavoriteLogCA> aggsLambda) {
376 SignificantTermsAggregationBuilder builder = regSignificantTermsA(name, "docId");
377 if (opLambda != null) {
378 opLambda.callback(builder);
379 }
380 if (aggsLambda != null) {
381 FavoriteLogCA ca = new FavoriteLogCA();
382 aggsLambda.callback(ca);
383 ca.getAggregationBuilderList().forEach(builder::subAggregation);
384 }
385 }
386
387 public void setDocId_IpRange() {
388 setDocId_IpRange(null);
389 }
390
391 public void setDocId_IpRange(ConditionOptionCall<IpRangeAggregationBuilder> opLambda) {
392 setDocId_IpRange("docId", opLambda, null);
393 }
394
395 public void setDocId_IpRange(ConditionOptionCall<IpRangeAggregationBuilder> opLambda, OperatorCall<BsFavoriteLogCA> aggsLambda) {
396 setDocId_IpRange("docId", opLambda, aggsLambda);
397 }
398
399 public void setDocId_IpRange(String name, ConditionOptionCall<IpRangeAggregationBuilder> opLambda,
400 OperatorCall<BsFavoriteLogCA> aggsLambda) {
401 IpRangeAggregationBuilder builder = regIpRangeA(name, "docId");
402 if (opLambda != null) {
403 opLambda.callback(builder);
404 }
405 if (aggsLambda != null) {
406 FavoriteLogCA ca = new FavoriteLogCA();
407 aggsLambda.callback(ca);
408 ca.getAggregationBuilderList().forEach(builder::subAggregation);
409 }
410 }
411
412 public void setDocId_Count() {
413 setDocId_Count(null);
414 }
415
416 public void setDocId_Count(ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
417 setDocId_Count("docId", opLambda);
418 }
419
420 public void setDocId_Count(String name, ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
421 ValueCountAggregationBuilder builder = regCountA(name, "docId");
422 if (opLambda != null) {
423 opLambda.callback(builder);
424 }
425 }
426
427 public void setDocId_Cardinality() {
428 setDocId_Cardinality(null);
429 }
430
431 public void setDocId_Cardinality(ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
432 setDocId_Cardinality("docId", opLambda);
433 }
434
435 public void setDocId_Cardinality(String name, ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
436 CardinalityAggregationBuilder builder = regCardinalityA(name, "docId");
437 if (opLambda != null) {
438 opLambda.callback(builder);
439 }
440 }
441
442 public void setDocId_Missing() {
443 setDocId_Missing(null);
444 }
445
446 public void setDocId_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda) {
447 setDocId_Missing("docId", opLambda, null);
448 }
449
450 public void setDocId_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda, OperatorCall<BsFavoriteLogCA> aggsLambda) {
451 setDocId_Missing("docId", opLambda, aggsLambda);
452 }
453
454 public void setDocId_Missing(String name, ConditionOptionCall<MissingAggregationBuilder> opLambda,
455 OperatorCall<BsFavoriteLogCA> aggsLambda) {
456 MissingAggregationBuilder builder = regMissingA(name, "docId");
457 if (opLambda != null) {
458 opLambda.callback(builder);
459 }
460 if (aggsLambda != null) {
461 FavoriteLogCA ca = new FavoriteLogCA();
462 aggsLambda.callback(ca);
463 ca.getAggregationBuilderList().forEach(builder::subAggregation);
464 }
465 }
466
467 public void setQueryId_Terms() {
468 setQueryId_Terms(null);
469 }
470
471 public void setQueryId_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda) {
472 setQueryId_Terms("queryId", opLambda, null);
473 }
474
475 public void setQueryId_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda, OperatorCall<BsFavoriteLogCA> aggsLambda) {
476 setQueryId_Terms("queryId", opLambda, aggsLambda);
477 }
478
479 public void setQueryId_Terms(String name, ConditionOptionCall<TermsAggregationBuilder> opLambda,
480 OperatorCall<BsFavoriteLogCA> aggsLambda) {
481 TermsAggregationBuilder builder = regTermsA(name, "queryId");
482 if (opLambda != null) {
483 opLambda.callback(builder);
484 }
485 if (aggsLambda != null) {
486 FavoriteLogCA ca = new FavoriteLogCA();
487 aggsLambda.callback(ca);
488 ca.getAggregationBuilderList().forEach(builder::subAggregation);
489 }
490 }
491
492 public void setQueryId_SignificantTerms() {
493 setQueryId_SignificantTerms(null);
494 }
495
496 public void setQueryId_SignificantTerms(ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda) {
497 setQueryId_SignificantTerms("queryId", opLambda, null);
498 }
499
500 public void setQueryId_SignificantTerms(ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda,
501 OperatorCall<BsFavoriteLogCA> aggsLambda) {
502 setQueryId_SignificantTerms("queryId", opLambda, aggsLambda);
503 }
504
505 public void setQueryId_SignificantTerms(String name, ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda,
506 OperatorCall<BsFavoriteLogCA> aggsLambda) {
507 SignificantTermsAggregationBuilder builder = regSignificantTermsA(name, "queryId");
508 if (opLambda != null) {
509 opLambda.callback(builder);
510 }
511 if (aggsLambda != null) {
512 FavoriteLogCA ca = new FavoriteLogCA();
513 aggsLambda.callback(ca);
514 ca.getAggregationBuilderList().forEach(builder::subAggregation);
515 }
516 }
517
518 public void setQueryId_IpRange() {
519 setQueryId_IpRange(null);
520 }
521
522 public void setQueryId_IpRange(ConditionOptionCall<IpRangeAggregationBuilder> opLambda) {
523 setQueryId_IpRange("queryId", opLambda, null);
524 }
525
526 public void setQueryId_IpRange(ConditionOptionCall<IpRangeAggregationBuilder> opLambda, OperatorCall<BsFavoriteLogCA> aggsLambda) {
527 setQueryId_IpRange("queryId", opLambda, aggsLambda);
528 }
529
530 public void setQueryId_IpRange(String name, ConditionOptionCall<IpRangeAggregationBuilder> opLambda,
531 OperatorCall<BsFavoriteLogCA> aggsLambda) {
532 IpRangeAggregationBuilder builder = regIpRangeA(name, "queryId");
533 if (opLambda != null) {
534 opLambda.callback(builder);
535 }
536 if (aggsLambda != null) {
537 FavoriteLogCA ca = new FavoriteLogCA();
538 aggsLambda.callback(ca);
539 ca.getAggregationBuilderList().forEach(builder::subAggregation);
540 }
541 }
542
543 public void setQueryId_Count() {
544 setQueryId_Count(null);
545 }
546
547 public void setQueryId_Count(ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
548 setQueryId_Count("queryId", opLambda);
549 }
550
551 public void setQueryId_Count(String name, ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
552 ValueCountAggregationBuilder builder = regCountA(name, "queryId");
553 if (opLambda != null) {
554 opLambda.callback(builder);
555 }
556 }
557
558 public void setQueryId_Cardinality() {
559 setQueryId_Cardinality(null);
560 }
561
562 public void setQueryId_Cardinality(ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
563 setQueryId_Cardinality("queryId", opLambda);
564 }
565
566 public void setQueryId_Cardinality(String name, ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
567 CardinalityAggregationBuilder builder = regCardinalityA(name, "queryId");
568 if (opLambda != null) {
569 opLambda.callback(builder);
570 }
571 }
572
573 public void setQueryId_Missing() {
574 setQueryId_Missing(null);
575 }
576
577 public void setQueryId_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda) {
578 setQueryId_Missing("queryId", opLambda, null);
579 }
580
581 public void setQueryId_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda, OperatorCall<BsFavoriteLogCA> aggsLambda) {
582 setQueryId_Missing("queryId", opLambda, aggsLambda);
583 }
584
585 public void setQueryId_Missing(String name, ConditionOptionCall<MissingAggregationBuilder> opLambda,
586 OperatorCall<BsFavoriteLogCA> aggsLambda) {
587 MissingAggregationBuilder builder = regMissingA(name, "queryId");
588 if (opLambda != null) {
589 opLambda.callback(builder);
590 }
591 if (aggsLambda != null) {
592 FavoriteLogCA ca = new FavoriteLogCA();
593 aggsLambda.callback(ca);
594 ca.getAggregationBuilderList().forEach(builder::subAggregation);
595 }
596 }
597
598 public void setUserInfoId_Terms() {
599 setUserInfoId_Terms(null);
600 }
601
602 public void setUserInfoId_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda) {
603 setUserInfoId_Terms("userInfoId", opLambda, null);
604 }
605
606 public void setUserInfoId_Terms(ConditionOptionCall<TermsAggregationBuilder> opLambda, OperatorCall<BsFavoriteLogCA> aggsLambda) {
607 setUserInfoId_Terms("userInfoId", opLambda, aggsLambda);
608 }
609
610 public void setUserInfoId_Terms(String name, ConditionOptionCall<TermsAggregationBuilder> opLambda,
611 OperatorCall<BsFavoriteLogCA> aggsLambda) {
612 TermsAggregationBuilder builder = regTermsA(name, "userInfoId");
613 if (opLambda != null) {
614 opLambda.callback(builder);
615 }
616 if (aggsLambda != null) {
617 FavoriteLogCA ca = new FavoriteLogCA();
618 aggsLambda.callback(ca);
619 ca.getAggregationBuilderList().forEach(builder::subAggregation);
620 }
621 }
622
623 public void setUserInfoId_SignificantTerms() {
624 setUserInfoId_SignificantTerms(null);
625 }
626
627 public void setUserInfoId_SignificantTerms(ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda) {
628 setUserInfoId_SignificantTerms("userInfoId", opLambda, null);
629 }
630
631 public void setUserInfoId_SignificantTerms(ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda,
632 OperatorCall<BsFavoriteLogCA> aggsLambda) {
633 setUserInfoId_SignificantTerms("userInfoId", opLambda, aggsLambda);
634 }
635
636 public void setUserInfoId_SignificantTerms(String name, ConditionOptionCall<SignificantTermsAggregationBuilder> opLambda,
637 OperatorCall<BsFavoriteLogCA> aggsLambda) {
638 SignificantTermsAggregationBuilder builder = regSignificantTermsA(name, "userInfoId");
639 if (opLambda != null) {
640 opLambda.callback(builder);
641 }
642 if (aggsLambda != null) {
643 FavoriteLogCA ca = new FavoriteLogCA();
644 aggsLambda.callback(ca);
645 ca.getAggregationBuilderList().forEach(builder::subAggregation);
646 }
647 }
648
649 public void setUserInfoId_IpRange() {
650 setUserInfoId_IpRange(null);
651 }
652
653 public void setUserInfoId_IpRange(ConditionOptionCall<IpRangeAggregationBuilder> opLambda) {
654 setUserInfoId_IpRange("userInfoId", opLambda, null);
655 }
656
657 public void setUserInfoId_IpRange(ConditionOptionCall<IpRangeAggregationBuilder> opLambda, OperatorCall<BsFavoriteLogCA> aggsLambda) {
658 setUserInfoId_IpRange("userInfoId", opLambda, aggsLambda);
659 }
660
661 public void setUserInfoId_IpRange(String name, ConditionOptionCall<IpRangeAggregationBuilder> opLambda,
662 OperatorCall<BsFavoriteLogCA> aggsLambda) {
663 IpRangeAggregationBuilder builder = regIpRangeA(name, "userInfoId");
664 if (opLambda != null) {
665 opLambda.callback(builder);
666 }
667 if (aggsLambda != null) {
668 FavoriteLogCA ca = new FavoriteLogCA();
669 aggsLambda.callback(ca);
670 ca.getAggregationBuilderList().forEach(builder::subAggregation);
671 }
672 }
673
674 public void setUserInfoId_Count() {
675 setUserInfoId_Count(null);
676 }
677
678 public void setUserInfoId_Count(ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
679 setUserInfoId_Count("userInfoId", opLambda);
680 }
681
682 public void setUserInfoId_Count(String name, ConditionOptionCall<ValueCountAggregationBuilder> opLambda) {
683 ValueCountAggregationBuilder builder = regCountA(name, "userInfoId");
684 if (opLambda != null) {
685 opLambda.callback(builder);
686 }
687 }
688
689 public void setUserInfoId_Cardinality() {
690 setUserInfoId_Cardinality(null);
691 }
692
693 public void setUserInfoId_Cardinality(ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
694 setUserInfoId_Cardinality("userInfoId", opLambda);
695 }
696
697 public void setUserInfoId_Cardinality(String name, ConditionOptionCall<CardinalityAggregationBuilder> opLambda) {
698 CardinalityAggregationBuilder builder = regCardinalityA(name, "userInfoId");
699 if (opLambda != null) {
700 opLambda.callback(builder);
701 }
702 }
703
704 public void setUserInfoId_Missing() {
705 setUserInfoId_Missing(null);
706 }
707
708 public void setUserInfoId_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda) {
709 setUserInfoId_Missing("userInfoId", opLambda, null);
710 }
711
712 public void setUserInfoId_Missing(ConditionOptionCall<MissingAggregationBuilder> opLambda, OperatorCall<BsFavoriteLogCA> aggsLambda) {
713 setUserInfoId_Missing("userInfoId", opLambda, aggsLambda);
714 }
715
716 public void setUserInfoId_Missing(String name, ConditionOptionCall<MissingAggregationBuilder> opLambda,
717 OperatorCall<BsFavoriteLogCA> aggsLambda) {
718 MissingAggregationBuilder builder = regMissingA(name, "userInfoId");
719 if (opLambda != null) {
720 opLambda.callback(builder);
721 }
722 if (aggsLambda != null) {
723 FavoriteLogCA ca = new FavoriteLogCA();
724 aggsLambda.callback(ca);
725 ca.getAggregationBuilderList().forEach(builder::subAggregation);
726 }
727 }
728
729 }