0

例如，我对具有子类 ConceptNode 和 DerivedNode 的类 Node 使用多表继承。为了确定我正在处理的节点类型并将函数调用分发到适当的子类，我经常必须像这样调用 hasattr：

test_node = Node.objects.all()[0]

if hasattr( test_node, "conceptnode"):
    test_node.conceptnode.myFunction()
elif hasattr( test_node, "derivednode"):
    test_node.derivednode.myFunction()
else:
   raise Exception("Not a valid type.")

我注意到这会导致多个数据库查询，这加起来确实会减慢我编写的某些函数的速度。

我尝试了另一种使用 try...catch 的方法，它不会减少查询的数量。

test_node = Node.objects.all()[0]

try:
    test_node.conceptnode.myFunction()
except ObjectDoesNotExist:
    test_node.derivednode.myFunction()

我的主要问题是：django 如何确定在这里执行哪些查询？我看不到 hasattr 是如何被翻译成数据库查询的。

此外，如果有人可以建议一种更有效的方法来处理这个问题（尤其是从查询计数的角度来看），那也太好了！

编辑：为了转储执行的 sqlite 查询，我执行了以下操作：

from django.db import connection
from django import db
db.reset_queries()
hasattr(nds[0],'conceptnode')
hasattr(nds[0],'derivednode')
connection.queries

我得到了以下结果：

{'sql': u'SELECT "nodes_node"."id", "nodes_node"."name", "nodes_node"."description", "nodes_node"."node_tree_id", "nodes_node"."unique_name", "nodes_node"."last_updated_timestamp", "nodes_node"."order", "nodes_node"."data_json", "nodes_node"."data_json_synchronized" FROM "nodes_node" LIMIT 1',  'time': '0.001'}
{'sql': u'SELECT "nodes_node"."id", "nodes_node"."name", "nodes_node"."description", "nodes_node"."node_tree_id", "nodes_node"."unique_name", "nodes_node"."last_updated_timestamp", "nodes_node"."order", "nodes_node"."data_json", "nodes_node"."data_json_synchronized", "nodes_conceptnode"."node_ptr_id", "nodes_conceptnode"."node_parent_id" FROM "nodes_conceptnode" INNER JOIN "nodes_node" ON ("nodes_conceptnode"."node_ptr_id" = "nodes_node"."id") WHERE "nodes_conceptnode"."node_ptr_id" = 1 ',  'time': '0.000'}
{'sql': u'SELECT "nodes_node"."id", "nodes_node"."name", "nodes_node"."description", "nodes_node"."node_tree_id", "nodes_node"."unique_name", "nodes_node"."last_updated_timestamp", "nodes_node"."order", "nodes_node"."data_json", "nodes_node"."data_json_synchronized" FROM "nodes_node" LIMIT 1',  'time': '0.001'}
{'sql': u'SELECT "nodes_node"."id", "nodes_node"."name", "nodes_node"."description", "nodes_node"."node_tree_id", "nodes_node"."unique_name", "nodes_node"."last_updated_timestamp", "nodes_node"."order", "nodes_node"."data_json", "nodes_node"."data_json_synchronized", "nodes_derivednode"."node_ptr_id", "nodes_derivednode"."node_source_id", "nodes_derivednode"."node_target_id" FROM "nodes_derivednode" INNER JOIN "nodes_node" ON ("nodes_derivednode"."node_ptr_id" = "nodes_node"."id") WHERE "nodes_derivednode"."node_ptr_id" = 1 ',  'time': '0.000'}

其中第一个和第三个是获取原始节点对象。

4

1 回答 1

0

您有两个简单节点查找（LIMIT 1查询）的实例，因为您将查询集作为列表多次访问。

nodes = Node.objects.all()
nodes[0]
nodes[0]

触发两个查询，而：

node = Node.objects.all()[0]
node
node

触发一个。起初这看起来有点奇怪，但关键是要记住Node.objects.all()在您访问它之前不会对其进行评估（不进行查询）。

至于为什么单个对象查找运行两个查询，您使用的是多表继承。如果你的模型中有这个：

class Node(models.Model):
    pass

class ConceptNode(Node):
    pass

Django 将创建两个表，其中ConceptNode行有一个 parent Node。

您可能正在寻找的是一个抽象基类，它允许您在多个类之间共享方法和属性，同时只为每个类使用一个表。只需添加abstract = True到父类元：

class Node(models.Model):
    class Meta:
        abstract = True

最后，请注意，这两个查询几乎都不需要时间，所以我不会太担心。

于 2012-08-01T20:35:39.200 回答