(22 개) 필드는 2.11 + 프레임 워크 2.3 케이스 클래스와 함수 플레이 스칼라 제한

스칼라 2.11 밖으로 및 사례 클래스의 22 개 필드 제한 (스칼라 문제, 릴리스 노트) 해결 될 것으로 보인다.

내가 플레이 + 포스트 그레스 비동기에서 22 개 이상의 필드가 모델 데이터베이스 개체에 케이스 클래스를 사용하기 때문에이 잠시 동안 나를 위해 문제가되고있다. 스칼라 2.10에서 내 솔루션은 여러 경우 클래스로 모델을 깰했지만, 나는 유지하고 확장하기 위해 열심히 해결책을 찾아, 나는 2.3.0-RC1 + 스칼라 2.11 플레이로 전환 한 후 아래에 설명 된대로 내가 뭔가를 구현할 수있는 기대했다. 0 :

package entities

case class MyDbEntity(
  id: String,
  field1: String,
  field2: Boolean,
  field3: String,
  field4: String,
  field5: String,
  field6: String,
  field7: String,
  field8: String,
  field9: String,
  field10: String,
  field11: String,
  field12: String,
  field13: String,
  field14: String,
  field15: String,
  field16: String,
  field17: String,
  field18: String,
  field19: String,
  field20: String,
  field21: String,
  field22: String,
  field23: String,
) 

object MyDbEntity {
  import play.api.libs.json.Json
  import play.api.data._
  import play.api.data.Forms._

  implicit val entityReads = Json.reads[MyDbEntity]
  implicit val entityWrites = Json.writes[MyDbEntity]
}

위의 코드는 모두 "읽기"에 대한 다음과 같은 메시지와 쓰기 ""와 함께 컴파일에 실패 :

없음 적용 취소 기능 발견

은 "읽습니다"와에 쓴다 ""업데이트 :

  implicit val entityReads: Reads[MyDbEntity] = (
    (__ \ "id").read[Long] and
    (__ \ "field_1").read[String]
    ........
  )(MyDbEntity.apply _)  

  implicit val postWrites: Writes[MyDbEntity] = (
    (__ \ "id").write[Long] and
    (__ \ "user").write[String]
    ........
  )(unlift(MyDbEntity.unapply))

또한 작동하지 않습니다

  implementation restricts functions to 22 parameters

  value unapply is not a member of object models.MyDbEntity

나의 이해는 스칼라 2.11 여전히 기능에 대한 몇 가지 제한 사항이 아직 가능하지 않다 내가 무엇을 상기 한 바와 같은 그 무언가를 가지고 있다는 것입니다. 난 아직 지원되지는 주요 사용자 사례의 하나가 케이스 클래스에 대한 제한 해제의 혜택을 볼 수 없습니다 이것은 내가 모르는 뭔가가있어 만약 내가 궁금하네요 그래서, 나에게 이상한 것 같다.

문제 또는 구현 세부 사항에 대한 포인터 환영 이상입니다! 감사!

해결법

==============================

1.이것은 여러 가지 이유에 대한 상자에서, 할 수 없습니다 :

이것은 여러 가지 이유에 대한 상자에서, 할 수 없습니다 :

그러나 어느 점에 의해 제 2 바이 패스 할 수있다 :

먼저, 누락 된 FunctionalBuilder을 만드는 :

class CustomFunctionalBuilder[M[_]](canBuild: FunctionalCanBuild[M]) extends FunctionalBuilder {

    class CustomCanBuild22[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22](m1: M[A1 ~ A2 ~ A3 ~ A4 ~ A5 ~ A6 ~ A7 ~ A8 ~ A9 ~ A10 ~ A11 ~ A12 ~ A13 ~ A14 ~ A15 ~ A16 ~ A17 ~ A18 ~ A19 ~ A20 ~ A21], m2: M[A22]) {
def ~[A23](m3: M[A23]) = new CustomCanBuild23[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23](canBuild(m1, m2), m3)

  def and[A23](m3: M[A23]) = this.~(m3)

  def apply[B](f: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22) => B)(implicit fu: Functor[M]): M[B] =
  fu.fmap[A1 ~ A2 ~ A3 ~ A4 ~ A5 ~ A6 ~ A7 ~ A8 ~ A9 ~ A10 ~ A11 ~ A12 ~ A13 ~ A14 ~ A15 ~ A16 ~ A17 ~ A18 ~ A19 ~ A20 ~ A21 ~ A22, B](canBuild(m1, m2), { case a1 ~ a2 ~ a3 ~ a4 ~ a5 ~ a6 ~ a7 ~ a8 ~ a9 ~ a10 ~ a11 ~ a12 ~ a13 ~ a14 ~ a15 ~ a16 ~ a17 ~ a18 ~ a19 ~ a20 ~ a21 ~ a22 => f(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22) })

  def apply[B](f: B => (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22))(implicit fu: ContravariantFunctor[M]): M[B] =
  fu.contramap(canBuild(m1, m2), (b: B) => { val (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22) = f(b); new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(a1, a2), a3), a4), a5), a6), a7), a8), a9), a10), a11), a12), a13), a14), a15), a16), a17), a18), a19), a20), a21), a22) })

  def apply[B](f1: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22) => B, f2: B => (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22))(implicit fu: InvariantFunctor[M]): M[B] =
  fu.inmap[A1 ~ A2 ~ A3 ~ A4 ~ A5 ~ A6 ~ A7 ~ A8 ~ A9 ~ A10 ~ A11 ~ A12 ~ A13 ~ A14 ~ A15 ~ A16 ~ A17 ~ A18 ~ A19 ~ A20 ~ A21 ~ A22, B](
    canBuild(m1, m2), { case a1 ~ a2 ~ a3 ~ a4 ~ a5 ~ a6 ~ a7 ~ a8 ~ a9 ~ a10 ~ a11 ~ a12 ~ a13 ~ a14 ~ a15 ~ a16 ~ a17 ~ a18 ~ a19 ~ a20 ~ a21 ~ a22 => f1(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22) },
    (b: B) => { val (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22) = f2(b); new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(new ~(a1, a2), a3), a4), a5), a6), a7), a8), a9), a10), a11), a12), a13), a14), a15), a16), a17), a18), a19), a20), a21), a22) }
  )

  def join[A >: A1](implicit witness1: <:<[A, A1], witness2: <:<[A, A2], witness3: <:<[A, A3], witness4: <:<[A, A4], witness5: <:<[A, A5], witness6: <:<[A, A6], witness7: <:<[A, A7], witness8: <:<[A, A8], witness9: <:<[A, A9], witness10: <:<[A, A10], witness11: <:<[A, A11], witness12: <:<[A, A12], witness13: <:<[A, A13], witness14: <:<[A, A14], witness15: <:<[A, A15], witness16: <:<[A, A16], witness17: <:<[A, A17], witness18: <:<[A, A18], witness19: <:<[A, A19], witness20: <:<[A, A20], witness21: <:<[A, A21], witness22: <:<[A, A22], fu: ContravariantFunctor[M]): M[A] =
  apply[A]((a: A) => (a: A1, a: A2, a: A3, a: A4, a: A5, a: A6, a: A7, a: A8, a: A9, a: A10, a: A11, a: A12, a: A13, a: A14, a: A15, a: A16, a: A17, a: A18, a: A19, a: A20, a: A21, a: A22))(fu)

  def reduce[A >: A1, B](implicit witness1: <:<[A1, A], witness2: <:<[A2, A], witness3: <:<[A3, A], witness4: <:<[A4, A], witness5: <:<[A5, A], witness6: <:<[A6, A], witness7: <:<[A7, A], witness8: <:<[A8, A], witness9: <:<[A9, A], witness10: <:<[A10, A], witness11: <:<[A11, A], witness12: <:<[A12, A], witness13: <:<[A13, A], witness14: <:<[A14, A], witness15: <:<[A15, A], witness16: <:<[A16, A], witness17: <:<[A17, A], witness18: <:<[A18, A], witness19: <:<[A19, A], witness20: <:<[A20, A], witness21: <:<[A21, A], witness22: <:<[A22, A], fu: Functor[M], reducer: Reducer[A, B]): M[B] =
  apply[B]((a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6, a7: A7, a8: A8, a9: A9, a10: A10, a11: A11, a12: A12, a13: A13, a14: A14, a15: A15, a16: A16, a17: A17, a18: A18, a19: A19, a20: A20, a21: A21, a22: A22) =>  reducer.append(reducer.append(reducer.append(reducer.append(reducer.append(reducer.append(reducer.append(reducer.append(reducer.append(reducer.append(reducer.append(reducer.append(reducer.append(reducer.append(reducer.append(reducer.append(reducer.append(reducer.append(reducer.append(reducer.append(reducer.append(reducer.unit(a1: A), a2: A), a3: A), a4: A), a5: A), a6: A), a7: A), a8: A), a9: A), a10: A), a11: A), a12: A), a13: A), a14: A), a15: A), a16: A), a17: A), a18: A), a19: A), a20: A), a21: A), a22: A))(fu)

  def tupled(implicit v: VariantExtractor[M]): M[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22)] =
  v match {
    case FunctorExtractor(fu) => apply { (a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6, a7: A7, a8: A8, a9: A9, a10: A10, a11: A11, a12: A12, a13: A13, a14: A14, a15: A15, a16: A16, a17: A17, a18: A18, a19: A19, a20: A20, a21: A21, a22: A22) => (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22) }(fu)
    case ContravariantFunctorExtractor(fu) => apply[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22)] { (a: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22)) => (a._1, a._2, a._3, a._4, a._5, a._6, a._7, a._8, a._9, a._10, a._11, a._12, a._13, a._14, a._15, a._16, a._17, a._18, a._19, a._20, a._21, a._22) }(fu)
    case InvariantFunctorExtractor(fu) => apply[(A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22)]({ (a1: A1, a2: A2, a3: A3, a4: A4, a5: A5, a6: A6, a7: A7, a8: A8, a9: A9, a10: A10, a11: A11, a12: A12, a13: A13, a14: A14, a15: A15, a16: A16, a17: A17, a18: A18, a19: A19, a20: A20, a21: A21, a22: A22) => (a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22) }, { (a: (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22)) => (a._1, a._2, a._3, a._4, a._5, a._6, a._7, a._8, a._9, a._10, a._11, a._12, a._13, a._14, a._15, a._16, a._17, a._18, a._19, a._20, a._21, a._22) })(fu)
    }

  }

  class CustomCanBuild23[A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12, A13, A14, A15, A16, A17, A18, A19, A20, A21, A22, A23](m1: M[A1 ~ A2 ~ A3 ~ A4 ~ A5 ~ A6 ~ A7 ~ A8 ~ A9 ~ A10 ~ A11 ~ A12 ~ A13 ~ A14 ~ A15 ~ A16 ~ A17 ~ A18 ~ A19 ~ A20 ~ A21 ~ A22], m2: M[A23]) {
  }

}

다음 자신의 FunctionalBuilderOps 인스턴스를 제공함으로써 :

implicit def customToFunctionalBuilderOps[M[_], A](a: M[A])(implicit fcb: FunctionalCanBuild[M]) = new CustomFunctionalBuilderOps[M, A](a)(fcb)

마지막으로, 첫 번째 점에 대해 나는 현재 구현을 단순화하기 위해 시도하는 풀 요청을 보냈습니다.

==============================

2.우리는 또한 여러 경우 클래스로 우리의 모델을 파괴했지만,이 신속하게 관리하기 어려운되고 있었다. 우리는 자동으로하지 않습니다 (우리는 우리의 객체 관계형 매퍼로 슬릭를 사용하고 슬릭 2.0은 우리가 (방법을 적용하여 와서 모방 경우 클래스에 생성자를 복사) JSON에서 인스턴스화 모델에 대한 방법과 함께 클래스를 생성하는 데 사용하는 코드 생성기와 함께 제공 우리가) 처리하는 너무 많은 특별한 경우가 있기 때문에 JSON으로 모델을 변환하는 방법을 생성합니다. 슬릭 코드 생성기를 사용하면 객체 관계형 매퍼로 슬릭를 사용할 필요가 없습니다.

우리는 또한 여러 경우 클래스로 우리의 모델을 파괴했지만,이 신속하게 관리하기 어려운되고 있었다. 우리는 자동으로하지 않습니다 (우리는 우리의 객체 관계형 매퍼로 슬릭를 사용하고 슬릭 2.0은 우리가 (방법을 적용하여 와서 모방 경우 클래스에 생성자를 복사) JSON에서 인스턴스화 모델에 대한 방법과 함께 클래스를 생성하는 데 사용하는 코드 생성기와 함께 제공 우리가) 처리하는 너무 많은 특별한 경우가 있기 때문에 JSON으로 모델을 변환하는 방법을 생성합니다. 슬릭 코드 생성기를 사용하면 객체 관계형 매퍼로 슬릭를 사용할 필요가 없습니다.

이 방법은 어느 인스턴스화 새로운 모델을 JSObject가 및 용법을 취하거나 기존 모델 업데이트 -이 코드 생성기에 대한 입력의 일부분이다.

private def getItem(original: Option[${name}], json: JsObject, trackingData: TrackingData)(implicit session: scala.slick.session.Session): Try[${name}] = {
  preProcess("$name", columnSet, json, trackingData).flatMap(updatedJson => {
    ${indent(indent(indent(entityColumnsSansId.map(c => s"""val ${c.name}_Parsed = parseJsonField[${c.exposedType}](original.map(_.${c.name}), "${c.name}", updatedJson, "${c.exposedType}")""").mkString("\n"))))}
    val errs = Seq(${indent(indent(indent(indent(entityColumnsSansId.map(c => s"${c.name}_Parsed.map(_ => ())").mkString(", ")))))}).condenseUnit
    for {
      _ <- errs
      ${indent(indent(indent(indent(entityColumnsSansId.map(c => s"${c.name}_Val <- ${c.name}_Parsed").mkString("\n")))))}
    } yield {
      original.map(_.copy(${entityColumnsSansId.map(c => s"${c.name} = ${c.name}_Val").mkString(", ")}))
        .getOrElse(${name}.apply(id = None, ${entityColumnsSansId.map(c => s"${c.name} = ${c.name}_Val").mkString(", ")}))
    }
  })
}

예를 들어, 우리 ActivityLog 모델이 다음과 같은 코드를 생성합니다. 경우 "원래는"다음이가 "createFromJson"메소드에서 호출되는 것도없고 우리는 새로운 모델의 인스턴스; "원래"경우에하는 것은 다음이는 "updateFromJson"메소드에서 호출되고 있으며, 우리는 기존 모델을 업데이트 일부 (activityLog)입니다. 은 "condenseUnit"메소드가 호출되는 "브로 잘못한다 ... ="라인이 서열은 [장치] 시도] 취하고 시도 생성 [단위]; 서열은 다음 시도를 오류가있는 경우 [단위]는 예외 메시지를 연결합니다. parseJsonField 및 parseField 방법은 생성되지 않습니다 - 그들은 단지 생성 된 코드에서 참조하고 있습니다.

private def parseField[T](name: String, json: JsObject, tpe: String)(implicit r: Reads[T]): Try[T] = {
  Try((json \ name).as[T]).recoverWith {
    case e: Exception => Failure(new IllegalArgumentException("Failed to parse " + Json.stringify(json \ name) + " as " + name + " : " + tpe))
  }
}

def parseJsonField[T](default: Option[T], name: String, json: JsObject, tpe: String)(implicit r: Reads[T]): Try[T] = {
  default match {
    case Some(t) => if(json.keys.contains(name)) parseField(name, json, tpe)(r) else Try(t)
    case _ => parseField(name, json, tpe)(r)
  }
}

private def getItem(original: Option[ActivityLog], json: JsObject, trackingData: TrackingData)(implicit session: scala.slick.session.Session): Try[ActivityLog] = {
  preProcess("ActivityLog", columnSet, json, trackingData).flatMap(updatedJson => {
    val user_id_Parsed = parseJsonField[Option[Int]](original.map(_.user_id), "user_id", updatedJson, "Option[Int]")
    val user_name_Parsed = parseJsonField[Option[String]](original.map(_.user_name), "user_name", updatedJson, "Option[String]")
    val item_id_Parsed = parseJsonField[Option[String]](original.map(_.item_id), "item_id", updatedJson, "Option[String]")
    val item_item_type_Parsed = parseJsonField[Option[String]](original.map(_.item_item_type), "item_item_type", updatedJson, "Option[String]")
    val item_name_Parsed = parseJsonField[Option[String]](original.map(_.item_name), "item_name", updatedJson, "Option[String]")
    val modified_Parsed = parseJsonField[Option[String]](original.map(_.modified), "modified", updatedJson, "Option[String]")
    val action_name_Parsed = parseJsonField[Option[String]](original.map(_.action_name), "action_name", updatedJson, "Option[String]")
    val remote_ip_Parsed = parseJsonField[Option[String]](original.map(_.remote_ip), "remote_ip", updatedJson, "Option[String]")
    val item_key_Parsed = parseJsonField[Option[String]](original.map(_.item_key), "item_key", updatedJson, "Option[String]")
    val created_at_Parsed = parseJsonField[Option[java.sql.Timestamp]](original.map(_.created_at), "created_at", updatedJson, "Option[java.sql.Timestamp]")
    val as_of_date_Parsed = parseJsonField[Option[java.sql.Timestamp]](original.map(_.as_of_date), "as_of_date", updatedJson, "Option[java.sql.Timestamp]")
    val errs = Seq(user_id_Parsed.map(_ => ()), user_name_Parsed.map(_ => ()), item_id_Parsed.map(_ => ()), item_item_type_Parsed.map(_ => ()), item_name_Parsed.map(_ => ()), modified_Parsed.map(_ => ()), action_name_Parsed.map(_ => ()), remote_ip_Parsed.map(_ => ()), item_key_Parsed.map(_ => ()), created_at_Parsed.map(_ => ()), as_of_date_Parsed.map(_ => ())).condenseUnit
    for {
      _ <- errs
      user_id_Val <- user_id_Parsed
      user_name_Val <- user_name_Parsed
      item_id_Val <- item_id_Parsed
      item_item_type_Val <- item_item_type_Parsed
      item_name_Val <- item_name_Parsed
      modified_Val <- modified_Parsed
      action_name_Val <- action_name_Parsed
      remote_ip_Val <- remote_ip_Parsed
      item_key_Val <- item_key_Parsed
      created_at_Val <- created_at_Parsed
      as_of_date_Val <- as_of_date_Parsed
    } yield {
      original.map(_.copy(user_id = user_id_Val, user_name = user_name_Val, item_id = item_id_Val, item_item_type = item_item_type_Val, item_name = item_name_Val, modified = modified_Val, action_name = action_name_Val, remote_ip = remote_ip_Val, item_key = item_key_Val, created_at = created_at_Val, as_of_date = as_of_date_Val))
        .getOrElse(ActivityLog.apply(id = None, user_id = user_id_Val, user_name = user_name_Val, item_id = item_id_Val, item_item_type = item_item_type_Val, item_name = item_name_Val, modified = modified_Val, action_name = action_name_Val, remote_ip = remote_ip_Val, item_key = item_key_Val, created_at = created_at_Val, as_of_date = as_of_date_Val))
    }
  })
}

==============================
3.당신은 잭슨의 스칼라 모듈을 사용할 수 있습니다. Play의 JSON 기능은 잭슨 스칼라에 내장되어 있습니다. 잭슨은 22 개 이상의 필드를 지원하는 반면 그들이 여기에 22 필드 제한을 넣어 이유를 모르겠어요. 이 함수 호출이 22 개 이상의 매개 변수를 사용할 수 없다는 의미가 있습니다, 그러나 여기이 제한 말도와 차종이 덜 생산적인 장난감을 재생 그래서 우리는 DB 엔티티 내부에 수백 개의 컬럼을 가질 수 있습니다. 이것 좀 봐:

당신은 잭슨의 스칼라 모듈을 사용할 수 있습니다. Play의 JSON 기능은 잭슨 스칼라에 내장되어 있습니다. 잭슨은 22 개 이상의 필드를 지원하는 반면 그들이 여기에 22 필드 제한을 넣어 이유를 모르겠어요. 이 함수 호출이 22 개 이상의 매개 변수를 사용할 수 없다는 의미가 있습니다, 그러나 여기이 제한 말도와 차종이 덜 생산적인 장난감을 재생 그래서 우리는 DB 엔티티 내부에 수백 개의 컬럼을 가질 수 있습니다. 이것 좀 봐:
```
import com.fasterxml.jackson.databind.ObjectMapper
import com.fasterxml.jackson.module.scala.experimental.ScalaObjectMapper
import com.fasterxml.jackson.module.scala.DefaultScalaModule

object JacksonUtil extends App {
  val mapper = new ObjectMapper with ScalaObjectMapper
  mapper.registerModule(DefaultScalaModule)


  val t23 = T23("a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w")

  println(mapper.writeValueAsString(t23))
 }
case class T23(f1:String,f2:String,f3:String,f4:String,f5:String,f6:String,f7:String,
    f8:String,f9:String,f10:String,f11:String,f12:String,f13:String,f14:String,f15:String,
    f16:String,f17:String,f18:String,f19:String,f20:String,f21:String,f22:String,f23:String)
```
==============================
4.케이스의 경우 클래스가 작동하지 않을 수 있습니다; 이러한 경우 중 하나는 케이스 클래스는 22 개 이상의 필드를 취할 수 없다는 것입니다. 또 다른 경우는 사전에 스키마에 대해 알고하지 않는 것이 될 수 있습니다. 이 방식에서, 데이터는 행 객체의 RDD로 로딩된다. 스키마는 별도로 각각의 테이블과 필드를 나타내는 StructType 및 StructField 오브젝트를 사용하여 생성된다. 스키마는 스파크에 DataFrame을 만들 수있는 행 RDD에 적용됩니다.

케이스의 경우 클래스가 작동하지 않을 수 있습니다; 이러한 경우 중 하나는 케이스 클래스는 22 개 이상의 필드를 취할 수 없다는 것입니다. 또 다른 경우는 사전에 스키마에 대해 알고하지 않는 것이 될 수 있습니다. 이 방식에서, 데이터는 행 객체의 RDD로 로딩된다. 스키마는 별도로 각각의 테이블과 필드를 나타내는 StructType 및 StructField 오브젝트를 사용하여 생성된다. 스키마는 스파크에 DataFrame을 만들 수있는 행 RDD에 적용됩니다.
==============================
5.나는 도서관을 만들고 있어요. 이 시도 https://github.com/xuwei-k/play-twenty-three하시기 바랍니다

나는 도서관을 만들고 있어요. 이 시도 https://github.com/xuwei-k/play-twenty-three하시기 바랍니다
==============================
6.나는 볼품없는 "자동 Typeclass 유도"다른 답변에서 제안 된 기반 솔루션을 시도하고, 우리의 모델 일을하지 않았다 - (~ 30 개 필드와 4-10 필드가있는 경우 클래스의 4 개 중첩 된 컬렉션으로 케이스 클래스) StackOverflow의 예외를 던지고 있었다.

나는 볼품없는 "자동 Typeclass 유도"다른 답변에서 제안 된 기반 솔루션을 시도하고, 우리의 모델 일을하지 않았다 - (~ 30 개 필드와 4-10 필드가있는 경우 클래스의 4 개 중첩 된 컬렉션으로 케이스 클래스) StackOverflow의 예외를 던지고 있었다.

그래서 우리는이 솔루션을 채택했고 그것은 완벽했다. ScalaCheck 테스트를 작성하여 있음을 확인했다. 공지 사항, 그것은 JSON 2.4 재생이 필요하다는.
==============================
7.그것은 모두 잘이 핸들을 보인다.

그것은 모두 잘이 핸들을 보인다.

+22 필드의 경우 클래스 포맷 및 더 많은 플레이 JSON에 대한 https://github.com/xdotai/play-json-extensions

지원 스칼라 2.11.x, 2.12.x와 2.13.x 2.3 재생, 2.4, 2.5 및 2.7

그리고 선호하는 솔루션으로 플레이 JSON 문제에서 참조 (아직 통합되지 않음)된다

from https://stackoverflow.com/questions/23571677/22-fields-limit-in-scala-2-11-play-framework-2-3-case-classes-and-functions by cc-by-sa and MIT license

'SCALA' 카테고리의 다른 글

[SCALA] 스칼라 : 같음 / 해시 코드를위한 경우 클래스 필드를 무시? (0)	2019.11.27
[SCALA] 왜 스칼라 패키지 오브젝트 내부 클래스는 dispreferred입니까? (0)	2019.11.27
[SCALA] 왜 스파크는 java.lang.OutOfMemoryError와 함께 실패 않습니다 GC 오버 헤드 제한을 초과? (0)	2019.11.27
[SCALA] 중첩 된 방법의 비용 (0)	2019.11.26
[SCALA] 에게 Heroku에 밀어 수 없습니다 (0)	2019.11.26

복붙노트

[SCALA] (22 개) 필드는 2.11 + 프레임 워크 2.3 케이스 클래스와 함수 플레이 스칼라 제한

(22 개) 필드는 2.11 + 프레임 워크 2.3 케이스 클래스와 함수 플레이 스칼라 제한

해결법

1.이것은 여러 가지 이유에 대한 상자에서, 할 수 없습니다 :

5.나는 도서관을 만들고 있어요. 이 시도 https://github.com/xuwei-k/play-twenty-three하시기 바랍니다

7.그것은 모두 잘이 핸들을 보인다.

'SCALA' 카테고리의 다른 글

티스토리툴바