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}