12

Anormとパーサーコンビネーターを使い始めたばかりです。ボイラープレートコードが非常に多いようです。たとえば、私は

case class Model(
    id:Int,
    field1:String,
    field2:Int,
    // a bunch of fields omitted
)

val ModelParser:RowParser[RegdataStudentClass] = {
  int("id") ~
  str("field1") ~
  int("field2") ~
  // a bunch of fields omitted
  map {
    case id ~ field1 ~ field2 //more omissions
        => Model(id, field1, field2, // still more omissions
           )
  }
}

すべてが定義される前に、各データベースフィールドが4回（！）繰り返されます。パーサーは、ケースクラスから半自動的に推定できるはずです。ここでの作業を減らすために提案するツールやその他のテクニックはありますか？

ポインタをありがとう。

4

2 に答える 2

3

ええと、実際には何も繰り返す必要はありません。を使用flattenしてタプルを作成し、そのタプルからモデルインスタンスを作成できます。

(int("id") ~ str("field1") ~ int("field2"))
  .map(flatten)
  .map { tuple => (Model apply _).tupled(tuple) }

ただし、さらに変換を行う必要がある場合は、タプルを何らかの方法で変更する必要があります。

(int("id") ~ str("field1") ~ int("field2"))
  .map(flatten)
  .map { tuple => (Model apply _).tupled(tuple.copy(_1=..., _2=....) }
于 2012-10-24T16:06:08.040 に答える
3

これが私が最終的に開発したソリューションです。私は現在、これをPlayプロジェクトのクラスとして持っています。スタンドアロンツールに変えることができます（すべきです！）。これを使用するには、tableNamevalをテーブルの名前に変更します。次にmain、クラスの下部にあるを使用して実行します。ケースクラスとパーサーコンビネーターのスケルトンを出力します。ほとんどの場合、これらのスケルトンはほとんど調整する必要がありません。

バイロン

package tools

import scala.sys.process._
import anorm._

/**
 * Generate a parser combinator for a specified table in the database.
 * Right now it's just specified with the val "tableName" a few lines
 * down.  
 * 
 * 20121024 bwbecker
 */
object ParserGenerator {

  val tableName = "uwdata.uwdir_person_by_student_id"


  /** 
   * Convert the sql type to an equivalent Scala type.
   */
  def fieldType(field:MetaDataItem):String = {
    val t = field.clazz match {
      case "java.lang.String" => "String"
      case "java.lang.Boolean" => "Boolean"
      case "java.lang.Integer" => "Int"
      case "java.math.BigDecimal" => "BigDecimal"
      case other => other
    }

    if (field.nullable) "Option[%s]" format (t)
    else t
  }

  /**
   * Drop the schema name from a string (tablename or fieldname)
   */
  def dropSchemaName(str:String):String = 
    str.dropWhile(c => c != '.').drop(1)

  def formatField(field:MetaDataItem):String = {
    "\t" + dropSchemaName(field.column) + " : " + fieldType(field)
  }

  /** 
   * Derive the class name from the table name:  drop the schema,
   * remove the underscores, and capitalize the leading letter of each word.
   */
  def deriveClassName(tableName:String) = 
    dropSchemaName(tableName).split("_").map(w => w.head.toUpper + w.tail).mkString

  /** 
   * Query the database to get the metadata for the given table.
   */
  def getFieldList(tableName:String):List[MetaDataItem] = {
      val sql = SQL("""select * from %s limit 1""" format (tableName))

      val results:Stream[SqlRow] = util.Util.DB.withConnection { implicit connection => sql()  }

      results.head.metaData.ms
    }

  /**
   * Generate a case class definition with one data member for each field in
   * the database table.
   */
  def genClassDef(className:String, fields:List[MetaDataItem]):String = {
    val fieldList = fields.map(formatField(_)).mkString(",\n")

    """    case class %s (
    %s
    )
    """ format (className, fieldList )
  }

  /**
   * Generate a parser for the table. 
   */
  def genParser(className:String, fields:List[MetaDataItem]):String = {

    val header:String = "val " + className.take(1).toLowerCase() + className.drop(1) + 
    "Parser:RowParser[" + className + "] = {\n"

    val getters = fields.map(f => 
      "\tget[" + fieldType(f) + "](\"" + dropSchemaName(f.column) + "\")"
    ).mkString(" ~ \n") 

    val mapper = " map {\n      case " + fields.map(f => dropSchemaName(f.column)).mkString(" ~ ") +
        " =>\n\t" + className + "(" + fields.map(f => dropSchemaName(f.column)).mkString(", ") + ")\n\t}\n}"

    header + getters + mapper
  }

  def main(args:Array[String]) = {

    val className = deriveClassName(tableName)
    val fields = getFieldList(tableName)

    println( genClassDef(className, fields) )

    println( genParser(className, fields))
  }
}
于 2012-11-02T13:22:38.067 に答える