    001    /*
    002     * Copyright (c) 2007-2014 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
    021    package cascading.pipe;
    022
    023    import java.beans.ConstructorProperties;
    024
    025    import cascading.pipe.joiner.Joiner;
    026    import 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     */
    114    public 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      }