Mercurial Repository: p/roundup/code: roundup/hyperdb.py comparison

comparison roundup/hyperdb.py @ 3682:193f316dbbe9

More transitive-property support. - Implemented transitive properties in sort and group specs. Sort/group specs can now be lists of specs. - All regression tests except for one metakit backend test related to metakit having no representation of NULL pass - Fixed more PEP 8 whitespace peeves (and probably introduced some new ones :-) - Moved Proptree from support.py to hyperdb.py due to circular import - Moved some proptree-specific methods from Class to Proptree - Added a test for sorting by ids -> should be numeric sort (which now really works for all backends) - Added "required" attribute to all property classes in hyperdb (e.g., String, Link,...), see Feature Requests [SF#539081] -> factored common stuff to _Type. Note that I also converted to a new-style class when I was at it. Bad: The repr changes for new-style classes which made some SQL backends break (!) because the repr of Multilink is used in the schema storage. Fixed the repr to be independent of the class type. - Added get_required_props to Class. Todo: should also automagically make the key property required... - Add a sort_repr method to property classes. This defines the sort-order. Individual backends may use diffent routines if the outcome is the same. This one has a special case for id properties to make the sorting numeric. Using these methods isn't mandatory in backends as long as the sort-order is correct. - Multilink sorting takes orderprop into account. It used to sort by ids. You can restore the old behaviour by specifying id as the orderprop of the Multilink if you really need that. - If somebody specified a Link or Multilink as orderprop, we sort by labelprop of that class -- not transitively by orderprop. I've resited the tempation to implement recursive orderprop here: There could even be loops if several classes specify a Link or Multilink as the orderprop... - Fixed a bug in Metakit-Backend: When sorting by Links, the backend would do a natural join to the Link class. It would rename the "id" attribute before joining but *not* all the other attributes of the joined class. So in one test-case we had a name-clash with priority.name and status.name when sorting *and* grouping by these attributes. Depending on the order of joining this would produce a name-clash with broken sort-results (and broken display if the original class has an attribute that clashes). I'm now doing the sorting of Links in the generic filter method for the metakit backend. I've left the dead code in the metakit-backend since correctly implementing this in the backend will probably be more efficient. - updated doc/design.html with the new docstring of filter.

author	Ralf Schlatterbeck <schlatterbeck@users.sourceforge.net>
date	Mon, 21 Aug 2006 12:19:48 +0000
parents	a15c15510e99
children	bffa231ec3bc

comparison

equal deleted inserted replaced

-:b9301ae1c34d
+:193f316dbbe9
 # BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 # FOR A PARTICULAR PURPOSE.  THE CODE PROVIDED HEREUNDER IS ON AN "AS IS"
 # BASIS, AND THERE IS NO OBLIGATION WHATSOEVER TO PROVIDE MAINTENANCE,
 # SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
 #
-# $Id: hyperdb.py,v 1.123 2006-08-11 04:50:24 richard Exp $
+# $Id: hyperdb.py,v 1.124 2006-08-21 12:19:48 schlatterbeck Exp $
 """Hyperdatabase implementation, especially field types.
 """
 __docformat__ = 'restructuredtext'
 # standard python modules
 import sys, os, time, re, shutil, weakref
+from sets import Set
 # roundup modules
 import date, password
-from support import ensureParentsExist, PrioList, Proptree
+from support import ensureParentsExist, PrioList, sorted, reversed
 #
 # Types
 #
-class String:
+class _Type(object):
-"""An object designating a String property."""
+"""A roundup property type."""
-def __init__(self, indexme='no'):
+def __init__(self, required=False):
-self.indexme = indexme == 'yes'
+self.required = required
 def __repr__(self):
 ' more useful for dumps '
-return '<%s>'%self.__class__
+return '<%s.%s>'%(self.__class__.__module__, self.__class__.__name__)
+def sort_repr (self, cls, val, name):
+"""Representation used for sorting. This should be a python
+built-in type, otherwise sorting will take ages. Note that
+individual backends may chose to use something different for
+sorting as long as the outcome is the same.
+"""
+return val
+class String(_Type):
+"""An object designating a String property."""
+def __init__(self, indexme='no', required=False):
+super(String, self).__init__(required)
+self.indexme = indexme == 'yes'
 def from_raw(self, value, **kw):
 """fix the CRLF/CR -> LF stuff"""
 return fixNewlines(value)
+def sort_repr (self, cls, val, name):
-class Password:
+if name == 'id':
+return int(val)
+return val
+class Password(_Type):
 """An object designating a Password property."""
-def __repr__(self):
-' more useful for dumps '
-return '<%s>'%self.__class__
 def from_raw(self, value, **kw):
 if not value:
 return None
 m = password.Password.pwre.match(value)
 if m:
 try:
 value = password.Password(value)
 except password.PasswordValueError, message:
 raise HyperdbValueError, 'property %s: %s'%(propname, message)
 return value
+def sort_repr (self, cls, val, name):
-class Date:
+if not val:
+return val
+return str(val)
+class Date(_Type):
 """An object designating a Date property."""
-def __init__(self, offset = None):
+def __init__(self, offset=None, required=False):
+super(Date, self).__init__(required)
 self._offset = offset
-def __repr__(self):
+def offset(self, db):
-' more useful for dumps '
+if self._offset is not None:
-return '<%s>'%self.__class__
-def offset (self, db) :
-if self._offset is not None :
 return self._offset
-return db.getUserTimezone ()
+return db.getUserTimezone()
 def from_raw(self, value, db, **kw):
 try:
 value = date.Date(value, self.offset(db))
 except ValueError, message:
 raise HyperdbValueError, 'property %s: %r is an invalid '\
 'date (%s)'%(kw['propname'], value, message)
 return value
 def range_from_raw(self, value, db):
 """return Range value from given raw value with offset correction"""
 return date.Range(value, date.Date, offset=self.offset(db))
+def sort_repr (self, cls, val, name):
-class Interval:
+if not val:
+return val
+return str(val)
+class Interval(_Type):
 """An object designating an Interval property."""
-def __repr__(self):
-' more useful for dumps '
-return '<%s>'%self.__class__
 def from_raw(self, value, **kw):
 try:
 value = date.Interval(value)
 except ValueError, message:
 raise HyperdbValueError, 'property %s: %r is an invalid '\
 'date interval (%s)'%(kw['propname'], value, message)
 return value
+def sort_repr (self, cls, val, name):
-class Link:
+if not val:
-"""An object designating a Link property that links to a
+return val
-node in a specified class."""
+return val.as_seconds()
-def __init__(self, classname, do_journal='yes'):
-''' Default is to not journal link and unlink events
+class _Pointer(_Type):
-'''
+"""An object designating a Pointer property that links or multilinks
+to a node in a specified class."""
+def __init__(self, classname, do_journal='yes', required=False):
+''' Default is to journal link and unlink events
+'''
+super(_Pointer, self).__init__(required)
 self.classname = classname
 self.do_journal = do_journal == 'yes'
 def __repr__(self):
-' more useful for dumps '
+"""more useful for dumps. But beware: This is also used in schema
-return '<%s to "%s">'%(self.__class__, self.classname)
+storage in SQL backends!
+"""
+return '<%s.%s to "%s">'%(self.__class__.__module__,
+self.__class__.__name__, self.classname)
+class Link(_Pointer):
+"""An object designating a Link property that links to a
+node in a specified class."""
 def from_raw(self, value, db, propname, **kw):
 if value == '-1' or not value:
 value = None
 else:
 value = convertLinkValue(db, propname, self, value)
 return value
+def sort_repr (self, cls, val, name):
-class Multilink:
+if not val:
+return val
+op = cls.labelprop()
+if op == 'id':
+return int(cls.get(val, op))
+return cls.get(val, op)
+class Multilink(_Pointer):
 """An object designating a Multilink property that links
 to nodes in a specified class.
 "classname" indicates the class to link to
 "do_journal" indicates whether the linked-to nodes should have
 'link' and 'unlink' events placed in their journal
 """
-def __init__(self, classname, do_journal='yes'):
-''' Default is to not journal link and unlink events
-'''
-self.classname = classname
-self.do_journal = do_journal == 'yes'
-def __repr__(self):
-' more useful for dumps '
-return '<%s to "%s">'%(self.__class__, self.classname)
 def from_raw(self, value, db, klass, propname, itemid, **kw):
 if not value:
 return []
 # get the current item value if it's not a new item
 value = [int(x) for x in value]
 value.sort()
 value = [str(x) for x in value]
 return value
-class Boolean:
+def sort_repr (self, cls, val, name):
+if not val:
+return val
+op = cls.labelprop()
+if op == 'id':
+return [int(cls.get(v, op)) for v in val]
+return [cls.get(v, op) for v in val]
+class Boolean(_Type):
 """An object designating a boolean property"""
-def __repr__(self):
-'more useful for dumps'
-return '<%s>' % self.__class__
 def from_raw(self, value, **kw):
 value = value.strip()
 # checked is a common HTML checkbox value
 value = value.lower() in ('checked', 'yes', 'true', 'on', '1')
 return value
-class Number:
+class Number(_Type):
 """An object designating a numeric property"""
-def __repr__(self):
-'more useful for dumps'
-return '<%s>' % self.__class__
 def from_raw(self, value, **kw):
 value = value.strip()
 try:
 value = float(value)
 except ValueError:
 m = dre.match(designator)
 if m is None:
 raise DesignatorError, '"%s" not a node designator'%designator
 return m.group(1), m.group(2)
+class Proptree(object):
+''' Simple tree data structure for optimizing searching of
+properties. Each node in the tree represents a roundup Class
+Property that has to be navigated for finding the given search
+or sort properties. The sort_type attribute is used for
+distinguishing nodes in the tree used for sorting or searching: If
+it is 0 for a node, that node is not used for sorting. If it is 1,
+it is used for both, sorting and searching. If it is 2 it is used
+for sorting only.
+The Proptree is also used for transitively searching attributes for
+backends that do not support transitive search (e.g. anydbm). The
+_val attribute with set_val is used for this.
+'''
+def __init__(self, db, cls, name, props, parent = None):
+self.db = db
+self.name = name
+self.props = props
+self.parent = parent
+self._val = None
+self.has_values = False
+self.cls = cls
+self.classname = None
+self.uniqname = None
+self.children = []
+self.sortattr = []
+self.propdict = {}
+self.sort_type = 0
+self.sort_direction = None
+self.sort_ids = None
+self.sort_ids_needed = False
+self.sort_result = None
+self.attr_sort_done = False
+self.tree_sort_done = False
+self.propclass = None
+if parent:
+self.root = parent.root
+self.depth = parent.depth + 1
+else:
+self.root = self
+self.seqno = 1
+self.depth = 0
+self.sort_type = 1
+self.id = self.root.seqno
+self.root.seqno += 1
+if self.cls:
+self.classname = self.cls.classname
+self.uniqname = '%s%s' % (self.cls.classname, self.id)
+if not self.parent:
+self.uniqname = self.cls.classname
+def append(self, name, sort_type = 0):
+"""Append a property to self.children. Will create a new
+propclass for the child.
+"""
+if name in self.propdict:
+pt = self.propdict[name]
+if sort_type and not pt.sort_type:
+pt.sort_type = 1
+return pt
+propclass = self.props[name]
+cls = None
+props = None
+if isinstance(propclass, (Link, Multilink)):
+cls = self.db.getclass(propclass.classname)
+props = cls.getprops()
+child = self.__class__(self.db, cls, name, props, parent = self)
+child.sort_type = sort_type
+child.propclass = propclass
+self.children.append(child)
+self.propdict[name] = child
+return child
+def compute_sort_done(self, mlseen=False):
+""" Recursively check if attribute is needed for sorting
+(self.sort_type > 0) or all children have tree_sort_done set and
+sort_ids_needed unset: set self.tree_sort_done if one of the conditions
+holds. Also remove sort_ids_needed recursively once having seen a
+Multilink.
+"""
+if isinstance (self.propclass, Multilink):
+mlseen = True
+if mlseen:
+self.sort_ids_needed = False
+self.tree_sort_done = True
+for p in self.children:
+p.compute_sort_done(mlseen)
+if not p.tree_sort_done:
+self.tree_sort_done = False
+if not self.sort_type:
+self.tree_sort_done = True
+if mlseen:
+self.tree_sort_done = False
+def ancestors(self):
+p = self
+while p.parent:
+yield p
+p = p.parent
+def search(self, search_matches=None, sort=True):
+""" Recursively search for the given properties in a proptree.
+Once all properties are non-transitive, the search generates a
+simple _filter call which does the real work
+"""
+filterspec = {}
+for p in self.children:
+if p.sort_type < 2:
+if p.children:
+p.search(sort = False)
+filterspec[p.name] = p.val
+self.val = self.cls._filter(search_matches, filterspec, sort and self)
+return self.val
+def sort (self, ids=None):
+""" Sort ids by the order information stored in self. With
+optimisations: Some order attributes may be precomputed (by the
+backend) and some properties may already be sorted.
+"""
+if ids is None:
+ids = self.val
+if self.sortattr and [s for s in self.sortattr if not s.attr_sort_done]:
+return self._searchsort(ids, True, True)
+return ids
+def sortable_children(self, intermediate=False):
+""" All children needed for sorting. If intermediate is True,
+intermediate nodes (not being a sort attribute) are returned,
+too.
+"""
+return [p for p in self.children
+if p.sort_type > 0 and (intermediate or p.sort_direction)]
+def __iter__(self):
+""" Yield nodes in depth-first order -- visited nodes first """
+for p in self.children:
+yield p
+for c in p:
+yield c
+def _get (self, ids):
+"""Lookup given ids -- possibly a list of list. We recurse until
+we have a list of ids.
+"""
+if not ids:
+return ids
+if isinstance (ids[0], list):
+cids = [self._get(i) for i in ids]
+else:
+cids = [i and self.parent.cls.get(i, self.name) for i in ids]
+if self.sortattr:
+cids = [self._searchsort(i, False, True) for i in cids]
+return cids
+def _searchsort(self, ids=None, update=True, dosort=True):
+""" Recursively compute the sort attributes. Note that ids
+may be a deeply nested list of lists of ids if several
+multilinks are encountered on the way from the root to an
+individual attribute. We make sure that everything is properly
+sorted on the way up. Note that the individual backend may
+already have precomputed self.result or self.sort_ids. In this
+case we do nothing for existing sa.result and recurse further if
+self.sort_ids is available.
+Yech, Multilinks: This gets especially complicated if somebody
+sorts by different attributes of the same multilink (or
+transitively across several multilinks). My use-case is sorting
+by issue.messages.author and (reverse) by issue.messages.date.
+In this case we sort the messages by author and date and use
+this sorted list twice for sorting issues. This means that
+issues are sorted by author and then by the time of the messages
+*of this author*. Probably what the user intends in that case,
+so we do *not* use two sorted lists of messages, one sorted by
+author and one sorted by date for sorting issues.
+"""
+for pt in self.sortable_children(intermediate = True):
+# ids can be an empty list
+if pt.tree_sort_done or not ids:
+continue
+if pt.sort_ids: # cached or computed by backend
+cids = pt.sort_ids
+else:
+cids = pt._get(ids)
+if pt.sort_direction and not pt.sort_result:
+sortrep = pt.propclass.sort_repr
+pt.sort_result = pt._sort_repr(sortrep, cids)
+pt.sort_ids = cids
+if pt.children:
+pt._searchsort(cids, update, False)
+if self.sortattr and dosort:
+ids = self._sort(ids)
+if not update:
+for pt in self.sortable_children(intermediate = True):
+pt.sort_ids = None
+for pt in self.sortattr:
+pt.sort_result = None
+return ids
+def _set_val(self, val):
+"""Check if self._val is already defined. If yes, we compute the
+intersection of the old and the new value(s)
+"""
+if self.has_values:
+v = self._val
+if not isinstance(self._val, type([])):
+v = [self._val]
+vals = Set(v)
+vals.intersection_update(val)
+self._val = [v for v in vals]
+else:
+self._val = val
+self.has_values = True
+val = property(lambda self: self._val, _set_val)
+def _sort(self, val):
+"""Finally sort by the given sortattr.sort_result. Note that we
+do not sort by attrs having attr_sort_done set. The caller is
+responsible for setting attr_sort_done only for trailing
+attributes (otherwise the sort order is wrong). Since pythons
+sort is stable, we can sort already sorted lists without
+destroying the sort-order for items that compare equal with the
+current sort.
+Sorting-Strategy: We sort repeatedly by different sort-keys from
+right to left. Since pythons sort is stable, we can safely do
+that. An optimisation is a "run-length encoding" of the
+sort-directions: If several sort attributes sort in the same
+direction we can combine them into a single sort. Note that
+repeated sorting is probably more efficient than using
+compare-methods in python due to the overhead added by compare
+methods.
+"""
+if not val:
+return val
+sortattr = []
+directions = []
+dir_idx = []
+idx = 0
+curdir = None
+for sa in self.sortattr:
+if sa.attr_sort_done:
+break
+if sortattr:
+assert len(sortattr[0]) == len(sa.sort_result)
+sortattr.append (sa.sort_result)
+if curdir != sa.sort_direction:
+dir_idx.append (idx)
+directions.append (sa.sort_direction)
+curdir = sa.sort_direction
+idx += 1
+sortattr.append (val)
+#print >> sys.stderr, "\nsortattr", sortattr
+sortattr = zip (*sortattr)
+for dir, i in reversed(zip(directions, dir_idx)):
+rev = dir == '-'
+sortattr = sorted (sortattr, key = lambda x:x[i:idx], reverse = rev)
+idx = i
+return [x[-1] for x in sortattr]
+def _sort_repr(self, sortrep, ids):
+"""Call sortrep for given ids -- possibly a list of list. We
+recurse until we have a list of ids.
+"""
+if not ids:
+return ids
+if isinstance (ids[0], list):
+res = [self._sort_repr(sortrep, i) for i in ids]
+else:
+res = [sortrep(self.cls, i, self.name) for i in ids]
+return res
+def __repr__(self):
+r = ["proptree:" + self.name]
+for n in self:
+r.append("proptree:" + "    " * n.depth + n.name)
+return '\n'.join(r)
+__str__ = __repr__
 #
 # the base Database class
 #
 class DatabaseError(ValueError):
 '''Error to be raised when there is some problem in the database code
 self.do_journal = 1
 # do the db-related init stuff
 db.addclass(self)
-actions = "create set retire restore".split ()
+actions = "create set retire restore".split()
-self.auditors = dict ([(a, PrioList ()) for a in actions])
+self.auditors = dict([(a, PrioList()) for a in actions])
-self.reactors = dict ([(a, PrioList ()) for a in actions])
+self.reactors = dict([(a, PrioList()) for a in actions])
 def __repr__(self):
 '''Slightly more useful representation
 '''
 return '<hyperdb.Class "%s">'%self.classname
 None, or a TypeError is raised.  The values of the key property on
 all existing nodes must be unique or a ValueError is raised.
 """
 raise NotImplementedError
-def setlabelprop (self, labelprop):
+def setlabelprop(self, labelprop):
 """Set the label property. Used for override of labelprop
 resolution order.
 """
-if labelprop not in self.getprops () :
+if labelprop not in self.getprops():
 raise ValueError, "Not a property name: %s" % labelprop
 self._labelprop = labelprop
-def setorderprop (self, orderprop):
+def setorderprop(self, orderprop):
 """Set the order property. Used for override of orderprop
 resolution order
 """
-if orderprop not in self.getprops () :
+if orderprop not in self.getprops():
 raise ValueError, "Not a property name: %s" % orderprop
 self._orderprop = orderprop
 def getkey(self):
 """Return the name of the key property for this class or None."""
 1. key property
 2. "name" property
 3. "title" property
 4. first property from the sorted property name list
 """
-if hasattr (self, '_labelprop') :
+if hasattr(self, '_labelprop'):
 return self._labelprop
 k = self.getkey()
 if  k:
 return k
 props = self.getprops()
 return 'id'
 props = props.keys()
 props.sort()
 return props[0]
-def orderprop (self):
+def orderprop(self):
 """Return the property name to use for sorting for the given node.
 This method computes the property for sorting.
 It tries the following in order:
 0. self._orderprop if set
 1. "order" property
-2. self.labelprop ()
+2. self.labelprop()
 """
-if hasattr (self, '_orderprop') :
+if hasattr(self, '_orderprop'):
 return self._orderprop
-props = self.getprops ()
+props = self.getprops()
-if props.has_key ('order'):
+if props.has_key('order'):
 return 'order'
-return self.labelprop ()
+return self.labelprop()
 def lookup(self, keyvalue):
 """Locate a particular node by its key property and return its id.
 If this class has no key property, a TypeError is raised.  If the
 """For some backends this implements the non-transitive
 search, for more information see the filter method.
 """
 raise NotImplementedError
-def _proptree (self, filterspec):
+def _proptree(self, filterspec, sortattr=[]):
 """Build a tree of all transitive properties in the given
 filterspec.
 """
-proptree = Proptree (self.db, self, '', self.getprops ())
+proptree = Proptree(self.db, self, '', self.getprops())
-for key, v in filterspec.iteritems ():
+for key, v in filterspec.iteritems():
-keys = key.split ('.')
+keys = key.split('.')
 p = proptree
 for k in keys:
-p = p.append (k)
+p = p.append(k)
 p.val = v
+multilinks = {}
+for s in sortattr:
+keys = s[1].split('.')
+p = proptree
+for k in keys:
+p = p.append(k, sort_type = 2)
+if isinstance (p.propclass, Multilink):
+multilinks[p] = True
+if p.cls:
+p = p.append(p.cls.orderprop(), sort_type = 2)
+if p.sort_direction: # if an orderprop is also specified explicitly
+continue
+p.sort_direction = s[0]
+proptree.sortattr.append (p)
+for p in multilinks.iterkeys():
+sattr = {}
+for c in p:
+if c.sort_direction:
+sattr [c] = True
+for sa in proptree.sortattr:
+if sa in sattr:
+p.sortattr.append (sa)
 return proptree
-def _propsearch (self, search_matches, proptree, sort, group):
+def get_transitive_prop(self, propname_path, default = None):
-""" Recursively search for the given properties in proptree.
-Once all properties are non-transitive, the search generates a
-simple _filter call which does the real work
-"""
-for p in proptree.children:
-if not p.children:
-continue
-p.val = p.cls._propsearch (None, p, (None, None), (None, None))
-filterspec = dict ([(p.name, p.val) for p in proptree.children])
-return self._filter (search_matches, filterspec, sort, group)
-def get_transitive_prop (self, propname_path, default = None) :
 """Expand a transitive property (individual property names
 separated by '.' into a new property at the end of the path. If
 one of the names does not refer to a valid property, we return
 None.
 Example propname_path (for class issue): "messages.author"
 """
 props = self.db.getclass(self.classname).getprops()
 for k in propname_path.split('.'):
-try :
+try:
 prop = props[k]
 except KeyError, TypeError:
 return default
-cl = getattr (prop, 'classname', None)
+cl = getattr(prop, 'classname', None)
 props = None
 if cl:
-props = self.db.getclass (cl).getprops()
+props = self.db.getclass(cl).getprops()
 return prop
-def filter(self, search_matches, filterspec, sort=(None,None),
+def _sortattr(self, sort=[], group=[]):
-group=(None,None)):
+"""Build a single list of sort attributes in the correct order
+with sanity checks (no duplicate properties) included. Always
+sort last by id -- if id is not already in sortattr.
+"""
+seen = {}
+sortattr = []
+for srt in group, sort:
+if not isinstance(srt, list):
+srt = [srt]
+for s in srt:
+if s[1] and s[1] not in seen:
+sortattr.append((s[0] or '+', s[1]))
+seen[s[1]] = True
+if 'id' not in seen :
+sortattr.append(('+', 'id'))
+return sortattr
+def filter(self, search_matches, filterspec, sort=[], group=[]):
 """Return a list of the ids of the active nodes in this class that
 match the 'filter' spec, sorted by the group spec and then the
 sort spec.
 "filterspec" is {propname: value(s)}
-Note that now the propname in filterspec may be transitive,
+"sort" and "group" are [(dir, prop), ...] where dir is '+', '-'
-i.e., it may contain properties of the form link.link.link.name,
+or None and prop is a prop name or None. Note that for
-e.g. you can search for all issues where a message was added by
+backward-compatibility reasons a single (dir, prop) tuple is
-a certain user in the last week with a filterspec of
+also allowed.
-{'messages.author' : '42', 'messages.creation' : '.-1w;'}
-"sort" and "group" are (dir, prop) where dir is '+', '-' or None
-and prop is a prop name or None
 "search_matches" is {nodeid: marker}
 The filter must match all properties specificed. If the property
 value to match is a list:
 1. String properties must match all elements in the list, and
 2. Other properties must match any of the elements in the list.
+Note that now the propname in filterspec and prop in a
+sort/group spec may be transitive, i.e., it may contain
+properties of the form link.link.link.name, e.g. you can search
+for all issues where a message was added by a certain user in
+the last week with a filterspec of
+{'messages.author' : '42', 'messages.creation' : '.-1w;'}
 Implementation note:
 This implements a non-optimized version of Transitive search
 using _filter implemented in a backend class. A more efficient
 version can be implemented in the individual backends -- e.g.,
 an SQL backen will want to create a single SQL statement and
 override the filter method instead of implementing _filter.
 """
-proptree = self._proptree (filterspec)
+sortattr = self._sortattr(sort = sort, group = group)
-return self._propsearch (search_matches, proptree, sort, group)
+proptree = self._proptree(filterspec, sortattr)
+proptree.search(search_matches)
+return proptree.sort()
 def count(self):
 """Get the number of nodes in this class.
 If the returned integer is 'numnodes', the ids of all the nodes
 """Return a dictionary mapping property names to property objects.
 If the "protected" flag is true, we include protected properties -
 those which may not be modified.
 """
 raise NotImplementedError
+def get_required_props(self, propnames = []):
+"""Return a dict of property names mapping to property objects.
+All properties that have the "required" flag set will be
+returned in addition to all properties in the propnames
+parameter.
+"""
+props = self.getprops(protected = False)
+pdict = dict([(p, props[p]) for p in propnames])
+pdict.update([(k, v) for k, v in props.iteritems() if v.required])
+return pdict
 def addprop(self, **properties):
 """Add properties to this class.
 The keyword arguments in 'properties' must map names to property

Mercurial > p > roundup > code

comparison roundup/hyperdb.py @ 3682:193f316dbbe9