Django 允许你用两种方式执行原生 SQL 查询：你可以使用 Manager.raw() 来 执行原生查询并返回模型实例，或者完全不用模型层 直接执行自定义 SQL。
若管理器方法 raw() 能用于执行原生 SQL 查询，就会返回模型实例：
该方法接受一个原生 SQL 查询语句，执行它，并返回一个 django.db.models.query.RawQuerySet 实例。这个 RawQuerySet 能像普通的 QuerySet 一样被迭代获取对象实例。
最好用例子来解释。假设你有以下模型:
\nclass Person(models.Model):\n first_name = models.CharField(...)\n last_name = models.CharField(...)\n birth_date = models.DateField(...)\n然后你可以像这样执行自定义 SQL:
\n>>> for p in Person.objects.raw('SELECT * FROM myapp_person'):\n... print(p)\nJohn Smith\nJane Jones\n这个例子并不令人激动——它与运行 Person.objects.all() 完全相同。然而， raw() 有很多额外选项，使得它非常强大。
raw() 字段将查询语句中的字段映射至模型中的字段。
查询语句中的字段排序并不重要。换而言之，以下两种查询是一致的:
\n>>> Person.objects.raw('SELECT id, first_name, last_name, birth_date FROM myapp_person')\n...\n>>> Person.objects.raw('SELECT last_name, birth_date, first_name, id FROM myapp_person')\n...\n匹配是根据名字来的。这意味着你可以使用 SQL 的 AS 子句将查询语句中的字段映射至模型中的字段。所以，若你还有一些数据表包含了 Person 数据，你可以很方便的将其映射至 Person 实例:
>>> Person.objects.raw('''SELECT first AS first_name,\n... last AS last_name,\n... bd AS birth_date,\n... pk AS id,\n... FROM some_other_table''')\n只要名字对上了，模型实例就会被正确创建。
\n或者，你可以用 raw() 的 translations 参数将查询语句中的字段映射至模型中的字段。这是一个字典，将查询语句中的字段名映射至模型中的字段名。例如，上面的查询也能这样写:
>>> name_map = {'first': 'first_name', 'last': 'last_name', 'bd': 'birth_date', 'pk': 'id'}\n>>> Person.objects.raw('SELECT * FROM some_other_table', translations=name_map)\nraw() 支持索引，所以，若你只需要第一个结果就这样写:
>>> first_person = Person.objects.raw('SELECT * FROM myapp_person')[0]\n不过，索引和切片不是在数据库层面上实现的。若数据库中有非常多的 Person 对象，更搞笑的方式是在 SQL 层面使用 limit 子句:
>>> first_person = Person.objects.raw('SELECT * FROM myapp_person LIMIT 1')[0]\n也可以省略字段:
\n>>> people = Person.objects.raw('SELECT id, first_name FROM myapp_person')\n该查询返回的 Person 对象即延迟模型实例（参考 defer()）。这意味着查询语句中省略的字段按需加载。例子:
>>> for p in Person.objects.raw('SELECT id, first_name FROM myapp_person'):\n... print(p.first_name, # This will be retrieved by the original query\n... p.last_name) # This will be retrieved on demand\n...\nJohn Smith\nJane Jones\n表面上，看起来该查询同时检出了 first name 和 last name。然而，这个例子实际上执行了三次查询。只有 first names 是由 raw() 查询检出的 —— last names 是在它们被打印时按需检出。
\n只有一个字段你不能省略 —— 主键字段。Django 用主键来区分模型实例，所以必须在原生查询语句中包含主键。若你忘了包含主键会抛出 FieldDoesNotExist 异常。
你可以执行带有模型中未定义字段的查询语句。例如，我们能用 PostgreSQL 的 age() 函数 获取用户列表，他们的年龄已由数据库计算:
\n>>> people = Person.objects.raw('SELECT *, age(birth_date) AS age FROM myapp_person')\n>>> for p in people:\n... print("%s is %s." % (p.first_name, p.age))\nJohn is 37.\nJane is 42.\n...\n你总是可以用 Func() 表达式 避免使用原生 SQL 去计算注释。
\nraw()Link to this heading#如果你需要执行参数化的查询，可以使用 raw() 的 params 参数:
>>> lname = 'Doe'\n>>> Person.objects.raw('SELECT * FROM myapp_person WHERE last_name = %s', [lname])\nparams 是一个参数字典。你将用一个列表替换查询字符串中 %s 占位符，或用字典替换 %(key)s 占位符（key 被字典 key 替换），不论你使用哪个数据库引擎。这些占位符会被 params 参数的值替换。
有时候，甚至 Manager.raw() 都无法满足需求：你可能要执行不明确映射至模型的查询语句，或者就是直接执行 UPDATE， INSERT 或 DELETE 语句。
这些情况下，你总是能直接访问数据库，完全绕过模型层。
\n对象 django.db.connection 代表默认数据库连接。要使用这个数据库连接，调用 connection.cursor() 来获取一个指针对象。然后，调用 cursor.execute(sql, [params]) 来执行该 SQL 和 cursor.fetchone()，或 cursor.fetchall() 获取结果数据。
例如:
\nfrom django.db import connection\n\ndef my_custom_sql(self):\n with connection.cursor() as cursor:\n cursor.execute("UPDATE bar SET foo = 1 WHERE baz = %s", [self.baz])\n cursor.execute("SELECT foo FROM bar WHERE baz = %s", [self.baz])\n row = cursor.fetchone()\n\n return row\n要避免 SQL 注入，你绝对不能在 SQL 字符串中用引号包裹 %s 占位符。
注意，若要在查询中包含文本的百分号，你需要在传入参数使用两个百分号:
\ncursor.execute("SELECT foo FROM bar WHERE baz = '30%'")\ncursor.execute("SELECT foo FROM bar WHERE baz = '30%%' AND id = %s", [self.id])\n若你同时使用 不止一个数据库，你可以使用 django.db.connections 获取指定数据库的连接（和指针）。 django.db.connections 是一个类字典对象，它允许你通过连接别名获取指定连接:
from django.db import connections\nwith connections['my_db_alias'].cursor() as cursor:\n # Your code here...\n默认情况下，Python DB API 返回的结果不会包含字段名，这意味着你最终会收到一个 list，而不是一个 dict。要追求较少的运算和内存消耗，你可以以 dict 返回结果，通过使用如下的玩意:
def dictfetchall(cursor):\n "Return all rows from a cursor as a dict"\n columns = [col[0] for col in cursor.description]\n return [\n dict(zip(columns, row))\n for row in cursor.fetchall()\n ]\n另一个选项是使用来自 Python 标准库的 collections.namedtuple()。 namedtuple 是一个类元组对象，可以通过属性查找来访问其包含的字段；也能通过索引和迭代。结果都是不可变的，但能通过字段名或索引访问，这很实用:
from collections import namedtuple\n\ndef namedtuplefetchall(cursor):\n "Return all rows from a cursor as a namedtuple"\n desc = cursor.description\n nt_result = namedtuple('Result', [col[0] for col in desc])\n return [nt_result(*row) for row in cursor.fetchall()]\n这有个例子，介绍了三者之间的不同:
\n>>> cursor.execute("SELECT id, parent_id FROM test LIMIT 2");\n>>> cursor.fetchall()\n((54360982, None), (54360880, None))\n\n>>> cursor.execute("SELECT id, parent_id FROM test LIMIT 2");\n>>> dictfetchall(cursor)\n[{'parent_id': None, 'id': 54360982}, {'parent_id': None, 'id': 54360880}]\n\n>>> cursor.execute("SELECT id, parent_id FROM test LIMIT 2");\n>>> results = namedtuplefetchall(cursor)\n>>> results\n[Result(id=54360982, parent_id=None), Result(id=54360880, parent_id=None)]\n>>> results[0].id\n54360982\n>>> results[0][0]\n54360982\nconnection 和 cursor 实现了 PEP 249 中介绍的大部分标准 Python DB-API —— 除了 事务处理 之外。
若你并不熟悉 Python DB-API，要注意 cursor.execute() 中的 SQL 语句使用了占位符 "%s"，而不是直接在 SQL 中添加参数。若你使用这个技巧，潜在的数据库库会自动在需要时转义参数。
也要注意，Django 期望 "%s" 占位符，而 不是 "?" 占位符，后者由 SQLite Python 绑定使用。这是为了一致性和正确性。
将指针作为上下文的管理器:
\nwith connection.cursor() as c:\n c.execute(...)\n相当于:
\nc = connection.cursor()\ntry:\n c.execute(...)\nfinally:\n c.close()\n以给定名称调用数据库存储流程。要提供一个序列 (params) 或字典 (kparams) 作为输入参数。大多数数据库不支持 kparams。对于 Django 内置后端来说，只有 Oracle 支持。
例如，在一个 Oracle 数据库中指定存储流程：
\nCREATE PROCEDURE "TEST_PROCEDURE"(v_i INTEGER, v_text NVARCHAR2(10)) AS\n p_i INTEGER;\n p_text NVARCHAR2(10);\nBEGIN\n p_i := v_i;\n p_text := v_text;\n ...\nEND;\n这将调用该存储流程:
\nwith connection.cursor() as cursor:\n cursor.callproc('test_procedure', [1, 'test'])\n