Neo4j Graph Database Fundamentals · Ders

CRUD İşlemlerini Programlı Olarak Gerçekleştirme

Graf verilerini dinamik olarak oluşturmak, okumak, güncellemek ve silmek için uygulamanızdan Cypher sorguları çalıştırın.

CRUD İşlemlerini Programlı Olarak Gerçekleştirme, CoddyKit'te ücretsiz bir Neo4j Graph Database Fundamentals dersidir. Bu, 4 dersinin 2. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Neo4j Graph Database Fundamentals öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Neo4j Graph Database Fundamentals kursu toplamda 4 dersten oluşur.

Bu dersin bazı bölümleri henüz çevrilmemiş olup İngilizce olarak gösterilmektedir.

CRUD from Your Application

When building applications, you'll often need to interact with your Neo4j database programmatically. This means writing code that sends Cypher queries to create, read, update, and delete data.

These fundamental operations are often referred to as CRUD:

Create: Adding new data (nodes, relationships).
Read: Retrieving existing data.
Update: Modifying existing data.
Delete: Removing data.

Connecting to Neo4j (Review)

Before performing any CRUD operations, your application needs to connect to the Neo4j database. As we learned previously, the official Neo4j Python Driver simplifies this.

You'll use a GraphDatabase.driver object to manage connections and then create a session to execute queries.

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()

Creating New Nodes

To add new entities to your graph, you use the Cypher CREATE clause. Programmatically, you pass your Cypher query string and any parameters to the session.run() method.

Using parameters (like $name, $age) is crucial for security and prevents Cypher injection.

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()

Creating Relationships

Relationships connect nodes and are essential for graph structures. To create a relationship, you first need to identify the nodes you want to connect, usually with MATCH, and then use CREATE.

The example connects 'Charlie' (created above) to 'Alice' (we'll ensure she exists for this demo).

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()

Reading Nodes (MATCH & RETURN)

Retrieving data is done using the MATCH clause to find patterns and RETURN to specify what data you want back. You can fetch entire nodes or specific properties.

The session.run() method returns a result object you can iterate 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()

Reading Connected Patterns

Graph databases excel at querying connected data. You can match complex patterns of nodes and relationships and retrieve specific parts of that pattern.

This example finds people who know 'Alice' and returns their names.

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()

Updating Node Properties

To modify existing data, you use MATCH to find the node(s) or relationship(s) and then the SET clause to change their properties.

Here, we'll update 'Charlie's age to 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()

Updating Relationship Properties

Just like nodes, relationships can also have properties. You can update these using MATCH to find the relationship and SET to modify its properties.

Let's add a since property to the KNOWS relationship between Charlie and 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()

Deleting Graph Data

To remove nodes and relationships, you use the DELETE clause. If a node has relationships, you must use DETACH DELETE to remove both the node and its relationships simultaneously.

Using just DELETE on a node with relationships will result in an error.

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()

Quick Check: CRUD Operations

You've learned how to perform all fundamental CRUD operations. Let's test your understanding.

Recap: Programmatic CRUD

Great job! In this lesson, you've learned how to perform essential CRUD operations on your Neo4j graph database directly from a Python application:

Create: Use CREATE to add nodes and relationships.
Read: Use MATCH and RETURN to retrieve data.
Update: Use MATCH and SET to modify properties.
Delete: Use MATCH and DETACH DELETE to remove data.

Mastering these operations is key to building dynamic and interactive graph applications.

Sıkça Sorulan Sorular

“CRUD İşlemlerini Programlı Olarak Gerçekleştirme” dersi ücretsiz mi?

Evet — “CRUD İşlemlerini Programlı Olarak Gerçekleştirme” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Neo4j Graph Database Fundamentals kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Neo4j Graph Database Fundamentals kursu toplamda 4 dersten oluşur.

“CRUD İşlemlerini Programlı Olarak Gerçekleştirme” dersinde ne öğreneceğim?

Graf verilerini dinamik olarak oluşturmak, okumak, güncellemek ve silmek için uygulamanızdan Cypher sorguları çalıştırın. Neo4j Graph Database Fundamentals ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

Neo4j Graph Database Fundamentals öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Neo4j Graph Database Fundamentals, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 2. dersidir.

“CRUD İşlemlerini Programlı Olarak Gerçekleştirme” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu Neo4j Graph Database Fundamentals dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Neo4j Graph Database Fundamentals dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

Python Sürücüsüyle Bağlanma
CRUD İşlemlerini Programlı Olarak Gerçekleştirme
İşlemleri ve Oturumları Yönetme
Bağlantı Havuzlama ve Hata İşleme

← Neo4j Graph Database Fundamentals Sayfasına Dön