Responding to myself. As I wrote the first message, I started thinking
how just deleting the FK after metadata.create_all() wouldn't be so bad
and now I think that's a pretty good solution.
Randall
Randall Smith wrote:
> Michael Bayer wrote:
>> I should learn to explain better what "syncrules" are about, so heres
>> an attempt:
>>
>> when you have a table A and a table B, and then a mapping relationship
>> between A and B, theres a join condition set up between the two tables.
>> By default, it draws from the foreign keys of the tables.
>> Alternatively, you can send "primaryjoin" and optionally
>> "secondaryjoin" (if you have a secondary association table in the
>> middle) to specify this join condition manually.
>>
>> Lets take a join condition of A.a_id=B.a_id. That means when I create
>> an instance mapped to table "A", it will have a primary key attribute
>> "a_id". An instance mapped to table "B" will have an attribute "a_id"
>> as well which contains the id of its related "A" object.
>>
>> The syncrule generated for this relationship is then "after saving an
>> instance of "A", copy the value of its "a_id" attribute to the "a_id"
>> attribute on all the "B" elements attached to it". The syncrule is
>> generated in the sqlalchemy.orm.sync module, and traverses across the
>> join conditions (i.e. the "primaryjoin") in order to generate the rule.
>>
>> If the syncrules execute and dont manage to find any rules that map
>> attributes from "A" to "B", its clear that the mapper has no way of
>> relating in the database the "A"/"B" relationship. So for now, it
>> assumes that its an error. Since if you have made a relation() from A
>> to B, the mapper needs to be able to persist it.
>>
>> So when you get that error message, it means the join conditions are
>> not taking into account the two tables involved in such a way that the
>> syncrules can figure it out, usually because the two tables are related
>> via an intermediary table which is stuck in the middle of the join (it
>> doesnt handle that).
>
> I have a setup similar to this and would prefer not to use an
> association table.
>
> A, B and C are tables.
>
> A <-FK B(intermediate) -> C
>
> C could possibly be truncated and restored so I don't want an FK
> deleting or restricting records in B.
>
> Table B does not have a Foreign Key defined for C because I don't want
> changes in C to affect B. Is there a way to define the foreign key such
> that it doesn't add a FK constraint to the database, but understands the
> relationship?
>
> I'm creating A and B via metadata.create_all() and I don't want a FK for
> B->C created, but do want sqlalchemy to know about the relationship so
> that I could define it like:
>
> mapper(AClass, A, properties={'C' : relation(C, secondary=B)})
>
> So the only difference is that there would be no Database FK, but I
> don't want to resort to manually deleting it if I dont' have to. Is
> there a nice way to do this?
>
> Randall
>
>
>> The syncrules are only needed for saving objects, not loading them,
>> which is why I added the "viewonly" flag to relations in case you
>> really want a relation() that uses an unusual join, and you dont care
>> about the mapper being able to persist it.
>>
>>
>
>
> >
>
--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups
"sqlalchemy" group.
To post to this group, send email to sqlalchemy@googlegroups.com
To unsubscribe from this group, send email to [EMAIL PROTECTED]
For more options, visit this group at
http://groups.google.com/group/sqlalchemy?hl=en
-~----------~----~----~----~------~----~------~--~---
