Changeset 3525

Timestamp:

04/16/10 02:56:51 (15 years ago)

Author:

jerome

Message:

Backported the improvement of the fix for #52. References #52.

Location:

pykota/branches/1.26_fixes/pykota

Files:

• storage.py (modified) (1 diff)
• storages/sql.py (modified) (2 diffs)

pykota/branches/1.26_fixes/pykota/storage.py

@@ -594 +594 @@
         """Ensures that the database connection is closed."""
         self.close()
+
+    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 getFromCache(self, cachetype, key) :

pykota/branches/1.26_fixes/pykota/storages/sql.py

@@ -447 +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."""
-        printers = []
-        # We 'could' do a SELECT printername FROM printers WHERE printername LIKE ...
-        # 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 printers")
-        if result :
-            patterns = printerpattern.split(",")
-            patdict = {}.fromkeys(patterns)
-            for record in result :
-                pname = self.databaseToUserCharset(record["printername"])
-                if patdict.has_key(pname) or self.tool.matchString(pname, patterns) :
-                    printer = self.storagePrinterFromRecord(pname, record)
-                    printers.append(printer)
-                    self.cacheEntry("PRINTERS", printer.Name, printer)
-        return printers
-
-    def getMatchingUsers(self, userpattern) :
-        """Returns the list of all users for which name matches a certain pattern."""
-        users = []
-        # We 'could' do a SELECT username FROM users WHERE username LIKE ...
+    def getMatchingStuff(self, pattern, tablename, entrytype, keyname) :
+        """Returns the list of all entries for which the name matches a certain pattern."""
+        entries = []
+        # We 'could' do a SELECT xxxxname FROM xxxx WHERE xxxxname LIKE ...
         # but we don't because other storages semantics may be different, so every
         # storage should use fnmatch to match patterns and be storage agnostic
         #
         # This doesn't prevent us from being smarter, thanks to bse@chalmers.se
-        userpattern = userpattern or "*"
-        patterns = userpattern.split(",")
+        pattern = pattern or "*"
+        patterns = pattern.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) :
+        storageEntryFromRecord = getattr(self, "storage%sFromRecord" % entrytype)
+        cachename = tablename.upper()
+        if self.hasWildCards(pattern) :
             # Slow route
-            result = self.doSearch("SELECT * FROM users")
+            result = self.doSearch("SELECT * FROM %s" % tablename)
             if result :
                 for record in result :
-                    uname = self.databaseToUserCharset(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)
+                    name = self.databaseToUserCharset(record[keyname])
+                    if patdict.has_key(name) or self.tool.matchString(name, patterns) :
+                        entry = storageEntryFromRecord(name, record)
+                        entries.append(entry)
+                        self.cacheEntry(cachename, entry.Name, entry)
+        else :
+            # Fast route (probably not faster with a few entries)
             while patterns :
                 subset = patterns[:MAXINNAMES]
                 nbpatterns = len(subset)
                 if nbpatterns == 1 :
-                    wherestmt = "username=%s" % self.doQuote(self.userCharsetToDatabase(subset[0]))
+                    wherestmt = "%s=%s" % (keyname, self.doQuote(self.userCharsetToDatabase(subset[0])))
                 else :
-                    wherestmt = "username IN (%s)" % ",".join([self.doQuote(self.userCharsetToDatabase(p)) for p in subset])
-                result = self.doSearch("SELECT * FROM users WHERE %s" % wherestmt)
+                    wherestmt = "%s IN (%s)" % (keyname,
+                                                ",".join([self.doQuote(self.userCharsetToDatabase(p)) for p in subset]))
+                result = self.doSearch("SELECT * FROM %s WHERE %s" % (tablename,
+                                                                      wherestmt))
                 if result :
                     for record in result :
-                        uname = self.databaseToUserCharset(record["username"])
-                        user = self.storageUserFromRecord(uname, record)
-                        users.append(user)
-                        self.cacheEntry("USERS", user.Name, user)
+                        name = self.databaseToUserCharset(record[keyname])
+                        entry = storageEntryFromRecord(name, record)
+                        entries.append(entry)
+                        self.cacheEntry(cachename, entry.Name, entry)
                 patterns = patterns[MAXINNAMES:]
-        users.sort(key=lambda u : u.Name) # Adds some ordering, we've already lost the cmd line one anyway.
-        return users
+        entries.sort(key=lambda e : e.Name) # Adds some ordering, we've already lost the cmd line one anyway.
+        return entries
+
+    def getMatchingPrinters(self, pattern) :
+        """Returns the list of all printers for which name matches a certain pattern."""
+        return self.getMatchingStuff(pattern, "printers", "Printer", "printername")
+
+    def getMatchingUsers(self, pattern) :
+        """Returns the list of all users for which name matches a certain pattern."""
+        return self.getMatchingStuff(pattern, "users", "User", "username")
+
+    def getMatchingBillingCodes(self, pattern) :
+        """Returns the list of all billing codes for which the label matches a certain pattern."""
+        return self.getMatchingStuff(pattern, "billingcodes", "BillingCode", "billingcode")
 
     def getMatchingGroups(self, grouppattern) :
@@ -533 +523 @@
                     self.cacheEntry("GROUPS", group.Name, group)
         return groups
-
-    def getMatchingBillingCodes(self, billingcodepattern) :
-        """Returns the list of all billing codes for which the label matches a certain pattern."""
-        codes = []
-        result = self.doSearch("SELECT * FROM billingcodes")
-        if result :
-            patterns = billingcodepattern.split(",")
-            patdict = {}.fromkeys(patterns)
-            for record in result :
-                codename = self.databaseToUserCharset(record["billingcode"])
-                if patdict.has_key(codename) or self.tool.matchString(codename, patterns) :
-                    code = self.storageBillingCodeFromRecord(codename, record)
-                    codes.append(code)
-                    self.cacheEntry("BILLINGCODES", code.BillingCode, code)
-        return codes
 
     def getPrinterUsersAndQuotas(self, printer, names=["*"]) :