230 lines
5.9 KiB
Markdown
230 lines
5.9 KiB
Markdown
<a name="queryset.clause"></a>
|
|
# queryset.clause
|
|
|
|
<a name="queryset.clause.FilterGroup"></a>
|
|
## FilterGroup Objects
|
|
|
|
```python
|
|
class FilterGroup()
|
|
```
|
|
|
|
Filter groups are used in complex queries condition to group and and or
|
|
clauses in where condition
|
|
|
|
<a name="queryset.clause.FilterGroup.resolve"></a>
|
|
#### resolve
|
|
|
|
```python
|
|
| resolve(model_cls: Type["Model"], select_related: List = None, filter_clauses: List = None) -> Tuple[List[FilterAction], List[str]]
|
|
```
|
|
|
|
Resolves the FilterGroups actions to use proper target model, replace
|
|
complex relation prefixes if needed and nested groups also resolved.
|
|
|
|
**Arguments**:
|
|
|
|
- `model_cls` (`Type["Model"]`): model from which the query is run
|
|
- `select_related` (`List[str]`): list of models to join
|
|
- `filter_clauses` (`List[FilterAction]`): list of filter conditions
|
|
|
|
**Returns**:
|
|
|
|
`Tuple[List[FilterAction], List[str]]`: list of filter conditions and select_related list
|
|
|
|
<a name="queryset.clause.FilterGroup._iter"></a>
|
|
#### \_iter
|
|
|
|
```python
|
|
| _iter() -> Generator
|
|
```
|
|
|
|
Iterates all actions in a tree
|
|
|
|
**Returns**:
|
|
|
|
`Generator`: generator yielding from own actions and nested groups
|
|
|
|
<a name="queryset.clause.FilterGroup._get_text_clauses"></a>
|
|
#### \_get\_text\_clauses
|
|
|
|
```python
|
|
| _get_text_clauses() -> List[sqlalchemy.sql.expression.TextClause]
|
|
```
|
|
|
|
Helper to return list of text queries from actions and nested groups
|
|
|
|
**Returns**:
|
|
|
|
`List[sqlalchemy.sql.elements.TextClause]`: list of text queries from actions and nested groups
|
|
|
|
<a name="queryset.clause.FilterGroup.get_text_clause"></a>
|
|
#### get\_text\_clause
|
|
|
|
```python
|
|
| get_text_clause() -> sqlalchemy.sql.expression.TextClause
|
|
```
|
|
|
|
Returns all own actions and nested groups conditions compiled and joined
|
|
inside parentheses.
|
|
Escapes characters if it's required.
|
|
Substitutes values of the models if value is a ormar Model with its pk value.
|
|
Compiles the clause.
|
|
|
|
**Returns**:
|
|
|
|
`sqlalchemy.sql.elements.TextClause`: complied and escaped clause
|
|
|
|
<a name="queryset.clause.or_"></a>
|
|
#### or\_
|
|
|
|
```python
|
|
or_(*args: FilterGroup, **kwargs: Any) -> FilterGroup
|
|
```
|
|
|
|
Construct or filter from nested groups and keyword arguments
|
|
|
|
**Arguments**:
|
|
|
|
- `args` (`Tuple[FilterGroup]`): nested filter groups
|
|
- `kwargs` (`Any`): fields names and proper value types
|
|
|
|
**Returns**:
|
|
|
|
`ormar.queryset.clause.FilterGroup`: FilterGroup ready to be resolved
|
|
|
|
<a name="queryset.clause.and_"></a>
|
|
#### and\_
|
|
|
|
```python
|
|
and_(*args: FilterGroup, **kwargs: Any) -> FilterGroup
|
|
```
|
|
|
|
Construct and filter from nested groups and keyword arguments
|
|
|
|
**Arguments**:
|
|
|
|
- `args` (`Tuple[FilterGroup]`): nested filter groups
|
|
- `kwargs` (`Any`): fields names and proper value types
|
|
|
|
**Returns**:
|
|
|
|
`ormar.queryset.clause.FilterGroup`: FilterGroup ready to be resolved
|
|
|
|
<a name="queryset.clause.QueryClause"></a>
|
|
## QueryClause Objects
|
|
|
|
```python
|
|
class QueryClause()
|
|
```
|
|
|
|
Constructs FilterActions from strings passed as arguments
|
|
|
|
<a name="queryset.clause.QueryClause.prepare_filter"></a>
|
|
#### prepare\_filter
|
|
|
|
```python
|
|
| prepare_filter(_own_only: bool = False, **kwargs: Any) -> Tuple[List[FilterAction], List[str]]
|
|
```
|
|
|
|
Main external access point that processes the clauses into sqlalchemy text
|
|
clauses and updates select_related list with implicit related tables
|
|
mentioned in select_related strings but not included in select_related.
|
|
|
|
**Arguments**:
|
|
|
|
- `_own_only`:
|
|
- `kwargs` (`Any`): key, value pair with column names and values
|
|
|
|
**Returns**:
|
|
|
|
`Tuple[List[sqlalchemy.sql.elements.TextClause], List[str]]`: Tuple with list of where clauses and updated select_related list
|
|
|
|
<a name="queryset.clause.QueryClause._populate_filter_clauses"></a>
|
|
#### \_populate\_filter\_clauses
|
|
|
|
```python
|
|
| _populate_filter_clauses(_own_only: bool, **kwargs: Any) -> Tuple[List[FilterAction], List[str]]
|
|
```
|
|
|
|
Iterates all clauses and extracts used operator and field from related
|
|
models if needed. Based on the chain of related names the target table
|
|
is determined and the final clause is escaped if needed and compiled.
|
|
|
|
**Arguments**:
|
|
|
|
- `kwargs` (`Any`): key, value pair with column names and values
|
|
|
|
**Returns**:
|
|
|
|
`Tuple[List[sqlalchemy.sql.elements.TextClause], List[str]]`: Tuple with list of where clauses and updated select_related list
|
|
|
|
<a name="queryset.clause.QueryClause._register_complex_duplicates"></a>
|
|
#### \_register\_complex\_duplicates
|
|
|
|
```python
|
|
| _register_complex_duplicates(select_related: List[str]) -> None
|
|
```
|
|
|
|
Checks if duplicate aliases are presented which can happen in self relation
|
|
or when two joins end with the same pair of models.
|
|
|
|
If there are duplicates, the all duplicated joins are registered as source
|
|
model and whole relation key (not just last relation name).
|
|
|
|
**Arguments**:
|
|
|
|
- `select_related` (`List[str]`): list of relation strings
|
|
|
|
**Returns**:
|
|
|
|
`None`: None
|
|
|
|
<a name="queryset.clause.QueryClause._parse_related_prefixes"></a>
|
|
#### \_parse\_related\_prefixes
|
|
|
|
```python
|
|
| _parse_related_prefixes(select_related: List[str]) -> List[Prefix]
|
|
```
|
|
|
|
Walks all relation strings and parses the target models and prefixes.
|
|
|
|
**Arguments**:
|
|
|
|
- `select_related` (`List[str]`): list of relation strings
|
|
|
|
**Returns**:
|
|
|
|
`List[Prefix]`: list of parsed prefixes
|
|
|
|
<a name="queryset.clause.QueryClause._switch_filter_action_prefixes"></a>
|
|
#### \_switch\_filter\_action\_prefixes
|
|
|
|
```python
|
|
| _switch_filter_action_prefixes(filter_clauses: List[FilterAction]) -> List[FilterAction]
|
|
```
|
|
|
|
Substitutes aliases for filter action if the complex key (whole relation str) is
|
|
present in alias_manager.
|
|
|
|
**Arguments**:
|
|
|
|
- `filter_clauses` (`List[FilterAction]`): raw list of actions
|
|
|
|
**Returns**:
|
|
|
|
`List[FilterAction]`: list of actions with aliases changed if needed
|
|
|
|
<a name="queryset.clause.QueryClause._verify_prefix_and_switch"></a>
|
|
#### \_verify\_prefix\_and\_switch
|
|
|
|
```python
|
|
| _verify_prefix_and_switch(action: "FilterAction") -> None
|
|
```
|
|
|
|
Helper to switch prefix to complex relation one if required
|
|
|
|
**Arguments**:
|
|
|
|
- `action` (`ormar.queryset.actions.filter_action.FilterAction`): action to switch prefix in
|
|
|