blocks|key|5345080|text|如果你只想在一个“根”上存储许多“子”实体，你可以使用一个LocalStructuredProperty来包含Child模型(但这意味着它不会被索引)。在讨论嵌套结构化属性时，App+Engine+NDB+docs中对此行为有一个提示：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|5345081|5345082|尽管StructuredProperty可以重复，并且StructuredProperty可以包含另一个StructuredProperty，但请注意:如果一个结构化属性包含另一个结构化属性，则只能重复其中一个。一种解决办法是使用LocalStructuredProperty，它没有此约束(但不允许查询其属性值)。|blockquote|5345083|5345084|5345085|像这样的嵌套关系建模的另一种选择是在键上使用祖先。例如，假设您的根密钥路径是：('Root',+1)。您可以使用键('Root',+1,+'Child',+1)、('Root',+1,+'Child',+5)等在其下面添加子对象，每次都将'Child‘附加到keypath中。然后，如果您想要查询对象的子项，您可以只使用祖先查询，例如：|5345086|def+create_child(parent,+name):
++++new_child+=+Child(parent=parent.key,+name=name)
++++new_child.put()
++++return+new_child

def+get_children(parent):
++++return+Child.query(ancestor=parent.key)

class+Child(ndb.Model):
+++++name+=+ndb.StringProperty()

class+Root(ndb.Model):
+++++name+=+ndb.StringProperty()|code-block|syntax|javascript|5345087|在这一点上，您甚至不再需要Root，因为您可以分配任意的keypath，也可以使用name作为ID，这样可以存储更少的信息。|5345088|也就是说，这完全取决于你实际试图建模的是什么，这里没有足够的信息来理解你的意思。|5345089|entityMap|0|LINK|mutability|MUTABLE|url|https://developers.google.com/appengine/docs/python/ndb/properties^0|T|N|1J|5|2G|J|0|0|0|0|0|0|13|B|1L|N|29|N|0|0|D|4|15|4|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@$9|15|A|16|B|C]|$9|17|A|18|B|C]]|D|@$9|19|A|1A|1|1B]]|E|$]]|$1|F|3|-4|5|6|7|1C|8|@]|D|@]|E|$]]|$1|G|3|H|5|I|7|1D|8|@]|D|@]|E|$]]|$1|J|3|-4|5|6|7|1E|8|@]|D|@]|E|$]]|$1|K|3|-4|5|6|7|1F|8|@]|D|@]|E|$]]|$1|L|3|M|5|6|7|1G|8|@$9|1H|A|1I|B|C]|$9|1J|A|1K|B|C]|$9|1L|A|1M|B|C]]|D|@]|E|$]]|$1|N|3|O|5|P|7|1N|8|@]|D|@]|E|$Q|R]]|$1|S|3|T|5|6|7|1O|8|@$9|1P|A|1Q|B|C]|$9|1R|A|1S|B|C]]|D|@]|E|$]]|$1|U|3|V|5|6|7|1T|8|@]|D|@]|E|$]]|$1|W|3|-4|5|6|7|1U|8|@]|D|@]|E|$]]]|X|$Y|$5|Z|10|11|E|$12|13]]]]

If you just want to be able to store many 'Child' entities on a single 'Root', you can use a <code>LocalStructuredProperty</code> to contain the <code>Child</code> model instead (but this means it won't be indexed). There's a hint to this behavior in the <a href="https://developers.google.com/appengine/docs/python/ndb/properties" rel="nofollow">App Engine NDB docs</a> when it discusses nested structured properties: 

<blockquote>
 Although a StructuredProperty can be repeated and a StructuredProperty can contain another StructuredProperty, beware: if one structured property contains another, only one of them can be repeated. A work-around is to use LocalStructuredProperty, which does not have this constraint (but does not allow queries on its property values).
</blockquote>

Another option for modeling nested relationships like this would be to use ancestors on the keys. So, for example, let's say your Root key path were: <code>('Root', 1)</code>. You could add children below it with keys <code>('Root', 1, 'Child', 1)</code>, <code>('Root', 1, 'Child', 5)</code>, and so on, appending 'Child' to the keypath each time. Then, we you wanted to query for the children of an object, you could just use an ancestor query, e.g.:

<pre><code>def create_child(parent, name):
 new_child = Child(parent=parent.key, name=name)
 new_child.put()
 return new_child

def get_children(parent):
 return Child.query(ancestor=parent.key)

class Child(ndb.Model):
 name = ndb.StringProperty()

class Root(ndb.Model):
 name = ndb.StringProperty()
</code></pre>

You don't really even need to have a <code>Root</code> anymore at this point, because you can assign any arbitrary keypath, and you could also use the <code>name</code> as an ID instead and store less information.

That said, it's really completely dependent on what you're actually trying to model, there's not really enough information here to understand what you mean.

blocks|key|5345111|text|我不明白你为什么要给孩子做KeyProperty检查。你可以这样模拟你的关系：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|5345112|class+Child(ndb.Model):
++++name+=+ndb.StringProperty()

class+Root(ndb.Model):
++++name+=+ndb.StringProperty()
++++child+=+ndb.KeyProperty(repeated=True)

c1+=+Child(name="b").put()
c2+=+Child(name="c").put()
a+=+Root(child=[c1,c2]).put()+#+put+returns+the+key;+otherwise+you+would+need+c1.key()+here
children_keys+=+a.get().child+#+[Key(Child,+1234),+Key(Child,+4567)]
#+to+retrieve+the+children,+you+could+do
children+=+[+key.get()+for+key+in+children_keys+]|code-block|syntax|javascript|5345113|entityMap^0|D|B|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

I don't see why you need a <code>KeyProperty</code> on the child. You could model your relationship like so:

<pre><code>class Child(ndb.Model):
 name = ndb.StringProperty()

class Root(ndb.Model):
 name = ndb.StringProperty()
 child = ndb.KeyProperty(repeated=True)

c1 = Child(name="b").put()
c2 = Child(name="c").put()
a = Root(child=[c1,c2]).put() # put returns the key; otherwise you would need c1.key() here
children_keys = a.get().child # [Key(Child, 1234), Key(Child, 4567)]
# to retrieve the children, you could do
children = [ key.get() for key in children_keys ]
</code></pre>

blocks|key|3877013|text|记住几件事。假设您将记录想象为文件系统上的文件。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3877014|3877015|A+KeyProperty是指向另一个文件的指针。|unordered-list-item|3877016|重复属性只存储多个重复属性，在本例中根本没有理由使用结构化属性，因此我们跳过这一步。|3877017|3877018|因此，如果你让“根”对象通过一个重复的属性“包含”所有子对象，这将导致你的根文件每秒只能更新一次，并且它最终会变得太大。|3877019|因此，作为替代，您有几个选择。您可以使用use祖先查询，就像Jeff提到的那样。或者，您可以只使用所有指针并使用查询来子代任何节点的子节点：|3877020|class+Node(ndb.Model):
++++parent+=+ndb.KeyProperty(kind='Node')

++++def+get_children(self):
++++++++return+Node.query().filter(Node.parent+==+self.key)|code-block|syntax|javascript|3877021|您可以使用get_children来获取任何节点的子节点。请注意，这一部分最终是一致的，所以最近添加的节点通常不会在get_children中显示一秒钟左右。|3877022|root+=+Node(parent=None)
child1+=+Node(parent=root)
child2+=+Node(parent=root)
child3+=+Node(parent=root)
sub_child1+=+Node(parent=child1)|3877023|entityMap^0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|Z|8|@]|9|@]|A|$]]|$1|F|3|G|5|E|7|10|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|11|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|12|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|13|8|@]|9|@]|A|$]]|$1|M|3|N|5|O|7|14|8|@]|9|@]|A|$P|Q]]|$1|R|3|S|5|6|7|15|8|@]|9|@]|A|$]]|$1|T|3|U|5|O|7|16|8|@]|9|@]|A|$P|Q]]|$1|V|3|-4|5|6|7|17|8|@]|9|@]|A|$]]]|W|$]]

Keep in mind a few things. Suppose that you imagine records as being like files on your filesystem.

<ul>
<li>A KeyProperty is a pointer to another file.</li>
<li>A repeated property just stores multiple values.</li>
<li>There's no reason to use a structured property at all in this example, so let's skip that.</li>
</ul>

So, if you have the "root" object "contain" all the children via a repeated property, that'll result in you having a root file that can only be updated once every second or so, and it'll eventually grow too large.

So, in lieu of that, you have a few choices. You can use use ancestor queries, like Jeff mentioned. Or, you can just use all pointers and use a query to child any node's children:

<pre><code>class Node(ndb.Model):
 parent = ndb.KeyProperty(kind='Node')

 def get_children(self):
 return Node.query().filter(Node.parent == self.key)
</code></pre>

You can use get_children to fetch any node's children. Note that this part is eventually consistent, so recently added nodes won't necessarily show up in get_children for generally only a second or so.

<pre><code>root = Node(parent=None)
child1 = Node(parent=root)
child2 = Node(parent=root)
child3 = Node(parent=root)
sub_child1 = Node(parent=child1)
</code></pre>

blocks|key|1561869|text|由于Root和Child类型的实体几乎相同，因此我看到的您试图建模的数据是同类实体之间一对多关系的经典示例。这种关系的建模方法如下：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1561870|class+RelatedKind(ndb.Model):
++++name+=+ndb.StringProperty()
++++root+=+ndb.KeyProperty(kind="RelatedKind")|code-block|syntax|javascript|1561871|要创建实体：|1561872|a+=+RelatedKind(name='a')
a_key+=+a.put()

b+=+RelatedKind(name='b',+root=a_key)
b_key+=+b.put()

c+=+RelatedKind(name='c',+root=a_key)
c_key+=+c.put()

#+To+get+all+'child'+of+a;

child_a+=+RelatedKind.query(root+==+a_key).fetch()

print(child_a)+
#+>>>+[b_key,+c_key]|1561873|使用数据存储查询，只要使用keyproperty，就可以实现相同的建模，而不需要重复使用。|1561874|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Since the entities of the Root and Child kinds are almost the same, The data I see you are trying to model is a classic example of one-to-many relationship between entities of the same kind. The modelling for this sort of relationship is below:

<pre><code>class RelatedKind(ndb.Model):
 name = ndb.StringProperty()
 root = ndb.KeyProperty(kind="RelatedKind")
</code></pre>

To create entities:

<pre><code>a = RelatedKind(name='a')
a_key = a.put()

b = RelatedKind(name='b', root=a_key)
b_key = b.put()

c = RelatedKind(name='c', root=a_key)
c_key = c.put()

# To get all 'child' of a;

child_a = RelatedKind.query(root == a_key).fetch()

print(child_a) 
# &gt;&gt;&gt; [b_key, c_key]
</code></pre>

With datastore query, and just keyproperty, you achieve the same modelling without using repeated.

I'm quite new to ndb. This is how my structure looks like in general:

<pre><code>a = [b, c]
b = [d, e, f]
d = [g, h]
e = [k, l, m, n]
f = [o]
c = [p, r, t]
</code></pre>

I have the following model.

<pre><code>class Child(ndb.Model):
 name = ndb.StringProperty()
 child = ndb.KeyProperty(kind="Child", repeated=True)

class Root(ndb.Model):
 name = ndb.StringProperty()
 child = db.StructuredProperty(Child, repeated=True)
</code></pre>

I can't do this since ndb won't allow me to repeat it because I already repeat Child.

What would be the proper way to model this structure?

Modelling with ndb

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我是ndb的新手。这是我的结构通常的样子：a = [b, c]b = [d, e, f]d = [g, h]e = [k, l, m, n]f = [o]c = [p, r, t]我有以下的模型。class Child(ndb.Model):    name = ndb.StringProperty()    chil...

问使用ndb进行建模
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问使用ndb进行建模EN