def create_query(self, parent_context: Optional[QueryContext]) -> QueryBuilder: query = self.query_builder(parent_context.alias if parent_context else None) context = QueryContext(query, parent_context) context.push(self.model, query._from[-1]) self._add_query_details(context=context) context.query._delete_from = True context.pop() return context.query
def _resolve_filter(self, queryset: "AwaitableStatement[MODEL]", context: QueryContext, key, value) -> QueryClauses: context_item = context.top model = context_item.model table = context_item.table if value is None and "isnull" in model._meta.db.filter_class.FILTER_FUNC_MAP: value = True key = f"{key}{LOOKUP_SEP}isnull" relation_field_name, _, field_sub = key.partition(LOOKUP_SEP) if self._check_annotations and relation_field_name in queryset.annotations: (filter_operator, _) = model._meta.db.filter_class.FILTER_FUNC_MAP[field_sub] annotation = queryset.annotations[relation_field_name] if annotation.field.is_aggregate: return QueryClauses(having_criterion=filter_operator(annotation.field, value)) else: return QueryClauses(where_criterion=filter_operator(annotation.field, value)) field_object = model._meta.fields_map.get(relation_field_name) if not field_object: raise UnknownFieldError(relation_field_name, model) key_filter = model._meta.get_filter(key) if key_filter: if isinstance(field_object, RelationField): join_data = context.join_table_by_field(table, field_object, full=False) if join_data: # # We are potentially adding two None here into the context # however, since we have a valid key_filter it means no sub_field # and hence to inner tables and no context is necessary, except # for the correct position of the stack levels, # context.push(join_data.model, join_data.table) clauses = QueryClauses(where_criterion=key_filter(context, value)) context.pop() else: clauses = QueryClauses(where_criterion=key_filter(context, value)) return clauses else: return QueryClauses(where_criterion=key_filter(context, value)) if isinstance(field_object, RelationField): join_data = context.join_table_by_field(table, field_object) context.push(join_data.model, join_data.table) q = Q(**{field_sub: value}) q._check_annotations = False modifier = q._resolve(queryset=queryset, context=context) context.pop() return modifier raise BaseFieldError(key, model)
def create_query_context(self, parent_context: Optional[QueryContext]) -> QueryContext: query = self.query_builder(parent_context.alias if parent_context else None)\ .select(*self.model._meta.db_columns) context = QueryContext(query, parent_context) context.push(self.model, query._from[-1]) context.resolve_select_related(self._select_related) context.pop() return context
def create_query(self, parent_context: QueryContext) -> QueryBuilder: query = self.query_builder( parent_context.alias if parent_context else None) context = QueryContext(query, parent_context) context.push(self.model, query._from[-1]) self._add_query_details(context=context) for return_as, field_name in self.fields_for_select.items(): _, field = context.resolve_field_name(field_name, self, accept_relation=False) context.query._select_other(field.as_(return_as)) context.pop() return context.query
def create_query(self, parent_context: Optional[QueryContext]) -> QueryBuilder: db_client = self._get_db_client() table = self.model._meta.table(parent_context.alias if parent_context else None) context = QueryContext(query=db_client.query_class.update(table), parent_context=parent_context) context.push(self.model, table) self._add_query_details(context=context) for field_name, value in self.update_kwargs.items(): field_object = self.model._meta.fields_map.get(field_name) if not field_object: raise UnknownFieldError(field_name, self.model) if field_object.primary_key: raise IntegrityError(f"Field {field_name} is primary key and can not be updated") if isinstance(field_object, RelationField): if isinstance(field_object, (ForeignKey, OneToOneField)): fk_field_name: str = field_object.id_field_name fk_field_object = self.model._meta.fields_map[fk_field_name] value = fk_field_object.db_value(value.pk, None) context.query = context.query.set(fk_field_object.db_column, value) else: raise NotADbColumnFieldError(field_name, self.model) else: if isinstance(value, Term): value = TermAnnotation(value) value.resolve_into(self, context) value = value.field elif isinstance(value, Annotation): value.resolve_into(self, context) value = value.field else: value = field_object.db_value(value, None) context.query = context.query.set(field_object.db_column, value) context.pop() return context.query