def __getitem__(self, path): session = DBSession() session._autoflush() if not hasattr(path, '__iter__'): path = (path,) if 'children' in self.__dict__: # If children are already in memory, don't query the database: first, rest = path[0], path[1:] try: [v] = [child for child in self.children if child.name == path[0]] except ValueError: raise KeyError(path) if rest: return v[rest] else: return v # Using the ORM interface here in a loop would join over all # polymorphic tables, so we'll use a 'handmade' select instead: conditions = [nodes.c.id==self.id] alias = nodes for name in path: alias, old_alias = nodes.alias(), alias conditions.append(alias.c.parent_id==old_alias.c.id) conditions.append(alias.c.name==unicode(name)) expr = select([alias.c.id], and_(*conditions)) row = session.execute(expr).fetchone() if row is None: raise KeyError(path) return session.query(Node).get(row.id)
def __getitem__(self, path: Union[str, Iterable[str]]) -> "Node": db_session = DBSession() db_session._autoflush() # if not hasattr(path, '__iter__'): if isinstance(path, str): path = (path,) path = [p for p in path] # Optimization: don't query children if self._children already there: if "_children" in self.__dict__: rest = path[1:] try: [child] = filter(lambda ch: ch.name == path[0], self._children) except ValueError: raise KeyError(path) if rest: return child[rest] else: return child baked_query = bakery(lambda session: session.query(Node)) if len(path) == 1: try: baked_query += lambda q: q.filter( Node.name == bindparam("name"), Node.parent_id == bindparam("parent_id"), ) return ( baked_query(db_session) .params(name=path[0], parent_id=self.id) .one() ) except NoResultFound: raise KeyError(path) # We have a path with more than one element, so let's be a # little clever about fetching the requested node: nodes = Node.__table__ conditions = [nodes.c.id == self.id] alias = nodes for name in path: alias, old_alias = nodes.alias(), alias conditions.append(alias.c.parent_id == old_alias.c.id) conditions.append(alias.c.name == name) expr = select([alias.c.id], and_(*conditions)) row = db_session.execute(expr).fetchone() if row is None: raise KeyError(path) return baked_query(db_session).get(row.id)
def __getitem__(self, path: Union[str, Iterable[str]]) -> "Node": db_session = DBSession() db_session._autoflush() # if not hasattr(path, '__iter__'): if isinstance(path, str): path = (path, ) path = [p for p in path] # Optimization: don't query children if self._children already there: if "_children" in self.__dict__: rest = path[1:] try: [child] = filter(lambda ch: ch.name == path[0], self._children) except ValueError: raise KeyError(path) if rest: return child[rest] else: return child baked_query = bakery(lambda session: session.query(Node)) if len(path) == 1: try: baked_query += lambda q: q.filter( Node.name == bindparam("name"), Node.parent_id == bindparam("parent_id"), ) return (baked_query(db_session).params( name=path[0], parent_id=self.id).one()) except NoResultFound: raise KeyError(path) # We have a path with more than one element, so let's be a # little clever about fetching the requested node: nodes = Node.__table__ conditions = [nodes.c.id == self.id] alias = nodes for name in path: alias, old_alias = nodes.alias(), alias conditions.append(alias.c.parent_id == old_alias.c.id) conditions.append(alias.c.name == name) expr = select([alias.c.id], and_(*conditions)) row = db_session.execute(expr).fetchone() if row is None: raise KeyError(path) return baked_query(db_session).get(row.id)
def __getitem__(self, path): session = DBSession() session._autoflush() if not hasattr(path, '__iter__'): path = (path,) path = [unicode(p) for p in path] # Optimization: don't query children if self._children is already there: if '_children' in self.__dict__: first, rest = path[0], path[1:] try: [child] = filter(lambda ch: ch.name == path[0], self._children) except ValueError: raise KeyError(path) if rest: return child[rest] else: return child if len(path) == 1: try: return DBSession.query(Node).filter_by( name=path[0], parent=self).one() except NoResultFound: raise KeyError(path) # We have a path with more than one element, so let's be a # little clever about fetching the requested node: nodes = Node.__table__ conditions = [nodes.c.id == self.id] alias = nodes for name in path: alias, old_alias = nodes.alias(), alias conditions.append(alias.c.parent_id == old_alias.c.id) conditions.append(alias.c.name == name) expr = select([alias.c.id], and_(*conditions)) row = session.execute(expr).fetchone() if row is None: raise KeyError(path) return session.query(Node).get(row.id)
def __getitem__(self, path): session = DBSession() session._autoflush() if not hasattr(path, '__iter__'): path = (path,) path = [unicode(p) for p in path] # Optimization: don't query children if self._children already there: if '_children' in self.__dict__: first, rest = path[0], path[1:] try: [child] = filter(lambda ch: ch.name == path[0], self._children) except ValueError: raise KeyError(path) if rest: return child[rest] else: return child if len(path) == 1: try: return DBSession.query(Node).filter_by( name=path[0], parent=self).one() except NoResultFound: raise KeyError(path) # We have a path with more than one element, so let's be a # little clever about fetching the requested node: nodes = Node.__table__ conditions = [nodes.c.id == self.id] alias = nodes for name in path: alias, old_alias = nodes.alias(), alias conditions.append(alias.c.parent_id == old_alias.c.id) conditions.append(alias.c.name == name) expr = select([alias.c.id], and_(*conditions)) row = session.execute(expr).fetchone() if row is None: raise KeyError(path) return session.query(Node).get(row.id)