py2neo: Beziehungseigenschaften mithilfe von Objekten abrufen

Question

Ich verwende Graph-Object-Mapping, wobei ich 2 Objekte für 2 Knoten habe. Ich möchte auch Eigenschaften für die Beziehungen haben, wie definiere ich eine Klasse für die Beziehung mit Eigenschaften? Here, sah ich ein Beispiel, aber das ist ohne Objekte zu verwenden.

mein Code sieht wie folgt aus:

class Intent(GraphObject): 
    name = Property() 
    message = RelatedTo("Message", "HAS") 

class Message(GraphObject): 
    name = Property() 
    owner = RelatedFrom("Intent","HAS") 

graph = Graph(password='1234') 
intent = Intent() 
intent.name = "ABC" 
complete_intent = graph.pull(intent) 

Wenn ich einige Eigenschaften für die Beziehung „HAS“ haben wollen, wie definiere ich die Klasse hat? und was sollte die Basisklasse von wo zu erben (wie GraphObject für Knoten, gibt es etwas für Beziehungen?)

Answer 1

Die aktuelle Version von py2neo ermöglicht nicht für 'Beziehungsobjekte', die Sie Parameter setzen könnte auf eine Beziehung in der Standard-OOP-y-Weise.

Die OGM ist sehr nützlich für den Einstieg in ein Projekt, und für schnelle Einfügen/Retrieval-Transaktionen, aber für die meisten komplexeren Transaktionen, sollten Sie schreiben, um Ihr Ziel zu erreichen.

Oft möchten Sie jedoch diese Abfragen auf einem GraphObject organisieren, und manchmal können Sie GraphObject erweitern, um eine Methode hinzuzufügen, um einige erforderliche Funktionalität bereitzustellen.

In Ihrem Anwendungsfall möchten Sie vielleicht einige Methoden hinzufügen, um Ihre Beziehungseigenschaften zu erhalten oder einzustellen. Ich habe eine kurze Demo zum Abrufen der Eigenschaften der Beziehung geschrieben. Sie können auch eine ähnliche Methode zum Festlegen der Beziehung hinzufügen.

from py2neo.ogm import (GraphObject, 
         INCOMING, 
         OUTGOING, 
         Property, 
         RelatedFrom, 
         RelatedTo,) 
# this function makes this kind of thing tonnes easier 
from py2neo.types import remote 


class GraphObjectWithRelProps(GraphObject): 
    """Simple extension to add get method for a relationship 
    between self and another node""" 

    @staticmethod 
    def _get_relationship(source, target, relationship): 
     """Returns the relationship connecting source and target as set 
     in the class definition. 
     Copy this method, adding an argument for the params 
     and altering the cypher to add a set function 

     Only works if two classes are rleated by only one relationship 

     :param source: GraphObject instance - the starting node 
     :param target: GraphObject instance - the ending node 
     :param relationship: str name of the relationship on source""" 

     # get relationship pattern 
     rel = getattr(source, relationship) 
     # the pattern is calculated for us on this object 
     pattern = rel._RelatedObjects__relationship_pattern 

     # basic cypher query 
     q = ('MATCH {0} ' 
      'WHERE id(a) = $sId AND id(b) = $tId ' 
      'RETURN _').format(pattern) 
     # for a set operation you would add 
     # DELETE _ CREATE {0} SET _ += $relParams 
     # where $relParams is supplied as a dict with your params 
     # you could also add a patch method using _ += $relParams 
     # the remote function allows us to get a reference to the graph 
     graph = remote(source.__ogm__.node).graph 
     # as well as the node IDs of the GraphObject 
     params = { 
      'sId': remote(source.__ogm__.node)._id, 
      'tId': remote(target.__ogm__.node)._id, 
     } 

     return graph.run(q, params).evaluate() 


class Intent(GraphObjectWithRelProps): 
    name = Property() 
    message = RelatedTo("Message", "HAS") 

    def get_message_rel(self, n): 
     graph = remote(self.__ogm__.node).graph 
     return self._get_relationship(graph, self, n, 'message') 


class Message(GraphObjectWithRelProps): 
    name = Property() 
    owner = RelatedFrom("Intent","HAS") 

    def get_owner_rel(self, n): 
     graph = remote(self.__ogm__.node).graph 
     return self._get_relationship(graph, self, n, 'owner')