[gnue] r7063 - in trunk/gnue-appserver/src: . language

[johannes]

Author: johannes
Date: 2005-02-25 06:46:43 -0600 (Fri, 25 Feb 2005)
New Revision: 7063

Modified:
   trunk/gnue-appserver/src/data.py
   trunk/gnue-appserver/src/language/ObjectList.py
   trunk/gnue-appserver/src/language/Session.py
Log:
propertynames are now automatically qualified in prefetch-list, sortorder and 
conditions. Conditions might contain Object instances


Modified: trunk/gnue-appserver/src/data.py
===================================================================
--- trunk/gnue-appserver/src/data.py    2005-02-25 10:59:00 UTC (rev 7062)
+++ trunk/gnue-appserver/src/data.py    2005-02-25 12:46:43 UTC (rev 7063)
@@ -549,7 +549,7 @@
     cTree = GConditions.buildTreeFromList (conditions)
 
   elif isinstance (conditions, DictType):
-    cTree = GConditions.buildTreeFromDict (conditions)
+    cTree = GConditions.buildConditionFromDict (conditions)
 
   else:
     cTree = conditions

Modified: trunk/gnue-appserver/src/language/ObjectList.py
===================================================================
--- trunk/gnue-appserver/src/language/ObjectList.py     2005-02-25 10:59:00 UTC 
(rev 7062)
+++ trunk/gnue-appserver/src/language/ObjectList.py     2005-02-25 12:46:43 UTC 
(rev 7063)
@@ -21,8 +21,10 @@
 #
 # $Id$
 
-from types import SliceType
+import types
+
 from Object import Object
+from gnue.common.datasources import GConditions
 
 CACHE_STEP = 10
 
@@ -34,17 +36,20 @@
   # -------------------------------------------------------------------------
   # Constructor
   # -------------------------------------------------------------------------
+
   def __init__ (self, session, classname, cond, sort, properties, definition):
-    self.classname   = classname
-    self.conditions  = cond
-    self.sortOrder   = sort
-    self.properties  = properties
-    self.definition  = definition
 
     self.__session   = session
     self.__list      = []
     self.__list_id   = None
+    self.__sid       = session.getSessionId ()
 
+    self.classname   = classname
+    self.conditions  = self.__normalizeCondition (cond)
+    self.sortOrder   = self.__normalizeSorting (sort)
+    self.properties  = self.__normalizeProperties (properties)
+    self.definition  = definition
+
     self.__cacheStep = CACHE_STEP
     self.__buildList ()
 
@@ -56,8 +61,7 @@
   def __len__ (self):
 
     sm  = self.__session.getSessionManager ()
-    sid = self.__session.getSessionId ()
-    return sm.count (sid, self.__list_id)
+    return sm.count (self.__sid, self.__list_id)
 
 
   # ---------------------------------------------------------------------------
@@ -74,7 +78,7 @@
   # -------------------------------------------------------------------------
   def __getitem__ (self, index):
     try:
-      if type (index) == SliceType:
+      if type (index) == types.SliceType:
         if index.start < 0:
           self.__fillup ()
 
@@ -101,10 +105,9 @@
   # -------------------------------------------------------------------------
   def __buildList (self):
     sm  = self.__session.getSessionManager ()
-    sid = self.__session.getSessionId ()
 
-    self.__list_id = sm.request (sid, self.classname, self.conditions,
-                                      self.sortOrder, self.properties)
+    self.__list_id = sm.request (self.__sid, self.classname, self.conditions,
+                                 self.sortOrder, self.properties)
     self.__list = []
     self.__populateList ()
 
@@ -114,9 +117,9 @@
   # -------------------------------------------------------------------------
   def __populateList (self):
     sm  = self.__session.getSessionManager ()
-    sid = self.__session.getSessionId ()
 
-    rset = sm.fetch (sid, self.__list_id, len (self.__list), 
self.__cacheStep,0)
+    rset = sm.fetch (self.__sid, self.__list_id, len (self.__list),
+                     self.__cacheStep, 0)
     for row in rset:
       obj = Object (self.__session, self.classname, row [0], self.definition)
       self.__list.append (obj)
@@ -139,3 +142,96 @@
       while self._populateList ():
         pass
 
+
+  # ---------------------------------------------------------------------------
+  # Normalize a condition given to a find
+  # ---------------------------------------------------------------------------
+
+  def __normalizeCondition (self, conditions):
+    """
+    This function returns a normalized form of a condition. This means all
+    field names are fully qualified and all constants given as Object instances
+    will be replaced by their gnue_id.
+
+    @param conditions: a condition as sequence, dictionary or condition tree
+
+    @return: the normalized condition in prefix notation
+    """
+
+    if conditions is None or not len (conditions):
+      return None
+
+    if isinstance (conditions, types.ListType):
+      cTree = GConditions.buildTreeFromList (conditions)
+
+    elif isinstance (conditions, types.DictType):
+      cTree = GConditions.buildConditionFromDict (conditions)
+
+    else:
+      cTree = conditions
+
+    try:
+      # Replace all constant values represented by an Object instance with the
+      # apropriate gnue_id
+      for item in cTree.findChildrenOfType ('GCCConst', True, True):
+        if isinstance (item.value, Object):
+          item.value = item.value.gnue_id
+
+      # Make sure all field names are fully qualified
+      for item in cTree.findChildrenOfType ('GCCField', True, True):
+        item.name = self.__session.qualifyMultiple (item.name)
+
+      return cTree.prefixNotation ()
+
+    finally:
+      cTree.breakReferences ()
+
+
+  # ---------------------------------------------------------------------------
+  # Create a sequence of fully qualified property names
+  # ---------------------------------------------------------------------------
+
+  def __normalizeProperties (self, sequence):
+    """
+    This function returns a sequence of fully qualified names.
+
+    @param sequence: sequence of names
+    @return: sequence with fully qualified names
+    """
+
+    return [self.__session.qualifyMultiple (p) for p in sequence]
+
+
+  # ---------------------------------------------------------------------------
+  # Create a normalized sort order
+  # ---------------------------------------------------------------------------
+
+  def __normalizeSorting (self, sorting):
+    """
+    This function returns a normalized sorting sequence. Such a sequence has
+    all fields fully qualified.
+
+    @param sorting: sorting sequence to be normalized
+    @return: sorting sequence with all fields fully qualified
+    """
+
+    result = []
+
+    for item in sorting:
+      if isinstance (item, types.DictType):
+        item ['name'] = self.__session.qualifyMultiple (item ['name'])
+
+      elif isinstance (item, types.ListType):
+        item [0] = self.__session.qualifyMultiple (item [0])
+
+      elif isinstance (item, types.TupleType):
+        data = list (item)
+        data [0] = self.__session.qualifyMultiple (data [0])
+        item = tuple (data)
+
+      else:
+        item = self.__session.qualifyMultiple (item)
+
+      result.append (item)
+
+    return result

Modified: trunk/gnue-appserver/src/language/Session.py
===================================================================
--- trunk/gnue-appserver/src/language/Session.py        2005-02-25 10:59:00 UTC 
(rev 7062)
+++ trunk/gnue-appserver/src/language/Session.py        2005-02-25 12:46:43 UTC 
(rev 7063)
@@ -22,6 +22,7 @@
 # $Id$
 
 import types
+import string
 
 from ObjectList import ObjectList
 from Object import Object
@@ -161,7 +162,23 @@
         return self.__context + "_" + name
 
 
+  # ---------------------------------------------------------------------------
+  # Qualify an identifier consisting of multiple parts
+  # ---------------------------------------------------------------------------
 
+  def qualifyMultiple (self, name):
+    """
+    This function returns a fully qualified identifier for a name with multiple
+    parts, i.e. 'foo.bar.baz' will be qualified in a context of 'ctx' as
+    'ctx_foo.ctx_bar.ctx_baz'.
+
+    @param name: name to be qualified
+    @return: fully qualified version of name
+    """
+
+    return string.join ([self.qualify (p) for p in name.split ('.')], ".")
+
+
   # -------------------------------------------------------------------------
   # Close the session 
   # -------------------------------------------------------------------------