Changeset 210 for elixir/trunk/elixir/entity.py

Timestamp:

09/24/07 15:41:42 (6 years ago)

Author:

ged

Message:

• moved away from assign_mapper, now all assign_mapper-provided methods are on
  the Entity class. Now, if people don't like them, they have the option to
  simply provide another base class.
  
• migrated from ".query()" and ".q" to ".query" syntax
  
• added support for "manual session management" (ie you can now define an
  entity with "using_options(session=None)" and it won't use any
  SessionContext extension, nor receive the "query" attribute.
  
• fixed TG issue (which uses activemapper's objectstore with Elixir!)
  
• default objectstore is now a ScopedSession if working on SA 0.4. Ie it's
  not wrapped in an Objectstore object at all. This means, that depending on
  the version of SA you are using, you'll get a slightly different behavior.
  
• fixed versioning extension (but I'm not sure what I've done to fix it --
  probably the session code)
  
• made the versioning extension slightly faster (limit 1 on query and do not
  recompute the whole colvalues several times for the same update)
  
• probably made the versioning extension work with manual sessions too
  (though this is untested)
  
• dropped support for the old threadlocal SA extension (which doesn't even exist
  anymore in SA 0.4)
  
• updated TODO file
  
• cleaned test_multi
  

Files:

• elixir/trunk/elixir/entity.py (modified) (10 diffs)

elixir/trunk/elixir/entity.py

@@ -7 +7 @@
 from sqlalchemy                     import Table, Integer, String, desc,\
                                            ForeignKey, and_
-from sqlalchemy.orm                 import deferred, Query, MapperExtension
-from sqlalchemy.ext.assignmapper    import assign_mapper
+from sqlalchemy.orm                 import deferred, Query, MapperExtension,\
+                                           mapper, object_session
 from sqlalchemy.ext.sessioncontext  import SessionContext
 from sqlalchemy.util                import OrderedDict
@@ -15 +15 @@
 from elixir.fields                  import Field
 from elixir.options                 import options_defaults
+
 
 try:
@@ -35 +36 @@
 DEFAULT_POLYMORPHIC_COL_SIZE = 40
 DEFAULT_POLYMORPHIC_COL_TYPE = String(DEFAULT_POLYMORPHIC_COL_SIZE)
+
+try: 
+    from sqlalchemy.orm import ScopedSession
+except ImportError: 
+    # Not on sqlalchemy version 0.4
+    ScopedSession = type(None)
+    
+def _do_mapping(session, cls, *args, **kwargs):
+    if session is None:
+        return mapper(cls, *args, **kwargs)
+    elif isinstance(session, ScopedSession):
+        return session.mapper(cls, *args, **kwargs)
+    elif isinstance(session, SessionContext):
+        extension = kwargs.pop('extension', None)
+        if extension is not None:
+            if not isinstance(extension, list):
+                extension = [extension]
+            extension.append(session.mapper_extension)
+        else:
+            extension = session.mapper_extension
+
+        class query(object):
+            def __getattr__(s, key):
+                return getattr(session.registry().query(cls), key)
+            def __call__(s):
+                return session.registry().query(cls)
+
+        if not 'query' in cls.__dict__: 
+            cls.query = query()
+
+        return mapper(cls, extension=extension, *args, **kwargs)
 
 class EntityDescriptor(object):
@@ -72 +104 @@
         self.table_args = list()
         self.metadata = getattr(self.module, 'metadata', elixir.metadata)
+        self.session = getattr(self.module, 'session', elixir.session)
 
         for option in ('inheritance', 'polymorphic',
                        'autoload', 'tablename', 'shortnames', 
-                       'auto_primarykey',
-                       'version_id_col'):
+                       'auto_primarykey', 'version_id_col'):
             setattr(self, option, options_defaults[option])
 
         for option_dict in ('mapper_options', 'table_options'):
             setattr(self, option_dict, options_defaults[option_dict].copy())
-   
+ 
     def setup_options(self):
         '''
@@ -88 +120 @@
         '''
         elixir.metadatas.add(self.metadata)
+
+        objectstore = None
+        session = self.session
+        if session is None or isinstance(session, ScopedSession):
+            # no stinking objectstore
+            pass
+        elif isinstance(session, SessionContext):
+            objectstore = Objectstore(session)
+        elif not hasattr(session, 'registry'):
+            # Both SessionContext and ScopedSession have a registry attribute,
+            # but objectstores (whether Elixir's or Activemapper's) don't, so 
+            # if we are here, it means an Objectstore is used for the session.
+            objectstore = session
+            session = objectstore.context
+
+        self.session = session
+        self.objectstore = objectstore
 
         entity = self.entity
@@ -286 +335 @@
         if self.entity.mapper:
             return
-        
-        # 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
@@ -362 +401 @@
             args = [self.entity.table]
 
-        self.objectstore.mapper(self.entity, properties=properties, 
-                                *args, **kwargs)
+        self.entity.mapper = _do_mapping(self.session, self.entity, 
+                                         properties=properties,
+                                         *args, **kwargs)
 
     def after_mapper(self):
@@ -605 +645 @@
         return type.__call__(cls, *args, **kwargs)
 
-    def q(cls):
-        return Query(cls, session=cls._descriptor.objectstore.session)
-    q = property(q)
 
 
@@ -638 +675 @@
             setattr(self, key, value)
 
+    # session methods
+    def flush(self, *args, **kwargs):
+        return object_session(self).flush([self], *args, **kwargs)
+
+    def delete(self, *args, **kwargs):
+        return object_session(self).delete(self, *args, **kwargs)
+
+    def expire(self, *args, **kwargs):
+        return object_session(self).expire(self, *args, **kwargs)
+
+    def refresh(self, *args, **kwargs):
+        return object_session(self).refresh(self, *args, **kwargs)
+
+    def expunge(self, *args, **kwargs):
+        return object_session(self).expunge(self, *args, **kwargs)
+
+    # This bunch of session methods, along with all the query methods below 
+    # only make sense when using a global/scoped/contextual session.
+    def _global_session(self):
+        return self._descriptor.session.registry()
+    _global_session = property(_global_session)
+
+    def merge(self, *args, **kwargs):
+        return self._global_session.merge(self, *args, **kwargs)
+
+    def save(self, *args, **kwargs):
+        return self._global_session.save(self, *args, **kwargs)
+
+    def update(self, *args, **kwargs):
+        return self._global_session.update(self, *args, **kwargs)
+
+    def save_or_update(self, *args, **kwargs):
+        return self._global_session.save_or_update(self, *args, **kwargs)
+
+    # query methods
     def get_by(cls, *args, **kwargs):
-        return cls.query().filter_by(*args, **kwargs).first()
+        return cls.query.filter_by(*args, **kwargs).first()
     get_by = classmethod(get_by)
 
-
     def get(cls, *args, **kwargs):
-        return cls.query().get(*args, **kwargs)
+        return cls.query.get(*args, **kwargs)
     get = classmethod(get)
 
-
-    # DEPRECATED LAND
+    #-----------------#
+    # DEPRECATED LAND #
+    #-----------------#
+
+    def filter(cls, *args, **kwargs):
+        warnings.warn("The filter method on the class is deprecated."
+                      "You should use cls.query.filter(...)", 
+                      DeprecationWarning, stacklevel=2)
+        return cls.query.filter(*args, **kwargs)
+    filter = classmethod(filter)
+
+    def filter_by(cls, *args, **kwargs):
+        warnings.warn("The filter_by method on the class is deprecated."
+                      "You should use cls.query.filter_by(...)", 
+                      DeprecationWarning, stacklevel=2)
+        return cls.query.filter_by(*args, **kwargs)
+    filter_by = classmethod(filter_by)
+
     def select(cls, *args, **kwargs):
         warnings.warn("The select method on the class is deprecated."
-                      "You should use cls.query.filter(...).all()", DeprecationWarning,
-                      stacklevel=2)
-        return cls.query().filter(*args, **kwargs).all()
+                      "You should use cls.query.filter(...).all()", 
+                      DeprecationWarning, stacklevel=2)
+        return cls.query.filter(*args, **kwargs).all()
     select = classmethod(select)
+
+    def select_by(cls, *args, **kwargs):
+        warnings.warn("The select_by method on the class is deprecated."
+                      "You should use cls.query.filter_by(...).all()", 
+                      DeprecationWarning, stacklevel=2)
+        return cls.query.filter_by(*args, **kwargs).all()
+    select_by = classmethod(select_by)
+
+    def selectfirst(cls, *args, **kwargs):
+        warnings.warn("The selectfirst method on the class is deprecated."
+                      "You should use cls.query.filter(...).first()", 
+                      DeprecationWarning, stacklevel=2)
+        return cls.query.filter(*args, **kwargs).first()
+    selectfirst = classmethod(selectfirst)
+
+    def selectfirst_by(cls, *args, **kwargs):
+        warnings.warn("The selectfirst_by method on the class is deprecated."
+                      "You should use cls.query.filter_by(...).first()", 
+                      DeprecationWarning, stacklevel=2)
+        return cls.query.filter_by(*args, **kwargs).first()
+    selectfirst_by = classmethod(selectfirst_by)
+
+    def selectone(cls, *args, **kwargs):
+        warnings.warn("The selectone method on the class is deprecated."
+                      "You should use cls.query.filter(...).one()", 
+                      DeprecationWarning, stacklevel=2)
+        return cls.query.filter(*args, **kwargs).one()
+    selectone = classmethod(selectone)
+
+    def selectone_by(cls, *args, **kwargs):
+        warnings.warn("The selectone_by method on the class is deprecated."
+                      "You should use cls.query.filter_by(...).one()", 
+                      DeprecationWarning, stacklevel=2)
+        return cls.query.filter_by(*args, **kwargs).one()
+    selectone_by = classmethod(selectone_by)
+
+    def join_to(cls, *args, **kwargs):
+        warnings.warn("The join_to method on the class is deprecated."
+                      "You should use cls.query.join(...)", 
+                      DeprecationWarning, stacklevel=2)
+        return cls.query.join_to(*args, **kwargs).all()
+    join_to = classmethod(join_to)
+
+    def join_via(cls, *args, **kwargs):
+        warnings.warn("The join_via method on the class is deprecated."
+                      "You should use cls.query.join(...)", 
+                      DeprecationWarning, stacklevel=2)
+        return cls.query.join_via(*args, **kwargs).all()
+    join_via = classmethod(join_via)
+
+    def count(cls, *args, **kwargs):
+        warnings.warn("The count method on the class is deprecated."
+                      "You should use cls.query.filter(...).count()", 
+                      DeprecationWarning, stacklevel=2)
+        return cls.query.filter(*args, **kwargs).count()
+    count = classmethod(count)
+
+    def count_by(cls, *args, **kwargs):
+        warnings.warn("The count_by method on the class is deprecated."
+                      "You should use cls.query.filter_by(...).count()", 
+                      DeprecationWarning, stacklevel=2)
+        return cls.query.filter_by(*args, **kwargs).count()
+    count_by = classmethod(count_by)
+
+    def options(cls, *args, **kwargs):
+        warnings.warn("The options method on the class is deprecated."
+                      "You should use cls.query.options(...)", 
+                      DeprecationWarning, stacklevel=2)
+        return cls.query.options(*args, **kwargs)
+    options = classmethod(options)
+
+    def instances(cls, *args, **kwargs):
+        warnings.warn("The instances method on the class is deprecated."
+                      "You should use cls.query.instances(...)", 
+                      DeprecationWarning, stacklevel=2)
+        return cls.query.instances(*args, **kwargs)
+    instances = classmethod(instances)
+
 
 
@@ -668 +833 @@
     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())