如何解析含字段冲突的JOIN结果中的多个case class？

针对你遇到的同名字段（如A和B的id）在解析时被覆盖的问题，有以下几种实用解决方案：

1. SQL查询时给冲突字段加别名，自定义解析器匹配别名 #

这是最直接的方案，通过给查询中的冲突字段指定唯一别名，让解析器能精准匹配对应值：

首先修改SQL语句，为每个冲突字段添加别名：

val sql = SQL"""
  SELECT 
    a.id AS a_id, a.name,
    b.id AS b_id, b.someField 
  FROM A as a LEFT JOIN B as b on a.id = b.a_id
"""

然后定义组合解析器，映射到目标实体：

// 定义组合结果的case class（如果需要）
case class AB(a: A, b: Option[B])

val abParser = (
  long("a_id") ~ str("name") ~
  long("b_id").? ~ str("someField").?
).map {
  case aId ~ name ~ bId ~ someField =>
    AB(A(aId, name), bId.flatMap(id => someField.map(B(id, _))))
}

val list = sql.as(abParser.*)

2. 手动编写解析器，指定字段对应的数据库列名 #

不依赖自动生成的Macro.namedParser，手动为每个字段绑定带表别名的列名（注意不同数据库返回的列名格式可能有差异，部分数据库会保留a.id这类带别名的列名）：

// 手动定义A的解析器，绑定a表的字段
val aParser = (long("a.id") ~ str("a.name")).map(A.tupled)
// 手动定义B的解析器，绑定b表的字段，因为是LEFT JOIN，用.?处理空值
val bParser = (long("b.id") ~ str("b.someField")).map(B.tupled).?

val parser = aParser ~ bParser
val list = SQL"SELECT a.*, b.* FROM A as a LEFT JOIN B as b on a.id = b.a_id".as(parser.*)

3. 使用Slick类型安全查询（推荐） #

如果项目使用Slick的ORM能力，通过定义Table映射类，让Slick自动处理字段别名和映射，避免手动编写SQL和解析器：

// 定义A的Table映射
class ATable(tag: Tag) extends Table[A](tag, "A") {
  def id = column[Long]("id")
  def name = column[String]("name")
  override def * = (id, name) <> (A.tupled, A.unapply)
}

// 定义B的Table映射
class BTable(tag: Tag) extends Table[B](tag, "B") {
  def id = column[Long]("id")
  def someField = column[String]("someField")
  def aId = column[Long]("a_id")
  override def * = (id, someField) <> (B.tupled, B.unapply)
}

// 创建TableQuery实例
val aTable = TableQuery[ATable]
val bTable = TableQuery[BTable]

// 编写类型安全的JOIN查询
val query = for {
  a <- aTable
  b <- bTable.filter(_.aId === a.id).result.headOption
} yield (a, b)

// 执行查询获取结果列表
val list: Future[List[(A, Option[B])]] = db.run(query.to[List])

这种方案完全避免了字段名冲突问题，同时享受Slick的类型安全检查，适合大型项目长期维护。

内容的提问来源于stack exchange，提问作者rvange