Thank you, the event worked like a charm :-) Though I think that I don't 
need the commit events, because the application terminates anyway.

I modified your approach to gather which objects were flushed so that in 
the end I can give the user more precise information:

        dbsession.info["new"] = set()                                      
                         
        dbsession.info["dirty"] = set()                                    
                         
        dbsession.info["deleted"] = set()                                  
                         
                                                                            
                        
        def update_session_info(session):                                  
                         
            new = session.info["new"]                                      
                         
            new |= set(session.new)                                        
                         
            dirty = session.info["dirty"]                                  
                         
            dirty |= set(session.dirty)                                    
                         
            deleted = session.info["deleted"]                              
                         
            deleted |= set(session.deleted)                                
                         
            return new, dirty, deleted                                      
                        
                                                                            
                        
        @event.listens_for(dbsession, "before_flush")                      
                         
        def on_before_flush(session, _, _):                                
     
            update_session_info(session)

        ...
        code.interact(local=locals())                                      
                         
        ...
           
        new, dirty, deleted = update_session_info(dbsession)                
                        
        if new or dirty or deleted:                                        
                         
            if new:                                                        
                         
                print("The following objects were created: ", new)          
                         
            if dirty:                                                      
                         
                print("The following objects were modified: ", dirty)      
                            
            if deleted:                                                    
                         
                print("The following objects were deleted: ", deleted)      
                             
            yesno = input("Would you like to commit this transaction? [y/N] 
")                     
            if yesno == "y":                                                
                        
                print("Committing transaction...")                          
                   
            else:                                                          
                         
                print("Rolling back transaction...")                        
                   
                raise _SessionRollbackException()                          
                         

        # ...this is where the context closes and the transaction commits 
and the dbsession ends.

Cheers,
Jens



On Saturday, November 18, 2017 at 12:03:05 AM UTC+10, Simon King wrote:
>
> OK, I think tracking session events seems reasonable. You could do 
> something like this (completely untested): 
>
> from sqalchemy.event import event 
>
> @event.listens_for(YourSessionOrSessionMaker, 'before_flush') 
> def on_before_flush(session, flush_context, instances): 
>     session.info['flushed'] = True 
>
>
> # You'd probably also want to reset the 'flushed' flag 
> # after a commit or rollback 
> @event.listens_for(YourSessionOrSessionMaker, 'after_commit') 
> @event.listens_for(YourSessionOrSessionMaker, 'after_rollback') 
> def on_session_reset(session): 
>     session.info['flushed'] = False 
>
>
> # when user exits interactive session: 
> modified = ( 
>     session.info.get('flushed', False) 
>     or session.deleted 
>     or session.new 
>     or session.dirty 
> ) 
> if modified: 
>     raw_input('do you want to commit?') 
>
>
> ...but note that if you ever execute raw SQL (ie. 
> session.execute('UPDATE x WHERE y')), that will not be noticed by 
> those events. 
>
> Hope that helps, 
>
> Simon 
>

-- 
SQLAlchemy - 
The Python SQL Toolkit and Object Relational Mapper

http://www.sqlalchemy.org/

To post example code, please provide an MCVE: Minimal, Complete, and Verifiable 
Example.  See  http://stackoverflow.com/help/mcve for a full description.
--- 
You received this message because you are subscribed to the Google Groups 
"sqlalchemy" group.
To unsubscribe from this group and stop receiving emails from it, send an email 
to sqlalchemy+unsubscr...@googlegroups.com.
To post to this group, send email to sqlalchemy@googlegroups.com.
Visit this group at https://groups.google.com/group/sqlalchemy.
For more options, visit https://groups.google.com/d/optout.

Reply via email to