zope.keyreference

zope.keyreference nagbibigay sa bagay na sanggunian na sumusuporta sa matatag na paghahambing at hash.
Pangunahing Mga sanggunian para sa Paulit-ulit Bagay
zope.keyreference.persistent.KeyReferenceToPersistent ay nagbibigay ng isang reference zope.keyreference.interfaces.IKeyReference para sa paulit-ulit na mga bagay.
Tingnan natin ang isang halimbawa. Una, lilikha kami ng ilang mga paulit-ulit na mga bagay sa isang database:
& Nbsp; >>> mula ZODB.MappingStorage import DB
& Nbsp; >>> import transaksyon
& Nbsp; >>> mula persistent.mapping import PersistentMapping
& Nbsp; >>> db = DB ()
& Nbsp; >>> conn = db.open ()
& Nbsp; >>> ugat = conn.root ()
& Nbsp; >>> ugat ['ob1'] = PersistentMapping ()
& Nbsp; >>> ugat ['ob2'] = PersistentMapping ()
& Nbsp; >>> transaction.commit ()
Pagkatapos ay lilikha kami ng ilang mga pangunahing sanggunian:
& Nbsp; >>> mula zope.keyreference.persistent import KeyReferenceToPersistent
& Nbsp; >>> key1 = KeyReferenceToPersistent (ugat ['ob1'])
& Nbsp; >>> key2 = KeyReferenceToPersistent (ugat ['ob2'])
Maaari naming tawagan ang mga key upang makuha ang mga bagay:
& Nbsp; >>> key1 () ay ang root ['ob1'], key2 () ay ang root ['ob2']
& Nbsp; (True, True)
Bagong mga susi sa parehong mga bagay ay pantay-pantay sa lumang:
& Nbsp; >>> KeyReferenceToPersistent (ugat ['ob1']) == key1
& Nbsp; True
at magkakaroon ng parehong mga hash:
& Nbsp; >>> hash (KeyReferenceToPersistent (ugat ['ob1'])) == hash (key1)
& Nbsp; True
Iba pang mga pangunahing reference pagpapatupad ay differed sa pamamagitan ng kanilang mga pangunahing uri ng id. Key reference dapat muna sa kanilang mga pangunahing uri at pangalawang-uri-uriin sa anumang impormasyon ng uri ng tukoy:
& Nbsp; >>> mula zope.interface import ipinapatupad ng
& Nbsp; >>> mula zope.keyreference.interfaces-import IKeyReference
& Nbsp; >>> klase DummyKeyReference (object):
& Nbsp; ... ipinapatupad ng (IKeyReference)
& Nbsp; ... key_type_id = 'zope.app.keyreference.object'
& Nbsp; ... def __init __ (sa sarili, obj):
& Nbsp; ... self.object = obj
& Nbsp; ... def __cmp __ (sa sarili, iba pa):
& Nbsp; ... kung self.key_type_id == other.key_type_id:
& Nbsp; ... balik cmp (self.object, other.object)
& Nbsp; ... balik 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; >>> key = [key1, dummy_key1, dummy_key2, key2, dummy_key3]
& Nbsp; >>> keys.sort ()
& Nbsp; >>> key_type_ids = [key.key_type_id para sa key sa key]
& Nbsp; >>> key_type_ids [0: 3] .count ('zope.app.keyreference.object')
& Nbsp; 3
. & Nbsp; >>> key_type_ids [3:] bilangin ('zope.app.keyreference.persistent')
& Nbsp; 2
Susubukan naming iimbak ang key na mga sanggunian sa database:
& Nbsp; >>> ugat ['key1'] = key1
& Nbsp; >>> ugat ['key2'] = key2
at gamitin ang mga key upang mag-imbak muli ang mga bagay:
& Nbsp; >>> ugat [key1] = ugat ['ob1']
& Nbsp; >>> ugat [key2] = ugat ['ob2']
& Nbsp; >>> transaction.commit ()
Ngayon makikita buksan kami ng isa pang koneksyon:
& Nbsp; >>> conn2 = db.open ()
At i-verify na maaari naming gamitin ang mga key upang hanapin ang mga bagay:
& Nbsp; >>> root2 = conn2.root ()
& Nbsp; >>> key1 = root2 ['key1']
& Nbsp; >>> root2 [key1] ay root2 ['ob1']
& Nbsp; True
& Nbsp; >>> key2 = root2 ['key2']
& Nbsp; >>> root2 [key2] ay root2 ['ob2']
& Nbsp; True
at maaari naming ring tumawag ang mga key upang makuha ang mga bagay:
& Nbsp; >>> key1 () ay root2 ['ob1']
& Nbsp; True
& Nbsp; >>> key2 () ay root2 ['ob2']
& Nbsp; True
Hindi namin makuha ang susi sanggunian para sa isang bagay na hindi pa naka-save:
& Nbsp; >>> KeyReferenceToPersistent (PersistentMapping ())
& Nbsp; ... # doctest: + elipsis
& Nbsp; Traceback (pinakahuling tawag huling):
& Nbsp; ...
& Nbsp; NotYet: ...
Tandaan na makakakuha tayo ng isang error NotYet. Ito ay nagpapahiwatig na maaari naming magagawang upang makakuha ng isang pangunahing reference sa ibang pagkakataon.
Maaari naming makakuha ng mga sanggunian sa mga hindi na-save na bagay kung mayroon sila ng adaptor sa ZODB.interfaces.IConnection. Ang pamamaraan add sa koneksyon ay magagamit upang bigyan ang bagay isang bagay id, na sapat na impormasyon upang makalkula ang reference. Upang makita ito, lilikha kami ng isang bagay na conforms sa IConnection sa isang nakakatawa paraan:
& Nbsp; >>> import paulit-ulit
& Nbsp; >>> mula ZODB.interfaces-import IConnection
& Nbsp; >>> klase C (persistent.Persistent):
& Nbsp; ... def __conform __ (sa sarili, iface):
& Nbsp; ... kung iface ay IConnection:
& Nbsp; ... balik conn2
& Nbsp; >>> ob3 = C ()
& Nbsp; >>> key3 = KeyReferenceToPersistent (ob3)
& Nbsp; >>> transaction.abort ()
Salungatan Resolution
Sa panahon na resolution kontrahan, gaya ng tinalakay sa ZODB / ConflictResolution.txt, mga sanggunian sa mga paulit-ulit na mga bagay ay aktwal na mga kaso ng ZODB.ConflictResolution.PersistentReference. Ito ay may kinalaman sa dalawang paraan para KeyReferenceToPersistent. Una, ipinapaliwanag nito ang isang kapitaganan ng klase: hindi ito magmana mula persistent.Persistent. Kung ginawa ito, ito ay hindi magiging available para sa resolusyon kontrahan, lamang PersistentReference nito stand-in.
Pangalawa, ipinapaliwanag nito ang ilan sa mga code sa __hash__ at __cmp__ mga pamamaraan. Mga pamamaraan na ito ay hindi lamang pangasiwaan persistent.Persistent bagay, ngunit PersistentReference bagay. Nang walang pag-uugaling ito, mga bagay, tulad ng mga klasikong ZODB BTrees, na gumagamit ng KeyReferenceToPersistent bilang key o hanay ng mga miyembro ay hindi malutas salungatan. Kahit na may mga espesyal na code, sa ilang mga kaso ang KeyReferenceToPersistent ay tanggihan upang ihambing at hash panahon resolution salungatan dahil hindi ito mapagkakatiwlaan magawa ito.
ay __hash__ gumana relatibong bihirang sa panahon ng resolution salungatan: lamang para sa multidatabase mga sanggunian. Narito ang ilang mga halimbawa.
& Nbsp; >>> mula ZODB.ConflictResolution import PersistentReference
& Nbsp; >>> def factory (ref):
& Nbsp; ... res = KeyReferenceToPersistent .__ bagong __ (
& Nbsp; ... KeyReferenceToPersistent, ref)
& Nbsp; ... res.object = ref
& Nbsp; ... balik res
& Nbsp; ...
& Nbsp; >>> hash (factory (PersistentReference (
& Nbsp; ... ('ng isang OID', 'klase ng metadata')))) # isang tipikal na reference
& Nbsp; Traceback (pinakahuling tawag huling):
& Nbsp; ...
& Nbsp; ValueError: Hindi magagamit ang pangalan ng database sa oras na ito
& Nbsp; >>> bool (hash (factory (PersistentReference (
& Nbsp; ... ['m', ('database', 'isang OID', 'klase ng metadata')])))) # multidatabase
& Nbsp; True
Nangangahulugan ito na KeyReferenceToPersistent ay madalas na hadlangan resolution salungatan para sa mga klase tulad ng PersistentMapping.
__cmp__ gumagana maliban kung ang isa sa bagay ay isang multidatabase reference at ang iba ay hindi. Narito ang ilang mga halimbawa.
& Nbsp; >>> cmp (factory (PersistentReference (
& Nbsp; ... ('ng isang OID', 'klase ng metadata'))),
& Nbsp; ... factory (PersistentReference (
& Nbsp; ... ('ng isang OID', 'klase ng metadata'))))
& Nbsp; 0
& Nbsp; >>> cmp (factory (PersistentReference (
& Nbsp; ... ('ng isang OID', 'klase ng metadata'))),
& Nbsp; ... factory (PersistentReference (
& Nbsp; ... ('isa pang OID', 'klase ng metadata'))))
& Nbsp; -1
& Nbsp; >>> cmp (factory (PersistentReference ('ng isang OID')),
& Nbsp; ... factory (PersistentReference (
& Nbsp; ... ('ng isang OID', 'klase ng metadata'))))
& Nbsp; 0
& Nbsp; >>> cmp (factory (PersistentReference ('ng isang OID')),
& Nbsp; ... factory (PersistentReference (
& Nbsp; ... ('ng isang OID', 'klase ng metadata'))))
& Nbsp; 0
& Nbsp; >>> cmp (factory (PersistentReference (
& Nbsp; ... ['m', ('database', 'isang OID', 'klase ng metadata')])),
& Nbsp; ... factory (PersistentReference (
& Nbsp; ... ['m', ('database', 'isang OID', 'klase ng metadata')])))
& Nbsp; 0
& Nbsp; >>> cmp (factory (PersistentReference (
& Nbsp; ... ['m', ('database', 'isang OID', 'klase ng metadata')])),
& Nbsp; ... factory (PersistentReference (
& Nbsp; ... ['n', ('database', 'isang OID')])))
& Nbsp; 0
& Nbsp; >>> cmp (factory (PersistentReference (
& Nbsp; ... ['m', ('database', 'isang OID', 'klase ng metadata')])),
& Nbsp; ... factory (PersistentReference (
& Nbsp; ... ['m', ('isa pang database', 'isang OID', 'klase ng metadata')])))
& Nbsp; -1
& Nbsp; >>> cmp (factory (PersistentReference (
& Nbsp; ... ['m', ('database', 'isang OID', 'klase ng metadata')])),
& Nbsp; ... factory (PersistentReference (
& Nbsp; ... ('ng isang OID', 'klase ng metadata'))))
& Nbsp; Traceback (pinakahuling tawag huling):
& Nbsp; ...
& Nbsp; ValueError: hindi ma-uri-uriin mapagkakatiwlaan
adapter koneksyon batay sa lokasyon
Ang function na zope.keyreference.connectionOfPersistent adapts bagay na koneksyon gamit ang isang simpleng hyuristiko batay sa lokasyon. Naka-check ito upang makita kung ang bagay ay may __parent__ na may koneksyon:
& Nbsp; >>> mula zope.keyreference.persistent import connectionOfPersistent
& Nbsp; >>> ob3 = PersistentMapping ()
& Nbsp; >>>-print connectionOfPersistent (ob3)
& Nbsp; Wala
& Nbsp; >>> ob3 .__ parent__ = root2 ['ob1']
& Nbsp; >>> connectionOfPersistent (ob3) ay conn2
& Nbsp; True

Ano ang bagong sa paglabas:

• Ayusin ang mga pagsubok na pinaghiwa sa pamamagitan ng pag-alis ng zope.testing mula sa pagsubok dependency: maiwasan ang ZODB3 module na kailangan nito.

Mga Kinakailangan :

• Python