def test_del_relation(self):
io = Io()
value = "You spin my head right ground right ground"
label = Label(cfg.INV_ID, value)
label = io.write_label(label)
prop_value = True
property = Property(cfg.INV_ID, PropertyType.BOOL, label, prop_value,
None)
property = io.write_property(property)
node = Node(cfg.INV_ID, label, property, None)
node2 = Node(cfg.INV_ID, label, property, None)
written1 = io.write_node(node)
written2 = io.write_node(node2)
relation = Relationship(cfg.INV_ID, False, written1, written2, label,
property, None, None, None, None)
written = io.write_relation(relation)
io.del_relation(written.id)
retrived = io.get_relations_by_id([written.id])
node1 = io.read_node(written1.id)
node2 = io.read_node(written2.id)
self.assertEqual(len(retrived), 0)
print(node1.next_rel)
print(node2.next_rel)
self.assertEqual(node1.next_rel is None, True)
self.assertEqual(node2.next_rel is None, True)
def test_relation_io(self):
io = Io()
value = "You spin my head right ground right ground"
label = Label(cfg.INV_ID, value)
label = io.write_label(label)
prop_value = True
property = Property(cfg.INV_ID, PropertyType.BOOL, label, prop_value,
None)
property = io.write_property(property)
node = Node(cfg.INV_ID, label, property, None)
node2 = Node(cfg.INV_ID, label, property, None)
written1 = io.write_node(node)
written2 = io.write_node(node2)
relation = Relationship(cfg.INV_ID, False, written1, written2, label,
property, None, None, None, None)
written = io.write_relation(relation)
retrieved = io.read_relation(written.id)
written1 = io.read_node(written1.id)
written2 = io.read_node(written2.id)
self.assertEqual(retrieved.label.value, value)
self.assertEqual(retrieved.next_prop.value, prop_value)
self.assertEqual(retrieved.first_node.id, written1.id)
self.assertEqual(retrieved.second_node.id, written2.id)
self.assertEqual(written2.next_rel, retrieved.id)
self.assertEqual(written1.next_rel, retrieved.id)
def _fix_node_rel(self, current: Relationship, node: Node):
if node.id == current.first_node.id:
if node.next_rel == current.id:
node.next_rel = current.first_next_rel
if node.id == current.second_node.id:
if node.next_rel == current.id:
node.next_rel = current.second_next_rel
self.write_node(node)
def write_node(self, node: Node) -> Node:
"""
Writes node to file.
:param node: to pack
:return: byte representation of string
"""
if node.id == cfg.INV_ID:
node.id = self._get_node_id()
node.label = self.write_label(node.label)
if (node.next_prop != cfg.INV_ID) and (node.next_prop is not None):
node.next_prop = self.write_property(node.next_prop)
value = Packer.pack_node(node)
self._write_bytes(self.nodes, node.id * cfg.NODE_SIZE, value)
return node
def create_node(self, node):
"""
Creates the new node.
:param node: A pair (<label>, <properties>) corresponding to a node.
:return: Void
"""
label, next_prop = node
# Before write to the storage dedupe the labels
label = self._dedupe_label(label)
next_prop = self._dedupe_next_prop(next_prop)
created_node = self._io.write_node(Node(cfg.INV_ID, label, next_prop))
label, next_prop = created_node.label, created_node.next_prop
# Add new labels to the corresponding cache
self._lb_cache[label.value] = label
while next_prop is not None:
self._lb_cache[next_prop.label] = next_prop.label
next_prop = next_prop.next_prop
# Update index (if any)
if len(self._index) != 0:
lookup = self._index_lookup((label, next_prop))
for key, value in lookup.values():
if value not in self._index[label.id][key]:
self._index[label.id][key][value] = list()
self._index[label.id][key][value].append(created_node.id)
def test_node_deletion(self):
io = Io()
value = "Graph DB is AWESOME"
label = Label(cfg.INV_ID, value)
prop_value = True
property = Property(cfg.INV_ID, PropertyType.BOOL, label, prop_value,
None)
node = Node(cfg.INV_ID, label, property, cfg.INV_ID)
written = io.write_node(node)
io.del_node(written.id)
retrieved = io.get_nodes_by_id([written.id])
self.assertEqual(len(retrieved), 0)
def test_get_nodes_io(self):
io = Io()
nodes = []
for i in range(0, 10):
value = "Macarena"
label = Label(cfg.INV_ID, value)
label = io.write_label(label)
node = Node(cfg.INV_ID, label, None, None)
node = io.write_node(node)
nodes.append(node.id)
node_list = io.get_nodes_by_id(set(nodes))
for id, node in enumerate(node_list):
self.assertEqual(node.id, nodes[id])
self.assertEqual(node.label.value, "Macarena")
def test_multirelation_deletion(self):
io = Io()
value = "You spin my head right ground right ground"
label = Label(cfg.INV_ID, value)
label = io.write_label(label)
prop_value = True
property = Property(cfg.INV_ID, PropertyType.BOOL, label, prop_value,
None)
property = io.write_property(property)
node = Node(cfg.INV_ID, label, property, None)
node2 = Node(cfg.INV_ID, label, property, None)
written_node1 = io.write_node(node)
written_node2 = io.write_node(node2)
relation1 = Relationship(cfg.INV_ID, False, written_node1,
written_node2, label, property, None, None,
None, None)
relation2 = Relationship(cfg.INV_ID, False, written_node1,
written_node2, label, property, None, None,
None, None)
written_rel1 = io.write_relation(relation1)
written_rel2 = io.write_relation(relation2)
io.del_node(written_node1.id)
retrived = io.get_relations_by_id([written_rel1.id, written_rel2.id])
self.assertEqual(len(retrived), 0)
def test_node_io(self):
io = Io()
value = "Graph DB is AWESOME"
label = Label(cfg.INV_ID, value)
prop_value = True
property = Property(cfg.INV_ID, PropertyType.BOOL, label, prop_value,
None)
node = Node(cfg.INV_ID, label, property, cfg.INV_ID)
written = io.write_node(node)
retrived = io.read_node(written.id)
self.assertEqual(node.id, retrived.id)
self.assertEqual(node.next_prop.id, retrived.next_prop.id)
self.assertEqual(node.next_prop.label.value, property.label.value)
self.assertEqual(node.label.value, retrived.label.value)
self.assertEqual(node.label.id, retrived.label.id)
def _update_next_rel(self, node: Node, relation: Relationship):
next_rel = self.read_relation(node.next_rel)
node.next_rel = relation.id
if next_rel.second_node.id == node.id:
next_rel.second_prev_rel = relation.id
if next_rel.first_node.id == node.id:
next_rel.first_prev_rel = relation.id
self.write_node(node)
value = Packer.pack_relation(next_rel)
self._write_bytes(self.relations, next_rel.id * cfg.RELATION_SIZE,
value)
if relation.first_node.id == node.id:
relation.first_next_rel = next_rel
if relation.second_node.id == node.id:
relation.second_next_rel = next_rel
return relation
def read_node(self, id: int) -> Node or None:
"""
Reads single node by it's id
:param id: offset of node to read
:return: Node unpacked
"""
if id > self.last_node_id:
raise Exception('Property ID is out of range')
node_bytes = self._read_bytes(self.nodes, id, cfg.NODE_SIZE)
in_use, label_id, property, relation_id = Unpacker.unpack_node(
node_bytes)
if in_use:
label = self.read_label(label_id)
if property != cfg.INV_ID:
property = self.read_property(property)
else:
property = None
if relation_id == cfg.INV_ID:
relation_id = None
return Node(id, label, property, relation_id)
else:
return None