implement and test bulk deletion

[matthijs/upstream/django-ldapdb.git] / ldapdb / models / query.py

diff --git a/ldapdb/models/query.py b/ldapdb/models/query.py
index 55576a6b4be1c44cb8427e49aff7c3eb29e4b42a..4f0273cc2ed6478f7fcd78897251cd1732bb932d 100644 (file)
--- a/ldapdb/models/query.py
+++ b/ldapdb/models/query.py
@@ -28,7 +28,7 @@ from django.db.models.sql.where import WhereNode as BaseWhereNode, Constraint as
 
 import ldapdb
 
-from ldapdb.models.fields import CharField, Integer, ListField
+from ldapdb.models.fields import CharField
 
 def get_lookup_operator(lookup_type):
     if lookup_type == 'gte':
@@ -63,6 +63,64 @@ class Constraint(BaseConstraint):
 
         return (self.alias, self.col, db_type), params
 
+class Compiler(object):
+    def __init__(self, query, connection, using):
+        self.query = query
+        self.connection = connection
+        self.using = using
+
+    def results_iter(self):
+        query = self.query
+        attrlist = [ x.db_column for x in query.model._meta.local_fields if x.db_column ]
+
+        vals = self.connection.search_s(
+            query.model.base_dn,
+            ldap.SCOPE_SUBTREE,
+            filterstr=query._ldap_filter(),
+            attrlist=attrlist,
+        )
+
+        # perform sorting
+        if query.extra_order_by:
+            ordering = query.extra_order_by
+        elif not query.default_ordering:
+            ordering = query.order_by
+        else:
+            ordering = query.order_by or query.model._meta.ordering
+        def cmpvals(x, y):
+            for fieldname in ordering:
+                if fieldname.startswith('-'):
+                    fieldname = fieldname[1:]
+                    negate = True
+                else:
+                    negate = False
+                field = query.model._meta.get_field(fieldname)
+                attr_x = field.from_ldap(x[1].get(field.db_column, []), connection=self.connection)
+                attr_y = field.from_ldap(y[1].get(field.db_column, []), connection=self.connection)
+                # perform case insensitive comparison
+                if hasattr(attr_x, 'lower'):
+                    attr_x = attr_x.lower()
+                if hasattr(attr_y, 'lower'):
+                    attr_y = attr_y.lower()
+                val = negate and cmp(attr_y, attr_x) or cmp(attr_x, attr_y)
+                if val:
+                    return val
+            return 0
+        vals = sorted(vals, cmp=cmpvals)
+
+        # process results
+        for dn, attrs in vals:
+            row = []
+            for field in iter(query.model._meta.fields):
+                if field.attname == 'dn':
+                    row.append(dn)
+                elif hasattr(field, 'from_ldap'):
+                    row.append(field.from_ldap(attrs.get(field.db_column, []), connection=self.connection))
+                else:
+                    row.append(None)
+            yield row
+
+
 class WhereNode(BaseWhereNode):
     def add(self, data, connector):
         if not isinstance(data, (list, tuple)):
@@ -121,77 +179,27 @@ class Query(BaseQuery):
         super(Query, self).__init__(*args, **kwargs)
         self.connection = ldapdb.connection
 
-    def get_count(self):
+    def _ldap_filter(self):
         filterstr = ''.join(['(objectClass=%s)' % cls for cls in self.model.object_classes])
         sql, params = self.where.as_sql()
         filterstr += sql
-        filterstr = '(&%s)' % filterstr
-
-        try:
-            vals = ldapdb.connection.search_s(
-                self.model.base_dn,
-                ldap.SCOPE_SUBTREE,
-                filterstr=filterstr,
-                attrlist=[],
-            )
-        except:
-            raise self.model.DoesNotExist
-
+        return '(&%s)' % filterstr
+
+    def get_count(self, using=None):
+        vals = ldapdb.connection.search_s(
+            self.model.base_dn,
+            ldap.SCOPE_SUBTREE,
+            filterstr=self._ldap_filter(),
+            attrlist=[],
+        )
         return len(vals)
 
-    def results_iter(self):
-        filterstr = ''.join(['(objectClass=%s)' % cls for cls in self.model.object_classes])
-        sql, params = self.where.as_sql()
-        filterstr += sql
-        filterstr = '(&%s)' % filterstr
-        attrlist = [ x.db_column for x in self.model._meta.local_fields if x.db_column ]
-
-        try:
-            vals = ldapdb.connection.search_s(
-                self.model.base_dn,
-                ldap.SCOPE_SUBTREE,
-                filterstr=filterstr,
-                attrlist=attrlist,
-            )
-        except:
-            raise self.model.DoesNotExist
-
-        # perform sorting
-        if self.extra_order_by:
-            ordering = self.extra_order_by
-        elif not self.default_ordering:
-            ordering = self.order_by
-        else:
-            ordering = self.order_by or self.model._meta.ordering
-        def cmpvals(x, y):
-            for field in ordering:
-                if field.startswith('-'):
-                    field = field[1:]
-                    negate = True
-                else:
-                    negate = False
-                attr = self.model._meta.get_field(field).db_column
-                attr_x = x[1].get(attr, '').lower()
-                attr_y = y[1].get(attr, '').lower()
-                val = negate and cmp(attr_y, attr_x) or cmp(attr_x, attr_y)
-                if val:
-                    return val
-            return 0
-        vals = sorted(vals, cmp=cmpvals)
+    def get_compiler(self, using=None, connection=None):
+        return Compiler(self, ldapdb.connection, using)
 
-        # process results
-        for dn, attrs in vals:
-            row = []
-            for field in iter(self.model._meta.fields):
-                if field.attname == 'dn':
-                    row.append(dn)
-                elif isinstance(field, IntegerField):
-                    row.append(int(attrs.get(field.db_column, [0])[0]))
-                elif isinstance(field, ListField):
-                    row.append(attrs.get(field.db_column, []))
-                else:
-                    row.append(attrs.get(field.db_column, [''])[0])
-            yield row
+    def results_iter(self):
+        "For django 1.1 compatibility"
+        return self.get_compiler().results_iter()
 
 class QuerySet(BaseQuerySet):
     def __init__(self, model=None, query=None, using=None):
@@ -206,3 +214,15 @@ class QuerySet(BaseQuerySet):
                 query = Query(model, None, WhereNode)
         super(QuerySet, self).__init__(model=model, query=query)
 
+    def delete(self):
+        "Bulk deletion."
+        vals = ldapdb.connection.search_s(
+            self.model.base_dn,
+            ldap.SCOPE_SUBTREE,
+            filterstr=self.query._ldap_filter(),
+            attrlist=[],
+        )
+        # FIXME : there is probably a more efficient way to do this 
+        for dn, attrs in vals:
+            ldapdb.connection.delete_s(dn)
+