def _create_path(self, path, name, unique):
node_names = self._create_path_nodes(path, name, unique)
rel_names = []
for i, rel in enumerate(path.rels):
rel_name = name + "r" + ustr(i)
rel_names.append(rel_name)
if rel.bound:
self.start_clause.append("{name}=rel({{{name}}})".format(name=rel_name))
self.parameters[rel_name] = rel._id
else:
if rel.properties:
template = "{start}-[{name}:{type} {{{name}}}]->{end}"
self.parameters[rel_name] = rel.properties
else:
template = "{start}-[{name}:{type}]->{end}"
start_index, end_index = i, i + 1
if isinstance(rel, Rev):
start_index, end_index = end_index, start_index
start_node = path.nodes[start_index]
end_node = path.nodes[end_index]
start = self._node_pattern(start_node, node_names[start_index],
full=(unique and not start_node.bound and start_node not in self))
end = self._node_pattern(end_node, node_names[end_index],
full=(unique and not end_node.bound and end_node not in self))
kwargs = {"start": start, "name": rel_name,
"type": cypher_escape(rel.type), "end": end}
if unique:
self.create_unique_clause.append(template.format(**kwargs))
else:
self.create_clause.append(template.format(**kwargs))
self.return_clause.append(rel_name)
return node_names, rel_names
def create_path(self, path, name):
node_names = []
for i, node in enumerate(path.nodes):
if isinstance(node, NodePointer):
node_names.append(_(node.address))
# Switch out node with object from elsewhere in entity list
nodes = list(path.nodes)
node = self.entities[node.address]
if not isinstance(node, Node):
raise ValueError("Pointer does not refer to a node")
nodes[i] = node
path.__nodes = tuple(nodes)
else:
node_name = name + "n" + ustr(i)
node_names.append(node_name)
self.create_node(node, node_name)
rel_names = []
for i, rel in enumerate(path.rels):
rel_name = name + "r" + ustr(i)
rel_names.append(rel_name)
if rel.bound:
self.start_clause.append("{name}=rel({{{name}}})".format(name=rel_name))
self.params[rel_name] = rel._id
else:
if rel.properties:
template = "({start})-[{name}:{type} {{{name}}}]->({end})"
self.params[rel_name] = rel.properties
else:
template = "({start})-[{name}:{type}]->({end})"
kwargs = {"start": node_names[i], "name": rel_name,
"type": cypher_escape(rel.type), "end": node_names[i + 1]}
self.create_clause.append(template.format(**kwargs))
self.return_clause.append(rel_name)
return node_names, rel_names
def _node_pattern(self, node, name, full):
template = "{name}"
kwargs = {"name": name}
if full:
if node.labels and self.supports_node_labels:
template += "{labels}"
kwargs["labels"] = "".join(":" + cypher_escape(label) for label in node.labels)
if node.properties:
template += " {{{name}}}"
self.parameters[name] = node.properties
return "(" + template.format(**kwargs) + ")"
def _node_pattern(self, node, name, full):
template = "{name}"
kwargs = {"name": name}
if full:
if node.labels and self.supports_node_labels:
template += "{labels}"
kwargs["labels"] = "".join(":" + cypher_escape(label)
for label in node.labels)
if node.properties:
template += " {{{name}}}"
self.parameters[name] = node.properties
return "(" + template.format(**kwargs) + ")"
def create_rel(self, name, rel, *node_names):
if rel.bound:
self.start_clause.append("{name}=rel({{{name}}})".format(name=name))
self.params[name] = rel._id
else:
if rel.properties:
template = "({0})-[{1}:{2} {{{1}}}]->({3})"
self.params[name] = rel.properties
else:
template = "({0})-[{1}:{2}]->({3})"
self.create_clause.append(template.format(node_names[0], name, cypher_escape(rel.type), node_names[1]))
self.return_clause.append(name)
return [], [name]
def _relationship_update_properties(self, properties):
if self.bound:
from py2neo.cypher.lang import cypher_escape
from py2neo.cypher.util import StartOrMatch
graph = self.graph
query, params = [StartOrMatch(graph).node("a", "{A}").string], {"A": self._id}
for i, (key, value) in enumerate(properties.items()):
value_tag = "V" + str(i)
query.append("SET a.%s={" + value_tag + "}" % cypher_escape(key))
params[value_tag] = value
query.append("RETURN a")
rel = graph.cypher.execute_one("\n".join(query), params)
self._properties = rel.__metadata__["data"]
else:
self._properties.update(properties)
def _relationship_update_properties(self, properties):
if self.bound:
from py2neo.cypher.lang import cypher_escape
from py2neo.cypher.util import StartOrMatch
graph = self.graph
query, params = [StartOrMatch(graph).node("a", "{A}").string], {"A": self._id}
for i, (key, value) in enumerate(properties.items()):
value_tag = "V" + str(i)
query.append("SET a.%s={" + value_tag + "}" % cypher_escape(key))
params[value_tag] = value
query.append("RETURN a")
rel = graph.cypher.execute_one("\n".join(query), params)
self._properties = rel.__metadata__["data"]
else:
self._properties.update(properties)
def create_node(self, name, node):
if node.bound:
self.start_clause.append("{name}=node({{{name}}})".format(name=name))
self.params[name] = node._id
else:
template = "{name}"
kwargs = {"name": name}
if node.labels and self.supports_node_labels:
template += "{labels}"
kwargs["labels"] = "".join(":" + cypher_escape(label) for label in node.labels)
if node.properties:
template += " {{{name}}}"
self.params[name] = node.properties
self.create_clause.append("(" + template.format(**kwargs) + ")")
self.return_clause.append(name)
return [name], []
def _create_path(self, path, name, unique):
node_names = []
for i, node in enumerate(path.nodes):
if isinstance(node, NodePointer):
node_names.append(_(node.address))
# Switch out node with object from elsewhere in entity list
nodes = list(path.nodes)
try:
node = self.entities[node.address]
except IndexError:
raise IndexError("Node pointer out of range")
if not isinstance(node, Node):
raise ValueError("Pointer does not refer to a node")
nodes[i] = node
path._Path__nodes = tuple(nodes)
else:
node_name = name + "n" + ustr(i)
node_names.append(node_name)
self.create_node(node, node_name)
rel_names = []
for i, rel in enumerate(path.rels):
rel_name = name + "r" + ustr(i)
rel_names.append(rel_name)
if rel.bound:
self.start_clause.append(
"{name}=rel({{{name}}})".format(name=rel_name))
self.parameters[rel_name] = rel._id
else:
if rel.properties:
template = "({start})-[{name}:{type} {{{name}}}]->({end})"
self.parameters[rel_name] = rel.properties
else:
template = "({start})-[{name}:{type}]->({end})"
kwargs = {
"start": node_names[i],
"name": rel_name,
"type": cypher_escape(rel.type),
"end": node_names[i + 1]
}
if unique:
self.create_unique_clause.append(template.format(**kwargs))
else:
self.create_clause.append(template.format(**kwargs))
self.return_clause.append(rel_name)
return node_names, rel_names
def create_node(self, node, name):
kwargs = {"name": name}
if node.bound:
self.start_clause.append(
"{name}=node({{{name}}})".format(**kwargs))
self.parameters[name] = node._id
else:
template = "{name}"
if node.labels and self.supports_node_labels:
template += "{labels}"
kwargs["labels"] = "".join(":" + cypher_escape(label)
for label in node.labels)
if node.properties:
template += " {{{name}}}"
self.parameters[name] = node.properties
self.create_clause.append("(" + template.format(**kwargs) + ")")
self.return_clause.append(name)
return [name], []
def _create_path(self, path, name, unique):
node_names = self._create_path_nodes(path, name, unique)
rel_names = []
for i, rel in enumerate(path.rels):
rel_name = name + "r" + ustr(i)
rel_names.append(rel_name)
if rel.bound:
self.start_or_match_clause.relationship(
rel_name, "{" + rel_name + "}")
self.parameters[rel_name] = rel._id
else:
if rel.properties:
template = "{start}-[{name}:{type} {{{name}}}]->{end}"
self.parameters[rel_name] = rel.properties
else:
template = "{start}-[{name}:{type}]->{end}"
start_index, end_index = i, i + 1
if isinstance(rel, Rev):
start_index, end_index = end_index, start_index
start_node = path.nodes[start_index]
end_node = path.nodes[end_index]
start = self._node_pattern(start_node,
node_names[start_index],
full=(unique
and not start_node.bound
and start_node not in self))
end = self._node_pattern(end_node,
node_names[end_index],
full=(unique and not end_node.bound
and end_node not in self))
kwargs = {
"start": start,
"name": rel_name,
"type": cypher_escape(rel.type),
"end": end
}
if unique:
self.create_unique_clause.append(template.format(**kwargs))
else:
self.create_clause.append(template.format(**kwargs))
self.return_clause.append(rel_name)
return node_names, rel_names
def presubstitute(statement, parameters):
more = True
while more:
before, opener, key = statement.partition(u"«")
if opener:
key, closer, after = key.partition(u"»")
try:
value = parameters.pop(key)
except KeyError:
raise KeyError("Expected a presubstitution parameter named %r" % key)
if is_integer(value):
value = ustr(value)
elif isinstance(value, tuple) and all(map(is_integer, value)):
value = u"%d..%d" % (value[0], value[-1])
elif is_collection(value):
value = ":".join(map(cypher_escape, value))
else:
value = cypher_escape(value)
statement = before + value + after
else:
more = False
return statement, parameters
def presubstitute(statement, parameters):
more = True
while more:
before, opener, key = statement.partition(u"«")
if opener:
key, closer, after = key.partition(u"»")
try:
value = parameters.pop(key)
except KeyError:
raise KeyError(
"Expected a presubstitution parameter named %r" % key)
if is_integer(value):
value = ustr(value)
elif isinstance(value, tuple) and all(map(is_integer, value)):
value = u"%d..%d" % (value[0], value[-1])
elif is_collection(value):
value = ":".join(map(cypher_escape, value))
else:
value = cypher_escape(value)
statement = before + value + after
else:
more = False
return statement, parameters
