diff --git a/django/conf/global_settings.py b/django/conf/global_settings.py
--- a/django/conf/global_settings.py
+++ b/django/conf/global_settings.py
@@ -130,6 +130,7 @@
 DATABASE_HOST = ''             # Set to empty string for localhost. Not used with sqlite3.
 DATABASE_PORT = ''             # Set to empty string for default. Not used with sqlite3.
 DATABASE_OPTIONS = {}          # Set to empty dictionary for default.
+DATABASE_SCHEMA = ''           # Set to empty string for default.
 
 # The email backend to use. For possible shortcuts see django.core.mail.
 # The default is to use the SMTP backend.
diff --git a/django/conf/project_template/settings.py b/django/conf/project_template/settings.py
--- a/django/conf/project_template/settings.py
+++ b/django/conf/project_template/settings.py
@@ -15,6 +15,7 @@
 DATABASE_PASSWORD = ''         # Not used with sqlite3.
 DATABASE_HOST = ''             # Set to empty string for localhost. Not used with sqlite3.
 DATABASE_PORT = ''             # Set to empty string for default. Not used with sqlite3.
+DATABASE_SCHEMA = ''           # Set to empty string for default.
 
 # Local time zone for this installation. Choices can be found here:
 # http://en.wikipedia.org/wiki/List_of_tz_zones_by_name
diff --git a/django/contrib/contenttypes/generic.py b/django/contrib/contenttypes/generic.py
--- a/django/contrib/contenttypes/generic.py
+++ b/django/contrib/contenttypes/generic.py
@@ -129,7 +129,15 @@
         return self.object_id_field_name
 
     def m2m_reverse_name(self):
-        return self.model._meta.pk.column
+        return self.rel.to._meta.pk.column
+
+    def m2m_db_schema(self):
+        return self.rel.to._meta.db_schema
+
+    def m2m_qualified_name(self):
+        schema = self.m2m_db_schema()
+        table = self.m2m_db_table()
+        return connection.ops.prep_db_table(schema, table)
 
     def contribute_to_class(self, cls, name):
         super(GenericRelation, self).contribute_to_class(cls, name)
diff --git a/django/core/management/commands/syncdb.py b/django/core/management/commands/syncdb.py
--- a/django/core/management/commands/syncdb.py
+++ b/django/core/management/commands/syncdb.py
@@ -49,8 +49,9 @@
         cursor = connection.cursor()
 
         # Get a list of already installed *models* so that references work right.
-        tables = connection.introspection.table_names()
+        tables = [('', tn) for tn in connection.introspection.table_names()]
         seen_models = connection.introspection.installed_models(tables)
+        seen_schemas = set()
         created_models = set()
         pending_references = {}
 
@@ -59,13 +60,26 @@
             app_name = app.__name__.split('.')[-2]
             model_list = models.get_models(app, include_auto_created=True)
             for model in model_list:
-                # Create the model's database table, if it doesn't already exist.
+                # Add model-defined schema tables if any.
+                db_schema = model._meta.db_schema
+                if db_schema:
+                    db_schema = connection.introspection.schema_name_converter(db_schema)
+                    if db_schema not in seen_schemas:
+                        tables += [(db_schema, tn) for tn in
+                                   connection.introspection.schema_table_names(db_schema)]
+                        seen_schemas.add(db_schema)
+
+                # Create the model's database table,
+                # if it doesn't already exist.
                 if verbosity >= 2:
                     print "Processing %s.%s model" % (app_name, model._meta.object_name)
                 opts = model._meta
-                if (connection.introspection.table_name_converter(opts.db_table) in tables or
-                    (opts.auto_created and
-                    connection.introspection.table_name_converter(opts.auto_created._meta.db_table) in tables)):
+                schema_table = (db_schema, connection.introspection.table_name_converter(opts.db_table))
+                if schema_table in tables or \
+                    (opts.auto_created and \
+                    (db_schema,
+                     connection.introspection.table_name_converter(opts.auto_created._meta.db_table))
+                    in tables):
                     continue
                 sql, references = connection.creation.sql_create_model(model, self.style, seen_models)
                 seen_models.add(model)
@@ -79,7 +93,7 @@
                     print "Creating table %s" % model._meta.db_table
                 for statement in sql:
                     cursor.execute(statement)
-                tables.append(connection.introspection.table_name_converter(model._meta.db_table))
+                tables.append(schema_table)
 
 
         transaction.commit_unless_managed()
diff --git a/django/core/management/sql.py b/django/core/management/sql.py
--- a/django/core/management/sql.py
+++ b/django/core/management/sql.py
@@ -68,7 +68,8 @@
 
     # Figure out which tables already exist
     if cursor:
-        table_names = connection.introspection.get_table_list(cursor)
+        table_names = [('', tn) for tn in
+                       connection.introspection.get_table_list(cursor)]
     else:
         table_names = []
 
@@ -79,8 +80,19 @@
 
     references_to_delete = {}
     app_models = models.get_models(app, include_auto_created=True)
+    seen_schemas = set()
     for model in app_models:
-        if cursor and connection.introspection.table_name_converter(model._meta.db_table) in table_names:
+        db_schema = model._meta.db_schema
+        # Find additional tables in model-defined schemas.
+        if db_schema:
+            db_schema = connection.introspection.schema_name_converter(db_schema)
+            if db_schema not in seen_schemas:
+                table_names += [(db_schema, tn) for tn in connection.introspection.get_schema_table_list(cursor, db_schema)]
+                seen_schemas.add(db_schema)
+        schema_table = (db_schema,
+                        connection.introspection.table_name_converter(model._meta.db_table))
+
+        if cursor and schema_table in table_names:
             # The table exists, so it needs to be dropped
             opts = model._meta
             for f in opts.local_fields:
@@ -90,7 +102,12 @@
             to_delete.add(model)
 
     for model in app_models:
-        if connection.introspection.table_name_converter(model._meta.db_table) in table_names:
+        db_schema = model._meta.db_schema
+        if db_schema:
+            db_schema = connection.introspection.schema_name_converter(db_schema)
+        schema_table = (db_schema,
+                        connection.introspection.table_name_converter(model._meta.db_table))
+        if schema_table in table_names:
             output.extend(connection.creation.sql_destroy_model(model, references_to_delete, style))
 
     # Close database connection explicitly, in case this output is being piped
@@ -116,7 +133,7 @@
     if only_django:
         tables = connection.introspection.django_table_names(only_existing=True)
     else:
-        tables = connection.introspection.table_names()
+        tables = [('', tn) for tn in connection.introspection.table_names()]
     statements = connection.ops.sql_flush(style, tables, connection.introspection.sequence_list())
     return statements
 
diff --git a/django/db/backends/__init__.py b/django/db/backends/__init__.py
--- a/django/db/backends/__init__.py
+++ b/django/db/backends/__init__.py
@@ -109,7 +109,7 @@
     a backend performs ordering or calculates the ID of a recently-inserted
     row.
     """
-    def autoinc_sql(self, table, column):
+    def autoinc_sql(self, schema, table, column):
         """
         Returns any SQL needed to support auto-incrementing primary keys, or
         None if no SQL is necessary.
@@ -155,7 +155,7 @@
         """
         return "DROP CONSTRAINT"
 
-    def drop_sequence_sql(self, table):
+    def drop_sequence_sql(self, schema, table):
         """
         Returns any SQL necessary to drop the sequence for the given table.
         Returns None if no SQL is necessary.
@@ -216,7 +216,7 @@
 
         return smart_unicode(sql) % u_params
 
-    def last_insert_id(self, cursor, table_name, pk_name):
+    def last_insert_id(self, cursor, schema_name, table_name, pk_name):
         """
         Given a cursor object that has just performed an INSERT statement into
         a table that has an auto-incrementing ID, returns the newly created ID.
@@ -287,6 +287,20 @@
         """
         raise NotImplementedError()
 
+    def prep_db_table(self, db_schema, db_table):
+        """
+        Prepares and formats the table name if necessary.
+        Just returns quoted db_table if not supported.
+        """
+        return self.quote_name(db_table)
+
+    def prep_db_index(self, db_schema, db_index):
+        """
+        Prepares and formats the table index name if necessary.
+        Just returns quoted db_index if not supported.
+        """
+        return self.quote_name(db_index)
+
     def random_function_sql(self):
         """
         Returns a SQL expression that returns a random value.
@@ -486,28 +500,69 @@
         return name
 
     def table_names(self):
-        "Returns a list of names of all tables that exist in the database."
+        "Returns a list of names of all tables that exist in the default schema."
         cursor = self.connection.cursor()
         return self.get_table_list(cursor)
 
+    def schema_name_converter(self, name):
+        """Apply a conversion to the name for the purposes of comparison.
+
+        The default schema name converter is for case sensitive comparison.
+        """
+        return name
+
+    def get_schema_list(self, cursor):
+        "Returns a list of schemas that exist in the database"
+        return []
+
+    def get_schema_table_list(self, cursor, schema):
+        "Returns a list of tables in a specific schema"
+        return []
+
+    def schema_names(self):
+        cursor = self.connection.cursor()
+        return self.get_schema_list(cursor)
+
+    def schema_table_names(self, schema):
+        "Returns a list of names of all tables that exist in the database schema."
+        cursor = self.connection.cursor()
+        return self.get_schema_table_list(cursor, schema)
+
     def django_table_names(self, only_existing=False):
         """
-        Returns a list of all table names that have associated Django models and
-        are in INSTALLED_APPS.
+        Returns a list of tuples containing all schema and table names that
+        have associated Django models and are in INSTALLED_APPS.
 
-        If only_existing is True, the resulting list will only include the tables
-        that actually exist in the database.
+        If only_existing is True, the resulting list will only include the
+        tables that actually exist in the database.
         """
         from django.db import models
         tables = set()
-        for app in models.get_apps():
-            for model in models.get_models(app):
-                if not model._meta.managed:
-                    continue
-                tables.add(model._meta.db_table)
-                tables.update([f.m2m_db_table() for f in model._meta.local_many_to_many])
         if only_existing:
-            tables = [t for t in tables if self.table_name_converter(t) in self.table_names()]
+            existing_tables = set([('', tn) for tn in self.table_names()])
+            seen_schemas = set()
+        for model in models.get_models():
+            if not model._meta.managed:
+                continue
+            db_schema = model._meta.db_schema
+            db_table = model._meta.db_table
+            if only_existing and db_schema and db_schema not in seen_schemas:
+                existing_tables.update([(db_schema, tn) for tn in
+                                        self.schema_table_names(db_schema)])
+                seen_schemas.add(db_schema)
+            tables.add((model._meta.db_schema, model._meta.db_table))
+            for f in model._meta.local_many_to_many:
+                m2m_schema = f.m2m_db_schema()
+                m2m_table = f.m2m_db_table()
+                if only_existing and m2m_schema and m2m_schema not in seen_schemas:
+                    existing_tables.update([(m2m_schema, tn) for tn in
+                                        self.schema_table_names(m2m_schema)])
+                    seen_schemas.add(m2m_schema)
+                tables.add((m2m_schema, m2m_table))
+        if only_existing:
+            tables = [(s, t) for (s, t) in tables
+                      if (self.schema_name_converter(s),
+                          self.table_name_converter(t)) in existing_tables]
         return tables
 
     def installed_models(self, tables):
@@ -534,14 +589,19 @@
                     continue
                 for f in model._meta.local_fields:
                     if isinstance(f, models.AutoField):
-                        sequence_list.append({'table': model._meta.db_table, 'column': f.column})
+                        sequence_list.append({'table': model._meta.db_table,
+                                              'column': f.column,
+                                              'schema': model._meta.db_schema})
                         break # Only one AutoField is allowed per model, so don't bother continuing.
 
                 for f in model._meta.local_many_to_many:
+                    schema = f.m2m_db_schema()
                     # If this is an m2m using an intermediate table,
                     # we don't need to reset the sequence.
                     if f.rel.through is None:
-                        sequence_list.append({'table': f.m2m_db_table(), 'column': None})
+                        sequence_list.append({'table': f.m2m_db_table(),
+                                              'column': None,
+                                              'schema': schema})
 
         return sequence_list
 
diff --git a/django/db/backends/creation.py b/django/db/backends/creation.py
--- a/django/db/backends/creation.py
+++ b/django/db/backends/creation.py
@@ -32,6 +32,17 @@
         """
         return '%x' % (abs(hash(args)) % 4294967296L)  # 2**32
 
+    def default_schema(self):
+        return ""
+
+    def sql_create_schema(self, schema, style):
+        """"
+        Returns the SQL required to create a single schema
+        """
+        qn = self.connection.ops.quote_name
+        output = "%s %s;" % (style.SQL_KEYWORD('CREATE SCHEMA'), qn(schema))
+        return output
+
     def sql_create_model(self, model, style, known_models=set()):
         """
         Returns the SQL required to create a single model, as a tuple of:
@@ -80,7 +91,7 @@
             table_output.append(style.SQL_KEYWORD('UNIQUE') + ' (%s)' % \
                 ", ".join([style.SQL_FIELD(qn(opts.get_field(f).column)) for f in field_constraints]))
 
-        full_statement = [style.SQL_KEYWORD('CREATE TABLE') + ' ' + style.SQL_TABLE(qn(opts.db_table)) + ' (']
+        full_statement = [style.SQL_KEYWORD('CREATE TABLE') + ' ' + style.SQL_TABLE(opts.qualified_name) + ' (']
         for i, line in enumerate(table_output): # Combine and add commas.
             full_statement.append('    %s%s' % (line, i < len(table_output)-1 and ',' or ''))
         full_statement.append(')')
@@ -92,7 +103,9 @@
         if opts.has_auto_field:
             # Add any extra SQL needed to support auto-incrementing primary keys.
             auto_column = opts.auto_field.db_column or opts.auto_field.name
-            autoinc_sql = self.connection.ops.autoinc_sql(opts.db_table, auto_column)
+            autoinc_sql = self.connection.ops.autoinc_sql(opts.db_schema,
+                                                          opts.db_table,
+                                                          auto_column)
             if autoinc_sql:
                 for stmt in autoinc_sql:
                     final_output.append(stmt)
@@ -104,7 +117,7 @@
         qn = self.connection.ops.quote_name
         if field.rel.to in known_models:
             output = [style.SQL_KEYWORD('REFERENCES') + ' ' + \
-                style.SQL_TABLE(qn(field.rel.to._meta.db_table)) + ' (' + \
+                style.SQL_TABLE(field.rel.to._meta.qualified_name) + ' (' + \
                 style.SQL_FIELD(qn(field.rel.to._meta.get_field(field.rel.field_name).column)) + ')' +
                 self.connection.ops.deferrable_sql()
             ]
@@ -130,15 +143,17 @@
             for rel_class, f in pending_references[model]:
                 rel_opts = rel_class._meta
                 r_table = rel_opts.db_table
+                r_qname = rel_opts.qualified_name
                 r_col = f.column
                 table = opts.db_table
+                qname = opts.qualified_name
                 col = opts.get_field(f.rel.field_name).column
                 # For MySQL, r_name must be unique in the first 64 characters.
                 # So we are careful with character usage here.
                 r_name = '%s_refs_%s_%s' % (r_col, col, self._digest(r_table, table))
                 final_output.append(style.SQL_KEYWORD('ALTER TABLE') + ' %s ADD CONSTRAINT %s FOREIGN KEY (%s) REFERENCES %s (%s)%s;' % \
-                    (qn(r_table), qn(truncate_name(r_name, self.connection.ops.max_name_length())),
-                    qn(r_col), qn(table), qn(col),
+                    (r_qname, qn(truncate_name(r_name, self.connection.ops.max_name_length())),
+                    qn(r_col), qname, qn(col),
                     self.connection.ops.deferrable_sql()))
             del pending_references[model]
         return final_output
@@ -157,7 +172,7 @@
         from django.db.backends.util import truncate_name
 
         output = []
-        if f.creates_table:
+        if f.rel.through._meta.auto_created:
             opts = model._meta
             qn = self.connection.ops.quote_name
             tablespace = f.db_tablespace or opts.db_tablespace
@@ -170,7 +185,7 @@
             else:
                 tablespace_sql = ''
             table_output = [style.SQL_KEYWORD('CREATE TABLE') + ' ' + \
-                style.SQL_TABLE(qn(f.m2m_db_table())) + ' (']
+                style.SQL_TABLE(qn(f.m2m_qualified_name())) + ' (']
             table_output.append('    %s %s %s%s,' %
                 (style.SQL_FIELD(qn('id')),
                 style.SQL_COLTYPE(models.AutoField(primary_key=True).db_type()),
@@ -202,7 +217,9 @@
                 self.connection.ops.deferrable_sql()))
 
             # Add any extra SQL needed to support auto-incrementing PKs
-            autoinc_sql = self.connection.ops.autoinc_sql(f.m2m_db_table(), 'id')
+            autoinc_sql = self.connection.ops.autoinc_sql(f.m2m_db_schema(),
+                                                          f.m2m_db_table(),
+                                                          'id')
             if autoinc_sql:
                 for stmt in autoinc_sql:
                     output.append(stmt)
@@ -219,14 +236,14 @@
                 (style.SQL_FIELD(qn(field.m2m_column_name())),
                 style.SQL_COLTYPE(models.ForeignKey(model).db_type()),
                 style.SQL_KEYWORD('NOT NULL REFERENCES'),
-                style.SQL_TABLE(qn(opts.db_table)),
+                style.SQL_TABLE(opts.qualified_name),
                 style.SQL_FIELD(qn(opts.pk.column)),
                 self.connection.ops.deferrable_sql()),
             '    %s %s %s %s (%s)%s,' %
                 (style.SQL_FIELD(qn(field.m2m_reverse_name())),
                 style.SQL_COLTYPE(models.ForeignKey(field.rel.to).db_type()),
                 style.SQL_KEYWORD('NOT NULL REFERENCES'),
-                style.SQL_TABLE(qn(field.rel.to._meta.db_table)),
+                style.SQL_TABLE(field.rel.to._meta.qualified_name),
                 style.SQL_FIELD(qn(field.rel.to._meta.pk.column)),
                 self.connection.ops.deferrable_sql())
         ]
@@ -256,16 +273,26 @@
                     tablespace_sql = ''
             else:
                 tablespace_sql = ''
+            index_name = '%s_%s' % (model._meta.db_table, f.column)
+            index_name = self.connection.ops.prep_db_index(model._meta.db_schema, index_name)
             output = [style.SQL_KEYWORD('CREATE INDEX') + ' ' +
-                style.SQL_TABLE(qn('%s_%s' % (model._meta.db_table, f.column))) + ' ' +
+                style.SQL_TABLE(index_name) + ' ' +
                 style.SQL_KEYWORD('ON') + ' ' +
-                style.SQL_TABLE(qn(model._meta.db_table)) + ' ' +
+                style.SQL_TABLE(model._meta.qualified_name) + ' ' +
                 "(%s)" % style.SQL_FIELD(qn(f.column)) +
                 "%s;" % tablespace_sql]
         else:
             output = []
         return output
 
+    def sql_destroy_schema(self, schema, style):
+        """"
+        Returns the SQL required to destroy a single schema.
+        """
+        qn = self.connection.ops.quote_name
+        output = "%s %s CASCADE;" % (style.SQL_KEYWORD('DROP SCHEMA IF EXISTS'), qn(schema))
+        return output
+
     def sql_destroy_model(self, model, references_to_delete, style):
         "Return the DROP TABLE and restraint dropping statements for a single model"
         if not model._meta.managed or model._meta.proxy:
@@ -273,12 +300,13 @@
         # Drop the table now
         qn = self.connection.ops.quote_name
         output = ['%s %s;' % (style.SQL_KEYWORD('DROP TABLE'),
-                              style.SQL_TABLE(qn(model._meta.db_table)))]
+                              style.SQL_TABLE(model._meta.qualified_name))]
         if model in references_to_delete:
             output.extend(self.sql_remove_table_constraints(model, references_to_delete, style))
 
         if model._meta.has_auto_field:
-            ds = self.connection.ops.drop_sequence_sql(model._meta.db_table)
+            ds = self.connection.ops.drop_sequence_sql(model._meta.db_schema,
+                                                       model._meta.db_table)
             if ds:
                 output.append(ds)
         return output
@@ -292,13 +320,14 @@
         qn = self.connection.ops.quote_name
         for rel_class, f in references_to_delete[model]:
             table = rel_class._meta.db_table
+            qname = rel_class._meta.qualified_name
             col = f.column
             r_table = model._meta.db_table
             r_col = model._meta.get_field(f.rel.field_name).column
             r_name = '%s_refs_%s_%s' % (col, r_col, self._digest(table, r_table))
             output.append('%s %s %s %s;' % \
                 (style.SQL_KEYWORD('ALTER TABLE'),
-                style.SQL_TABLE(qn(table)),
+                style.SQL_TABLE(qname),
                 style.SQL_KEYWORD(self.connection.ops.drop_foreignkey_sql()),
                 style.SQL_FIELD(truncate_name(r_name, self.connection.ops.max_name_length()))))
         del references_to_delete[model]
@@ -308,10 +337,11 @@
         "Returns the DROP TABLE statements for a single m2m field"
         qn = self.connection.ops.quote_name
         output = []
-        if f.creates_table:
+        if f.rel.through._meta.auto_created:
             output.append("%s %s;" % (style.SQL_KEYWORD('DROP TABLE'),
-                style.SQL_TABLE(qn(f.m2m_db_table()))))
-            ds = self.connection.ops.drop_sequence_sql("%s_%s" % (model._meta.db_table, f.column))
+                style.SQL_TABLE(f.m2m_qualified_name())))
+            ds = self.connection.ops.drop_sequence_sql(model._meta.db_schema,
+                               "%s_%s" % (model._meta.db_table, f.column))
             if ds:
                 output.append(ds)
         return output
@@ -324,7 +354,9 @@
         if verbosity >= 1:
             print "Creating test database..."
 
-        test_database_name = self._create_test_db(verbosity, autoclobber)
+        schema_apps = self._get_app_with_schemas()
+        schemas = self._get_schemas(schema_apps)
+        test_database_name = self._create_test_db(verbosity, autoclobber, schemas)
 
         self.connection.close()
         settings.DATABASE_NAME = test_database_name
@@ -333,6 +365,10 @@
         settings.DATABASE_SUPPORTS_TRANSACTIONS = can_rollback
         self.connection.settings_dict["DATABASE_SUPPORTS_TRANSACTIONS"] = can_rollback
 
+        # Create the test schemas.
+        cursor = self.connection.cursor()
+        self._create_test_schemas(verbosity, schemas, cursor)
+
         call_command('syncdb', verbosity=verbosity, interactive=False)
 
         if settings.CACHE_BACKEND.startswith('db://'):
@@ -346,7 +382,50 @@
 
         return test_database_name
 
-    def _create_test_db(self, verbosity, autoclobber):
+    def _create_test_schemas(self, verbosity, schemas, cursor):
+        from django.core.management.color import no_style
+        style = no_style()
+        for schema in schemas:
+            if verbosity >= 1:
+                print "Creating schema %s" % schema
+            cursor.execute(self.sql_create_schema(schema, style))
+
+    def _destroy_test_schemas(self, verbosity, schemas, cursor):
+        from django.core.management.color import no_style
+        style = no_style()
+        for schema in schemas:
+            if verbosity >= 1:
+                print "Destroying schema %s" % schema
+            cursor.execute(self.sql_destroy_schema(schema, style))
+            if verbosity >= 1:
+                print "Schema %s destroyed" % schema
+
+    def _get_schemas(self, apps):
+        from django.db import models
+        schemas = set()
+        for app in apps:
+            app_models = models.get_models(app)
+            for model in app_models:
+                schema = model._meta.db_schema
+                if not schema or schema in schemas:
+                    continue
+                schemas.add(schema)
+        return schemas
+
+    def _get_app_with_schemas(self):
+        from django.db import models
+        apps = models.get_apps()
+        schema_apps = set()
+        for app in apps:
+            app_models = models.get_models(app)
+            for model in app_models:
+                schema = model._meta.db_schema
+                if not schema or app in schema_apps:
+                    continue
+                schema_apps.add(app)
+        return schema_apps
+
+    def _create_test_db(self, verbosity, autoclobber, schemas):
         "Internal implementation - creates the test db tables."
         suffix = self.sql_table_creation_suffix()
 
@@ -372,6 +451,7 @@
                 try:
                     if verbosity >= 1:
                         print "Destroying old test database..."
+                    self._destroy_test_schemas(verbosity, schemas, cursor)
                     cursor.execute("DROP DATABASE %s" % qn(test_database_name))
                     if verbosity >= 1:
                         print "Creating test database..."
diff --git a/django/db/backends/mysql/base.py b/django/db/backends/mysql/base.py
--- a/django/db/backends/mysql/base.py
+++ b/django/db/backends/mysql/base.py
@@ -160,6 +160,16 @@
             return name # Quoting once is enough.
         return "`%s`" % name
 
+    def prep_db_table(self, db_schema, db_table):
+        qn = self.quote_name
+        if db_schema:
+            return "%s.%s" % (qn(db_schema), qn(db_table))
+        else:
+            return qn(db_table)
+
+    def prep_db_index(self, db_schema, db_index):
+        return self.prep_db_table(db_schema, db_index)
+
     def random_function_sql(self):
         return 'RAND()'
 
@@ -169,19 +179,22 @@
         # to clear all tables of all data
         if tables:
             sql = ['SET FOREIGN_KEY_CHECKS = 0;']
-            for table in tables:
-                sql.append('%s %s;' % (style.SQL_KEYWORD('TRUNCATE'), style.SQL_FIELD(self.quote_name(table))))
+            for (schema, table) in tables:
+                sql.append('%s %s;' % (style.SQL_KEYWORD('TRUNCATE'), style.SQL_FIELD(self.prep_db_table(schema, table))))
             sql.append('SET FOREIGN_KEY_CHECKS = 1;')
 
             # 'ALTER TABLE table AUTO_INCREMENT = 1;'... style SQL statements
             # to reset sequence indices
-            sql.extend(["%s %s %s %s %s;" % \
-                (style.SQL_KEYWORD('ALTER'),
-                 style.SQL_KEYWORD('TABLE'),
-                 style.SQL_TABLE(self.quote_name(sequence['table'])),
-                 style.SQL_KEYWORD('AUTO_INCREMENT'),
-                 style.SQL_FIELD('= 1'),
-                ) for sequence in sequences])
+            for sequence_info in sequences:
+                schema_name = sequence_info['schema']
+                table_name = self.prep_db_table(schema_name, sequence_info['table'])
+                sql.append("%s %s %s %s %s;" % \
+                           (style.SQL_KEYWORD('ALTER'),
+                            style.SQL_KEYWORD('TABLE'),
+                            style.SQL_TABLE(table_name),
+                            style.SQL_KEYWORD('AUTO_INCREMENT'),
+                            style.SQL_FIELD('= 1'),
+                            ))
             return sql
         else:
             return []
diff --git a/django/db/backends/mysql/creation.py b/django/db/backends/mysql/creation.py
--- a/django/db/backends/mysql/creation.py
+++ b/django/db/backends/mysql/creation.py
@@ -41,12 +41,12 @@
     def sql_for_inline_foreign_key_references(self, field, known_models, style):
         "All inline references are pending under MySQL"
         return [], True
-        
+
     def sql_for_inline_many_to_many_references(self, model, field, style):
         from django.db import models
         opts = model._meta
         qn = self.connection.ops.quote_name
-        
+
         table_output = [
             '    %s %s %s,' %
                 (style.SQL_FIELD(qn(field.m2m_column_name())),
@@ -64,4 +64,23 @@
                 field.rel.to._meta.db_table, field.rel.to._meta.pk.column)
             ]
         return table_output, deferred
-        
\ No newline at end of file
+
+    def default_schema(self):
+        return settings.DATABASE_NAME
+
+    def sql_create_schema(self, schema, style):
+        """
+        Returns the SQL required to create a single schema.
+        In MySQL schemas are synonymous to databases
+        """
+        qn = self.connection.ops.quote_name
+        output = "%s %s;" % (style.SQL_KEYWORD('CREATE DATABASE'), qn(schema))
+        return output
+
+    def sql_destroy_schema(self, schema, style):
+        """"
+        Returns the SQL required to destroy a single schema.
+        """
+        qn = self.connection.ops.quote_name
+        output = "%s %s;" % (style.SQL_KEYWORD('DROP DATABASE IF EXISTS'), qn(schema))
+        return output
diff --git a/django/db/backends/mysql/introspection.py b/django/db/backends/mysql/introspection.py
--- a/django/db/backends/mysql/introspection.py
+++ b/django/db/backends/mysql/introspection.py
@@ -33,6 +33,14 @@
         cursor.execute("SHOW TABLES")
         return [row[0] for row in cursor.fetchall()]
 
+    def get_schema_list(self, cursor):
+        cursor.execute("SHOW SCHEMAS")
+        return [row[0] for row in cursor.fetchall()]
+
+    def get_schema_table_list(self, cursor, schema):
+        cursor.execute("SHOW TABLES FROM %s" % self.connection.ops.quote_name(schema))
+        return [schema + "." + row[0] for row in cursor.fetchall()]
+
     def get_table_description(self, cursor, table_name):
         "Returns a description of the table, with the DB-API cursor.description interface."
         cursor.execute("SELECT * FROM %s LIMIT 1" % self.connection.ops.quote_name(table_name))
diff --git a/django/db/backends/oracle/base.py b/django/db/backends/oracle/base.py
--- a/django/db/backends/oracle/base.py
+++ b/django/db/backends/oracle/base.py
@@ -55,12 +55,14 @@
 
 class DatabaseOperations(BaseDatabaseOperations):
 
-    def autoinc_sql(self, table, column):
+    def autoinc_sql(self, schema, table, column):
         # To simulate auto-incrementing primary keys in Oracle, we have to
         # create a sequence and a trigger.
         sq_name = get_sequence_name(table)
         tr_name = get_trigger_name(table)
-        tbl_name = self.quote_name(table)
+        tbl_name = self.prep_db_table(schema, table)
+        sq_qname = self.prep_db_table(schema, sq_name)
+        tr_qname = self.prep_db_table(schema, tr_name)
         col_name = self.quote_name(column)
         sequence_sql = """
 DECLARE
@@ -69,17 +71,17 @@
     SELECT COUNT(*) INTO i FROM USER_CATALOG
         WHERE TABLE_NAME = '%(sq_name)s' AND TABLE_TYPE = 'SEQUENCE';
     IF i = 0 THEN
-        EXECUTE IMMEDIATE 'CREATE SEQUENCE "%(sq_name)s"';
+        EXECUTE IMMEDIATE 'CREATE SEQUENCE %(sq_qname)s';
     END IF;
 END;
 /""" % locals()
         trigger_sql = """
-CREATE OR REPLACE TRIGGER "%(tr_name)s"
+CREATE OR REPLACE TRIGGER %(tr_qname)s
 BEFORE INSERT ON %(tbl_name)s
 FOR EACH ROW
 WHEN (new.%(col_name)s IS NULL)
     BEGIN
-        SELECT "%(sq_name)s".nextval
+        SELECT %(sq_qname)s.nextval
         INTO :new.%(col_name)s FROM dual;
     END;
 /""" % locals()
@@ -108,8 +110,9 @@
     def deferrable_sql(self):
         return " DEFERRABLE INITIALLY DEFERRED"
 
-    def drop_sequence_sql(self, table):
-        return "DROP SEQUENCE %s;" % self.quote_name(get_sequence_name(table))
+    def drop_sequence_sql(self, schema, table):
+        sequence_name = self.prep_db_table(schema, get_sequence_name(table))
+        return "DROP SEQUENCE %s;" % sequence_name
 
     def fetch_returned_insert_id(self, cursor):
         return long(cursor._insert_id_var.getvalue())
@@ -120,9 +123,9 @@
         else:
             return "%s"
 
-    def last_insert_id(self, cursor, table_name, pk_name):
-        sq_name = get_sequence_name(table_name)
-        cursor.execute('SELECT "%s".currval FROM dual' % sq_name)
+    def last_insert_id(self, cursor, schema_name, table_name, pk_name):
+        sq_name = self.prep_db_table(schema_name, get_sequence_name(table_name))
+        cursor.execute('SELECT %s.currval FROM dual' % sq_name)
         return cursor.fetchone()[0]
 
     def lookup_cast(self, lookup_type):
@@ -133,6 +136,16 @@
     def max_name_length(self):
         return 30
 
+    def prep_db_table(self, db_schema, db_table):
+        qn = self.quote_name
+        if db_schema:
+            return "%s.%s" % (qn(db_schema), qn(db_table))
+        else:
+            return qn(db_table)
+
+    def prep_db_index(self, db_schema, db_index):
+        return self.prep_db_table(db_schema, db_index)
+
     def prep_for_iexact_query(self, x):
         return x
 
@@ -186,27 +199,30 @@
     def sql_flush(self, style, tables, sequences):
         # Return a list of 'TRUNCATE x;', 'TRUNCATE y;',
         # 'TRUNCATE z;'... style SQL statements
+        sql = []
         if tables:
             # Oracle does support TRUNCATE, but it seems to get us into
             # FK referential trouble, whereas DELETE FROM table works.
-            sql = ['%s %s %s;' % \
-                    (style.SQL_KEYWORD('DELETE'),
-                     style.SQL_KEYWORD('FROM'),
-                     style.SQL_FIELD(self.quote_name(table)))
-                    for table in tables]
+            for schema, table in tables:
+                table = self.prep_db_table(schema, table)
+                sql.append('%s %s %s;' % \
+                           (style.SQL_KEYWORD('DELETE'),
+                            style.SQL_KEYWORD('FROM'),
+                            style.SQL_FIELD(table)))
             # Since we've just deleted all the rows, running our sequence
             # ALTER code will reset the sequence to 0.
             for sequence_info in sequences:
-                sequence_name = get_sequence_name(sequence_info['table'])
-                table_name = self.quote_name(sequence_info['table'])
+                schema_name = sequence_info['schema']
+                sequence_name = self.prep_db_table(schema_name,
+                                    get_sequence_name(sequence_info['table']))
+                table_name = self.prep_db_table(schema_name,
+                                                sequence_info['table'])
                 column_name = self.quote_name(sequence_info['column'] or 'id')
                 query = _get_sequence_reset_sql() % {'sequence': sequence_name,
                                                      'table': table_name,
                                                      'column': column_name}
                 sql.append(query)
-            return sql
-        else:
-            return []
+        return sql
 
     def sequence_reset_sql(self, style, model_list):
         from django.db import models
@@ -215,8 +231,9 @@
         for model in model_list:
             for f in model._meta.local_fields:
                 if isinstance(f, models.AutoField):
-                    table_name = self.quote_name(model._meta.db_table)
-                    sequence_name = get_sequence_name(model._meta.db_table)
+                    table_name = model._meta.qualified_name
+                    sequence_name = self.prep_db_table(model._meta.db_schema,
+                                       get_sequence_name(model._meta.db_table))
                     column_name = self.quote_name(f.column)
                     output.append(query % {'sequence': sequence_name,
                                            'table': table_name,
@@ -226,8 +243,9 @@
                     break
             for f in model._meta.many_to_many:
                 if not f.rel.through:
-                    table_name = self.quote_name(f.m2m_db_table())
-                    sequence_name = get_sequence_name(f.m2m_db_table())
+                    table_name = self.quote_name(f.m2m_qualified_name())
+                    sequence_name = self.prep_db_table(f.m2m_db_schema(),
+                                           get_sequence_name(f.m2m_db_table()))
                     column_name = self.quote_name('id')
                     output.append(query % {'sequence': sequence_name,
                                            'table': table_name,
@@ -551,12 +569,12 @@
 BEGIN
     LOCK TABLE %(table)s IN SHARE MODE;
     SELECT NVL(MAX(%(column)s), 0) INTO startvalue FROM %(table)s;
-    SELECT "%(sequence)s".nextval INTO cval FROM dual;
+    SELECT %(sequence)s.nextval INTO cval FROM dual;
     cval := startvalue - cval;
     IF cval != 0 THEN
-        EXECUTE IMMEDIATE 'ALTER SEQUENCE "%(sequence)s" MINVALUE 0 INCREMENT BY '||cval;
-        SELECT "%(sequence)s".nextval INTO cval FROM dual;
-        EXECUTE IMMEDIATE 'ALTER SEQUENCE "%(sequence)s" INCREMENT BY 1';
+        EXECUTE IMMEDIATE 'ALTER SEQUENCE %(sequence)s MINVALUE 0 INCREMENT BY '||cval;
+        SELECT %(sequence)s.nextval INTO cval FROM dual;
+        EXECUTE IMMEDIATE 'ALTER SEQUENCE %(sequence)s INCREMENT BY 1';
     END IF;
     COMMIT;
 END;
diff --git a/django/db/backends/oracle/creation.py b/django/db/backends/oracle/creation.py
--- a/django/db/backends/oracle/creation.py
+++ b/django/db/backends/oracle/creation.py
@@ -40,9 +40,35 @@
         'URLField':                     'VARCHAR2(%(max_length)s)',
     }
 
+    def sql_create_schema(self, schema, style, password=None,
+                          tablespace=None, temp_tablespace=None):
+        qn = self.connection.ops.quote_name
+        lock_account = (password is None)
+        if lock_account:
+            password = schema
+        output = []
+        output.append("%s %s %s %s" % (style.SQL_KEYWORD('CREATE USER'),
+                                       qn(schema),
+                                       style.SQL_KEYWORD('IDENTIFIED BY'),
+                                       qn(password)))
+        if tablespace:
+            output.append("%s %s" % (style.SQL_KEYWORD('DEFAULT TABLESPACE'),
+                                     qn(tablespace)))
+        if temp_tablespace:
+            output.append("%s %s" % (style.SQL_KEYWORD('TEMPORARY TABLESPACE'),
+                                     qn(temp_tablespace)))
+        if lock_account:
+            output.append(style.SQL_KEYWORD('ACCOUNT LOCK'))
+        return '\n'.join(output)
+
+    def sql_destroy_schema(self, schema, style):
+        qn = self.connection.ops.quote_name
+        return "%s %s %s" % (style.SQL_KEYWORD('DROP USER'), qn(schema),
+                             style.SQL_KEYWORD('CASCADE'))
+
     remember = {}
 
-    def _create_test_db(self, verbosity=1, autoclobber=False):
+    def _create_test_db(self, verbosity=1, autoclobber=False, schema):
         TEST_DATABASE_NAME = self._test_database_name(settings)
         TEST_DATABASE_USER = self._test_database_user(settings)
         TEST_DATABASE_PASSWD = self._test_database_passwd(settings)
@@ -175,7 +201,7 @@
                DEFAULT TABLESPACE %(tblspace)s
                TEMPORARY TABLESPACE %(tblspace_temp)s
             """,
-            """GRANT CONNECT, RESOURCE TO %(user)s""",
+            """GRANT CONNECT, RESOURCE, CREATE USER, DROP USER, CREATE ANY TABLE, ALTER ANY TABLE, CREATE ANY INDEX, CREATE ANY SEQUENCE, CREATE ANY TRIGGER, SELECT ANY TABLE, INSERT ANY TABLE, UPDATE ANY TABLE, DELETE ANY TABLE TO %(user)s""",
         ]
         self._execute_statements(cursor, statements, parameters, verbosity)
 
diff --git a/django/db/backends/oracle/introspection.py b/django/db/backends/oracle/introspection.py
--- a/django/db/backends/oracle/introspection.py
+++ b/django/db/backends/oracle/introspection.py
@@ -119,3 +119,26 @@
         for row in cursor.fetchall():
             indexes[row[0]] = {'primary_key': row[1], 'unique': row[2]}
         return indexes
+
+    def schema_name_converter(self, name):
+        """Convert to lowercase for case-sensitive schema name comparison."""
+        return name.lower()
+
+    def get_schema_list(self, cursor):
+        "Returns a list of schemas that exist in the database."
+        sql = """
+        select distinct username
+        from all_users, all_objects
+        where username = owner
+        """
+        cursor.execute(sql)
+        return [schema.lower() for (schema,) in cursor]
+
+    def get_schema_table_list(self, cursor, schema):
+        "Returns a list of tables in a specific schema."
+        sql = """
+        select table_name from all_tables
+        where owner = upper(%s)
+        """
+        cursor.execute(sql, [schema])
+        return [table.lower() for (table,) in cursor]
diff --git a/django/db/backends/postgresql/creation.py b/django/db/backends/postgresql/creation.py
--- a/django/db/backends/postgresql/creation.py
+++ b/django/db/backends/postgresql/creation.py
@@ -51,10 +51,11 @@
                 tablespace_sql = ''
 
             def get_index_sql(index_name, opclass=''):
+                index_name = self.connection.ops.prep_db_index(model._meta.db_schema, index_name)
                 return (style.SQL_KEYWORD('CREATE INDEX') + ' ' +
-                        style.SQL_TABLE(qn(index_name)) + ' ' +
+                        style.SQL_TABLE(index_name) + ' ' +
                         style.SQL_KEYWORD('ON') + ' ' +
-                        style.SQL_TABLE(qn(db_table)) + ' ' +
+                        style.SQL_TABLE(model._meta.qualified_name) + ' ' +
                         "(%s%s)" % (style.SQL_FIELD(qn(f.column)), opclass) +
                         "%s;" % tablespace_sql)
 
diff --git a/django/db/backends/postgresql/introspection.py b/django/db/backends/postgresql/introspection.py
--- a/django/db/backends/postgresql/introspection.py
+++ b/django/db/backends/postgresql/introspection.py
@@ -31,6 +31,24 @@
                 AND pg_catalog.pg_table_is_visible(c.oid)""")
         return [row[0] for row in cursor.fetchall()]
 
+    def get_schema_list(self, cursor):
+        cursor.execute("""
+            SELECT DISTINCT n.nspname
+            FROM pg_catalog.pg_class c
+            LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+            WHERE c.relkind IN ('r', 'v', '')
+            AND n.nspname NOT IN ('pg_catalog', 'pg_toast', 'information_schema')""")
+        return [row[0] for row in cursor.fetchall()]
+
+    def get_schema_table_list(self, cursor, schema):
+        cursor.execute("""
+            SELECT c.relname
+            FROM pg_catalog.pg_class c
+            LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+            WHERE c.relkind IN ('r', 'v', '')
+                AND n.nspname = '%s'""" % schema)
+        return [row[0] for row in cursor.fetchall()]
+
     def get_table_description(self, cursor, table_name):
         "Returns a description of the table, with the DB-API cursor.description interface."
         cursor.execute("SELECT * FROM %s LIMIT 1" % self.connection.ops.quote_name(table_name))
diff --git a/django/db/backends/postgresql/operations.py b/django/db/backends/postgresql/operations.py
--- a/django/db/backends/postgresql/operations.py
+++ b/django/db/backends/postgresql/operations.py
@@ -52,8 +52,10 @@
             return 'HOST(%s)'
         return '%s'
 
-    def last_insert_id(self, cursor, table_name, pk_name):
-        cursor.execute("SELECT CURRVAL('\"%s_%s_seq\"')" % (table_name, pk_name))
+    def last_insert_id(self, cursor, schema_name, table_name, pk_name):
+        sequence_name = '%s_%s_seq' % (table_name, pk_name)
+        sequence_name = self.prep_db_table(schema_name, sequence_name)
+        cursor.execute("SELECT CURRVAL('%s')" % sequence_name)
         return cursor.fetchone()[0]
 
     def no_limit_value(self):
@@ -64,8 +66,17 @@
             return name # Quoting once is enough.
         return '"%s"' % name
 
+    def prep_db_table(self, db_schema, db_table):
+        qn = self.quote_name
+        if db_schema:
+            return "%s.%s" % (qn(db_schema), qn(db_table))
+        else:
+            return qn(db_table)
+
     def sql_flush(self, style, tables, sequences):
         if tables:
+            qnames = [self.prep_db_table(schema, table)
+                      for (schema, table) in tables]
             if self.postgres_version[0:2] >= (8,1):
                 # Postgres 8.1+ can do 'TRUNCATE x, y, z...;'. In fact, it *has to*
                 # in order to be able to truncate tables referenced by a foreign
@@ -73,7 +84,7 @@
                 # statement.
                 sql = ['%s %s;' % \
                     (style.SQL_KEYWORD('TRUNCATE'),
-                     style.SQL_FIELD(', '.join([self.quote_name(table) for table in tables]))
+                     style.SQL_FIELD(', '.join(qnames))
                 )]
             else:
                 # Older versions of Postgres can't do TRUNCATE in a single call, so
@@ -81,21 +92,23 @@
                 sql = ['%s %s %s;' % \
                         (style.SQL_KEYWORD('DELETE'),
                          style.SQL_KEYWORD('FROM'),
-                         style.SQL_FIELD(self.quote_name(table))
-                         ) for table in tables]
+                         style.SQL_FIELD(qname)
+                         ) for qname in qnames]
 
             # 'ALTER SEQUENCE sequence_name RESTART WITH 1;'... style SQL statements
             # to reset sequence indices
             for sequence_info in sequences:
+                schema_name = sequence_info['schema']
                 table_name = sequence_info['table']
                 column_name = sequence_info['column']
                 if column_name and len(column_name) > 0:
                     sequence_name = '%s_%s_seq' % (table_name, column_name)
                 else:
                     sequence_name = '%s_id_seq' % table_name
+                sequence_name = self.prep_db_table(schema_name, sequence_name)
                 sql.append("%s setval('%s', 1, false);" % \
                     (style.SQL_KEYWORD('SELECT'),
-                    style.SQL_FIELD(self.quote_name(sequence_name)))
+                    style.SQL_FIELD(sequence_name))
                 )
             return sql
         else:
@@ -111,25 +124,32 @@
             # if there are records (as the max pk value is already in use), otherwise set it to false.
             for f in model._meta.local_fields:
                 if isinstance(f, models.AutoField):
+                    sequence_name = qn('%s_%s_seq' % (model._meta.db_table,
+                                                      f.column)) # XXX: generic schemas support
+                    sequence_name = self.prep_db_table(model._meta.db_schema,
+                                                       sequence_name)
                     output.append("%s setval('%s', coalesce(max(%s), 1), max(%s) %s null) %s %s;" % \
                         (style.SQL_KEYWORD('SELECT'),
-                        style.SQL_FIELD(qn('%s_%s_seq' % (model._meta.db_table, f.column))),
+                        style.SQL_FIELD(sequence_name),
                         style.SQL_FIELD(qn(f.column)),
                         style.SQL_FIELD(qn(f.column)),
                         style.SQL_KEYWORD('IS NOT'),
                         style.SQL_KEYWORD('FROM'),
-                        style.SQL_TABLE(qn(model._meta.db_table))))
+                        style.SQL_TABLE(model._meta.qualified_name)))
                     break # Only one AutoField is allowed per model, so don't bother continuing.
             for f in model._meta.many_to_many:
                 if not f.rel.through:
+                    sequence_name = qn('%s_id_seq' % f.m2m_db_table()) # XXX: generic schemas support
+                    sequence_name = self.prep_db_table(f.m2m_db_schema(),
+                                                       sequence_name)
                     output.append("%s setval('%s', coalesce(max(%s), 1), max(%s) %s null) %s %s;" % \
                         (style.SQL_KEYWORD('SELECT'),
-                        style.SQL_FIELD(qn('%s_id_seq' % f.m2m_db_table())),
+                        style.SQL_FIELD(sequence_name),
                         style.SQL_FIELD(qn('id')),
                         style.SQL_FIELD(qn('id')),
                         style.SQL_KEYWORD('IS NOT'),
                         style.SQL_KEYWORD('FROM'),
-                        style.SQL_TABLE(qn(f.m2m_db_table()))))
+                        style.SQL_TABLE(qn(f.m2m_qualified_name()))))
         return output
 
     def savepoint_create_sql(self, sid):
diff --git a/django/db/backends/sqlite3/base.py b/django/db/backends/sqlite3/base.py
--- a/django/db/backends/sqlite3/base.py
+++ b/django/db/backends/sqlite3/base.py
@@ -94,7 +94,7 @@
                 (style.SQL_KEYWORD('DELETE'),
                  style.SQL_KEYWORD('FROM'),
                  style.SQL_FIELD(self.quote_name(table))
-                 ) for table in tables]
+                 ) for (_, table) in tables]
         # Note: No requirement for reset of auto-incremented indices (cf. other
         # sql_flush() implementations). Just return SQL at this point
         return sql
diff --git a/django/db/backends/sqlite3/creation.py b/django/db/backends/sqlite3/creation.py
--- a/django/db/backends/sqlite3/creation.py
+++ b/django/db/backends/sqlite3/creation.py
@@ -30,7 +30,7 @@
         'TextField':                    'text',
         'TimeField':                    'time',
     }
-    
+
     def sql_for_pending_references(self, model, style, pending_references):
         "SQLite3 doesn't support constraints"
         return []
@@ -38,8 +38,8 @@
     def sql_remove_table_constraints(self, model, references_to_delete, style):
         "SQLite3 doesn't support constraints"
         return []
-        
-    def _create_test_db(self, verbosity, autoclobber):
+
+    def _create_test_db(self, verbosity, autoclobber, schemas):
         if settings.TEST_DATABASE_NAME and settings.TEST_DATABASE_NAME != ":memory:":
             test_database_name = settings.TEST_DATABASE_NAME
             # Erase the old test database
@@ -64,7 +64,7 @@
         else:
             test_database_name = ":memory:"
         return test_database_name
-        
+
     def _destroy_test_db(self, test_database_name, verbosity):
         if test_database_name and test_database_name != ":memory:":
             # Remove the SQLite database file
diff --git a/django/db/models/base.py b/django/db/models/base.py
--- a/django/db/models/base.py
+++ b/django/db/models/base.py
@@ -611,7 +611,7 @@
             # into a pure queryset operation.
             where = ['%s %s (SELECT %s FROM %s WHERE %s=%%s)' % \
                 (qn('_order'), op, qn('_order'),
-                qn(self._meta.db_table), qn(self._meta.pk.column))]
+                self._meta.qualified_name, qn(self._meta.pk.column))]
             params = [self.pk]
             obj = self._default_manager.filter(**{order_field.name: getattr(self, order_field.attname)}).extra(where=where, params=params).order_by(order)[:1].get()
             setattr(self, cachename, obj)
diff --git a/django/db/models/fields/related.py b/django/db/models/fields/related.py
--- a/django/db/models/fields/related.py
+++ b/django/db/models/fields/related.py
@@ -752,7 +752,7 @@
         if isinstance(self.rel.to, basestring):
             target = self.rel.to
         else:
-            target = self.rel.to._meta.db_table
+            target = self.rel.to._meta.qualified_name
         cls._meta.duplicate_targets[self.column] = (target, "o2m")
 
     def contribute_to_related_class(self, cls, related):
@@ -835,6 +835,7 @@
         to = to.lower()
     meta = type('Meta', (object,), {
         'db_table': field._get_m2m_db_table(klass._meta),
+        'db_schema': field._get_m2m_db_schema(klass._meta),
         'managed': managed,
         'auto_created': klass,
         'app_label': klass._meta.app_label,
@@ -864,6 +865,7 @@
             through=kwargs.pop('through', None))
 
         self.db_table = kwargs.pop('db_table', None)
+        self.db_schema = kwargs.pop('db_schema', '')
         if kwargs['rel'].through is not None:
             assert self.db_table is None, "Cannot specify a db_table if an intermediary model is used."
 
@@ -885,6 +887,18 @@
             return util.truncate_name('%s_%s' % (opts.db_table, self.name),
                                       connection.ops.max_name_length())
 
+    def _get_m2m_db_schema(self, opts):
+        "Function that can be curried to provide the m2m schema name for this relation"
+        if self.rel.through is not None and self.rel.through._meta.db_schema:
+            return self.rel.through._meta.db_schema
+        return self.db_schema
+
+    def _get_m2m_qualified_name(self, opts):
+        "Function that can be curried to provide the qualified m2m table name for this relation"
+        schema = self._get_m2m_db_schema(opts)
+        table = self._get_m2m_db_table(opts)
+        return connection.ops.prep_db_table(schema, table)
+
     def _get_m2m_attr(self, related, attr):
         "Function that can be curried to provide the source column name for the m2m table"
         cache_attr = '_m2m_%s_cache' % attr
@@ -974,6 +988,9 @@
 
         # Set up the accessor for the m2m table name for the relation
         self.m2m_db_table = curry(self._get_m2m_db_table, cls._meta)
+        self.m2m_db_schema = curry(self._get_m2m_db_schema, cls._meta)
+        self.m2m_qualified_name = curry(self._get_m2m_qualified_name,
+                                        cls._meta)
 
         # Populate some necessary rel arguments so that cross-app relations
         # work correctly.
@@ -985,7 +1002,7 @@
         if isinstance(self.rel.to, basestring):
             target = self.rel.to
         else:
-            target = self.rel.to._meta.db_table
+            target = self.rel.to._meta.qualified_name
         cls._meta.duplicate_targets[self.column] = (target, "m2m")
 
     def contribute_to_related_class(self, cls, related):
diff --git a/django/db/models/options.py b/django/db/models/options.py
--- a/django/db/models/options.py
+++ b/django/db/models/options.py
@@ -21,7 +21,7 @@
 DEFAULT_NAMES = ('verbose_name', 'db_table', 'ordering',
                  'unique_together', 'permissions', 'get_latest_by',
                  'order_with_respect_to', 'app_label', 'db_tablespace',
-                 'abstract', 'managed', 'proxy', 'auto_created')
+                 'abstract', 'managed', 'proxy', 'auto_created', 'db_schema')
 
 class Options(object):
     def __init__(self, meta, app_label=None):
@@ -30,6 +30,8 @@
         self.module_name, self.verbose_name = None, None
         self.verbose_name_plural = None
         self.db_table = ''
+        self.db_schema = settings.DATABASE_SCHEMA
+        self.qualified_name = ''
         self.ordering = []
         self.unique_together =  []
         self.permissions =  []
@@ -104,6 +106,12 @@
             self.db_table = "%s_%s" % (self.app_label, self.module_name)
             self.db_table = truncate_name(self.db_table, connection.ops.max_name_length())
 
+        # Construct qualified table name.
+        self.qualified_name = connection.ops.prep_db_table(self.db_schema,
+                                                           self.db_table)
+        if self.qualified_name == connection.ops.quote_name(self.db_table):
+            # If unchanged, the backend doesn't support schemas.
+            self.db_schema = ''
 
     def _prepare(self, model):
         if self.order_with_respect_to:
@@ -177,6 +185,8 @@
         self.pk = target._meta.pk
         self.proxy_for_model = target
         self.db_table = target._meta.db_table
+        self.db_schema = target._meta.db_schema
+        self.qualified_name = target._meta.qualified_name
 
     def __repr__(self):
         return '<Options for %s>' % self.object_name
diff --git a/django/db/models/sql/query.py b/django/db/models/sql/query.py
--- a/django/db/models/sql/query.py
+++ b/django/db/models/sql/query.py
@@ -620,7 +620,7 @@
         might not have all the pieces in place at that time.
         """
         if not self.tables:
-            self.join((None, self.model._meta.db_table, None, None))
+            self.join((None, self.model._meta.qualified_name, None, None))
         if (not self.select and self.default_cols and not
                 self.included_inherited_models):
             self.setup_inherited_models()
@@ -720,7 +720,7 @@
         Callback used by deferred_to_columns(). The "target" parameter should
         be a set instance.
         """
-        table = model._meta.db_table
+        table = model._meta.qualified_name
         if table not in target:
             target[table] = set()
         for field in fields:
@@ -837,7 +837,8 @@
                         alias = start_alias
                     else:
                         link_field = opts.get_ancestor_link(model)
-                        alias = self.join((start_alias, model._meta.db_table,
+                        alias = self.join((start_alias,
+                                model._meta.qualified_name,
                                 link_field.column, model._meta.pk.column))
                     seen[model] = alias
             else:
@@ -900,7 +901,7 @@
                 result.append('%s%s%s' % (connector, qn(name), alias_str))
             first = False
         for t in self.extra_tables:
-            alias, unused = self.table_alias(t)
+            alias, unused = self.table_alias(qn(t))
             # Only add the alias if it's not already present (the table_alias()
             # calls increments the refcount, so an alias refcount of one means
             # this is the only reference.
@@ -1245,7 +1246,8 @@
             alias = self.tables[0]
             self.ref_alias(alias)
         else:
-            alias = self.join((None, self.model._meta.db_table, None, None))
+            alias = self.join((None, self.model._meta.qualified_name,
+                               None, None))
         return alias
 
     def count_active_tables(self):
@@ -1358,7 +1360,8 @@
                     seen[model] = root_alias
                 else:
                     link_field = opts.get_ancestor_link(model)
-                    seen[model] = self.join((root_alias, model._meta.db_table,
+                    seen[model] = self.join((root_alias,
+                            model._meta.qualified_name,
                             link_field.column, model._meta.pk.column))
         self.included_inherited_models = seen
 
@@ -1416,7 +1419,7 @@
             # what "used" specifies).
             avoid = avoid_set.copy()
             dupe_set = orig_dupe_set.copy()
-            table = f.rel.to._meta.db_table
+            table = f.rel.to._meta.qualified_name
             if nullable or f.null:
                 promote = True
             else:
@@ -1440,8 +1443,8 @@
                                 ())
                         dupe_set.add((opts, lhs_col))
                     int_opts = int_model._meta
-                    alias = self.join((alias, int_opts.db_table, lhs_col,
-                            int_opts.pk.column), exclusions=used,
+                    alias = self.join((alias, int_opts.qualified_name,
+                            lhs_col, int_opts.pk.column), exclusions=used,
                             promote=promote)
                     alias_chain.append(alias)
                     for (dupe_opts, dupe_col) in dupe_set:
@@ -1795,8 +1798,9 @@
                                     (id(opts), lhs_col), ()))
                             dupe_set.add((opts, lhs_col))
                         opts = int_model._meta
-                        alias = self.join((alias, opts.db_table, lhs_col,
-                                opts.pk.column), exclusions=exclusions)
+                        alias = self.join((alias, opts.qualified_name,
+                                           lhs_col, opts.pk.column),
+                                          exclusions=exclusions)
                         joins.append(alias)
                         exclusions.add(alias)
                         for (dupe_opts, dupe_col) in dupe_set:
@@ -1821,11 +1825,11 @@
                         (table1, from_col1, to_col1, table2, from_col2,
                                 to_col2, opts, target) = cached_data
                     else:
-                        table1 = field.m2m_db_table()
+                        table1 = field.m2m_qualified_name()
                         from_col1 = opts.pk.column
                         to_col1 = field.m2m_column_name()
                         opts = field.rel.to._meta
-                        table2 = opts.db_table
+                        table2 = opts.qualified_name
                         from_col2 = field.m2m_reverse_name()
                         to_col2 = opts.pk.column
                         target = opts.pk
@@ -1852,7 +1856,7 @@
                     else:
                         opts = field.rel.to._meta
                         target = field.rel.get_related_field()
-                        table = opts.db_table
+                        table = opts.qualified_name
                         from_col = field.column
                         to_col = target.column
                         orig_opts._join_cache[name] = (table, from_col, to_col,
@@ -1874,11 +1878,11 @@
                         (table1, from_col1, to_col1, table2, from_col2,
                                 to_col2, opts, target) = cached_data
                     else:
-                        table1 = field.m2m_db_table()
+                        table1 = field.m2m_qualified_name()
                         from_col1 = opts.pk.column
                         to_col1 = field.m2m_reverse_name()
                         opts = orig_field.opts
-                        table2 = opts.db_table
+                        table2 = opts.qualified_name
                         from_col2 = field.m2m_column_name()
                         to_col2 = opts.pk.column
                         target = opts.pk
@@ -1901,7 +1905,7 @@
                         local_field = opts.get_field_by_name(
                                 field.rel.field_name)[0]
                         opts = orig_field.opts
-                        table = opts.db_table
+                        table = opts.qualified_name
                         from_col = local_field.column
                         to_col = field.column
                         target = opts.pk
@@ -2140,7 +2144,7 @@
         self.group_by = []
         if self.connection.features.allows_group_by_pk:
             if len(self.select) == len(self.model._meta.fields):
-                self.group_by.append((self.model._meta.db_table,
+                self.group_by.append((self.model._meta.qualified_name,
                                       self.model._meta.pk.column))
                 return
 
@@ -2162,7 +2166,8 @@
         else:
             opts = self.model._meta
             if not self.select:
-                count = self.aggregates_module.Count((self.join((None, opts.db_table, None, None)), opts.pk.column),
+                count = self.aggregates_module.Count((self.join((None,
+                           opts.qualified_name, None, None)), opts.pk.column),
                                          is_summary=True, distinct=True)
             else:
                 # Because of SQL portability issues, multi-column, distinct
diff --git a/django/db/models/sql/subqueries.py b/django/db/models/sql/subqueries.py
--- a/django/db/models/sql/subqueries.py
+++ b/django/db/models/sql/subqueries.py
@@ -54,7 +54,7 @@
                             'in',
                             pk_list[offset : offset+GET_ITERATOR_CHUNK_SIZE]),
                             AND)
-                    self.do_query(related.field.m2m_db_table(), where)
+                    self.do_query(related.field.m2m_qualified_name(), where)
 
         for f in cls._meta.many_to_many:
             w1 = self.where_class()
@@ -85,7 +85,7 @@
             field = self.model._meta.pk
             where.add((Constraint(None, field.column, field), 'in',
                     pk_list[offset : offset + GET_ITERATOR_CHUNK_SIZE]), AND)
-            self.do_query(self.model._meta.db_table, where)
+            self.do_query(self.model._meta.qualified_name, where)
 
 class UpdateQuery(Query):
     """
@@ -304,12 +304,12 @@
         # going to be column names (so we can avoid the extra overhead).
         qn = self.connection.ops.quote_name
         opts = self.model._meta
-        result = ['INSERT INTO %s' % qn(opts.db_table)]
+        result = ['INSERT INTO %s' % opts.qualified_name]
         result.append('(%s)' % ', '.join([qn(c) for c in self.columns]))
         result.append('VALUES (%s)' % ', '.join(self.values))
         params = self.params
         if self.return_id and self.connection.features.can_return_id_from_insert:
-            col = "%s.%s" % (qn(opts.db_table), qn(opts.pk.column))
+            col = "%s.%s" % (opts.qualified_name, qn(opts.pk.column))
             r_fmt, r_params = self.connection.ops.return_insert_id()
             result.append(r_fmt % col)
             params = params + r_params
@@ -323,7 +323,8 @@
         if self.connection.features.can_return_id_from_insert:
             return self.connection.ops.fetch_returned_insert_id(cursor)
         return self.connection.ops.last_insert_id(cursor,
-                self.model._meta.db_table, self.model._meta.pk.column)
+                self.model._meta.db_schema, self.model._meta.db_table,
+                self.model._meta.pk.column)
 
     def insert_values(self, insert_values, raw_values=False):
         """
diff --git a/docs/ref/models/options.txt b/docs/ref/models/options.txt
--- a/docs/ref/models/options.txt
+++ b/docs/ref/models/options.txt
@@ -61,6 +61,23 @@
 aren't allowed in Python variable names -- notably, the hyphen -- that's OK.
 Django quotes column and table names behind the scenes.
 
+.. _db_schema:
+
+``db_schema``
+-------------
+
+.. attribute:: Options.db_schema
+
+.. versionadded:: 1.3
+
+The name of the database schema to use for the model. If the backend
+doesn't support multiple schemas, this option is ignored.
+
+If this is used then Django will prefix the model table names with the schema
+name. For example with MySQL Django would use ``db_schema + '.' + db_table``.
+Be aware that PostgreSQL supports different schemas within the database.
+MySQL solves the same thing by treating it as just another database.
+
 ``db_tablespace``
 -----------------
 
diff --git a/docs/ref/settings.txt b/docs/ref/settings.txt
--- a/docs/ref/settings.txt
+++ b/docs/ref/settings.txt
@@ -272,6 +272,23 @@
 The port to use when connecting to the database. An empty string means the
 default port. Not used with SQLite.
 
+.. setting:: DATABASE_SCHEMA
+
+DATABASE_SCHEMA
+---------------
+
+.. versionadded:: 1.3
+
+Default: ``''`` (Empty string)
+
+The name of the database schema to use for models. If the backend
+doesn't support multiple schemas, this option is ignored. An empty
+string means the default schema.
+
+If this is used then Django will prefix any table names with the schema name.
+The schema can be overriden on a per-model basis, for details see
+:ref:`db_schema`.
+
 .. setting:: DATABASE_USER
 
 DATABASE_USER
diff --git a/docs/topics/db/models.txt b/docs/topics/db/models.txt
--- a/docs/topics/db/models.txt
+++ b/docs/topics/db/models.txt
@@ -629,7 +629,8 @@
             verbose_name_plural = "oxen"
 
 Model metadata is "anything that's not a field", such as ordering options
-(:attr:`~Options.ordering`), database table name (:attr:`~Options.db_table`), or
+(:attr:`~Options.ordering`), database table name (:attr:`~Options.db_table`),
+custom schema for the tables (:attr:`~Options.db_schema`), or
 human-readable singular and plural names (:attr:`~Options.verbose_name` and
 :attr:`~Options.verbose_name_plural`). None are required, and adding ``class
 Meta`` to a model is completely optional.
diff --git a/tests/modeltests/schemas/__init__.py b/tests/modeltests/schemas/__init__.py
new file mode 100644
--- /dev/null
+++ b/tests/modeltests/schemas/__init__.py
@@ -0,0 +1,1 @@
+#
diff --git a/tests/modeltests/schemas/fixtures/testschema.json b/tests/modeltests/schemas/fixtures/testschema.json
new file mode 100644
--- /dev/null
+++ b/tests/modeltests/schemas/fixtures/testschema.json
@@ -0,0 +1,43 @@
+[
+    {
+        "pk": 1,
+        "model": "schemas.tag",
+        "fields": {
+            "name": "Test"
+        }
+    },
+    {
+        "pk": 1,
+        "model": "schemas.blog",
+        "fields": {
+            "name":"Test"
+        }
+    },
+    {
+        "pk": 1,
+        "model": "schemas.entry",
+        "fields": {
+            "blog": 1,
+            "title": "Test entry",
+            "tags": [1]
+        }
+    },
+    {
+        "pk": 1,
+        "model": "schemas.comment",
+        "fields": {
+            "entry": 1,
+            "text": "nice entry"
+        }
+    },
+    {
+        "pk": 2,
+        "model": "schemas.comment",
+        "fields": {
+            "entry": 1,
+            "text": "typical spam comment"
+        }
+    }
+
+
+]
diff --git a/tests/modeltests/schemas/models.py b/tests/modeltests/schemas/models.py
new file mode 100644
--- /dev/null
+++ b/tests/modeltests/schemas/models.py
@@ -0,0 +1,102 @@
+# coding: utf-8
+
+from django.db import models
+
+class Category(models.Model):
+    name = models.CharField(max_length=50)
+    
+
+class Blog(models.Model):
+    "Model in default schema"
+    name = models.CharField(max_length=50)
+
+
+class Entry(models.Model):
+    "Model in custom schema that references the default"
+    blog = models.ForeignKey(Blog)
+    title = models.CharField(max_length=50)
+    categories = models.ManyToManyField(Category)
+    
+    class Meta:
+        "using custom db_table as well"
+        db_table='schema_blog_entries'
+        db_schema = 'test_schema'
+
+
+class Comment(models.Model):
+    "Model in the custom schema that references Entry in the same schema"
+    entry = models.ForeignKey(Entry)
+    text = models.CharField(max_length=50)
+
+    class Meta:
+        db_schema = 'test_schema'
+
+
+class Tag(models.Model):
+    "Used for m2m relations"
+    name=models.CharField(max_length=20)
+    entries=models.ManyToManyField(Entry)
+
+    
+    
+__test__ = {'API_TESTS': """
+
+#Test with actual data
+# Nothing in there yet
+>>> Blog.objects.all()
+[]
+
+# Create a blog
+>>> b = Blog(name='Test')
+>>> b.save()
+
+# Verify that we got an ID
+>>> b.id
+1
+
+# Create entry
+>>> e = Entry(blog=b, title='Test entry')
+>>> e.save()
+>>> e.id
+1
+
+# Create Comments
+>>> c1 = Comment(entry=e, text='nice entry')
+>>> c1.save()
+>>> c2 = Comment(entry=e, text='really like it')
+>>> c2.save()
+
+#Retrieve the stuff again.
+>>> b2 = Blog.objects.get(id=b.id)
+>>> b==b2
+True
+
+>>> b2.entry_set.all()
+[<Entry: Entry object>]
+
+#make sure we don't break many to many relations
+>>> t = Tag(name="test")
+>>> t.save()
+>>> t.entries = [e]
+>>> t.entries.all()
+[<Entry: Entry object>]
+
+
+>>> from django.conf import settings
+>>> from django.db import connection, models
+
+# Test if we support schemas and can find the table if so
+>>> if e._meta.db_schema:
+...     tables = connection.introspection.schema_table_names(e._meta.db_schema)
+... else:
+...     tables = connection.introspection.table_names()
+>>> if connection.introspection.table_name_converter(e._meta.db_table) in tables:
+...     print "ok"
+... else:
+...     print "schema=" + e._meta.db_schema
+...     print "tables=%s" % tables
+ok
+
+
+"""
+}
diff --git a/tests/modeltests/schemas/tests.py b/tests/modeltests/schemas/tests.py
new file mode 100644
--- /dev/null
+++ b/tests/modeltests/schemas/tests.py
@@ -0,0 +1,35 @@
+# Validate that you can override the default test suite
+
+import unittest
+from models import *
+
+from django.conf import settings
+from django.db import connection, models
+
+class SampleTests(unittest.TestCase):
+    fixtures = ['testschema',]
+    VALID_ENGINES=['postgresql_psycopg2', 'postgresql', 'mysql','oracle']
+
+    def test_meta_information(self):
+        e=Entry.objects.get(id=1)
+        b = Blog.objects.get(id=1)
+        if settings.DATABASE_ENGINE in self.VALID_ENGINES:
+            self.assertEqual('test_schema', e._meta.db_schema)
+            if settings.DATABASE_SCHEMA:
+                self.assertEqual(settings.DATABASE_SCHEMA, b._meta.db_schema)
+            else:
+                self.assertFalse(b._meta.db_schema)
+        else:
+            self.assertFalse(e._meta.db_schema) #no model schema
+            self.assertFalse(b._meta.db_schema) #no global schema
+
+    def test_schema_in_m2m_declaring_model(self):
+        e = Entry.objects.get(id=1)
+        c = Category(name='Test')
+        c.save()
+        e.categories = [c]
+
+        categories= e.categories.filter(name='Test')
+
+        a = len(categories)
+        self.assertEqual(1, len(categories))
diff --git a/tests/regressiontests/introspection/tests.py b/tests/regressiontests/introspection/tests.py
--- a/tests/regressiontests/introspection/tests.py
+++ b/tests/regressiontests/introspection/tests.py
@@ -63,7 +63,7 @@
 
     def test_sequence_list(self):
         sequences = connection.introspection.sequence_list()
-        expected = {'table': Reporter._meta.db_table, 'column': 'id'}
+        expected = {'table': Reporter._meta.db_table, 'column': 'id', 'schema': ''}
         self.assert_(expected in sequences,
                      'Reporter sequence not found in sequence_list()')
 
