Programmatisk udførelse af CRUD-operationer
Udfør Cypher-forespørgsler fra Deres applikation for dynamisk at oprette, læse, opdatere og slette grafdata.
Programmatisk udførelse af CRUD-operationer er en gratis Grundlæggende om grafdatabasen Neo4j-lektion på CoddyKit. Dette er lektion 2 af 4. Du kan læse alle 3 lektioner i dette læringsspor gratis i deres fulde længde — derefter låser CoddyKit PRO alle lektioner op samt praktiske øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Den er en del af læringsforløbet i Grundlæggende om grafdatabasen Neo4j, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Grundlæggende om grafdatabasen Neo4j-kurset indeholder 4 lektioner i alt.
CRUD fra din applikation
Når du udvikler applikationer, får du ofte brug for at arbejde programmatisk med din Neo4j-database. Det betyder, at du skriver kode, der sender Cypher-forespørgsler for at oprette, læse, opdatere og slette data.
Disse grundlæggende handlinger kaldes ofte CRUD:
- Create: Tilføjelse af nye data (noder, relationer).
- Read: Hentning af eksisterende data.
- Update: Ændring af eksisterende data.
- Delete: Fjernelse af data.
Opret forbindelse til Neo4j (opsamling)
Før du udfører CRUD-handlinger, skal din applikation oprette forbindelse til Neo4j-databasen. Som vi tidligere har lært, gør den officielle Neo4j Python-driver dette enklere.
Du bruger et GraphDatabase.driver-objekt til at administrere forbindelser og opretter derefter en session til at udføre forespørgsler.
from neo4j import GraphDatabase
URI = "bolt://localhost:7687"
AUTH = ("neo4j", "password") # Use your credentials
def main():
driver = GraphDatabase.driver(URI, auth=AUTH)
with driver.session() as session:
# Your Cypher queries will go here
print("Connected to Neo4j!")
driver.close()
if __name__ == "__main__":
main()Oprettelse af nye noder
Hvis du vil føje nye entiteter til din graf, bruger du Cypher-CREATE-sætningen. Programmatisk sender du din Cypher-forespørgselsstreng og eventuelle parametre til metoden session.run().
Det er afgørende at bruge parametre (som $name og $age) af hensyn til sikkerheden, og det forhindrer Cypher-injektion.
from neo4j import GraphDatabase
URI = "bolt://localhost:7687"
AUTH = ("neo4j", "password")
def main():
driver = GraphDatabase.driver(URI, auth=AUTH)
with driver.session() as session:
query = (
"CREATE (p:Person {name: $name, age: $age}) "
"RETURN p.name AS name"
)
result = session.run(query, name="Charlie", age=25)
print(f"Created: {result.single()['name']}")
driver.close()
if __name__ == "__main__":
main()Oprettelse af relationer
Relationer forbinder noder og er afgørende for grafstrukturer. Hvis du vil oprette en relation, skal du først identificere de noder, du vil forbinde, normalt med MATCH, og derefter bruge CREATE.
Eksemplet forbinder 'Charlie' (som blev oprettet ovenfor) med 'Alice' (vi sikrer, at hun findes i denne demonstration).
from neo4j import GraphDatabase
URI = "bolt://localhost:7687"
AUTH = ("neo4j", "password")
def main():
driver = GraphDatabase.driver(URI, auth=AUTH)
with driver.session() as session:
# Ensure Alice exists for the demo
session.run("MERGE (:Person {name: 'Alice', age: 30})")
query = (
"MATCH (a:Person {name: $name1}), "
"(b:Person {name: $name2}) "
"CREATE (a)-[r:KNOWS]->(b) "
"RETURN type(r) AS relType"
)
result = session.run(query, name1="Charlie", name2="Alice")
print(f"Relationship created: {result.single()['relType']}")
driver.close()
if __name__ == "__main__":
main()Læsning af noder (<code>MATCH</code> og <code>RETURN</code>)
Du henter data ved at bruge MATCH-sætningen til at finde mønstre og RETURN til at angive, hvilke data du vil have tilbage. Du kan hente hele noder eller bestemte egenskaber.
Metoden session.run() returnerer et resultatobjekt, som du kan iterere over.
from neo4j import GraphDatabase
URI = "bolt://localhost:7687"
AUTH = ("neo4j", "password")
def main():
driver = GraphDatabase.driver(URI, auth=AUTH)
with driver.session() as session:
query = "MATCH (p:Person) RETURN p.name AS name, p.age AS age"
print("All People:")
for record in session.run(query):
print(f"- {record['name']} ({record['age']} years old)")
driver.close()
if __name__ == "__main__":
main()Læsning af forbundne mønstre
Grafdatabaser er særligt gode til at forespørge på forbundne data. Du kan matche komplekse mønstre af noder og relationer og hente bestemte dele af mønstret.
Dette eksempel finder personer, der kender 'Alice', og returnerer deres navne.
from neo4j import GraphDatabase
URI = "bolt://localhost:7687"
AUTH = ("neo4j", "password")
def main():
driver = GraphDatabase.driver(URI, auth=AUTH)
with driver.session() as session:
query = (
"MATCH (p:Person)-[:KNOWS]->(a:Person {name: $targetName}) "
"RETURN p.name AS knowsAlice"
)
result = session.run(query, targetName="Alice")
print("People who know Alice:")
for record in result:
print(f"- {record['knowsAlice']}")
driver.close()
if __name__ == "__main__":
main()Opdatering af nodeegenskaber
Hvis du vil ændre eksisterende data, bruger du MATCH til at finde noden eller noderne eller relationen eller relationerne og derefter SET-sætningen til at ændre deres egenskaber.
Her opdaterer vi 'Charlies alder til 26.
from neo4j import GraphDatabase
URI = "bolt://localhost:7687"
AUTH = ("neo4j", "password")
def main():
driver = GraphDatabase.driver(URI, auth=AUTH)
with driver.session() as session:
query = (
"MATCH (p:Person {name: $name}) "
"SET p.age = $newAge "
"RETURN p.name AS name, p.age AS newAge"
)
result = session.run(query, name="Charlie", newAge=26)
record = result.single()
print(f"Updated {record['name']}'s age to {record['newAge']}")
driver.close()
if __name__ == "__main__":
main()Opdatering af relationsegenskaber
Ligesom noder kan relationer også have egenskaber. Du kan opdatere dem ved at bruge MATCH til at finde relationen og SET til at ændre dens egenskaber.
Lad os føje egenskaben since til KNOWS-relationen mellem Charlie og Alice.
from neo4j import GraphDatabase
URI = "bolt://localhost:7687"
AUTH = ("neo4j", "password")
def main():
driver = GraphDatabase.driver(URI, auth=AUTH)
with driver.session() as session:
query = (
"MATCH (p1:Person {name: $name1})"
"-[r:KNOWS]->"
"(p2:Person {name: $name2}) "
"SET r.since = $year "
"RETURN p1.name, p2.name, r.since AS sinceYear"
)
result = session.run(query, name1="Charlie", name2="Alice", year=2022)
record = result.single()
print(f"{record['p1.name']} knows {record['p2.name']} since {record['sinceYear']}")
driver.close()
if __name__ == "__main__":
main()Sletning af grafdata
Hvis du vil fjerne noder og relationer, bruger du DELETE-sætningen. Hvis en node har relationer, skal du bruge DETACH DELETE for at fjerne både noden og dens relationer samtidig.
Hvis du kun bruger DELETE på en node med relationer, opstår der en fejl.
from neo4j import GraphDatabase
URI = "bolt://localhost:7687"
AUTH = ("neo4j", "password")
def main():
driver = GraphDatabase.driver(URI, auth=AUTH)
with driver.session() as session:
query = (
"MATCH (p:Person {name: $name}) "
"DETACH DELETE p"
)
result = session.run(query, name="Charlie")
print("Charlie and related data deleted.")
driver.close()
if __name__ == "__main__":
main()Hurtigt tjek: CRUD-handlinger
Du har lært, hvordan du udfører alle grundlæggende CRUD-handlinger. Lad os teste din forståelse.
Opsummering: Programmatisk CRUD
Godt gået! I denne lektion har du lært, hvordan du udfører de vigtigste CRUD-handlinger på din Neo4j-grafdatabase direkte fra en Python-applikation:
- Create: Brug
CREATEtil at tilføje noder og relationer. - Read: Brug
MATCHogRETURNtil at hente data. - Update: Brug
MATCHogSETtil at ændre egenskaber. - Delete: Brug
MATCHogDETACH DELETEtil at fjerne data.
Det er afgørende at beherske disse handlinger, hvis du vil bygge dynamiske og interaktive grafapplikationer.
Lær Grundlæggende om grafdatabasen Neo4j med en AI-underviser — gratis
Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.
- Kurser
- 12
- Lektioner
- 48
Ofte stillede spørgsmål
Er lektionen “Programmatisk udførelse af CRUD-operationer” gratis?
Ja — alle 3 lektioner i læringssporet Grundlæggende om grafdatabasen Neo4j, inklusive “Programmatisk udførelse af CRUD-operationer”, kan læses gratis i deres fulde længde her på webstedet. Derefter låser CoddyKit PRO alle lektioner op samt interaktive øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Grundlæggende om grafdatabasen Neo4j-kurset indeholder 4 lektioner i alt.
Hvad lærer jeg i “Programmatisk udførelse af CRUD-operationer”?
Udfør Cypher-forespørgsler fra Deres applikation for dynamisk at oprette, læse, opdatere og slette grafdata. Du øver dig i Grundlæggende om grafdatabasen Neo4j med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.
Skal jeg have erfaring for at begynde på Grundlæggende om grafdatabasen Neo4j?
Der kræves ingen tidligere erfaring. Grundlæggende om grafdatabasen Neo4j på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 2 af 4.
Hvor lang tid tager lektionen “Programmatisk udførelse af CRUD-operationer”?
De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.
Kan jeg skrive og køre kode i denne Grundlæggende om grafdatabasen Neo4j-lektion?
Ja. Alle Grundlæggende om grafdatabasen Neo4j-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.
Alle lektioner i dette kursus
- Forbindelse med Python-driveren
- Programmatisk udførelse af CRUD-operationer
- Håndtering af transaktioner og sessioner
- Forbindelsespooling og fejlhåndtering