    001/*
    002 * Copyright (c) 2007-2016 Concurrent, 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  }