Python CreateStatement.execute Examples

Example #1

def test_a_unique_relationship_is_really_unique(graph):
    results = graph.cypher.stream("CREATE (a)-[ab:KNOWS]->(b) RETURN a, ab, b")
    alice, alice_knows_bob, bob = next(results).values
    assert alice.degree == 1
    assert bob.degree == 1
    statement = CreateStatement(graph)
    statement.create_unique(Relationship(alice, "KNOWS", bob))
    statement.execute()
    assert alice.degree == 1
    assert bob.degree == 1

Example #2

File: cypher_create_test.py Project: JohannesOos/py2neo

def test_a_unique_relationship_is_really_unique(graph):
    results = graph.cypher.stream("CREATE (a)-[ab:KNOWS]->(b) RETURN a, ab, b")
    alice, alice_knows_bob, bob = next(results).values
    assert alice.degree == 1
    assert bob.degree == 1
    statement = CreateStatement(graph)
    statement.create_unique(Relationship(alice, "KNOWS", bob))
    statement.execute()
    assert alice.degree == 1
    assert bob.degree == 1

Example #3

def test_can_create_node_with_properties(graph):
    node = Node(name="Alice")
    statement = CreateStatement(graph)
    statement.create(node)
    created = statement.execute()
    assert created == (node, )
    assert node.bound

Example #4

def test_can_create_naked_node(graph):
    node = Node()
    statement = CreateStatement(graph)
    statement.create(node)
    created = statement.execute()
    assert created == (node, )
    assert node.bound

Example #5

File: cypher_create_test.py Project: JohannesOos/py2neo

def test_can_create_naked_node(graph):
    node = Node()
    statement = CreateStatement(graph)
    statement.create(node)
    created = statement.execute()
    assert created == (node,)
    assert node.bound

Example #6

File: cypher_create_test.py Project: JohannesOos/py2neo

def test_can_create_node_with_properties(graph):
    node = Node(name="Alice")
    statement = CreateStatement(graph)
    statement.create(node)
    created = statement.execute()
    assert created == (node,)
    assert node.bound

Example #7

File: cypher_create_test.py Project: JohannesOos/py2neo

def test_unique_path_not_unique_exception(graph):
    results = graph.cypher.stream("CREATE (a)-[ab:KNOWS]->(b), (a)-[:KNOWS]->(b) RETURN a, ab, b")
    alice, alice_knows_bob, bob = next(results).values
    assert alice.degree == 2
    assert bob.degree == 2
    statement = CreateStatement(graph)
    statement.create_unique(Relationship(alice, "KNOWS", bob))
    try:
        statement.execute()
    except CypherError as error:
        assert error.exception == "UniquePathNotUniqueException"
        assert error.fullname in [None, "org.neo4j.cypher.UniquePathNotUniqueException"]
        assert error.statement == ("START _0n0=node({_0n0}),_0n1=node({_0n1})\n"
                                   "CREATE UNIQUE (_0n0)-[_0r0:KNOWS]->(_0n1)\n"
                                   "RETURN _0n0,_0n1,_0r0")
    else:
        assert False

Example #8

def test_can_create_node_with_label(graph):
    if not graph.supports_node_labels:
        return
    node = Node("Person", name="Alice")
    statement = CreateStatement(graph)
    statement.create(node)
    created = statement.execute()
    assert created == (node, )
    assert node.bound

Example #9

File: cypher_create_test.py Project: JohannesOos/py2neo

def test_can_create_node_with_label(graph):
    if not graph.supports_node_labels:
        return
    node = Node("Person", name="Alice")
    statement = CreateStatement(graph)
    statement.create(node)
    created = statement.execute()
    assert created == (node,)
    assert node.bound

Example #10

def test_can_pass_entities_that_already_exist(graph):
    results = graph.cypher.stream("CREATE (a)-[ab:KNOWS]->(b) RETURN a, ab, b")
    alice, alice_knows_bob, bob = next(results).values
    statement = CreateStatement(graph)
    statement.create(alice)
    statement.create(bob)
    statement.create(alice_knows_bob)
    created = statement.execute()
    assert created == (alice, bob, alice_knows_bob)

Example #11

File: cypher_create_test.py Project: JohannesOos/py2neo

def test_can_pass_entities_that_already_exist(graph):
    results = graph.cypher.stream("CREATE (a)-[ab:KNOWS]->(b) RETURN a, ab, b")
    alice, alice_knows_bob, bob = next(results).values
    statement = CreateStatement(graph)
    statement.create(alice)
    statement.create(bob)
    statement.create(alice_knows_bob)
    created = statement.execute()
    assert created == (alice, bob, alice_knows_bob)

Example #12

File: cypher_create_test.py Project: JohannesOos/py2neo

def test_can_create_a_relationship_to_two_existing_nodes(graph):
    alice = graph.cypher.execute_one("CREATE (a {name:'Alice'}) RETURN a")
    bob = graph.cypher.execute_one("CREATE (b {name:'Bob'}) RETURN b")
    alice_knows_bob = Relationship(alice, "KNOWS", bob)
    statement = CreateStatement(graph)
    statement.create(alice_knows_bob)
    created = statement.execute()
    assert created == (alice_knows_bob,)
    assert alice_knows_bob.bound
    assert alice_knows_bob.start_node is alice
    assert alice_knows_bob.end_node is bob

Example #13

def test_can_create_a_relationship_to_two_existing_nodes(graph):
    alice = graph.cypher.execute_one("CREATE (a {name:'Alice'}) RETURN a")
    bob = graph.cypher.execute_one("CREATE (b {name:'Bob'}) RETURN b")
    alice_knows_bob = Relationship(alice, "KNOWS", bob)
    statement = CreateStatement(graph)
    statement.create(alice_knows_bob)
    created = statement.execute()
    assert created == (alice_knows_bob, )
    assert alice_knows_bob.bound
    assert alice_knows_bob.start_node is alice
    assert alice_knows_bob.end_node is bob

Example #14

def test_unique_path_not_unique_exception(graph):
    results = graph.cypher.stream(
        "CREATE (a)-[ab:KNOWS]->(b), (a)-[:KNOWS]->(b) RETURN a, ab, b")
    alice, alice_knows_bob, bob = next(results).values
    assert alice.degree == 2
    assert bob.degree == 2
    statement = CreateStatement(graph)
    statement.create_unique(Relationship(alice, "KNOWS", bob))
    try:
        statement.execute()
    except CypherError as error:
        assert error.exception == "UniquePathNotUniqueException"
        assert error.fullname in [
            None, "org.neo4j.cypher.UniquePathNotUniqueException"
        ]
        assert error.statement == (
            "START _0n0=node({_0n0}),_0n1=node({_0n1})\n"
            "CREATE UNIQUE (_0n0)-[_0r0:KNOWS]->(_0n1)\n"
            "RETURN _0n0,_0n1,_0r0")
    else:
        assert False

Example #15

File: cypher_create_test.py Project: JohannesOos/py2neo

def test_can_create_two_nodes_and_a_relationship(graph):
    alice = Node(name="Alice")
    bob = Node(name="Bob")
    alice_knows_bob = Relationship(alice, "KNOWS", bob)
    statement = CreateStatement(graph)
    statement.create(alice)
    statement.create(bob)
    statement.create(alice_knows_bob)
    created = statement.execute()
    assert created == (alice, bob, alice_knows_bob)
    assert alice.bound
    assert bob.bound
    assert alice_knows_bob.bound
    assert alice_knows_bob.start_node is alice
    assert alice_knows_bob.end_node is bob

Example #16

def test_can_create_two_nodes_and_a_relationship(graph):
    alice = Node(name="Alice")
    bob = Node(name="Bob")
    alice_knows_bob = Relationship(alice, "KNOWS", bob)
    statement = CreateStatement(graph)
    statement.create(alice)
    statement.create(bob)
    statement.create(alice_knows_bob)
    created = statement.execute()
    assert created == (alice, bob, alice_knows_bob)
    assert alice.bound
    assert bob.bound
    assert alice_knows_bob.bound
    assert alice_knows_bob.start_node is alice
    assert alice_knows_bob.end_node is bob

Example #17

def test_can_create_a_path_with_existing_nodes(graph):
    alice = graph.cypher.execute_one("CREATE (a {name:'Alice'}) RETURN a")
    bob = Node(name="Bob")
    carol = graph.cypher.execute_one("CREATE (c {name:'Carol'}) RETURN c")
    dave = Node(name="Dave")
    path = Path(alice, "LOVES", bob, Rev("HATES"), carol, "KNOWS", dave)
    statement = CreateStatement(graph)
    statement.create(path)
    created = statement.execute()
    assert created == (path, )
    assert bob.bound
    assert dave.bound
    ab, cb, cd = path.relationships
    assert ab.start_node is alice
    assert ab.end_node is bob
    assert cb.start_node is carol
    assert cb.end_node is bob
    assert cd.start_node is carol
    assert cd.end_node is dave

Example #18

File: cypher_create_test.py Project: JohannesOos/py2neo

def test_can_create_a_path_with_existing_nodes(graph):
    alice = graph.cypher.execute_one("CREATE (a {name:'Alice'}) RETURN a")
    bob = Node(name="Bob")
    carol = graph.cypher.execute_one("CREATE (c {name:'Carol'}) RETURN c")
    dave = Node(name="Dave")
    path = Path(alice, "LOVES", bob, Rev("HATES"), carol, "KNOWS", dave)
    statement = CreateStatement(graph)
    statement.create(path)
    created = statement.execute()
    assert created == (path,)
    assert bob.bound
    assert dave.bound
    ab, cb, cd = path.relationships
    assert ab.start_node is alice
    assert ab.end_node is bob
    assert cb.start_node is carol
    assert cb.end_node is bob
    assert cd.start_node is carol
    assert cd.end_node is dave

Example #19

def test_can_create_an_entirely_new_path(graph):
    alice = Node(name="Alice")
    bob = Node(name="Bob")
    carol = Node(name="Carol")
    dave = Node(name="Dave")
    path = Path(alice, "LOVES", bob, Rev("HATES"), carol, "KNOWS", dave)
    statement = CreateStatement(graph)
    statement.create(path)
    created = statement.execute()
    assert created == (path, )
    assert alice.bound
    assert bob.bound
    assert carol.bound
    assert dave.bound
    ab, cb, cd = path.relationships
    assert ab.start_node is alice
    assert ab.end_node is bob
    assert cb.start_node is carol
    assert cb.end_node is bob
    assert cd.start_node is carol
    assert cd.end_node is dave

Example #20

File: cypher_create_test.py Project: JohannesOos/py2neo

def test_can_create_an_entirely_new_path(graph):
    alice = Node(name="Alice")
    bob = Node(name="Bob")
    carol = Node(name="Carol")
    dave = Node(name="Dave")
    path = Path(alice, "LOVES", bob, Rev("HATES"), carol, "KNOWS", dave)
    statement = CreateStatement(graph)
    statement.create(path)
    created = statement.execute()
    assert created == (path,)
    assert alice.bound
    assert bob.bound
    assert carol.bound
    assert dave.bound
    ab, cb, cd = path.relationships
    assert ab.start_node is alice
    assert ab.end_node is bob
    assert cb.start_node is carol
    assert cb.end_node is bob
    assert cd.start_node is carol
    assert cd.end_node is dave

Example #21

File: test_graph_importer.py Project: Caleydo/pathfinder_graph

# Relationship(nodes["c"], "RELATIONSHIP", nodes["e"]),
# Relationship(nodes["d"], "RELATIONSHIP", nodes["c"]),
# Relationship(nodes["d"], "RELATIONSHIP", nodes["f"]),
# Relationship(nodes["e"], "RELATIONSHIP", nodes["g"]),
#      Relationship(nodes["e"], "RELATIONSHIP", nodes["f"]),
#      Relationship(nodes["f"], "RELATIONSHIP", nodes["g"]),
#      Relationship(nodes["g"], "RELATIONSHIP", nodes["a"])]

builder = CreateStatement(graph)

# graph.create(nodeDict.values())
for node in nodes.values():
    builder.create(node)
for edge in edges:
    builder.create(edge)
builder.execute()


def edge_query(source, target):
    return (
        "MATCH (source:NETWORK_NODE {id: '" + source + "'}) "
        "MATCH (target:NETWORK_NODE {id: '" + target + "'}) "
        "MERGE (source)-[rel:EDGE]->(target) "
        'ON CREATE SET rel._isSetEdge=true, rel.pathways=["hsa02"], rel.try=true '
        'ON MATCH SET rel._isSetEdge=true, rel.pathways= CASE WHEN NOT (HAS (rel.pathways)) THEN ["hsa02"] ELSE rel.pathways + ["hsa02", "hsa03"] END, rel.try=true '
    )


graph.cypher.execute("CREATE CONSTRAINT ON (n:NETWORK_NODE) ASSERT n.id IS UNIQUE")

graph.cypher.execute('MERGE (node:NETWORK_NODE {id: "A"}) ' 'ON CREATE SET node.name="A"' 'ON MATCH SET node.name="A"')

Example #22

# Relationship(nodes["c"], "RELATIONSHIP", nodes["e"]),
# Relationship(nodes["d"], "RELATIONSHIP", nodes["c"]),
# Relationship(nodes["d"], "RELATIONSHIP", nodes["f"]),
# Relationship(nodes["e"], "RELATIONSHIP", nodes["g"]),
#      Relationship(nodes["e"], "RELATIONSHIP", nodes["f"]),
#      Relationship(nodes["f"], "RELATIONSHIP", nodes["g"]),
#      Relationship(nodes["g"], "RELATIONSHIP", nodes["a"])]

builder = CreateStatement(graph)

# graph.create(nodeDict.values())
for node in nodes.values():
    builder.create(node)
for edge in edges:
    builder.create(edge)
builder.execute()


def edge_query(source, target):
    return (
        "MATCH (source:NETWORK_NODE {id: '" + source + "'}) "
        "MATCH (target:NETWORK_NODE {id: '" + target + "'}) "
        "MERGE (source)-[rel:EDGE]->(target) "
        "ON CREATE SET rel._isSetEdge=true, rel.pathways=[\"hsa02\"], rel.try=true "
        "ON MATCH SET rel._isSetEdge=true, rel.pathways= CASE WHEN NOT (HAS (rel.pathways)) THEN [\"hsa02\"] ELSE rel.pathways + [\"hsa02\", \"hsa03\"] END, rel.try=true "
    )


graph.cypher.execute(
    "CREATE CONSTRAINT ON (n:NETWORK_NODE) ASSERT n.id IS UNIQUE")

Example #23

File: cypher_create_test.py Project: JohannesOos/py2neo

def test_empty_statement_returns_empty_tuple(graph):
    statement = CreateStatement(graph)
    created = statement.execute()
    assert created == ()

Example #24

def test_empty_statement_returns_empty_tuple(graph):
    statement = CreateStatement(graph)
    created = statement.execute()
    assert created == ()