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