"reproduce with liftQuery" in {
    val repeated = Seq(Seq("a", "b"), Seq("c", "d"))

    val ctx = new SqlMirrorContext(MirrorSqlDialect, Literal)
    import ctx.*

    val query = dynamicQuery[Custom].filter(v =>
        repeated.map(l => 
          quote(liftQuery(l).contains(v.name))
        ).reduce((l,r) => quote(l || r))
    )
    val sql = ctx.translate(query)
    assert(sql == "SELECT v0.name FROM Custom v0 WHERE v0.name IN ('a', 'b') OR v0.name IN ('c', 'd')")
  }

 "reproduce with additionalLifts" in {
    val ctx: MirrorContext[MirrorSqlDialectWithReturnClause, Literal] = new MirrorContext[MirrorSqlDialectWithReturnClause, Literal](MirrorSqlDialectWithReturnClause, Literal)
    import ctx.*

    val nameFilter = Seq("John", "Doe")

    case class Person(id: Int, name: String, age: Int)

    val people = List(Person(1, "Joe", 123), Person(2, "Jill", 456))

    val updateDynamic = quote {
      (p: Person) => query[Person].filter(p => 
          nameFilter.map(n => quote(sql"${p.name} == ${lift(n)}".asCondition)).reduce(_ || _)
        ).updateValue(p)
    }
    val mirror = ctx.run { liftQuery(people).foreach(p => updateDynamic(p)) }

    assert(mirror.triple  == ("UPDATE Person AS p SET id = ?, name = ?, age = ? WHERE p.name == ? OR p.name == ?", List(List(1, "Joe", 123, 36, "John", "Doe"), List(2, "Jill", 456, 36, "John", "Doe")), Dynamic))
  }

val regularLiftIndexes =
      regularLifts.groupBy(_.uid)

    trace"Organizing into Lift Slots: ${slots}".andLog()
    slots.foldLeft((List.empty[Planter[?, ?, ?]], Set.empty[Planter[?, ?, ?]])) {
      case ((acc, viewed), LiftSlot.Numbered(valueClauseNum, uid)) =>
        (acc :+ valueClauseLiftIndexes
          .get(ValueLiftKey(valueClauseNum, uid))
          .getOrElse {
            throw new IllegalStateException(s"Could not find the Value-Clause lift index:${valueClauseNum},uid:${uid}. Existing values are: ${valueClauseLiftIndexes}")
          }, viewed)
      case ((acc, viewed), LiftSlot.Plain(uid)) =>
        val planter: Planter[?, ?, ?] = regularLiftIndexes
          .get(uid)
          .flatMap(_.find(l => !viewed.contains(l)))
          .getOrElse {
            throw new IllegalStateException(s"Could not find the lift uid:${uid},uid:${uid}. Existing values are: ${regularLiftIndexes}")
          }
        (acc :+ planter , viewed + planter)
      case (acc, other) =>
        throw new IllegalStateException(s"Illegal LiftSlot: ${other}")
    }._1

    val encodeablesMap =
      lifts.groupBy(_.uid)

    val secondaryEncodeablesMap =
      secondaryLifts.groupBy(_.uid)

    val sortedEncodeables =
      uidsOfScalarTags.distinct
        .flatMap { uid =>
          encodeablesMap.get(uid) match {
            case Some(elements) => elements.map(UidStatus.Primary(uid, _))
            case None =>
              secondaryEncodeablesMap.get(uid) match {
                case Some(elements) => elements.map(UidStatus.Secondary(uid, _))
                case None          => UidStatus.NotFound(uid) :: Nil
              }
          }
        }