self.using = using
def results_iter(self):
- query = self.query
+ if self.query.select_fields:
+ fields = self.query.select_fields
+ else:
+ fields = self.query.model._meta.fields
- filterstr = ''.join(['(objectClass=%s)' % cls for cls in query.model.object_classes])
- sql, params = query.where.as_sql()
- filterstr += sql
- filterstr = '(&%s)' % filterstr
- attrlist = [ x.db_column for x in query.model._meta.local_fields if x.db_column ]
+ attrlist = [ x.db_column for x in fields if x.db_column ]
try:
vals = self.connection.search_s(
- query.model.base_dn,
+ self.query.model.base_dn,
ldap.SCOPE_SUBTREE,
- filterstr=filterstr,
+ filterstr=self.query._ldap_filter(),
attrlist=attrlist,
)
- except:
- raise query.model.DoesNotExist
+ except ldap.NO_SUCH_OBJECT:
+ return
# perform sorting
- if query.extra_order_by:
- ordering = query.extra_order_by
- elif not query.default_ordering:
- ordering = query.order_by
+ if self.query.extra_order_by:
+ ordering = self.query.extra_order_by
+ elif not self.query.default_ordering:
+ ordering = self.query.order_by
else:
- ordering = query.order_by or query.model._meta.ordering
+ ordering = self.query.order_by or self.query.model._meta.ordering
def cmpvals(x, y):
for fieldname in ordering:
if fieldname.startswith('-'):
negate = True
else:
negate = False
- field = query.model._meta.get_field(fieldname)
+ field = self.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
vals = sorted(vals, cmp=cmpvals)
# process results
+ pos = 0
for dn, attrs in vals:
+ # FIXME : This is not optimal, we retrieve more results than we need
+ # but there is probably no other options as we can't perform ordering
+ # server side.
+ if (self.query.low_mark and pos < self.query.low_mark) or \
+ (self.query.high_mark is not None and pos >= self.query.high_mark):
+ pos += 1
+ continue
row = []
- for field in iter(query.model._meta.fields):
+ for field in iter(fields):
if field.attname == 'dn':
row.append(dn)
elif hasattr(field, 'from_ldap'):
else:
row.append(None)
yield row
+ pos += 1
class WhereNode(BaseWhereNode):
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
+ return '(&%s)' % filterstr
+ def get_count(self, using=None):
try:
- vals = self.connection.search_s(
+ vals = ldapdb.connection.search_s(
self.model.base_dn,
ldap.SCOPE_SUBTREE,
- filterstr=filterstr,
+ filterstr=self._ldap_filter(),
attrlist=[],
)
- except:
- raise self.model.DoesNotExist
+ except ldap.NO_SUCH_OBJECT:
+ return 0
+
+ number = len(vals)
- return len(vals)
+ # apply limit and offset
+ number = max(0, number - self.low_mark)
+ if self.high_mark is not None:
+ number = min(number, self.high_mark - self.low_mark)
+
+ return number
def get_compiler(self, using=None, connection=None):
return Compiler(self, ldapdb.connection, using)
query = Query(model, None, WhereNode)
super(QuerySet, self).__init__(model=model, query=query)
+ def delete(self):
+ "Bulk deletion."
+ try:
+ vals = ldapdb.connection.search_s(
+ self.model.base_dn,
+ ldap.SCOPE_SUBTREE,
+ filterstr=self.query._ldap_filter(),
+ attrlist=[],
+ )
+ except ldap.NO_SUCH_OBJECT:
+ return
+
+ # FIXME : there is probably a more efficient way to do this
+ for dn, attrs in vals:
+ ldapdb.connection.delete_s(dn)
+