zope.keyreference

zope.keyreference prevede referințe obiect care susțin comparație stabil și hash-uri.
Referinte cheie pentru Obiecte persistente
zope.keyreference.persistent.KeyReferenceToPersistent oferă o referință zope.keyreference.interfaces.IKeyReference de obiecte persistente.
Să ne uităm la un exemplu. În primul rând, vom crea unele obiecte persistente într-o bază de date:
& Nbsp; >>> din ZODB.MappingStorage import DB
& Nbsp; >>> operațiune de import
& Nbsp; >>> din persistent.mapping PersistentMapping import
& Nbsp; >>> db = DB ()
& Nbsp; >>> Conn = db.open ()
& Nbsp; >>> root = conn.root ()
& Nbsp; >>> rădăcină ['OB1'] = PersistentMapping ()
& Nbsp; >>> rădăcină ['OB2'] = PersistentMapping ()
& Nbsp; >>> transaction.commit ()
Atunci vom crea unele referințe cheie:
& Nbsp; >>> din KeyReferenceToPersistent import zope.keyreference.persistent
& Nbsp; >>> cheie1 = KeyReferenceToPersistent (rădăcină ['OB1'])
& Nbsp; >>> key2 = KeyReferenceToPersistent (rădăcină ['OB2'])
Putem apela tastele pentru a obține obiectele:
& Nbsp; >>> cheie1 () este rădăcina ['OB1'], key2 () este rădăcina ['OB2']
& Nbsp; (Adevărat, adevărat)
Noi cheile de la aceleași obiecte sunt egale cu vechi:
& Nbsp; >>> KeyReferenceToPersistent (rădăcină ['OB1']) == cheie1
& Nbsp; Adevărat
și au aceleași hash:
& Nbsp; >>> hash (KeyReferenceToPersistent (rădăcină ['OB1'])) == diez (cheie1)
& Nbsp; Adevărat
Alte implementări de referință cheie sunt difereau de tipul lor id cheie. Referințele cheie ar trebui să sortați primul de tipul lor cheie și a doua la orice informație de tip specifice:
& Nbsp; >>> de instrumente de import zope.interface
& Nbsp; >>> din zope.keyreference.interfaces import IKeyReference
& Nbsp; >>> DummyKeyReference clasă (obiect):
& Nbsp; ... unelte (IKeyReference)
& Nbsp; ... key_type_id = 'zope.app.keyreference.object'
& Nbsp; ... def automat metodei __init __ (self, obj):
& Nbsp; ... self.object = obj
& Nbsp; ... def __cmp __ (self, altele):
& Nbsp; ... dacă self.key_type_id == other.key_type_id:
& Nbsp; ... CMP întoarcere (self.object, other.object)
& Nbsp; ... CMP întoarcere (self.key_type_id, other.key_type_id)
& Nbsp; >>> dummy_key1 = DummyKeyReference (obiect ())
& Nbsp; >>> dummy_key2 = DummyKeyReference (obiect ())
& Nbsp; >>> dummy_key3 = DummyKeyReference (obiect ())
& Nbsp; >>> chei = [cheie1, dummy_key1, dummy_key2, key2, dummy_key3]
& Nbsp; >>> keys.sort ()
& Nbsp; >>> key_type_ids = [key.key_type_id de cheie în cheile]
& Nbsp; >>> key_type_ids [0: 3] .count ("zope.app.keyreference.object")
& Nbsp; 3
. & Nbsp; >>> key_type_ids [3]: Numar ("zope.app.keyreference.persistent")
& Nbsp; 2
Vom păstra trimiterile cheie în baza de date:
& Nbsp; >>> rădăcină ['cheie1'] = cheie1
& Nbsp; >>> rădăcină ['key2'] = key2
și de a folosi tastele pentru a stoca obiectele din nou:
& Nbsp; >>> rădăcină [cheie1] = rădăcină ['OB1']
& Nbsp; >>> rădăcină [key2] = rădăcină ['OB2']
& Nbsp; >>> transaction.commit ()
Acum vom deschide o altă conexiune:
& Nbsp; >>> conn2 = db.open ()
Și a verifica dacă putem folosi tastele pentru a căuta obiecte:
& Nbsp; >>> root2 = conn2.root ()
& Nbsp; >>> cheie1 = root2 ['cheie1']
& Nbsp; >>> root2 [cheie1] este root2 ['OB1']
& Nbsp; Adevărat
& Nbsp; >>> key2 = root2 ['key2']
& Nbsp; >>> root2 [key2] este root2 ['OB2']
& Nbsp; Adevărat
și că putem apela, de asemenea tastele pentru a obține obiectele:
& Nbsp; >>> cheie1 () este root2 ['OB1']
& Nbsp; Adevărat
& Nbsp; >>> key2 () este root2 ['OB2']
& Nbsp; Adevărat
Nu putem obține de referință cheie pentru un obiect care nu a fost salvată încă:
& Nbsp; >>> KeyReferenceToPersistent (PersistentMapping ())
& Nbsp; ... # doctest: + elipsă
& Nbsp; Traceback (apel cele mai recente Ultima):
& Nbsp; ...
& Nbsp; NotYet: ...
Rețineți că vom obține o eroare NotYet. Acest lucru indică faptul că am putea fi capabil de a obține o referință cheie mai târziu.
Putem obține trimiteri la obiectele salvate dacă au un adaptor de ZODB.interfaces.IConnection. Metoda add pe conexiunea va fi folosit pentru a da obiectul unui id obiect, care este destul de informații pentru a calcula de referință. Pentru a vedea acest lucru, vom crea un obiect care este conform cu IConnection într-un mod stupid:
& Nbsp; >>> import persistent
& Nbsp; >>> din ZODB.interfaces import IConnection
& Nbsp; >>> clasa C (persistent.Persistent):
& Nbsp; ... def __conform __ (self, iface):
& Nbsp; ... dacă iface este IConnection:
& Nbsp; ... conn2 întoarcere
& Nbsp; >>> OB3 = C ()
& Nbsp; >>> key3 = KeyReferenceToPersistent (OB3)
& Nbsp; >>> transaction.abort ()
conflictelor
În timpul soluționare a conflictelor, așa cum sa discutat în ZODB / ConflictResolution.txt, trimiterile la obiectele persistente sunt de fapt cazuri de ZODB.ConflictResolution.PersistentReference. Acest lucru este pertinent în două moduri pentru KeyReferenceToPersistent. În primul rând, se explică o subtilitate a clasei: ea nu moștenesc de la persistent.Persistent. În cazul în care a făcut-o, nu ar fi disponibile de soluționare a conflictelor, doar PersistentReference sa stau-in.
În al doilea rând, se explică o parte din codul în __hash__ și __cmp__ metode. Aceste metode nu ocupa doar obiecte persistent.Persistent, dar obiecte PersistentReference. Fără acest comportament, obiecte, cum ar fi clasic ZODB BTrees, care folosesc KeyReferenceToPersistent ca chei sau membri set va fi în imposibilitatea de a rezolva conflictele. Chiar și cu codul special, în unele cazuri, KeyReferenceToPersistent va refuza să compare și distribuire în timpul de soluționare a conflictelor, deoarece nu credibil poate face acest lucru.
__hash__ va lucra relativ rar în timpul de rezolvare a conflictelor: doar pentru referințe multidatabase. Aici sunt câteva exemple.
& Nbsp; >>> din ZODB.ConflictResolution PersistentReference import
& Nbsp; >>> fabrică def (ref):
& Nbsp; ... res = KeyReferenceToPersistent .__ __ nou (
& Nbsp; ... KeyReferenceToPersistent, ref)
& Nbsp; ... res.object = ref
& Nbsp; ... res returnare
& Nbsp; ...
& Nbsp; >>> hash (fabricii (PersistentReference (
& Nbsp; ... ("metadate clasa '' un OID")))) # o trimitere tipic
& Nbsp; Traceback (apel cele mai recente Ultima):
& Nbsp; ...
& Nbsp; ValueError: numele bazei de date indisponibil în acest moment
& Nbsp; >>> bool (hash (fabricii (PersistentReference (
& Nbsp; ... ['m', ("o bază de date", "un OID", "metadate clasă")])))) # multidatabase
& Nbsp; Adevărat
Acest lucru înseamnă că KeyReferenceToPersistent va împiedica de multe ori de rezolvare a conflictelor pentru clasele, cum ar fi PersistentMapping.
__cmp__ funcționează cu excepția cazului în un obiect este o referință multidatabase și celălalt nu este. Iată câteva exemple.
& Nbsp; >>> CMP (fabricii (PersistentReference (
& Nbsp; ... ("un OID", "metadate clasă"))),
& Nbsp; ... fabricii (PersistentReference (
& Nbsp; ... ("un OID", "metadate clasă"))))
& Nbsp; 0
& Nbsp; >>> CMP (fabricii (PersistentReference (
& Nbsp; ... ("un OID", "metadate clasă"))),
& Nbsp; ... fabricii (PersistentReference (
& Nbsp; ... ("un alt oid", "metadate clasă"))))
& Nbsp; -1
& Nbsp; >>> CMP (fabricii (PersistentReference ("un OID")),
& Nbsp; ... fabricii (PersistentReference (
& Nbsp; ... ("un OID", "metadate clasă"))))
& Nbsp; 0
& Nbsp; >>> CMP (fabricii (PersistentReference ("un OID")),
& Nbsp; ... fabricii (PersistentReference (
& Nbsp; ... ("un OID", "metadate clasă"))))
& Nbsp; 0
& Nbsp; >>> CMP (fabricii (PersistentReference (
& Nbsp; ... ['m', ("o bază de date", "un OID", "metadate clasă")])),
& Nbsp; ... fabricii (PersistentReference (
& Nbsp; ... ['m', ("o bază de date", "un OID", "metadate clasă")])))
& Nbsp; 0
& Nbsp; >>> CMP (fabricii (PersistentReference (
& Nbsp; ... ['m', ("o bază de date", "un OID", "metadate clasă")])),
& Nbsp; ... fabricii (PersistentReference (
& Nbsp; ... ['n', ("o bază de date", "un OID")])))
& Nbsp; 0
& Nbsp; >>> CMP (fabricii (PersistentReference (
& Nbsp; ... ['m', ("o bază de date", "un OID", "metadate clasă")])),
& Nbsp; ... fabricii (PersistentReference (
& Nbsp; ... ['m', ('altă bază de date "," un OID "," metadate clasă ")])))
& Nbsp; -1
& Nbsp; >>> CMP (fabricii (PersistentReference (
& Nbsp; ... ['m', ("o bază de date", "un OID", "metadate clasă")])),
& Nbsp; ... fabricii (PersistentReference (
& Nbsp; ... ("un OID", "metadate clasă"))))
& Nbsp; Traceback (apel cele mai recente Ultima):
& Nbsp; ...
& Nbsp; ValueError: nu se poate sortare credibil
bazate pe locație adaptor conexiune
Funcția zope.keyreference.connectionOfPersistent adaptează obiecte de conexiuni folosind un bazate pe locație simplu euristice. Se verifică pentru a vedea dacă obiectul are o __parent__ care are o conexiune:
& Nbsp; >>> din connectionOfPersistent import zope.keyreference.persistent
& Nbsp; >>> OB3 = PersistentMapping ()
& Nbsp; >>> connectionOfPersistent imprimare (OB3)
& Nbsp; Nici unul
& Nbsp; >>> OB3 .__ parent__ = root2 ['OB1']
& Nbsp; >>> connectionOfPersistent (OB3) este conn2
& Nbsp; Adevărat

Ce este nou în această versiune:

• teste Fix rupt prin îndepărtarea zope.testing de la dependențe de încercare: evita modulul ZODB3 care are nevoie de ea.

Cerințe :

• Python