Python base.BaseDatabaseWrapper类代码示例

 def close(self):
     self.validate_thread_sharing()
     # If database is in memory, closing the connection destroys the
     # database. To prevent accidental data loss, ignore close requests on
     # an in-memory db.
     if not self.is_in_memory_db():
         BaseDatabaseWrapper.close(self)

    def __init__(self, *args, **kwargs):
        BaseDatabaseWrapper.__init__(self, *args, **kwargs)

        self.server_version = None
        self.features = DatabaseFeatures(self)
        self.ops = DatabaseOperations(self)
        self.client = DatabaseClient(self)
        self.creation = DatabaseCreation(self)
        self.introspection = DatabaseIntrospection(self)
        self.validation = DatabaseValidation(self)

def create_cloned_sqlite_db(queries):
    """
    Magic. Inspired by:
    http://stackoverflow.com/questions/8045602/how-can-i-copy-an-in-memory-sqlite-database-to-another-in-memory-sqlite-database
    http://stackoverflow.com/questions/8242837/django-multiprocessing-and-database-connections
    """
    for query_list, database_wrapper in zip(queries, connections.all()):
        # Work around :memory: in django/db/backends/sqlite3/base.py
        BaseDatabaseWrapper.close(database_wrapper)

        cursor = database_wrapper.cursor()
        for sql in query_list.split(';'):
            sql += ';'
            cursor.execute(sql)
        database_wrapper.connection.commit()

 def _rollback(self):
     try:
         BaseDatabaseWrapper._rollback(self)
     except NotSupportedError:
         pass

    def run_tests(self, test_labels, extra_tests=None, **kwargs):
        extra = 1 if extra_tests else 0
        start = time.time()
        if not test_labels:
            # If no test labels were provided, provide them
            # and remove our custom exclusions
            test_labels = [
                # Don't double-discover tests?
                app.__name__.replace('.models', '')
                for app in self.get_apps_after_exclusions()
            ]
            # Hide most of the test output so we can focus on failures,
            # unless the user wanted to see the full output per app.
            if self.verbosity == 1:
                self.verbosity = 0

        self.setup_test_environment()

        # Prepare (often many) test suites to be run across multiple processes
        # suite = self.build_suite(test_labels, extra_tests)
        processes = []
        source_queue = Queue(maxsize=len(test_labels) + extra)

        for label in test_labels:
            suite = self.build_suite([label])
            source_queue.put((label, suite))
        if extra_tests:
            source_queue.put(
                ('extra_tests', self.build_suite(None, extra_tests))
            )

        if self.ramdb and self.db_files_exist():
            # Have run before, reuse the RAM DB.
            in_files = self.db_file_paths()
            print('Reusing database files: \n{}'.format('\n'.join(in_files)))
            queries = []
            for in_file_name in in_files:
                with open(in_file_name) as infile:
                    queries.append('\n'.join(infile.readlines()))
            if DJANGO_VERSION[1] >= 7:
                hijack_setup_databases(self.verbosity, self.interactive)
            else:
                self.setup_databases()
        else:
            start = time.time()
            tag_hash = self.get_source_control_tag_hash()
            if tag_hash == self.DEFAULT_TAG_HASH:
                print('git or hg source control not found, '
                      'only most recent migration saved')
            print('Running (often slow) migrations... \n'
                  'Hint: Use --ramdb={} to reuse the final stored SQL later.'
                  .format(tag_hash))
            tag_hash = os.path.join(self.ramdb_saves, tag_hash)
            if not os.path.exists(tag_hash):
                os.makedirs(tag_hash)
            # Only run the slow migrations if --ramdb is not specified,
            # or running for first time
            old_config = self.setup_databases()
            queries = []
            for database_wrapper in connections.all():
                connection = database_wrapper.connection
                sql = '\n'.join(line for line in connection.iterdump())
                queries.append(sql)
                # Work around :memory: in django/db/backends/sqlite3/base.py
                BaseDatabaseWrapper.close(database_wrapper)
                mem, db_name = database_wrapper.creation.test_db_signature()
                with open(self.get_db_path(db_name, tag_hash), 'w') as outfile:
                    outfile.write(sql)
            self.teardown_databases(old_config)
            msg = 'Setup, migrations, ... completed in {:.3f} seconds'.format(
                time.time() - start
            )
            print(msg)

        result_queue = Queue(maxsize=len(test_labels) + extra)
        process_args = (self, source_queue, result_queue, queries)
        for _ in range(min(self.concurrency, len(test_labels) + extra)):
            p = Process(target=multi_proc_run_tests, args=process_args)
            p.start()
            processes.append(p)
        else:
            # Concurrency == 0 - run in same process
            multi_proc_run_tests(*process_args)

        for p in processes:
            p.join()

        results = []
        retrieved_labels = []
        while not result_queue.empty():
            retrieved_label, result = result_queue.get()
            results.append(result)
            retrieved_labels.append(retrieved_label)
        not_covered = set(test_labels) - set(retrieved_labels)
        if not_covered:
            msg = (
                'Tests that did not return results under --concurrency={} '
                '(try running separately, or with --concurrency=0): {}'.format(
                    self.concurrency,
                    ' '.join(sorted(not_covered)),
#.........这里部分代码省略.........

"""