def get_ancestors(cur, node, sort=True):
"""
Return an iterator that yields a ``NodeData`` object of every
element while traversing from ``node`` to the root node.
:param node:
:type node: Node or int
:param bool sort: Start with closest node and end with root node.
(default: True)
"""
# TODO: benchmark if vectorize_nodes() or WITH RECURSIVE is faster
sql = """
SELECT
nodes.*
FROM
ancestors
INNER JOIN
nodes
ON
ancestors.ancestor=nodes.id
WHERE
ancestors.node=%s;
"""
cur.execute(sql, (int(node), ))
if sort:
make_node = lambda r: NodeData(**r)
for node in vectorize_nodes(map(make_node, cur)):
yield node
else:
for result in cur:
yield NodeData(**result)
def ancestors(self):
""" Get bottom-up ordered list of ancestor nodes. """
ret = []
for node in core.get_ancestors(self._cursor, self.id, sort=True):
node = Node(self._transaction, node.id)
ret.append(node)
return utils.vectorize_nodes(ret)[::-1]
def get_ancestors(cur, node, sort=True):
"""
Return an iterator that yields a ``NodeData`` object of every
element while traversing from ``node`` to the root node.
:param node:
:type node: Node or int
:param bool sort: Start with closest node and end with root node.
(default: True)
"""
# TODO: benchmark if vectorize_nodes() or WITH RECURSIVE is faster
sql = """
SELECT
nodes.*
FROM
ancestors
INNER JOIN
nodes
ON
ancestors.ancestor=nodes.id
WHERE
ancestors.node=%s;
"""
cur.execute(sql, (int(node), ))
if sort:
make_node = lambda r: NodeData(**r)
for node in vectorize_nodes(map(make_node, cur)):
yield node
else:
for result in cur:
yield NodeData(**result)
def get_ancestors(cur, node, sort=True):
"""
Return an iterator which yields a ``NodeData`` object for every
node in the hierarchy chain from ``node`` to root node.
:param node:
:type node: Node or uuid4
:param bool sort: Start with closest node and end with root node.
(default: True). Set to False if order is
unimportant.
"""
# TODO: benchmark if vectorize_nodes() or WITH RECURSIVE is faster
sql = """
SELECT
nodes.*
FROM
ancestors
INNER JOIN
nodes
ON
ancestors.ancestor=nodes.id
WHERE
ancestors.node=%s;
"""
cur.execute(sql, (str(node), ))
if sort:
make_node = lambda r: NodeData(**r)
for node in vectorize_nodes(map(make_node, cur))[::-1]:
yield node
else:
for result in cur:
yield NodeData(**result)
def get_ancestors(cur, node, sort=True):
"""
Return an iterator which yields a ``NodeData`` object for every
node in the hierarchy chain from ``node`` to root node.
:param node:
:type node: Node or uuid4
:param bool sort: Start with closest node and end with root node.
(default: True). Set to False if order is
unimportant.
"""
# TODO: benchmark if vectorize_nodes() or WITH RECURSIVE is faster
sql = """
SELECT
nodes.*
FROM
ancestors
INNER JOIN
nodes
ON
ancestors.ancestor=nodes.id
WHERE
ancestors.node=%s;
"""
cur.execute(sql, (str(node), ))
if sort:
make_node = lambda r: NodeData(**r)
for node in vectorize_nodes(map(make_node, cur))[::-1]:
yield node
else:
for result in cur:
yield NodeData(**result)
def test_vectorize_nodes(cur, root, nd2, nd2_1, nd2_1_1):
nodes = [nd2_1_1, nd2, root, nd2_1]
expected = [root, nd2, nd2_1, nd2_1_1]
assert vectorize_nodes(nodes) == expected
assert vectorize_nodes(*nodes) == expected
def test_vectorize_nodes(cur, root, nd2, nd2_1, nd2_1_1):
nodes = [nd2_1_1, nd2, root, nd2_1]
expected = [root, nd2, nd2_1, nd2_1_1]
assert vectorize_nodes(nodes) == expected
assert vectorize_nodes(*nodes) == expected
