Changeset 3521 for pykota

Timestamp:

04/15/10 01:21:11 (14 years ago)

Author:

jerome

Message:

Removed some code specific to Python v2.2 and earlier.
Improved the work done by bse@… to fix #52.
IMPORTANT : the same optimisation is currently done for users only, not for
users groups, printers or billing codes. And more importantly the code
was not ported to the LDAP backend. I need more time to do all this.

Location:

pykota/trunk/pykota/storages

Files:

• ldapstorage.py (modified) (4 diffs)
• sql.py (modified) (6 diffs)

pykota/trunk/pykota/storages/ldapstorage.py

@@ -704 +704 @@
         if result :
             patterns = printerpattern.split(",")
-            try :
-                patdict = {}.fromkeys(patterns)
-            except AttributeError :
-                # Python v2.2 or earlier
-                patdict = {}
-                for p in patterns :
-                    patdict[p] = None
+            patdict = {}.fromkeys(patterns)
             for (printerid, fields) in result :
                 printername = databaseToUnicode(fields.get("pykotaPrinterName", [""])[0] or fields.get(self.info["printerrdn"], [""])[0])
@@ -740 +734 @@
         if result :
             patterns = userpattern.split(",")
-            try :
-                patdict = {}.fromkeys(patterns)
-            except AttributeError :
-                # Python v2.2 or earlier
-                patdict = {}
-                for p in patterns :
-                    patdict[p] = None
+            patdict = {}.fromkeys(patterns)
             for (userid, fields) in result :
                 username = databaseToUnicode(fields.get("pykotaUserName", [""])[0] or fields.get(self.info["userrdn"], [""])[0])
@@ -807 +795 @@
         if result :
             patterns = grouppattern.split(",")
-            try :
-                patdict = {}.fromkeys(patterns)
-            except AttributeError :
-                # Python v2.2 or earlier
-                patdict = {}
-                for p in patterns :
-                    patdict[p] = None
+            patdict = {}.fromkeys(patterns)
             for (groupid, fields) in result :
                 groupname = databaseToUnicode(fields.get("pykotaGroupName", [""])[0] or fields.get(self.info["grouprdn"], [""])[0])
@@ -1823 +1805 @@
         if result :
             patterns = billingcodepattern.split(",")
-            try :
-                patdict = {}.fromkeys(patterns)
-            except AttributeError :
-                # Python v2.2 or earlier
-                patdict = {}
-                for p in patterns :
-                    patdict[p] = None
+            patdict = {}.fromkeys(patterns)
             for (codeid, fields) in result :
                 codename = databaseToUnicode(fields.get("pykotaBillingCode", [""])[0])

pykota/trunk/pykota/storages/sql.py

@@ -28 +28 @@
 
 from pykota.utils import *
+
+MAXINNAMES = 500 # Maximum number of non-patterns names to use in a single IN statement
 
 class SQLStorage :
@@ -445 +447 @@
         return pgroups
 
+    def hasWildCards(self, pattern) :
+        """Returns True if the pattern contains wildcards, else False."""
+        specialchars = "*?[!" # no need to check for ] since [ would be there first
+        for specialchar in specialchars :
+            if specialchar in pattern :
+                return True
+        return False
+
     def getMatchingPrinters(self, printerpattern) :
         """Returns the list of all printers for which name matches a certain pattern."""
@@ -454 +464 @@
         if result :
             patterns = printerpattern.split(",")
-            try :
-                patdict = {}.fromkeys(patterns)
-            except AttributeError :
-                # Python v2.2 or earlier
-                patdict = {}
-                for p in patterns :
-                    patdict[p] = None
+            patdict = {}.fromkeys(patterns)
             for record in result :
                 pname = databaseToUnicode(record["printername"])
@@ -475 +479 @@
         # but we don't because other storages semantics may be different, so every
         # storage should use fnmatch to match patterns and be storage agnostic
-        result = self.doSearch("SELECT * FROM users")
-        if result :
-            patterns = userpattern.split(",")
-            try :
-                patdict = {}.fromkeys(patterns)
-            except AttributeError :
-                # Python v2.2 or earlier
-                patdict = {}
-                for p in patterns :
-                    patdict[p] = None
-            for record in result :
-                uname = databaseToUnicode(record["username"])
-                if patdict.has_key(uname) or self.tool.matchString(uname, patterns) :
-                    user = self.storageUserFromRecord(uname, record)
-                    users.append(user)
-                    self.cacheEntry("USERS", user.Name, user)
+        #
+        # This doesn't prevent us from being smarter, thanks to bse@chalmers.se
+        userpattern = userpattern or "*"
+        patterns = userpattern.split(",")
+        patdict = {}.fromkeys(patterns)
+        patterns = patdict.keys() # Ensures the uniqueness of each pattern, but we lose the cmd line ordering
+        # BEWARE : if a single pattern contains wild cards, we'll still use the slow route.
+        if self.hasWildCards(userpattern) :
+            # Slow route
+            result = self.doSearch("SELECT * FROM users")
+            if result :
+                for record in result :
+                    uname = databaseToUnicode(record["username"])
+                    if patdict.has_key(uname) or self.tool.matchString(uname, patterns) :
+                        user = self.storageUserFromRecord(uname, record)
+                        users.append(user)
+                        self.cacheEntry("USERS", user.Name, user)
+        else :
+            # Fast route (probably not faster with a few users)
+            while patterns :
+                subset = patterns[:MAXINNAMES]
+                nbpatterns = len(subset)
+                if nbpatterns == 1 :
+                    wherestmt = "username=%s" % self.doQuote(unicodeToDatabase(subset[0]))
+                else :
+                    wherestmt = "username IN (%s)" % ",".join([self.doQuote(unicodeToDatabase(p)) for p in subset])
+                result = self.doSearch("SELECT * FROM users WHERE %s" % wherestmt)
+                if result :
+                    for record in result :
+                        uname = databaseToUnicode(record["username"])
+                        user = self.storageUserFromRecord(uname, record)
+                        users.append(user)
+                        self.cacheEntry("USERS", user.Name, user)
+                patterns = patterns[MAXINNAMES:]
+        users.sort(key=lambda u : u.Name) # Adds some ordering, we've already lost the cmd line one anyway.
         return users
 
@@ -502 +525 @@
         if result :
             patterns = grouppattern.split(",")
-            try :
-                patdict = {}.fromkeys(patterns)
-            except AttributeError :
-                # Python v2.2 or earlier
-                patdict = {}
-                for p in patterns :
-                    patdict[p] = None
+            patdict = {}.fromkeys(patterns)
             for record in result :
                 gname = databaseToUnicode(record["groupname"])
@@ -523 +540 @@
         if result :
             patterns = billingcodepattern.split(",")
-            try :
-                patdict = {}.fromkeys(patterns)
-            except AttributeError :
-                # Python v2.2 or earlier
-                patdict = {}
-                for p in patterns :
-                    patdict[p] = None
+            patdict = {}.fromkeys(patterns)
             for record in result :
                 codename = databaseToUnicode(record["billingcode"])