def set_leaf(self, column, operator, value, is_pk_field, negated, namespace, target_field=None): assert column assert operator assert isinstance(is_pk_field, bool) assert isinstance(negated, bool) if operator == "iexact" and isinstance(target_field, AutoField): # When new instance is created, automatic primary key 'id' does not generate '_idx_iexact_id'. # As the primary key 'id' (AutoField) is integer and is always case insensitive, # we can deal with 'id_iexact=' query by using 'exact' rather than 'iexact'. operator = "exact" value = int(value) if is_pk_field: # If this is a primary key, we need to make sure that the value # we pass to the query is a datastore Key. We have to deal with IN queries here # because they aren't flattened until the DNF stage model = get_top_concrete_parent(target_field.model) table = model._meta.db_table if isinstance(value, (list, tuple)): value = [ datastore.Key.from_path(table, x, namespace=namespace) for x in value if x ] else: if operator == "isnull" and value is True: # FIXME: Strictly, this isn't correct, this could be one of several branches # but id=None filters are silly anyway. This should be moved to after normalization.. # probably. This fixes a test in Django which does this in get_or_create for some reason raise EmptyResultSet() if not value: # Empty strings and 0 are forbidden as keys # so make this an impossible filter # FIXME: This is a hack! It screws with the ordering # because it's an inequality. Instead we should wipe this # filter out when preprocessing in the DNF (because it's impossible) value = datastore.Key.from_path('', 1) operator = '<' else: value = datastore.Key.from_path(table, value, namespace=namespace) column = "__key__" # Do any special index conversions necessary to perform this lookup if operator in REQUIRES_SPECIAL_INDEXES: if is_pk_field: column = model._meta.pk.column value = unicode(value.id_or_name()) add_special_index(target_field.model, column, operator, value) indexer = REQUIRES_SPECIAL_INDEXES[operator] index_type = indexer.prepare_index_type(operator, value) value = indexer.prep_value_for_query(value) column = indexer.indexed_column_name(column, value, index_type) operator = indexer.prep_query_operator(operator) self.column = column self.operator = convert_operator(operator) self.value = value
def set_leaf(self, column, operator, value, is_pk_field, negated, target_field=None): assert column assert operator assert isinstance(is_pk_field, bool) assert isinstance(negated, bool) if operator == "iexact" and isinstance(target_field, AutoField): # When new instance is created, automatic primary key 'id' does not generate '_idx_iexact_id'. # As the primary key 'id' (AutoField) is integer and is always case insensitive, # we can deal with 'id_iexact=' query by using 'exact' rather than 'iexact'. operator = "exact" value = int(value) if is_pk_field: # If this is a primary key, we need to make sure that the value # we pass to the query is a datastore Key. We have to deal with IN queries here # because they aren't flattened until the DNF stage model = get_top_concrete_parent(target_field.model) table = model._meta.db_table if isinstance(value, (list, tuple)): value = [ datastore.Key.from_path(table, x) for x in value if x ] else: if operator == "isnull" and value is True: # FIXME: Strictly, this isn't correct, this could be one of several branches # but id=None filters are silly anyway. This should be moved to after normalization.. # probably. This fixes a test in Django which does this in get_or_create for some reason raise EmptyResultSet() if not value: # Empty strings and 0 are forbidden as keys # so make this an impossible filter # FIXME: This is a hack! It screws with the ordering # because it's an inequality. Instead we should wipe this # filter out when preprocessing in the DNF (because it's impossible) value = datastore.Key.from_path('', 1) operator = '<' else: value = datastore.Key.from_path(table, value) column = "__key__" # Do any special index conversions necessary to perform this lookup if operator in REQUIRES_SPECIAL_INDEXES: add_special_index(target_field.model, column, operator, value) indexer = REQUIRES_SPECIAL_INDEXES[operator] index_type = indexer.prepare_index_type(operator, value) value = indexer.prep_value_for_query(value) if not indexer.validate_can_be_indexed(value, negated): raise NotSupportedError("Unsupported special index or value '%s %s'" % (column, operator)) column = indexer.indexed_column_name(column, value, index_type) operator = indexer.prep_query_operator(operator) self.column = column self.operator = convert_operator(operator) self.value = value
def set_leaf(self, column, operator, value, is_pk_field, negated, lookup_name, namespace, target_field=None): assert column assert operator assert isinstance(is_pk_field, bool) assert isinstance(negated, bool) if operator == "iexact" and isinstance(target_field, AutoField): # When new instance is created, automatic primary key 'id' does not generate '_idx_iexact_id'. # As the primary key 'id' (AutoField) is integer and is always case insensitive, # we can deal with 'id_iexact=' query by using 'exact' rather than 'iexact'. operator = "exact" value = int(value) if is_pk_field: # If this is a primary key, we need to make sure that the value # we pass to the query is a datastore Key. We have to deal with IN queries here # because they aren't flattened until the DNF stage model = get_top_concrete_parent(target_field.model) table = model._meta.db_table if isinstance(value, (list, tuple)): value = [ datastore.Key.from_path(table, x, namespace=namespace) for x in value if x ] else: if (operator == "isnull" and value is True) or not value: # id=None will never return anything and # Empty strings and 0 are forbidden as keys self.will_never_return_results = True else: value = datastore.Key.from_path(table, value, namespace=namespace) column = "__key__" # Do any special index conversions necessary to perform this lookup special_indexer = get_indexer(target_field, operator) if special_indexer: if is_pk_field: column = model._meta.pk.column value = unicode(value.id_or_name()) add_special_index(target_field.model, column, special_indexer, operator, value) index_type = special_indexer.prepare_index_type(operator, value) value = special_indexer.prep_value_for_query(value) column = special_indexer.indexed_column_name(column, value, index_type) operator = special_indexer.prep_query_operator(operator) self.column = column self.operator = convert_operator(operator) self.value = value self.lookup_name = lookup_name
def set_leaf(self, column, operator, value, is_pk_field, negated, lookup_name, namespace, target_field=None): assert column assert operator assert isinstance(is_pk_field, bool) assert isinstance(negated, bool) if operator == "iexact" and isinstance(target_field, AutoField): # When new instance is created, automatic primary key 'id' # does not generate '_idx_iexact_id'. # As the primary key 'id' (AutoField) is integer and is always case insensitive, # we can deal with 'id_iexact=' query by using 'exact' rather than 'iexact'. operator = "exact" value = int(value) if is_pk_field: # If this is a primary key, we need to make sure that the value # we pass to the query is a datastore Key. We have to deal with IN queries here # because they aren't flattened until the DNF stage model = get_top_concrete_parent(target_field.model) table = model._meta.db_table if isinstance(value, (list, tuple)): value = [ rpc.Key.from_path(table, x, namespace=namespace) for x in value if x ] else: # Django 1.11 has operators as symbols, earlier versions use "exact" etc. if (operator == "isnull" and value is True) or ( operator in ("exact", "lt", "lte", "<", "<=", "=") and not value): # id=None will never return anything and # Empty strings and 0 are forbidden as keys self.will_never_return_results = True elif operator in ("gt", "gte", ">", ">=") and not value: # If the value is 0 or "", then we need to manipulate the value and operator here to # get the right result (given that both are invalid keys) so for both we return # >= 1 or >= "\0" for strings if isinstance(value, six.integer_types): value = 1 else: value = "\0" value = rpc.Key.from_path(table, value, namespace=namespace) operator = "gte" else: value = rpc.Key.from_path(table, value, namespace=namespace) column = "__key__" # Do any special index conversions necessary to perform this lookup special_indexer = get_indexer(target_field, operator) if special_indexer: if is_pk_field: column = model._meta.pk.column value = unicode(value.id_or_name()) add_special_index(target_field.model, column, special_indexer, operator, value) index_type = special_indexer.prepare_index_type(operator, value) value = special_indexer.prep_value_for_query( value, model=target_field.model, column=column, connection=connections[self.using]) column = special_indexer.indexed_column_name( column, value, index_type) operator = special_indexer.prep_query_operator(operator) self.column = column self.operator = convert_operator(operator) self.value = value self.lookup_name = lookup_name
def set_leaf( self, column, operator, value, is_pk_field, negated, lookup_name, namespace, target_field=None): assert column assert operator assert isinstance(is_pk_field, bool) assert isinstance(negated, bool) if operator == "iexact" and isinstance(target_field, AutoField): # When new instance is created, automatic primary key 'id' # does not generate '_idx_iexact_id'. # As the primary key 'id' (AutoField) is integer and is always case insensitive, # we can deal with 'id_iexact=' query by using 'exact' rather than 'iexact'. operator = "exact" value = int(value) if is_pk_field: # If this is a primary key, we need to make sure that the value # we pass to the query is a datastore Key. We have to deal with IN queries here # because they aren't flattened until the DNF stage model = get_top_concrete_parent(target_field.model) table = model._meta.db_table if isinstance(value, (list, tuple)): value = [ rpc.Key.from_path(table, x, namespace=namespace) for x in value if x ] else: # Django 1.11 has operators as symbols, earlier versions use "exact" etc. if (operator == "isnull" and value is True) or (operator in ("exact", "lt", "lte", "<", "<=", "=") and not value): # id=None will never return anything and # Empty strings and 0 are forbidden as keys self.will_never_return_results = True elif operator in ("gt", "gte", ">", ">=") and not value: # If the value is 0 or "", then we need to manipulate the value and operator here to # get the right result (given that both are invalid keys) so for both we return # >= 1 or >= "\0" for strings if isinstance(value, six.integer_types): value = 1 else: value = "\0" value = rpc.Key.from_path(table, value, namespace=namespace) operator = "gte" else: value = rpc.Key.from_path(table, value, namespace=namespace) column = "__key__" # Do any special index conversions necessary to perform this lookup special_indexer = get_indexer(target_field, operator) if special_indexer: if is_pk_field: column = model._meta.pk.column value = unicode(value.id_or_name()) add_special_index(target_field.model, column, special_indexer, operator, value) index_type = special_indexer.prepare_index_type(operator, value) value = special_indexer.prep_value_for_query( value, model=target_field.model, column=column, connection=connections[self.using] ) column = special_indexer.indexed_column_name(column, value, index_type) operator = special_indexer.prep_query_operator(operator) self.column = column self.operator = convert_operator(operator) self.value = value self.lookup_name = lookup_name