我有这个数据模型(我做了，所以如果有更好的方法，请告诉我(。从本质上讲，我Club可以有很多Courses.现在我想知道俱乐部的所有members和instructors。 members和instructors存储在Course模型中，Club具有对它们的引用。请参阅代码..
class Course(ndb.Model):
...
instructor_keys = ndb.KeyProperty(kind="User", repeated=True)
member_keys = ndb.KeyProperty(kind="User", repeated=True)
@property
def instructors(self):
return ndb.get_multi(self.instructor_keys)
@property
def members(self):
return filter(lambda x: x.is_active, ndb.get_multi(self.member_keys))
def add_instructor(self, instructor):
if instructor.key not in self.instructor_keys:
self.instructor_keys.append(instructor.key)
self.put()
def rm_instructor(self, instructor):
if instructor.key in self.instructor_keys:
self.instructor_keys.remove(instructor.key)
self.put()
def add_member(self, member):
if member.key not in self.member_keys:
self.member_keys.append(member.key)
self.put()
def rm_member(self, member):
if member.key in self.member_keys:
self.member_keys.remove(member.key)
self.put()
和
class Club(ndb.Model):
...
owners_keys = ndb.KeyProperty(kind="User", repeated=True)
course_keys = ndb.KeyProperty(kind="Course", repeated=True)
@property
def members(self):
# TODO: is this correct? efficient?
l_members = []
for courses in self.courses:
l_members = l_members + courses.members
return l_members
@property
def trainers(self):
l_trainers = []
for courses in self.courses:
l_trainers = l_trainers + courses.trainers
return l_trainers
@property
def owners(self):
return ndb.get_multi(self.owners_keys)
@property
def courses(self):
return filter(lambda x: x.is_active, ndb.get_multi(self.course_keys))
def add_owner(self, owner):
if owner.key not in self.owners_keys:
self.owner_keys.append(owner.key)
self.put()
def rm_owner(self, owner):
if owner.key in self.owners_keys:
self.owner_keys.remove(owner.key)
self.put()
def add_course(self, course):
if course.key not in self.courses_keys:
self.course_keys.append(course.key)
self.put()
def rm_course(self, course):
if course.key in self.courses_keys:
self.course_keys.remove(course.key)
self.put()
def membership_type(self, user):
if user.key in self.owners_keys:
return "OWNER"
elif user in self.members:
return "MEMBER"
elif user in self.trainers:
return "TRAINER"
else:
raise Exception("The user %s is not in the club %s" % (user.id, self.id))
现在，Course上的@property对我来说似乎还可以。(我说的对吗？但Club中的那个似乎效率很低。每次我都必须迭代所有Courses来计算members和trainers。此外，这些方法不会缓存，而是每次都计算。所以如果它非常昂贵。
有什么建议吗？我正在考虑将instructors和members作为Club中的密钥列表，并在每次将某人添加到Course时更新俱乐部，但不确定它是否正确。
PS：有没有更好的方法也可以ndb.get_multi filter？
我会尝试规范化您的模型，而不是使用非规范化的模型：
class CourseInscription(ndb.Model):
member = ndb.KeyProperty(kind='User', required=True)
course = ndb.KeyProperty(kind='Course', required=True)
is_active = ndb.BooleanProperty(default=True)
然后，您可以添加类似
class Course(ndb.Model):
# all the stuff already there
@property
def members(self):
return CourseInscription.query(CourseInscription.course == self.key)
通常，我更喜欢只返回查询，让调用方决定直接调用它或添加更多过滤/排序，而不是直接执行ndb.get_multi。
我通常做的另一个不错的操作是使用它们的父实体构造关系实体的 id，这样我就可以使用 get by id 轻松检查是否存在，而不必查询
class CourseInscription(ndb.Model):
# all the other stuff
@staticmethod
def build_id(user_key, course_key):
return '%s/%s' % (user_key.urlsafe(), course_key.urlsafe())
# somewhere I can create an inscription like
CourseInscription(
id=CourseInscription.build_id(user_key, course_key),
user=user_key, course=course_key, is_active=True
).put()
# somewhere else I can check if a User is in a Course by just getting... no queries needed
if ndb.Key(CourseInscription, CourseInscription.build_id(user, course)).get():
# Then the user is in the course!
else:
# then it's not
成员和讲师除了被课程引用之外，还属于俱乐部是完全有意义的。考虑到用例，会员需要在加入俱乐部提供的课程之前加入俱乐部(当然这可能同时发生(。直接引用会员/讲师(在俱乐部中(也比每次都遍历课程更有效率。您的权衡来自额外的代码维护，但在这种情况下这似乎是合理的。
关于活动课程过滤器，您可能希望考虑俱乐部的"活动"课程列表和"非活动"课程列表：一旦不再提供课程，将其移动到"非活动"列表(并将其从"活动"列表中删除(。