Packages

final class SMBMultiJoin extends AnyRef

Source
SMBMultiJoin.scala
Linear Supertypes
AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. SMBMultiJoin
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Instance Constructors

  1. new SMBMultiJoin(self: ScioContext)

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##: Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  5. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @native()
  6. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  7. def equals(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef → Any
  8. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.Throwable])
  9. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  10. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  11. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  12. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  13. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  14. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  15. def sortMergeCoGroup[KEY, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], h: Read[H], i: Read[I], j: Read[J], k: Read[K], l: Read[L], m: Read[M], n: Read[N], o: Read[O], p: Read[P], q: Read[Q], r: Read[R], s: Read[S], t: Read[T], u: Read[U], v: Read[V])(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G], arg8: Coder[H], arg9: Coder[I], arg10: Coder[J], arg11: Coder[K], arg12: Coder[L], arg13: Coder[M], arg14: Coder[N], arg15: Coder[O], arg16: Coder[P], arg17: Coder[Q], arg18: Coder[R], arg19: Coder[S], arg20: Coder[T], arg21: Coder[U], arg22: Coder[V]): SCollection[(KEY, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G], Iterable[H], Iterable[I], Iterable[J], Iterable[K], Iterable[L], Iterable[M], Iterable[N], Iterable[O], Iterable[P], Iterable[Q], Iterable[R], Iterable[S], Iterable[T], Iterable[U], Iterable[V]))]
  16. def sortMergeCoGroup[KEY, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], h: Read[H], i: Read[I], j: Read[J], k: Read[K], l: Read[L], m: Read[M], n: Read[N], o: Read[O], p: Read[P], q: Read[Q], r: Read[R], s: Read[S], t: Read[T], u: Read[U], v: Read[V], targetParallelism: TargetParallelism)(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G], arg8: Coder[H], arg9: Coder[I], arg10: Coder[J], arg11: Coder[K], arg12: Coder[L], arg13: Coder[M], arg14: Coder[N], arg15: Coder[O], arg16: Coder[P], arg17: Coder[Q], arg18: Coder[R], arg19: Coder[S], arg20: Coder[T], arg21: Coder[U], arg22: Coder[V]): SCollection[(KEY, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G], Iterable[H], Iterable[I], Iterable[J], Iterable[K], Iterable[L], Iterable[M], Iterable[N], Iterable[O], Iterable[P], Iterable[Q], Iterable[R], Iterable[S], Iterable[T], Iterable[U], Iterable[V]))]
  17. def sortMergeCoGroup[KEY, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], h: Read[H], i: Read[I], j: Read[J], k: Read[K], l: Read[L], m: Read[M], n: Read[N], o: Read[O], p: Read[P], q: Read[Q], r: Read[R], s: Read[S], t: Read[T], u: Read[U])(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G], arg8: Coder[H], arg9: Coder[I], arg10: Coder[J], arg11: Coder[K], arg12: Coder[L], arg13: Coder[M], arg14: Coder[N], arg15: Coder[O], arg16: Coder[P], arg17: Coder[Q], arg18: Coder[R], arg19: Coder[S], arg20: Coder[T], arg21: Coder[U]): SCollection[(KEY, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G], Iterable[H], Iterable[I], Iterable[J], Iterable[K], Iterable[L], Iterable[M], Iterable[N], Iterable[O], Iterable[P], Iterable[Q], Iterable[R], Iterable[S], Iterable[T], Iterable[U]))]
  18. def sortMergeCoGroup[KEY, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], h: Read[H], i: Read[I], j: Read[J], k: Read[K], l: Read[L], m: Read[M], n: Read[N], o: Read[O], p: Read[P], q: Read[Q], r: Read[R], s: Read[S], t: Read[T], u: Read[U], targetParallelism: TargetParallelism)(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G], arg8: Coder[H], arg9: Coder[I], arg10: Coder[J], arg11: Coder[K], arg12: Coder[L], arg13: Coder[M], arg14: Coder[N], arg15: Coder[O], arg16: Coder[P], arg17: Coder[Q], arg18: Coder[R], arg19: Coder[S], arg20: Coder[T], arg21: Coder[U]): SCollection[(KEY, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G], Iterable[H], Iterable[I], Iterable[J], Iterable[K], Iterable[L], Iterable[M], Iterable[N], Iterable[O], Iterable[P], Iterable[Q], Iterable[R], Iterable[S], Iterable[T], Iterable[U]))]
  19. def sortMergeCoGroup[KEY, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], h: Read[H], i: Read[I], j: Read[J], k: Read[K], l: Read[L], m: Read[M], n: Read[N], o: Read[O], p: Read[P], q: Read[Q], r: Read[R], s: Read[S], t: Read[T])(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G], arg8: Coder[H], arg9: Coder[I], arg10: Coder[J], arg11: Coder[K], arg12: Coder[L], arg13: Coder[M], arg14: Coder[N], arg15: Coder[O], arg16: Coder[P], arg17: Coder[Q], arg18: Coder[R], arg19: Coder[S], arg20: Coder[T]): SCollection[(KEY, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G], Iterable[H], Iterable[I], Iterable[J], Iterable[K], Iterable[L], Iterable[M], Iterable[N], Iterable[O], Iterable[P], Iterable[Q], Iterable[R], Iterable[S], Iterable[T]))]
  20. def sortMergeCoGroup[KEY, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], h: Read[H], i: Read[I], j: Read[J], k: Read[K], l: Read[L], m: Read[M], n: Read[N], o: Read[O], p: Read[P], q: Read[Q], r: Read[R], s: Read[S], t: Read[T], targetParallelism: TargetParallelism)(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G], arg8: Coder[H], arg9: Coder[I], arg10: Coder[J], arg11: Coder[K], arg12: Coder[L], arg13: Coder[M], arg14: Coder[N], arg15: Coder[O], arg16: Coder[P], arg17: Coder[Q], arg18: Coder[R], arg19: Coder[S], arg20: Coder[T]): SCollection[(KEY, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G], Iterable[H], Iterable[I], Iterable[J], Iterable[K], Iterable[L], Iterable[M], Iterable[N], Iterable[O], Iterable[P], Iterable[Q], Iterable[R], Iterable[S], Iterable[T]))]
  21. def sortMergeCoGroup[KEY, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], h: Read[H], i: Read[I], j: Read[J], k: Read[K], l: Read[L], m: Read[M], n: Read[N], o: Read[O], p: Read[P], q: Read[Q], r: Read[R], s: Read[S])(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G], arg8: Coder[H], arg9: Coder[I], arg10: Coder[J], arg11: Coder[K], arg12: Coder[L], arg13: Coder[M], arg14: Coder[N], arg15: Coder[O], arg16: Coder[P], arg17: Coder[Q], arg18: Coder[R], arg19: Coder[S]): SCollection[(KEY, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G], Iterable[H], Iterable[I], Iterable[J], Iterable[K], Iterable[L], Iterable[M], Iterable[N], Iterable[O], Iterable[P], Iterable[Q], Iterable[R], Iterable[S]))]
  22. def sortMergeCoGroup[KEY, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], h: Read[H], i: Read[I], j: Read[J], k: Read[K], l: Read[L], m: Read[M], n: Read[N], o: Read[O], p: Read[P], q: Read[Q], r: Read[R], s: Read[S], targetParallelism: TargetParallelism)(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G], arg8: Coder[H], arg9: Coder[I], arg10: Coder[J], arg11: Coder[K], arg12: Coder[L], arg13: Coder[M], arg14: Coder[N], arg15: Coder[O], arg16: Coder[P], arg17: Coder[Q], arg18: Coder[R], arg19: Coder[S]): SCollection[(KEY, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G], Iterable[H], Iterable[I], Iterable[J], Iterable[K], Iterable[L], Iterable[M], Iterable[N], Iterable[O], Iterable[P], Iterable[Q], Iterable[R], Iterable[S]))]
  23. def sortMergeCoGroup[KEY, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], h: Read[H], i: Read[I], j: Read[J], k: Read[K], l: Read[L], m: Read[M], n: Read[N], o: Read[O], p: Read[P], q: Read[Q], r: Read[R])(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G], arg8: Coder[H], arg9: Coder[I], arg10: Coder[J], arg11: Coder[K], arg12: Coder[L], arg13: Coder[M], arg14: Coder[N], arg15: Coder[O], arg16: Coder[P], arg17: Coder[Q], arg18: Coder[R]): SCollection[(KEY, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G], Iterable[H], Iterable[I], Iterable[J], Iterable[K], Iterable[L], Iterable[M], Iterable[N], Iterable[O], Iterable[P], Iterable[Q], Iterable[R]))]
  24. def sortMergeCoGroup[KEY, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], h: Read[H], i: Read[I], j: Read[J], k: Read[K], l: Read[L], m: Read[M], n: Read[N], o: Read[O], p: Read[P], q: Read[Q], r: Read[R], targetParallelism: TargetParallelism)(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G], arg8: Coder[H], arg9: Coder[I], arg10: Coder[J], arg11: Coder[K], arg12: Coder[L], arg13: Coder[M], arg14: Coder[N], arg15: Coder[O], arg16: Coder[P], arg17: Coder[Q], arg18: Coder[R]): SCollection[(KEY, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G], Iterable[H], Iterable[I], Iterable[J], Iterable[K], Iterable[L], Iterable[M], Iterable[N], Iterable[O], Iterable[P], Iterable[Q], Iterable[R]))]
  25. def sortMergeCoGroup[KEY, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], h: Read[H], i: Read[I], j: Read[J], k: Read[K], l: Read[L], m: Read[M], n: Read[N], o: Read[O], p: Read[P], q: Read[Q])(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G], arg8: Coder[H], arg9: Coder[I], arg10: Coder[J], arg11: Coder[K], arg12: Coder[L], arg13: Coder[M], arg14: Coder[N], arg15: Coder[O], arg16: Coder[P], arg17: Coder[Q]): SCollection[(KEY, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G], Iterable[H], Iterable[I], Iterable[J], Iterable[K], Iterable[L], Iterable[M], Iterable[N], Iterable[O], Iterable[P], Iterable[Q]))]
  26. def sortMergeCoGroup[KEY, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], h: Read[H], i: Read[I], j: Read[J], k: Read[K], l: Read[L], m: Read[M], n: Read[N], o: Read[O], p: Read[P], q: Read[Q], targetParallelism: TargetParallelism)(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G], arg8: Coder[H], arg9: Coder[I], arg10: Coder[J], arg11: Coder[K], arg12: Coder[L], arg13: Coder[M], arg14: Coder[N], arg15: Coder[O], arg16: Coder[P], arg17: Coder[Q]): SCollection[(KEY, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G], Iterable[H], Iterable[I], Iterable[J], Iterable[K], Iterable[L], Iterable[M], Iterable[N], Iterable[O], Iterable[P], Iterable[Q]))]
  27. def sortMergeCoGroup[KEY, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], h: Read[H], i: Read[I], j: Read[J], k: Read[K], l: Read[L], m: Read[M], n: Read[N], o: Read[O], p: Read[P])(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G], arg8: Coder[H], arg9: Coder[I], arg10: Coder[J], arg11: Coder[K], arg12: Coder[L], arg13: Coder[M], arg14: Coder[N], arg15: Coder[O], arg16: Coder[P]): SCollection[(KEY, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G], Iterable[H], Iterable[I], Iterable[J], Iterable[K], Iterable[L], Iterable[M], Iterable[N], Iterable[O], Iterable[P]))]
  28. def sortMergeCoGroup[KEY, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], h: Read[H], i: Read[I], j: Read[J], k: Read[K], l: Read[L], m: Read[M], n: Read[N], o: Read[O], p: Read[P], targetParallelism: TargetParallelism)(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G], arg8: Coder[H], arg9: Coder[I], arg10: Coder[J], arg11: Coder[K], arg12: Coder[L], arg13: Coder[M], arg14: Coder[N], arg15: Coder[O], arg16: Coder[P]): SCollection[(KEY, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G], Iterable[H], Iterable[I], Iterable[J], Iterable[K], Iterable[L], Iterable[M], Iterable[N], Iterable[O], Iterable[P]))]
  29. def sortMergeCoGroup[KEY, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], h: Read[H], i: Read[I], j: Read[J], k: Read[K], l: Read[L], m: Read[M], n: Read[N], o: Read[O])(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G], arg8: Coder[H], arg9: Coder[I], arg10: Coder[J], arg11: Coder[K], arg12: Coder[L], arg13: Coder[M], arg14: Coder[N], arg15: Coder[O]): SCollection[(KEY, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G], Iterable[H], Iterable[I], Iterable[J], Iterable[K], Iterable[L], Iterable[M], Iterable[N], Iterable[O]))]
  30. def sortMergeCoGroup[KEY, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], h: Read[H], i: Read[I], j: Read[J], k: Read[K], l: Read[L], m: Read[M], n: Read[N], o: Read[O], targetParallelism: TargetParallelism)(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G], arg8: Coder[H], arg9: Coder[I], arg10: Coder[J], arg11: Coder[K], arg12: Coder[L], arg13: Coder[M], arg14: Coder[N], arg15: Coder[O]): SCollection[(KEY, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G], Iterable[H], Iterable[I], Iterable[J], Iterable[K], Iterable[L], Iterable[M], Iterable[N], Iterable[O]))]
  31. def sortMergeCoGroup[KEY, A, B, C, D, E, F, G, H, I, J, K, L, M, N](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], h: Read[H], i: Read[I], j: Read[J], k: Read[K], l: Read[L], m: Read[M], n: Read[N])(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G], arg8: Coder[H], arg9: Coder[I], arg10: Coder[J], arg11: Coder[K], arg12: Coder[L], arg13: Coder[M], arg14: Coder[N]): SCollection[(KEY, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G], Iterable[H], Iterable[I], Iterable[J], Iterable[K], Iterable[L], Iterable[M], Iterable[N]))]
  32. def sortMergeCoGroup[KEY, A, B, C, D, E, F, G, H, I, J, K, L, M, N](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], h: Read[H], i: Read[I], j: Read[J], k: Read[K], l: Read[L], m: Read[M], n: Read[N], targetParallelism: TargetParallelism)(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G], arg8: Coder[H], arg9: Coder[I], arg10: Coder[J], arg11: Coder[K], arg12: Coder[L], arg13: Coder[M], arg14: Coder[N]): SCollection[(KEY, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G], Iterable[H], Iterable[I], Iterable[J], Iterable[K], Iterable[L], Iterable[M], Iterable[N]))]
  33. def sortMergeCoGroup[KEY, A, B, C, D, E, F, G, H, I, J, K, L, M](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], h: Read[H], i: Read[I], j: Read[J], k: Read[K], l: Read[L], m: Read[M])(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G], arg8: Coder[H], arg9: Coder[I], arg10: Coder[J], arg11: Coder[K], arg12: Coder[L], arg13: Coder[M]): SCollection[(KEY, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G], Iterable[H], Iterable[I], Iterable[J], Iterable[K], Iterable[L], Iterable[M]))]
  34. def sortMergeCoGroup[KEY, A, B, C, D, E, F, G, H, I, J, K, L, M](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], h: Read[H], i: Read[I], j: Read[J], k: Read[K], l: Read[L], m: Read[M], targetParallelism: TargetParallelism)(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G], arg8: Coder[H], arg9: Coder[I], arg10: Coder[J], arg11: Coder[K], arg12: Coder[L], arg13: Coder[M]): SCollection[(KEY, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G], Iterable[H], Iterable[I], Iterable[J], Iterable[K], Iterable[L], Iterable[M]))]
  35. def sortMergeCoGroup[KEY, A, B, C, D, E, F, G, H, I, J, K, L](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], h: Read[H], i: Read[I], j: Read[J], k: Read[K], l: Read[L])(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G], arg8: Coder[H], arg9: Coder[I], arg10: Coder[J], arg11: Coder[K], arg12: Coder[L]): SCollection[(KEY, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G], Iterable[H], Iterable[I], Iterable[J], Iterable[K], Iterable[L]))]
  36. def sortMergeCoGroup[KEY, A, B, C, D, E, F, G, H, I, J, K, L](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], h: Read[H], i: Read[I], j: Read[J], k: Read[K], l: Read[L], targetParallelism: TargetParallelism)(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G], arg8: Coder[H], arg9: Coder[I], arg10: Coder[J], arg11: Coder[K], arg12: Coder[L]): SCollection[(KEY, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G], Iterable[H], Iterable[I], Iterable[J], Iterable[K], Iterable[L]))]
  37. def sortMergeCoGroup[KEY, A, B, C, D, E, F, G, H, I, J, K](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], h: Read[H], i: Read[I], j: Read[J], k: Read[K])(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G], arg8: Coder[H], arg9: Coder[I], arg10: Coder[J], arg11: Coder[K]): SCollection[(KEY, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G], Iterable[H], Iterable[I], Iterable[J], Iterable[K]))]
  38. def sortMergeCoGroup[KEY, A, B, C, D, E, F, G, H, I, J, K](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], h: Read[H], i: Read[I], j: Read[J], k: Read[K], targetParallelism: TargetParallelism)(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G], arg8: Coder[H], arg9: Coder[I], arg10: Coder[J], arg11: Coder[K]): SCollection[(KEY, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G], Iterable[H], Iterable[I], Iterable[J], Iterable[K]))]
  39. def sortMergeCoGroup[KEY, A, B, C, D, E, F, G, H, I, J](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], h: Read[H], i: Read[I], j: Read[J])(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G], arg8: Coder[H], arg9: Coder[I], arg10: Coder[J]): SCollection[(KEY, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G], Iterable[H], Iterable[I], Iterable[J]))]
  40. def sortMergeCoGroup[KEY, A, B, C, D, E, F, G, H, I, J](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], h: Read[H], i: Read[I], j: Read[J], targetParallelism: TargetParallelism)(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G], arg8: Coder[H], arg9: Coder[I], arg10: Coder[J]): SCollection[(KEY, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G], Iterable[H], Iterable[I], Iterable[J]))]
  41. def sortMergeCoGroup[KEY, A, B, C, D, E, F, G, H, I](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], h: Read[H], i: Read[I])(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G], arg8: Coder[H], arg9: Coder[I]): SCollection[(KEY, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G], Iterable[H], Iterable[I]))]
  42. def sortMergeCoGroup[KEY, A, B, C, D, E, F, G, H, I](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], h: Read[H], i: Read[I], targetParallelism: TargetParallelism)(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G], arg8: Coder[H], arg9: Coder[I]): SCollection[(KEY, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G], Iterable[H], Iterable[I]))]
  43. def sortMergeCoGroup[KEY, A, B, C, D, E, F, G, H](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], h: Read[H])(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G], arg8: Coder[H]): SCollection[(KEY, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G], Iterable[H]))]
  44. def sortMergeCoGroup[KEY, A, B, C, D, E, F, G, H](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], h: Read[H], targetParallelism: TargetParallelism)(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G], arg8: Coder[H]): SCollection[(KEY, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G], Iterable[H]))]
  45. def sortMergeCoGroup[KEY, A, B, C, D, E, F, G](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G])(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G]): SCollection[(KEY, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G]))]
  46. def sortMergeCoGroup[KEY, A, B, C, D, E, F, G](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], targetParallelism: TargetParallelism)(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G]): SCollection[(KEY, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G]))]
  47. def sortMergeCoGroup[KEY, A, B, C, D, E, F](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F])(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F]): SCollection[(KEY, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F]))]
  48. def sortMergeCoGroup[KEY, A, B, C, D, E, F](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], targetParallelism: TargetParallelism)(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F]): SCollection[(KEY, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F]))]
  49. def sortMergeCoGroup[KEY, A, B, C, D, E](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E])(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E]): SCollection[(KEY, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E]))]
  50. def sortMergeCoGroup[KEY, A, B, C, D, E](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], targetParallelism: TargetParallelism)(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E]): SCollection[(KEY, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E]))]
  51. def sortMergeCoGroup[KEY, A, B, C, D](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D])(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D]): SCollection[(KEY, (Iterable[A], Iterable[B], Iterable[C], Iterable[D]))]
  52. def sortMergeCoGroup[KEY, A, B, C, D](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], targetParallelism: TargetParallelism)(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D]): SCollection[(KEY, (Iterable[A], Iterable[B], Iterable[C], Iterable[D]))]
  53. def sortMergeCoGroup[KEY, A, B, C](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C])(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C]): SCollection[(KEY, (Iterable[A], Iterable[B], Iterable[C]))]
  54. def sortMergeCoGroup[KEY, A, B, C](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], targetParallelism: TargetParallelism)(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C]): SCollection[(KEY, (Iterable[A], Iterable[B], Iterable[C]))]
  55. def sortMergeCoGroup[KEY, A, B](keyClass: Class[KEY], a: Read[A], b: Read[B])(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B]): SCollection[(KEY, (Iterable[A], Iterable[B]))]
  56. def sortMergeCoGroup[KEY, A, B](keyClass: Class[KEY], a: Read[A], b: Read[B], targetParallelism: TargetParallelism)(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B]): SCollection[(KEY, (Iterable[A], Iterable[B]))]
  57. def sortMergeTransform[KEY, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], h: Read[H], i: Read[I], j: Read[J], k: Read[K], l: Read[L], m: Read[M], n: Read[N], o: Read[O], p: Read[P], q: Read[Q], r: Read[R], s: Read[S], t: Read[T], u: Read[U], v: Read[V])(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G], arg8: Coder[H], arg9: Coder[I], arg10: Coder[J], arg11: Coder[K], arg12: Coder[L], arg13: Coder[M], arg14: Coder[N], arg15: Coder[O], arg16: Coder[P], arg17: Coder[Q], arg18: Coder[R], arg19: Coder[S], arg20: Coder[T], arg21: Coder[U], arg22: Coder[V]): ReadBuilder[KEY, KEY, Void, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G], Iterable[H], Iterable[I], Iterable[J], Iterable[K], Iterable[L], Iterable[M], Iterable[N], Iterable[O], Iterable[P], Iterable[Q], Iterable[R], Iterable[S], Iterable[T], Iterable[U], Iterable[V])]
  58. def sortMergeTransform[KEY, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], h: Read[H], i: Read[I], j: Read[J], k: Read[K], l: Read[L], m: Read[M], n: Read[N], o: Read[O], p: Read[P], q: Read[Q], r: Read[R], s: Read[S], t: Read[T], u: Read[U], v: Read[V], targetParallelism: TargetParallelism)(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G], arg8: Coder[H], arg9: Coder[I], arg10: Coder[J], arg11: Coder[K], arg12: Coder[L], arg13: Coder[M], arg14: Coder[N], arg15: Coder[O], arg16: Coder[P], arg17: Coder[Q], arg18: Coder[R], arg19: Coder[S], arg20: Coder[T], arg21: Coder[U], arg22: Coder[V]): ReadBuilder[KEY, KEY, Void, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G], Iterable[H], Iterable[I], Iterable[J], Iterable[K], Iterable[L], Iterable[M], Iterable[N], Iterable[O], Iterable[P], Iterable[Q], Iterable[R], Iterable[S], Iterable[T], Iterable[U], Iterable[V])]
  59. def sortMergeTransform[KEY, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], h: Read[H], i: Read[I], j: Read[J], k: Read[K], l: Read[L], m: Read[M], n: Read[N], o: Read[O], p: Read[P], q: Read[Q], r: Read[R], s: Read[S], t: Read[T], u: Read[U])(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G], arg8: Coder[H], arg9: Coder[I], arg10: Coder[J], arg11: Coder[K], arg12: Coder[L], arg13: Coder[M], arg14: Coder[N], arg15: Coder[O], arg16: Coder[P], arg17: Coder[Q], arg18: Coder[R], arg19: Coder[S], arg20: Coder[T], arg21: Coder[U]): ReadBuilder[KEY, KEY, Void, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G], Iterable[H], Iterable[I], Iterable[J], Iterable[K], Iterable[L], Iterable[M], Iterable[N], Iterable[O], Iterable[P], Iterable[Q], Iterable[R], Iterable[S], Iterable[T], Iterable[U])]
  60. def sortMergeTransform[KEY, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], h: Read[H], i: Read[I], j: Read[J], k: Read[K], l: Read[L], m: Read[M], n: Read[N], o: Read[O], p: Read[P], q: Read[Q], r: Read[R], s: Read[S], t: Read[T], u: Read[U], targetParallelism: TargetParallelism)(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G], arg8: Coder[H], arg9: Coder[I], arg10: Coder[J], arg11: Coder[K], arg12: Coder[L], arg13: Coder[M], arg14: Coder[N], arg15: Coder[O], arg16: Coder[P], arg17: Coder[Q], arg18: Coder[R], arg19: Coder[S], arg20: Coder[T], arg21: Coder[U]): ReadBuilder[KEY, KEY, Void, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G], Iterable[H], Iterable[I], Iterable[J], Iterable[K], Iterable[L], Iterable[M], Iterable[N], Iterable[O], Iterable[P], Iterable[Q], Iterable[R], Iterable[S], Iterable[T], Iterable[U])]
  61. def sortMergeTransform[KEY, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], h: Read[H], i: Read[I], j: Read[J], k: Read[K], l: Read[L], m: Read[M], n: Read[N], o: Read[O], p: Read[P], q: Read[Q], r: Read[R], s: Read[S], t: Read[T])(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G], arg8: Coder[H], arg9: Coder[I], arg10: Coder[J], arg11: Coder[K], arg12: Coder[L], arg13: Coder[M], arg14: Coder[N], arg15: Coder[O], arg16: Coder[P], arg17: Coder[Q], arg18: Coder[R], arg19: Coder[S], arg20: Coder[T]): ReadBuilder[KEY, KEY, Void, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G], Iterable[H], Iterable[I], Iterable[J], Iterable[K], Iterable[L], Iterable[M], Iterable[N], Iterable[O], Iterable[P], Iterable[Q], Iterable[R], Iterable[S], Iterable[T])]
  62. def sortMergeTransform[KEY, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], h: Read[H], i: Read[I], j: Read[J], k: Read[K], l: Read[L], m: Read[M], n: Read[N], o: Read[O], p: Read[P], q: Read[Q], r: Read[R], s: Read[S], t: Read[T], targetParallelism: TargetParallelism)(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G], arg8: Coder[H], arg9: Coder[I], arg10: Coder[J], arg11: Coder[K], arg12: Coder[L], arg13: Coder[M], arg14: Coder[N], arg15: Coder[O], arg16: Coder[P], arg17: Coder[Q], arg18: Coder[R], arg19: Coder[S], arg20: Coder[T]): ReadBuilder[KEY, KEY, Void, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G], Iterable[H], Iterable[I], Iterable[J], Iterable[K], Iterable[L], Iterable[M], Iterable[N], Iterable[O], Iterable[P], Iterable[Q], Iterable[R], Iterable[S], Iterable[T])]
  63. def sortMergeTransform[KEY, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], h: Read[H], i: Read[I], j: Read[J], k: Read[K], l: Read[L], m: Read[M], n: Read[N], o: Read[O], p: Read[P], q: Read[Q], r: Read[R], s: Read[S])(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G], arg8: Coder[H], arg9: Coder[I], arg10: Coder[J], arg11: Coder[K], arg12: Coder[L], arg13: Coder[M], arg14: Coder[N], arg15: Coder[O], arg16: Coder[P], arg17: Coder[Q], arg18: Coder[R], arg19: Coder[S]): ReadBuilder[KEY, KEY, Void, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G], Iterable[H], Iterable[I], Iterable[J], Iterable[K], Iterable[L], Iterable[M], Iterable[N], Iterable[O], Iterable[P], Iterable[Q], Iterable[R], Iterable[S])]
  64. def sortMergeTransform[KEY, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], h: Read[H], i: Read[I], j: Read[J], k: Read[K], l: Read[L], m: Read[M], n: Read[N], o: Read[O], p: Read[P], q: Read[Q], r: Read[R], s: Read[S], targetParallelism: TargetParallelism)(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G], arg8: Coder[H], arg9: Coder[I], arg10: Coder[J], arg11: Coder[K], arg12: Coder[L], arg13: Coder[M], arg14: Coder[N], arg15: Coder[O], arg16: Coder[P], arg17: Coder[Q], arg18: Coder[R], arg19: Coder[S]): ReadBuilder[KEY, KEY, Void, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G], Iterable[H], Iterable[I], Iterable[J], Iterable[K], Iterable[L], Iterable[M], Iterable[N], Iterable[O], Iterable[P], Iterable[Q], Iterable[R], Iterable[S])]
  65. def sortMergeTransform[KEY, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], h: Read[H], i: Read[I], j: Read[J], k: Read[K], l: Read[L], m: Read[M], n: Read[N], o: Read[O], p: Read[P], q: Read[Q], r: Read[R])(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G], arg8: Coder[H], arg9: Coder[I], arg10: Coder[J], arg11: Coder[K], arg12: Coder[L], arg13: Coder[M], arg14: Coder[N], arg15: Coder[O], arg16: Coder[P], arg17: Coder[Q], arg18: Coder[R]): ReadBuilder[KEY, KEY, Void, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G], Iterable[H], Iterable[I], Iterable[J], Iterable[K], Iterable[L], Iterable[M], Iterable[N], Iterable[O], Iterable[P], Iterable[Q], Iterable[R])]
  66. def sortMergeTransform[KEY, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], h: Read[H], i: Read[I], j: Read[J], k: Read[K], l: Read[L], m: Read[M], n: Read[N], o: Read[O], p: Read[P], q: Read[Q], r: Read[R], targetParallelism: TargetParallelism)(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G], arg8: Coder[H], arg9: Coder[I], arg10: Coder[J], arg11: Coder[K], arg12: Coder[L], arg13: Coder[M], arg14: Coder[N], arg15: Coder[O], arg16: Coder[P], arg17: Coder[Q], arg18: Coder[R]): ReadBuilder[KEY, KEY, Void, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G], Iterable[H], Iterable[I], Iterable[J], Iterable[K], Iterable[L], Iterable[M], Iterable[N], Iterable[O], Iterable[P], Iterable[Q], Iterable[R])]
  67. def sortMergeTransform[KEY, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], h: Read[H], i: Read[I], j: Read[J], k: Read[K], l: Read[L], m: Read[M], n: Read[N], o: Read[O], p: Read[P], q: Read[Q])(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G], arg8: Coder[H], arg9: Coder[I], arg10: Coder[J], arg11: Coder[K], arg12: Coder[L], arg13: Coder[M], arg14: Coder[N], arg15: Coder[O], arg16: Coder[P], arg17: Coder[Q]): ReadBuilder[KEY, KEY, Void, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G], Iterable[H], Iterable[I], Iterable[J], Iterable[K], Iterable[L], Iterable[M], Iterable[N], Iterable[O], Iterable[P], Iterable[Q])]
  68. def sortMergeTransform[KEY, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], h: Read[H], i: Read[I], j: Read[J], k: Read[K], l: Read[L], m: Read[M], n: Read[N], o: Read[O], p: Read[P], q: Read[Q], targetParallelism: TargetParallelism)(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G], arg8: Coder[H], arg9: Coder[I], arg10: Coder[J], arg11: Coder[K], arg12: Coder[L], arg13: Coder[M], arg14: Coder[N], arg15: Coder[O], arg16: Coder[P], arg17: Coder[Q]): ReadBuilder[KEY, KEY, Void, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G], Iterable[H], Iterable[I], Iterable[J], Iterable[K], Iterable[L], Iterable[M], Iterable[N], Iterable[O], Iterable[P], Iterable[Q])]
  69. def sortMergeTransform[KEY, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], h: Read[H], i: Read[I], j: Read[J], k: Read[K], l: Read[L], m: Read[M], n: Read[N], o: Read[O], p: Read[P])(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G], arg8: Coder[H], arg9: Coder[I], arg10: Coder[J], arg11: Coder[K], arg12: Coder[L], arg13: Coder[M], arg14: Coder[N], arg15: Coder[O], arg16: Coder[P]): ReadBuilder[KEY, KEY, Void, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G], Iterable[H], Iterable[I], Iterable[J], Iterable[K], Iterable[L], Iterable[M], Iterable[N], Iterable[O], Iterable[P])]
  70. def sortMergeTransform[KEY, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], h: Read[H], i: Read[I], j: Read[J], k: Read[K], l: Read[L], m: Read[M], n: Read[N], o: Read[O], p: Read[P], targetParallelism: TargetParallelism)(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G], arg8: Coder[H], arg9: Coder[I], arg10: Coder[J], arg11: Coder[K], arg12: Coder[L], arg13: Coder[M], arg14: Coder[N], arg15: Coder[O], arg16: Coder[P]): ReadBuilder[KEY, KEY, Void, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G], Iterable[H], Iterable[I], Iterable[J], Iterable[K], Iterable[L], Iterable[M], Iterable[N], Iterable[O], Iterable[P])]
  71. def sortMergeTransform[KEY, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], h: Read[H], i: Read[I], j: Read[J], k: Read[K], l: Read[L], m: Read[M], n: Read[N], o: Read[O])(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G], arg8: Coder[H], arg9: Coder[I], arg10: Coder[J], arg11: Coder[K], arg12: Coder[L], arg13: Coder[M], arg14: Coder[N], arg15: Coder[O]): ReadBuilder[KEY, KEY, Void, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G], Iterable[H], Iterable[I], Iterable[J], Iterable[K], Iterable[L], Iterable[M], Iterable[N], Iterable[O])]
  72. def sortMergeTransform[KEY, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], h: Read[H], i: Read[I], j: Read[J], k: Read[K], l: Read[L], m: Read[M], n: Read[N], o: Read[O], targetParallelism: TargetParallelism)(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G], arg8: Coder[H], arg9: Coder[I], arg10: Coder[J], arg11: Coder[K], arg12: Coder[L], arg13: Coder[M], arg14: Coder[N], arg15: Coder[O]): ReadBuilder[KEY, KEY, Void, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G], Iterable[H], Iterable[I], Iterable[J], Iterable[K], Iterable[L], Iterable[M], Iterable[N], Iterable[O])]
  73. def sortMergeTransform[KEY, A, B, C, D, E, F, G, H, I, J, K, L, M, N](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], h: Read[H], i: Read[I], j: Read[J], k: Read[K], l: Read[L], m: Read[M], n: Read[N])(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G], arg8: Coder[H], arg9: Coder[I], arg10: Coder[J], arg11: Coder[K], arg12: Coder[L], arg13: Coder[M], arg14: Coder[N]): ReadBuilder[KEY, KEY, Void, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G], Iterable[H], Iterable[I], Iterable[J], Iterable[K], Iterable[L], Iterable[M], Iterable[N])]
  74. def sortMergeTransform[KEY, A, B, C, D, E, F, G, H, I, J, K, L, M, N](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], h: Read[H], i: Read[I], j: Read[J], k: Read[K], l: Read[L], m: Read[M], n: Read[N], targetParallelism: TargetParallelism)(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G], arg8: Coder[H], arg9: Coder[I], arg10: Coder[J], arg11: Coder[K], arg12: Coder[L], arg13: Coder[M], arg14: Coder[N]): ReadBuilder[KEY, KEY, Void, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G], Iterable[H], Iterable[I], Iterable[J], Iterable[K], Iterable[L], Iterable[M], Iterable[N])]
  75. def sortMergeTransform[KEY, A, B, C, D, E, F, G, H, I, J, K, L, M](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], h: Read[H], i: Read[I], j: Read[J], k: Read[K], l: Read[L], m: Read[M])(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G], arg8: Coder[H], arg9: Coder[I], arg10: Coder[J], arg11: Coder[K], arg12: Coder[L], arg13: Coder[M]): ReadBuilder[KEY, KEY, Void, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G], Iterable[H], Iterable[I], Iterable[J], Iterable[K], Iterable[L], Iterable[M])]
  76. def sortMergeTransform[KEY, A, B, C, D, E, F, G, H, I, J, K, L, M](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], h: Read[H], i: Read[I], j: Read[J], k: Read[K], l: Read[L], m: Read[M], targetParallelism: TargetParallelism)(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G], arg8: Coder[H], arg9: Coder[I], arg10: Coder[J], arg11: Coder[K], arg12: Coder[L], arg13: Coder[M]): ReadBuilder[KEY, KEY, Void, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G], Iterable[H], Iterable[I], Iterable[J], Iterable[K], Iterable[L], Iterable[M])]
  77. def sortMergeTransform[KEY, A, B, C, D, E, F, G, H, I, J, K, L](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], h: Read[H], i: Read[I], j: Read[J], k: Read[K], l: Read[L])(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G], arg8: Coder[H], arg9: Coder[I], arg10: Coder[J], arg11: Coder[K], arg12: Coder[L]): ReadBuilder[KEY, KEY, Void, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G], Iterable[H], Iterable[I], Iterable[J], Iterable[K], Iterable[L])]
  78. def sortMergeTransform[KEY, A, B, C, D, E, F, G, H, I, J, K, L](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], h: Read[H], i: Read[I], j: Read[J], k: Read[K], l: Read[L], targetParallelism: TargetParallelism)(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G], arg8: Coder[H], arg9: Coder[I], arg10: Coder[J], arg11: Coder[K], arg12: Coder[L]): ReadBuilder[KEY, KEY, Void, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G], Iterable[H], Iterable[I], Iterable[J], Iterable[K], Iterable[L])]
  79. def sortMergeTransform[KEY, A, B, C, D, E, F, G, H, I, J, K](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], h: Read[H], i: Read[I], j: Read[J], k: Read[K])(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G], arg8: Coder[H], arg9: Coder[I], arg10: Coder[J], arg11: Coder[K]): ReadBuilder[KEY, KEY, Void, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G], Iterable[H], Iterable[I], Iterable[J], Iterable[K])]
  80. def sortMergeTransform[KEY, A, B, C, D, E, F, G, H, I, J, K](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], h: Read[H], i: Read[I], j: Read[J], k: Read[K], targetParallelism: TargetParallelism)(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G], arg8: Coder[H], arg9: Coder[I], arg10: Coder[J], arg11: Coder[K]): ReadBuilder[KEY, KEY, Void, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G], Iterable[H], Iterable[I], Iterable[J], Iterable[K])]
  81. def sortMergeTransform[KEY, A, B, C, D, E, F, G, H, I, J](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], h: Read[H], i: Read[I], j: Read[J])(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G], arg8: Coder[H], arg9: Coder[I], arg10: Coder[J]): ReadBuilder[KEY, KEY, Void, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G], Iterable[H], Iterable[I], Iterable[J])]
  82. def sortMergeTransform[KEY, A, B, C, D, E, F, G, H, I, J](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], h: Read[H], i: Read[I], j: Read[J], targetParallelism: TargetParallelism)(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G], arg8: Coder[H], arg9: Coder[I], arg10: Coder[J]): ReadBuilder[KEY, KEY, Void, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G], Iterable[H], Iterable[I], Iterable[J])]
  83. def sortMergeTransform[KEY, A, B, C, D, E, F, G, H, I](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], h: Read[H], i: Read[I])(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G], arg8: Coder[H], arg9: Coder[I]): ReadBuilder[KEY, KEY, Void, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G], Iterable[H], Iterable[I])]
  84. def sortMergeTransform[KEY, A, B, C, D, E, F, G, H, I](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], h: Read[H], i: Read[I], targetParallelism: TargetParallelism)(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G], arg8: Coder[H], arg9: Coder[I]): ReadBuilder[KEY, KEY, Void, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G], Iterable[H], Iterable[I])]
  85. def sortMergeTransform[KEY, A, B, C, D, E, F, G, H](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], h: Read[H])(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G], arg8: Coder[H]): ReadBuilder[KEY, KEY, Void, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G], Iterable[H])]
  86. def sortMergeTransform[KEY, A, B, C, D, E, F, G, H](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], h: Read[H], targetParallelism: TargetParallelism)(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G], arg8: Coder[H]): ReadBuilder[KEY, KEY, Void, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G], Iterable[H])]
  87. def sortMergeTransform[KEY, A, B, C, D, E, F, G](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G])(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G]): ReadBuilder[KEY, KEY, Void, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G])]
  88. def sortMergeTransform[KEY, A, B, C, D, E, F, G](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], g: Read[G], targetParallelism: TargetParallelism)(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F], arg7: Coder[G]): ReadBuilder[KEY, KEY, Void, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F], Iterable[G])]
  89. def sortMergeTransform[KEY, A, B, C, D, E, F](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F])(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F]): ReadBuilder[KEY, KEY, Void, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F])]
  90. def sortMergeTransform[KEY, A, B, C, D, E, F](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], f: Read[F], targetParallelism: TargetParallelism)(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E], arg6: Coder[F]): ReadBuilder[KEY, KEY, Void, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E], Iterable[F])]
  91. def sortMergeTransform[KEY, A, B, C, D, E](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E])(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E]): ReadBuilder[KEY, KEY, Void, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E])]
  92. def sortMergeTransform[KEY, A, B, C, D, E](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], e: Read[E], targetParallelism: TargetParallelism)(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D], arg5: Coder[E]): ReadBuilder[KEY, KEY, Void, (Iterable[A], Iterable[B], Iterable[C], Iterable[D], Iterable[E])]
  93. def sortMergeTransform[KEY, A, B, C, D](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D])(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D]): ReadBuilder[KEY, KEY, Void, (Iterable[A], Iterable[B], Iterable[C], Iterable[D])]
  94. def sortMergeTransform[KEY, A, B, C, D](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], d: Read[D], targetParallelism: TargetParallelism)(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C], arg4: Coder[D]): ReadBuilder[KEY, KEY, Void, (Iterable[A], Iterable[B], Iterable[C], Iterable[D])]
  95. def sortMergeTransform[KEY, A, B, C](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C])(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C]): ReadBuilder[KEY, KEY, Void, (Iterable[A], Iterable[B], Iterable[C])]
  96. def sortMergeTransform[KEY, A, B, C](keyClass: Class[KEY], a: Read[A], b: Read[B], c: Read[C], targetParallelism: TargetParallelism)(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B], arg3: Coder[C]): ReadBuilder[KEY, KEY, Void, (Iterable[A], Iterable[B], Iterable[C])]
  97. def sortMergeTransform[KEY, A, B](keyClass: Class[KEY], a: Read[A], b: Read[B])(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B]): ReadBuilder[KEY, KEY, Void, (Iterable[A], Iterable[B])]
  98. def sortMergeTransform[KEY, A, B](keyClass: Class[KEY], a: Read[A], b: Read[B], targetParallelism: TargetParallelism)(implicit arg0: Coder[KEY], arg1: Coder[A], arg2: Coder[B]): ReadBuilder[KEY, KEY, Void, (Iterable[A], Iterable[B])]
  99. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  100. def toString(): String
    Definition Classes
    AnyRef → Any
  101. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  102. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  103. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException]) @native()

Inherited from AnyRef

Inherited from Any

Ungrouped