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
@@ -24,7 +24,6 @@
     except ImportError, e1:
         from sqlite3 import dbapi2 as Database
 except ImportError, exc:
-    import sys
     from django.core.exceptions import ImproperlyConfigured
     if sys.version_info < (2, 5, 0):
         module = 'pysqlite2 module'
@@ -62,6 +61,10 @@
     can_use_chunked_reads = False
 
 class DatabaseOperations(BaseDatabaseOperations):
+    def __init__(self, connection):
+        super(DatabaseOperations, self).__init__()
+        self.connection = connection
+
     def date_extract_sql(self, lookup_type, field_name):
         # sqlite doesn't support extract, so we fake it with the user-defined
         # function django_extract that's registered in connect(). Note that
@@ -128,6 +131,15 @@
         # No field, or the field isn't known to be a decimal or integer
         return value
 
+    def deferrable_sql(self):
+        """
+        Returns the SQL necessary to make a constraint "initially deferred"
+        during a CREATE TABLE statement.
+        """
+        if self.connection.supports_fk_constraints:
+            return " ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED"
+        return ''
+
 class DatabaseWrapper(BaseDatabaseWrapper):
 
     # SQLite requires LIKE statements to include an ESCAPE clause if the value
@@ -154,14 +166,17 @@
         super(DatabaseWrapper, self).__init__(*args, **kwargs)
 
         self.features = DatabaseFeatures()
-        self.ops = DatabaseOperations()
+        self.ops = DatabaseOperations(self)
         self.client = DatabaseClient(self)
         self.creation = DatabaseCreation(self)
         self.introspection = DatabaseIntrospection(self)
         self.validation = BaseDatabaseValidation(self)
+        self.supports_fk_constraints = False
 
     def _cursor(self):
+        new_connection = False
         if self.connection is None:
+            new_connection = True
             settings_dict = self.settings_dict
             if not settings_dict['NAME']:
                 from django.core.exceptions import ImproperlyConfigured
@@ -177,7 +192,12 @@
             self.connection.create_function("django_date_trunc", 2, _sqlite_date_trunc)
             self.connection.create_function("regexp", 2, _sqlite_regexp)
             connection_created.send(sender=self.__class__, connection=self)
-        return self.connection.cursor(factory=SQLiteCursorWrapper)
+        cursor = self.connection.cursor(factory=SQLiteCursorWrapper)
+        if new_connection:
+            self.supports_fk_constraints = self._check_fk_constraint_support(cursor)
+            if self.supports_fk_constraints:
+                cursor.execute("PRAGMA foreign_keys = ON")
+        return cursor
 
     def close(self):
         # If database is in memory, closing the connection destroys the
@@ -186,6 +206,13 @@
         if self.settings_dict['NAME'] != ":memory:":
             BaseDatabaseWrapper.close(self)
 
+    def _check_fk_constraint_support(self, cursor):
+        cursor.execute("PRAGMA foreign_keys")
+        v = cursor.fetchone()
+        if v is None:
+            return False
+        return True
+
 FORMAT_QMARK_REGEX = re.compile(r'(?![^%])%s')
 
 class SQLiteCursorWrapper(Database.Cursor):
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
@@ -64,3 +64,27 @@
         if test_database_name and test_database_name != ":memory:":
             # Remove the SQLite database file
             os.remove(test_database_name)
+
+    def sql_for_inline_foreign_key_references(self, field, known_models, style):
+        "Return the SQL snippet defining the foreign key reference for a field"
+        if self.connection.supports_fk_constraints:
+            qn = self.connection.ops.quote_name
+            output = [style.SQL_KEYWORD('REFERENCES') + ' ' + \
+                style.SQL_TABLE(qn(field.rel.to._meta.db_table)) + ' (' + \
+                style.SQL_FIELD(qn(field.rel.to._meta.get_field(field.rel.field_name).column)) + ')' +
+                self.connection.ops.deferrable_sql()
+            ]
+            return output, False
+        return super(DatabaseCreation, self).sql_for_inline_foreign_key_references(field, known_models, style)
+
+    def sql_destroy_model(self, model, references_to_delete, style):
+        "Return the DROP TABLE and restraint dropping statements for a single model"
+        if self.connection.supports_fk_constraints:
+            if not model._meta.managed or model._meta.proxy:
+                return []
+            # 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)))]
+            return output
+        return super(DatabaseCreation, self).sql_destroy_model(model, references_to_delete, style)
