zope.keyreference

zope.keyreference bietet Objektreferenzen, die stabil gegen und Hashes zu unterstützen.
Key Referenzen für Persistent Objects
zope.keyreference.persistent.KeyReferenceToPersistent bietet eine zope.keyreference.interfaces.IKeyReference Referenz für persistente Objekte.
Schauen wir uns ein Beispiel. Zuerst werden wir einige persistente Objekte in einer Datenbank erstellen:
& Nbsp; >>> von ZODB.MappingStorage Import DB
& Nbsp; >>> import Transaktion
& Nbsp; >>> von persistent.mapping Import PersistentMapping
& Nbsp; >>> db = DB ()
& Nbsp; >>> conn = db.open ()
& Nbsp; >>> root = conn.root ()
& Nbsp; >>> root [OB1 '] = PersistentMapping ()
& Nbsp; >>> root ['OB 2'] = PersistentMapping ()
& Nbsp; >>> transaction.commit ()
Dann werden wir einige wichtige Hinweise zu erstellen:
& Nbsp; >>> von zope.keyreference.persistent Import KeyReferenceToPersistent
& Nbsp; >>> key1 = KeyReferenceToPersistent (root [OB1 '])
& Nbsp; >>> key2 = KeyReferenceToPersistent (root ['OB 2'])
Wir können die Tasten rufen, um die Objekte zu bekommen:
& Nbsp; >>> key1 () ist root [OB1 '], ist key2 () root [' OB 2 ']
& Nbsp; (True, True)
Neue Schlüssel auf die gleichen Objekte sind gleich dem alten:
& Nbsp; >>> KeyReferenceToPersistent (root [OB1 ']) == key1
& Nbsp; Wahr
und haben die gleichen Hash:
& Nbsp; >>> Hash (KeyReferenceToPersistent (root [OB1 '])) == Hash (key1)
& Nbsp; Wahr
Weitere wichtige Referenzimplementierungen werden durch ihre Schlüsseltyp-ID unterschieden. Key Verweise auf jeder Art spezifische Informationen zunächst auf ihre Schlüsseltyp und zweiten sortieren:
& Nbsp; >>> von zope.interface Importgeräte
& Nbsp; >>> von zope.keyreference.interfaces importieren IKeyReference
& Nbsp; >>> Klasse DummyKeyReference (Objekt):
& Nbsp; ... Geräte (IKeyReference)
& Nbsp; ... key_type_id = 'zope.app.keyreference.object'
& Nbsp; ... def init __ (self, obj):
& Nbsp; ... self.object = obj
& Nbsp; ... def __cmp __ (self, andere):
& Nbsp; ... wenn self.key_type_id == other.key_type_id:
& Nbsp; ... Rückkehr cmp (self.object, other.object)
& Nbsp; ... Rückkehr cmp (self.key_type_id, other.key_type_id)
& Nbsp; >>> dummy_key1 = DummyKeyReference (object ())
& Nbsp; >>> dummy_key2 = DummyKeyReference (object ())
& Nbsp; >>> dummy_key3 = DummyKeyReference (object ())
& Nbsp; >>> Tasten = [key1, dummy_key1, dummy_key2, key2, dummy_key3]
& Nbsp; >>> keys.sort ()
& Nbsp; >>> key_type_ids = [key.key_type_id für Schlüssel im Schlüssel]
& Nbsp; >>> key_type_ids [0: 3] .count ('zope.app.keyreference.object')
& Nbsp; 3
. & Nbsp; >>> key_type_ids [3:] zu zählen ("zope.app.keyreference.persistent ')
& Nbsp; 2
Wir werden die wichtigsten Referenzen in der Datenbank zu speichern:
& Nbsp; >>> root ['key1'] = key1
& Nbsp; >>> root ["key2 '] = key2
und verwenden Sie die Tasten, um die Objekte wieder zu speichern:
& Nbsp; >>> root [key1] = root [OB1 ']
& Nbsp; >>> root [key2] = root ['OB 2']
& Nbsp; >>> transaction.commit ()
Jetzt werden wir eine weitere Verbindung zu öffnen:
& Nbsp; >>> conn2 = db.open ()
Und stellen Sie sicher, dass wir die Schlüssel zum Nachschlagen von der Objekte:
& Nbsp; >>> root2 = conn2.root ()
& Nbsp; >>> key1 = root2 ['key1']
& Nbsp; >>> root2 [key1] ist root2 [OB1 ']
& Nbsp; Wahr
& Nbsp; >>> key2 = root2 ['key2']
& Nbsp; >>> root2 [key2] ist root2 ['OB 2']
& Nbsp; Wahr
und das können wir auch die Tasten rufen, um die Objekte zu bekommen:
& Nbsp; >>> key1 () ist root2 [OB1 ']
& Nbsp; Wahr
& Nbsp; >>> key2 () ist root2 ['OB 2']
& Nbsp; Wahr
Wir können nicht die wichtigen Bezugspunkt für ein Objekt, das noch nicht gespeichert wurde:
& Nbsp; >>> KeyReferenceToPersistent (PersistentMapping ())
& Nbsp; ... # doctest: + ELLIPSIS
& Nbsp; Traceback (jüngste Aufforderung zuletzt):
& Nbsp; ...
& Nbsp; NotYet: ...
Beachten Sie, dass wir ein NotYet Fehler. Dies zeigt, dass wir vielleicht in der Lage, einen wichtigen Bezugspunkt später zu bekommen.
Wir können Verweise auf gespeicherte Objekte zu erhalten, wenn sie einen Adapter, um ZODB.interfaces.IConnection haben. Das Add-Methode für die Verbindung verwendet werden, um das Objekt ein Objekt-ID, die genügend Informationen, um die Referenz zu berechnen ist, zu geben. Um dies zu sehen, werden wir ein Objekt, das in einem IConnection dumme Art und Weise erfüllt zu erstellen:
& Nbsp; >>> import anhalt
& Nbsp; >>> von ZODB.interfaces importieren IConnection
& Nbsp; >>> Klasse C (persistent.Persistent):
& Nbsp; ... def __conform __ (self, iface):
& Nbsp; ... wenn iface ist IConnection:
& Nbsp; ... Rückkehr conn2
& Nbsp; >>> OB3 = C ()
& Nbsp; >>> key3 = KeyReferenceToPersistent (OB3)
& Nbsp; >>> transaction.abort ()
Conflict Resolution
Während der Konfliktlösung, wie in ZODB / ConflictResolution.txt diskutiert, Referenzen auf persistente Objekte sind eigentlich Instanzen ZODB.ConflictResolution.PersistentReference. Dies ist relevant in zweierlei Hinsicht für KeyReferenceToPersistent. Zuerst erklärt er eine Subtilität der Klasse: sie nicht aus persistent.Persistent erben. Wenn ja, wäre es nicht zur Konfliktlösung zur Verfügung, nur seine PersistentReference Stand-in.
Zweitens erklärt es ein Teil des Codes in den __hash__ und __cmp__ Methoden. Diese Methoden nicht nur persistent.Persistent Objekte, sondern PersistentReference Objekte zu behandeln. Ohne dieses Verhalten, werden Objekte, wie dem klassischen ZODB BTrees, die KeyReferenceToPersistent als Schlüssel oder Set-Mitglieder verwenden nicht in der Lage, Konflikte zu lösen. Auch mit dem speziellen Code, in einigen Fällen die KeyReferenceToPersistent wird sich weigern, bei der Konfliktlösung zu vergleichen und Hash, weil sie nicht zuverlässig tun.
__hash__ während der Konfliktlösung relativ selten arbeiten: nur für Multidatenreferenzen. Hier sind ein paar Beispiele.
& Nbsp; >>> von ZODB.ConflictResolution Import PersistentReference
& Nbsp; >>> def Fabrik (ref):
& Nbsp; ... res = KeyReferenceToPersistent .__ neue __ (
& Nbsp; ... KeyReferenceToPersistent, ref)
& Nbsp; ... res.object = ref
& Nbsp; ... return res
& Nbsp; ...
& Nbsp; >>> Hash (Werks (PersistentReference (
& Nbsp; ... ('ein oid "," Klasse Metadaten ")))) # eine typische Referenz
& Nbsp; Traceback (jüngste Aufforderung zuletzt):
& Nbsp; ...
& Nbsp; Valueerror: Datenbankname nicht verfügbar zu diesem Zeitpunkt
& Nbsp; >>> bool (Hash (Werks (PersistentReference (
& Nbsp; ... ['m', ('eine Datenbank "," ein oid "," Klasse Metadaten')])))) # Multidaten
& Nbsp; Wahr
Das bedeutet, dass KeyReferenceToPersistent oft behindern Konfliktlösung für Klassen wie PersistentMapping.
__cmp__ arbeitet, es sei denn ein Objekt ist eine Multidatenreferenz und der andere nicht. Hier sind ein paar Beispiele.
& Nbsp; >>> cmp (Werks (PersistentReference (
& Nbsp; ... ('ein oid "," Klasse Metadaten "))),
& Nbsp; ... Fabrik (PersistentReference (
& Nbsp; ... ('ein oid "," Klasse Metadaten "))))
& Nbsp; 0
& Nbsp; >>> cmp (Werks (PersistentReference (
& Nbsp; ... ('ein oid "," Klasse Metadaten "))),
& Nbsp; ... Fabrik (PersistentReference (
& Nbsp; ... ('ein weiteres oid "," Klasse Metadaten "))))
& Nbsp; -1
& Nbsp; >>> cmp (Werks (PersistentReference ("ein oid")),
& Nbsp; ... Fabrik (PersistentReference (
& Nbsp; ... ('ein oid "," Klasse Metadaten "))))
& Nbsp; 0
& Nbsp; >>> cmp (Werks (PersistentReference ("ein oid")),
& Nbsp; ... Fabrik (PersistentReference (
& Nbsp; ... ('ein oid "," Klasse Metadaten "))))
& Nbsp; 0
& Nbsp; >>> cmp (Werks (PersistentReference (
& Nbsp; ... ['m', ('eine Datenbank "," ein oid "," Klasse Metadaten')])),
& Nbsp; ... Fabrik (PersistentReference (
& Nbsp; ... ['m', ('eine Datenbank "," ein oid "," Klasse Metadaten')])))
& Nbsp; 0
& Nbsp; >>> cmp (Werks (PersistentReference (
& Nbsp; ... ['m', ('eine Datenbank "," ein oid "," Klasse Metadaten')])),
& Nbsp; ... Fabrik (PersistentReference (
& Nbsp; ... ['n', ('eine Datenbank "," ein oid)])))
& Nbsp; 0
& Nbsp; >>> cmp (Werks (PersistentReference (
& Nbsp; ... ['m', ('eine Datenbank "," ein oid "," Klasse Metadaten')])),
& Nbsp; ... Fabrik (PersistentReference (
& Nbsp; ... ['m', ('weitere Datenbank "," ein oid "," Klasse Metadaten')])))
& Nbsp; -1
& Nbsp; >>> cmp (Werks (PersistentReference (
& Nbsp; ... ['m', ('eine Datenbank "," ein oid "," Klasse Metadaten')])),
& Nbsp; ... Fabrik (PersistentReference (
& Nbsp; ... ('ein oid "," Klasse Metadaten "))))
& Nbsp; Traceback (jüngste Aufforderung zuletzt):
& Nbsp; ...
& Nbsp; Valueerror: können sie nicht Art zuverlässig
Location-based-Anschlussadapter
Die Funktion zope.keyreference.connectionOfPersistent passt Objekten, Verbindungen mit einer einfachen standortbasierte Heuristik. Es überprüft, ob das Objekt eine __parent__, die eine Verbindung über:
& Nbsp; >>> von zope.keyreference.persistent Import connectionOfPersistent
& Nbsp; >>> OB3 = PersistentMapping ()
& Nbsp; >>> print connectionOfPersistent (OB3)
& Nbsp; Keine
& Nbsp; >>> OB3 .__ parent__ = root2 [OB1 ']
& Nbsp; >>> connectionOfPersistent (OB3) ist conn2
& Nbsp; Wahr

Was ist neu in dieser Pressemitteilung:

• Fix Tests durch Entfernen zope.testing von Test Abhängigkeiten zusammen: vermeiden die ZODB3 Modul, das es braucht.

Anforderungen :

• Python