Neo4j Graph Database Fundamentals · Aula

Executando Operações CRUD de Forma Programática

Execute consultas Cypher a partir da sua aplicação para criar, ler, atualizar e excluir dados de grafos dinamicamente.

Executando Operações CRUD de Forma Programática é uma aula grátis de Neo4j Graph Database Fundamentals no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Neo4j Graph Database Fundamentals, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Neo4j Graph Database Fundamentals inclui 4 aulas no total.

Partes desta aula ainda não foram traduzidas e aparecem em inglês.

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.

Perguntas Frequentes

A aula “Executando Operações CRUD de Forma Programática” é grátis?

Sim — o texto completo de “Executando Operações CRUD de Forma Programática” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Neo4j Graph Database Fundamentals, atualize para CoddyKit PRO. O curso de Neo4j Graph Database Fundamentals inclui 4 aulas no total.

O que vou aprender em “Executando Operações CRUD de Forma Programática”?

Execute consultas Cypher a partir da sua aplicação para criar, ler, atualizar e excluir dados de grafos dinamicamente. Você pratica Neo4j Graph Database Fundamentals com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Neo4j Graph Database Fundamentals?

Nenhuma experiência prévia é necessária. Neo4j Graph Database Fundamentals no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Executando Operações CRUD de Forma Programática”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Neo4j Graph Database Fundamentals?

Sim. Cada aula de Neo4j Graph Database Fundamentals inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

Conectando-se com o Driver do Python
Executando Operações CRUD de Forma Programática
Gerenciando Transações e Sessões
Agrupamento de Conexões e Tratamento de Erros

← Voltar para Neo4j Graph Database Fundamentals