Testing nested sets on GAE got an error

BadFilterError: BadFilterError: invalid filter: Only one property per
query may have inequality filters (<=, >=, <, >)


Just don't know what to do at the moment to make it work...

On Mon, Nov 9, 2009 at 1:51 AM, mdipierro <[email protected]> wrote:

>
> It would be nice to implement in a general way so that once can do:
>
> db.define_table('mytabletree',Field('data_at_node'),Tree
> ('mytabletree'))
>
> where
>
> class Tree:
>   def __call__(self,tablename):
>      return sql.Table(...)
>   other methods....
>
> Hope it makes sense. Not sure how doable.
>
> massimo
>
> On Nov 8, 5:40 pm, Thadeus Burgess <[email protected]> wrote:
> > Wow what timing, I was just about to post a similar thing :)
> >
> > http://pastebin.com/f4fc602d7
> >
> > -Thadeus
> >
> > On Sun, Nov 8, 2009 at 5:28 PM, Vasile Ermicioi <[email protected]>
> wrote:
> > > - for using in some queries like direct children (just too lazy to
> think
> > > how to use lft and rgt :) )
> > > - cascade delete (if is supported by the database)
> >
> > > On Mon, Nov 9, 2009 at 1:18 AM, mdipierro <[email protected]>
> wrote:
> >
> > >> what do you need parent_id for when you have lgt and rgt?
> >
> > >> On Nov 8, 5:10 pm, elffikk <[email protected]> wrote:
> > >> > Hi,
> >
> > >> > I started a nested sets implementation
> > >> > Just sharing the code. I welcome any thoughts you have
> >
> > >> > 2 files - nstree_controller (just quick and dirty tests of the
> model),
> > >> > and nstree_model
> >
> > >> > [nstree_controller :]
> >
> > >> > t1 = nstree(db, db.tree1)
> >
> > >> > def index():
> > >> >     return dict(message="Version " + nstree.version)
> >
> > >> > def test_path():
> > >> >     _id = 33
> > >> >     return dict(message = " > ".join([node.name for node in t1.path
> > >> > (_id)]))
> >
> > >> > def test_removetree():
> > >> >     _id = request.vars.id if request.vars.id else 3
> > >> >     t1.remove_tree(_id)
> > >> >     return dict(message="Success")
> >
> > >> > def test_delete():
> > >> >     _id = request.vars.id if request.vars.id else 19
> > >> >     node = t1.delete(_id)
> > >> >     return dict(message= node.name + " deleted ")
> >
> > >> > def test_get():
> > >> >     _id = request.vars.id if request.vars.id else 15
> > >> >     #nodes = t1.ancestors(_id)
> > >> >     #nodes = t1.descendants(_id)
> > >> >     nodes = t1.children(_id)
> > >> >     return dict(message= ", ".join([node.name for node in nodes]))
> >
> > >> > def test_gettree():
> > >> >     root_id = request.vars.root_id if request.vars.root_id else 1
> > >> >     nodes = t1.tree(root_id)
> > >> >     return dict(message="Count "+str(len(nodes)))
> >
> > >> > def test_add():
> > >> >     root_id = request.vars.root_id if request.vars.root_id else
> > >> > t1.roots()[0].id
> > >> >     r1 = t1.add(root_id, name='1')
> > >> >     r2 = t1.add(root_id, name='2')
> > >> >     r3 = t1.add(root_id, name='3')
> > >> >     t1.add(r1, name='11')
> > >> >     t1.add(r1, name='12')
> > >> >     return dict(message="Success")
> >
> > >> > def test_create_roots():
> > >> >     '''
> > >> >     t1.create_root(name='root1')
> > >> >     t1.create_root(name='root2')
> > >> >     t1.create_root(name='root3')
> > >> >     t1.create_root(name='root4')
> > >> >     '''
> > >> >     roots = t1.roots()
> > >> >     return dict(message="Roots count : " + str(len(roots)))
> >
> > >> > [nstree_model:]
> >
> > >> > db.define_table('tree1',
> > >> >     SQLField('name', "string", 128),
> > >> >     SQLField('lft','integer'),
> > >> >     SQLField('rgt','integer'),
> > >> >     SQLField('level','integer'),
> > >> >     SQLField('root_id','integer'),
> > >> >     SQLField('parent_id','reference tree1'),
> > >> >     )
> > >> > #
> > >> > #  A Nested Sets implementation
> > >> > #  need to pass a table with following fields:
> > >> > #  lft, rgt, level, parent_id, root_id - all fields of type int
> > >> > #  -------
> > >> > #  Notes:
> > >> > #  - table can contain multiple roots
> > >> > #
> > >> > class nstree:
> > >> >     version = "1.0.0.04"
> > >> >     def __init__(self, db, dbtable):
> > >> >         self.db = db
> > >> >         self.dbtable = dbtable
> > >> >         #self.lft = dbtable.lft
> > >> >         #self.rgt = dbtable.rgt
> > >> >         #self.level = dbtable.level
> > >> >         #self.parent_id = dbtable.parent_id
> > >> >         #self.root_id = dbtable.root_id
> > >> >     #
> > >> >     #  Methods for building tree (create, delete nodes)
> > >> >     #
> > >> >     def create_root(self, **fields):
> > >> >         _id = self.dbtable.insert(lft=1, rgt=2, level=0, **fields)
> > >> >         _root = self.dbtable[_id]
> > >> >         _root.update_record(root_id  = _id)
> > >> >         return _root
> > >> >     def add(self, parent_id, **fields): return self.add_last_child
> > >> > (parent_id, **fields)
> > >> >     def add_last_child(self, parent_id, **fields):
> > >> >         _parent = self.dbtable[parent_id]
> > >> >         q1 = self.dbtable.rgt >= _parent.rgt
> > >> >         q2 = self.dbtable.lft >= _parent.rgt
> > >> >         q3 = self.dbtable.root_id == _parent.root_id
> > >> >         self.db(q1)(q3).update(rgt=self.dbtable.rgt+2)
> > >> >         self.db(q2)(q3).update(lft=self.dbtable.lft+2)
> > >> >         return self.dbtable.insert(
> > >> >             parent_id = parent_id,
> > >> >             lft = _parent.rgt,
> > >> >             rgt = _parent.rgt+1,
> > >> >             level = _parent.level+1,
> > >> >             root_id = _parent.root_id,
> > >> >             **fields
> > >> >         )
> > >> >     def delete(self, id): return self.remove(id)
> > >> >     def remove(self, id):
> > >> >         node = self.dbtable[id]
> > >> >         delta = node.rgt - node.lft + 1
> > >> >         q1 = self.dbtable.lft >= node.lft
> > >> >         q2 = self.dbtable.rgt <= node.rgt
> > >> >         self.db(q1)(q2).delete()
> > >> >         self.db(self.dbtable.lft > node.rgt).update(lft =
> > >> > self.dbtable.lft - delta)
> > >> >         self.db(self.dbtable.rgt > node.rgt).update(rgt =
> > >> > self.dbtable.rgt - delta)
> > >> >         return node
> > >> >     def remove_descendants(self, id):
> > >> >         node = self.dbtable[id]
> > >> >         delta = node.rgt - node.lft + 1
> > >> >         q1 = self.dbtable.lft > node.lft
> > >> >         q2 = self.dbtable.rgt < node.rgt
> > >> >         self.db(q1)(q2).delete()
> > >> >         self.db(self.dbtable.lft > node.rgt).update(lft =
> > >> > self.dbtable.lft - delta)
> > >> >         self.db(self.dbtable.rgt > node.rgt).update(rgt =
> > >> > self.dbtable.rgt - delta)
> > >> >     def remove_tree(self, id):
> > >> >         self.db(self.dbtable.root_id == id).delete()
> > >> >     #
> > >> >     #  Methods for retrieving nodes
> > >> >     #
> > >> >     def roots(self): return self.db(self.dbtable.lft == 1).select()
> > >> >     def tree(self, root_id): return self.db(self.dbtable.root_id ==
> > >> > root_id).select(orderby = self.dbtable.lft)
> > >> >     def ancestors(self, id):
> > >> >         node = self.dbtable[id]
> > >> >         q1 = self.dbtable.lft < node.lft
> > >> >         q2 = self.dbtable.rgt > node.rgt
> > >> >         q3 = self.dbtable.root_id == node.root_id
> > >> >         return self.db(q1)(q2)(q3).select(orderby =
> self.dbtable.lft)
> > >> >     def path(self, id):
> > >> >         node = self.dbtable[id]
> > >> >         q1 = self.dbtable.lft <= node.lft
> > >> >         q2 = self.dbtable.rgt >= node.rgt
> > >> >         q3 = self.dbtable.root_id == node.root_id
> > >> >         return self.db(q1)(q2)(q3).select(orderby =
> self.dbtable.lft)
> > >> >     def descendants(self, id):
> > >> >         node = self.dbtable[id]
> > >> >         q1 = self.dbtable.lft > node.lft
> > >> >         q2 = self.dbtable.rgt < node.rgt
> > >> >         q3 = self.dbtable.root_id == node.root_id
> > >> >         return self.db(q1)(q2)(q3).select(orderby =
> self.dbtable.lft)
> > >> >     def children(self, id): return self.db(self.dbtable.parent_id ==
> > >> > id).select(orderby = self.dbtable.lft)
> > >> >     #
> > >> >     #  Methods for checking or getting state of node(s)
> > >> >     #
> > >> >     def num_children(self, node): return
> int((node.rgt-node.lft-1)/2)
> > >> >     def is_root(self, node): return node.id == node.root_id
> > >> >     def is_leaf(self, node): return node.lft == node.rgt-1
> > >> >     def is_child(self, node1, node2): return node1.lft > node2.lft
> > >> > and node1.rgt < node2.rgt
> >
> >
> >
>

--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups 
"web2py-users" group.
To post to this group, send email to [email protected]
To unsubscribe from this group, send email to 
[email protected]
For more options, visit this group at 
http://groups.google.com/group/web2py?hl=en
-~----------~----~----~----~------~----~------~--~---

Reply via email to