def main(): '''Read sys.argv for configuration, and perform the imports.''' if len(sys.argv) != 3: print "Usage: %s pootle.prefs users.prefs" % ( sys.argv[0]) return oldprefsfile = sys.argv[1] parsed_oldprefs = prefs.PrefsParser(oldprefsfile) usersfile = sys.argv[2] parsed_users = prefs.PrefsParser(usersfile) try: try: transaction.enter_transaction_management() transaction.managed(True) set_up_db_then_import_languages_then_users(parsed_oldprefs, parsed_users) except: if transaction.is_dirty(): transaction.rollback() if transaction.is_managed(): transaction.leave_transaction_management() raise finally: if transaction.is_managed(): if transaction.is_dirty(): transaction.commit() if transaction.is_managed(): transaction.leave_transaction_management()
def afterTest(self, test): """ Clean up any changes to the test database. """ # Restore transaction support on tests from django.conf import settings from django.db import connections, transaction from django.test.utils import setup_test_environment, teardown_test_environment use_transaction_isolation = self._should_use_transaction_isolation( test, settings) if self._should_rebuild_schema(test): for connection in connections.all(): connection.creation.destroy_test_db( self.old_db, verbosity=self.verbosity) teardown_test_environment() setup_test_environment() for connection in connections.all(): connection.creation.create_test_db(verbosity=self.verbosity) self.restore_transaction_support(transaction) transaction.commit() if transaction.is_managed(): transaction.leave_transaction_management() # If connection is not closed Postgres can go wild with # character encodings. for connection in connections.all(): connection.close() logger.debug("Running syncdb") self._num_syncdb_calls += 1 self._loaded_test_fixtures = [] return if use_transaction_isolation: self.restore_transaction_support(transaction) logger.debug("Rolling back") transaction.rollback() if transaction.is_managed(): transaction.leave_transaction_management() # If connection is not closed Postgres can go wild with # character encodings. for connection in connections.all(): connection.close() else: # Have to clear the db even if we're using django because django # doesn't properly flush the database after a test. It relies on # flushing before a test, so we want to avoid the case where a django # test doesn't flush and then a normal test runs, because it will # expect the db to already be flushed self._flush_db() self._loaded_test_fixtures = [] self.call_plugins_method('afterRollback', settings)
def test_can_use_twice(): """Can use same xact object as context manager twice.""" cm = xact.xact() assert not transaction.is_managed() for i in range(2): with cm: assert transaction.is_managed() assert not transaction.is_managed()
def test_django_db_transaction_managed(self): """ Check that django.db.transaction.managed is not affected by monkey-patching """ from django.db import transaction self.assertFalse(transaction.is_managed()) transaction.enter_transaction_management() try: transaction.managed() self.assertTrue(transaction.is_managed()) finally: transaction.leave_transaction_management()
def process_response(self, request, response): """Commit or abort the transaction after processing the response. On successful completion of the request, the transaction will be committed. As an exception to this, if the L{STORM_COMMIT_SAFE_METHODS} setting is False, and the request used either of the GET and HEAD methods, the transaction will be aborted. """ from django.db import transaction as django_transaction # If process_exception() has been called, then we'll no longer # be in managed transaction mode. if django_transaction.is_managed(): if self.commit_safe_methods or (request.method not in ['HEAD', 'GET']): try: transaction.commit() except Exception: transaction.abort() raise else: transaction.abort() django_transaction.set_clean() django_transaction.leave_transaction_management() return response
def is_managed(using=None): if django.VERSION[:2] < (1, 6): return transaction.is_managed(using=using) elif django.VERSION[:2] >= (1, 6): # See https://code.djangoproject.com/ticket/21004 return not transaction.get_autocommit(using=using) return False
def associate(self, handle, entry_id): """ Associate an unassociated handle with an id. It is illegal to associate a handle with more than one entry. It is also illegal to have two handles point to the same entry. :param handle: The handle. :type handle: str :param entry_id: The entry id. :type entry_id: int """ if not transaction.is_managed(): raise Exception("transactions must be managed") if self.id(handle) is not None: raise ValueError("handle {0} already associated".format(handle)) if self.entry_id_to_handle.get(entry_id, None) is not None: raise ValueError("id {0} already associated".format(entry_id)) handle_obj = Handle.objects.select_for_update().get( id=self.handle_to_handle_obj_id[handle]) handle_obj.entry_id = entry_id handle_obj.save() self.handle_to_entry_id[handle] = entry_id self.entry_id_to_handle[entry_id] = handle
def id(self, handle): """ Return the id associated with a handle. :param handle: The handle. :type handle: str :returns: The id. :rtype: int or None """ if not transaction.is_managed(): raise Exception("transactions must be managed") # If it is there and not none, it can't have changed, so we # don't have to read the database. if handle in self.handle_to_entry_id and \ self.handle_to_entry_id[handle] is not None: return self.handle_to_entry_id[handle] # Otherwise, check whether it has been associated. try: handle_obj = Handle.objects.get(session=self.session_key, handle=handle) except Handle.DoesNotExist: raise ValueError("handle {0} does not exist".format(handle)) entry_id = handle_obj.entry.id if handle_obj.entry is not None else None self.handle_to_entry_id[handle] = entry_id self.handle_to_handle_obj_id[handle] = handle_obj.id if entry_id is not None: self.entry_id_to_handle[entry_id] = handle return entry_id
def apply_async(cls, *args, **kwargs): # Delay the task unless the client requested otherwise or transactions # aren't being managed (i.e. the signal handlers won't send the task). # A rather roundabout way of allowing control of transaction behaviour from source. I'm sure there's a better way. after_transaction = True if len(args) > 1: if isinstance(args[1], dict): after_transaction = args[1].pop('after_transaction', True) if 'after_transaction' in kwargs: after_transaction = kwargs.pop('after_transaction') if transaction.is_managed() and after_transaction: if not transaction.is_dirty(): # Always mark the transaction as dirty # because we push task in queue that must be fired or discarded if 'using' in kwargs: transaction.set_dirty(using=kwargs['using']) else: transaction.set_dirty() _get_task_queue().append((cls, args, kwargs)) else: apply_async_orig = cls.original_apply_async if current_app.conf.CELERY_ALWAYS_EAGER: apply_async_orig = transaction.autocommit()(apply_async_orig) return apply_async_orig(*args, **kwargs)
def _single_commit_on_success(db_name): if transaction.is_managed(db_name): _logger.error( '_single_commit_on_success: raise DuplicateTransactionError') raise DuplicateTransactionError, db_name return transaction.commit_on_success(using=db_name)
def __enter__(self): if transaction.is_managed(self.using): # We're already in a transaction; create a savepoint. self.sid = transaction.savepoint(self.using) else: transaction.enter_transaction_management(using=self.using) transaction.managed(True, using=self.using)
def add_jobs(self, jobs, command): """Add a job, and any others which are required in order to reach its prerequisite state""" # Important: the Job must not be committed until all # its dependencies and locks are in. assert transaction.is_managed() for job in jobs: for dependency in self._dep_cache.get(job).all(): if not dependency.satisfied(): log.info("add_jobs: setting required dependency %s %s" % (dependency.stateful_object, dependency.preferred_state)) self._set_state(dependency.get_stateful_object(), dependency.preferred_state, command) log.info("add_jobs: done checking dependencies") locks = self._create_locks(job) job.locks_json = json.dumps([l.to_dict() for l in locks]) self._create_dependencies(job, locks) with transaction.commit_on_success(): job.save() log.info("add_jobs: created Job %s (%s)" % (job.pk, job.description())) for l in locks: self._lock_cache.add(l) command.jobs.add(job) self._job_collection.add_command(command, jobs)
def in_transaction(test_ignore=True): result = transaction.is_managed() if test_ignore: # Ignore when running inside a Django test case, which uses # transactions. result = result and not hasattr(mail, "outbox") return result
def new_func(*args, **kwargs): if settings.BROKER_TRANSPORT == "django" or not transaction.is_managed(): # если используется db транспорт или мы не под транзакцией, то нам это не нужно. # все работает по старому return old_func(*args, **kwargs) else: store.queue.append(curry(old_func, *args, **kwargs)) #@UndefinedVariable
def _publish_article(slug, article): article.set_spam_status('clean') from django.db import transaction if transaction.is_managed(): transaction.commit() article.ping_external_urls() caching.invalidate_by_article(slug, article.topic_id)
def _acquire_entry_lock(entry, user): """ Acquire the lock. The caller must make sure that there is no lock yet on the entry before calling this function. :param entry: The entry for which to acquire the lock. :type entry: :class:`.Entry` :param user: The user who is acquiring the lock. :type user: The value of :attr:`settings.AUTH_USER_MODEL` determines the class. :returns: The lock if the lock was acquired, or ``None`` if not. :rtype: :class:`.EntryLock` """ if not transaction.is_managed(): raise Exception("_acquire_entry_lock requires transactions to be " "managed") lock = EntryLock() lock.entry = entry now = util.utcnow() lock.owner = user lock.datetime = now lock.save() _report(lock, "acquired") return lock
def results_iter(self): """ Returns an iterator over the results from executing this query. """ resolve_columns = hasattr(self, 'resolve_columns') fields = None has_aggregate_select = bool(self.query.aggregate_select) # Set transaction dirty if we're using SELECT FOR UPDATE to ensure # a subsequent commit/rollback is executed, so any database locks # are released. if self.query.select_for_update and transaction.is_managed(self.using): transaction.set_dirty(self.using) for rows in self.execute_sql(MULTI): for row in rows: if resolve_columns: if fields is None: # We only set this up here because # related_select_cols isn't populated until # execute_sql() has been called. # We also include types of fields of related models that # will be included via select_related() for the benefit # of MySQL/MySQLdb when boolean fields are involved # (#15040). # This code duplicates the logic for the order of fields # found in get_columns(). It would be nice to clean this up. if self.query.select: fields = [f.field for f in self.query.select] else: fields = self.query.model._meta.fields fields = fields + [ f.field for f in self.query.related_select_cols ] # If the field was deferred, exclude it from being passed # into `resolve_columns` because it wasn't selected. only_load = self.deferred_to_columns() if only_load: db_table = self.query.model._meta.db_table fields = [ f for f in fields if db_table in only_load and f.column in only_load[db_table] ] row = self.resolve_columns(row, fields) if has_aggregate_select: aggregate_start = len(self.query.extra_select) + len( self.query.select) aggregate_end = aggregate_start + len( self.query.aggregate_select) row = tuple(row[:aggregate_start]) + tuple([ self.query.resolve_aggregate(value, aggregate, self.connection) for (alias, aggregate), value in zip( self.query.aggregate_select.items(), row[aggregate_start:aggregate_end]) ]) + tuple(row[aggregate_end:]) yield row
def process_response(self, request, response): """Commit or abort the transaction after processing the response. On successful completion of the request, the transaction will be committed. As an exception to this, if the L{STORM_COMMIT_SAFE_METHODS} setting is False, and the request used either of the GET and HEAD methods, the transaction will be aborted. """ from django.db import transaction as django_transaction # If process_exception() has been called, then we'll no longer # be in managed transaction mode. if django_transaction.is_managed(): if self.commit_safe_methods or ( request.method not in ['HEAD', 'GET']): try: transaction.commit() except Exception: transaction.abort() raise else: transaction.abort() django_transaction.set_clean() django_transaction.leave_transaction_management() return response
def process_response(self, request, response): """Commits and leaves transaction management.""" if transaction.is_managed(using=self.get_tenant(request)): if transaction.is_dirty(using=self.get_tenant(request)): transaction.commit(using=self.get_tenant(request)) transaction.leave_transaction_management(using=self.get_tenant(request)) return response
def test_savepoint_rollback(self): """Tests rollbacks of savepoints""" from django.db import transaction from testapp.models import Genre, Publisher from johnny import cache if not connection.features.uses_savepoints: return self.failUnless(transaction.is_managed() == False) self.failUnless(transaction.is_dirty() == False) connection.queries = [] cache.local.clear() transaction.enter_transaction_management() transaction.managed() g = Genre.objects.get(pk=1) start_title = g.title g.title = "Adventures in Savepoint World" g.save() g = Genre.objects.get(pk=1) self.failUnless(g.title == "Adventures in Savepoint World") sid = transaction.savepoint() g.title = "In the Void" g.save() g = Genre.objects.get(pk=1) self.failUnless(g.title == "In the Void") transaction.savepoint_rollback(sid) g = Genre.objects.get(pk=1) self.failUnless(g.title == "Adventures in Savepoint World") transaction.rollback() g = Genre.objects.get(pk=1) self.failUnless(g.title == start_title) transaction.managed(False) transaction.leave_transaction_management()
def transaction_rollback(using): """ DB(using)をロールバックし、トランザクション区間を終了する。 """ if ( transaction.is_managed(using=using) ): transaction.rollback(using=using) transaction.leave_transaction_management(using=using)
def process_exception(self, request, exception): """Rolls back the database and leaves transaction management.""" if transaction.is_managed(): if transaction.is_dirty(): transaction.rollback() transaction.leave_transaction_management()
def truncate_queryset(qs): """ Deletes all records matched by queryset using DELETE from table WHERE <condition> query without fetching PK values for all items in original queryset unlike django's standard QuerySet.delete(). See https://code.djangoproject.com/ticket/9519. """ delete_query = qs.query.clone(DeleteQuery) # transaction management code is copied from QuerySet.update if not transaction.is_managed(using=qs.db): transaction.enter_transaction_management(using=qs.db) forced_managed = True else: forced_managed = False try: delete_query.get_compiler(qs.db).execute_sql(None) if forced_managed: transaction.commit(using=qs.db) else: transaction.commit_unless_managed(using=qs.db) finally: if forced_managed: transaction.leave_transaction_management(using=qs.db)
def apply_async(self, *args, **kwargs): # Delay the task unless the client requested otherwise or transactions # aren't being managed (i.e. the signal handlers won't send the task). celery_eager = _get_celery_settings('CELERY_ALWAYS_EAGER') # New setting to run eager task post transaction # defaults to `not CELERY_ALWAYS_EAGER` eager_transaction = _get_celery_settings('CELERY_EAGER_TRANSACTION', not celery_eager) if django.VERSION < (1, 6): if transaction.is_managed() and eager_transaction: if not transaction.is_dirty(): # Always mark the transaction as dirty # because we push task in queue that must be fired or discarded if 'using' in kwargs: transaction.set_dirty(using=kwargs['using']) else: transaction.set_dirty() _get_task_queue().append((self, args, kwargs)) else: apply_async_orig = super(PostTransactionTask, self).apply_async return apply_async_orig(*args, **kwargs) else: connection = get_connection() if connection.in_atomic_block and eager_transaction: _get_task_queue().append((self, args, kwargs)) else: return self.original_apply_async(*args, **kwargs)
def process_response(self, request, response): """Commits and leaves transaction management.""" if transaction.is_managed(): if transaction.is_dirty(): transaction.commit() transaction.leave_transaction_management() return response
def update(self, **kwargs): if transaction.is_managed(using=self.db): # トランザクション中. return super(PIQuerySet, self).update(**kwargs) else: # トランザクション外. return save_custom_retries(self.__update_sub, **kwargs)
def test_transaction_rollback(self): """Tests johnny's handling of transaction rollbacks. Similar to the commit, this sets up a write to a db in a transaction, reads from it (to force a cache write of sometime), then rolls back.""" from Queue import Queue as queue from django.db import transaction from testapp.models import Genre, Publisher from johnny import cache if settings.DATABASE_ENGINE == 'sqlite3': print "\n Skipping test requiring multiple threads." return self.failUnless(transaction.is_managed() == False) self.failUnless(transaction.is_dirty() == False) connection.queries = [] cache.local.clear() q = queue() other = lambda x: self._run_threaded(x, q) # load some data start = Genre.objects.get(id=1) other('Genre.objects.get(id=1)') hit, ostart = q.get() # these should be the same and should have hit cache self.failUnless(hit) self.failUnless(ostart == start) # enter manual transaction management transaction.enter_transaction_management() transaction.managed() start.title = 'Jackie Chan Novels' # local invalidation, this key should hit the localstore! nowlen = len(cache.local) start.save() self.failUnless(nowlen != len(cache.local)) # perform a read OUTSIDE this transaction... it should still see the # old gen key, and should still find the "old" data other('Genre.objects.get(id=1)') hit, ostart = q.get() self.failUnless(hit) self.failUnless(ostart.title != start.title) # perform a READ inside the transaction; this should hit the localstore # but not the outside! nowlen = len(cache.local) start2 = Genre.objects.get(id=1) self.failUnless(start2.title == start.title) self.failUnless(len(cache.local) > nowlen) transaction.rollback() # we rollback, and flush all johnny keys related to this transaction # subsequent gets should STILL hit the cache in the other thread # and indeed, in this thread. self.failUnless(transaction.is_dirty() == False) other('Genre.objects.get(id=1)') hit, ostart = q.get() self.failUnless(hit) start = Genre.objects.get(id=1) self.failUnless(ostart.title == start.title) transaction.managed(False) transaction.leave_transaction_management()
def create_qark(attrs=None): """ """ # Wrap the creation of the facet and its attributes in a transaction savepoint # and ensure that a transaction is active assert transaction.is_managed(), "A managed transaction is required to create a Fact" sid = transaction.savepoint() try: # Create a QArk and save it; make sure it is new qark = QArk(nextrev=1) qark.save(force_insert=True) # Look up the id's of any attributes specified by name # Find all of the Facets by looking up the attributes specified # Create each of the attributes for attrdict in attrs: # Create a QArkAttr and save it; make sure it's new; and add it to the QArk attr = QArkAttr.create_qarkattr(**attrdict) attr.qark = qark attr.rev = 0 attr.save(force_insert=True) return qark except: transaction.savepoint_rollback(sid) # TODO: Need an exception here that is meaningful to what went wrong raise else: transaction.savepoint_commit(sid)
def _commit_on_success_unless_managed(*args, **kw): try: if transaction.is_managed(): forced_managed = False else: transaction.enter_transaction_management() forced_managed = True try: res = func(*args, **kw) except: # All exceptions must be handled here (even string ones). if transaction.is_dirty(): if forced_managed: transaction.rollback() else: transaction.rollback_unless_managed() raise else: if transaction.is_dirty(): if forced_managed: transaction.commit() else: transaction.commit_unless_managed() return res finally: if forced_managed: transaction.leave_transaction_management()
def in_transaction(test_ignore=True): result = transaction.is_managed() if test_ignore: # Ignore when running inside a Django test case, which uses # transactions. result = result and not hasattr(mail, 'outbox') return result
def tearDown(self): from django.db import transaction if transaction.is_managed(): if transaction.is_dirty(): transaction.rollback() transaction.managed(False) transaction.leave_transaction_management()
def transaction_rollback(using): """ DB(using)をロールバックし、トランザクション区間を終了する。 """ if (transaction.is_managed(using=using)): transaction.rollback(using=using) transaction.leave_transaction_management(using=using)
def createTable(self): """ Sets up the database table using self.field_list """ if not self.field_list: self._getModelFieldList() if not transaction.is_managed(): db.start_transaction() db.create_table(self._tname, tuple(self.field_list)) # Executing deferred SQL, after correcting the CREATE INDEX statements deferred_sql = [] for stmt in db.deferred_sql: deferred_sql.append(re.sub('^CREATE INDEX \"customforms\".', 'CREATE INDEX ', stmt)) db.deferred_sql = deferred_sql db.execute_deferred_sql() db.commit_transaction() else: db.create_table(self._tname, tuple(self.field_list)) # Executing deferred SQL, after correcting the CREATE INDEX statements deferred_sql = [] for stmt in db.deferred_sql: deferred_sql.append(re.sub('^CREATE INDEX \"customforms\".', 'CREATE INDEX ', stmt)) db.deferred_sql = deferred_sql db.execute_deferred_sql()
def update(self, **kwargs): """ Updates all elements in the current QuerySet, setting all the given fields to the appropriate values. """ assert self.query.can_filter(), \ "Cannot update a query once a slice has been taken." query = self.query.clone(sql.UpdateQuery) query.add_update_values(kwargs) if not transaction.is_managed(): transaction.enter_transaction_management() forced_managed = True else: forced_managed = False try: rows = query.execute_sql(None) if forced_managed: transaction.commit() else: transaction.commit_unless_managed() finally: if forced_managed: transaction.leave_transaction_management() self._result_cache = None return rows
def apply_async(self, *args, **kwargs): # Delay the task unless the client requested otherwise or transactions # aren't being managed (i.e. the signal handlers won't send the task). if django.VERSION < (1, 6): if transaction.is_managed() and not current_app.conf.CELERY_ALWAYS_EAGER: if not transaction.is_dirty(): # Always mark the transaction as dirty # because we push task in queue that must be fired or discarded if 'using' in kwargs: transaction.set_dirty(using=kwargs['using']) else: transaction.set_dirty() _get_task_queue().append((self, args, kwargs)) else: apply_async_orig = super(PostTransactionTask, self).apply_async return apply_async_orig(*args, **kwargs) else: connection = get_connection() if connection.in_atomic_block and not getattr(current_app.conf, 'CELERY_ALWAYS_EAGER', False): _get_task_queue().append((self, args, kwargs)) else: return self.original_apply_async(*args, **kwargs)
def test_django_db_transaction_managed(self): """ Check that django.db.transaction.managed is not affected by monkey-patching """ if django.VERSION >= (1,6): self.skipTest('Django 1.6 does not need this test') from django.db import transaction self.assertFalse(transaction.is_managed()) transaction.enter_transaction_management() try: transaction.managed() self.assertTrue(transaction.is_managed()) finally: transaction.leave_transaction_management()
def process_response(self, request, response): if transaction.is_managed(): try: transaction.commit() except: pass transaction.leave_transaction_management() return response
def wrapper(*args, **kwargs): if transaction.is_managed(): @transaction.commit_on_success def f_deferred(*a, **kw): f(*args, **kwargs) transaction.signals.post_commit.connect(f_deferred, weak=False) else: f(*args, **kwargs)
def mark_deleted(self): # If this is not within a managed transaction we must use commit_on_success to ensure that the object is # only marked deleted if the updates to alerts also succeed if transaction.is_managed(): self._mark_deleted() else: with transaction.commit_on_success(): self._mark_deleted()
def transaction_commit(using): """ DB(using)がdirtyな場合、commitし、トランザクション区間を終了する。 """ if (transaction.is_managed(using=using)): if (transaction.is_dirty(using=using)): transaction.commit(using=using) transaction.leave_transaction_management(using=using)
def daemon_refresh(): """Ask daemon to reload configuration""" if transaction.is_managed(): transaction.commit() queue = redis.Redis(db=0) queue.lpush('bot', 'REFRESH')
def commit_unless_managed(using=None): if not transaction.is_managed(using=using): connection = conn(using) transaction_signals.pre_commit.send(sender=connection) yield send_robust_and_log_errors("post_commit", sender=connection) else: yield
def rollback_unless_managed(using=None): if not transaction.is_managed(using=using): connection = conn(using) signals.pre_rollback.send(sender=connection) yield send_robust_and_log_errors("post_rollback", sender=connection) else: yield
def test_django_db_transaction_managed(self): """ Check that django.db.transaction.managed is not affected by monkey-patching """ if django.VERSION >= (1, 6): self.skipTest('Django 1.6 does not need this test') from django.db import transaction self.assertFalse(transaction.is_managed()) transaction.enter_transaction_management() try: transaction.managed() self.assertTrue(transaction.is_managed()) finally: transaction.leave_transaction_management()
def transaction_commit(using): """ DB(using)がdirtyな場合、commitし、トランザクション区間を終了する。 """ if ( transaction.is_managed(using=using) ): if ( transaction.is_dirty(using=using) ): transaction.commit(using=using) transaction.leave_transaction_management(using=using)
def create_tables_for_dynamic_classes(*model_classes): """ Creates the table for the dynamic model class if needed :param model_classes: 0 or more model classes for which to create a table :return: """ for model_class in model_classes: if dynamic_model_table_exists(model_class): continue #info = "Model class table {model_class} doesn't exist -- creating it \n" #logger.debug(info.format(model_class=model_class._meta.db_table)) fields = [(f.name, f) for f in model_class._meta.local_fields] table_name = model_class._meta.db_table db.create_table(table_name, fields) # some fields (eg GeoDjango) require additional SQL to be executed # Because of the poor Django/GeoDjango support for schemas, we have to manipulate the GeoDjango sql here so that the table is resolved to the correct schema, sigh if len(table_name.split('.')) == 2: schema, table = parse_schema_and_table(table_name) for i, sql in enumerate(db.deferred_sql): # Replace the POSTGIS single argument with two arguments # TODO this stupidly assumes that all deferred sql is POSTGIS # Substitution for '"schema"."table"' to 'schema','table'. This is for AddGeometryColumn db.deferred_sql[i] = re.sub( "'{0}'".format(table_name), "'{0}','{1}'".format(schema, table), sql) # Substitution for "schema"."table" to schema.table. This is for CREATE INDEX db.deferred_sql[i] = re.sub("{0}".format(table_name), "{0}.{1}".format(schema, table), db.deferred_sql[i]) # Substitution for "schema"."tableHEX". Some indexes add random hex to the table name inside the double quotes. They may also truncate the table name, so just capture everything between "s # Also truncate to 64 characters the schema name minus the length of the table name, favoring the end of the schema which is most unique db.deferred_sql[i] = re.sub(r'"(".*)"\."(.*") ON', r'\1.\2 ON'.format(schema, table), db.deferred_sql[i]) # Last ditch effort to remove extra " when we can't match generated index db.deferred_sql[i] = re.sub(r'""', r'"', db.deferred_sql[i]) if string.find(db.deferred_sql[i], 'CREATE INDEX') == 0: subs = db.deferred_sql[i] # Truncate the index name. This could be done more elegantly # db.deferred_sql[i] = subs[0:14] + subs[14:string.index(subs, '" ON')][-63:] + subs[string.index(subs, '" ON'):] db.deferred_sql[i] = subs[0:14] + table + '_' + re.findall( r'"([^"]*)"', subs)[1] + subs[string.index(subs, '" ON'):] try: db.execute_deferred_sql() except Exception, e: raise Exception( "The table {table_name} was not created. Original exception: {message}. Deferred sql calls: {sql}" .format(table_name=model_class._meta.db_table, message=e.message, sql='\n'.join(db.deferred_sql))) # TODO I don't know if or when this is needed. if transaction.is_managed(): transaction.commit()
def process_response(self, request, response): """Commits and leaves transaction management.""" db = self.get_tenant(request) if db: if transaction.is_managed(using=db): if transaction.is_dirty(using=db): transaction.commit(using=db) transaction.leave_transaction_management(using=db) return response