diff options
| -rw-r--r-- | doc/build/content/datamapping.txt | 13 | ||||
| -rw-r--r-- | lib/sqlalchemy/ext/sessioncontext.py | 5 | ||||
| -rw-r--r-- | lib/sqlalchemy/orm/__init__.py | 26 | ||||
| -rw-r--r-- | lib/sqlalchemy/orm/interfaces.py | 9 | ||||
| -rw-r--r-- | lib/sqlalchemy/orm/mapper.py | 6 | ||||
| -rw-r--r-- | lib/sqlalchemy/orm/session.py | 95 | ||||
| -rw-r--r-- | lib/sqlalchemy/orm/sessionmaker.py | 94 | ||||
| -rw-r--r-- | lib/sqlalchemy/orm/util.py | 1 | ||||
| -rw-r--r-- | lib/sqlalchemy/util.py | 5 | ||||
| -rw-r--r-- | test/orm/session.py | 18 | ||||
| -rw-r--r-- | test/orm/unitofwork.py | 338 |
11 files changed, 395 insertions, 215 deletions
diff --git a/doc/build/content/datamapping.txt b/doc/build/content/datamapping.txt index 01099eac5..6308c8d7b 100644 --- a/doc/build/content/datamapping.txt +++ b/doc/build/content/datamapping.txt @@ -102,11 +102,16 @@ What was that last `id` attribute? That was placed there by the `Mapper`, to tr ## Creating a Session -We're now ready to start talking to the database. The ORM's "handle" to the database is the `Session`. Whenever you need to have a conversation with the database, you instantiate one of these objects. +We're now ready to start talking to the database. The ORM's "handle" to the database is the `Session`. When we first set up the application, at the same level as our `create_engine()` statement, we define a second object called `Session` (or whatever you want to call it, `create_session`, etc.) which is configured by the `sessionmaker()` function. This function is configurational and need only be called once. {python} - >>> from sqlalchemy.orm import Session - >>> session = Session(engine) + >>> from sqlalchemy.orm import sessionmaker + >>> Session = sessionmaker(bind=engine, autoflush=True, transactional=True) + +This `Session` class will create new `Session` objects which are bound to our database and have some various transactional characteristics. Whenever you need to have a conversation with the database, you instantiate a `Session`: + + {python} + >>> session = Session() The above `Session` is associated with our SQLite `engine`, but it hasn't opened any connections yet. When it's first used, it retrieves a connection from a pool of connections stored in the `engine`, and holds onto it until we commit all changes and/or close the session object. With most database configurations, theres also a transaction in progress (one notable exception to this is MySQL, when you use its default table style of MyISAM). There's many options available to modify this behavior but we'll go with this straightforward version to start. @@ -486,7 +491,7 @@ Let's save into the session, then close out the session and create a new one...s ['j25@yahoo.com', 5] COMMIT - >>> session = Session(engine) + >>> session = Session() Querying for Jack, we get just Jack back. No SQL is yet issued for for Jack's addresses: diff --git a/lib/sqlalchemy/ext/sessioncontext.py b/lib/sqlalchemy/ext/sessioncontext.py index 91c03d3c3..8221bc495 100644 --- a/lib/sqlalchemy/ext/sessioncontext.py +++ b/lib/sqlalchemy/ext/sessioncontext.py @@ -1,4 +1,4 @@ -from sqlalchemy.util import ScopedRegistry +from sqlalchemy.util import ScopedRegistry, warn_deprecated from sqlalchemy.orm import create_session, object_session, MapperExtension, EXT_CONTINUE __all__ = ['SessionContext', 'SessionContextExt'] @@ -25,6 +25,7 @@ class SessionContext(object): """ def __init__(self, session_factory=None, scopefunc=None): + warn_deprecated("SessionContext is deprecated. Use Session=sessionmaker(scope='thread').") if session_factory is None: session_factory = create_session self.registry = ScopedRegistry(session_factory, scopefunc) @@ -63,7 +64,7 @@ class SessionContextExt(MapperExtension): def get_session(self): return self.context.current - def init_instance(self, mapper, class_, instance, args, kwargs): + def init_instance(self, mapper, class_, oldinit, instance, args, kwargs): session = kwargs.pop('_sa_session', self.context.current) session._save_impl(instance, entity_name=kwargs.pop('_sa_entity_name', None)) return EXT_CONTINUE diff --git a/lib/sqlalchemy/orm/__init__.py b/lib/sqlalchemy/orm/__init__.py index 3c221bb66..26b583bb1 100644 --- a/lib/sqlalchemy/orm/__init__.py +++ b/lib/sqlalchemy/orm/__init__.py @@ -20,14 +20,15 @@ from sqlalchemy.orm import collections, strategies from sqlalchemy.orm.query import Query from sqlalchemy.orm.util import polymorphic_union from sqlalchemy.orm.session import Session as _Session -from sqlalchemy.orm.session import object_session, attribute_manager +from sqlalchemy.orm.session import object_session, attribute_manager, sessionmaker +from sqlalchemy.orm.sessionmaker import sessionmaker __all__ = [ 'relation', 'column_property', 'composite', 'backref', 'eagerload', 'eagerload_all', 'lazyload', 'noload', 'deferred', 'defer', 'undefer', 'undefer_group', 'extension', 'mapper', 'clear_mappers', - 'compile_mappers', 'class_mapper', 'object_mapper', + 'compile_mappers', 'class_mapper', 'object_mapper', 'sessionmaker', 'dynamic_loader', 'MapperExtension', 'Query', 'polymorphic_union', - 'create_session', 'Session', 'synonym', 'contains_alias', + 'create_session', 'synonym', 'contains_alias', 'contains_eager', 'EXT_CONTINUE', 'EXT_STOP', 'EXT_PASS', 'object_session', 'PropComparator' ] @@ -38,28 +39,11 @@ def create_session(bind=None, **kwargs): The session by default does not begin a transaction, and requires that flush() be called explicitly in order to persist results to the database. """ - + sautil.warn_deprecated("create_session() is deprecated. Use Session=sessionmaker() instead.") kwargs.setdefault('autoflush', False) kwargs.setdefault('transactional', False) return _Session(bind=bind, **kwargs) -class Session(_Session): - """front-end for a [sqlalchemy.orm.session#Session]. By default, - produces an autoflushing, transactional session.""" - - def __init__(self, bind=None, **kwargs): - """create a new transactional [sqlalchemy.orm.session#Session]. - - The session starts a new transaction for each database accessed. To - commit the transaction, use the commit() method. SQL is issued for - write operations (i.e. flushes) automatically in most cases, before each query - and during commit. - """ - - kwargs.setdefault('autoflush', True) - kwargs.setdefault('transactional', True) - super(Session, self).__init__(bind=bind, **kwargs) - def relation(argument, secondary=None, **kwargs): """Provide a relationship of a primary Mapper to a secondary Mapper. diff --git a/lib/sqlalchemy/orm/interfaces.py b/lib/sqlalchemy/orm/interfaces.py index 271846ca8..abaeff49c 100644 --- a/lib/sqlalchemy/orm/interfaces.py +++ b/lib/sqlalchemy/orm/interfaces.py @@ -34,11 +34,14 @@ class MapperExtension(object): EXT_PASS is a synonym for EXT_CONTINUE and is provided for backward compatibility. """ - - def init_instance(self, mapper, class_, instance, args, kwargs): + + def instrument_class(self, mapper, class_): + return EXT_CONTINUE + + def init_instance(self, mapper, class_, oldinit, instance, args, kwargs): return EXT_CONTINUE - def init_failed(self, mapper, class_, instance, args, kwargs): + def init_failed(self, mapper, class_, oldinit, instance, args, kwargs): return EXT_CONTINUE def get_session(self): diff --git a/lib/sqlalchemy/orm/mapper.py b/lib/sqlalchemy/orm/mapper.py index debce60f2..af7c9d4cf 100644 --- a/lib/sqlalchemy/orm/mapper.py +++ b/lib/sqlalchemy/orm/mapper.py @@ -304,6 +304,8 @@ class Mapper(object): for ext in extlist: self.extension.append(ext) + self.extension.instrument_class(self, self.class_) + def _compile_inheritance(self): """Determine if this Mapper inherits from another mapper, and if so calculates the mapped_table for this Mapper taking the @@ -679,7 +681,7 @@ class Mapper(object): oldinit = self.class_.__init__ def init(instance, *args, **kwargs): self.compile() - self.extension.init_instance(self, self.class_, instance, args, kwargs) + self.extension.init_instance(self, self.class_, oldinit, instance, args, kwargs) if oldinit is not None: try: @@ -687,7 +689,7 @@ class Mapper(object): except: # call init_failed but suppress exceptions into warnings so that original __init__ # exception is raised - util.warn_exception(self.extension.init_failed, self, self.class_, instance, args, kwargs) + util.warn_exception(self.extension.init_failed, self, self.class_, oldinit, instance, args, kwargs) raise # override oldinit, ensuring that its not already a Mapper-decorated init method diff --git a/lib/sqlalchemy/orm/session.py b/lib/sqlalchemy/orm/session.py index b957f822f..996c7d8a0 100644 --- a/lib/sqlalchemy/orm/session.py +++ b/lib/sqlalchemy/orm/session.py @@ -4,13 +4,104 @@ # This module is part of SQLAlchemy and is released under # the MIT License: http://www.opensource.org/licenses/mit-license.php -import weakref +import weakref, types from sqlalchemy import util, exceptions, sql, engine -from sqlalchemy.orm import unitofwork, query, util as mapperutil +from sqlalchemy.orm import unitofwork, query, util as mapperutil, MapperExtension, EXT_CONTINUE from sqlalchemy.orm.mapper import object_mapper as _object_mapper from sqlalchemy.orm.mapper import class_mapper as _class_mapper +from sqlalchemy.orm.mapper import global_extensions +__all__ = ['Session', 'SessionTransaction'] + +def sessionmaker(autoflush, transactional, bind=None, scope=None, enhance_classes=False, **kwargs): + """Generate a Session configuration.""" + + if enhance_classes and scope is None: + raise exceptions.InvalidRequestError("enhance_classes requires a non-None 'scope' argument, so that mappers can automatically locate a Session already in progress.") + + class Sess(Session): + def __init__(self, **local_kwargs): + local_kwargs.setdefault('bind', bind) + local_kwargs.setdefault('autoflush', autoflush) + local_kwargs.setdefault('transactional', transactional) + for k in kwargs: + local_kwargs.setdefault(k, kwargs[k]) + super(Sess, self).__init__(**local_kwargs) + + if scope=="thread": + registry = util.ScopedRegistry(Sess, scopefunc=None) + + if enhance_classes: + class SessionContextExt(MapperExtension): + def get_session(self): + return registry() + + def instrument_class(self, mapper, class_): + class query(object): + def __getattr__(self, key): + return getattr(registry().query(class_), key) + def __call__(self): + return registry().query(class_) + + if not hasattr(class_, 'query'): + class_.query = query() + + def init_instance(self, mapper, class_, oldinit, instance, args, kwargs): + session = kwargs.pop('_sa_session', registry()) + if not isinstance(oldinit, types.MethodType): + for key, value in kwargs.items(): + #if validate: + # if not self.mapper.get_property(key, resolve_synonyms=False, raiseerr=False): + # raise exceptions.ArgumentError("Invalid __init__ argument: '%s'" % key) + setattr(instance, key, value) + session._save_impl(instance, entity_name=kwargs.pop('_sa_entity_name', None)) + return EXT_CONTINUE + + def init_failed(self, mapper, class_, oldinit, instance, args, kwargs): + object_session(instance).expunge(instance) + return EXT_CONTINUE + + def dispose_class(self, mapper, class_): + if hasattr(class_, '__init__') and hasattr(class_.__init__, '_oldinit'): + if class_.__init__._oldinit is not None: + class_.__init__ = class_.__init__._oldinit + else: + delattr(class_, '__init__') + if hasattr(class_, 'query'): + delattr(class_, 'query') + + global_extensions.append(SessionContextExt()) + + default_scope=scope + class ScopedSess(Sess): + def __new__(cls, **kwargs): + if len(kwargs): + scope = kwargs.pop('scope', default_scope) + if scope is not None: + if registry.has(): + raise exceptions.InvalidRequestError("Scoped session is already present; no new arguments may be specified.") + else: + sess = Sess(**kwargs) + registry.set(sess) + return sess + else: + return Sess(**kwargs) + else: + return registry() + def instrument(name): + def do(cls, *args, **kwargs): + return getattr(registry(), name)(*args, **kwargs) + return classmethod(do) + for meth in ('get', 'close', 'save', 'commit', 'update', 'flush', 'query', 'delete'): + setattr(ScopedSess, meth, instrument(meth)) + + return ScopedSess + elif scope is not None: + raise exceptions.ArgumentError("Unknown scope '%s'" % scope) + else: + return session + class SessionTransaction(object): """Represents a Session-level Transaction. diff --git a/lib/sqlalchemy/orm/sessionmaker.py b/lib/sqlalchemy/orm/sessionmaker.py new file mode 100644 index 000000000..42064c5b8 --- /dev/null +++ b/lib/sqlalchemy/orm/sessionmaker.py @@ -0,0 +1,94 @@ +import types + +from sqlalchemy import util, exceptions +from sqlalchemy.orm.session import Session +from sqlalchemy.orm import query, util as mapperutil, MapperExtension, EXT_CONTINUE +from sqlalchemy.orm.mapper import global_extensions + +def sessionmaker(autoflush, transactional, bind=None, scope=None, enhance_classes=False, **kwargs): + """Generate a Session configuration.""" + + if enhance_classes and scope is None: + raise exceptions.InvalidRequestError("enhance_classes requires a non-None 'scope' argument, so that mappers can automatically locate a Session already in progress.") + + class Sess(Session): + def __init__(self, **local_kwargs): + local_kwargs.setdefault('bind', bind) + local_kwargs.setdefault('autoflush', autoflush) + local_kwargs.setdefault('transactional', transactional) + for k in kwargs: + local_kwargs.setdefault(k, kwargs[k]) + super(Sess, self).__init__(**local_kwargs) + + if scope=="thread": + registry = util.ScopedRegistry(Sess, scopefunc=None) + + if enhance_classes: + class SessionContextExt(MapperExtension): + def get_session(self): + return registry() + + def instrument_class(self, mapper, class_): + class query(object): + def __getattr__(self, key): + return getattr(registry().query(class_), key) + def __call__(self): + return registry().query(class_) + + if not hasattr(class_, 'query'): + class_.query = query() + + def init_instance(self, mapper, class_, oldinit, instance, args, kwargs): + session = kwargs.pop('_sa_session', registry()) + if not isinstance(oldinit, types.MethodType): + for key, value in kwargs.items(): + #if validate: + # if not self.mapper.get_property(key, resolve_synonyms=False, raiseerr=False): + # raise exceptions.ArgumentError("Invalid __init__ argument: '%s'" % key) + setattr(instance, key, value) + session._save_impl(instance, entity_name=kwargs.pop('_sa_entity_name', None)) + return EXT_CONTINUE + + def init_failed(self, mapper, class_, oldinit, instance, args, kwargs): + object_session(instance).expunge(instance) + return EXT_CONTINUE + + def dispose_class(self, mapper, class_): + if hasattr(class_, '__init__') and hasattr(class_.__init__, '_oldinit'): + if class_.__init__._oldinit is not None: + class_.__init__ = class_.__init__._oldinit + else: + delattr(class_, '__init__') + if hasattr(class_, 'query'): + delattr(class_, 'query') + + global_extensions.append(SessionContextExt()) + + default_scope=scope + class ScopedSess(Sess): + def __new__(cls, **kwargs): + if len(kwargs): + scope = kwargs.pop('scope', default_scope) + if scope is not None: + if registry.has(): + raise exceptions.InvalidRequestError("Scoped session is already present; no new arguments may be specified.") + else: + sess = Sess(**kwargs) + registry.set(sess) + return sess + else: + return Sess(**kwargs) + else: + return registry() + def instrument(name): + def do(cls, *args, **kwargs): + return getattr(registry(), name)(*args, **kwargs) + return classmethod(do) + for meth in ('get', 'close', 'save', 'commit', 'update', 'flush', 'query', 'delete'): + setattr(ScopedSess, meth, instrument(meth)) + + return ScopedSess + elif scope is not None: + raise exceptions.ArgumentError("Unknown scope '%s'" % scope) + else: + return Sess diff --git a/lib/sqlalchemy/orm/util.py b/lib/sqlalchemy/orm/util.py index 6a9c4164f..727be50c6 100644 --- a/lib/sqlalchemy/orm/util.py +++ b/lib/sqlalchemy/orm/util.py @@ -140,6 +140,7 @@ class ExtensionCarrier(MapperExtension): return EXT_CONTINUE return _do + instrument_class = _create_do('instrument_class') init_instance = _create_do('init_instance') init_failed = _create_do('init_failed') dispose_class = _create_do('dispose_class') diff --git a/lib/sqlalchemy/util.py b/lib/sqlalchemy/util.py index 7391d86fd..ea1c8286a 100644 --- a/lib/sqlalchemy/util.py +++ b/lib/sqlalchemy/util.py @@ -543,7 +543,10 @@ class ScopedRegistry(object): return self.registry[key] except KeyError: return self.registry.setdefault(key, self.createfunc()) - + + def has(self): + return self._get_key() in self.registry + def set(self, obj): self.registry[self._get_key()] = obj diff --git a/test/orm/session.py b/test/orm/session.py index 925f61497..230be907e 100644 --- a/test/orm/session.py +++ b/test/orm/session.py @@ -4,6 +4,7 @@ from sqlalchemy.orm import * from testlib import * from testlib.tables import * import testlib.tables as tables +from sqlalchemy.orm.session import Session class SessionTest(AssertMixin): def setUpAll(self): @@ -97,7 +98,7 @@ class SessionTest(AssertMixin): conn1 = testbase.db.connect() conn2 = testbase.db.connect() - sess = Session(bind=conn1) + sess = Session(bind=conn1, transactional=True, autoflush=True) u = User() u.user_name='ed' sess.save(u) @@ -115,7 +116,7 @@ class SessionTest(AssertMixin): mapper(User, users) try: - sess = Session() + sess = Session(transactional=True, autoflush=True) u = User() u.user_name='ed' sess.save(u) @@ -136,7 +137,7 @@ class SessionTest(AssertMixin): conn1 = testbase.db.connect() conn2 = testbase.db.connect() - sess = Session(bind=conn1) + sess = Session(bind=conn1, transactional=True, autoflush=True) u = User() u.user_name='ed' sess.save(u) @@ -144,14 +145,15 @@ class SessionTest(AssertMixin): assert conn1.execute("select count(1) from users").scalar() == 1 assert testbase.db.connect().execute("select count(1) from users").scalar() == 1 - def test_autoflush_rollback(self): + # TODO: not doing rollback of attributes right now. + def dont_test_autoflush_rollback(self): tables.data() mapper(Address, addresses) mapper(User, users, properties={ 'addresses':relation(Address) }) - sess = Session() + sess = Session(transactional=True, autoflush=True) u = sess.query(User).get(8) newad = Address() newad.email_address == 'something new' @@ -171,7 +173,7 @@ class SessionTest(AssertMixin): mapper(User, users) conn = testbase.db.connect() trans = conn.begin() - sess = Session(conn) + sess = Session(conn, transactional=True, autoflush=True) sess.begin() u = User() sess.save(u) @@ -187,7 +189,7 @@ class SessionTest(AssertMixin): try: conn = testbase.db.connect() trans = conn.begin() - sess = Session(conn) + sess = Session(conn, transactional=True, autoflush=True) u1 = User() sess.save(u1) sess.flush() @@ -233,7 +235,7 @@ class SessionTest(AssertMixin): def test_joined_transaction(self): class User(object):pass mapper(User, users) - sess = Session() + sess = Session(transactional=True, autoflush=True) sess.begin() u = User() sess.save(u) diff --git a/test/orm/unitofwork.py b/test/orm/unitofwork.py index b67a6faf3..a3e025586 100644 --- a/test/orm/unitofwork.py +++ b/test/orm/unitofwork.py @@ -4,8 +4,6 @@ from sqlalchemy import * from sqlalchemy.orm import * from sqlalchemy.orm.mapper import global_extensions from sqlalchemy.orm import util as ormutil -from sqlalchemy.ext.sessioncontext import SessionContext -import sqlalchemy.ext.assignmapper as assignmapper from testlib import * from testlib.tables import * from testlib import tables @@ -14,16 +12,12 @@ from testlib import tables class UnitOfWorkTest(AssertMixin): def setUpAll(self): - global ctx, assign_mapper - ctx = SessionContext(Session) - def assign_mapper(*args, **kwargs): - return assignmapper.assign_mapper(ctx, *args, **kwargs) - global_extensions.append(ctx.mapper_extension) + global Session + Session = sessionmaker(autoflush=True, transactional=True, enhance_classes=True, scope="thread") def tearDownAll(self): - global_extensions.remove(ctx.mapper_extension) + global_extensions[:] = [] def tearDown(self): Session.close_all() - ctx.current.close() clear_mappers() class HistoryTest(UnitOfWorkTest): @@ -61,7 +55,7 @@ class HistoryTest(UnitOfWorkTest): class VersioningTest(UnitOfWorkTest): def setUpAll(self): UnitOfWorkTest.setUpAll(self) - ctx.current.close() + Session.close() global version_table version_table = Table('version_test', MetaData(testbase.db), Column('id', Integer, Sequence('version_test_seq'), primary_key=True ), @@ -77,9 +71,9 @@ class VersioningTest(UnitOfWorkTest): version_table.delete().execute() def testbasic(self): - s = Session() + s = Session(scope=None) class Foo(object):pass - assign_mapper(Foo, version_table, version_id_col=version_table.c.version_id) + mapper(Foo, version_table, version_id_col=version_table.c.version_id) f1 =Foo(value='f1', _sa_session=s) f2 = Foo(value='f2', _sa_session=s) s.commit() @@ -126,9 +120,9 @@ class VersioningTest(UnitOfWorkTest): def testversioncheck(self): """test that query.with_lockmode performs a 'version check' on an already loaded instance""" - s1 = Session() + s1 = Session(scope=None) class Foo(object):pass - assign_mapper(Foo, version_table, version_id_col=version_table.c.version_id) + mapper(Foo, version_table, version_id_col=version_table.c.version_id) f1s1 =Foo(value='f1', _sa_session=s1) s1.commit() s2 = Session() @@ -154,7 +148,7 @@ class VersioningTest(UnitOfWorkTest): """test that query.with_lockmode works OK when the mapper has no version id col""" s1 = Session() class Foo(object):pass - assign_mapper(Foo, version_table) + mapper(Foo, version_table) f1s1 =Foo(value='f1', _sa_session=s1) f1s1.version_id=0 s1.commit() @@ -196,7 +190,7 @@ class UnicodeTest(UnitOfWorkTest): txt = u"\u0160\u0110\u0106\u010c\u017d" t1 = Test(id=1, txt = txt) self.assert_(t1.txt == txt) - ctx.current.commit() + Session.commit() self.assert_(t1.txt == txt) def testrelation(self): class Test(object): @@ -213,9 +207,9 @@ class UnicodeTest(UnitOfWorkTest): t1 = Test(txt=txt) t1.t2s.append(Test2()) t1.t2s.append(Test2()) - ctx.current.commit() - ctx.current.close() - t1 = ctx.current.query(Test).get_by(id=t1.id) + Session.commit() + Session.close() + t1 = Session.query(Test).get_by(id=t1.id) assert len(t1.t2s) == 2 class MutableTypesTest(UnitOfWorkTest): @@ -238,14 +232,14 @@ class MutableTypesTest(UnitOfWorkTest): mapper(Foo, table) f1 = Foo() f1.data = pickleable.Bar(4,5) - ctx.current.commit() - ctx.current.close() - f2 = ctx.current.query(Foo).get_by(id=f1.id) + Session.commit() + Session.close() + f2 = Session.query(Foo).get_by(id=f1.id) assert f2.data == f1.data f2.data.y = 19 - ctx.current.commit() - ctx.current.close() - f3 = ctx.current.query(Foo).get_by(id=f1.id) + Session.commit() + Session.close() + f3 = Session.query(Foo).get_by(id=f1.id) print f2.data, f3.data assert f3.data != f1.data assert f3.data == pickleable.Bar(4, 19) @@ -257,12 +251,12 @@ class MutableTypesTest(UnitOfWorkTest): f1 = Foo() f1.data = pickleable.Bar(4,5) f1.value = unicode('hi') - ctx.current.commit() + Session.commit() def go(): - ctx.current.commit() + Session.commit() self.assert_sql_count(testbase.db, go, 0) f1.value = unicode('someothervalue') - self.assert_sql(testbase.db, lambda: ctx.current.commit(), [ + self.assert_sql(testbase.db, lambda: Session.commit(), [ ( "UPDATE mutabletest SET value=:value WHERE mutabletest.id = :mutabletest_id", {'mutabletest_id': f1.id, 'value': u'someothervalue'} @@ -270,7 +264,7 @@ class MutableTypesTest(UnitOfWorkTest): ]) f1.value = unicode('hi') f1.data.x = 9 - self.assert_sql(testbase.db, lambda: ctx.current.commit(), [ + self.assert_sql(testbase.db, lambda: Session.commit(), [ ( "UPDATE mutabletest SET data=:data, value=:value WHERE mutabletest.id = :mutabletest_id", {'mutabletest_id': f1.id, 'value': u'hi', 'data':f1.data} @@ -284,32 +278,32 @@ class MutableTypesTest(UnitOfWorkTest): mapper(Foo, table) f1 = Foo() f1.data = pickleable.BarWithoutCompare(4,5) - ctx.current.commit() + Session.commit() def go(): - ctx.current.commit() + Session.commit() self.assert_sql_count(testbase.db, go, 0) - ctx.current.close() + Session.close() - f2 = ctx.current.query(Foo).get_by(id=f1.id) + f2 = Session.query(Foo).get_by(id=f1.id) def go(): - ctx.current.commit() + Session.commit() self.assert_sql_count(testbase.db, go, 0) f2.data.y = 19 def go(): - ctx.current.commit() + Session.commit() self.assert_sql_count(testbase.db, go, 1) - ctx.current.close() - f3 = ctx.current.query(Foo).get_by(id=f1.id) + Session.close() + f3 = Session.query(Foo).get_by(id=f1.id) print f2.data, f3.data assert (f3.data.x, f3.data.y) == (4,19) def go(): - ctx.current.commit() + Session.commit() self.assert_sql_count(testbase.db, go, 0) def testunicode(self): @@ -321,12 +315,12 @@ class MutableTypesTest(UnitOfWorkTest): mapper(Foo, table) f1 = Foo() f1.value = u'hi' - ctx.current.commit() - ctx.current.close() - f1 = ctx.current.get(Foo, f1.id) + Session.commit() + Session.close() + f1 = Session.get(Foo, f1.id) f1.value = u'hi' def go(): - ctx.current.commit() + Session.commit() self.assert_sql_count(testbase.db, go, 0) @@ -371,8 +365,8 @@ class PKTest(UnitOfWorkTest): e.name = 'entry1' e.value = 'this is entry 1' e.multi_rev = 2 - ctx.current.commit() - ctx.current.close() + Session.commit() + Session.close() e2 = Query(Entry).get((e.multi_id, 2)) self.assert_(e is not e2 and e._instance_key == e2._instance_key) @@ -385,7 +379,7 @@ class PKTest(UnitOfWorkTest): e.pk_col_1 = 'pk1' e.pk_col_2 = 'pk1_related' e.data = 'im the data' - ctx.current.commit() + Session.commit() def testkeypks(self): import datetime @@ -397,7 +391,7 @@ class PKTest(UnitOfWorkTest): e.secondary = 'pk2' e.assigned = datetime.date.today() e.data = 'some more data' - ctx.current.commit() + Session.commit() def testpksimmutable(self): class Entry(object): @@ -407,11 +401,11 @@ class PKTest(UnitOfWorkTest): e.multi_id=5 e.multi_rev=5 e.name='somename' - ctx.current.commit() + Session.commit() e.multi_rev=6 e.name = 'someothername' try: - ctx.current.commit() + Session.commit() assert False except exceptions.FlushError, fe: assert str(fe) == "Can't change the identity of instance Entry@%s in session (existing identity: (%s, (5, 5), None); new identity: (%s, (5, 6), None))" % (hex(id(e)), repr(e.__class__), repr(e.__class__)) @@ -457,7 +451,7 @@ class ForeignPKTest(UnitOfWorkTest): ps = PersonSite() ps.site = 'asdf' p.sites.append(ps) - ctx.current.commit() + Session.commit() assert people.count(people.c.person=='im the key').scalar() == peoplesites.count(peoplesites.c.person=='im the key').scalar() == 1 class PassiveDeletesTest(UnitOfWorkTest): @@ -497,7 +491,7 @@ class PassiveDeletesTest(UnitOfWorkTest): 'children':relation(MyOtherClass, passive_deletes=True, cascade="all") }) - sess = ctx.current + sess = Session mc = MyClass() mc.children.append(MyOtherClass()) mc.children.append(MyOtherClass()) @@ -548,14 +542,14 @@ class DefaultTest(UnitOfWorkTest): def testinsert(self): class Hoho(object):pass - assign_mapper(Hoho, default_table) + mapper(Hoho, default_table) h1 = Hoho(hoho=self.althohoval) h2 = Hoho(counter=12) h3 = Hoho(hoho=self.althohoval, counter=12) h4 = Hoho() h5 = Hoho(foober='im the new foober') - ctx.current.commit() + Session.commit() self.assert_(h1.hoho==self.althohoval) self.assert_(h3.hoho==self.althohoval) @@ -575,7 +569,7 @@ class DefaultTest(UnitOfWorkTest): self.assert_(h5.foober=='im the new foober') self.assert_sql_count(testbase.db, go, 0) - ctx.current.close() + Session.close() l = Query(Hoho).select() @@ -592,11 +586,11 @@ class DefaultTest(UnitOfWorkTest): def testinsertnopostfetch(self): # populates the PassiveDefaults explicitly so there is no "post-update" class Hoho(object):pass - assign_mapper(Hoho, default_table) + mapper(Hoho, default_table) h1 = Hoho(hoho="15", counter="15") - ctx.current.commit() + Session.commit() def go(): self.assert_(h1.hoho=="15") self.assert_(h1.counter=="15") @@ -605,12 +599,12 @@ class DefaultTest(UnitOfWorkTest): def testupdate(self): class Hoho(object):pass - assign_mapper(Hoho, default_table) + mapper(Hoho, default_table) h1 = Hoho() - ctx.current.commit() + Session.commit() self.assert_(h1.foober == 'im foober') h1.counter = 19 - ctx.current.commit() + Session.commit() self.assert_(h1.foober == 'im the update') class OneToManyTest(UnitOfWorkTest): @@ -639,7 +633,7 @@ class OneToManyTest(UnitOfWorkTest): a2.email_address = 'lala@test.org' u.addresses.append(a2) print repr(u.addresses) - ctx.current.commit() + Session.commit() usertable = users.select(users.c.user_id.in_(u.user_id)).execute().fetchall() self.assertEqual(usertable[0].values(), [u.user_id, 'one2manytester']) @@ -652,7 +646,7 @@ class OneToManyTest(UnitOfWorkTest): a2.email_address = 'somethingnew@foo.com' - ctx.current.commit() + Session.commit() addresstable = addresses.select(addresses.c.address_id == addressid).execute().fetchall() self.assertEqual(addresstable[0].values(), [addressid, userid, 'somethingnew@foo.com']) @@ -680,7 +674,7 @@ class OneToManyTest(UnitOfWorkTest): a3 = Address() a3.email_address = 'emailaddress3' - ctx.current.commit() + Session.commit() # modify user2 directly, append an address to user1. # upon commit, user2 should be updated, user1 should not @@ -688,7 +682,7 @@ class OneToManyTest(UnitOfWorkTest): u2.user_name = 'user2modified' u1.addresses.append(a3) del u1.addresses[0] - self.assert_sql(testbase.db, lambda: ctx.current.commit(), + self.assert_sql(testbase.db, lambda: Session.commit(), [ ( "UPDATE users SET user_name=:user_name WHERE users.user_id = :users_user_id", @@ -716,13 +710,13 @@ class OneToManyTest(UnitOfWorkTest): a = Address() a.email_address = 'address1' u1.addresses.append(a) - ctx.current.commit() + Session.commit() del u1.addresses[0] u2.addresses.append(a) - ctx.current.delete(u1) - ctx.current.commit() - ctx.current.close() - u2 = ctx.current.get(User, u2.user_id) + Session.delete(u1) + Session.commit() + Session.close() + u2 = Session.get(User, u2.user_id) assert len(u2.addresses) == 1 def testchildmove_2(self): @@ -736,12 +730,12 @@ class OneToManyTest(UnitOfWorkTest): a = Address() a.email_address = 'address1' u1.addresses.append(a) - ctx.current.commit() + Session.commit() del u1.addresses[0] u2.addresses.append(a) - ctx.current.commit() - ctx.current.close() - u2 = ctx.current.get(User, u2.user_id) + Session.commit() + Session.close() + u2 = Session.get(User, u2.user_id) assert len(u2.addresses) == 1 def testo2mdeleteparent(self): @@ -753,10 +747,10 @@ class OneToManyTest(UnitOfWorkTest): u.user_name = 'one2onetester' u.address = a u.address.email_address = 'myonlyaddress@foo.com' - ctx.current.commit() - ctx.current.delete(u) - ctx.current.commit() - self.assert_(a.address_id is not None and a.user_id is None and not ctx.current.identity_map.has_key(u._instance_key) and ctx.current.identity_map.has_key(a._instance_key)) + Session.commit() + Session.delete(u) + Session.commit() + self.assert_(a.address_id is not None and a.user_id is None and not Session().identity_map.has_key(u._instance_key) and Session().identity_map.has_key(a._instance_key)) def testonetoone(self): m = mapper(User, users, properties = dict( @@ -766,11 +760,11 @@ class OneToManyTest(UnitOfWorkTest): u.user_name = 'one2onetester' u.address = Address() u.address.email_address = 'myonlyaddress@foo.com' - ctx.current.commit() + Session.commit() u.user_name = 'imnew' - ctx.current.commit() + Session.commit() u.address.email_address = 'imnew@foo.com' - ctx.current.commit() + Session.commit() def testbidirectional(self): m1 = mapper(User, users) @@ -786,7 +780,7 @@ class OneToManyTest(UnitOfWorkTest): a = Address() a.email_address = 'testaddress' a.user = u - ctx.current.commit() + Session.commit() print repr(u.addresses) x = False try: @@ -798,8 +792,8 @@ class OneToManyTest(UnitOfWorkTest): if x: self.assert_(False, "User addresses element should be scalar based") - ctx.current.delete(u) - ctx.current.commit() + Session.delete(u) + Session.commit() def testdoublerelation(self): m2 = mapper(Address, addresses) @@ -819,7 +813,7 @@ class OneToManyTest(UnitOfWorkTest): u.boston_addresses.append(a) u.newyork_addresses.append(b) - ctx.current.commit() + Session.commit() class SaveTest(UnitOfWorkTest): @@ -853,31 +847,31 @@ class SaveTest(UnitOfWorkTest): u2 = User() u2.user_name = 'savetester2' - ctx.current.save(u) + Session.save(u) - ctx.current.flush([u]) - ctx.current.commit() + Session.flush([u]) + Session.commit() # assert the first one retreives the same from the identity map - nu = ctx.current.get(m, u.user_id) + nu = Session.get(m, u.user_id) print "U: " + repr(u) + "NU: " + repr(nu) self.assert_(u is nu) # clear out the identity map, so next get forces a SELECT - ctx.current.close() + Session.close() # check it again, identity should be different but ids the same - nu = ctx.current.get(m, u.user_id) + nu = Session.get(m, u.user_id) self.assert_(u is not nu and u.user_id == nu.user_id and nu.user_name == 'savetester') # change first users name and save - ctx.current.update(u) + Session.update(u) u.user_name = 'modifiedname' - assert u in ctx.current.dirty - ctx.current.commit() + assert u in Session().dirty + Session.commit() # select both - #ctx.current.close() + #Session.close() userlist = Query(m).select(users.c.user_id.in_(u.user_id, u2.user_id), order_by=[users.c.user_name]) print repr(u.user_id), repr(userlist[0].user_id), repr(userlist[0].user_name) self.assert_(u.user_id == userlist[0].user_id and userlist[0].user_name == 'modifiedname') @@ -895,12 +889,12 @@ class SaveTest(UnitOfWorkTest): u.addresses.append(Address()) u.addresses.append(Address()) u.addresses.append(Address()) - ctx.current.commit() - ctx.current.close() - ulist = ctx.current.query(m1).select() + Session.commit() + Session.close() + ulist = Session.query(m1).select() u1 = ulist[0] u1.user_name = 'newname' - ctx.current.commit() + Session.commit() self.assert_(len(u1.addresses) == 4) def testinherits(self): @@ -917,9 +911,9 @@ class SaveTest(UnitOfWorkTest): ) au = AddressUser() - ctx.current.commit() - ctx.current.close() - l = ctx.current.query(AddressUser).selectone() + Session.commit() + Session.close() + l = Session.query(AddressUser).selectone() self.assert_(l.user_id == au.user_id and l.address_id == au.address_id) def testdeferred(self): @@ -929,18 +923,18 @@ class SaveTest(UnitOfWorkTest): }) u = User() u.user_id=42 - ctx.current.commit() + Session.commit() def test_dont_update_blanks(self): mapper(User, users) u = User() u.user_name = "" - ctx.current.commit() - ctx.current.close() - u = ctx.current.query(User).get(u.user_id) + Session.commit() + Session.close() + u = Session.query(User).get(u.user_id) u.user_name = "" def go(): - ctx.current.commit() + Session.commit() self.assert_sql_count(testbase.db, go, 0) def testmultitable(self): @@ -958,12 +952,12 @@ class SaveTest(UnitOfWorkTest): u.user_name = 'multitester' u.email = 'multi@test.org' - ctx.current.commit() + Session.commit() id = m.primary_key_from_instance(u) - ctx.current.close() + Session.close() - u = ctx.current.get(User, id) + u = Session.get(User, id) assert u.user_name == 'multitester' usertable = users.select(users.c.user_id.in_(u.foo_id)).execute().fetchall() @@ -973,15 +967,15 @@ class SaveTest(UnitOfWorkTest): u.email = 'lala@hey.com' u.user_name = 'imnew' - ctx.current.commit() + Session.commit() usertable = users.select(users.c.user_id.in_(u.foo_id)).execute().fetchall() self.assertEqual(usertable[0].values(), [u.foo_id, 'imnew']) addresstable = addresses.select(addresses.c.address_id.in_(u.address_id)).execute().fetchall() self.assertEqual(addresstable[0].values(), [u.address_id, u.foo_id, 'lala@hey.com']) - ctx.current.close() - u = ctx.current.get(User, id) + Session.close() + u = Session.get(User, id) assert u.user_name == 'imnew' def testhistoryget(self): @@ -994,11 +988,11 @@ class SaveTest(UnitOfWorkTest): u = User() u.addresses.append(Address()) u.addresses.append(Address()) - ctx.current.commit() - ctx.current.close() - u = ctx.current.query(User).get(u.user_id) - ctx.current.delete(u) - ctx.current.commit() + Session.commit() + Session.close() + u = Session.query(User).get(u.user_id) + Session.delete(u) + Session.commit() assert users.count().scalar() == 0 assert addresses.count().scalar() == 0 @@ -1015,7 +1009,7 @@ class SaveTest(UnitOfWorkTest): u1.username = 'user1' u2 = User() u2.username = 'user2' - ctx.current.commit() + Session.commit() clear_mappers() @@ -1025,7 +1019,7 @@ class SaveTest(UnitOfWorkTest): u2 = User() u2.username = 'user2' try: - ctx.current.commit() + Session.commit() assert False except AssertionError: assert True @@ -1062,11 +1056,11 @@ class ManyToOneTest(UnitOfWorkTest): a.user.user_name = elem['user_name'] objects.append(a) - ctx.current.commit() + Session.commit() objects[2].email_address = 'imnew@foo.bar' objects[3].user = User() objects[3].user.user_name = 'imnewlyadded' - self.assert_sql(testbase.db, lambda: ctx.current.commit(), [ + self.assert_sql(testbase.db, lambda: Session.commit(), [ ( "INSERT INTO users (user_name) VALUES (:user_name)", {'user_name': 'imnewlyadded'} @@ -1110,17 +1104,17 @@ class ManyToOneTest(UnitOfWorkTest): u1.user_name='user1' a1.user = u1 - ctx.current.commit() - ctx.current.close() - a1 = ctx.current.query(Address).get(a1.address_id) - u1 = ctx.current.query(User).get(u1.user_id) + Session.commit() + Session.close() + a1 = Session.query(Address).get(a1.address_id) + u1 = Session.query(User).get(u1.user_id) assert a1.user is u1 a1.user = None - ctx.current.commit() - ctx.current.close() - a1 = ctx.current.query(Address).get(a1.address_id) - u1 = ctx.current.query(User).get(u1.user_id) + Session.commit() + Session.close() + a1 = Session.query(Address).get(a1.address_id) + u1 = Session.query(User).get(u1.user_id) assert a1.user is None def testmanytoone_2(self): @@ -1135,19 +1129,19 @@ class ManyToOneTest(UnitOfWorkTest): u1.user_name='user1' a1.user = u1 - ctx.current.commit() - ctx.current.close() - a1 = ctx.current.query(Address).get(a1.address_id) - a2 = ctx.current.query(Address).get(a2.address_id) - u1 = ctx.current.query(User).get(u1.user_id) + Session.commit() + Session.close() + a1 = Session.query(Address).get(a1.address_id) + a2 = Session.query(Address).get(a2.address_id) + u1 = Session.query(User).get(u1.user_id) assert a1.user is u1 a1.user = None a2.user = u1 - ctx.current.commit() - ctx.current.close() - a1 = ctx.current.query(Address).get(a1.address_id) - a2 = ctx.current.query(Address).get(a2.address_id) - u1 = ctx.current.query(User).get(u1.user_id) + Session.commit() + Session.close() + a1 = Session.query(Address).get(a1.address_id) + a2 = Session.query(Address).get(a2.address_id) + u1 = Session.query(User).get(u1.user_id) assert a1.user is None assert a2.user is u1 @@ -1163,19 +1157,19 @@ class ManyToOneTest(UnitOfWorkTest): u2.user_name='user2' a1.user = u1 - ctx.current.commit() - ctx.current.close() - a1 = ctx.current.query(Address).get(a1.address_id) - u1 = ctx.current.query(User).get(u1.user_id) - u2 = ctx.current.query(User).get(u2.user_id) + Session.commit() + Session.close() + a1 = Session.query(Address).get(a1.address_id) + u1 = Session.query(User).get(u1.user_id) + u2 = Session.query(User).get(u2.user_id) assert a1.user is u1 a1.user = u2 - ctx.current.commit() - ctx.current.close() - a1 = ctx.current.query(Address).get(a1.address_id) - u1 = ctx.current.query(User).get(u1.user_id) - u2 = ctx.current.query(User).get(u2.user_id) + Session.commit() + Session.close() + a1 = Session.query(Address).get(a1.address_id) + u1 = Session.query(User).get(u1.user_id) + u2 = Session.query(User).get(u2.user_id) assert a1.user is u2 class ManyToManyTest(UnitOfWorkTest): @@ -1213,7 +1207,7 @@ class ManyToManyTest(UnitOfWorkTest): item.item_name = elem['item_name'] item.keywords = [] if len(elem['keywords'][1]): - klist = ctx.current.query(keywordmapper).select(keywords.c.name.in_(*[e['name'] for e in elem['keywords'][1]])) + klist = Session.query(keywordmapper).select(keywords.c.name.in_(*[e['name'] for e in elem['keywords'][1]])) else: klist = [] khash = {} @@ -1227,16 +1221,16 @@ class ManyToManyTest(UnitOfWorkTest): k.name = kname item.keywords.append(k) - ctx.current.commit() + Session.commit() - l = ctx.current.query(m).select(items.c.item_name.in_(*[e['item_name'] for e in data[1:]]), order_by=[items.c.item_name]) + l = Session.query(m).select(items.c.item_name.in_(*[e['item_name'] for e in data[1:]]), order_by=[items.c.item_name]) self.assert_result(l, *data) objects[4].item_name = 'item4updated' k = Keyword() k.name = 'yellow' objects[5].keywords.append(k) - self.assert_sql(testbase.db, lambda:ctx.current.commit(), [ + self.assert_sql(testbase.db, lambda:Session.commit(), [ { "UPDATE items SET item_name=:item_name WHERE items.item_id = :items_item_id": {'item_name': 'item4updated', 'items_item_id': objects[4].item_id} @@ -1265,7 +1259,7 @@ class ManyToManyTest(UnitOfWorkTest): objects[2].keywords.append(k) dkid = objects[5].keywords[1].keyword_id del objects[5].keywords[1] - self.assert_sql(testbase.db, lambda:ctx.current.commit(), [ + self.assert_sql(testbase.db, lambda:Session.commit(), [ ( "DELETE FROM itemkeywords WHERE itemkeywords.item_id = :item_id AND itemkeywords.keyword_id = :keyword_id", [{'item_id': objects[5].item_id, 'keyword_id': dkid}] @@ -1276,8 +1270,8 @@ class ManyToManyTest(UnitOfWorkTest): ) ]) - ctx.current.delete(objects[3]) - ctx.current.commit() + Session.delete(objects[3]) + Session.commit() def testmanytomanyremove(self): """tests that setting a list-based attribute to '[]' properly affects the history and allows @@ -1293,11 +1287,11 @@ class ManyToManyTest(UnitOfWorkTest): k2 = Keyword() i.keywords.append(k1) i.keywords.append(k2) - ctx.current.commit() + Session.commit() assert itemkeywords.count().scalar() == 2 i.keywords = [] - ctx.current.commit() + Session.commit() assert itemkeywords.count().scalar() == 0 def testscalar(self): @@ -1310,9 +1304,9 @@ class ManyToManyTest(UnitOfWorkTest): )) i = Item() - ctx.current.commit() - ctx.current.delete(i) - ctx.current.commit() + Session.commit() + Session.delete(i) + Session.commit() @@ -1337,15 +1331,15 @@ class ManyToManyTest(UnitOfWorkTest): item.keywords.append(k1) item.keywords.append(k2) item.keywords.append(k3) - ctx.current.commit() + Session.commit() item.keywords = [] item.keywords.append(k1) item.keywords.append(k2) - ctx.current.commit() + Session.commit() - ctx.current.close() - item = ctx.current.query(Item).get(item.item_id) + Session.close() + item = Session.query(Item).get(item.item_id) print [k1, k2] print item.keywords assert item.keywords == [k1, k2] @@ -1409,8 +1403,8 @@ class ManyToManyTest(UnitOfWorkTest): ik.keyword = k item.keywords.append(ik) - ctx.current.commit() - ctx.current.close() + Session.commit() + Session.close() l = Query(m).select(items.c.item_name.in_(*[e['item_name'] for e in data[1:]]), order_by=[items.c.item_name]) self.assert_result(l, *data) @@ -1435,11 +1429,11 @@ class ManyToManyTest(UnitOfWorkTest): k = KeywordUser() k.user_name = 'keyworduser' k.keyword_name = 'a keyword' - ctx.current.commit() + Session.commit() id = (k.user_id, k.keyword_id) - ctx.current.close() - k = ctx.current.query(KeywordUser).get(id) + Session.close() + k = Session.query(KeywordUser).get(id) assert k.user_name == 'keyworduser' assert k.keyword_name == 'a keyword' @@ -1447,7 +1441,7 @@ class ManyToManyTest(UnitOfWorkTest): class SaveTest2(UnitOfWorkTest): def setUp(self): - ctx.current.close() + Session.close() clear_mappers() global meta, users, addresses meta = MetaData(testbase.db) @@ -1482,7 +1476,7 @@ class SaveTest2(UnitOfWorkTest): a.user = User() a.user.user_name = elem['user_name'] objects.append(a) - self.assert_sql(testbase.db, lambda: ctx.current.commit(), [ + self.assert_sql(testbase.db, lambda: Session.commit(), [ ( "INSERT INTO users (user_name) VALUES (:user_name)", {'user_name': 'thesub'} @@ -1568,12 +1562,12 @@ class SaveTest3(UnitOfWorkTest): k2 = Keyword() i.keywords.append(k1) i.keywords.append(k2) - ctx.current.commit() + Session.commit() assert t2.count().scalar() == 2 i.keywords = [] print i.keywords - ctx.current.commit() + Session.commit() assert t2.count().scalar() == 0 |