001/*
002 * Copyright (c) 2007-2017 Xplenty, Inc. All Rights Reserved.
003 *
004 * Project and contact information: http://www.cascading.org/
005 *
006 * This file is part of the Cascading project.
007 *
008 * Licensed under the Apache License, Version 2.0 (the "License");
009 * you may not use this file except in compliance with the License.
010 * You may obtain a copy of the License at
011 *
012 *     http://www.apache.org/licenses/LICENSE-2.0
013 *
014 * Unless required by applicable law or agreed to in writing, software
015 * distributed under the License is distributed on an "AS IS" BASIS,
016 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
017 * See the License for the specific language governing permissions and
018 * limitations under the License.
019 */
020
021package cascading.pipe;
022
023import java.beans.ConstructorProperties;
024
025import cascading.pipe.joiner.Joiner;
026import cascading.tuple.Fields;
027
028/**
029 * The CoGroup pipe allows for two or more tuple streams to join into a single stream via an optional {@link Joiner}.
030 * <p/>
031 * If followed by an assembly of {@link Every}s to execute one or more {@link cascading.operation.Aggregator}s,
032 * they will be guaranteed to receive all values associated with a
033 * unique grouping key. In the case of a MapReduce platform, this invokes a {@code Reduce} task to guarantee
034 * all values are associated with a given unique grouping key.
035 * <p/>
036 * If no aggregations are to be performed, and one or more streams of data are small (may fit in reasonable memory),
037 * see the {@link HashJoin} Pipe for partially non-blocking joins.
038 * <p/>
039 * For every incoming {@link Pipe} instance, a {@link Fields} instance must be specified that denotes the field names
040 * or positions that should be co-grouped with the other given Pipe instances. If the incoming Pipe instances declare
041 * one or more field with the same name, the declaredFields must be given to name all the outgoing Tuple stream fields
042 * to overcome field name collisions. That is, if the first pipe has 4 fields, and the second pipe has 3 fields, 7 fields
043 * total must be declared having unique field names, if any.
044 * <p/>
045 * {@code resultGroupFields} value is a convenience allowing the override of the resulting grouping field names. The
046 * size of resultGroupFields must be equal to the total number of grouping keys fields. That is, if joining on two pipes
047 * which are grouping on two keys, the resultGroupFields must be 4 fields, each field field name being unique, if any.
048 * By default, the resultGroupKeys are retrieved from the declaredFields.
049 * <p/>
050 * By default CoGroup performs an inner join via the {@link cascading.pipe.joiner.InnerJoin}
051 * {@link cascading.pipe.joiner.Joiner} class.
052 * <p/>
053 * To implement a custom join, implement the {@link Joiner} interface. Or, as of Cascading 2.5, use a
054 * {@link cascading.pipe.joiner.BufferJoin} and implement the join in a {@link cascading.operation.Buffer}.
055 * <p/>
056 * Self joins can be achieved by using a constructor that takes a single Pipe and a numSelfJoins value. A value of
057 * 1 for numSelfJoins will join the Pipe with itself once.
058 * <p/>
059 * The outgoing grouping Tuple stream is sorted by the natural order of the grouping fields. To control this order,
060 * at least the first groupingFields value given should be an instance of {@link cascading.tuple.Fields} containing
061 * {@link java.util.Comparator} instances for the appropriate fields.
062 * This allows fine grained control of the sort grouping order.
063 * <p/>
064 * CoGrouping does not scale well when implemented over MapReduce. In Cascading there are two
065 * ways to optimize CoGrouping.
066 * <p/>
067 * The first is to consider the order of the pipes handed to the CoGroup constructor.
068 * <p/>
069 * During co-grouping, for any given unique grouping key, all of the rightmost pipes will accumulate the current
070 * grouping values into memory so they may be iterated across for every value in the left hand side pipe. During
071 * the accumulation step, if the number of values exceeds the {@link cascading.tuple.collect.SpillableTupleList} threshold
072 * value, those values will be spilled to disk so the accumulation may continue.
073 * <p/>
074 * See the {@link cascading.tuple.collect.TupleCollectionFactory} and {@link cascading.tuple.collect.TupleMapFactory} for a means
075 * to use alternative spillable types.
076 * <p/>
077 * There is no accumulation for the left hand side pipe, only for those to the "right".
078 * <p/>
079 * Thus, for the pipe that has the largest number of values per unique key grouping, on average, it should be made the
080 * "left hand side" pipe ({@code lhs}). And all remaining pipes should be the on the "right hand side" ({@code rhs}) to
081 * prevent the likelihood of a spill and to reduce the blocking associated with accumulating the values. If using
082 * the {@code Pipe[]} constructor, {@code Pipe[0]} is the left hand sided pipe.
083 * <p/>
084 * If spills are happening, consider increasing the spill threshold, see {@link cascading.tuple.collect.SpillableTupleList},
085 * if more RAM is available. See the logs for hints on how much more these values can be increased, if any.
086 * <p/>
087 * Spills are intended to prevent {@link OutOfMemoryError}'s, so reducing the number of spills is important by
088 * increasing the threshold, but memory errors aren't recoverable, so the correct balance will need to be found.
089 * <p/>
090 * To customize the spill values for a given CoGroup only, see {@link #getStepConfigDef()}.
091 * <p/>
092 * See the {@link cascading.tuple.Hasher} interface when a custom {@link java.util.Comparator} on the grouping keys is
093 * being provided that makes two values with differing hashCode values equal. For example,
094 * {@code new BigDecimal( 100.0D )} and {@code new Double 100.0D )} are equal using a custom Comparator, but
095 * {@link Object#hashCode()} will be different, thus forcing each value into differing partitions.
096 * <p/>
097 * Currently "non-equi-joins" are not supported via the Hasher and Comparator interfaces. That is, joining one String
098 * key with a lowercase value with another String key with an uppercase value using a "case insensitive" Comparator
099 * will not have consistent results. The join will execute and be correct, but the actual values in the key columns may
100 * be replaced with "equivalent" values from other streams.
101 * <p/>
102 * If the original key values must be retained, consider normalizing the keys with a Function and then joining on the
103 * resulting field.
104 *
105 * @see cascading.pipe.joiner.InnerJoin
106 * @see cascading.pipe.joiner.OuterJoin
107 * @see cascading.pipe.joiner.LeftJoin
108 * @see cascading.pipe.joiner.RightJoin
109 * @see cascading.pipe.joiner.MixedJoin
110 * @see cascading.pipe.joiner.BufferJoin
111 * @see cascading.tuple.Fields
112 * @see cascading.tuple.collect.SpillableTupleList
113 */
114public class CoGroup extends Splice implements Group
115  {
116  /**
117   * Constructor CoGroup creates a new CoGroup instance.
118   *
119   * @param lhs            of type Pipe
120   * @param lhsGroupFields of type Fields
121   * @param rhs            of type Pipe
122   * @param rhsGroupFields of type Fields
123   * @param declaredFields of type Fields
124   */
125  @ConstructorProperties({"lhs", "lhsGroupFields", "rhs", "rhsGroupFields", "declaredFields"})
126  public CoGroup( Pipe lhs, Fields lhsGroupFields, Pipe rhs, Fields rhsGroupFields, Fields declaredFields )
127    {
128    super( lhs, lhsGroupFields, rhs, rhsGroupFields, declaredFields );
129    }
130
131  /**
132   * Constructor CoGroup creates a new CoGroup instance.
133   *
134   * @param lhs               of type Pipe
135   * @param lhsGroupFields    of type Fields
136   * @param rhs               of type Pipe
137   * @param rhsGroupFields    of type Fields
138   * @param declaredFields    of type Fields
139   * @param resultGroupFields of type Fields
140   */
141  @ConstructorProperties({"lhs", "lhsGroupFields", "rhs", "rhsGroupFields", "declaredFields", "resultGroupFields"})
142  public CoGroup( Pipe lhs, Fields lhsGroupFields, Pipe rhs, Fields rhsGroupFields, Fields declaredFields, Fields resultGroupFields )
143    {
144    super( lhs, lhsGroupFields, rhs, rhsGroupFields, declaredFields, resultGroupFields );
145    }
146
147  /**
148   * Constructor CoGroup creates a new CoGroup instance.
149   *
150   * @param lhs            of type Pipe
151   * @param lhsGroupFields of type Fields
152   * @param rhs            of type Pipe
153   * @param rhsGroupFields of type Fields
154   * @param declaredFields of type Fields
155   * @param joiner         of type CoGrouper
156   */
157  @ConstructorProperties({"lhs", "lhsGroupFields", "rhs", "rhsGroupFields", "declaredFields", "joiner"})
158  public CoGroup( Pipe lhs, Fields lhsGroupFields, Pipe rhs, Fields rhsGroupFields, Fields declaredFields, Joiner joiner )
159    {
160    super( lhs, lhsGroupFields, rhs, rhsGroupFields, declaredFields, joiner );
161    }
162
163  /**
164   * Constructor CoGroup creates a new CoGroup instance.
165   *
166   * @param lhs               of type Pipe
167   * @param lhsGroupFields    of type Fields
168   * @param rhs               of type Pipe
169   * @param rhsGroupFields    of type Fields
170   * @param declaredFields    of type Fields
171   * @param resultGroupFields of type Fields
172   * @param joiner            of type Joiner
173   */
174  @ConstructorProperties({"lhs", "lhsGroupFields", "rhs", "rhsGroupFields", "declaredFields", "resultGroupFields",
175                          "joiner"})
176  public CoGroup( Pipe lhs, Fields lhsGroupFields, Pipe rhs, Fields rhsGroupFields, Fields declaredFields, Fields resultGroupFields, Joiner joiner )
177    {
178    super( lhs, lhsGroupFields, rhs, rhsGroupFields, declaredFields, resultGroupFields, joiner );
179    }
180
181  /**
182   * Constructor CoGroup creates a new CoGroup instance.
183   *
184   * @param lhs            of type Pipe
185   * @param lhsGroupFields of type Fields
186   * @param rhs            of type Pipe
187   * @param rhsGroupFields of type Fields
188   * @param joiner         of type CoGrouper
189   */
190  @ConstructorProperties({"lhs", "lhsGroupFields", "rhs", "rhsGroupFields", "joiner"})
191  public CoGroup( Pipe lhs, Fields lhsGroupFields, Pipe rhs, Fields rhsGroupFields, Joiner joiner )
192    {
193    super( lhs, lhsGroupFields, rhs, rhsGroupFields, joiner );
194    }
195
196  /**
197   * Constructor CoGroup creates a new CoGroup instance.
198   *
199   * @param lhs            of type Pipe
200   * @param lhsGroupFields of type Fields
201   * @param rhs            of type Pipe
202   * @param rhsGroupFields of type Fields
203   */
204  @ConstructorProperties({"lhs", "lhsGroupFields", "rhs", "rhsGroupFields"})
205  public CoGroup( Pipe lhs, Fields lhsGroupFields, Pipe rhs, Fields rhsGroupFields )
206    {
207    super( lhs, lhsGroupFields, rhs, rhsGroupFields );
208    }
209
210  /**
211   * Constructor CoGroup creates a new CoGroup instance.
212   *
213   * @param pipes of type Pipe...
214   */
215  @ConstructorProperties({"pipes"})
216  public CoGroup( Pipe... pipes )
217    {
218    super( pipes );
219    }
220
221  /**
222   * Constructor CoGroup creates a new CoGroup instance.
223   *
224   * @param pipes       of type Pipe[]
225   * @param groupFields of type Fields[]
226   */
227  @ConstructorProperties({"pipes", "groupFields"})
228  public CoGroup( Pipe[] pipes, Fields[] groupFields )
229    {
230    super( pipes, groupFields );
231    }
232
233  /**
234   * Constructor CoGroup creates a new CoGroup instance.
235   *
236   * @param pipes          of type Pipe[]
237   * @param groupFields    of type Fields[]
238   * @param declaredFields of type Fields
239   * @param joiner         of type CoGrouper
240   */
241  @ConstructorProperties({"pipes", "groupFields", "declaredFields", "joiner"})
242  public CoGroup( Pipe[] pipes, Fields[] groupFields, Fields declaredFields, Joiner joiner )
243    {
244    super( pipes, groupFields, declaredFields, joiner );
245    }
246
247  /**
248   * Constructor CoGroup creates a new CoGroup instance.
249   *
250   * @param pipes             of type Pipe[]
251   * @param groupFields       of type Fields[]
252   * @param declaredFields    of type Fields
253   * @param resultGroupFields of type Fields
254   * @param joiner            of type Joiner
255   */
256  @ConstructorProperties({"pipes", "groupFields", "declaredFields", "resultGroupFields", "joiner"})
257  public CoGroup( Pipe[] pipes, Fields[] groupFields, Fields declaredFields, Fields resultGroupFields, Joiner joiner )
258    {
259    super( pipes, groupFields, declaredFields, resultGroupFields, joiner );
260    }
261
262  /**
263   * Constructor CoGroup creates a new CoGroup instance.
264   *
265   * @param groupName   of type String
266   * @param pipes       of type Pipe[]
267   * @param groupFields of type Fields[]
268   */
269  @ConstructorProperties({"groupName", "pipes", "groupFields"})
270  public CoGroup( String groupName, Pipe[] pipes, Fields[] groupFields )
271    {
272    super( groupName, pipes, groupFields );
273    }
274
275  /**
276   * Constructor CoGroup creates a new CoGroup instance.
277   *
278   * @param groupName      of type String
279   * @param pipes          of type Pipe[]
280   * @param groupFields    of type Fields[]
281   * @param declaredFields of type Fields
282   */
283  @ConstructorProperties({"groupName", "pipes", "groupFields", "declaredFields"})
284  public CoGroup( String groupName, Pipe[] pipes, Fields[] groupFields, Fields declaredFields )
285    {
286    super( groupName, pipes, groupFields, declaredFields );
287    }
288
289  /**
290   * Constructor CoGroup creates a new CoGroup instance.
291   *
292   * @param groupName         of type String
293   * @param pipes             of type Pipe[]
294   * @param groupFields       of type Fields[]
295   * @param declaredFields    of type Fields
296   * @param resultGroupFields of type Fields
297   */
298  @ConstructorProperties({"groupName", "pipes", "groupFields", "declaredFields", "resultGroupFields"})
299  public CoGroup( String groupName, Pipe[] pipes, Fields[] groupFields, Fields declaredFields, Fields resultGroupFields )
300    {
301    super( groupName, pipes, groupFields, declaredFields, resultGroupFields );
302    }
303
304  /**
305   * Constructor CoGroup creates a new CoGroup instance.
306   *
307   * @param groupName      of type String
308   * @param pipes          of type Pipe[]
309   * @param groupFields    of type Fields[]
310   * @param declaredFields of type Fields
311   * @param joiner         of type CoGrouper
312   */
313  @ConstructorProperties({"groupName", "pipes", "groupFields", "declaredFields", "joiner"})
314  public CoGroup( String groupName, Pipe[] pipes, Fields[] groupFields, Fields declaredFields, Joiner joiner )
315    {
316    super( groupName, pipes, groupFields, declaredFields, null, joiner );
317    }
318
319  /**
320   * Constructor CoGroup creates a new CoGroup instance.
321   *
322   * @param groupName         of type String
323   * @param pipes             of type Pipe[]
324   * @param groupFields       of type Fields[]
325   * @param declaredFields    of type Fields
326   * @param resultGroupFields of type Fields
327   * @param joiner            of type CoGrouper
328   */
329  @ConstructorProperties({"groupName", "pipes", "groupFields", "declaredFields", "resultGroupFields", "joiner"})
330  public CoGroup( String groupName, Pipe[] pipes, Fields[] groupFields, Fields declaredFields, Fields resultGroupFields, Joiner joiner )
331    {
332    super( groupName, pipes, groupFields, declaredFields, resultGroupFields, joiner );
333    }
334
335  /**
336   * Constructor CoGroup creates a new CoGroup instance.
337   *
338   * @param groupName      of type String
339   * @param lhs            of type Pipe
340   * @param lhsGroupFields of type Fields
341   * @param rhs            of type Pipe
342   * @param rhsGroupFields of type Fields
343   * @param declaredFields of type Fields
344   */
345  @ConstructorProperties({"groupName", "lhs", "lhsGroupFields", "rhs", "rhsGroupFields", "declaredFields"})
346  public CoGroup( String groupName, Pipe lhs, Fields lhsGroupFields, Pipe rhs, Fields rhsGroupFields, Fields declaredFields )
347    {
348    super( groupName, lhs, lhsGroupFields, rhs, rhsGroupFields, declaredFields );
349    }
350
351  /**
352   * Constructor CoGroup creates a new CoGroup instance.
353   *
354   * @param groupName         of type String
355   * @param lhs               of type Pipe
356   * @param lhsGroupFields    of type Fields
357   * @param rhs               of type Pipe
358   * @param rhsGroupFields    of type Fields
359   * @param declaredFields    of type Fields
360   * @param resultGroupFields of type Fields
361   */
362  @ConstructorProperties({"groupName", "lhs", "lhsGroupFields", "rhs", "rhsGroupFields", "declaredFields",
363                          "resultGroupFields"})
364  public CoGroup( String groupName, Pipe lhs, Fields lhsGroupFields, Pipe rhs, Fields rhsGroupFields, Fields declaredFields, Fields resultGroupFields )
365    {
366    super( groupName, lhs, lhsGroupFields, rhs, rhsGroupFields, declaredFields, resultGroupFields );
367    }
368
369  /**
370   * Constructor CoGroup creates a new CoGroup instance.
371   *
372   * @param groupName      of type String
373   * @param lhs            of type Pipe
374   * @param lhsGroupFields of type Fields
375   * @param rhs            of type Pipe
376   * @param rhsGroupFields of type Fields
377   * @param declaredFields of type Fields
378   * @param joiner         of type CoGrouper
379   */
380  @ConstructorProperties({"groupName", "lhs", "lhsGroupFields", "rhs", "rhsGroupFields", "declaredFields", "joiner"})
381  public CoGroup( String groupName, Pipe lhs, Fields lhsGroupFields, Pipe rhs, Fields rhsGroupFields, Fields declaredFields, Joiner joiner )
382    {
383    super( groupName, lhs, lhsGroupFields, rhs, rhsGroupFields, declaredFields, joiner );
384    }
385
386  /**
387   * Constructor CoGroup creates a new CoGroup instance.
388   *
389   * @param groupName         of type String
390   * @param lhs               of type Pipe
391   * @param lhsGroupFields    of type Fields
392   * @param rhs               of type Pipe
393   * @param rhsGroupFields    of type Fields
394   * @param declaredFields    of type Fields
395   * @param resultGroupFields of type Fields
396   * @param joiner            of type Joiner
397   */
398  @ConstructorProperties({"groupName", "lhs", "lhsGroupFields", "rhs", "rhsGroupFields", "declaredFields",
399                          "resultGroupFields", "joiner"})
400  public CoGroup( String groupName, Pipe lhs, Fields lhsGroupFields, Pipe rhs, Fields rhsGroupFields, Fields declaredFields, Fields resultGroupFields, Joiner joiner )
401    {
402    super( groupName, lhs, lhsGroupFields, rhs, rhsGroupFields, declaredFields, resultGroupFields, joiner );
403    }
404
405  /**
406   * Constructor CoGroup creates a new CoGroup instance.
407   *
408   * @param groupName      of type String
409   * @param lhs            of type Pipe
410   * @param lhsGroupFields of type Fields
411   * @param rhs            of type Pipe
412   * @param rhsGroupFields of type Fields
413   * @param joiner         of type CoGrouper
414   */
415  @ConstructorProperties({"groupName", "lhs", "lhsGroupFields", "rhs", "rhsGroupFields", "joiner"})
416  public CoGroup( String groupName, Pipe lhs, Fields lhsGroupFields, Pipe rhs, Fields rhsGroupFields, Joiner joiner )
417    {
418    super( groupName, lhs, lhsGroupFields, rhs, rhsGroupFields, joiner );
419    }
420
421  /**
422   * Constructor CoGroup creates a new CoGroup instance.
423   *
424   * @param groupName      of type String
425   * @param lhs            of type Pipe
426   * @param lhsGroupFields of type Fields
427   * @param rhs            of type Pipe
428   * @param rhsGroupFields of type Fields
429   */
430  @ConstructorProperties({"groupName", "lhs", "lhsGroupFields", "rhs", "rhsGroupFields"})
431  public CoGroup( String groupName, Pipe lhs, Fields lhsGroupFields, Pipe rhs, Fields rhsGroupFields )
432    {
433    super( groupName, lhs, lhsGroupFields, rhs, rhsGroupFields );
434    }
435
436  /**
437   * Constructor CoGroup creates a new CoGroup instance.
438   *
439   * @param groupName of type String
440   * @param pipes     of type Pipe...
441   */
442  @ConstructorProperties({"groupName", "pipes"})
443  public CoGroup( String groupName, Pipe... pipes )
444    {
445    super( groupName, pipes );
446    }
447
448  /**
449   * Constructor CoGroup creates a new CoGroup instance that performs numSelfJoins number of self joins on the
450   * given {@link Pipe} instance.
451   *
452   * @param pipe           of type Pipe
453   * @param groupFields    of type Fields
454   * @param numSelfJoins   of type int
455   * @param declaredFields of type Fields
456   */
457  @ConstructorProperties({"pipe", "groupFields", "numSelfJoins", "declaredFields"})
458  public CoGroup( Pipe pipe, Fields groupFields, int numSelfJoins, Fields declaredFields )
459    {
460    super( pipe, groupFields, numSelfJoins, declaredFields );
461    }
462
463  /**
464   * Constructor CoGroup creates a new CoGroup instance.
465   *
466   * @param pipe              of type Pipe
467   * @param groupFields       of type Fields
468   * @param numSelfJoins      of type int
469   * @param declaredFields    of type Fields
470   * @param resultGroupFields of type Fields
471   */
472  @ConstructorProperties({"pipe", "groupFields", "numSelfJoins", "declaredFields", "resultGroupFields"})
473  public CoGroup( Pipe pipe, Fields groupFields, int numSelfJoins, Fields declaredFields, Fields resultGroupFields )
474    {
475    super( pipe, groupFields, numSelfJoins, declaredFields, resultGroupFields );
476    }
477
478  /**
479   * Constructor CoGroup creates a new CoGroup instance that performs numSelfJoins number of self joins on the
480   * given {@link Pipe} instance.
481   *
482   * @param pipe           of type Pipe
483   * @param groupFields    of type Fields
484   * @param numSelfJoins   of type int
485   * @param declaredFields of type Fields
486   * @param joiner         of type CoGrouper
487   */
488  @ConstructorProperties({"pipe", "groupFields", "numSelfJoins", "declaredFields", "joiner"})
489  public CoGroup( Pipe pipe, Fields groupFields, int numSelfJoins, Fields declaredFields, Joiner joiner )
490    {
491    super( pipe, groupFields, numSelfJoins, declaredFields, joiner );
492    }
493
494  /**
495   * Constructor CoGroup creates a new CoGroup instance.
496   *
497   * @param pipe              of type Pipe
498   * @param groupFields       of type Fields
499   * @param numSelfJoins      of type int
500   * @param declaredFields    of type Fields
501   * @param resultGroupFields of type Fields
502   * @param joiner            of type Joiner
503   */
504  @ConstructorProperties({"pipe", "groupFields", "numSelfJoins", "declaredFields", "resultGroupFields", "joiner"})
505  public CoGroup( Pipe pipe, Fields groupFields, int numSelfJoins, Fields declaredFields, Fields resultGroupFields, Joiner joiner )
506    {
507    super( pipe, groupFields, numSelfJoins, declaredFields, resultGroupFields, joiner );
508    }
509
510  /**
511   * Constructor CoGroup creates a new CoGroup instance that performs numSelfJoins number of self joins on the
512   * given {@link Pipe} instance.
513   *
514   * @param pipe         of type Pipe
515   * @param groupFields  of type Fields
516   * @param numSelfJoins of type int
517   * @param joiner       of type CoGrouper
518   */
519  @ConstructorProperties({"pipe", "groupFields", "numSelfJoins", "joiner"})
520  public CoGroup( Pipe pipe, Fields groupFields, int numSelfJoins, Joiner joiner )
521    {
522    super( pipe, groupFields, numSelfJoins, joiner );
523    }
524
525  /**
526   * Constructor CoGroup creates a new CoGroup instance that performs numSelfJoins number of self joins on the
527   * given {@link Pipe} instance.
528   *
529   * @param pipe         of type Pipe
530   * @param groupFields  of type Fields
531   * @param numSelfJoins of type int
532   */
533  @ConstructorProperties({"pipe", "groupFields", "numSelfJoins"})
534  public CoGroup( Pipe pipe, Fields groupFields, int numSelfJoins )
535    {
536    super( pipe, groupFields, numSelfJoins );
537    }
538
539  /**
540   * Constructor CoGroup creates a new CoGroup instance that performs numSelfJoins number of self joins on the
541   * given {@link Pipe} instance.
542   *
543   * @param groupName      of type String
544   * @param pipe           of type Pipe
545   * @param groupFields    of type Fields
546   * @param numSelfJoins   of type int
547   * @param declaredFields of type Fields
548   */
549  @ConstructorProperties({"groupName", "pipe", "groupFields", "numSelfJoins", "declaredFields"})
550  public CoGroup( String groupName, Pipe pipe, Fields groupFields, int numSelfJoins, Fields declaredFields )
551    {
552    super( groupName, pipe, groupFields, numSelfJoins, declaredFields );
553    }
554
555  /**
556   * Constructor CoGroup creates a new CoGroup instance.
557   *
558   * @param groupName         of type String
559   * @param pipe              of type Pipe
560   * @param groupFields       of type Fields
561   * @param numSelfJoins      of type int
562   * @param declaredFields    of type Fields
563   * @param resultGroupFields of type Fields
564   */
565  @ConstructorProperties({"groupName", "pipe", "groupFields", "numSelfJoins", "declaredFields", "resultGroupFields"})
566  public CoGroup( String groupName, Pipe pipe, Fields groupFields, int numSelfJoins, Fields declaredFields, Fields resultGroupFields )
567    {
568    super( groupName, pipe, groupFields, numSelfJoins, declaredFields, resultGroupFields );
569    }
570
571  /**
572   * Constructor CoGroup creates a new CoGroup instance that performs numSelfJoins number of self joins on the
573   * given {@link Pipe} instance.
574   *
575   * @param groupName      of type String
576   * @param pipe           of type Pipe
577   * @param groupFields    of type Fields
578   * @param numSelfJoins   of type int
579   * @param declaredFields of type Fields
580   * @param joiner         of type CoGrouper
581   */
582  @ConstructorProperties({"groupName", "pipe", "groupFields", "numSelfJoins", "declaredFields", "joiner"})
583  public CoGroup( String groupName, Pipe pipe, Fields groupFields, int numSelfJoins, Fields declaredFields, Joiner joiner )
584    {
585    super( groupName, pipe, groupFields, numSelfJoins, declaredFields, joiner );
586    }
587
588  /**
589   * Constructor CoGroup creates a new CoGroup instance.
590   *
591   * @param groupName         of type String
592   * @param pipe              of type Pipe
593   * @param groupFields       of type Fields
594   * @param numSelfJoins      of type int
595   * @param declaredFields    of type Fields
596   * @param resultGroupFields of type Fields
597   * @param joiner            of type Joiner
598   */
599  @ConstructorProperties({"groupName", "pipe", "groupFields", "numSelfJoins", "declaredFields", "resultGroupFields",
600                          "joiner"})
601  public CoGroup( String groupName, Pipe pipe, Fields groupFields, int numSelfJoins, Fields declaredFields, Fields resultGroupFields, Joiner joiner )
602    {
603    super( groupName, pipe, groupFields, numSelfJoins, declaredFields, resultGroupFields, joiner );
604    }
605
606  /**
607   * Constructor CoGroup creates a new CoGroup instance that performs numSelfJoins number of self joins on the
608   * given {@link Pipe} instance.
609   *
610   * @param groupName    of type String
611   * @param pipe         of type Pipe
612   * @param groupFields  of type Fields
613   * @param numSelfJoins of type int
614   * @param joiner       of type CoGrouper
615   */
616  @ConstructorProperties({"groupName", "pipe", "groupFields", "numSelfJoins", "joiner"})
617  public CoGroup( String groupName, Pipe pipe, Fields groupFields, int numSelfJoins, Joiner joiner )
618    {
619    super( groupName, pipe, groupFields, numSelfJoins, joiner );
620    }
621
622  /**
623   * Constructor CoGroup creates a new CoGroup instance that performs numSelfJoins number of self joins on the
624   * given {@link Pipe} instance.
625   *
626   * @param groupName    of type String
627   * @param pipe         of type Pipe
628   * @param groupFields  of type Fields
629   * @param numSelfJoins of type int
630   */
631  @ConstructorProperties({"groupName", "pipe", "groupFields", "numSelfJoins"})
632  public CoGroup( String groupName, Pipe pipe, Fields groupFields, int numSelfJoins )
633    {
634    super( groupName, pipe, groupFields, numSelfJoins );
635    }
636  }