def __init__(self, xml_target, xpath_expr, new_xml):
if not hasattr(xpath_expr, 'resolve_expression'):
xpath_expr = Value(xpath_expr)
if not hasattr(new_xml, 'resolve_expression'):
new_xml = Value(new_xml)
return super(UpdateXML, self).__init__(xml_target, xpath_expr, new_xml,
output_field=TextField())
def __init__(self, expression, regex, replace):
if not hasattr(regex, 'resolve_expression'):
regex = Value(regex)
if not hasattr(replace, 'resolve_expression'):
replace = Value(replace)
super(RegexpReplace, self).__init__(expression, regex, replace,
output_field=CharField())
def test_if_basic(self):
Alphabet.objects.create(d='String')
Alphabet.objects.create(d='')
Alphabet.objects.create(d='String')
Alphabet.objects.create(d='')
results = list(
Alphabet.objects.annotate(has_d=If(Length('d'), Value(
True), Value(False))).order_by('id').values_list('has_d',
flat=True))
assert results == [True, False, True, False]
def __init__(self, expression, hash_len=512):
if hash_len not in self.hash_lens:
raise ValueError(
"hash_len must be one of {}"
.format(",".join(str(x) for x in self.hash_lens))
)
super(SHA2, self).__init__(expression, Value(hash_len))
def __init__(self, xml_frag, xpath_expr):
if not hasattr(xpath_expr, 'resolve_expression'):
xpath_expr = Value(xpath_expr)
return super(XMLExtractValue, self).__init__(xml_frag,
xpath_expr,
output_field=TextField())
def __init__(self, expression, regex):
if not hasattr(regex, 'resolve_expression'):
regex = Value(regex)
super(RegexpSubstr, self).__init__(expression,
regex,
output_field=CharField())
def __init__(self, field, values, **kwargs):
values_exprs = []
for v in values:
if not hasattr(v, 'resolve_expression'):
v = Value(v)
values_exprs.append(v)
super(Field, self).__init__(field, *values_exprs)
def __init__(self, num, expressions):
value_exprs = []
for v in expressions:
if not hasattr(v, 'resolve_expression'):
v = Value(v)
value_exprs.append(v)
super(ELT, self).__init__(num, *value_exprs, output_field=CharField())
def __init__(self, expression, data_type):
if not hasattr(expression, 'resolve_expression'):
expression = Value(expression)
if data_type not in self.TYPE_MAP:
raise ValueError("Invalid data_type '{}'".format(data_type))
super(AsType, self).__init__(expression, data_type=data_type)
def test_if_false_default_None(self):
Alphabet.objects.create(a=1)
result = list(
Alphabet.objects.annotate(conditional=If(Q(a=2), Value(1))).filter(
conditional__isnull=True).values_list('conditional',
flat=True))
assert result == [None]
def __init__(self, expression, to_add):
from django_mysql.models.fields import DynamicField
expressions = [expression]
for name, value in to_add.items():
if not hasattr(name, 'resolve_expression'):
name = Value(name)
if isinstance(value, dict):
raise ValueError(
"ColumnAdd with nested values is not supported")
if not hasattr(value, 'resolve_expression'):
value = Value(value)
expressions.extend((name, value))
super(ColumnAdd, self).__init__(*expressions,
output_field=DynamicField())
def __init__(self, expression, *paths):
from django_mysql.models.fields import JSONField
exprs = [expression]
for path in paths:
if not hasattr(path, 'resolve_expression'):
path = Value(path)
exprs.append(path)
super(JSONExtract, self).__init__(*exprs, output_field=JSONField())
def __init__(self, expression, path=None):
from django_mysql.models.fields import JSONField
exprs = [expression]
if path is not None:
if not hasattr(path, 'resolve_expression'):
path = Value(path)
exprs.append(path)
super(JSONKeys, self).__init__(*exprs, output_field=JSONField())
def __init__(self, expression, path=None, **extra):
output_field = extra.pop('output_field', IntegerField())
exprs = [expression]
if path is not None:
if not hasattr(path, 'resolve_expression'):
path = Value(path)
exprs.append(path)
super(JSONLength, self).__init__(*exprs, output_field=output_field)
def __init__(self, expression, *to_delete):
from django_mysql.models.fields import DynamicField
expressions = [expression]
for name in to_delete:
if not hasattr(name, 'resolve_expression'):
name = Value(name)
expressions.append(name)
super(ColumnDelete, self).__init__(*expressions,
output_field=DynamicField())
def test_if_field_lookups_work(self):
Alphabet.objects.create(a=1, d='Lentils')
Alphabet.objects.create(a=2, d='Cabbage')
Alphabet.objects.create(a=3, d='Rice')
result = list(
Alphabet.objects.annotate(conditional=If(Q(
a__gte=2), Upper('d'), Value(''))).filter(
conditional__startswith='C').order_by('id').values_list(
'conditional', flat=True))
assert result == ['CABBAGE']
def __init__(self, *expressions, **kwargs):
separator = kwargs.pop('separator', ',')
if len(kwargs) > 0:
raise ValueError("Invalid keyword arguments for ConcatWS: {}"
.format(",".join(kwargs.keys())))
if len(expressions) < 2:
raise ValueError('ConcatWS must take at least two expressions')
if not hasattr(separator, 'resolve_expression'):
separator = Value(separator)
# N.B. if separator is "," we could potentially use list field
output_field = TextField()
super(ConcatWS, self).__init__(separator, *expressions,
output_field=output_field)
def __init__(self, expression, column_name, data_type):
if not hasattr(column_name, 'resolve_expression'):
column_name = Value(column_name)
try:
output_field = self.TYPE_MAP[data_type]
except KeyError:
raise ValueError("Invalid data_type '{}'".format(data_type))
if data_type == 'BINARY':
output_field = output_field() # no spec
else:
output_field = output_field
super(ColumnGet, self).__init__(expression, column_name,
output_field=output_field,
data_type=data_type)
def appendleft(self, value):
if not hasattr(value, 'as_sql'):
value = Value(value)
return AppendLeftListF(self.field, value)
def remove(self, value):
if not hasattr(value, 'as_sql'):
value = Value(value)
return RemoveSetF(self.field, value)
def add(self, value):
if not hasattr(value, 'as_sql'):
value = Value(value)
return AddSetF(self.field, value)
def test_delete_subfunc(self):
say_sub = ConcatWS(Value('s'), Value('ub'), separator='')
DynamicModel.objects.update(attrs=ColumnDelete('attrs', say_sub))
m = DynamicModel.objects.get()
assert m.attrs == {'flote': 1.0}
