--- a/app/soc/logic/models/base.py	Sat Nov 22 20:54:42 2008 +0000
+++ b/app/soc/logic/models/base.py	Sat Nov 22 21:15:21 2008 +0000
@@ -295,135 +295,6 @@
 
     return query.fetch(limit, offset)
 
-  def buildTypedQueryString(self):
-    """Returns a GQL query string compatible with PolyModel.
-    """
-    return ''.join(self._buildTypedQueryParts())
-
-  def _buildTypedQueryParts(self):
-    if self._base_model:
-      return [
-          'SELECT * FROM ', self._base_model.__name__,
-          " WHERE inheritance_line = '", self.getFullModelClassName(), "'"]
-    
-    return ['SELECT * FROM ', self._model.__name__]
-
-  def buildOrderedQueryString(self, order_by=None):
-    """Returns a an ordered GQL query string compatible with PolyModel.
-  
-    Args:
-      order_by: optional field name by which to order the query results;
-        default is None, in which case no ORDER BY clause is placed in
-        the query string
-    """
-    return ''.join(self._buildOrderedQueryParts(order_by=order_by))
-
-  def _buildOrderedQueryParts(self, order_by=None):
-    query_str_parts = self._buildTypedQueryParts()
-
-    if order_by:
-      query_str_parts.extend([' ORDER BY ', order_by])
-
-    return query_str_parts
-
-  def getEntitiesForLimitAndOffset(self, limit, offset=0, order_by=None):
-    """Returns entities for given offset and limit or None if not found.
-    
-    Args:
-      limit: max amount of entities to return
-      offset: optional offset in entities list which defines first entity to
-        return; default is zero (first entity)
-    """
-    query_string = self.buildOrderedQueryString(order_by=order_by)
-    query = db.GqlQuery(query_string)
-
-    return query.fetch(limit, offset)
-
-  def getNearestEntities(self, fields_to_try):
-    """Get entities just before and just after the described entity.
-    
-    Args:
-      fields_to_try: ordered list of key/value pairs that "describe"
-        the desired entity (which may not necessarily exist), where key is
-        the name of the field, and value is an instance of that field
-        used in the comparison; if value is None, that field is skipped
-
-    Returns:
-      a two-tuple: ([nearest_entities], 'field_name')
-    
-      nearest_entities: list of entities being those just before and just
-        after the (possibly non-existent) entity identified by the first
-        of the supplied (non-None) fields
-          OR
-        possibly None if query had no results for the supplied field
-        that was used.
-    """
-    # SELECT * FROM base_class WHERE inheritance_line = 'derived_class'
-    typed_query_parts = self._buildTypedQueryParts()
-  
-    if self._base_model:
-      typed_query_parts.append(' AND %s > :1')
-    else:
-      typed_query_parts.append(' WHERE %s > :1')
-
-    typed_query_fmt = ''.join(typed_query_parts)
-
-    for field, value in fields_to_try:
-      if value is None:
-        # skip this not-supplied field
-        continue
-
-      query = db.GqlQuery(typed_query_fmt % field, value)
-      return query.fetch(1), field
-
-    # all fields exhausted, and all had None values
-    return (None, None)
-
-  def findNearestEntitiesOffset(width, fields_to_try):
-    """Finds offset of beginning of a range of entities around the nearest.
-  
-    Args:
-      width: the width of the "found" window around the nearest User found
-      fields_to_try:  see getNearestEntities()
-    
-    Returns:
-      an offset into the list of entities that is width/2 less than the
-      offset of the first entity returned by getNearestEntities(), or zero
-      if that offset would be less than zero
-        OR
-      None if there are no nearest entities or the offset of the beginning of
-      the range cannot be found for some reason 
-    """
-    # find entity "nearest" to supplied fields
-    nearest_entities, field = self.getNearestEntities(fields_to_try)
-  
-    if not nearest_entities:
-      # no "nearest" entity, so indicate that with None
-      return None
-
-    nearest_entity = nearest_entities[0]
-
-    # start search for beginning of nearest Users range at offset zero
-    offset = 0
-    entities = self.getEntitiesForLimitAndOffset(width, offset=offset)
-  
-    while True:
-      for entity in entities:
-        if getattr(nearest_entity, field) == getattr(entity, field):
-          # nearest User found in current search range, so return a range start
-          return max(0, (offset - (width/2)))
-
-        offset = offset + 1
-
-      # nearest User was not in the current search range, so fetch the next set
-      entities = self.getEntitiesForLimitAndOffset(width, offset=offset)
-
-      if not entities:
-        # nearest User never found, so indicate that with None
-        break
-
-    return None
-
   def updateModelProperties(self, model, model_properties):
     """Update existing model entity using supplied model properties.