scalikejdbc.OneToXSQL.scala Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of scalikejdbc-core_2.12 Show documentation
scalikejdbc-core
The newest version!
package scalikejdbc

/**
 * Endpoint of one-to-x APIs
 */
class OneToXSQL[A, E <: WithExtractor, Z](
  override val statement: String, override val rawParameters: scala.collection.Seq[Any])(val one: WrappedResultSet => A)
  extends SQL[Z, E](statement, rawParameters)(SQL.noExtractor[Z]("one-to-one/one-to-many operation needs toOne(RS => Option[B]).map((A,B) => A) or toMany(RS => Option[B]).map((A,Seq(B) => A)."))
  with AllOutputDecisionsUnsupported[Z, E] {

  def toOne[B](to: WrappedResultSet => B): OneToOneSQL[A, B, E, Z] = {
    val q: OneToOneSQL[A, B, E, Z] = new OneToOneSQL(statement, rawParameters)(one)(to.andThen((b: B) => Option(b)))((a, b) => a.asInstanceOf[Z])
    q.queryTimeout(queryTimeout)
    q.fetchSize(fetchSize)
    q.tags(tags.toSeq*)
    q
  }

  def toOptionalOne[B](to: WrappedResultSet => Option[B]): OneToOneSQL[A, Option[B], E, Z] = {
    val q: OneToOneSQL[A, Option[B], E, Z] = new OneToOneSQL(statement, rawParameters)(one)(to.andThen((maybeB: Option[B]) => Option(maybeB)))((a, maybeB) => a.asInstanceOf[Z])
    q.queryTimeout(queryTimeout)
    q.fetchSize(fetchSize)
    q.tags(tags.toSeq*)
    q
  }

  def toMany[B](to: WrappedResultSet => Option[B]): OneToManySQL[A, B, E, Z] = {
    val q: OneToManySQL[A, B, E, Z] = new OneToManySQL(statement, rawParameters)(one)(to)((a, bs) => a.asInstanceOf[Z])
    q.queryTimeout(queryTimeout)
    q.fetchSize(fetchSize)
    q.tags(tags.toSeq*)
    q
  }

  def toManies[B1, B2](
    to1: WrappedResultSet => Option[B1], to2: WrappedResultSet => Option[B2]
  ): OneToManies2SQL[A, B1, B2, E, Z] = {
    val q: OneToManies2SQL[A, B1, B2, E, Z] = new OneToManies2SQL(
      statement, rawParameters)(one)(to1, to2)((a, _, _) => a.asInstanceOf[Z])
    q.queryTimeout(queryTimeout)
    q.fetchSize(fetchSize)
    q.tags(tags.toSeq*)
  }

  def toManies[B1, B2, B3](
    to1: WrappedResultSet => Option[B1], to2: WrappedResultSet => Option[B2], to3: WrappedResultSet => Option[B3]
  ): OneToManies3SQL[A, B1, B2, B3, E, Z] = {
    val q: OneToManies3SQL[A, B1, B2, B3, E, Z] = new OneToManies3SQL(
      statement, rawParameters)(one)(to1, to2, to3)((a, _, _, _) => a.asInstanceOf[Z])
    q.queryTimeout(queryTimeout)
    q.fetchSize(fetchSize)
    q.tags(tags.toSeq*)
  }

  def toManies[B1, B2, B3, B4](
    to1: WrappedResultSet => Option[B1], to2: WrappedResultSet => Option[B2], to3: WrappedResultSet => Option[B3], to4: WrappedResultSet => Option[B4]
  ): OneToManies4SQL[A, B1, B2, B3, B4, E, Z] = {
    val q: OneToManies4SQL[A, B1, B2, B3, B4, E, Z] = new OneToManies4SQL(
      statement, rawParameters)(one)(to1, to2, to3, to4)((a, _, _, _, _) => a.asInstanceOf[Z])
    q.queryTimeout(queryTimeout)
    q.fetchSize(fetchSize)
    q.tags(tags.toSeq*)
  }

  def toManies[B1, B2, B3, B4, B5](
    to1: WrappedResultSet => Option[B1], to2: WrappedResultSet => Option[B2], to3: WrappedResultSet => Option[B3], to4: WrappedResultSet => Option[B4], to5: WrappedResultSet => Option[B5]
  ): OneToManies5SQL[A, B1, B2, B3, B4, B5, E, Z] = {
    val q: OneToManies5SQL[A, B1, B2, B3, B4, B5, E, Z] = new OneToManies5SQL(
      statement, rawParameters)(one)(to1, to2, to3, to4, to5)((a, _, _, _, _, _) => a.asInstanceOf[Z])
    q.queryTimeout(queryTimeout)
    q.fetchSize(fetchSize)
    q.tags(tags.toSeq*)
  }

  def toManies[B1, B2, B3, B4, B5, B6](
    to1: WrappedResultSet => Option[B1], to2: WrappedResultSet => Option[B2], to3: WrappedResultSet => Option[B3], to4: WrappedResultSet => Option[B4], to5: WrappedResultSet => Option[B5], to6: WrappedResultSet => Option[B6]
  ): OneToManies6SQL[A, B1, B2, B3, B4, B5, B6, E, Z] = {
    val q: OneToManies6SQL[A, B1, B2, B3, B4, B5, B6, E, Z] = new OneToManies6SQL(
      statement, rawParameters)(one)(to1, to2, to3, to4, to5, to6)((a, _, _, _, _, _, _) => a.asInstanceOf[Z])
    q.queryTimeout(queryTimeout)
    q.fetchSize(fetchSize)
    q.tags(tags.toSeq*)
  }

  def toManies[B1, B2, B3, B4, B5, B6, B7](
    to1: WrappedResultSet => Option[B1], to2: WrappedResultSet => Option[B2], to3: WrappedResultSet => Option[B3], to4: WrappedResultSet => Option[B4], to5: WrappedResultSet => Option[B5], to6: WrappedResultSet => Option[B6], to7: WrappedResultSet => Option[B7]
  ): OneToManies7SQL[A, B1, B2, B3, B4, B5, B6, B7, E, Z] = {
    val q: OneToManies7SQL[A, B1, B2, B3, B4, B5, B6, B7, E, Z] = new OneToManies7SQL(
      statement, rawParameters)(one)(to1, to2, to3, to4, to5, to6, to7)((a, _, _, _, _, _, _, _) => a.asInstanceOf[Z])
    q.queryTimeout(queryTimeout)
    q.fetchSize(fetchSize)
    q.tags(tags.toSeq*)
  }

  def toManies[B1, B2, B3, B4, B5, B6, B7, B8](
    to1: WrappedResultSet => Option[B1], to2: WrappedResultSet => Option[B2], to3: WrappedResultSet => Option[B3], to4: WrappedResultSet => Option[B4], to5: WrappedResultSet => Option[B5], to6: WrappedResultSet => Option[B6], to7: WrappedResultSet => Option[B7], to8: WrappedResultSet => Option[B8]
  ): OneToManies8SQL[A, B1, B2, B3, B4, B5, B6, B7, B8, E, Z] = {
    val q: OneToManies8SQL[A, B1, B2, B3, B4, B5, B6, B7, B8, E, Z] = new OneToManies8SQL(
      statement, rawParameters)(one)(to1, to2, to3, to4, to5, to6, to7, to8)((a, _, _, _, _, _, _, _, _) => a.asInstanceOf[Z])
    q.queryTimeout(queryTimeout)
    q.fetchSize(fetchSize)
    q.tags(tags.toSeq*)
  }

  def toManies[B1, B2, B3, B4, B5, B6, B7, B8, B9](
    to1: WrappedResultSet => Option[B1], to2: WrappedResultSet => Option[B2], to3: WrappedResultSet => Option[B3], to4: WrappedResultSet => Option[B4], to5: WrappedResultSet => Option[B5], to6: WrappedResultSet => Option[B6], to7: WrappedResultSet => Option[B7], to8: WrappedResultSet => Option[B8], to9: WrappedResultSet => Option[B9]
  ): OneToManies9SQL[A, B1, B2, B3, B4, B5, B6, B7, B8, B9, E, Z] = {
    val q: OneToManies9SQL[A, B1, B2, B3, B4, B5, B6, B7, B8, B9, E, Z] = new OneToManies9SQL(
      statement, rawParameters)(one)(to1, to2, to3, to4, to5, to6, to7, to8, to9)((a, _, _, _, _, _, _, _, _, _) => a.asInstanceOf[Z])
    q.queryTimeout(queryTimeout)
    q.fetchSize(fetchSize)
    q.tags(tags.toSeq*)
  }

  def toManies[B1, B2, B3, B4, B5, B6, B7, B8, B9, B10](
    to1: WrappedResultSet => Option[B1], to2: WrappedResultSet => Option[B2], to3: WrappedResultSet => Option[B3], to4: WrappedResultSet => Option[B4], to5: WrappedResultSet => Option[B5], to6: WrappedResultSet => Option[B6], to7: WrappedResultSet => Option[B7], to8: WrappedResultSet => Option[B8], to9: WrappedResultSet => Option[B9], to10: WrappedResultSet => Option[B10]
  ): OneToManies10SQL[A, B1, B2, B3, B4, B5, B6, B7, B8, B9, B10, E, Z] = {
    val q: OneToManies10SQL[A, B1, B2, B3, B4, B5, B6, B7, B8, B9, B10, E, Z] = new OneToManies10SQL(
      statement, rawParameters)(one)(to1, to2, to3, to4, to5, to6, to7, to8, to9, to10)((a, _, _, _, _, _, _, _, _, _, _) => a.asInstanceOf[Z])
    q.queryTimeout(queryTimeout)
    q.fetchSize(fetchSize)
    q.tags(tags.toSeq*)
  }

  def toManies[B1, B2, B3, B4, B5, B6, B7, B8, B9, B10, B11](
    to1: WrappedResultSet => Option[B1], to2: WrappedResultSet => Option[B2], to3: WrappedResultSet => Option[B3], to4: WrappedResultSet => Option[B4], to5: WrappedResultSet => Option[B5], to6: WrappedResultSet => Option[B6], to7: WrappedResultSet => Option[B7], to8: WrappedResultSet => Option[B8], to9: WrappedResultSet => Option[B9], to10: WrappedResultSet => Option[B10], to11: WrappedResultSet => Option[B11]
  ): OneToManies11SQL[A, B1, B2, B3, B4, B5, B6, B7, B8, B9, B10, B11, E, Z] = {
    val q: OneToManies11SQL[A, B1, B2, B3, B4, B5, B6, B7, B8, B9, B10, B11, E, Z] = new OneToManies11SQL(
      statement, rawParameters)(one)(to1, to2, to3, to4, to5, to6, to7, to8, to9, to10, to11)((a, _, _, _, _, _, _, _, _, _, _, _) => a.asInstanceOf[Z])
    q.queryTimeout(queryTimeout)
    q.fetchSize(fetchSize)
    q.tags(tags.toSeq*)
  }

  def toManies[B1, B2, B3, B4, B5, B6, B7, B8, B9, B10, B11, B12](
    to1: WrappedResultSet => Option[B1], to2: WrappedResultSet => Option[B2], to3: WrappedResultSet => Option[B3], to4: WrappedResultSet => Option[B4], to5: WrappedResultSet => Option[B5], to6: WrappedResultSet => Option[B6], to7: WrappedResultSet => Option[B7], to8: WrappedResultSet => Option[B8], to9: WrappedResultSet => Option[B9], to10: WrappedResultSet => Option[B10], to11: WrappedResultSet => Option[B11], to12: WrappedResultSet => Option[B12]
  ): OneToManies12SQL[A, B1, B2, B3, B4, B5, B6, B7, B8, B9, B10, B11, B12, E, Z] = {
    val q: OneToManies12SQL[A, B1, B2, B3, B4, B5, B6, B7, B8, B9, B10, B11, B12, E, Z] = new OneToManies12SQL(
      statement, rawParameters)(one)(to1, to2, to3, to4, to5, to6, to7, to8, to9, to10, to11, to12)((a, _, _, _, _, _, _, _, _, _, _, _, _) => a.asInstanceOf[Z])
    q.queryTimeout(queryTimeout)
    q.fetchSize(fetchSize)
    q.tags(tags.toSeq*)
  }

  def toManies[B1, B2, B3, B4, B5, B6, B7, B8, B9, B10, B11, B12, B13](
    to1: WrappedResultSet => Option[B1], to2: WrappedResultSet => Option[B2], to3: WrappedResultSet => Option[B3], to4: WrappedResultSet => Option[B4], to5: WrappedResultSet => Option[B5], to6: WrappedResultSet => Option[B6], to7: WrappedResultSet => Option[B7], to8: WrappedResultSet => Option[B8], to9: WrappedResultSet => Option[B9], to10: WrappedResultSet => Option[B10], to11: WrappedResultSet => Option[B11], to12: WrappedResultSet => Option[B12], to13: WrappedResultSet => Option[B13]
  ): OneToManies13SQL[A, B1, B2, B3, B4, B5, B6, B7, B8, B9, B10, B11, B12, B13, E, Z] = {
    val q: OneToManies13SQL[A, B1, B2, B3, B4, B5, B6, B7, B8, B9, B10, B11, B12, B13, E, Z] = new OneToManies13SQL(
      statement, rawParameters)(one)(to1, to2, to3, to4, to5, to6, to7, to8, to9, to10, to11, to12, to13)((a, _, _, _, _, _, _, _, _, _, _, _, _, _) => a.asInstanceOf[Z])
    q.queryTimeout(queryTimeout)
    q.fetchSize(fetchSize)
    q.tags(tags.toSeq*)
  }

  def toManies[B1, B2, B3, B4, B5, B6, B7, B8, B9, B10, B11, B12, B13, B14](
    to1: WrappedResultSet => Option[B1], to2: WrappedResultSet => Option[B2], to3: WrappedResultSet => Option[B3], to4: WrappedResultSet => Option[B4], to5: WrappedResultSet => Option[B5], to6: WrappedResultSet => Option[B6], to7: WrappedResultSet => Option[B7], to8: WrappedResultSet => Option[B8], to9: WrappedResultSet => Option[B9], to10: WrappedResultSet => Option[B10], to11: WrappedResultSet => Option[B11], to12: WrappedResultSet => Option[B12], to13: WrappedResultSet => Option[B13], to14: WrappedResultSet => Option[B14]
  ): OneToManies14SQL[A, B1, B2, B3, B4, B5, B6, B7, B8, B9, B10, B11, B12, B13, B14, E, Z] = {
    val q: OneToManies14SQL[A, B1, B2, B3, B4, B5, B6, B7, B8, B9, B10, B11, B12, B13, B14, E, Z] = new OneToManies14SQL(
      statement, rawParameters)(one)(to1, to2, to3, to4, to5, to6, to7, to8, to9, to10, to11, to12, to13, to14)((a, _, _, _, _, _, _, _, _, _, _, _, _, _, _) => a.asInstanceOf[Z])
    q.queryTimeout(queryTimeout)
    q.fetchSize(fetchSize)
    q.tags(tags.toSeq*)
  }

  def toManies[B1, B2, B3, B4, B5, B6, B7, B8, B9, B10, B11, B12, B13, B14, B15](
    to1: WrappedResultSet => Option[B1], to2: WrappedResultSet => Option[B2], to3: WrappedResultSet => Option[B3], to4: WrappedResultSet => Option[B4], to5: WrappedResultSet => Option[B5], to6: WrappedResultSet => Option[B6], to7: WrappedResultSet => Option[B7], to8: WrappedResultSet => Option[B8], to9: WrappedResultSet => Option[B9], to10: WrappedResultSet => Option[B10], to11: WrappedResultSet => Option[B11], to12: WrappedResultSet => Option[B12], to13: WrappedResultSet => Option[B13], to14: WrappedResultSet => Option[B14], to15: WrappedResultSet => Option[B15]
  ): OneToManies15SQL[A, B1, B2, B3, B4, B5, B6, B7, B8, B9, B10, B11, B12, B13, B14, B15, E, Z] = {
    val q: OneToManies15SQL[A, B1, B2, B3, B4, B5, B6, B7, B8, B9, B10, B11, B12, B13, B14, B15, E, Z] = new OneToManies15SQL(
      statement, rawParameters)(one)(to1, to2, to3, to4, to5, to6, to7, to8, to9, to10, to11, to12, to13, to14, to15)((a, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _) => a.asInstanceOf[Z])
    q.queryTimeout(queryTimeout)
    q.fetchSize(fetchSize)
    q.tags(tags.toSeq*)
  }

  def toManies[B1, B2, B3, B4, B5, B6, B7, B8, B9, B10, B11, B12, B13, B14, B15, B16](
    to1: WrappedResultSet => Option[B1], to2: WrappedResultSet => Option[B2], to3: WrappedResultSet => Option[B3], to4: WrappedResultSet => Option[B4], to5: WrappedResultSet => Option[B5], to6: WrappedResultSet => Option[B6], to7: WrappedResultSet => Option[B7], to8: WrappedResultSet => Option[B8], to9: WrappedResultSet => Option[B9], to10: WrappedResultSet => Option[B10], to11: WrappedResultSet => Option[B11], to12: WrappedResultSet => Option[B12], to13: WrappedResultSet => Option[B13], to14: WrappedResultSet => Option[B14], to15: WrappedResultSet => Option[B15], to16: WrappedResultSet => Option[B16]
  ): OneToManies16SQL[A, B1, B2, B3, B4, B5, B6, B7, B8, B9, B10, B11, B12, B13, B14, B15, B16, E, Z] = {
    val q: OneToManies16SQL[A, B1, B2, B3, B4, B5, B6, B7, B8, B9, B10, B11, B12, B13, B14, B15, B16, E, Z] = new OneToManies16SQL(
      statement, rawParameters)(one)(to1, to2, to3, to4, to5, to6, to7, to8, to9, to10, to11, to12, to13, to14, to15, to16)((a, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _) => a.asInstanceOf[Z])
    q.queryTimeout(queryTimeout)
    q.fetchSize(fetchSize)
    q.tags(tags.toSeq*)
  }

  def toManies[B1, B2, B3, B4, B5, B6, B7, B8, B9, B10, B11, B12, B13, B14, B15, B16, B17](
    to1: WrappedResultSet => Option[B1], to2: WrappedResultSet => Option[B2], to3: WrappedResultSet => Option[B3], to4: WrappedResultSet => Option[B4], to5: WrappedResultSet => Option[B5], to6: WrappedResultSet => Option[B6], to7: WrappedResultSet => Option[B7], to8: WrappedResultSet => Option[B8], to9: WrappedResultSet => Option[B9], to10: WrappedResultSet => Option[B10], to11: WrappedResultSet => Option[B11], to12: WrappedResultSet => Option[B12], to13: WrappedResultSet => Option[B13], to14: WrappedResultSet => Option[B14], to15: WrappedResultSet => Option[B15], to16: WrappedResultSet => Option[B16], to17: WrappedResultSet => Option[B17]
  ): OneToManies17SQL[A, B1, B2, B3, B4, B5, B6, B7, B8, B9, B10, B11, B12, B13, B14, B15, B16, B17, E, Z] = {
    val q: OneToManies17SQL[A, B1, B2, B3, B4, B5, B6, B7, B8, B9, B10, B11, B12, B13, B14, B15, B16, B17, E, Z] = new OneToManies17SQL(
      statement, rawParameters)(one)(to1, to2, to3, to4, to5, to6, to7, to8, to9, to10, to11, to12, to13, to14, to15, to16, to17)((a, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _) => a.asInstanceOf[Z])
    q.queryTimeout(queryTimeout)
    q.fetchSize(fetchSize)
    q.tags(tags.toSeq*)
  }

  def toManies[B1, B2, B3, B4, B5, B6, B7, B8, B9, B10, B11, B12, B13, B14, B15, B16, B17, B18](
    to1: WrappedResultSet => Option[B1], to2: WrappedResultSet => Option[B2], to3: WrappedResultSet => Option[B3], to4: WrappedResultSet => Option[B4], to5: WrappedResultSet => Option[B5], to6: WrappedResultSet => Option[B6], to7: WrappedResultSet => Option[B7], to8: WrappedResultSet => Option[B8], to9: WrappedResultSet => Option[B9], to10: WrappedResultSet => Option[B10], to11: WrappedResultSet => Option[B11], to12: WrappedResultSet => Option[B12], to13: WrappedResultSet => Option[B13], to14: WrappedResultSet => Option[B14], to15: WrappedResultSet => Option[B15], to16: WrappedResultSet => Option[B16], to17: WrappedResultSet => Option[B17], to18: WrappedResultSet => Option[B18]
  ): OneToManies18SQL[A, B1, B2, B3, B4, B5, B6, B7, B8, B9, B10, B11, B12, B13, B14, B15, B16, B17, B18, E, Z] = {
    val q: OneToManies18SQL[A, B1, B2, B3, B4, B5, B6, B7, B8, B9, B10, B11, B12, B13, B14, B15, B16, B17, B18, E, Z] = new OneToManies18SQL(
      statement, rawParameters)(one)(to1, to2, to3, to4, to5, to6, to7, to8, to9, to10, to11, to12, to13, to14, to15, to16, to17, to18)((a, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _) => a.asInstanceOf[Z])
    q.queryTimeout(queryTimeout)
    q.fetchSize(fetchSize)
    q.tags(tags.toSeq*)
  }

  def toManies[B1, B2, B3, B4, B5, B6, B7, B8, B9, B10, B11, B12, B13, B14, B15, B16, B17, B18, B19](
    to1: WrappedResultSet => Option[B1], to2: WrappedResultSet => Option[B2], to3: WrappedResultSet => Option[B3], to4: WrappedResultSet => Option[B4], to5: WrappedResultSet => Option[B5], to6: WrappedResultSet => Option[B6], to7: WrappedResultSet => Option[B7], to8: WrappedResultSet => Option[B8], to9: WrappedResultSet => Option[B9], to10: WrappedResultSet => Option[B10], to11: WrappedResultSet => Option[B11], to12: WrappedResultSet => Option[B12], to13: WrappedResultSet => Option[B13], to14: WrappedResultSet => Option[B14], to15: WrappedResultSet => Option[B15], to16: WrappedResultSet => Option[B16], to17: WrappedResultSet => Option[B17], to18: WrappedResultSet => Option[B18], to19: WrappedResultSet => Option[B19]
  ): OneToManies19SQL[A, B1, B2, B3, B4, B5, B6, B7, B8, B9, B10, B11, B12, B13, B14, B15, B16, B17, B18, B19, E, Z] = {
    val q: OneToManies19SQL[A, B1, B2, B3, B4, B5, B6, B7, B8, B9, B10, B11, B12, B13, B14, B15, B16, B17, B18, B19, E, Z] = new OneToManies19SQL(
      statement, rawParameters)(one)(to1, to2, to3, to4, to5, to6, to7, to8, to9, to10, to11, to12, to13, to14, to15, to16, to17, to18, to19)((a, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _) => a.asInstanceOf[Z])
    q.queryTimeout(queryTimeout)
    q.fetchSize(fetchSize)
    q.tags(tags.toSeq*)
  }

  def toManies[B1, B2, B3, B4, B5, B6, B7, B8, B9, B10, B11, B12, B13, B14, B15, B16, B17, B18, B19, B20](
    to1: WrappedResultSet => Option[B1], to2: WrappedResultSet => Option[B2], to3: WrappedResultSet => Option[B3], to4: WrappedResultSet => Option[B4], to5: WrappedResultSet => Option[B5], to6: WrappedResultSet => Option[B6], to7: WrappedResultSet => Option[B7], to8: WrappedResultSet => Option[B8], to9: WrappedResultSet => Option[B9], to10: WrappedResultSet => Option[B10], to11: WrappedResultSet => Option[B11], to12: WrappedResultSet => Option[B12], to13: WrappedResultSet => Option[B13], to14: WrappedResultSet => Option[B14], to15: WrappedResultSet => Option[B15], to16: WrappedResultSet => Option[B16], to17: WrappedResultSet => Option[B17], to18: WrappedResultSet => Option[B18], to19: WrappedResultSet => Option[B19], to20: WrappedResultSet => Option[B20]
  ): OneToManies20SQL[A, B1, B2, B3, B4, B5, B6, B7, B8, B9, B10, B11, B12, B13, B14, B15, B16, B17, B18, B19, B20, E, Z] = {
    val q: OneToManies20SQL[A, B1, B2, B3, B4, B5, B6, B7, B8, B9, B10, B11, B12, B13, B14, B15, B16, B17, B18, B19, B20, E, Z] = new OneToManies20SQL(
      statement, rawParameters)(one)(to1, to2, to3, to4, to5, to6, to7, to8, to9, to10, to11, to12, to13, to14, to15, to16, to17, to18, to19, to20)((a, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _) => a.asInstanceOf[Z])
    q.queryTimeout(queryTimeout)
    q.fetchSize(fetchSize)
    q.tags(tags.toSeq*)
  }

  def toManies[B1, B2, B3, B4, B5, B6, B7, B8, B9, B10, B11, B12, B13, B14, B15, B16, B17, B18, B19, B20, B21](
    to1: WrappedResultSet => Option[B1], to2: WrappedResultSet => Option[B2], to3: WrappedResultSet => Option[B3], to4: WrappedResultSet => Option[B4], to5: WrappedResultSet => Option[B5], to6: WrappedResultSet => Option[B6], to7: WrappedResultSet => Option[B7], to8: WrappedResultSet => Option[B8], to9: WrappedResultSet => Option[B9], to10: WrappedResultSet => Option[B10], to11: WrappedResultSet => Option[B11], to12: WrappedResultSet => Option[B12], to13: WrappedResultSet => Option[B13], to14: WrappedResultSet => Option[B14], to15: WrappedResultSet => Option[B15], to16: WrappedResultSet => Option[B16], to17: WrappedResultSet => Option[B17], to18: WrappedResultSet => Option[B18], to19: WrappedResultSet => Option[B19], to20: WrappedResultSet => Option[B20], to21: WrappedResultSet => Option[B21]
  ): OneToManies21SQL[A, B1, B2, B3, B4, B5, B6, B7, B8, B9, B10, B11, B12, B13, B14, B15, B16, B17, B18, B19, B20, B21, E, Z] = {
    val q: OneToManies21SQL[A, B1, B2, B3, B4, B5, B6, B7, B8, B9, B10, B11, B12, B13, B14, B15, B16, B17, B18, B19, B20, B21, E, Z] = new OneToManies21SQL(
      statement, rawParameters)(one)(to1, to2, to3, to4, to5, to6, to7, to8, to9, to10, to11, to12, to13, to14, to15, to16, to17, to18, to19, to20, to21)((a, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _) => a.asInstanceOf[Z])
    q.queryTimeout(queryTimeout)
    q.fetchSize(fetchSize)
    q.tags(tags.toSeq*)
  }


}

object OneToXSQL {
  def unapply[A, E <: WithExtractor, Z](sqlObject: OneToXSQL[A, E, Z]): Some[(String, scala.collection.Seq[Any], WrappedResultSet => A)] = {
    Some((sqlObject.statement, sqlObject.rawParameters, sqlObject.one))
  }
  def handleException(e: Exception): Nothing = e match {
    case invalidColumn: InvalidColumnNameException =>
      throw new ResultSetExtractorException(
        "Failed to extract ResultSet because the specified column name (" + invalidColumn.name + ") is invalid." +
          " If you're using SQLInterpolation, you may mistake u.id for u.resultName.id.")
    case e: Exception => throw e
  }
}