def target_field(self):
"""
When filtering against this relation, returns the field on the remote
model against which the filtering should happen.
"""
target_fields = self.get_path_info()[-1].target_fields
if len(target_fields) > 1:
raise exceptions.FieldError(
"Can't use target_field for multicolumn relations.")
return target_fields[0]
def target_field(self):
"""
<<<<<<< HEAD
When filtering against this relation, returns the field on the remote
=======
When filtering against this relation, return the field on the remote
>>>>>>> 37c99181c9a6b95433d60f8c8ef9af5731096435
model against which the filtering should happen.
"""
target_fields = self.get_path_info()[-1].target_fields
if len(target_fields) > 1:
raise exceptions.FieldError("Can't use target_field for multicolumn relations.")
return target_fields[0]
def get_transform(self, name):
transform = super(TSVectorField, self).get_transform(name)
if transform:
return transform
try:
if name in map(lambda x: x[1],
self.model._meta.get_field(
self.dictionary).choices):
return DictionaryTransformFactory(name)
else:
raise exceptions.FieldError(
"The '%s' is not in %s choices" %
(name, self.model._meta.get_field(self.dictionary)))
except ValueError:
pass
def get_db_prep_lookup(self,
lookup_type,
value,
connection,
prepared=False):
if lookup_type not in self.valid_lookups:
raise exceptions.FieldError("'%s' isn't valid Lookup for %s" %
(lookup_type, self.__class__.__name__))
return [
self.get_db_prep_value(self._get_db_prep_lookup(
lookup_type, value),
connection=connection,
prepared=prepared)
]
def _do_checks(self):
assert not self.weights or (
len(self.weights) is 4
and all(map(lambda x: isinstance(x, (int, float)), self.weights))
), 'weights must be of length 4 and type float or integer'
assert not self.normalization or all(
map(lambda x: (isinstance(x, int) and x in self.NORMALIZATION),
self.normalization)), 'normalization must be in (%s)' % (
', '.join('%d' % i for i in self.NORMALIZATION))
assert len(self.extra) == 1, 'to many arguments for %s' % (
self.__class__.__name__)
if self.srt_lookup not in TSVectorBaseField.valid_lookups:
raise exceptions.FieldError(
"The '%s' isn't valid Lookup for %s" %
(self.srt_lookup, self.__class__.__name__))
def get_lookup_constraint(self, constraint_class, alias, targets, sources,
lookups, raw_value):
from django.db.models.sql.where import Constraint
assert len(targets) == len(sources)
if isinstance(lookups, basestring):
lookup_type = lookups
else:
if len(lookups) > 1:
raise exceptions.FieldError(
'UnixDateTimeField fields do not support nested lookups')
lookup_type = lookups[0]
if lookup_type == 'isnull' and self.zero_null and raw_value:
return (Constraint(alias, targets[0].column,
targets[0]), 'exact', None)
else:
return (Constraint(alias, targets[0].column,
self), lookup_type, raw_value)
def _get_lookup_constraint(self, constraint_class, alias, targets, sources,
lookups, raw_value):
from django.core import exceptions
from django.db.models.sql.where import AND
root_constraint = constraint_class()
# we need some checks from ForeignObject.get_lookup_constraint
# before we could check the lookups.
assert len(targets) == len(sources)
if len(lookups) > 1:
raise exceptions.FieldError('%s does not support nested lookups' %
self.__class__.__name__)
lookup_type = lookups[0]
target = targets[0]
source = sources[0]
# use custom Lookups when applicable
if lookup_type in ['isempty', 'overlap', 'contains']:
if lookup_type == 'isempty':
root_constraint.add(
IsEmptyLookup(target.get_col(alias, source), raw_value),
AND)
elif lookup_type == 'overlap':
root_constraint.add(
RelatedOverlapLookup(target.get_col(alias, source),
raw_value), AND)
elif lookup_type == 'contains':
root_constraint.add(
RelatedContainsLookup(target.get_col(alias, source),
raw_value), AND)
return root_constraint
elif lookup_type in ('in', 'exact', 'isnull'):
raise TypeError(
"%s doesn't allow exact, in or isnull. Use contains, overlap or isempty respectively"
% self.__class__.__name__)
return super(RelatedIteratorField,
self).get_lookup_constraint(constraint_class, alias,
targets, sources, lookups,
raw_value)
def vals_tuple(value: int):
if ActivityTypeEnum.is_viable_enum(value):
return ActivityTypeEnum.TYPES_DICT[value]
return exceptions.FieldError(
"type_val is not a viable ActivityTypeEnum value")
def q_from_condition(condition):
"""
Build a Lucene query from a filtering condition.
"""
q = None
field = condition.field
attname = field.attname
def escape_wilds(s):
return str(s).replace('*','\*').replace('?','\?')
if condition.operator is OPERATORS.EXACT:
q = Q(attname, field.to_neo_index(condition.value))
elif condition.operator is OPERATORS.STARTSWITH:
q = Q(attname, '%s*' % escape_wilds(condition.value), wildcard=True)
elif condition.operator is OPERATORS.CONTAINS:
q = Q(attname, '*%s*' % escape_wilds(condition.value), wildcard=True)
elif condition.operator is OPERATORS.MEMBER:
q = Q(attname, field.member_to_neo_index(condition.value))
elif condition.operator is OPERATORS.IN:
q = reduce(or_, (Q(attname, field.to_neo_index(v)) for v in condition.value))
elif condition.operator is OPERATORS.MEMBER_IN:
q = reduce(or_, (Q(attname, field.member_to_neo_index(v)) for v in condition.value))
#FIXME OBOE with field.MAX + exrange, not sure it's easy to fix though...
elif condition.operator in (OPERATORS.GT, OPERATORS.GTE, OPERATORS.LT,
OPERATORS.LTE, OPERATORS.RANGE):
if not field.indexed_range:
raise exceptions.FieldError(
'The {0} property is not configured for range '
'indexing.'.format(field.attname))
fieldtype = field._property_type()
if condition.operator in (OPERATORS.GT, OPERATORS.GTE):
if not hasattr(field, 'MAX'):
raise exceptions.FieldError(
'The {0} property is not configured for gt/gte '
'queries.'.format(field.attname))
if condition.operator is OPERATORS.GT:
q = Q(attname, exrange=(field.to_neo_index(condition.value),
field.to_neo_index(fieldtype.MAX)))
else:
q = Q(attname, inrange=(field.to_neo_index(condition.value),
field.to_neo_index(fieldtype.MAX)))
elif condition.operator in (OPERATORS.LT, OPERATORS.LTE):
if not hasattr(fieldtype, 'MIN'):
raise exceptions.FieldError(
'The {0} property is not configured for lt/lte '
'queries.'.format(field.attname))
if condition.operator is OPERATORS.LT:
q = Q(attname, exrange=(field.to_neo_index(fieldtype.MIN),
field.to_neo_index(condition.value)))
else:
q = Q(attname, inrange=(field.to_neo_index(fieldtype.MIN),
field.to_neo_index(condition.value)))
elif condition.operator is OPERATORS.RANGE:
if len(condition.value) != 2:
raise exceptions.ValidationError('Range queries need upper and'
' lower bounds.')
q = Q(condition.field.attname,
inrange=[condition.field.to_neo_index(v)
for v in condition.value])
else:
return None
if condition.negate:
q = ~q
return q
