We've also seen some issues where our transactions are failing because of fk contraint errors relating to entities created in the transaction. ie.
class Foo(var a: String) extends Entity
class Bar(var b: Foo) extends Entity
transactional {
val a = new Foo("a")
val bs = List(1,2,3).map(_ => new Bar(a))
}This would fail because it says fk constraint on a failed. This only seemed to happen immediately after the context started and I have had some difficulty reproducing.
I'm trying to do something like the folllowing, but I'm running into issues.
// example use case
case class Foo(a: String, b: Bar)
case class Bar(d: Date)
def find(startDate: Option[Date], endDate: Option[Date]) = {
val query = MaybeFilter(SlickQuery[Foo])
.filter(startDate)(_.b.d >= startDate.get)
.filter(endDate)(_.b.d <= endDate.get)
.query
query.list
}
About the fk issue, activate has a mechanism to order the statements according to the references
It works normally, so I would need a reproducible case to verify if it is a bug
The only case that activate can't order is where when there is a circular reference. Could that be your case?
About the nested properties with slick, it is necessary to do the joins explicitly
So join with the B entity and then filter it
For the fk issue the entities are defined like the following, so not strictly circular but there is a circular reference through foos.
class Foo(val a: String, val bar: Bar) extends Entity
class Bar(val name: String) extends Entity {
def foos = selec[Foo].where(_.bar :== this)
}
But it's not truly a circular relationship is it? Bar doesn't reference Foo.
yeah, there isn’t a circular dependency
you said that it isn’t possible to reproduce easly, right?
Any input on the SlickQuery Enumeration issue?
about the enum, do you have a stack trace?
or is it a compilation error?
or the query and entity field
s/or/of
btw, about the fk: i think it is possible to set the db constraint to be DEFERRED
if the issue is really a circular dependency
object Status extends Enumeration {
case class Status(name: String) extends Val(name)
val ACTIVE = AccountStatus("active")
val INACTIVE = AccountStatus("inactive")
}
class Foo(name: String, status: Status.Status) extends Entity
SlickQuery[Foo].filter(_.status.col === Status.ACTIVE)
I think it might have to do with whatever implicit mappers Slick is using to convert the value to a Column?
but i don’t remember what this means :(
maybe you can provide the implicit by using MappedColumnType.base
this is the way that the TypedType is provided for entities ^
I think I found a solution to the slick enum issue. I'm running into problems with the Val enums used for Activate though. My enumerations are failing comparisons. The indexes on values that should be equivalent (they have the same name) are different. Also when I inspect the vmap of the outerEnum there are duplicates.
Ok, I finally realized what was going on with the enums. I think this may be a serious flaw with the use of Enumerations in activate.
object Status extends Enumeration {
case class Status(name: String) extends Val(name)
val ACTIVE = Status("active")
val INACTIVE = Status("inactive")
}
val a = Status.ACTIVE
val b = Status.Status("active")
val c = a == b // false
val d = a.name == b.name // true
c is true for running this code
let me test the code again
@spry-rproud index for the fks?