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 ]
+ if self.query.select_fields:
+ fields = self.query.select_fields
+ else:
+ fields = self.query.model._meta.fields
+
+ attrlist = [ x.db_column for x in fields if x.db_column ]
- vals = self.connection.search_s(
- query.model.base_dn,
- ldap.SCOPE_SUBTREE,
- filterstr=query._ldap_filter(),
- attrlist=attrlist,
- )
+ try:
+ vals = self.connection.search_s(
+ self.query.model.base_dn,
+ ldap.SCOPE_SUBTREE,
+ filterstr=self.query._ldap_filter(),
+ attrlist=attrlist,
+ )
+ 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):
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)
+ try:
+ vals = ldapdb.connection.search_s(
+ self.model.base_dn,
+ ldap.SCOPE_SUBTREE,
+ filterstr=self._ldap_filter(),
+ attrlist=[],
+ )
+ except ldap.NO_SUCH_OBJECT:
+ return 0
+
+ number = 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)
def delete(self):
"Bulk deletion."
- vals = ldapdb.connection.search_s(
- self.model.base_dn,
- ldap.SCOPE_SUBTREE,
- filterstr=self.query._ldap_filter(),
- attrlist=[],
- )
+ 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)