Changeset 185

Timestamp:

08/18/07 18:00:17 (6 years ago)

Author:

cleverdevil

Message:

Patch from Mike Bayer:

The attached patch modifies Elixir's "Objectstore" implementation to work
for a SessionContext from versions 0.3 and 0.4, as well as the
0.4-onlyScopedSession object. Additionally, a new using_options() option
"session" is added, such that any user-defined SessionContext or
ScopedSession may be assigned to an Elixir class individually. So the
contextual "Session" which is to be used by Elixir can now be set at three
levels; globally using elixir.objectstore, per-module using module.session,
or per-class using using_options(session=somesess).

Three tests are added, two of which test using_options(session) against

both kinds of session, and a third which tests module-level usage of
ScopedSession.

At the very least, the new "Objectstore" class should be implemented which

establishes compatibility with ScopedSession which is featured in the Pylons
tutorial.

the patch also fixes a bug in versioned.py where an execute() statement
could be issued using unicode keywords, which is illegal for the **params
calling style.

Thanks, Mike!

Location:

elixir/trunk

Files:

• elixir/__init__.py (modified) (2 diffs)
• elixir/entity.py (modified) (5 diffs)
• elixir/ext/versioned.py (modified) (4 diffs)
• elixir/options.py (modified) (1 diff)
• tests/test_options.py (modified) (2 diffs)

elixir/trunk/elixir/__init__.py

@@ -24 +24 @@
 from elixir.options import using_options, using_table_options, \
                            using_mapper_options, options_defaults
-from elixir.entity import Entity, EntityMeta, EntityDescriptor
+from elixir.entity import Entity, EntityMeta, EntityDescriptor, Objectstore
 from elixir.fields import has_field, with_fields, Field
 from elixir.relationships import belongs_to, has_one, has_many, \
@@ -56 +56 @@
     objectstore = sqlalchemy.objectstore
 except AttributeError:
-    # thread local SessionContext
-    class Objectstore(object):
-
-        def __init__(self, *args, **kwargs):
-            self.context = SessionContext(*args, **kwargs)
-
-        def __getattr__(self, name):
-            return getattr(self.context.current, name)
-
-        session = property(lambda s:s.context.current)
-
-    objectstore = Objectstore(sqlalchemy.orm.create_session)
+    objectstore = Objectstore(SessionContext(sqlalchemy.orm.create_session))
 
 metadatas = set()
 
 
-def create_all():
+def create_all(engine=None):
     'Create all necessary tables for all declared entities'
     for md in metadatas:
-        md.create_all()
+        md.create_all(bind=engine)
 
 
-def drop_all():
+def drop_all(engine=None):
     'Drop all tables for all declared entities'
     for md in metadatas:
-        md.drop_all()
+        md.drop_all(bind=engine)
 
 _delayed_descriptors = list()

elixir/trunk/elixir/entity.py

@@ -7 +7 @@
 from sqlalchemy.orm                 import deferred, Query, MapperExtension
 from sqlalchemy.ext.assignmapper    import assign_mapper
+from sqlalchemy.ext.sessioncontext  import SessionContext
 from sqlalchemy.util                import OrderedDict
 import sqlalchemy
@@ -156 +157 @@
             return
         
-        session = getattr(self.module, 'session', elixir.objectstore)
+        # look for a 'session' attribute assigned to the entity
+        # (or entity's base class)
+        session = getattr(self, 'session', None)
+        if session is None:
+            session = getattr(self.module, 'session', elixir.objectstore)
+        if not isinstance(session, Objectstore):
+            session = Objectstore(session)
+            
+        self.objectstore = session
         
         kwargs = self.mapper_options
@@ -213 +222 @@
             args = [self.entity.table]
 
-        assign_mapper(session.context, self.entity, properties=properties, 
+        self.objectstore.mapper(self.entity, properties=properties, 
                       *args, **kwargs)
 
@@ -496 +505 @@
 
     def q(cls):
-        return Query(cls, session=elixir.objectstore.session)
+        return Query(cls, session=cls._descriptor.objectstore.session)
     q = property(q)
 
@@ -544 +553 @@
 
 
+class Objectstore(object):
+    """a wrapper for a SQLAlchemy session-making object, such as 
+    SessionContext or ScopedSession.
+    
+    Uses the ``registry`` attribute present on both objects
+    (versions 0.3 and 0.4) in order to return the current
+    contextual session.
+    """
+    
+    def __init__(self, ctx):
+        self.context = ctx
+        self.is_ctx = isinstance(ctx, SessionContext)
+
+    def __getattr__(self, name):
+        return getattr(self.context.registry(), name)
+    
+    def mapper(self, cls, *args, **kwargs):
+        if self.is_ctx:
+            assign_mapper(self.context, cls, *args, **kwargs)
+        else:
+            cls.mapper = self.context.mapper(cls, *args, **kwargs)
+        
+    session = property(lambda s:s.context.registry())
+

elixir/trunk/elixir/ext/versioned.py

@@ -40 +40 @@
 '''
 
-from elixir                import Integer, objectstore, DateTime
+from elixir                import Integer, DateTime
 from elixir.statements     import Statement
 from elixir.fields         import Field
@@ -143 +143 @@
         # attach utility methods and properties to the entity
         def get_versions(self):
-            return objectstore.query(Version).select(get_history_where(self))
+            return entity._descriptor.objectstore.query(Version).select(get_history_where(self))
         
         def get_as_of(self, dt):
@@ -152 +152 @@
             # otherwise, we need to look to the history table to get our
             # older version
-            items = objectstore.query(Version).select(
+            items = entity._descriptor.objectstore.query(Version).select(
                 and_(get_history_where(self), Version.c.timestamp <= dt),
                 order_by=desc(Version.c.timestamp),
@@ -168 +168 @@
             
             entity.table.update(get_entity_where(self)).execute(
-                **dict(old_version.items())
+                dict(old_version.items())
             )
             

elixir/trunk/elixir/options.py

@@ -137 +137 @@
         'metadata',
         'order_by',
+        'session',
     )
     

elixir/trunk/tests/test_options.py

@@ -7 +7 @@
 from sqlalchemy.exceptions import SQLError, ConcurrentModificationError 
 from elixir import *
-
 
 class TestOptions(object):
@@ -77 +76 @@
 
 
-
+class TestSessionOptions(object):
+    def setup(self):
+        metadata.bind = None
+
+    def teardown(self):
+        cleanup_all()
+
+    def test_session_context(self):
+        from sqlalchemy.ext.sessioncontext import SessionContext
+        from sqlalchemy.orm import create_session
+        from sqlalchemy import create_engine
+
+        engine = create_engine('sqlite:///')
+        
+        ctx = SessionContext(lambda: create_session(bind=engine))
+        
+        class Person(Entity):
+            using_options(session=ctx)
+            has_field('firstname', Unicode(30))
+            has_field('surname', Unicode(30))
+
+        create_all(engine)
+
+        homer = Person(firstname="Homer", surname='Simpson')
+        bart = Person(firstname="Bart", surname='Simpson')
+        ctx.current.flush()
+        
+        assert Person.query().session is ctx.current
+        
+        assert Person.query().filter_by(firstname='Homer').one() is homer
+
+    def test_scoped_session(self):
+        try:
+            from sqlalchemy.orm import scoped_session, sessionmaker
+        except ImportError:
+            print "Not on version 0.4 of sqlalchemy"
+            return
+            
+        from sqlalchemy import create_engine
+
+        engine = create_engine('sqlite:///')
+
+        Session = scoped_session(sessionmaker(bind=engine))
+
+        class Person(Entity):
+            using_options(session=Session)
+            has_field('firstname', Unicode(30))
+            has_field('surname', Unicode(30))
+
+        create_all(engine)
+
+        homer = Person(firstname="Homer", surname='Simpson')
+        bart = Person(firstname="Bart", surname='Simpson')
+        Session.flush()
+
+        assert Person.query().session is Session()
+
+        assert Person.query().filter_by(firstname='Homer').one() is homer
+        
+    def test_global_scoped_session(self):
+        try:
+            from sqlalchemy.orm import scoped_session, sessionmaker
+        except ImportError:
+            print "Not on version 0.4 of sqlalchemy"
+            return
+
+        from sqlalchemy import create_engine
+
+        global session
+        
+        engine = create_engine('sqlite:///')
+        
+        session = scoped_session(sessionmaker(bind=engine))
+        
+        class Person(Entity):
+            has_field('firstname', Unicode(30))
+            has_field('surname', Unicode(30))
+
+        create_all(engine)
+
+        homer = Person(firstname="Homer", surname='Simpson')
+        bart = Person(firstname="Bart", surname='Simpson')
+        session.flush()
+        
+        assert Person.query().session is session()
+        
+        assert Person.query().filter_by(firstname='Homer').one() is homer
+
+        del session
+        
 class TestTableOptions(object):
     def setup(self):