Neo4j Graph Database Fundamentals · Pelajaran

Menjalankan Operasi CRUD secara Terprogram

Jalankan kueri Cypher dari aplikasi Anda untuk membuat, membaca, memperbarui, dan menghapus data graf secara dinamis.

Menjalankan Operasi CRUD secara Terprogram adalah pelajaran Neo4j Graph Database Fundamentals gratis di CoddyKit. Ini adalah pelajaran 2 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Neo4j Graph Database Fundamentals, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Neo4j Graph Database Fundamentals mencakup 4 pelajaran total.

Bagian dari pelajaran ini belum diterjemahkan dan ditampilkan dalam bahasa Inggris.

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.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Menjalankan Operasi CRUD secara Terprogram” gratis?

Ya — teks lengkap “Menjalankan Operasi CRUD secara Terprogram” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Neo4j Graph Database Fundamentals, upgrade ke CoddyKit PRO. Kursus Neo4j Graph Database Fundamentals mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Menjalankan Operasi CRUD secara Terprogram”?

Jalankan kueri Cypher dari aplikasi Anda untuk membuat, membaca, memperbarui, dan menghapus data graf secara dinamis. Kamu berlatih Neo4j Graph Database Fundamentals dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Neo4j Graph Database Fundamentals?

Tidak diperlukan pengalaman sebelumnya. Neo4j Graph Database Fundamentals di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 4.

Berapa lama pelajaran “Menjalankan Operasi CRUD secara Terprogram” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Neo4j Graph Database Fundamentals ini?

Ya. Setiap pelajaran Neo4j Graph Database Fundamentals menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

Menghubungkan dengan Driver Python
Menjalankan Operasi CRUD secara Terprogram
Menangani Transaksi dan Sesi
Pengumpulan Koneksi dan Penanganan Kesalahan

← Kembali ke Neo4j Graph Database Fundamentals