Neomodel Python OGM: Tiefer Einblick in die Neo4j-Modellierung

Startseite » Python » Neomodel Python OGM: Tiefer Einblick in die Neo4j-Modellierung

Neomodel ist ein Python-Objektgraph-Mapper (OGM), der die Arbeit mit Neo4j so intuitiv wie das Schreiben von regulärem Python-Code gestaltet. Anstatt ständig Cypher-Abfragen manuell zu erstellen, beschreiben Sie Ihre Graphdomäne mit Klassen, Feldern und Beziehungen. Neomodel übernimmt dann die Zuordnung zwischen Python-Objekten und Neo4j-Knoten und -Beziehungen. Es basiert auf dem offiziellen Neo4j-Python-Treiber und verfügt nur über eine schlanke Abstraktionsschicht. So profitieren Sie von hohem Bedienkomfort ohne nennenswerte Leistungseinbußen.

Als Teil des Neo4j Labs-Ökosystems wird neomodel aktiv gepflegt, unterstützt vollständig moderne Python- und Neo4j-Versionen und bietet sowohl synchrone als auch asynchrone APIs. Es bietet vertraute, Django-ähnliche Modelldefinitionen, eine umfangreiche Abfrage-API, Schema-Durchsetzung über Kardinalität, integrierte Transaktionen und eine enge Integration mit Django durch django_neomodelGleichzeitig bleibt es aber hardwarenah: Man kann jederzeit auf reines Cypher zurückgreifen, wenn es die Performance oder die Komplexität der Abfrage erfordert.

Was das Neomodell ist und warum es wichtig ist

Neomodel ist ein Objektgraph-Mapper für die Neo4j-Graphdatenbank, der Python-Klassen und Graphstrukturen miteinander verbindet. Anstatt Knoten und Beziehungen manuell über Cypher-Strings zu erstellen, definieren Sie Python-Klassen, die Ihre Domänenentitäten repräsentieren. Neomodel wandelt diese dann in beschriftete Knoten mit indizierten Eigenschaften und Einschränkungen in Neo4j um. Es baut auf der offiziellen Bibliothek auf. neo4j-python-driverSein Verhalten entspricht also dem, was Sie tun würden, wenn Sie den Treiber direkt verwenden.

Die Bibliothek setzt auf einen vertrauten, klassenbasierten Modellierungsstil mit robuster Vererbung, Hooks und Validierung. Dieser Ansatz ist besonders komfortabel für Entwickler, die mit Django ORM oder anderen Python-ORMs vertraut sind: Attribute Ihrer Modellklassen entsprechen Eigenschaften in Neo4j, während spezielle Beziehungsfelder die Kanten des Graphen abbilden. Mit diesem Setup reduziert sich die Graphdurchquerung auf das Verfolgen von Objektattributen, anstatt jedes Mal umständlichen Cypher-Code schreiben zu müssen.

Im Hintergrund bietet neomodel eine leistungsstarke Abfrage-API, die gängige Graphzugriffsmuster abdeckt, ohne dass man sich sofort mit rohem Cypher auseinandersetzen muss. Über eine Python-ähnliche Schnittstelle können Sie filtern, sortieren, Beziehungen durchlaufen, Knotengruppen aufteilen und erweiterte Operationen durchführen. Bei Bedarf haben Sie weiterhin Zugriff auf eine cypher_query Hilfsprogramm zum Ausführen benutzerdefinierter Abfragen und zur direkten Weiterverarbeitung der zurückgegebenen Ergebnisse.

Ein weiteres zentrales Merkmal ist die Schemaerzwingung durch Kardinalitätsregeln für Beziehungen und Eigenschaftseinschränkungen. Durch die direkte Angabe der Kardinalität (z. B. null oder mehr, eins oder mehr oder eins) für Beziehungsfelder können Sie strukturelle Erwartungen in Ihrem Beziehungsgraphen durchsetzen und mithilfe von Neomodel Dateninkonsistenzen vermeiden. Indizes und Einschränkungen werden automatisch auf Basis der Modelldefinitionen erstellt und können über CLI-Dienstprogramme kontrolliert in der Datenbank angewendet oder entfernt werden.

Neomodel unterstützt Transaktionsverarbeitung vollständig und ist sicher in Multithread-Umgebungen einsetzbar. Transaktionen lassen sich vorhersehbar öffnen und abschließen, und da die Abstraktionsschicht um den offiziellen Treiber bewusst schlank gehalten ist, ist der Leistungsverlust gering. Benchmarks mit Tools wie Locust zeigen, dass die Abstraktionsschicht von Neomodel selbst unter gleichzeitiger Last nur minimale Latenz verursacht.

Versionsunterstützung, SemVer und Konfiguration

Moderne Neomodel-Releases folgen der semantischen Versionierung (SemVer) nach dem klassischen Schema Hauptversion.Nebenversion.Patch. Das bedeutet, dass grundlegende Änderungen nur mit Hauptversionserhöhungen eingeführt werden, neue Funktionen ohne grundlegende Änderungen als Nebenversionen und Fehlerbehebungen als Patch-Versionen. Diese Versionierungsstrategie vereinfacht die Planung von Upgrades, insbesondere für Produktionssysteme.

Die 6.x-Serie von Neomodel zielt auf aktuelle Python- und Neo4j-Versionen ab, um den Anforderungen der meisten professionellen Installationen gerecht zu werden. Konkret benötigt Neomodel 6.x Python 3.10 oder höher und unterstützt Neo4j 5.x, Neo4j 4.4 LTS sowie die neuere Neo4j-Reihe 2025.xx. Sowohl Neo4j Community, Neo4j Enterprise als auch Neo4j Aura (der gehostete Dienst) werden unterstützt und bieten Ihnen somit Flexibilität bei der Wahl des Hosting-Standorts Ihrer Datenbank.

Für ältere Umgebungen unterstützen frühere Neomodel-Zweige weiterhin ältere Python- und Neo4j-Kombinationen. Die 5.x-Reihe unterstützt Python 3.8+ mit Neo4j 5.x und 4.4 (LTS), während die 4.x-Reihe Python 3.7 bis 3.10 und Neo4j 4.x, einschließlich 4.4 LTS bei Verwendung von Neomodel 4.0.10, abdeckt. Diese Kompatibilität ermöglicht eine schrittweise Migration, ohne die bestehenden Systeme zu beeinträchtigen.

Ab Neomodel 6 erfolgt die Konfiguration über eine moderne, typannotierte Datenklasse mit Laufzeitvalidierung und Unterstützung für Umgebungsvariablen. Anstelle verstreuter Ad-hoc-Einstellungen werden Konfigurationsfelder bei Aktualisierung validiert, einschließlich Typüberprüfungen und logischer Einschränkungen. Umgebungsvariablen ermöglichen das einfache Überschreiben der Konfiguration, was optimal mit containerisierten Bereitstellungen und Cloud-Umgebungen harmoniert.

Die Version 6.0 enthält außerdem explizite Änderungen, die die Kompatibilität beeinträchtigen, sowie Verhaltenskorrekturen, um die API besser vorhersehbar zu machen. Die Listenauflösung von Cypher liefert nun beispielsweise die erwartete Tiefe zurück: eine Abfrage wie RETURN collect(node) wird zugeordnet results[0][0] anstelle der vorherigen, unintuitiven results[0][0][0] Die Kardinalitätsprüfungen sind strenger und standardmäßig aktiviert, und mehrere eigenständige Hilfsfunktionen wurden in die zentrale Struktur verschoben. Database() und AsyncDatabase() Singleton-Klassen.

Installation und Einrichtung

Die empfohlene Installationsmethode für Neomodel ist die direkte Installation über PyPI mit Ihrem bevorzugten Paketmanager. Sie können es mit einem einfachen Installationsbefehl in eine virtuelle Umgebung einbinden und anschließend Aktualisierungen über Ihre gewohnten Abhängigkeitsverwaltungstools durchführen. Falls Sie die aktuellsten Änderungen benötigen oder mitwirken möchten, ist die Installation auch direkt über das GitHub-Repository möglich.

Bevor Sie neomodel-Code ausführen, müssen Sie die Verbindungs-URL konfigurieren, damit die Bibliothek weiß, wie sie Ihre Neo4j-Instanz erreichen kann. Diese Konfiguration umfasst typischerweise das Schema (Bolt oder Neo4j), Host, Port, Benutzername, Passwort und optional den Datenbanknamen. Bei Django-Projekten wird diese Konfiguration üblicherweise in folgendem Verzeichnis abgelegt: settings.py Es wird also initialisiert, sobald die Anwendung startet.

Wenn Ihr Neo4j-Server neu installiert ist, sollten Sie das Standardpasswort über den Neo4j-Browser oder das Admin-Panel ändern. Standardmäßig ist dieses Bedienfeld unter folgender Adresse zugänglich: http://localhost:7474Sobald Sie das Passwort aktualisiert und bestätigt haben. dbms.security.auth_enabled=true In der Datenbankkonfiguration sind Sie bereit, eine Verbindung von neomodel herzustellen.

Für Entwicklung und Tests ist es üblich, separate Neo4j-Datenbanken und dedizierte Zugangsdaten zu verwenden. Die Testsuite von Neomodel setzt eine Neo4j-Datenbank ab Version 4 voraus und verwendet bestimmte Umgebungsvariablen für die Verbindung. Wenn Sie die Tests auf einer neu erstellten Datenbank ausführen, setzt die Testsuite das Passwort auf test Standardmäßig ist dies der Fall; wenn ein bereits vorhandener Datensatz erkannt wird, verweigert das Programm die Fortsetzung, es sei denn, Sie übergeben explizit ein Reset-Flag, wodurch Sie versehentlichen Datenverlust vermeiden können.

Wenn Sie neomodel mit verschiedenen Python- und Neo4j-Versionen testen möchten, können Docker und docker-compose alles automatisch orchestrieren. Das Projekt bietet eine Konfiguration, um eine Matrix von Interpreterversionen und Neo4j-Releases zu erstellen, sodass Integrationstests konsistent ausgeführt werden können. Dies ist besonders nützlich, wenn Sie Funktionen beisteuern, die mit mehreren unterstützten Versionen kompatibel sein sollen.

Kernfunktionen: Modelle, Schema und Indizes

Das Herzstück von Neomodel sind seine klassenbasierten Modelldefinitionen, die direkt auf Neo4j-Knotenbezeichnungen und -Beziehungen abgebildet werden. Ihre Knotenklassen leiten Sie typischerweise ab von StructuredNodeund Beziehungsklassen von StructuredRelKnotenfelder werden mithilfe von neomodellspezifischen Eigenschaftstypen definiert, die steuern, wie Daten in Neo4j gespeichert und validiert werden.

Jede Modellklasse wird in Neo4j zu einem Label, und neomodel verwaltet Indizes und Constraints automatisch anhand Ihrer Definitionen. Das bedeutet, dass Eindeutigkeit, erforderliche Eigenschaften und indizierte Felder in Python festgelegt werden können, ohne dass die Cypher-Befehle für die Schemaerstellung manuell geschrieben werden müssen. Im Hintergrund übersetzt neomodel Ihre Modellmetadaten in die entsprechenden Neo4j-Schemaoperationen.

Beziehungen werden Knotenklassen mithilfe spezieller Deskriptoren wie z. B. zugeordnet. RelationshipTo, RelationshipFrom und Relationship. Diese Deskriptoren definieren die Art der Beziehung, die Kardinalität und die Traversierungsrichtung. RelationshipTo und RelationshipFrom unidirektionale Navigation aus der Python-Perspektive ausdrücken, während Relationship wird verwendet, wenn Sie die Beziehung im Code als in beide Richtungen navigierbar behandeln möchten, obwohl Neo4j selbst Beziehungen immer mit einer Richtung speichert.

Wenn Beziehungen logisch bidirektional sind, empfiehlt es sich, die Erstellung zweier gespiegelter Felder zu vermeiden und stattdessen ein einziges Feld zu verwenden. Relationship stattdessen. Dadurch bleibt Ihr Modell übersichtlich und konsistent, während gleichzeitig die Traversierung in beide Richtungen in Ihrem Python-Code ermöglicht wird. Neo4j speichert intern weiterhin gerichtete Beziehungen, aber die Abstraktion von neomodel verbirgt dieses Detail bei der Traversierung.

Für Szenarien, in denen die Knotenstrukturen nicht vollständig im Voraus bekannt sind, bietet das Neomodell eine SemiStructuredNode Basisklasse. Von diesem Typ abgeleitete Klassen können „ad-hoc“-Eigenschaften enthalten, die im Modell nicht explizit definiert wurden. Dies ist besonders praktisch, wenn sich Ihr Graphschema häufig ändert oder wenn Sie gelegentlich zusätzliche Attribute hinzufügen müssen, ohne das Modell jedes Mal neu zu strukturieren.

Kardinalitätsregeln legen die Anzahl zulässiger Beziehungen zwischen Knoten fest und werden in Neomodel 6 durch strengere Prüfungen abgesichert. Weiche Kardinalitätsprüfungen sind für alle Beziehungskardinalitäten verfügbar, die strenge Prüfung ist standardmäßig aktiviert. Wenn Ihre Daten gegen die konfigurierten Beziehungsregeln verstoßen, meldet Neomodel dieses Problem, anstatt eine inkonsistente Struktur stillschweigend bestehen zu lassen.

Automatische Schemaverwaltung und -prüfung

Sobald Sie Ihre Modelle definiert oder aktualisiert haben, müssen Sie die entsprechenden Einschränkungen und Indizes auf die Neo4j-Datenbank anwenden. Neomodel wird mit einem Skript namens „…“ ausgeliefert. neomodel_install_labels Dieses Skript durchsucht Ihre Modelle und erstellt oder aktualisiert die erforderlichen Indizes und Einschränkungen. Nach einer Schemaänderung sollten Sie dieses Skript ausführen und die Anzahl der verarbeiteten Klassen überprüfen, um sicherzustellen, dass alles synchronisiert ist.

Falls Sie jemals von Neomodel verwaltete Einschränkungen und Indizes löschen müssen, gibt es einen ergänzenden Befehl namens neomodel_remove_labels. Dieses Skript entfernt automatisch alle vorhandenen Einschränkungen und Indizes, die Neomodel zuvor installiert hat. Es gibt außerdem aus, was entfernt wurde, sodass Sie die Auswirkungen des Vorgangs deutlich erkennen können.

Beide Schema-Verwaltungsbefehle unterstützen ein --db Argument und Standardwert auf die NEO4J_BOLT_URL Umgebungsvariable, falls nicht angegeben. Dieses Verhalten trägt dazu bei, dass Anmeldeinformationen und Verbindungsdetails nicht im Befehlszeilenverlauf gespeichert werden und ermöglicht eine einfache Konfiguration über Umgebungsvariablen. Außerdem vereinfacht es die Verwaltung von Automatisierungs- und Bereitstellungsskripten.

Zusätzlich zur Schemaerstellung beinhaltet neomodel ein Datenbankinspektionstool, das einen bestehenden Graphen rückwärts analysieren und eine Modelldatei generieren kann. Verwendung der inspect Mit diesem Befehl (der die Installation von APOC-Prozeduren in Neo4j erfordert) können Sie eine Datenbank scannen und ein Ergebnis erzeugen. models.py Datei unter einem Zielverzeichnis wie z.B. yourappDie generierte Datei enthält Importe, Knotenklassendefinitionen und Beziehungsdefinitionen, die der erkannten Graphstruktur entsprechen.

Der Inspektionsprozess kann für große Graphen optimiert werden, indem Beziehungseigenschaften und Kardinalitätsprüfungen übersprungen werden. Bei Datenbanken mit Hunderttausenden von Knoten und mehr als einer Million Beziehungen kann der vollständige Scan Dutzende von Sekunden dauern. Optionen wie --no-rel-props und --no-rel-cardinality Beschleunigen Sie den Vorgang, indem Sie auf detaillierte Analysen verzichten, Beziehungsfelder aber weiterhin generieren, die Kardinalität jedoch standardmäßig auf einen generischen Wert wie ZeroOrMore setzen.

Arbeiten mit der Neomodel Query API

Mit der Query API von Neomodel können Sie komplexe Graphabfragen über Python-Methoden auf Ihren Modellklassen durchführen, anstatt Cypher direkt zu schreiben. Jedes Modell legt ein .nodes Ein managerähnliches Attribut, das eine Gruppe von Knoten mit der entsprechenden Bezeichnung repräsentiert. Von dort aus können Sie zählen, filtern, sortieren, segmentieren und die zugrunde liegenden Graphdaten abrufen.

maximal einfach anrufen len(MyModel.nodes) löst eine Cypher-Abfrage aus, die die Knoten mit dem entsprechenden Label zählt MyModel. Dies bietet eine intuitive Möglichkeit, Zählungen zu erhalten, ohne die Python-Syntax verlassen zu müssen. Wenn Ihre Knotenmenge bereits gefiltert ist, spiegelt die Zählung nur die Knoten wider, die diesen Filtern entsprechen – genau das Verhalten, das man von einem typischen ORM erwartet.

Das Slicing wird direkt auf Knotensätzen unterstützt, was äußerst nützlich ist, wenn Sie mit gebündelten Ergebnissen arbeiten möchten. Ausdrücke wie MyModel.nodes[0:10] Es wird eine segmentierte Knotenmenge zurückgegeben, die Sie durchlaufen oder mit zusätzlichen Filtern verketten können. Das Segment gibt nicht sofort eine Rohliste zurück, sondern ein weiteres Knotenmengenobjekt, sodass Sie komplexe Abfragen schrittweise erstellen können.

Node Sets unterstützen Iteration und boolesche Prüfungen, wobei Längen- und Wahrheitsprüfungen terminal sind. Sobald Sie bewerten len() Oder verwenden Sie eine Knotengruppe in einem booleschen Kontext, so lösen Sie effektiv einen Auswertungsschritt aus, der ein konkretes Ergebnis anstelle eines weiteren verkettbaren Abfrageobjekts zurückgibt. Dieses Design vereint die Vorteile der Python-Idiome mit der verzögerten Abfrageerstellung.

Zum Abrufen tatsächlicher Objekte verwendet man typischerweise Methoden wie .all() und .get() auf die .nodes Manager. Diese Methoden können empfangen lazy=True Dieses Argument gibt lediglich die Knoten-IDs anstelle der vollständigen Objekte mit all ihren Eigenschaften zurück. Dies ist hilfreich, wenn Sie den Datentransfer minimieren oder Folgeabfragen manuell anhand der IDs durchführen möchten.

Erstellen, Aktualisieren, Löschen und Beziehungen

Das Erstellen von Knoten mit Neomodel ist so einfach wie das Instanziieren Ihrer Modellklasse und der Aufruf von save(). Sobald Sie Ihre Eigenschaften und Standardwerte definiert haben, können Sie eine Instanz mit den gewünschten Feldwerten erstellen und diese aufrufen. saveNeomodel erstellt oder aktualisiert dann den entsprechenden Knoten in Neo4j. Dies ist analog zur Vorgehensweise der meisten ORMs beim Persistenzmanagement.

Das Aktualisieren von Knoten folgt demselben Muster: Eine Instanz wird abgerufen, ihren Attributen werden neue Werte zugewiesen und sie wird erneut gespeichert. Neomodel generiert den passenden Cypher-Code, um nur die geänderten Eigenschaften des bestehenden Knotens zu modifizieren. Dadurch bleibt Ihr Code übersichtlich und die Details der Aktualisierungsvorgänge bleiben von Ihrer Geschäftslogik getrennt.

Das Löschen eines Knotens erfolgt ebenfalls direkt: Sobald Sie eine Instanz haben, rufen Sie deren Methode auf. delete() Methode. Dadurch wird der Knoten entfernt und, abhängig von Ihrer Beziehungskonfiguration und den Einschränkungen der Datenbank, gegebenenfalls auch zugehörige Beziehungen. Vor- und Nachlöschvorgänge können für ein erweitertes Verhalten oder eine Protokollierung definiert werden.

Beziehungen zwischen Knoten werden über Beziehungsfelder und praktische Methoden wie z. B. verwaltet. connect(). Sobald Sie zwei Knoten haben, können Sie beispielsweise Folgendes aufrufen: actor.movies.connect(movie) um eine geeignete Beziehungsinstanz im Graphen zu erstellen. Beziehungseigenschaften können modelliert werden über StructuredRel-basierte Klassen, die Ihnen die Möglichkeit geben, Attribute auch an Kanten zu speichern.

Komplexere Graphdurchläufe lassen sich durch das Verfolgen von Beziehungsattributen oder durch die Kombination von Abfragefiltern über Beziehungen hinweg erreichen. Zum Beispiel könnten Sie mit einem Entity Man filtert eine Gruppe von Knoten nach einer bestimmten Eigenschaft und durchläuft dann die zugehörigen Knoten, um auch deren Attribute zu filtern. Dadurch wird im Hintergrund schrittweise eine Cypher-Abfrage erstellt, die von Neomodel ausgeführt wird.

Asynchrones Neomodel und transpilierte synchrone API

Neomodel bietet asynchrone Unterstützung, die auf den asynchronen Funktionen des offiziellen Neo4j-Python-Treibers aufbaut. Dadurch lassen sich Neo4j-Operationen in moderne asynchrone Python-Frameworks und -Dienste integrieren und die Vorteile der Parallelverarbeitung für Workloads mit vielen E/A-intensiven Operationen voll ausschöpfen.

Leistungstests mit Tools wie Locust haben gezeigt, dass das asynchrone Neomodel bei gleichzeitiger Verwendung sowohl serielle Abfragen als auch gleichzeitig ausgeführte synchrone Neomodel-Aufrufe übertrifft. Da viele Graphoperationen Netzwerk-E/A und das Warten auf Datenbankantworten erfordern, führt die gleichzeitige Verarbeitung mehrerer Abfragen durch die Ereignisschleife zu einem besseren Durchsatz und einer effizienteren Ressourcennutzung.

Intern sorgt neomodel für die Angleichung der asynchronen und synchronen APIs durch einen Transpilierungsschritt, der asynchronen Code in sein synchrones Äquivalent umwandelt. Eine spezielle Bibliothek wird verwendet, um automatisch zu entfernen await Schlüsselwörter, Klassen umbenennen (z. B. entfernen) Async Präfixe) und führen gezielte Ersetzungen durch, wie z. B. das Ändern von adb zu db or mark_async_test zu mark_sync_testDieser Ansatz vermeidet die Pflege zweier völlig getrennter Codebasen.

Bei Ihren Beiträgen arbeiten Sie hauptsächlich an der asynchronen Implementierung unter neomodel/async_ und führen Sie anschließend das bereitgestellte Transpilierungsskript aus, um die synchrone Variante zu generieren. Sie können auch Pre-Commit-Hooks verwenden, um diesen Schritt zu automatisieren und sicherzustellen, dass beide Versionen synchron bleiben. In vielen Fällen muss Ihre Geschäftslogik nur einmal in der asynchronen Schicht geschrieben werden.

Manche Funktionen sind möglicherweise nur für die asynchrone oder nur für die synchrone Verwendung vorgesehen. Neomodel stellt ein Hilfsmuster (inspiriert vom offiziellen Neo4j-Treiber) bereit, um diese Codepfade zu trennen. Dadurch können Sie Verhaltensweisen definieren, die sich zwischen den beiden Modi unterscheiden, während Ihre API insgesamt konsistent bleibt. Testmodule, wie beispielsweise die für die Match-API, demonstrieren, wie asynchroner Code transpiliert wird und wie sich der resultierende synchrone Code verhält.

Datenbank- und AsyncDatabase-Singletons

Im Neomodell 6, Database() und AsyncDatabase() Die Klassen werden als echte Singletons implementiert, um zu verdeutlichen, wie globale Operationen gehandhabt werden. Anstatt eigenständige Hilfsfunktionen zu verteilen, gruppiert neomodel nun datenbankweite Operationen in diesen Singleton-Instanzen, wodurch die API besser auffindbar und konsistenter wird.

Mehrere ältere Funktionen wurden in die Database() Die Klasse wurde aus dem globalen Namensraum entfernt. Beispiele umfassen change_neo4j_password, clear_neo4j_database, drop_constraints, drop_indexes, remove_all_labels, install_labels und install_all_labelsDie asynchronen Gegenstücke sind über die AsyncDatabase() Singleton, üblicherweise bezeichnet als adb im asynchronen Kontext.

Diese Neugestaltung vereinfacht das Verständnis von Datenbankoperationen und vermeidet Unklarheiten im Umgang mit Konfiguration und globalem Zustand. Da synchrone und asynchrone Modi eine ähnliche Struktur aufweisen, lässt sich leichter nachvollziehen, wann ein sicherer Wechsel zwischen den Ansätzen möglich ist oder wann beide parallel in verschiedenen Teilen einer größeren Anwendung ausgeführt werden können.

Darüber hinaus wurde mit Version 6.0 Folgendes eingeführt: merge_by Parameter für Batch-Operationen, der eine bessere Kontrolle darüber ermöglicht, wie Knoten und Beziehungen zusammengeführt werden. Sie können individuell festlegen, welche Bezeichnungen und Eigenschaftsschlüssel die Eindeutigkeit für Stapelzusammenführungen definieren. Dies ist von entscheidender Bedeutung bei der Verarbeitung großer Datenmengen oder bei Synchronisierungsaufgaben.

Django-Integration und praktische Anwendung

Neomodel lässt sich nahtlos in Django integrieren. django_neomodel Paket, mit dem Sie Ihre Graphmodelle als Teil eines Django-Projekts behandeln können. Durch diese Integration befindet sich die Konfiguration typischerweise in settings.pyund Ihre Knoten- und Beziehungsklassen koexistieren mit dem Rest Ihres Django-Ökosystems, einschließlich Apps, Middleware und Views.

Ein konkretes Beispiel ist ein mehrteiliges Django-Tutorial, das neomodel verwendet, um eine Graphdatenbank im Stil der Paradise Papers zu erkunden und zu durchsuchen. In den ersten Teilen richten Sie das Django-Projekt ein und integrieren Neomodel; in späteren Teilen erstellen Sie ein fetch_api In der App werden Modelle definiert, die Entitäten, Beziehungen und Eigenschaften im Graphen widerspiegeln. Anschließend werden schrittweise Hilfsprogramme und Ansichten darauf aufgebaut.

Innerhalb eines solchen Projekts können Sie Neomodel-Modelle direkt in Django-Views, Serialisierern oder Hilfsmodulen verwenden. Ein gängiger Ansatz besteht darin, ein/e zu erstellen utils.py Datei, in der Sie Hilfsfunktionen definieren, die die Abfrage-API aufrufen. Zum Beispiel könnten Sie Folgendes implementieren count_nodes, fetch_nodes und fetch_node_details Hilfsfunktionen, die Filter, Paginierungsparameter und Modellnamen dynamisch aufnehmen.

Manche Daten, wie zum Beispiel Listen von Ländern, Gerichtsbarkeiten oder Datenquellen, könnten bei wiederholter Abfrage teuer sein. Daher können Sie diese mit rohem Cypher vorab berechnen und als Konstanten speichern. A constants.py Das Modul kann diese Cypher-Abfragen einmal ausführen und sortierte Listen wie diese ableiten. COUNTRIES, JURISDICTIONS und DATASOURCEund sorgen Sie dafür, dass sie in Ihrer Django-App problemlos importiert werden können.

Um sicherzustellen, dass diese Konstanten beim Start der Anwendung verfügbar sind, können Sie sich in die App-Konfiguration von Django einklinken, indem Sie eine definieren ready() Methode in fetch_api/app.py. Innerhalb dieser Methode importieren Sie constants.pyDadurch werden die ersten Cypher-Abfragen ausgelöst und die entsprechenden Listen gefüllt. Auf diese Weise können nachfolgende Anfragen einfach aus den bereits vorbereiteten Datenstrukturen lesen.

Raw Chipher vs. OGM für komplexe Anfragen

Neomodels OGM eignet sich zwar ideal für alltägliche CRUD-Operationen und die Traversierung von Beziehungen, es gibt jedoch Szenarien, in denen manuell geschriebene Cypher-Abfragen effizienter sind. Tief verschachtelte Traversierungen, Abfragen zweiter Ordnung oder mit mehreren Hops sowie komplexe Aggregationen lassen sich mitunter klarer und performanter als reine Cypher-Abfragen ausdrücken als als OGM-Ketten.

Ein typisches Beispiel ist die Suche nach Co-Darstellern, die in einem Film an der Seite eines bestimmten Schauspielers aufgetreten sind, etwa nach allen Personen, die mit Tom Hanks zusammengearbeitet haben. Als Cypher-Abfrage lässt sich dies recht direkt umsetzen: Man sucht den Schauspieler, durchläuft die Filme, in denen er mitgewirkt hat, und anschließend die anderen Schauspieler in diesen Filmen, wobei bei Bedarf Filter und Aggregationen angewendet werden. Das Ergebnis ist ein prägnantes, optimiertes Graphmuster.

Um dasselbe Verhalten ausschließlich mithilfe von OGM-Hilfsmethoden nachzubilden, wäre ein Prozess mit einer Komplexität von O(n²) erforderlich, der Filme und zugehörige Akteure auf Python-Ebene durchläuft. Dies ist sowohl weniger elegant als auch weniger effizient, als Neo4j die rechenintensive Arbeit in einer einzigen Cypher-Anweisung erledigen zu lassen. Es zeigt, dass OGMs keine Universallösung für jedes Zugriffsmuster auf einen Graphen darstellen.

Bei der Verwendung von OGM-Operationen für tiefe Traversierungen kann die Struktur der zurückgegebenen Daten zudem recht komplex werden. Der generierte Cypher enthält häufig den Startknoten, Zwischenbeziehungen, Nachbarknoten und deren Beziehungen. Dies kann hilfreich sein, wenn umfangreiche Kontextinformationen benötigt werden, ist aber möglicherweise übertrieben, wenn lediglich bestimmte aggregierte Ergebnisse oder eine Teilmenge von Eigenschaften benötigt werden.

In Situationen, in denen Leistung und Klarheit von größter Bedeutung sind, cypher_query Die direkte Ausführung eines handgefertigten Chiffres kann die bessere Option sein. Neomodel macht diesen Ausweg absichtlich: Sie können High-Level-OGM-Interaktionen mit Low-Level-Cypher im selben Projekt kombinieren und für jede bestimmte Abfrage das richtige Werkzeug auswählen, während die Modelle dennoch die einzige Quelle der Wahrheit für Ihr Schema bleiben.

Neomodel in Neo4j Labs und Projektsteuerung

Neomodels Beitritt zum Neo4j Labs-Programm formalisierte seinen Status als aktiv gepflegtes, gemeinschaftlich getragenes Projekt mit klaren Qualitätsstandards. Neo4j Labs dient als Plattform für experimentelle und fortgeschrittene Projekte, die bereits erfolgreich eingesetzt werden, aber nicht zum Kernprodukt gehören. Viele bekannte Tools, wie Graph-Data-Science-Komponenten, die GraphQL-Bibliothek, APOC Core und Streaming-Integrationen, haben ihren Ursprung in diesem Programm.

Die Zugehörigkeit zu Neo4j Labs bedeutet, dass neomodel die grundlegenden Standards für Tests, Sicherheitsprüfungen und automatisierte Tools wie CI/CD-Pipelines einhält. Das Wartungsteam führt Integrationstests mit einer Vielzahl von Python- und Neo4j-Versionen durch und gewährleistet so die Kompatibilität mit neuen Releases. Dies ist einer der Gründe, warum neomodel volle Unterstützung für alle aktuell unterstützten Python- und Neo4j-Versionen, sowohl Community als auch Enterprise, bieten kann.

Das Projekt bleibt vollständig Open Source und Community-orientiert. GitHub dient als zentrale Plattform für Probleme, Diskussionen und Beiträge. Das Problemprotokoll wird wieder aktiv gepflegt, ältere Einträge werden nach Möglichkeit priorisiert und zusammengefasst. Der Diskussionsbereich ist für alle zugänglich und wird für Ankündigungen und Designgespräche genutzt. Mindestens ein Neo4j-Mitarbeiter ist als Maintainer tätig und bringt so seine Praxiserfahrung in das Projekt ein.

Reale Produktionsprojekte wie OpenStudyBuilder von Novo Nordisk spielen eine wichtige Rolle bei der Gestaltung der Roadmap von neomodel. Diese umfangreichen, praxisnahen Anwendungen liefern konkrete Anforderungen und Feedback, die in neue Funktionen und Verbesserungen münden, welche wiederum der Community zur Verfügung gestellt werden. Dieser positive Kreislauf zeigt, wie sich Unternehmenseinsatz und Open-Source-Entwicklung gegenseitig verstärken können.

Mit seiner Python-basierten Modellierung, der starken Neo4j-Kompatibilität, den asynchronen und synchronen APIs und der aktiven Weiterentwicklung durch das Lab bietet neomodel eine überzeugende Möglichkeit, in kleinen Projekten wie auch in anspruchsvollen Produktionssystemen mit Graphen in Python zu arbeiten. Bei durchdachter Anwendung – mit dem OGM für eine klare Domänenmodellierung und typische Graphinteraktionen sowie dem Einsatz von Cypher für komplexe Muster oder Performance-Anforderungen – kann es die Entwicklung, Abfrage und Wartung graphenbasierter Anwendungen deutlich vereinfachen.