zc.relationship 2.1

概述

索引对世界的看法非常精确：实例化需要多个指定配置的参数；并且使用索引需要你承认关系及其相关的索引值通常在索引中被令牌化。这种精确性以一些易用性为代价，换取了灵活性、强大和效率的可能性。话虽如此，索引的 API 设计要保持一致，并且基本上遵循“只有一种方法可以这样做”的原则。

            Alice
         __/     \__
    Betty           Chuck
    /   \           /   \
Duane   Edgar   Frank   Grant
  |
Howie

开始 N-向示例

为了进一步锻炼索引，我们将构建一个相对复杂的关系以进行索引。让我们假设我们正在模拟一个通用的设置，例如在上下文中 SUBJECT RELATIONSHIPTYPE OBJECT。这可以让用户定义关系类型，并在运行时对其进行索引。上下文可以是某个项目，因此我们可以说

“Fred” 在 “zope.org 重设计项目” 中“担任” “项目经理”。

映射到关系对象的部分，那将是

["Fred" (主题)] ["担任" (关系类型)] ["项目经理" (对象)] 在 ["zope.org 重设计项目" (上下文)]。

没有上下文，您仍然可以进行一些有趣的事情，例如

["Ygritte" (主题)] ["管理" (关系类型)] ["Uther" (对象)]

在我们的新示例中，我们将利用索引可以接受接口属性进行索引的事实。因此，让我们定义一个不带上下文的基本接口，然后是一个带上下文的扩展接口。

>>> from zope import interface
>>> class IRelationship(interface.Interface):
...     subjects = interface.Attribute(
...         'The sources of the relationship; the subject of the sentence')
...     relationshiptype = interface.Attribute(
...         '''unicode: the single relationship type of this relationship;
...         usually contains the verb of the sentence.''')
...     objects = interface.Attribute(
...         '''the targets of the relationship; usually a direct or
...         indirect object in the sentence''')
...
>>> class IContextAwareRelationship(IRelationship):
...     def getContext():
...         '''return a context for the relationship'''
...

现在我们将创建一个索引。为此，我们必须至少传递一个可迭代的对象，描述要索引的值。可迭代的每个项目必须是接口元素（与接口关联的 zope.interface.Attribute 或 zope.interface.Method，通常通过类似于 IRelationship['subjects'] 的拼写获得）或字典。每个字典必须具有 'element' 键，这是要索引的接口元素；或者 'callable' 键，这是在上面的简单介绍性示例中显示的可调用函数 [4]。

它还可以包含其他键来覆盖元素的默认索引行为。

元素或可调用的 __name__ 将用于在查询中引用此元素，除非字典具有 'name' 键，它必须是一个非空字符串 [5]。

除非字典具有 'multiple' 键并且其值相当于 True，否则假定元素是单个值。在我们的示例中，“subjects” 和 “objects” 可能是多个值，而 “relationshiptype” 和 “getContext” 是单个值。

默认情况下，元素的值将被标记并使用 intid 工具解析，并存储在 BTrees.IFBTree 中。如果您想要使对象标记容易与典型的 Zope 3 目录结果合并，这是一个不错的选择。如果您需要对任何元素有不同的行为，您可以为每个字典指定三个键

• ‘dump’，标记器，一个接收 (obj, index, cache) 并返回标记的可调用函数；

• ‘load’，标记解析器，一个接收 (token, index, cache) 并返回标记表示的对象的可调用函数；以及

• ‘btree’，用于存储和处理标记的 btree 模块，例如 BTrees.OOBTree。

如果您提供自定义的“dump”，几乎肯定需要提供自定义的“load”；如果您的标记不是整数，则您需要指定不同的“btree”（截至本文撰写时，为BTrees.OOBTree或BTrees.OIBTree）。

标记化函数（“dump”）必须返回同质、不可变的标记：也就是说，任何给定的标记化器只能返回可以无歧义地排序的标记，这在Python版本之间通常意味着它们都是同一类型。例如，标记化器只能返回整数，或者只能返回字符串，或者只能返回字符串元组等。用于同一索引中不同元素的标记化器可能返回不同的类型。它们也可能返回与其他标记化器相同的值，以表示不同的对象：存储是分开的。

请注意，在字典中，dump和load也可以显式地设置为None：这意味着值已经适当地用作标记。这启用了《优化关系索引使用》部分中描述的优化Optimizing relationship index use [6]。

除了类所需的单个参数外，签名还包含四个可选参数。下一个是“defaultTransitiveQueriesFactory”，允许您指定接口ITransitiveQueriesFactory中描述的可调用对象。如果没有它，传递搜索将需要每次都明确地提供一个工厂，这可能会很麻烦。索引包提供了一个简单的实现，支持在两个索引元素之后执行传递搜索（TransposingTransitiveQueriesFactory），并且本文描述了更复杂的可能传递行为，这些行为可以建模。在我们的示例中，“subjects”和“objects”是默认传递字段，因此如果Ygritte（SUBJECT）管理Uther（OBJECT），并且Uther（SUBJECT）管理Emily（OBJECT），则搜索所有那些由Ygritte传递管理的将Uther从OBJECT转换为SUBJECT并找到Uther管理Emily。类似地，为了找到Emily的所有传递管理者，Uther将在搜索中从SUBJECT转换为OBJECT[7]。

接下来三个参数“dumpRel”、“loadRel”和“relFamily”与关系标记有关。默认值假设您将使用intid标记关系，因此“dumpRel”和“loadRel”分别使用intid实用程序标记和解析；而“relFamily”默认为BTrees.IFBTree。

如果关系标记（从“findRelationshipChains”或“apply”或“findRelationshipTokenSet”或作为大多数搜索方法的过滤器中的过滤器）要与其他目录结果合并，则关系标记应基于intid，如默认值所示。例如，如果某些关系仅基于安全机制对某些用户可用，并且您保留了一个索引，那么您将希望使用基于当前用户可查看的关系标记的目录索引保留的过滤器的过滤器。

如果您无法或不愿意使用intid关系标记，标记必须仍然是上面描述的索引值标记的同质和不可变的。

最后一个参数是“family”，它实际上默认为BTrees.family32。如果您没有明确指定您的值和关系集的BTree模块，这个值将决定您是使用32位还是64位的IFBTrees [8]。

如果我们注册了IIntId实用工具并想使用默认设置，那么为我们的关系实例化索引将类似于以下：

>>> ix = index.Index(
...     ({'element': IRelationship['subjects'], 'multiple': True},
...      IRelationship['relationshiptype'],
...      {'element': IRelationship['objects'], 'multiple': True},
...      IContextAwareRelationship['getContext']),
...     index.TransposingTransitiveQueriesFactory('subjects', 'objects'))

这是一个简单的情况。几乎没有麻烦，我们就得到了一个IIndex和一个实现ITransitiveQueriesFactory的默认TransitiveQueriesFactory，它按照上述方式切换主语和对象。

>>> from zc.relationship import interfaces
>>> from zope.interface.verify import verifyObject
>>> verifyObject(interfaces.IIndex, ix)
True
>>> verifyObject(
...     interfaces.ITransitiveQueriesFactory,
...     ix.defaultTransitiveQueriesFactory)
True

然而，为了更复杂的例子，我们将更充分地利用索引的选项——我们将使用至少一个‘name’，‘dump’，‘load’和‘btree’。

• ‘subjects’和‘objects’将使用一个基于自定义整数的标记生成器。它们将共享标记，这将使我们能够使用默认的TransposingTransitiveQueriesFactory。我们可以继续使用IFBTree集，因为标记仍然是整数。

• ‘relationshiptype’将使用名称‘reltype’，并且将仅使用Unicode值作为标记，不进行转换，但进行注册检查。

• ‘getContext’将使用名称‘context’，但将继续使用intid实用工具并使用其接口的名称。我们将在稍后看到，在处理不同标记源之间的传递遍历必须谨慎处理。

我们还将使用intid实用工具来解决关系标记。请参见关系容器（和container.rst）中更改关系类型的示例，尤其是在keyref.py中。

以下是我们将用于‘subjects’和‘objects’标记的方法，接着是我们将用于‘relationshiptypes’标记的方法。

>>> lookup = {}
>>> counter = [0]
>>> prefix = '_z_token__'
>>> def dump(obj, index, cache):
...     assert (interfaces.IIndex.providedBy(index) and
...             isinstance(cache, dict)), (
...         'did not receive correct arguments')
...     token = getattr(obj, prefix, None)
...     if token is None:
...         token = counter[0]
...         counter[0] += 1
...         if counter[0] >= 2147483647:
...             raise RuntimeError("Whoa!  That's a lot of ids!")
...         assert token not in lookup
...         setattr(obj, prefix, token)
...         lookup[token] = obj
...     return token
...
>>> def load(token, index, cache):
...     assert (interfaces.IIndex.providedBy(index) and
...             isinstance(cache, dict)), (
...         'did not receive correct arguments')
...     return lookup[token]
...
>>> relTypes = []
>>> def relTypeDump(obj, index, cache):
...     assert obj in relTypes, 'unknown relationshiptype'
...     return obj
...
>>> def relTypeLoad(token, index, cache):
...     assert token in relTypes, 'unknown relationshiptype'
...     return token
...

请注意，如果我们在乎基于ZODB的持久性，这些实现是完全荒谬的：为了使其半可接受，我们应该在某个合理持久数据结构中持久化存储计数器、查找和relTypes。这只是一个演示示例。

现在我们可以创建一个索引。

正如我们的初始示例一样，我们将使用索引模块中定义的简单传递查询工厂来为我们的默认传递行为：当你想要进行传递搜索时，将‘subjects’与‘objects’进行转置，并保留所有其他内容；如果同时提供了主语和对象，则不进行任何传递搜索。

>>> from BTrees import OIBTree # could also be OOBTree
>>> ix = index.Index(
...     ({'element': IRelationship['subjects'], 'multiple': True,
...       'dump': dump, 'load': load},
...      {'element': IRelationship['relationshiptype'],
...       'dump': relTypeDump, 'load': relTypeLoad, 'btree': OIBTree,
...       'name': 'reltype'},
...      {'element': IRelationship['objects'], 'multiple': True,
...       'dump': dump, 'load': load},
...      {'element': IContextAwareRelationship['getContext'],
...       'name': 'context'}),
...     index.TransposingTransitiveQueriesFactory('subjects', 'objects'))

我们希望在系统中某个地方放置索引，以便它可以找到intid实用工具。我们将像示例的一部分一样将其添加为实用工具。只要索引有一个有效的__parent__，它自己通过传递连接到具有所需intid实用工具的站点管理器，一切应该都正常，因此不需要将其作为实用工具安装。这只是一个示例。

>>> from zope import interface
>>> sm = app.getSiteManager()
>>> sm['rel_index'] = ix
>>> import zope.interface.interfaces
>>> registry = zope.interface.interfaces.IComponentRegistry(sm)
>>> registry.registerUtility(ix, interfaces.IIndex)
>>> import transaction
>>> transaction.commit()

现在我们将创建一些代表性的对象，我们可以将它们关联起来，并创建和索引我们的第一个示例关系。

在示例中，请注意，上下文仅作为ISpecialRelationship对象的适配器可用：索引尝试将对象适配到适当的接口，如果无法适配，则认为值是空的。

>>> import persistent
>>> from zope.app.container.contained import Contained
>>> class Base(persistent.Persistent, Contained):
...     def __init__(self, name):
...         self.name = name
...     def __repr__(self):
...         return '<%s %r>' % (self.__class__.__name__, self.name)
...
>>> class Person(Base): pass
...
>>> class Role(Base): pass
...
>>> class Project(Base): pass
...
>>> class Company(Base): pass
...
>>> @interface.implementer(IRelationship)
... class Relationship(persistent.Persistent, Contained):
...     def __init__(self, subjects, relationshiptype, objects):
...         self.subjects = subjects
...         assert relationshiptype in relTypes
...         self.relationshiptype = relationshiptype
...         self.objects = objects
...     def __repr__(self):
...         return '<%r %s %r>' % (
...             self.subjects, self.relationshiptype, self.objects)
...
>>> class ISpecialRelationship(interface.Interface):
...     pass
...
>>> from zope import component
>>> @component.adapter(ISpecialRelationship)
... @interface.implementer(IContextAwareRelationship)
... class ContextRelationshipAdapter(object):
...     def __init__(self, adapted):
...         self.adapted = adapted
...     def getContext(self):
...         return getattr(self.adapted, '_z_context__', None)
...     def setContext(self, value):
...         self.adapted._z_context__ = value
...     def __getattr__(self, name):
...         return getattr(self.adapted, name)
...
>>> component.provideAdapter(ContextRelationshipAdapter)
>>> @interface.implementer(ISpecialRelationship)
... class SpecialRelationship(Relationship):
...     pass
...
>>> people = {}
>>> for p in ['Abe', 'Bran', 'Cathy', 'David', 'Emily', 'Fred', 'Gary',
...           'Heather', 'Ingrid', 'Jim', 'Karyn', 'Lee', 'Mary',
...           'Nancy', 'Olaf', 'Perry', 'Quince', 'Rob', 'Sam', 'Terry',
...           'Uther', 'Van', 'Warren', 'Xen', 'Ygritte', 'Zane']:
...     app[p] = people[p] = Person(p)
...
>>> relTypes.extend(
...     ['has the role of', 'manages', 'taught', 'commissioned'])
>>> roles = {}
>>> for r in ['Project Manager', 'Software Engineer', 'Designer',
...           'Systems Administrator', 'Team Leader', 'Mascot']:
...     app[r] = roles[r] = Role(r)
...
>>> projects = {}
>>> for p in ['zope.org redesign', 'Zope 3 manual',
...           'improved test coverage', 'Vault design and implementation']:
...     app[p] = projects[p] = Project(p)
...
>>> companies = {}
>>> for c in ['Ynod Corporation', 'HAL, Inc.', 'Zookd']:
...     app[c] = companies[c] = Company(c)
...

>>> app['fredisprojectmanager'] = rel = SpecialRelationship(
...     (people['Fred'],), 'has the role of', (roles['Project Manager'],))
>>> IContextAwareRelationship(rel).setContext(
...     projects['zope.org redesign'])
>>> ix.index(rel)
>>> transaction.commit()

令牌转换

在我们检查搜索功能之前，我们应该简要讨论索引上的标记化API。所有搜索查询都必须使用值标记，搜索结果有时可以是值或关系标记。因此，在标记和真实值之间进行转换可能很重要。索引为此目的提供了许多转换方法。

其中最重要的可能是tokenizeQuery：它接受一个查询，其中每个键和值都是索引值的名称和实际值；然后返回一个查询，其中实际值已转换为标记。例如，考虑以下示例。要可靠地显示转换有些困难（例如，我们无法知道intid标记将是什么），所以我们只显示结果值是输入的标记化版本。

>>> res = ix.tokenizeQuery(
...     {'objects': roles['Project Manager'],
...      'context': projects['zope.org redesign']})
>>> res['objects'] == dump(roles['Project Manager'], ix, {})
True
>>> from zope.app.intid.interfaces import IIntIds
>>> intids = component.getUtility(IIntIds, context=ix)
>>> res['context'] == intids.getId(projects['zope.org redesign'])
True

标记化查询可以使用resolveQuery再次解析为值。

>>> sorted(ix.resolveQuery(res).items()) # doctest: +NORMALIZE_WHITESPACE
[('context', <Project 'zope.org redesign'>),
 ('objects', <Role 'Project Manager'>)]

其他有用的转换包括 tokenizeValues，它返回给定索引名称值的可迭代标记；

>>> examples = (people['Abe'], people['Bran'], people['Cathy'])
>>> res = list(ix.tokenizeValues(examples, 'subjects'))
>>> res == [dump(o, ix, {}) for o in examples]
True

resolveValueTokens，它返回给定索引名称标记的可迭代值；

>>> list(ix.resolveValueTokens(res, 'subjects'))
[<Person 'Abe'>, <Person 'Bran'>, <Person 'Cathy'>]

tokenizeRelationship，它返回给定关系的标记；

>>> res = ix.tokenizeRelationship(rel)
>>> res == intids.getId(rel)
True

resolveRelationshipToken，它返回给定标记的关系；

>>> ix.resolveRelationshipToken(res) is rel
True

tokenizeRelationships，它返回给定关系的可迭代标记；以及

>>> app['another_rel'] = another_rel = Relationship(
...     (companies['Ynod Corporation'],), 'commissioned',
...     (projects['Vault design and implementation'],))
>>> res = list(ix.tokenizeRelationships((another_rel, rel)))
>>> res == [intids.getId(r) for r in (another_rel, rel)]
True

resolveRelationshipTokens，它返回给定标记的可迭代关系。

>>> list(ix.resolveRelationshipTokens(res)) == [another_rel, rel]
True

基本搜索

现在我们转向接口的核心：搜索。索引接口定义了几个搜索方法

• findValues 和 findValueTokens 询问“这与什么相关？”；

• findRelationshipChains 和 findRelationshipTokenChains 询问“如何相关？”，特别是对于传递搜索；

• isLinked 询问“是否存在这样的关系？”；

• findRelationshipTokenSet 询问“与我的查询匹配的哪些是转述关系？”并且特别适用于索引数据结构的底层使用；

• findRelationships 提出同样的问题，但返回关系迭代器而不是标记集；

• findValueTokenSet 询问“对于这个特定的索引名称和关系标记，哪些是值标记？”并且适用于索引数据结构的底层使用，如传递查询工厂；并且

• 标准的 zope.index 方法 apply 实质上通过查询对象拼写暴露了 findRelationshipTokenSet 和 findValueTokens 方法。

findRelationshipChains 和 findRelationshipTokenChains 是成对的方法，做相同的工作，但有和没有解析结果标记；同样，findValues 和 findValueTokens 也是以同样的方式成对。

非常重要的一点是，所有查询都必须使用标记，而不是实际对象。如上所述，索引提供了一种方法来简化这个要求，形式为 tokenizeQuery 方法，该方法将包含对象的字典转换为包含标记的字典。你将在下面看到，我们通过将 tokenizeQuery 存储在 'q' 名称中，来缩短我们的调用。

>>> q = ix.tokenizeQuery

我们已经索引了第一个示例关系——“Fred 在 zope.org 重设计中担任项目经理角色”——因此我们可以搜索它。我们将首先查看 findValues 和 findValueTokens。在这里，我们询问‘谁在 zope.org 重设计中担任项目经理角色？’我们首先使用 findValues，然后使用 findValueTokens [9]。

如果不传递查询给这些方法，则获取给定名称在 BTree 中的所有索引值（不要修改此！这是一个内部数据结构，我们直接传递它，因为您可以使用 BTree 集合操作有效地使用它）。在这种情况下，我们只索引了一个关系，因此其主题是此结果中的主题。

>>> res = ix.findValueTokens('subjects', maxDepth=1)
>>> res # doctest: +ELLIPSIS
<BTrees.IOBTree.IOBTree object at ...>
>>> [load(t, ix, {}) for t in res]
[<Person 'Fred'>]

如果我们想找到 Fred 是其主题的所有关系，我们可以使用 findRelationshipTokenSet。它与 findValueTokenSet 结合使用，有助于在您想要以其他搜索方法不支持的方式使用数据时，在相当低的级别查询索引数据结构。

findRelationshipTokenSet，给定一个包含 {indexName: token} 的单个字典，返回一个基于索引中关系 btree 家族的标记集，这些标记集不传递性地匹配它；

>>> res = ix.findRelationshipTokenSet(q({'subjects': people['Fred']}))
>>> res # doctest: +ELLIPSIS
<BTrees.IFBTree.IFTreeSet object at ...>
>>> [intids.getObject(t) for t in res]
[<(<Person 'Fred'>,) has the role of (<Role 'Project Manager'>,)>]

实际上，它等同于不带传递性和不带任何过滤器的 findRelationshipTokens 调用。

>>> res2 = ix.findRelationshipTokens(
...     q({'subjects': people['Fred']}), maxDepth=1)
>>> res2 is res
True

findRelationshipTokenSet 方法始终返回一个集合，即使查询没有结果。

>>> res = ix.findRelationshipTokenSet(q({'subjects': people['Ygritte']}))
>>> res # doctest: +ELLIPSIS
<BTrees.IFBTree.IFTreeSet object at ...>
>>> list(res)
[]

空查询返回索引中的所有关系（其他搜索方法也是如此）。

>>> res = ix.findRelationshipTokenSet({})
>>> res # doctest: +ELLIPSIS
<BTrees.IFBTree.IFTreeSet object at ...>
>>> len(res) == ix.documentCount()
True
>>> for r in ix.resolveRelationshipTokens(res):
...     if r not in ix:
...         print('oops')
...         break
... else:
...     print('correct')
...
correct

findRelationships 可以做同样的事情，但是解析关系。

>>> list(ix.findRelationships(q({'subjects': people['Fred']})))
[<(<Person 'Fred'>,) has the role of (<Role 'Project Manager'>,)>]

然而，与 findRelationshipTokens 类似，与 findRelationshipTokenSet 不同，findRelationships 可以递归地使用，如本文档的引言部分所示。

findValueTokenSet 在给定一个关系令牌和值名称的情况下，返回该关系的基于值（基于值的 btree 家族）的值令牌集。

>>> src = ix.findRelationshipTokenSet(q({'subjects': people['Fred']}))

>>> res = ix.findValueTokenSet(list(src)[0], 'subjects')
>>> res # doctest: +ELLIPSIS
<BTrees.IFBTree.IFTreeSet object at ...>
>>> [load(t, ix, {}) for t in res]
[<Person 'Fred'>]

与 findRelationshipTokenSet 和 findRelationshipTokens 类似，findValueTokenSet 等同于 findValueTokens，但不进行递归搜索或过滤。

>>> res2 = ix.findValueTokenSet(list(src)[0], 'subjects')
>>> res2 is res
True

apply 方法是 zope.index.interfaces.IIndexSearch 接口的一部分，基本上只能复制 findValueTokens 和 findRelationshipTokenSet 搜索调用。唯一额外的功能是结果始终是 IFBTree 集合：如果请求的令牌不在 IFBTree 集合中（例如，基于实例化的“btree”键），则索引将引发 ValueError。一个包装字典指定搜索的类型，值应该是搜索的参数。

在这里，我们询问 zope.org 重设计的当前已知角色。

>>> res = ix.apply({'values':
...     {'resultName': 'objects', 'query':
...         q({'reltype': 'has the role of',
...            'context': projects['zope.org redesign']})}})
>>> res # doctest: +ELLIPSIS
IFSet([...])
>>> [load(t, ix, {}) for t in res]
[<Role 'Project Manager'>]

理想情况下，这将失败，因为虽然令牌是整数，但实际上不能与基于 intid 的目录结果合并。然而，如果索引可以确定返回的集合不是 IFTreeSet 或 IFSet，则只会抱怨。

在这里，我们询问具有“具有角色”类型的关系。

>>> res = ix.apply({'relationships':
...     q({'reltype': 'has the role of'})})
>>> res # doctest: +ELLIPSIS
<BTrees.IFBTree.IFTreeSet object at ...>
>>> [intids.getObject(t) for t in res]
[<(<Person 'Fred'>,) has the role of (<Role 'Project Manager'>,)>]

在这里，我们询问 zope.org 重设计的已知关系类型。它将失败，因为结果不能表示为 IFBTree.IFTreeSet。

>>> res = ix.apply({'values':
...     {'resultName': 'reltype', 'query':
...         q({'context': projects['zope.org redesign']})}})
... # doctest: +NORMALIZE_WHITESPACE
Traceback (most recent call last):
...
ValueError: cannot fulfill `apply` interface because cannot return an
            (I|L)FBTree-based result

如果您请求关系，而这些关系未存储在 IFBTree 或 LFBTree 结构中，将引发相同类型的错误。[10]

最后的基本搜索方法 isLinked、findRelationshipTokenChains 和 findRelationshipChains 对于递归搜索最有用。我们尚未创建任何可以递归使用的关联。它们仍然可以与递归搜索一起工作，因此我们在这里作为介绍进行演示，然后在我们介绍递归关系时进一步讨论。

findRelationshipChains 和 findRelationshipTokenChains 允许您找到递归关系路径。目前一个单一的关系——一个单一的点——无法形成很大的线。所以，首先，这里是一个有点无用的例子

>>> [[intids.getObject(t) for t in path] for path in
...  ix.findRelationshipTokenChains(
...     q({'reltype': 'has the role of'}))]
... # doctest: +NORMALIZE_WHITESPACE
[[<(<Person 'Fred'>,) has the role of (<Role 'Project Manager'>,)>]]

这是无用的，因为没有机会进行递归搜索，所以最好使用 findRelationshipTokenSet。这将在稍后变得更有趣。

这是使用 findRelationshipChains 的相同示例，它自己解析关系令牌。

>>> list(ix.findRelationshipChains(q({'reltype': 'has the role of'})))
... # doctest: +NORMALIZE_WHITESPACE
[(<(<Person 'Fred'>,) has the role of (<Role 'Project Manager'>,)>,)]

isLinked 如果至少有一条路径匹配搜索，则返回布尔值——实际上，实现基本上是

try:
    iter(ix.findRelationshipTokenChains(...args...)).next()
except StopIteration:
    return False
else:
    return True

所以，我们可以说

>>> ix.isLinked(q({'subjects': people['Fred']}))
True
>>> ix.isLinked(q({'subjects': people['Gary']}))
False
>>> ix.isLinked(q({'subjects': people['Fred'],
...                'reltype': 'manages'}))
False

这本身就有一定的实用性，可以用来测试基本的断言。它也可以用于递归搜索，如下文所示。

与传递搜索一起工作

也可以进行传递搜索。这可以让你找到所有传递上司或下属，在我们的“管理”关系类型中。让我们设置一些示例关系。用字母代表我们的人，我们将创建三个这样的层次结构

    A        JK           R
   / \      /  \
  B   C    LM   NOP     S T U
 / \  |     |          /| |  \
D  E  F     Q         V W X   |
|     |                    \--Y
H     G                       |
|                             Z
I

这意味着，例如，人“A”（“Abe”）管理“B”（“Bran”）和“C”（“Cathy”）。

我们已经有了Abe到Bran的关系，所以我们将只添加剩余的。

>>> relmap = (
...     ('A', 'C'), ('B', 'D'), ('B', 'E'), ('C', 'F'),
...     ('F', 'G'), ('D', 'H'), ('H', 'I'), ('JK', 'LM'), ('JK', 'NOP'),
...     ('LM', 'Q'), ('R', 'STU'), ('S', 'VW'), ('T', 'X'), ('UX', 'Y'),
...     ('Y', 'Z'))
>>> letters = dict((name[0], ob) for name, ob in people.items())
>>> for subs, obs in relmap:
...     subs = tuple(letters[l] for l in subs)
...     obs = tuple(letters[l] for l in obs)
...     app['%sManages%s' % (''.join(o.name for o in subs),
...                          ''.join(o.name for o in obs))] = rel = (
...         Relationship(subs, 'manages', obs))
...     ix.index(rel)
...

现在我们可以进行传递性和非传递性搜索。这里有一些例子。

>>> [load(t, ix, {}) for t in ix.findValueTokens(
...     'subjects',
...     q({'objects': people['Ingrid'],
...        'reltype': 'manages'}))
...     ]
[<Person 'Heather'>, <Person 'David'>, <Person 'Bran'>, <Person 'Abe'>]

这里是使用findValues做的同样的事情。

>>> list(ix.findValues(
...     'subjects',
...     q({'objects': people['Ingrid'],
...        'reltype': 'manages'})))
[<Person 'Heather'>, <Person 'David'>, <Person 'Bran'>, <Person 'Abe'>]

请注意，它们是有序的，从搜索起点离开。它也是广度优先的—例如，看看Zane的上级列表：Xen和Uther排在Rob和Terry之前。

>>> res = list(ix.findValues(
...     'subjects',
...     q({'objects': people['Zane'], 'reltype': 'manages'})))
>>> res[0]
<Person 'Ygritte'>
>>> sorted(repr(p) for p in res[1:3])
["<Person 'Uther'>", "<Person 'Xen'>"]
>>> sorted(repr(p) for p in res[3:])
["<Person 'Rob'>", "<Person 'Terry'>"]

请注意，在遍历过程中保持搜索的所有元素—只有转置的值会改变，其余的保持静态。例如，请注意这两个结果之间的区别。

>>> [load(t, ix, {}) for t in ix.findValueTokens(
...     'objects',
...     q({'subjects': people['Cathy'], 'reltype': 'manages'}))]
[<Person 'Fred'>, <Person 'Gary'>]
>>> res = [load(t, ix, {}) for t in ix.findValueTokens(
...     'objects',
...     q({'subjects': people['Cathy']}))]
>>> res[0]
<Person 'Fred'>
>>> sorted(repr(i) for i in res[1:])
["<Person 'Gary'>", "<Role 'Project Manager'>"]

第一次搜索得到了我们预期的管理关系类型的结果—从Cathy出发，关系类型保持不变，我们只得到了Gary的下属。第二次搜索没有指定关系类型，因此传递搜索包括了第一个添加的角色（Fred是zope.org重设计的项目经理）。

maxDepth参数允许控制搜索多远。例如，如果我们只想搜索Bran的下属至多两步深，我们可以这样做

>>> res = [load(t, ix, {}) for t in ix.findValueTokens(
...     'objects',
...     q({'subjects': people['Bran']}),
...     maxDepth=2)]
>>> sorted(repr(i) for i in res)
["<Person 'David'>", "<Person 'Emily'>", "<Person 'Heather'>"]

对findValues来说也是一样。

>>> res = list(ix.findValues(
...     'objects',
...     q({'subjects': people['Bran']}), maxDepth=2))
>>> sorted(repr(i) for i in res)
["<Person 'David'>", "<Person 'Emily'>", "<Person 'Heather'>"]

也可以通过使用下面将要描述的targetFilter参数来实现最小深度—即必须遍历的关系数量，以便得到结果。现在，我们将按照参数列表的顺序继续，所以下一个是filter。

filter参数接受一个提供interfaces.IFilter的对象（如函数）。如接口列表所示，它接收当前的关系令牌链（“relchain”）、启动搜索的原始查询（“query”）、索引对象（“index”）以及在整个搜索过程中使用并在之后丢弃的字典，可以用于优化（“cache”）。它应该返回一个布尔值，该值确定是否应该使用给定的relchain—遍历或返回。例如，如果安全规定当前用户只能看到某些关系，则可以使用过滤器来仅使可用的关系可遍历。其他用途包括仅获取在给定时间之后创建的关系或具有某些注释的关系（在解析令牌后可用）。

让我们看一个只允许给定集合中关系的过滤器示例，就像基于安全的过滤器可能工作的方式一样。然后我们将使用它来模拟当前用户除了Xen之外，看不到Ygritte被Uther管理的情况。

>>> s = set(intids.getId(r) for r in app.values()
...         if IRelationship.providedBy(r))
>>> relset = list(
...     ix.findRelationshipTokenSet(q({'subjects': people['Xen']})))
>>> len(relset)
1
>>> s.remove(relset[0])
>>> dump(people['Uther'], ix, {}) in list(
...     ix.findValueTokens('subjects', q({'objects': people['Ygritte']})))
True
>>> dump(people['Uther'], ix, {}) in list(ix.findValueTokens(
...     'subjects', q({'objects': people['Ygritte']}),
...     filter=lambda relchain, query, index, cache: relchain[-1] in s))
False
>>> people['Uther'] in list(
...     ix.findValues('subjects', q({'objects': people['Ygritte']})))
True
>>> people['Uther'] in list(ix.findValues(
...     'subjects', q({'objects': people['Ygritte']}),
...     filter=lambda relchain, query, index, cache: relchain[-1] in s))
False

接下来两个搜索参数是targetQuery和targetFilter。它们都是对搜索方法输出的过滤器，而不会影响遍历/搜索过程。targetQuery接受与主查询相同的查询，而targetFilter接受与filter参数相同的IFilter。targetFilter可以完成targetQuery的所有工作，但targetQuery使得一个常见的情况——想要找到两个对象之间的路径，或者两个对象是否相互链接，例如——变得方便。

我们暂时跳过targetQuery（当我们重新访问findRelationshipChains和isLinked时我们将回来），看看targetFilter。targetFilter可用于许多任务，例如仅返回具有特殊注释关系的值，或者仅返回在两阶段搜索中穿越了一定枢纽关系的值，或其他任务。然而，一个非常简单的任务就是有效地指定最小遍历深度。在这里，我们找到正好在Bran下方两步的人，不多也不少。我们做了两次，一次使用findValueTokens，一次使用findValues。

>>> [load(t, ix, {}) for t in ix.findValueTokens(
...     'objects', q({'subjects': people['Bran']}), maxDepth=2,
...     targetFilter=lambda relchain, q, i, c: len(relchain)>=2)]
[<Person 'Heather'>]
>>> list(ix.findValues(
...     'objects', q({'subjects': people['Bran']}), maxDepth=2,
...     targetFilter=lambda relchain, q, i, c: len(relchain)>=2))
[<Person 'Heather'>]

Heather是唯一一个正好在Bran下方两步的人。

注意，我们指定了maxDepth和targetFilter。我们可以通过指定targetFilter为len(relchain)==2而没有maxDepth来获得相同的结果，但是它们在效率上有一个重要的区别。maxDepth和filter可以减少索引的工作量，因为它们可以在达到最大深度或失败过滤器后停止搜索；targetFilter和targetQuery参数只是隐藏了获得的结果，这可以在getValues的情况下减少一点工作量，但通常不会减少任何遍历工作量。

搜索方法的最后一个参数是transitiveQueriesFactory。这是一个在搜索期间替换索引默认遍历工厂的强工具。这允许为单个搜索进行自定义遍历，并可以支持许多高级用例。例如，我们的索引假设您想要遍历对象和来源，并且上下文应该是恒定的；这可能不是始终希望的遍历行为。如果我们有一个关系PERSON1教授PERSON2（PERSON3的课程），那么要找到任何给定人的老师，您可能想遍历PERSON1，但有时您可能还想遍历PERSON3。您可以通过提供不同的工厂来更改此行为。

为了展示这个例子，我们需要添加一些更多关系。我们将说Mary教授RobAbe的课程；Olaf教授ZaneBran的课程；Cathy教授BranLee的课程；David教授AbeZane的课程；Emily教授MaryYgritte的课程。

在图中，左侧线条表示“教授”，右侧线条表示“课程”，所以

E   Y
 \ /
  M

应读作“Emily教授MaryYgritte的课程”。这是完整的图表

          C   L
           \ /
        O   B
         \ /
E   Y D   Z
 \ /   \ /
  M     A
   \   /
    \ /
     R

您可以看到，Rob的老师间接路径是Mary和Emily，但Rob的课程间接路径是Abe、Zane、Bran和Lee。

当间接遍历跨越标记类型时，间接查询工厂必须做额外的工作。我们之前已经使用TransposingTransitiveQueriesFactory构建了我们的转置器，但现在我们需要编写一个自定义的，它翻译标记（哦！一个TokenTranslatingTransitiveQueriesFactory！……也许我们不会走到这一步……）。

我们将添加关系，构建自定义间接工厂，然后再次进行两次搜索工作，一次使用findValueTokens，一次使用findValues。

>>> for triple in ('EMY', 'MRA', 'DAZ', 'OZB', 'CBL'):
...     teacher, student, source = (letters[l] for l in triple)
...     rel = SpecialRelationship((teacher,), 'taught', (student,))
...     app['%sTaught%sTo%s' % (
...         teacher.name, source.name, student.name)] = rel
...     IContextAwareRelationship(rel).setContext(source)
...     ix.index_doc(intids.register(rel), rel)
...

>>> def transitiveFactory(relchain, query, index, cache):
...     dynamic = cache.get('dynamic')
...     if dynamic is None:
...         intids = cache['intids'] = component.getUtility(
...             IIntIds, context=index)
...         static = cache['static'] = {}
...         dynamic = cache['dynamic'] = []
...         names = ['objects', 'context']
...         for nm, val in query.items():
...             try:
...                 ix = names.index(nm)
...             except ValueError:
...                 static[nm] = val
...             else:
...                 if dynamic:
...                     # both were specified: no transitive search known.
...                     del dynamic[:]
...                     cache['intids'] = False
...                     break
...                 else:
...                     dynamic.append(nm)
...                     dynamic.append(names[not ix])
...         else:
...             intids = component.getUtility(IIntIds, context=index)
...             if dynamic[0] == 'objects':
...                 def translate(t):
...                     return dump(intids.getObject(t), index, cache)
...             else:
...                 def translate(t):
...                     return intids.register(load(t, index, cache))
...             cache['translate'] = translate
...     else:
...         static = cache['static']
...         translate = cache['translate']
...     if dynamic:
...         for r in index.findValueTokenSet(relchain[-1], dynamic[1]):
...             res = {dynamic[0]: translate(r)}
...             res.update(static)
...             yield res

>>> [load(t, ix, {}) for t in ix.findValueTokens(
...     'subjects',
...     q({'objects': people['Rob'], 'reltype': 'taught'}))]
[<Person 'Mary'>, <Person 'Emily'>]
>>> [intids.getObject(t) for t in ix.findValueTokens(
...     'context',
...     q({'objects': people['Rob'], 'reltype': 'taught'}),
...     transitiveQueriesFactory=transitiveFactory)]
[<Person 'Abe'>, <Person 'Zane'>, <Person 'Bran'>, <Person 'Lee'>]

>>> list(ix.findValues(
...     'subjects',
...     q({'objects': people['Rob'], 'reltype': 'taught'})))
[<Person 'Mary'>, <Person 'Emily'>]
>>> list(ix.findValues(
...     'context',
...     q({'objects': people['Rob'], 'reltype': 'taught'}),
...     transitiveQueriesFactory=transitiveFactory))
[<Person 'Abe'>, <Person 'Zane'>, <Person 'Bran'>, <Person 'Lee'>]

间接查询工厂非常强大，我们在这个文档中还没有结束谈论它们：请参阅下文的“间接映射多个元素”。

我们现在已经讨论过，或者至少提到了所有可用的搜索参数。《apply方法中的'value'搜索具有与findValues相同的参数和功能，因此也可以执行这些间接技巧。让我们找到所有Karyn的下级。

>>> res = ix.apply({'values':
...     {'resultName': 'objects', 'query':
...         q({'reltype': 'manages',
...           'subjects': people['Karyn']})}})
>>> res # doctest: +ELLIPSIS
IFSet([...])
>>> sorted(repr(load(t, ix, {})) for t in res)
... # doctest: +NORMALIZE_WHITESPACE
["<Person 'Lee'>", "<Person 'Mary'>", "<Person 'Nancy'>",
 "<Person 'Olaf'>", "<Person 'Perry'>", "<Person 'Quince'>"]

当我们回到 findRelationshipChains 和 findRelationshipTokenChains 时，我们也会回到上面推迟的搜索参数：targetQuery。

findRelationshipChains 和 findRelationshipTokenChains 可以简单地找到所有路径

>>> res = [repr([intids.getObject(t) for t in path]) for path in
...  ix.findRelationshipTokenChains(
...     q({'reltype': 'manages', 'subjects': people['Jim']}
...     ))]
>>> len(res)
3
>>> sorted(res[:2]) # doctest: +NORMALIZE_WHITESPACE
["[<(<Person 'Jim'>, <Person 'Karyn'>) manages
    (<Person 'Lee'>, <Person 'Mary'>)>]",
 "[<(<Person 'Jim'>, <Person 'Karyn'>) manages
    (<Person 'Nancy'>, <Person 'Olaf'>, <Person 'Perry'>)>]"]
>>> res[2] # doctest: +NORMALIZE_WHITESPACE
"[<(<Person 'Jim'>, <Person 'Karyn'>) manages
   (<Person 'Lee'>, <Person 'Mary'>)>,
  <(<Person 'Lee'>, <Person 'Mary'>) manages
   (<Person 'Quince'>,)>]"
>>> res == [repr(list(p)) for p in
...  ix.findRelationshipChains(
...     q({'reltype': 'manages', 'subjects': people['Jim']}
...     ))]
True

就像 findValues 一样，这是一个广度优先搜索。

如果我们使用 findRelationshipChains 中的 targetQuery，可以找到两个搜索之间的所有路径。例如，考虑 Rob 和 Ygritte 之间的路径。如果要求搜索主管，findValues 搜索只会包含 Rob 一次，但这里有两个路径。这些路径可以通过 targetQuery 找到。

>>> res = [repr([intids.getObject(t) for t in path]) for path in
...  ix.findRelationshipTokenChains(
...     q({'reltype': 'manages', 'subjects': people['Rob']}),
...     targetQuery=q({'objects': people['Ygritte']}))]
>>> len(res)
2
>>> sorted(res[:2]) # doctest: +NORMALIZE_WHITESPACE
["[<(<Person 'Rob'>,) manages
    (<Person 'Sam'>, <Person 'Terry'>, <Person 'Uther'>)>,
   <(<Person 'Terry'>,) manages (<Person 'Xen'>,)>,
   <(<Person 'Uther'>, <Person 'Xen'>) manages (<Person 'Ygritte'>,)>]",
 "[<(<Person 'Rob'>,) manages
    (<Person 'Sam'>, <Person 'Terry'>, <Person 'Uther'>)>,
   <(<Person 'Uther'>, <Person 'Xen'>) manages (<Person 'Ygritte'>,)>]"]

这是一个没有结果的查询

>>> len(list(ix.findRelationshipTokenChains(
...     q({'reltype': 'manages', 'subjects': people['Rob']}),
...     targetQuery=q({'objects': companies['Zookd']}))))
0

您可以将 targetQuery 与 targetFilter 结合使用。这里我们随意说我们正在寻找一条在 Rob 和 Ygritte 之间至少有 3 个链接的路径。

>>> res = [repr([intids.getObject(t) for t in path]) for path in
...  ix.findRelationshipTokenChains(
...     q({'reltype': 'manages', 'subjects': people['Rob']}),
...     targetQuery=q({'objects': people['Ygritte']}),
...     targetFilter=lambda relchain, q, i, c: len(relchain)>=3)]
>>> len(res)
1
>>> res # doctest: +NORMALIZE_WHITESPACE
["[<(<Person 'Rob'>,) manages
    (<Person 'Sam'>, <Person 'Terry'>, <Person 'Uther'>)>,
   <(<Person 'Terry'>,) manages (<Person 'Xen'>,)>,
   <(<Person 'Uther'>, <Person 'Xen'>) manages (<Person 'Ygritte'>,)>]"]

isLinked 与所有其他传递性方法具有相同的参数。例如，Rob 和 Ygritte 是传递性链接，但 Abe 和 Zane 不是。

>>> ix.isLinked(
...     q({'reltype': 'manages', 'subjects': people['Rob']}),
...     targetQuery=q({'objects': people['Ygritte']}))
True
>>> ix.isLinked(
...     q({'reltype': 'manages', 'subjects': people['Abe']}),
...     targetQuery=q({'objects': people['Ygritte']}))
False

谎言、该死的谎言和统计数据

zope.index.interfaces.IStatistics方法实现提供了最小的可观察性。wordCount总是返回0，因为单词与这种索引无关。documentCount返回索引的关系数。

>>> ix.wordCount()
0
>>> ix.documentCount()
25

重新索引和删除关系

通常，在应用程序的生命周期中使用索引需要更改索引对象。根据zope.index接口，index_doc可以重新索引关系，unindex_doc可以移除它们，而clear可以清除整个索引。

在这里，我们将zope.org项目管理者从Fred更改为Emily。

>>> [load(t, ix, {}) for t in ix.findValueTokens(
...     'subjects',
...     q({'reltype': 'has the role of',
...       'objects': roles['Project Manager'],
...       'context': projects['zope.org redesign']}))]
[<Person 'Fred'>]
>>> rel = intids.getObject(list(ix.findRelationshipTokenSet(
...     q({'reltype': 'has the role of',
...       'objects': roles['Project Manager'],
...       'context': projects['zope.org redesign']})))[0])
>>> rel.subjects = (people['Emily'],)
>>> ix.index_doc(intids.register(rel), rel)
>>> q = ix.tokenizeQuery
>>> [load(t, ix, {}) for t in ix.findValueTokens(
...     'subjects',
...     q({'reltype': 'has the role of',
...       'objects': roles['Project Manager'],
...       'context': projects['zope.org redesign']}))]
[<Person 'Emily'>]

在这里，我们移除了导致“国王伪装”场景中Abe循环的关系。

>>> res = list(ix.findRelationshipTokenChains(
...     q({'objects': people['Ingrid'],
...        'reltype': 'manages'})))
>>> len(res)
8
>>> len(res[7])
8
>>> interfaces.ICircularRelationshipPath.providedBy(res[7])
True
>>> rel = intids.getObject(list(ix.findRelationshipTokenSet(
...     q({'subjects': people['Gary'], 'reltype': 'manages',
...        'objects': people['Abe']})))[0])
>>> ix.unindex(rel) # == ix.unindex_doc(intids.getId(rel))
>>> ix.documentCount()
24
>>> res = list(ix.findRelationshipTokenChains(
...     q({'objects': people['Ingrid'], 'reltype': 'manages'})))
>>> len(res)
4
>>> len(res[3])
4
>>> interfaces.ICircularRelationshipPath.providedBy(res[3])
False

最后，我们清除了整个索引。

>>> ix.clear()
>>> ix.documentCount()
0
>>> list(ix.findRelationshipTokenChains(
...     q({'objects': people['Ingrid'], 'reltype': 'manages'})))
[]
>>> [load(t, ix, {}) for t in ix.findValueTokens(
...     'subjects',
...     q({'reltype': 'has the role of',
...       'objects': roles['Project Manager'],
...       'context': projects['zope.org redesign']}))]
[]

优化关系索引的使用

索引中集成了三个优化机会。

• 使用缓存来加载和保存标记；

• 不加载或保存标记（值本身可能用作标记）；并且

• 返回值与结果家族属于同一btree家族。

对于某些操作，尤其是当单个关系值有数百或数千个成员时，这些优化可以使一些常见的重新索引工作速度提高约100倍。

最简单（可能也是最不实用）的优化是，所有由单个操作生成的保存调用和加载调用共享一个调用类型（保存/加载）的缓存字典。例如，我们可以存储intids实用工具，这样我们只需要进行一次实用工具查找，之后它只是一个字典查找。这正是index.py中默认的generateToken和resolveToken函数所做的事情：看看它们作为例子。

另一种优化是不加载或保存标记，而使用可能是标记的值。如果标记在C中有__cmp__（或等效），例如内置类型如int，这将特别有用。为了指定这种行为，你可以创建一个索引，将索引属性描述的“加载”和“保存”值显式设置为None。

>>> ix = index.Index(
...     ({'element': IRelationship['subjects'], 'multiple': True,
...       'dump': None, 'load': None},
...      {'element': IRelationship['relationshiptype'],
...       'dump': relTypeDump, 'load': relTypeLoad, 'btree': OIBTree,
...       'name': 'reltype'},
...      {'element': IRelationship['objects'], 'multiple': True,
...       'dump': None, 'load': None},
...      {'element': IContextAwareRelationship['getContext'],
...       'name': 'context'}),
...     index.TransposingTransitiveQueriesFactory('subjects', 'objects'))
...
>>> sm['rel_index_2'] = ix
>>> app['ex_rel_1'] = rel = Relationship((1,), 'has the role of', (2,))
>>> ix.index(rel)
>>> list(ix.findValueTokens('objects', {'subjects': 1}))
[2]

最后，如果您有与特定属性存储的BTree相同类型的单个关系，并且该关系涉及数百或数千个对象，那么如果值是该BTree的“倍数”，这将是一个巨大的胜利。默认的属性BTree家族是IFBTree；IOBTree也是一个不错的选择，并且可能对某些应用程序更可取。

>>> ix = index.Index(
...     ({'element': IRelationship['subjects'], 'multiple': True,
...       'dump': None, 'load': None},
...      {'element': IRelationship['relationshiptype'],
...       'dump': relTypeDump, 'load': relTypeLoad, 'btree': OIBTree,
...       'name': 'reltype'},
...      {'element': IRelationship['objects'], 'multiple': True,
...       'dump': None, 'load': None},
...      {'element': IContextAwareRelationship['getContext'],
...       'name': 'context'}),
...     index.TransposingTransitiveQueriesFactory('subjects', 'objects'))
...
>>> sm['rel_index_3'] = ix
>>> from BTrees import IFBTree
>>> app['ex_rel_2'] = rel = Relationship(
...     IFBTree.IFTreeSet((1,)), 'has the role of', IFBTree.IFTreeSet())
>>> ix.index(rel)
>>> list(ix.findValueTokens('objects', {'subjects': 1}))
[]
>>> list(ix.findValueTokens('subjects', {'objects': None}))
[1]

重新索引是可能出现一些重大改进的地方。以下操作练习了优化代码。

>>> rel.objects.insert(2)
1
>>> ix.index(rel)
>>> list(ix.findValueTokens('objects', {'subjects': 1}))
[2]
>>> rel.subjects = IFBTree.IFTreeSet((3,4,5))
>>> ix.index(rel)
>>> list(ix.findValueTokens('objects', {'subjects': 3}))
[2]

>>> rel.subjects.insert(6)
1
>>> ix.index(rel)
>>> list(ix.findValueTokens('objects', {'subjects': 6}))
[2]

>>> rel.subjects.update(range(100, 200))
100
>>> ix.index(rel)
>>> list(ix.findValueTokens('objects', {'subjects': 100}))
[2]

>>> rel.subjects = IFBTree.IFTreeSet((3,4,5,6))
>>> ix.index(rel)
>>> list(ix.findValueTokens('objects', {'subjects': 3}))
[2]

>>> rel.subjects = IFBTree.IFTreeSet(())
>>> ix.index(rel)
>>> list(ix.findValueTokens('objects', {'subjects': 3}))
[]

>>> rel.subjects = IFBTree.IFTreeSet((3,4,5))
>>> ix.index(rel)
>>> list(ix.findValueTokens('objects', {'subjects': 3}))
[2]

tokenizeValues和resolveValueTokens在没有任何加载器或保存器的情况下可以正确工作——也就是说，它们什么也不做。

>>> ix.tokenizeValues((3,4,5), 'subjects')
(3, 4, 5)
>>> ix.resolveValueTokens((3,4,5), 'subjects')
(3, 4, 5)

__contains__ 和取消索引

您可以使用__contains__测试关系是否在索引中。请注意，这使用的是实际的关系，而不是关系标记。

>>> ix = index.Index(
...     ({'element': IRelationship['subjects'], 'multiple': True,
...       'dump': dump, 'load': load},
...      {'element': IRelationship['relationshiptype'],
...       'dump': relTypeDump, 'load': relTypeLoad, 'btree': OIBTree,
...       'name': 'reltype'},
...      {'element': IRelationship['objects'], 'multiple': True,
...       'dump': dump, 'load': load},
...      {'element': IContextAwareRelationship['getContext'],
...       'name': 'context'}),
...     index.TransposingTransitiveQueriesFactory('subjects', 'objects'))
>>> ix.documentCount()
0
>>> app['fredisprojectmanager'].subjects = (people['Fred'],)
>>> ix.index(app['fredisprojectmanager'])
>>> ix.index(app['another_rel'])
>>> ix.documentCount()
2
>>> app['fredisprojectmanager'] in ix
True
>>> list(ix.findValues(
...     'subjects',
...     q({'reltype': 'has the role of',
...       'objects': roles['Project Manager'],
...       'context': projects['zope.org redesign']})))
[<Person 'Fred'>]

>>> app['another_rel'] in ix
True

>>> app['abeAndBran'] in ix
False

如前所述，您可以使用unindex(relationship)或unindex_doc(relationship token)来取消索引。

>>> ix.unindex_doc(ix.tokenizeRelationship(app['fredisprojectmanager']))
>>> app['fredisprojectmanager'] in ix
False
>>> list(ix.findValues(
...     'subjects',
...     q({'reltype': 'has the role of',
...       'objects': roles['Project Manager'],
...       'context': projects['zope.org redesign']})))
[]

>>> ix.unindex(app['another_rel'])
>>> app['another_rel'] in ix
False

根据zope.index.interfaces.IInjection定义，如果关系不在索引中，则调用unindex_doc是不执行任何操作的；unindex也同理。但apply和其他与zope.index相关的方 法是明显的例外。

>>> ix.unindex(app['abeAndBran'])
>>> ix.unindex_doc(ix.tokenizeRelationship(app['abeAndBran']))

高级用法

关系容器还可以执行其他四个高级技巧：启用搜索过滤器；允许单个关系有多个源和目标；允许关联关系；以及公开未解析的令牌结果。

    ob0
    x |x
  ob1 | x
  x   | x
  ob2 | ob3
  | x |
ob5  ob4

    ob20              (ob22, obj26)       (ob26, obj23)
    |   |\                  |                   |
  ob21  | |               obj24               obj20
  |     | |
ob22    | ob23
  |  \  |
ob25  ob24

    ob20              (ob26, obj24)       (ob26, obj23)
    |   |\                  |                   |
  ob21  | |               obj22               obj20
  |     | |                 |                   |
ob22    | ob23        (ob20, obj27)       (ob23, obj28)
  |  \  |
ob25  ob24

2.1 (2021-03-22)

• 支持Python 3.7至3.9。

• 更新到zope.component >= 5。

2.0.post1 (2018-06-19)

• 通过使用正确的ReST语法修复PyPI页面。

2.0 (2018-06-19)

2.x系列与1.x系列几乎完全兼容。一个值得注意的不兼容性不会影响关系容器的使用，并且足够小，希望不会影响任何人。

1.1 分支

支持Zope 3.4/Zope 2.11/ZODB 3.8

1.0 分支

支持Zope 3.3/Zope 2.10/ZODB 3.7