Как составить запросы в ScalaQuery, чтобы создать многоразовые трейты?

У меня возникли проблемы с компоновкой разных компонентов запроса в один запрос. Моя цель — создать набор признаков (например, SoftDeletable, HasName, SortedByName, WithTimestamps), которые я могу просто смешать с объектами Table, чтобы добавить это поведение.

В идеале это выглядело бы так:

abstract class BaseModel[Tuple <: Product,CaseClass](tableName: String)
     extends Table[Tuple](tableName) {
  def id = column[Int]("id", O.AutoInc, O.PrimaryKey)

  def mapped: MappedProjection[CaseClass, TupleClass]

  def allQuery = this.map(_.mapped)
  final def all = database.withSession { implicit session: Session => 
    allQuery.list() 
  }

  ...
}

trait SoftDeletable[Tuple  <: Product, CaseClass]
    extends BaseModel[Tuple,CaseClass] {
  def isActive = column[String]("is_active")

  def * = super.* ~ isActive
  def allQuery = /* here, I'd like to compose super.allQuery 
                    with a filter that returns rows where isActive is true */
}

trait HasName[Tuple <: Product] extends Table[Tuple] {
  def name = column[String]("name")

  def * = super.* ~ name
}

trait SortedByName[Tuple <: Product] extends HasName[Tuple {
  override def allQuery = super.allQuery /* compose somehow 
                                             with (_ <- Query orderBy name */
}

Могу ли я делать подобные вещи с помощью ScalaQuery? Основными камнем преткновения являются:

1. Как правильно скомпоновать фильтры в SoftDeletable.allQueryи сортировку в SortedByName.allQueryс BaseModel.allQuery?

2. Добавляя столбцы в реализации подкласса метода *, параметр типа кортежа в Tableне соответствует последнему — есть ли способ для этих трейтов постепенно добавлять новые типы в кортеж столбцов в конечном конкретном классе? (Я не ожидаю, что это будет, но было бы неплохо, если бы я что-то упустил).

3. Мне нужно повторять объявление длинного кортежа в каждом трейте, что становится очень громоздким, если в таблице пять или шесть столбцов.Есть ли что-то, что я могу сделать с членами типа, чтобы избежать таких вещей, как:

   case class Foo
   класс Foos[(Int,Int,Boolean,String), Foo] расширяется
   Таблица[(Int,Int,Boolean,String)] с
   SoftDeletable[(Int,Int,Boolean,String), Foo] с
   SortedByName[(Int,Int,Boolean,String), Foo] с
   HasName[(Int,Int,Boolean,String)] {
   }
   

Могу ли я избежать всего этого повторения? Основываясь на предложении jesnor из IRC, я смог избежать некоторых из них следующим образом:

abstract class SoftDeletableBaseModel[TupleClass <: Product, CaseClass](tableName: String)
        extends BaseModel[TupleClass, CaseClass](tableName)
        with SoftDeletable[TupleClass,CaseClass]

Другими словами, благодаря объединению определенных признаков мне не нужно повторять объявление всего кортежа; конечно, недостатком является то, что простое смешивание различных черт больше невозможно — мне нужно создать множество конкретных подклассов, чтобы избежать этого повторения. Есть ли другой способ?

Обновление: Итак, я понял, что мне не нужно использовать отдельные параметры типа CaseClass и TupleClass. Поскольку классы case реализуют Product*, вы можете просто передать имя класса case в Table, что решает проблему в 3:

trait SoftDeletable[CaseClass] extends BaseModel[CaseClass] { ... }

class Models extends BaseModel[Model]("models") with SoftDeletable[Model] { ... }