zope.keyreference

zope.keyreference nyújt objektumhivatkozásait támogató stabil összehasonlítás és a hash-eket.
Főbb referenciák perzisztens objektumok
zope.keyreference.persistent.KeyReferenceToPersistent nyújt zope.keyreference.interfaces.IKeyReference hivatkozási perzisztens objektumokat.
Nézzünk egy példát. Először hozunk létre néhány állandó objektumok ábrázolásához:
& Nbsp; >>> from ZODB.MappingStorage import DB
& Nbsp; >>> importügyletnél
& Nbsp; >>> from persistent.mapping import PersistentMapping
& Nbsp; >>> db = DB ()
& Nbsp; >>> kapcs = db.open ()
& Nbsp; >>> root = conn.root ()
& Nbsp; >>> gyökér ['OB1'] = PersistentMapping ()
& Nbsp; >>> gyökér ['OB2'] = PersistentMapping ()
& Nbsp; >>> transaction.commit ()
Akkor hozzon létre néhány kulcsfontosságú referenciák:
& Nbsp; >>> from zope.keyreference.persistent import KeyReferenceToPersistent
& Nbsp; >>> KEY1 = KeyReferenceToPersistent (root ['OB1'])
& Nbsp; >>> KEY2 = KeyReferenceToPersistent (root ['OB2 "])
Nevezhetjük a kulcsokat, hogy a tárgyak:
& Nbsp; >>> KEY1 () root ['OB1'], KEY2 () root ['OB2 "]
& Nbsp; (True, True)
Új gombokkal ugyanaz a tárgy megegyezik a régi:
& Nbsp; >>> KeyReferenceToPersistent (root ['OB1']) == KEY1
& Nbsp; True
és azonos hash-eket:
& Nbsp; >>> hash (KeyReferenceToPersistent (root ['OB1'])) == hash (KEY1)
& Nbsp; True
További fő hivatkozási implementáció különböztek a kulcs típusa id. Főbb referenciák kell rendezni előbb a gomb típusát és a második bármilyen típus-specifikus információk:
& Nbsp; >>> from zope.interface import munkagépek
& Nbsp; >>> from zope.keyreference.interfaces importálni IKeyReference
& Nbsp; >>> class DummyKeyReference (tárgy):
& Nbsp; ... munkagépek (IKeyReference)
& Nbsp; ... key_type_id = 'zope.app.keyreference.object "
& Nbsp; ... def __init __ (self, obj):
& Nbsp; ... self.object = obj
& Nbsp; ... def __cmp __ (self, egyéb):
& Nbsp; ... ha self.key_type_id == other.key_type_id:
& Nbsp; ... cserébe CMP (self.object, other.object)
& Nbsp; ... cserébe 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; >>> gombokat = [KEY1, dummy_key1, dummy_key2, KEY2, dummy_key3]
& Nbsp; >>> keys.sort ()
& Nbsp; >>> key_type_ids = [key.key_type_id a kulcs kulcsok]
& Nbsp; >>> key_type_ids [0: 3] .count ("zope.app.keyreference.object)
& Nbsp; 3
& Nbsp; >>> key_type_ids [3:]. Számíthatnak ("zope.app.keyreference.persistent)
& Nbsp; 2
Majd tároljuk a kulcsot hivatkozásokat az adatbázisban:
& Nbsp; >>> gyökér ['KEY1'] = KEY1
& Nbsp; >>> gyökér ['KEY2'] = KEY2
és használja a gombokat, hogy tárolja az objektumok újra:
& Nbsp; >>> gyökér [KEY1] = root ['OB1']
& Nbsp; >>> gyökér [KEY2] = root ['OB2 "]
& Nbsp; >>> transaction.commit ()
Most majd nyitni egy másik kapcsolatot:
& Nbsp; >>> conn2 = db.open ()
És ellenőrizze, hogy tudjuk használni a kulcsokat, hogy néz ki a tárgyakat:
& Nbsp; >>> root2 = conn2.root ()
& Nbsp; >>> KEY1 = root2 ['KEY1']
& Nbsp; >>> root2 [KEY1] van root2 ['OB1']
& Nbsp; True
& Nbsp; >>> KEY2 = root2 ['KEY2']
& Nbsp; >>> root2 [KEY2] van root2 ['OB2 "]
& Nbsp; True
és hogy nyugodtan nevezhetünk a gombokat, hogy a tárgyak:
& Nbsp; >>> KEY1 () van root2 ['OB1']
& Nbsp; True
& Nbsp; >>> KEY2 () van root2 ['OB2 "]
& Nbsp; True
Nem tudjuk, hogy a legfőbb hivatkozási alapja egy tárgy, amely még nem mentettük még:
& Nbsp; >>> KeyReferenceToPersistent (PersistentMapping ())
& Nbsp; ... # doctest: + ellipszis
& Nbsp; Traceback (legutolsó hívás utolsó):
& Nbsp; ...
& Nbsp; NotYet: ...
Figyeljük meg, hogy kap egy NotYet hibát. Ez azt jelzi, hogy lehet, hogy kap egy fontos hivatkozási később.
Mi lehet kapni hivatkozásokat nem mentett objektumokat, ha van egy adapterre ZODB.interfaces.IConnection. A kiegészítő módszer a kapcsolatot fogja használni, hogy az objektum egy objektum id, ami elég információt, hogy kiszámolja a referencia. Ahhoz hogy ezt hozunk létre egy objektumot, amely megfelel IConnection egy buta módon:
& Nbsp; >>> import tartós
& Nbsp; >>> from ZODB.interfaces importálni IConnection
& Nbsp; >>> class C (persistent.Persistent):
& Nbsp; ... def __conform __ (self, iface):
& Nbsp; ... ha iface van IConnection:
& Nbsp; ... cserébe conn2
& Nbsp; >>> ob3 = C ()
& Nbsp; >>> KEY3 = KeyReferenceToPersistent (ob3)
& Nbsp; >>> transaction.abort ()
Konfliktuskezelés
Során a konfliktuskezelés, a tárgyalt ZODB / ConflictResolution.txt, hivatkozásokat tartós objektumok valójában példányait ZODB.ConflictResolution.PersistentReference. Ez lényeges kétféleképpen számára KeyReferenceToPersistent. Először is, ez magyarázza a finomság az osztály: nem örökölnek persistent.Persistent. Ha mégis, akkor nem lenne elérhető a konfliktuskezelés, csak a PersistentReference stand-ban.
Másodszor, részben megmagyarázhatja a kódot a __hash__ és __cmp__ módszerek. Ezek a módszerek nem csak kezelni persistent.Persistent tárgyakat, de PersistentReference tárgyakat. E nélkül a viselkedését, tárgyak, mint például a klasszikus ZODB BTrees, hogy használja KeyReferenceToPersistent kulcsokat vagy set tagjai nem lesznek képesek a konfliktusok megoldása érdekében. Még a speciális kódot, bizonyos esetekben a KeyReferenceToPersistent nem fogja összehasonlítani, és hash során a konfliktuskezelés, mert nem lehet megbízhatóan megtenni.
__hash__ fog működni viszonylag ritkán konfliktusmegoldás: csak multidatabase hivatkozásokat. Íme néhány példa.
& Nbsp; >>> from ZODB.ConflictResolution import PersistentReference
& Nbsp; >>> def gyári (ref):
& Nbsp; ... res = KeyReferenceToPersistent .__ új __ (
& Nbsp; ... KeyReferenceToPersistent, ref)
& Nbsp; ... res.object = ref
& Nbsp; ... cserébe res
& Nbsp; ...
& Nbsp; >>> hash (gyári (PersistentReference (
& Nbsp; ... (OID ',' class metaadatok)))) # a referencia-
& Nbsp; Traceback (legutolsó hívás utolsó):
& Nbsp; ...
& Nbsp; ValueError: adatbázis neve jelenleg nem érhető el
& Nbsp; >>> bool (hash (gyári (PersistentReference (
& Nbsp; ... ['m', ("adatbázis", "OID ',' class metaadatok)])))) # multidatabase
& Nbsp; True
Ez azt jelenti, hogy KeyReferenceToPersistent gyakran akadályozzák a konfliktuskezelés az osztályok, mint a PersistentMapping.
__cmp__ működik hacsak egy objektum egy multidatabase referencia és a másik nem. Íme néhány példa.
& Nbsp; >>> CMP (gyári (PersistentReference (
& Nbsp; ... (OID ',' class metaadatok))),
& Nbsp; ... gyári (PersistentReference (
& Nbsp; ... (OID ',' class metaadatok))))
& Nbsp; 0
& Nbsp; >>> CMP (gyári (PersistentReference (
& Nbsp; ... (OID ',' class metaadatok))),
& Nbsp; ... gyári (PersistentReference (
& Nbsp; ... ("egy másik OID ',' class metaadatok))))
& Nbsp; -1
& Nbsp; >>> CMP (gyári (PersistentReference ("OID)),
& Nbsp; ... gyári (PersistentReference (
& Nbsp; ... (OID ',' class metaadatok))))
& Nbsp; 0
& Nbsp; >>> CMP (gyári (PersistentReference ("OID)),
& Nbsp; ... gyári (PersistentReference (
& Nbsp; ... (OID ',' class metaadatok))))
& Nbsp; 0
& Nbsp; >>> CMP (gyári (PersistentReference (
& Nbsp; ... ['m', ("adatbázis", "OID ',' class metaadatok)])),
& Nbsp; ... gyári (PersistentReference (
& Nbsp; ... ['m', ("adatbázis", "OID ',' class metaadatok)])))
& Nbsp; 0
& Nbsp; >>> CMP (gyári (PersistentReference (
& Nbsp; ... ['m', ("adatbázis", "OID ',' class metaadatok)])),
& Nbsp; ... gyári (PersistentReference (
& Nbsp; ... ['n', ("adatbázis", "OID)])))
& Nbsp; 0
& Nbsp; >>> CMP (gyári (PersistentReference (
& Nbsp; ... ['m', ("adatbázis", "OID ',' class metaadatok)])),
& Nbsp; ... gyári (PersistentReference (
& Nbsp; ... ['m', ("egy másik adatbázis", "OID ',' class metaadatok)])))
& Nbsp; -1
& Nbsp; >>> CMP (gyári (PersistentReference (
& Nbsp; ... ['m', ("adatbázis", "OID ',' class metaadatok)])),
& Nbsp; ... gyári (PersistentReference (
& Nbsp; ... (OID ',' class metaadatok))))
& Nbsp; Traceback (legutolsó hívás utolsó):
& Nbsp; ...
& Nbsp; ValueError: nem lehet rendezni megbízhatóan
A helyfüggő csatlakozó adapter
A funkció zope.keyreference.connectionOfPersistent alkalmazkodik tárgyak kapcsolatok egy egyszerű helyfüggő heurisztikus. Ez ellenőrizhető, hogy az objektumnak __parent__, hogy van egy kapcsolat:
& Nbsp; >>> from zope.keyreference.persistent import connectionOfPersistent
& Nbsp; >>> ob3 = PersistentMapping ()
& Nbsp; >>> print connectionOfPersistent (ob3)
& Nbsp; None
& Nbsp; >>> ob3 .__ parent__ = root2 ['OB1']
& Nbsp; >>> connectionOfPersistent (ob3) van conn2
& Nbsp; True

Mi az új ebben a kiadásban:

• Fix tesztek törött eltávolításával zope.testing a teszt függőségek: elkerüljék a ZODB3 modul, hogy szüksége van rá.

követelmények :

• Python