Scala 在Slick中，如何为表提供默认列

我有一些所有表共享的列，所以我想为所有表提供默认列。以下是我迄今为止所做的尝试。我正在使用Slick 3.0

// created_at and updated_at are the columns every table share
abstract class BaseTable[T](tag: Tag, tableName: String) 
     extends Table[T](tag, tableName) {

  def currentWhenInserting = new Timestamp((new Date).getTime)

  def createdAt = column[Timestamp]("created_at", O.Default(currentWhenInserting))

  def updatedAt = column[Timestamp]("updated_at", O.Default(currentWhenInserting))

}

实现这一点的简单方法如下所示

case class Student(
  name: String, age: Int, 
  created_at: Timestamp, updated_at: Timestamp
)

class Students(tag: Tag) extends BaseTable[Student](tag, "students"){

  def name = column[String]("name")
  def age = column[Int]("age")

  override def * : ProvenShape[Student] = 
        (name, age, createdAt, updatedAt).shaped <> 
        (Student.tupled, Student.unapply _)
}

案例班学生(
名称：String，年龄：Int，
创建时间：Timestamp，更新时间：Timestamp
)
班级学生（tag:tag）扩展BaseTable[Student]（tag，“Students”）{
def名称=列[字符串]（“名称”）
定义年龄=列[Int]（“年龄”）
覆盖定义*：形状[学生]=
（姓名、年龄、创建日期、更新日期）。形状
（Student.tuple，Student.unapply)
}

但这是不可取的

首先，强制每个表行case类在创建时合并，并在更新时合并。如果我有更多的字段，从API设计角度来看，这是完全不可接受的

其次，在（姓名、年龄、createdAt、updatedAt）中明确写入两个createdAt、updatedAt。这不是我对默认行的期望

我理想的解决方法如下：

case class Student(name: String, age: Int)

class Students(tag: Tag) extends BaseTable[Student](tag, "students"){    

  def name = column[String]("name")
  def age = column[Int]("age")

  override def * : ProvenShape[Student] = 
        (name, age).shaped <> 
        (Student.tupled, Student.unapply _)
}

case类学生（姓名：String，年龄：Int）
类学生（tag:tag）扩展了BaseTable[Student]（tag，“Students”）{
def名称=列[字符串]（“名称”）
定义年龄=列[Int]（“年龄”）
覆盖定义*：形状[学生]=
（姓名、年龄）
（Student.tuple，Student.unapply)
}

也就是说，在BaseTable中编写一些方法或定义BaseCaseClass，以避免在表定义中显式编写额外的两个字段，如Students和row case class definition Student。

然而，经过痛苦的斗争，仍然可以做到这一点。

---

任何帮助都将不胜感激。

我使用以下模式：

case class Common(arg0: String, arg1: String)

trait Commons { this: Table[_] =>
  def arg0 = column[String]("ARG0", O.Length(123))
  def arg1 = column[String]("ARG1", O.Length(123))

  def common = (arg0, arg1).<> [Meta, (String, String)](
    r => {
      val (arg0, arg1) = r
      Meta(arg0, arg1)
    },
    o => Some(o.arg0, o.arg1)
  )
}

case class MyRecord(a: String, b: String, common: Common)

class MyRecords(tag: Tag) extends Table[MyRecord](tag, "MY_RECORDS") with Commons {
  def a = column[String]("A", O.PrimaryKey, O.Length(123))
  def b = column[String]("B", O.Length(123))

  def * = (a, b, common) <> (MyRecord.tupled, MyRecord.unapply)
}

case类公共（arg0:String，arg1:String）
trait Commons{this:Table[\u]=>
def arg0=列[字符串]（“arg0”，O.Length（123））
def arg1=列[字符串]（“arg1”，O.Length（123））
def common=（arg0，arg1）。[Meta，（字符串，字符串）](
r=>{
val（arg0，arg1）=r
元（arg0，arg1）
},
o=>Some（o.arg0，o.arg1）
)
}
案例类MyRecord（a:String，b:String，common:common）
类MyRecords（tag:tag）用Commons扩展了表[MyRecord]（tag，“myu记录”）{
def a=列[字符串]（“a”，O.PrimaryKey，O.Length（123））
def b=列[字符串]（“b”，O.Length（123））
def*=（a、b、公共）（MyRecord.tuple、MyRecord.unapply）
}

---

它并不完美，但它有助于避免重复，而不会让人难以理解。

一个开始可能是让

Student

扩展一个具有

createdAt

和

updatedAt

的基本对象。不确定您是否可以使用它来减少

*

的冗长。只提出想法-不是Scala/圆滑的专家。