zope.keyreference

zope.keyreference zapewnia odwołań do obiektów, które wspierają stabilne porównanie i skrótów.
Najważniejsze Odniesienia do trwałych obiektów
zope.keyreference.persistent.KeyReferenceToPersistent stanowi odniesienie do trwałych obiektów zope.keyreference.interfaces.IKeyReference.
Spójrzmy na przykład. Najpierw stworzymy kilka trwałych obiektów w bazie danych:
& Nbsp; >>> import DB z ZODB.MappingStorage
& Nbsp; >>> transakcji importu
& Nbsp; >>> z persistent.mapping importu PersistentMapping
& Nbsp; >>> db = DB ()
& Nbsp; >>> conn = db.open ()
& Nbsp; >>> root = conn.root ()
& Nbsp; >>> główny ['OB1'] = PersistentMapping ()
& Nbsp; >>> główny ['OB2'] = PersistentMapping ()
& Nbsp; >>> transaction.commit ()
Następnie stworzymy kilka kluczowych odniesienia:
& Nbsp; >>> z zope.keyreference.persistent importu KeyReferenceToPersistent
& Nbsp; >>> klucz1 = KeyReferenceToPersistent (root ['OB1'])
& Nbsp; >>> klucz2 = KeyReferenceToPersistent (root ['OB2'])
Można nazwać klawiszy, aby uzyskać obiekty:
& Nbsp; >>> klucz1 () jest root ['OB1'], klucz2 () jest root ['OB2']
& Nbsp; (prawda, prawda)
Nowe klucze do tych samych obiektów są równe stare:
& Nbsp; >>> KeyReferenceToPersistent (root ['OB1']) == klucz1
& Nbsp; prawda
i mają te same wartości skrótów:
& Nbsp; >>> hash (KeyReferenceToPersistent (root ['OB1'])) == hash (klucz1)
& Nbsp; prawda
Inne kluczowe implementacje referencyjne są różniły ich kluczowej typu id. Główne odniesienia powinien uporządkować najpierw na ich typ klucza, a druga na informacjach specyficznych dla danego typu:
& Nbsp; >>> z zope.interface narzędzi importu
& Nbsp; >>> z zope.keyreference.interfaces importować IKeyReference
& Nbsp; >>> klasy DummyKeyReference (obiekt):
& Nbsp; ... przyrządy (IKeyReference)
& Nbsp; ... key_type_id = "zope.app.keyreference.object"
& Nbsp; ... def __init __ (self, obj):
& Nbsp; ... self.object = obj
& Nbsp; ... def __cmp __ (self, inne):
& Nbsp; ... jeśli self.key_type_id == other.key_type_id:
& Nbsp; ... powrót cmp (self.object, other.object)
& Nbsp; ... powrót cmp (self.key_type_id, other.key_type_id)
& Nbsp; >>> dummy_key1 = DummyKeyReference (obiekt ())
& Nbsp; >>> dummy_key2 = DummyKeyReference (obiekt ())
& Nbsp; >>> dummy_key3 = DummyKeyReference (obiekt ())
& Nbsp; >>> klucze = [klucz1, dummy_key1, dummy_key2, klucz2, dummy_key3]
& Nbsp; >>> keys.sort ()
& Nbsp; >>> key_type_ids = [key.key_type_id na klucz w klawisze]
& Nbsp; >>> key_type_ids [0: 3] .count ("zope.app.keyreference.object")
& Nbsp; 3
. & Nbsp; >>> key_type_ids [3:] ("zope.app.keyreference.persistent count ')
& Nbsp; 2
Będziemy przechowywać najważniejsze odniesienia w bazie danych:
& Nbsp; >>> główny ['klucz1'] = klucz1
& Nbsp; >>> główny ['klucz2'] = klucz2
i za pomocą przycisków, aby ponownie zapisać obiekty:
& Nbsp; >>> główny [klucz1] = root ['OB1']
& Nbsp; >>> główny [klucz2] = root ['OB2']
& Nbsp; >>> transaction.commit ()
Teraz będziemy otwierać kolejne połączenie:
& Nbsp; >>> conn2 = db.open ()
I sprawdzić, czy możemy użyć klawiszy, aby wyszukać obiekty:
& Nbsp; >>> root2 = conn2.root ()
& Nbsp; >>> klucz1 = root2 ['klucz1']
& Nbsp; >>> root2 [klucz1] jest root2 ['OB1']
& Nbsp; prawda
& Nbsp; >>> klucz2 = root2 ['klucz2']
& Nbsp; >>> root2 [klucz2] jest root2 ['OB2']
& Nbsp; prawda
i że możemy zadzwonić klawiszy, aby obiekty:
& Nbsp; >>> klucz1 () jest root2 ['OB1']
& Nbsp; prawda
& Nbsp; >>> klucz2 () jest root2 ['OB2']
& Nbsp; prawda
Nie możemy się kluczowe odniesienie do obiektu, który nie został jeszcze zapisany:
& Nbsp; >>> KeyReferenceToPersistent (PersistentMapping ())
& Nbsp; ... # doctest: + wielokropka
& Nbsp; Traceback (najnowsze połączenie ostatni):
& Nbsp; ...
& Nbsp; notyet: ...
Zauważ, że pojawia się błąd notyet. Oznacza to, że możemy być w stanie uzyskać kluczową odniesienie później.
Możemy odniesienia do niezapisanych obiektów, jeśli mają adapter ZODB.interfaces.IConnection. Metoda dodatek na połączenia zostaną wykorzystane, aby dać obiektowi identyfikator obiektu, który jest wystarczająco dużo informacji, aby obliczyć odniesienia. Aby to zobaczyć, stworzymy obiekt, który odpowiada IConnection w głupi sposób:
& Nbsp; >>> import trwałe
& Nbsp; >>> z ZODB.interfaces importować IConnection
& Nbsp; >>> klasa C (persistent.Persistent):
& Nbsp; ... def __conform __ (self, iface):
& Nbsp; ... jeśli iface jest IConnection:
& Nbsp; ... powrót conn2
& Nbsp; >>> OB3 = C ()
& Nbsp; >>> Key3 = KeyReferenceToPersistent (OB3)
& Nbsp; >>> transaction.abort ()
Rozwiązywanie konfliktów
W trakcie rozwiązywania konfliktów, jak to opisano w ZODB / ConflictResolution.txt odniesienia do trwałych obiektów w rzeczywistości przypadki ZODB.ConflictResolution.PersistentReference. Jest to istotne z dwóch sposobów KeyReferenceToPersistent. Po pierwsze, wyjaśnia subtelności klasy: nie dziedziczą persistent.Persistent. Jeśli tak, to nie będzie dostępne dla rozwiązywania konfliktów, tylko jej PersistentReference stand-in.
Po drugie, wyjaśnia niektóre kodu w metodach __hash__ i __cmp__. Metody te nie tylko przenosić przedmioty persistent.Persistent, ale obiekty PersistentReference. Bez tego zachowania, obiekty, takie jak klasyczny ZODB BTrees, które używają KeyReferenceToPersistent jak klucze lub zestaw członków nie będzie w stanie rozwiązać konflikty. Nawet ze specjalnym kodem, w niektórych przypadkach KeyReferenceToPersistent odmówi porównać i mieszania w trakcie rozwiązywania konfliktów, ponieważ nie można w wiarygodny sposób to zrobić.
__hash__ będzie działać stosunkowo rzadko w trakcie rozwiązywania konfliktów: tylko dla odniesienia multidatabase. Oto kilka przykładów.
& Nbsp; >>> z ZODB.ConflictResolution importu PersistentReference
& Nbsp; >>> fabrycznie def (ref):
& Nbsp; ... res = KeyReferenceToPersistent .__ nowa __ (
& Nbsp; ... KeyReferenceToPersistent, ref)
& Nbsp; ... res.object = sędzią
& Nbsp; ... res powrotne
& Nbsp; ...
& Nbsp; >>> hash (fabryczne (PersistentReference (
& Nbsp; ... ("oid", "metadane klasa")))) # typowego
& Nbsp; Traceback (najnowsze połączenie ostatni):
& Nbsp; ...
& Nbsp; ValueError: nazwa bazy danych w tej chwili niedostępna
& Nbsp; >>> bool (hash (fabryczne (PersistentReference (
& Nbsp; ... ['m', ("baza danych", "oid", "metadata class ')])))) # multidatabase
& Nbsp; prawda
Oznacza to, że często utrudniają KeyReferenceToPersistent rozwiązywania konfliktów dla klas takich jak PersistentMapping.
__cmp__ działa, chyba że jeden obiekt jest multidatabase odniesienia, a druga nie. Oto kilka przykładów.
& Nbsp; >>> cmp (fabryczne (PersistentReference (
& Nbsp; ... ("oid", "metadane klasa"))),
& Nbsp; ... Fabryka (PersistentReference (
& Nbsp; ... ("oid", "metadane klasa"))))
& Nbsp; 0
& Nbsp; >>> cmp (fabryczne (PersistentReference (
& Nbsp; ... ("oid", "metadane klasa"))),
& Nbsp; ... Fabryka (PersistentReference (
& Nbsp; ... ("kolejny oid", "metadane klasa"))))
& Nbsp; -1
& Nbsp; >>> cmp (fabryczne (PersistentReference ("oid")),
& Nbsp; ... Fabryka (PersistentReference (
& Nbsp; ... ("oid", "metadane klasa"))))
& Nbsp; 0
& Nbsp; >>> cmp (fabryczne (PersistentReference ("oid")),
& Nbsp; ... Fabryka (PersistentReference (
& Nbsp; ... ("oid", "metadane klasa"))))
& Nbsp; 0
& Nbsp; >>> cmp (fabryczne (PersistentReference (
& Nbsp; ... ["m", ("bazy danych", "oid", "Klasa") metadane])),
& Nbsp; ... Fabryka (PersistentReference (
& Nbsp; ... ["m", ("baza", "oid", "metadane klasy ')])))
& Nbsp; 0
& Nbsp; >>> cmp (fabryczne (PersistentReference (
& Nbsp; ... ["m", ("bazy danych", "oid", "Klasa") metadane])),
& Nbsp; ... Fabryka (PersistentReference (
& Nbsp; ... ["n", ("baza", "oid")])))
& Nbsp; 0
& Nbsp; >>> cmp (fabryczne (PersistentReference (
& Nbsp; ... ["m", ("bazy danych", "oid", "Klasa") metadane])),
& Nbsp; ... Fabryka (PersistentReference (
& Nbsp; ... ["m", ("inna baza danych", "oid", "metadane klasy ')])))
& Nbsp; -1
& Nbsp; >>> cmp (fabryczne (PersistentReference (
& Nbsp; ... ["m", ("bazy danych", "oid", "Klasa") metadane])),
& Nbsp; ... Fabryka (PersistentReference (
& Nbsp; ... ("oid", "metadane klasa"))))
& Nbsp; Traceback (najnowsze połączenie ostatni):
& Nbsp; ...
& Nbsp; ValueError: Nie można sortować wiarygodny
Adapter połączenia w oparciu o lokalizację
Funkcja zope.keyreference.connectionOfPersistent dopasowuje obiekty do połączeń przy użyciu prostej heurystyki oparte na lokalizacji. To sprawdzone, aby sprawdzić, czy obiekt ma __parent__, który ma połączenie:
& Nbsp; >>> z zope.keyreference.persistent importu connectionOfPersistent
& Nbsp; >>> OB3 = PersistentMapping ()
& Nbsp; >>> print connectionOfPersistent (OB3)
& Nbsp; Brak
& Nbsp; >>> OB3 .__ parent__ = root2 ['OB1']
& Nbsp; >>> connectionOfPersistent (OB3) jest conn2
& Nbsp; prawda

Co nowego w tym wydaniu:

• Testy naprawić uszkodzone przez usunięcie zope.testing z zależnościami testowych: uniknąć moduł ZODB3, że potrzebuje go.

Wymagania :

• Python