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) 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 primary_operation = operator.split("__")[0] special_indexer = REQUIRES_SPECIAL_INDEXES.get(primary_operation) 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, primary_operation, 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
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 primary_operation = operator.split("__")[0] special_indexer = REQUIRES_SPECIAL_INDEXES.get(primary_operation) 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, primary_operation, 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
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) 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 primary_operation = operator.split("__")[0] special_indexer = REQUIRES_SPECIAL_INDEXES.get(primary_operation) 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, primary_operation, 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
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 primary_operation = operator.split("__")[0] special_indexer = REQUIRES_SPECIAL_INDEXES.get(primary_operation) 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, primary_operation, 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