logging = __import__('logging')
default_enabled = False
-def default_logging():
+def default_logging(name):
global default_enabled
+ if logging.getLogger(name).getEffectiveLevel() < logging.WARN:
+ default_enabled=True
if not default_enabled:
default_enabled = True
rootlogger = logging.getLogger('sqlalchemy')
return logger.isEnabledFor(logging.INFO)
class echo_property(object):
- level_map={logging.DEBUG : "debug", logging.NOTSET : False}
+ level_map={logging.DEBUG : "debug", logging.INFO:True}
def __get__(self, instance, owner):
level = logging.getLogger(_get_instance_name(instance)).getEffectiveLevel()
- return echo_property.level_map.get(level, True)
+ return echo_property.level_map.get(level, False)
def __set__(self, instance, value):
if value:
- default_logging()
+ default_logging(_get_instance_name(instance))
logging.getLogger(_get_instance_name(instance)).setLevel(value == 'debug' and logging.DEBUG or logging.INFO)
else:
logging.getLogger(_get_instance_name(instance)).setLevel(logging.NOTSET)
objects in this Session."""
for instance in self:
self._unattach(instance)
+ echo = self.uow.echo
self.uow = unitofwork.UnitOfWork()
+ self.uow.echo = echo
def mapper(self, class_, entity_name=None):
"""given an Class, returns the primary Mapper responsible for persisting it"""
'objects' is a list or tuple of objects specifically to be flushed; if None, all
new and modified objects are flushed."""
- self.uow.flush(self, objects, echo=self.echo_uow)
+ self.uow.flush(self, objects)
def get(self, class_, ident, **kwargs):
"""return an instance of the object based on the given identifier, or None if not found.
def locate_dirty(self):
return util.Set([x for x in self.identity_map.values() if x not in self.deleted and attribute_manager.is_modified(x)])
- def flush(self, session, objects=None, echo=False):
+ def flush(self, session, objects=None):
# this context will track all the objects we want to save/update/delete,
# and organize a hierarchical dependency structure. it also handles
# communication with the mappers and relationships to fire off SQL
trans = session.create_transaction(autoflush=False)
flush_context.transaction = trans
try:
- flush_context.execute(echo=echo)
+ flush_context.execute()
except:
trans.rollback()
raise
self.__modified = False
self.__is_executing = False
self.logger = logging.instance_logger(self)
+ self.echo = uow.echo
+
+ echo = logging.echo_property()
def register_object(self, obj, isdelete = False, listonly = False, postupdate=False, post_update_cols=None, **kwargs):
"""adds an object to this UOWTransaction to be updated in the database.
task.dependencies.add(up)
self._mark_modified()
- def execute(self, echo=False):
+ def execute(self):
# insure that we have a UOWTask for every mapper that will be involved
# in the topological sort
[self.get_task_by_mapper(m) for m in self._get_noninheriting_mappers()]
head = self._sort_dependencies()
self.__modified = False
- if echo:
+ if self.echo:
if head is None:
self.logger.info("Task dump: None")
else:
head.execute(self)
#if self.__modified and head is not None:
# raise "Assertion failed ! new pre-execute dependency step should eliminate post-execute changes (except post_update stuff)."
- if echo:
- self.logger.info("Execute Complete")
+ self.logger.info("Execute Complete")
def post_exec(self):
"""after an execute/flush is completed, all of the objects and lists that have