On 6/15/15 11:48 AM, T Mark wrote:
Hi Mike,
Thanks so much for the reply and the pointer.
Since I never added anything to the session explicitly, I think I was
missing that loading an object implicitly adds that object to the
session - which does make sense.
Is that right ?
All the objects we deal with when using the ORM represent a row in the
database, in terms of a transaction. So when we load rows, the objects
which proxy those rows stay associated with the session. The ORM uses
the lazy loader pattern so that when unloaded attributes are accessed,
the associated Session is used as a source of transactional context.
Objects that are used in this way are known as "persistent" objects.
There are several states an object might have, including states that are
unassociated with a Session as well. These states are discussed at
http://docs.sqlalchemy.org/en/rel_1_0/orm/session_state_management.html.
thanks again,
terry
On Monday, June 15, 2015 at 11:26:39 AM UTC-4, Michael Bayer wrote:
On 6/15/15 11:12 AM, T Mark wrote:
Hi there,
I have been pulling my hair out on this one.
I understood that objects make it into the session only due to an
explicit call to add().
or if they are associated with a parent object that is added to
the Session via add(), or if they are associated with an object
that is already present in a Session via add(); this also will
occur for backrefs, e.g. A is in the session, B.a is referred to
A, B.a has a backref A.bs, therefore B is now added. This is
configurable.
But, I seem to be seeing objects being added without my
explicitly doing so. Is this to be expected ?
yes. please see:
http://docs.sqlalchemy.org/en/rel_1_0/orm/cascades.html?highlight=cascades
<http://docs.sqlalchemy.org/en/rel_1_0/orm/cascades.html?highlight=cascades>
For instance, I want to establish a many-to-many relationship
between two classes: say, for the purposes here, "Person" and "Kid".
|
test=> create table persons (id SERIAL NOT NULL);
test=> CREATE TABLE person_to_kids (person_id INT NOT
NULL, kid_id INT NOT NULL);
test=> create table kids (id SERIAL NOT NULL, name TEXT NOT NULL);
test=> insert into kids (name) VALUES ('Fred');
test=> insert into kids (name) VALUES ('Barney');
person_to_kids = Table('person_to_kids',
Base.metadata,
Column('person_id', Integer, ForeignKey('persons.id
<http://persons.id>')),
Column('kid_id', Integer, ForeignKey('kids.id <http://kids.id>')))
class Person(Base):
__tablename__ = 'persons'
id = Column('id', Integer, primary_key = True)
def __init__(self,
kids = []):
kids = Kid.get_kids(kid_names = kids)
print("__init__ before kids assignment")
print(session.new)
""" Assigning to self.kids here seems to add self to session ??? """
self.kids=kids
print("After assignment to self.kids")
print(session.new)
class Kid(Base):
__tablename__ = 'kids'
id = Column(Integer, primary_key = True)
name = Column(String)
parents = relationship("Person",
secondary = person_to_kids,
backref="kids")
def __init__(self, name = None):
self.name <http://self.name> = name
@staticmethod
def get_kids(kid_names = []):
kids = []
for name in kid_names:
# find first kid
target_set = session.query(Kid).filter(Kid.name ==
name).first()
kids.append(target_set)
return kids
|
What is puzzling me is that, if I have a collection of Kid
objects, and I assign it to the kids collection in a Person, the
Person object seems to be automatically added to the session and
marked as pending, even if I have not added it.
For instance, if the Persons table is empty:
|
test=> select * from persons;
id
----
(0 rows)
|
and I run the following code:
|
print(session.new)
obj = Person(kids = ['Barney', 'Fred'])
print("obj has been created")
print(session.new)
session.commit()
|
The output shows that the Person object is added immediately
after the assignment to obj.kids, without any call to
session.add() anywhere in the code:
|
IdentitySet([])
|
__init__ before kids assignment
IdentitySet([])
After assignment to self.kids
IdentitySet([<__main__.Person object at 0x7fb6ce447b10>])
obj has been created
IdentitySet([<__main__.Person object at 0x7fb6ce447b10>])
And indeed, due to the commit() at the end, the person object
makes it into the database:
|
test=> select * from persons;
id
----
10
(1 row)
|
But, I understood that objects (only) make it into a session by
virtue of being explicitly added.
So, is this the correct behavior, or am I misunderstanding
something ?
If I'm not misunderstanding this all, the complete code is at
https://github.com/NuggyBuggy/sqlalchemy_question.git
<https://github.com/NuggyBuggy/sqlalchemy_question.git> .
Thanks for reading,
terry
--
You received this message because you are subscribed to the
Google Groups "sqlalchemy" group.
To unsubscribe from this group and stop receiving emails from it,
send an email to sqlalchemy+...@googlegroups.com <javascript:>.
To post to this group, send email to sqlal...@googlegroups.com
<javascript:>.
Visit this group at http://groups.google.com/group/sqlalchemy
<http://groups.google.com/group/sqlalchemy>.
For more options, visit https://groups.google.com/d/optout
<https://groups.google.com/d/optout>.
--
You received this message because you are subscribed to the Google
Groups "sqlalchemy" group.
To unsubscribe from this group and stop receiving emails from it, send
an email to sqlalchemy+unsubscr...@googlegroups.com
<mailto:sqlalchemy+unsubscr...@googlegroups.com>.
To post to this group, send email to sqlalchemy@googlegroups.com
<mailto:sqlalchemy@googlegroups.com>.
Visit this group at http://groups.google.com/group/sqlalchemy.
For more options, visit https://groups.google.com/d/optout.
--
You received this message because you are subscribed to the Google Groups
"sqlalchemy" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to sqlalchemy+unsubscr...@googlegroups.com.
To post to this group, send email to sqlalchemy@googlegroups.com.
Visit this group at http://groups.google.com/group/sqlalchemy.
For more options, visit https://groups.google.com/d/optout.
