Changeset 349

Show
Ignore:
Timestamp:
07/02/08 13:33:20 (6 years ago)
Author:
ged
Message:

- The default session (elixir.session) uses sessionmaker() instead of

create_session(), which means it has now the following characterisics:

  • autoflush=True
  • autocommit=False (with SA 0.5 -- equivalent to transactional=True with
    SA 0.4)
  • autoexpire=True (with SA 0.5).

- Removed objectstore and some other old cruft (mostly SA 0.3 or earlier

support code)

Location:
elixir/trunk
Files:
25 modified

Legend:

Unmodified
Added
Removed
  • elixir/trunk/CHANGES

    r347 r349  
    1313  the identity name automatically from the class itself. 
    1414- Added __setattr__ method on Metaclass so that you can add properties 
    15   slightly more easily after class definition (but before setup_all): 
     15  slightly more easily after class definition (but *before* setup_all): 
    1616    class A(Entity): 
    1717        pass 
     
    2121- Added support for SQLAlchemy 0.5, and dropped support for version 0.3 and 
    2222  earlier. 
     23- The default session (elixir.session) uses sessionmaker() instead of 
     24  create_session(), which means it has now the following characterisics: 
     25    * autoflush=True 
     26    * autocommit=False (with SA 0.5 -- equivalent to transactional=True with  
     27      SA 0.4) 
     28    * autoexpire=True (with SA 0.5). 
     29- removed objectstore 
    2330 
    2431Bug fixes: 
  • elixir/trunk/elixir/__init__.py

    r347 r349  
    5050           'ManyToOne', 'OneToOne', 'OneToMany', 'ManyToMany', 
    5151           'using_options', 'using_table_options', 'using_mapper_options', 
    52            'options_defaults', 'metadata', 'objectstore', 'session', 
     52           'options_defaults', 'metadata', 'session', 
    5353           'create_all', 'drop_all', 
    5454           'setup_all', 'cleanup_all', 
     
    6060               'metadata', 'session'] 
    6161 
    62  
    63 class Objectstore(object): 
    64     """a wrapper for a SQLAlchemy session-making object, such as 
    65     SessionContext or ScopedSession. 
    66  
    67     Uses the ``registry`` attribute present on both objects 
    68     (versions 0.3 and 0.4) in order to return the current 
    69     contextual session. 
    70     """ 
    71  
    72     def __init__(self, ctx): 
    73         self.context = ctx 
    74  
    75     def __getattr__(self, name): 
    76         return getattr(self.context.registry(), name) 
    77  
    78     session = property(lambda s:s.context.registry()) 
    79  
    8062# default session 
    81 try: 
    82     from sqlalchemy.orm import scoped_session 
    83     session = scoped_session(sqlalchemy.orm.create_session) 
    84 except ImportError: 
    85     # Not on version 0.4 of sqlalchemy 
    86     from sqlalchemy.ext.sessioncontext import SessionContext 
    87     session = Objectstore(SessionContext(sqlalchemy.orm.create_session)) 
    88  
    89 # backward-compatible name 
    90 objectstore = session 
     63session = sqlalchemy.orm.scoped_session(sqlalchemy.orm.sessionmaker()) 
    9164 
    9265# default metadata 
     
    201174    metadatas.clear() 
    202175 
    203     session.clear() 
     176    session.close() 
    204177 
    205178    sqlalchemy.orm.clear_mappers() 
  • elixir/trunk/elixir/entity.py

    r348 r349  
    1515                           ForeignKeyConstraint 
    1616from sqlalchemy.orm import Query, MapperExtension, mapper, object_session, \ 
    17                            EXT_CONTINUE, polymorphic_union 
    18 try: 
    19     from sqlalchemy.ext.sessioncontext import SessionContext 
    20 except ImportError: 
    21     # Probably on sqlalchemy version 0.5 
    22     pass 
     17                           EXT_CONTINUE, polymorphic_union, ScopedSession 
    2318 
    2419import elixir 
     
    3025__doc_all__ = ['Entity', 'EntityMeta'] 
    3126 
    32  
    33 try: 
    34     from sqlalchemy.orm import ScopedSession 
    35 except ImportError: 
    36     # Not on sqlalchemy version 0.4 
    37     ScopedSession = type(None) 
    38  
    39  
    40 def _do_mapping(session, cls, *args, **kwargs): 
    41     if session is None: 
    42         return mapper(cls, *args, **kwargs) 
    43     elif isinstance(session, ScopedSession): 
    44         return session.mapper(cls, *args, **kwargs) 
    45     elif isinstance(session, SessionContext): 
    46         extension = kwargs.pop('extension', None) 
    47         if extension is not None: 
    48             if not isinstance(extension, list): 
    49                 extension = [extension] 
    50             extension.append(session.mapper_extension) 
    51         else: 
    52             extension = session.mapper_extension 
    53  
    54         class query(object): 
    55             def __getattr__(s, key): 
    56                 return getattr(session.registry().query(cls), key) 
    57  
    58             def __call__(s): 
    59                 return session.registry().query(cls) 
    60  
    61         if not 'query' in cls.__dict__: 
    62             cls.query = query() 
    63  
    64         return mapper(cls, extension=extension, *args, **kwargs) 
    65     else: 
    66         raise Exception("Failed to map entity '%s' with its table or " 
    67                         "selectable" % cls.__name__) 
    6827 
    6928 
     
    11675        self.metadata = getattr(self.module, '__metadata__', elixir.metadata) 
    11776        self.session = getattr(self.module, '__session__', elixir.session) 
    118         self.objectstore = None 
    11977        self.collection = getattr(self.module, '__entity_collection__', 
    12078                                  elixir.entities) 
     
    13896        if self.collection is not None: 
    13997            self.collection.map_entity(self.entity) 
    140  
    141         objectstore = None 
    142         session = self.session 
    143         if session is None or isinstance(session, ScopedSession): 
    144             # no stinking objectstore 
    145             pass 
    146         elif isinstance(session, SessionContext): 
    147             objectstore = elixir.Objectstore(session) 
    148         elif not hasattr(session, 'registry'): 
    149             # Both SessionContext and ScopedSession have a registry attribute, 
    150             # but objectstores (whether Elixir's or Activemapper's) don't, so 
    151             # if we are here, it means an Objectstore is used for the session. 
    152 #XXX: still true for activemapper post 0.4? 
    153             objectstore = session 
    154             session = objectstore.context 
    155  
    156         self.session = session 
    157         self.objectstore = objectstore 
    15898 
    15999        entity = self.entity 
     
    462402            args = [self.entity.table] 
    463403 
    464         self.entity.mapper = _do_mapping(self.session, self.entity, 
    465                                          properties=self.properties, 
    466                                          *args, **kwargs) 
     404        # do the mapping 
     405        kwargs['properties'] = self.properties 
     406        if self.session is None: 
     407            self.entity.mapper = mapper(self.entity, *args, **kwargs) 
     408        elif isinstance(self.session, ScopedSession): 
     409            self.entity.mapper = self.session.mapper(self.entity, 
     410                                                     *args, **kwargs) 
     411        else: 
     412            raise Exception("Failed to map entity '%s' with its table or " 
     413                            "selectable" % self.entity.__name__) 
    467414 
    468415    def after_mapper(self): 
     
    965912 
    966913    # session methods 
    967     def flush(self, *args, **kwargs): 
    968         return object_session(self).flush([self], *args, **kwargs) 
     914    def commit(self, *args, **kwargs): 
     915        return object_session(self).commit([self], *args, **kwargs) 
    969916 
    970917    def delete(self, *args, **kwargs): 
  • elixir/trunk/elixir/ext/list.py

    r313 r349  
    66Once you flag an entity with an `acts_as_list()` statement, a column will be 
    77added to the entity called `position` which will be an integer column that is 
    8 managed for you by the plugin.  You can pass an alternative column name to  
     8managed for you by the plugin.  You can pass an alternative column name to 
    99the plugin using the `column_name` keyword argument. 
    1010 
     
    3838    from elixir import * 
    3939    from elixir.ext.list import acts_as_list 
    40      
     40 
    4141    class ToDo(Entity): 
    4242        subject = Field(String(128)) 
     
    5151        name = Field(String(64)) 
    5252        todos = OneToMany('ToDo', order_by='position') 
    53          
    54  
    55 The above example can then be used to manage ordered todo lists for people. Note 
    56 that you must set the `order_by` property on the `Person.todo` relation in order 
    57 for the relation to respect the ordering. Here is an example of using this model 
    58 in practice: 
     53 
     54 
     55The above example can then be used to manage ordered todo lists for people.  
     56Note that you must set the `order_by` property on the `Person.todo` relation in 
     57order for the relation to respect the ordering. Here is an example of using  
     58this model in practice: 
    5959 
    6060.. sourcecode:: python 
     
    6464    p.todos.append(ToDo(subject='Two')) 
    6565    p.todos.append(ToDo(subject='One')) 
    66     session.flush(); session.clear() 
    67      
     66    session.commit(); session.clear() 
     67 
    6868    p = Person.query.filter_by(name='Jonathan').one() 
    6969    p.todos[0].move_to_bottom() 
    7070    p.todos[2].move_to_top() 
    71     session.flush(); session.clear() 
    72      
     71    session.commit(); session.clear() 
     72 
    7373    p = Person.query.filter_by(name='Jonathan').one() 
    7474    assert p.todos[0].subject == 'One' 
    7575    assert p.todos[1].subject == 'Two' 
    7676    assert p.todos[2].subject == 'Three' 
    77      
     77 
    7878 
    7979For more examples, refer to the unit tests for this plugin. 
     
    9797 
    9898class ListEntityBuilder(object): 
    99      
     99 
    100100    def __init__(self, entity, qualifier=None, column_name='position'): 
    101101        self.entity = entity 
    102102        self.qualifier_method = qualifier 
    103103        self.column_name = column_name 
    104      
     104 
    105105    def create_non_pk_cols(self): 
    106106        self.position_column = Column(self.column_name, Integer) 
    107107        self.entity._descriptor.add_column(self.position_column) 
    108      
     108 
    109109    def after_table(self): 
    110110        position_column = self.position_column 
    111111        position_column_name = self.column_name 
    112          
    113         qualifier_method = self.qualifier_method  
     112 
     113        qualifier_method = self.qualifier_method 
    114114        if not qualifier_method: 
    115115            qualifier_method = lambda self: None 
    116          
     116 
    117117        def _init_position(self): 
    118118            s = select( 
     
    123123            ) 
    124124            a = s.alias() 
     125            #XXX: two func.max? 
    125126            setattr(self, position_column_name, select([func.max(a.c.value)])) 
    126127        _init_position = before_insert(_init_position) 
    127          
     128 
    128129        def _shift_items(self): 
    129130            self.table.update( 
     
    137138            ).execute() 
    138139        _shift_items = before_delete(_shift_items) 
    139          
    140         def move_to_bottom(self):         
     140 
     141        def move_to_bottom(self): 
    141142            # move the items that were above this item up one 
    142143            self.table.update( 
     
    149150                } 
    150151            ).execute() 
    151              
     152 
    152153            # move this item to the max position 
    153154            self.table.update( 
     
    160161                } 
    161162            ).execute() 
    162              
     163 
    163164        def move_to_top(self): 
    164165            # move the items that were above this item down one 
     
    169170                ), 
    170171                values = { 
    171                     position_column : position_column + 1 
     172                    position_column: position_column + 1 
    172173                } 
    173174            ).execute() 
    174175 
    175176            # move this item to the first position 
    176             self.table.update(get_entity_where(self)).execute(**{position_column_name:1}) 
    177              
     177            self.table.update(get_entity_where(self)) \ 
     178                      .execute(**{position_column_name: 1}) 
     179 
    178180        def move_to(self, position): 
    179181            current_position = getattr(self, position_column_name) 
    180              
     182 
    181183            # determine which direction we're moving 
    182184            if position < current_position: 
     
    194196                ) 
    195197                modifier = -1 
    196              
     198 
    197199            # shift the items in between the current and new positions 
    198200            self.table.update(where, values = { 
    199201                position_column : position_column + modifier 
    200202            }).execute() 
    201              
     203 
    202204            # update this item's position to the desired position 
    203             self.table.update(get_entity_where(self)).execute(**{position_column_name:position}) 
    204          
    205         def move_lower(self):  
    206             self.move_to(getattr(self, position_column_name)+1) 
    207          
    208         def move_higher(self):  
    209             self.move_to(getattr(self, position_column_name)-1) 
    210          
    211          
     205            self.table.update(get_entity_where(self)) \ 
     206                      .execute(**{position_column_name: position}) 
     207 
     208        def move_lower(self): 
     209            self.move_to(getattr(self, position_column_name) + 1) 
     210 
     211        def move_higher(self): 
     212            self.move_to(getattr(self, position_column_name) - 1) 
     213 
     214 
    212215        # attach new methods to entity 
    213216        self.entity._init_position = _init_position 
  • elixir/trunk/elixir/options.py

    r347 r349  
    108108|                     | By default, entities uses the global                  | 
    109109|                     | ``elixir.session``.                                   | 
    110 |                     | This option accepts Objectstore                       | 
    111 |                     | (found in Elixir and ActiveMapper), SessionContext    | 
    112 |                     | (found in SQLAlchemy 0.3) or ScopedSession (found in  | 
    113 |                     | SQLAlchemy 0.4) objects. It also supports ``None``,   | 
    114 |                     | in which case your entity will be mapped using a      | 
     110|                     | This option takes a ``ScopedSession`` object or       | 
     111|                     | ``None``. In the later case your entity will be       | 
     112|                     | mapped using a                                        | 
    115113|                     | non-contextual mapper. This option can also be set    | 
    116114|                     | for all entities of a module by setting the           | 
  • elixir/trunk/tests/test_acts_as_list.py

    r347 r349  
    4040    def test_acts_as_list(self): 
    4141        # create a person 
    42         # you must create and flush this _before_ you attach todo's to it 
     42        # you must create and commit this _before_ you attach todo's to it 
    4343        # because of the way that the plugin is implemented 
    4444        p = Person(name='Jonathan') 
    45         session.flush(); session.clear() 
     45        session.commit(); session.clear() 
    4646 
    4747        # add three todos, in the reverse order that we want them 
     
    5050        p.todos.append(ToDo(subject='Two')) 
    5151        p.todos.append(ToDo(subject='One')) 
    52         session.flush(); session.clear() 
     52        session.commit(); session.clear() 
    5353 
    5454        # move the first item lower 
    5555        p = Person.get(1) 
    5656        p.todos[0].move_lower() 
    57         session.flush(); session.clear() 
     57        session.commit(); session.clear() 
    5858 
    5959        # validate it worked 
     
    6565        # move the last item to the top to put things in correct order 
    6666        p.todos[2].move_to_top() 
    67         session.flush(); session.clear() 
     67        session.commit(); session.clear() 
    6868 
    6969        # validate it worked 
     
    7676        # and move_to_top 
    7777        p.todos[2].move_to_top() 
    78         session.flush(); session.clear() 
     78        session.commit(); session.clear() 
    7979 
    8080        p = Person.get(1) 
     
    8484 
    8585        p.todos[1].move_to_bottom() 
    86         session.flush(); session.clear() 
     86        session.commit(); session.clear() 
    8787 
    8888        p = Person.get(1) 
     
    9595        p.todos[0].move_to(3) 
    9696        p.todos[2].move_to(1) 
    97         session.flush(); session.clear() 
     97        session.commit(); session.clear() 
    9898 
    9999        # validate it worked 
     
    108108        # delete the second todo list item 
    109109        p.todos[1].delete() 
    110         session.flush(); session.clear() 
     110        session.commit(); session.clear() 
    111111 
    112112        # validate that the deletion worked, and sequence numebers 
  • elixir/trunk/tests/test_associable.py

    r347 r349  
    7373        user.orders.append(neworder) 
    7474 
    75         session.flush() 
     75        session.commit() 
    7676        session.clear() 
    7777 
     
    109109        art = Article(title='Hope Soars') 
    110110 
    111         session.flush() 
     111        session.commit() 
    112112        session.clear() 
  • elixir/trunk/tests/test_autoload.py

    r347 r349  
    9898        lisa = Person(name="Lisa", pets=[snowball]) 
    9999 
    100         session.flush() 
     100        session.commit() 
    101101        session.clear() 
    102102 
     
    119119        lisa.father = homer 
    120120 
    121         session.flush() 
     121        session.commit() 
    122122        session.clear() 
    123123 
     
    141141        simpson.persons.extend([bart, lisa]) 
    142142 
    143         session.flush() 
     143        session.commit() 
    144144        session.clear() 
    145145 
     
    158158        homer = Person(name="Homer", appreciate=[barney]) 
    159159 
    160         session.flush() 
     160        session.commit() 
    161161        session.clear() 
    162162 
     
    219219        a1 = A(id=1, name="a1") 
    220220 
    221         session.flush() 
     221        session.commit() 
    222222        session.clear() 
    223223 
  • elixir/trunk/tests/test_class_methods.py

    r347 r349  
    2222        a1 = A(name="a1") 
    2323 
    24         session.flush() 
     24        session.commit() 
    2525        session.clear() 
    2626 
  • elixir/trunk/tests/test_custombase.py

    r347 r349  
    2929        a1 = A(name="a1") 
    3030 
    31         session.flush() 
     31        session.commit() 
    3232        session.clear() 
    3333 
     
    4848        b1 = B(name="b1", data="-b1-") 
    4949 
    50         session.flush() 
     50        session.commit() 
    5151        session.clear() 
    5252 
     
    7171        a1.name = "a1" 
    7272 
    73         session.flush() 
     73        session.commit() 
    7474        session.clear() 
    7575 
  • elixir/trunk/tests/test_dict.py

    r322 r349  
    5858    t2 = Table2() 
    5959    t1.tbl2s.append(t2) 
    60     el.session.flush() 
     60    el.session.commit() 
    6161    t1.from_dict(dict(tbl2s=[])) 
    6262    assert len(t1.tbl2s) == 0 
     
    6666    t2 = Table2() 
    6767    t1.tbl2s.append(t2) 
    68     el.session.flush() 
     68    el.session.commit() 
    6969    t1.from_dict(dict(tbl2s=[{'id':t2.id, 'name':'test4'}])) 
    7070    assert len(t1.tbl2s) == 1 
     
    7575    t2 = Table2() 
    7676    t1.tbl2s.append(t2) 
    77     el.session.flush() 
     77    el.session.commit() 
    7878    try: 
    7979        t1.from_dict(dict(tbl2s=[{'id':t2.id+1}])) 
     
    9595    t2 = Table2(id=50, name='test4') 
    9696    t1.tbl2s.append(t2) 
    97     el.session.flush() 
     97    el.session.commit() 
    9898    assert t1.to_dict(deep={'tbl2s':{}}) == \ 
    9999            {'id':52, 'name':'test3', 'tbl2s':[{'id':50, 'name':'test4'}]} 
     
    102102    t1 = Table1(id=53, name='test2') 
    103103    t1.tbl3 = Table3(id=50, name='wobble') 
    104     el.session.flush() 
     104    el.session.commit() 
    105105    assert t1.to_dict(deep={'tbl3':{}}) == \ 
    106106            {'id':53, 'name':'test2', 'tbl3':{'id':50,'name':'wobble'}} 
  • elixir/trunk/tests/test_encryption.py

    r347 r349  
    5151        jonathan.pets = [winston, nelson] 
    5252 
    53         session.flush(); session.clear() 
     53        session.commit(); session.clear() 
    5454 
    5555        p = Person.get_by(name='Jonathan LaCour') 
     
    6363        p.password = 'N3wpAzzw0rd' 
    6464 
    65         session.flush(); session.clear() 
     65        session.commit(); session.clear() 
    6666 
    6767        p = Person.get_by(name='Jonathan LaCour') 
     
    6969        p.name = 'Jon LaCour' 
    7070 
    71         session.flush(); session.clear() 
     71        session.commit(); session.clear() 
  • elixir/trunk/tests/test_events.py

    r347 r349  
    7272    def test_events(self): 
    7373        d = Document(name='My Document') 
    74         session.flush(); session.clear() 
     74        session.commit(); session.clear() 
    7575 
    7676        d = Document.query.get(1) 
    7777        d.name = 'My Document Updated' 
    78         session.flush(); session.clear() 
     78        session.commit(); session.clear() 
    7979 
    8080        d = Document.query.get(1) 
    8181        d.delete() 
    82         session.flush(); session.clear() 
     82        session.commit(); session.clear() 
    8383 
    8484        assert before_insert_called == 1 
  • elixir/trunk/tests/test_fields.py

    r347 r349  
    2222        bart = Person(firstname="Bart", surname="Simpson") 
    2323 
    24         session.flush() 
     24        session.commit() 
    2525        session.clear() 
    2626 
     
    3939        bart = Person(firstname="Bart", surname="Simpson") 
    4040 
    41         session.flush() 
     41        session.commit() 
    4242        session.clear() 
    4343 
     
    5858        bart = Person(firstname="Bart", surname="Simpson") 
    5959 
    60         session.flush() 
     60        session.commit() 
    6161        session.clear() 
    6262 
  • elixir/trunk/tests/test_inherit.py

    r347 r349  
    4646    E(data1='e1') 
    4747 
    48     session.flush() 
     48    session.commit() 
    4949    session.clear() 
    5050 
     
    8282        b1 = B(name="b1") # no value for other 
    8383 
    84         session.flush() 
     84        session.commit() 
    8585 
    8686    def test_delete_parent(self): 
     
    9696        b1 = B(name='b1') 
    9797 
    98         session.flush() 
     98        session.commit() 
    9999 
    100100        A.table.delete().execute() 
  • elixir/trunk/tests/test_m2m.py

    r347 r349  
    2727        b1 = B(name='b1', as_=[A(name='a1')]) 
    2828 
    29         session.flush() 
     29        session.commit() 
    3030        session.clear() 
    3131 
     
    5151        b1 = B(name='b1', as_=[A(name='a1')]) 
    5252 
    53         session.flush() 
     53        session.commit() 
    5454        session.clear() 
    5555 
     
    8383        b1 = B(name='b1', as_=[A(key1=10, key2='a1')]) 
    8484 
    85         session.flush() 
     85        session.commit() 
    8686        session.clear() 
    8787 
     
    108108                          rel2=[B(name='b3'), B(name='b4'), b1]) 
    109109 
    110         session.flush() 
     110        session.commit() 
    111111        session.clear() 
    112112 
     
    131131        barney.friends.append(homer) 
    132132 
    133         session.flush() 
     133        session.commit() 
    134134        session.clear() 
    135135 
     
    156156        a3 = A(name='a3') 
    157157 
    158         session.flush() 
     158        session.commit() 
    159159        session.clear() 
    160160 
  • elixir/trunk/tests/test_m2o.py

    r347 r349  
    2424        b1 = B(name='b1', a=A(name='a1')) 
    2525 
    26         session.flush() 
     26        session.commit() 
    2727        session.clear() 
    2828 
     
    4545        b1 = B(a=A(testx=1)) 
    4646 
    47         session.flush() 
     47        session.commit() 
    4848        session.clear() 
    4949 
     
    6969 
    7070        a = A() 
    71         session.flush() 
     71        session.commit() 
    7272        b = B(a=a) 
    73         session.flush() 
     73        session.commit() 
    7474        session.clear() 
    7575 
     
    166166        b2 = B(name="b2", a_rel1=a1, a_rel2=a1) 
    167167 
    168         session.flush() 
     168        session.commit() 
    169169        session.clear() 
    170170 
     
    190190        rudolph = Animal(name="Rudolph", owner=santa) 
    191191 
    192         session.flush() 
     192        session.commit() 
    193193        session.clear() 
    194194 
  • elixir/trunk/tests/test_o2m.py

    r347 r349  
    2626        b1 = B(name='b1', a=a1) 
    2727 
    28         # does it work before a flush? (does the backref work?) 
     28        # does it work before a commit? (does the backref work?) 
    2929        assert b1 in a1.bs 
    3030 
    31         session.flush() 
     31        session.commit() 
    3232        session.clear() 
    3333 
     
    5555        lisa.father = homer 
    5656 
    57         session.flush() 
     57        session.commit() 
    5858        session.clear() 
    5959 
     
    9999        node.children.append(TreeNode(name='node3')) 
    100100 
    101         session.flush() 
     101        session.commit() 
    102102        session.clear() 
    103103 
     
    119119        rudolph = Animal(name="Rudolph", owner=santa) 
    120120 
    121         session.flush() 
     121        session.commit() 
    122122        session.clear() 
    123123 
  • elixir/trunk/tests/test_o2o.py

    r271 r349  
    2121        b1 = B(name='b1', a=A(name='a1')) 
    2222 
    23         session.flush() 
     23        session.commit() 
    2424        session.clear() 
    2525 
  • elixir/trunk/tests/test_options.py

    r347 r349  
    44 
    55from sqlalchemy import UniqueConstraint, create_engine, Column 
    6 from sqlalchemy.orm import create_session 
     6from sqlalchemy.orm import scoped_session, sessionmaker 
    77from sqlalchemy.exceptions import SQLError, ConcurrentModificationError 
    88from elixir import * 
     
    2626 
    2727        p1 = Person(name='Daniel') 
    28         session.flush() 
     28        session.commit() 
    2929        session.clear() 
    3030 
    3131        person = Person.query.first() 
    3232        person.name = 'Gaetan' 
    33         session.flush() 
     33        session.commit() 
     34        assert person.row_version == 2 
    3435        session.clear() 
    35         assert person.row_version == 2 
    3636 
    3737        person = Person.query.first() 
    3838        person.name = 'Jonathan' 
    39         session.flush() 
     39        session.commit() 
     40        assert person.row_version == 3 
    4041        session.clear() 
    41         assert person.row_version == 3 
    4242 
    4343        # check that a concurrent modification raises exception 
    4444        p1 = Person.query.first() 
    45         s2 = create_session() 
     45        s2 = sessionmaker()() 
    4646        p2 = s2.query(Person).first() 
    4747        p1.name = "Daniel" 
    4848        p2.name = "Gaetan" 
    49         s2.flush() 
    50         try: 
    51             session.flush() 
     49        s2.commit() 
     50        try: 
     51            session.commit() 
    5252            assert False 
    5353        except ConcurrentModificationError: 
     
    113113        cleanup_all() 
    114114 
    115     def test_session_context(self): 
    116         try: 
    117             from sqlalchemy.ext.sessioncontext import SessionContext 
    118         except ImportError: 
    119             # we are probably on SQLAlchemy 0.5, no need to test this. 
    120             return 
    121  
    122         engine = create_engine('sqlite:///') 
    123  
    124         ctx = SessionContext(lambda: create_session(bind=engine)) 
    125  
    126         class Person(Entity): 
    127             using_options(session=ctx) 
    128             firstname = Field(String(30)) 
    129             surname = Field(String(30)) 
    130  
    131         setup_all() 
    132         create_all(engine) 
    133  
    134         homer = Person(firstname="Homer", surname='Simpson') 
    135         bart = Person(firstname="Bart", surname='Simpson') 
    136         ctx.current.flush() 
    137  
    138         assert Person.query.session is ctx.current 
    139         assert Person.query.filter_by(firstname='Homer').one() is homer 
    140  
    141115    def test_manual_session(self): 
    142116        engine = create_engine('sqlite:///') 
     
    150124        create_all(engine) 
    151125 
    152         session = create_session(bind=engine) 
     126        Session = sessionmaker(bind=engine) 
     127        session = Session() 
    153128 
    154129        homer = Person(firstname="Homer", surname='Simpson') 
     
    157132        session.save(homer) 
    158133        session.save(bart) 
    159         session.flush() 
     134        session.commit() 
    160135 
    161136        bart.delete() 
    162         session.flush() 
     137        session.commit() 
    163138 
    164139        assert session.query(Person).filter_by(firstname='Homer').one() is homer 
    165140        assert session.query(Person).count() == 1 
    166141 
    167     def test_activemapper_session(self): 
    168         try: 
    169             from sqlalchemy.orm import scoped_session, sessionmaker 
    170             #TODO: this test, as-is has no sense on SA 0.4 since activemapper 
    171             # session uses scoped_session, but we need to provide a new 
    172             # test for that. 
    173             return 
    174         except ImportError: 
    175             pass 
    176  
    177         try: 
    178             from sqlalchemy.ext import activemapper 
    179         except ImportError: 
    180             return 
    181  
     142    def test_scoped_session(self): 
    182143        engine = create_engine('sqlite:///') 
    183  
    184         store = activemapper.Objectstore(lambda: create_session(bind=engine)) 
    185  
    186         class Person(Entity): 
    187             using_options(session=store) 
     144        Session = scoped_session(sessionmaker(bind=engine)) 
     145 
     146        class Person(Entity): 
     147            using_options(session=Session) 
    188148            firstname = Field(String(30)) 
    189149            surname = Field(String(30)) 
     
    194154        homer = Person(firstname="Homer", surname='Simpson') 
    195155        bart = Person(firstname="Bart", surname='Simpson') 
    196  
    197         store.flush() 
    198  
    199         assert Person.query.session is store.context.current 
    200         assert Person.query.filter_by(firstname='Homer').one() is homer 
    201  
    202     def test_scoped_session(self): 
    203         try: 
    204             from sqlalchemy.orm import scoped_session, sessionmaker 
    205         except ImportError: 
    206             print "Not on version 0.4 or later of sqlalchemy" 
    207             return 
    208  
    209         engine = create_engine('sqlite:///') 
    210  
    211         Session = scoped_session(sessionmaker(bind=engine)) 
    212  
    213         class Person(Entity): 
    214             using_options(session=Session) 
    215             firstname = Field(String(30)) 
    216             surname = Field(String(30)) 
    217  
    218         setup_all() 
    219         create_all(engine) 
    220  
    221         homer = Person(firstname="Homer", surname='Simpson') 
    222         bart = Person(firstname="Bart", surname='Simpson') 
    223         Session.flush() 
     156        Session.commit() 
    224157 
    225158        assert Person.query.session is Session() 
     
    227160 
    228161    def test_global_scoped_session(self): 
    229         try: 
    230             from sqlalchemy.orm import scoped_session, sessionmaker 
    231         except ImportError: 
    232             print "Not on version 0.4 or later of sqlalchemy" 
    233             return 
    234  
    235162        global __session__ 
    236163 
    237164        engine = create_engine('sqlite:///') 
    238  
    239165        session = scoped_session(sessionmaker(bind=engine)) 
    240166        __session__ = session 
     
    249175        homer = Person(firstname="Homer", surname='Simpson') 
    250176        bart = Person(firstname="Bart", surname='Simpson') 
    251         session.flush() 
     177        session.commit() 
    252178 
    253179        assert Person.query.session is session() 
     
    276202        bart = Person(firstname="Bart", surname='Simpson') 
    277203 
    278         session.flush() 
     204        session.commit() 
    279205 
    280206        homer2 = Person(firstname="Homer", surname='Simpson') 
     
    282208        raised = False 
    283209        try: 
    284             session.flush() 
     210            session.commit() 
    285211        except SQLError: 
    286212            raised = True 
     
    304230        hobbit = Book(title="The Hobbit", author=tolkien) 
    305231 
    306         session.flush() 
     232        session.commit() 
    307233 
    308234        tolkien2 = Author(name="Tolkien") 
    309235        hobbit2 = Book(title="The Hobbit", author=tolkien2) 
    310236 
    311         session.flush() 
     237        session.commit() 
    312238 
    313239        hobbit3 = Book(title="The Hobbit", author=tolkien) 
     
    315241        raised = False 
    316242        try: 
    317             session.flush() 
     243            session.commit() 
    318244        except SQLError: 
    319245            raised = True 
  • elixir/trunk/tests/test_order_by.py

    r347 r349  
    5151        Record(title=title, artist=artist, year=year, genres=[genre]) 
    5252 
    53     session.flush() 
     53    session.commit() 
    5454    session.clear() 
    5555 
  • elixir/trunk/tests/test_packages.py

    r347 r349  
    3131        b1 = B(name='b1', as_=[A(name='a1')]) 
    3232 
    33         session.flush() 
     33        session.commit() 
    3434        session.clear() 
    3535 
  • elixir/trunk/tests/test_properties.py

    r347 r349  
    2828        t2 = Tag(score1=10.0, score2=2.0) 
    2929 
    30         session.flush() 
     30        session.commit() 
    3131        session.clear() 
    3232 
     
    4646        t2 = Tag(score1=10.0, score2=2.0) 
    4747 
    48         session.flush() 
     48        session.commit() 
    4949        session.clear() 
    5050 
     
    8888        c1 = Category(name='dummy', users=[u1, u2]) 
    8989 
    90         session.flush() 
     90        session.commit() 
    9191        session.clear() 
    9292 
     
    111111        t1 = Tag(score1=10.0, score2=2.0) 
    112112 
    113         session.flush() 
     113        session.commit() 
    114114        session.clear() 
    115115 
     
    125125 
    126126        A(name='foo') 
    127         session.flush() 
     127        session.commit() 
    128128 
    129129    def test_synonym(self): 
     
    155155        assert Person.email_values == ['x@y.com', 'x@z.com'] 
    156156 
    157         session.flush() 
     157        session.commit() 
    158158        session.clear() 
    159159 
     
    184184        ) 
    185185 
    186         session.flush(); session.clear() 
     186        session.commit(); session.clear() 
    187187 
    188188        p = Person.get_by(name='Alexandre da Silva') 
     
    193193 
    194194        u.email_address = 'new@z.com' 
    195         session.flush(); session.clear() 
     195        session.commit(); session.clear() 
    196196 
    197197        p = Person.get_by(name='Johann Felipe Voigt') 
     
    208208        a1 = A(name='a1') 
    209209 
    210         session.flush(); session.clear() 
     210        session.commit(); session.clear() 
    211211 
    212212        a = A.query.one() 
  • elixir/trunk/tests/test_sa_integration.py

    r347 r349  
    4141 
    4242        session.save(b1) 
    43         session.flush() 
     43        session.commit() 
    4444        session.clear() 
    4545 
     
    7171# 
    7272#        session.save(b1) 
    73 #        session.flush() 
     73#        session.commit() 
    7474#        session.clear() 
    7575# 
  • elixir/trunk/tests/test_versioning.py

    r347 r349  
    2828        autoupd = Field(Integer, default=nextOne, onupdate=nextOne) 
    2929        director = ManyToOne('Director', inverse='movies') 
    30         actors = ManyToMany('Actor', inverse='movies', tablename='movie_casting') 
     30        actors = ManyToMany('Actor', inverse='movies', 
     31                            tablename='movie_casting') 
    3132        using_options(tablename='movies') 
    3233        acts_as_versioned(ignore=['ignoreme', 'autoupd']) 
     
    3536    class Actor(Entity): 
    3637        name = Field(String(60)) 
    37         movies = ManyToMany('Movie', inverse='actors', tablename='movie_casting') 
     38        movies = ManyToMany('Movie', inverse='actors', 
     39                            tablename='movie_casting') 
    3840        using_options(tablename='actors') 
    3941 
     
    5254    def teardown(self): 
    5355        drop_all() 
    54         session.clear() 
     56        session.close() 
    5557 
    5658    def test_versioning(self): 
    5759        gilliam = Director(name='Terry Gilliam') 
    58         monkeys = Movie(id=1, title='12 Monkeys', description='draft description', director=gilliam) 
     60        monkeys = Movie(id=1, title='12 Monkeys', 
     61                        description='draft description', director=gilliam) 
    5962        bruce = Actor(name='Bruce Willis', movies=[monkeys]) 
    60         session.flush(); session.clear() 
     63        session.commit(); session.clear() 
    6164 
    6265        time.sleep(1) 
     
    7073        assert movie.autoupd == 2, movie.autoupd 
    7174        movie.description = 'description two' 
    72         session.flush(); session.clear() 
     75        session.commit(); session.clear() 
    7376 
    7477        time.sleep(1) 
     
    7881        movie = Movie.get_by(title='12 Monkeys') 
    7982        movie.description = 'description three' 
    80         session.flush(); session.clear() 
     83        session.commit(); session.clear() 
    8184 
    8285        # Edit the ignored field, this shouldn't change the version 
    8386        monkeys = Movie.get_by(title='12 Monkeys') 
    8487        monkeys.ignoreme = 1 
    85         session.flush(); session.clear() 
     88        session.commit(); session.clear() 
    8689 
    8790        time.sleep(1) 
     
    107110        assert middle_version.autoupd > oldest_version.autoupd 
    108111 
    109         assert latest_version.version == 3, 'version=%i' % latest_version.version 
     112        assert latest_version.version == 3, \ 
     113               'version=%i' % latest_version.version 
    110114        assert latest_version.description == 'description three' 
    111115        assert latest_version.ignoreme == 1 
     
    113117 
    114118        differences = latest_version.compare_with(oldest_version) 
    115         assert differences['description'] == ('description three', 'draft description') 
     119        assert differences['description'] == \ 
     120               ('description three', 'draft description') 
    116121 
    117122        assert len(movie.versions) == 3 
     
    123128 
    124129        movie.revert_to(2) 
    125         session.flush(); session.clear() 
     130        session.commit(); session.clear() 
    126131 
    127132        movie = Movie.get_by(title='12 Monkeys') 
     
    130135 
    131136        movie.description = "description 3" 
    132         session.flush(); session.clear(); 
     137        session.commit(); session.clear() 
    133138 
    134139        movie = Movie.get_by(title='12 Monkeys') 
    135140        movie.description = "description 4" 
    136         session.flush(); session.clear(); 
     141        session.commit(); session.clear() 
    137142 
    138143        movie = Movie.get_by(title='12 Monkeys') 
     
    140145        movie.revert_to(movie.versions[-2]) 
    141146        movie.description = "description 5" 
    142         session.flush(); session.clear(); 
     147        session.commit(); session.clear() 
    143148 
    144149        movie = Movie.get_by(title='12 Monkeys') 
     
    146151        assert movie.versions[-2].description == "description 3" 
    147152 
    148         # Updates to the history table must be inside the transaction 
    149         session.begin() 
    150         movie = Movie(id=3, title='Foo', description='1') 
    151         session.commit(); 
    152  
    153         session.begin() 
    154         movie.description = '2' 
    155         session.flush() 
    156         session.rollback() 
    157         session.clear() 
    158  
    159         session.begin() 
    160         movie = Movie.get_by(title='Foo') 
    161         movie.description = '3' 
    162         session.commit() 
    163