
As a short term solution, I think you're right. However, I think we might
want to consider a slightly more sophisticated approach... I say consider
specifically, because I'm really not certain that what I'm saying is a good
idea.
I think there's basically three problems with the approach of using a
PersistValue inside a PersistKey:
1) It will probably hurt performance, since we'll need to do more checking.
2) The code becomes a bit more fragile. By adding this sum type to the mix,
we're adding necessity for a number of checks that can fail.
3) There's nothing stopping you from inserting a value into one database
(say, SQLite), getting a key, and then looking up in MongoDB. (Not that this
is a flaw in the current approach as well.)
So here's the idea: each database backend will have an associated type for
its key datatype. Then, instead of having:
data Key entity = Int64
we'll have
data Key entity backend = BackendKey backend
(ignoring all the newtype wrappers). I think this should solve both the
issue you raise about MongoDB, and the three points I mention above.
However, I'm still concerned that it might lead to difficult-to-follow code.
There's really only one way to find out, but I just wanted to bounce the
idea around before diving in.
Michael
On Sun, Apr 3, 2011 at 4:45 PM, Rick Richardson
I think I have a simple solution. I haven't looked at all of the places that *PersistKey is used, but it appears that we can simply make persistKey a PersistValue, and get rid of the toPersistKey and fromPersistKey functions.
I am only half-way through my coffee this morning, but it seems like this could solve all of our problems. Am I off in left field here?
On Sat, Apr 2, 2011 at 6:57 PM, Rick Richardson
wrote:
I ran into another snag getting the tests running for MongoDB backend. The PersistEntity class, and, it appears, the TH is hardcoded to set the key type as Int64.
This is a problem since the key type in MongoDB is a 12 byte blob.
The other problem is that it looks like PersistBackends are pretty much hardcoded to that type as well. I guess the correct approach would be to allow the designation in mkPersist and then ensure that the PersistBackends can parametrically deal with differing Key types. Or, in the case of MongoDB, hardcode it to a 12 byte blob, because other key types (ObjectId's) rarely make sense.
Thoughts?
_______________________________________________ web-devel mailing list web-devel@haskell.org http://www.haskell.org/mailman/listinfo/web-devel