Retour aux données originales

La méthode suivante vous permet d'exécuter une requête, mais au lieu de renvoyer un modèle ormar, elle renvoie un dictionnaire ou une liste de tuples.

• values(fields = None, exclude_through = False) -> List[Dict]

• values_list(fields = None, exclude_through = False, flatten = False) -> List

• Query Set Agent pour

  • QuerysetProxy.values(fields = None, exclude_through = False) Méthode
  • QuerysetProxy.values_list(fields = None, exclude_through= False, flatten = False) Méthode

!!!danger Notez que les valeurs et les valeurs_list ignorent l'analyse des résultats dans le modèle ormar et donc la validation des résultats!

!!!Attention Notez que chaque entrée dans la liste des résultats est une réflexion un-à-un de la ligne de résultat de la requête. puisque les lignes ne sont pas analysées si vous avez une relation un-à-plusieurs ou plusieurs-à-plusieurs, les valeurs de colonne dupliquées apparaissent dans l'entrée de résultat si une ligne parente a plusieurs lignes associées.

Les valeurs

values(fields: Union[List, str, Set, Dict] = None, exclude_through: bool = False) -> List[Dict]

Renvoie une liste de dictionnaires représentant les valeurs des colonnes de la base de données.

Vous pouvez utiliser le paramètre fields pour sélectionner un sous-ensemble de champs qui accepte le même ensemble d'arguments que la méthode fields().

Notez que passer un champ à values(fields) est en fait un raccourci pour appeler fields(fields).values.

!!!Conseil Pour en savoir plus sur ce que vous pouvez passer à un champ et comment sélectionner un champ de modèle imbriqué, lisez la documentation sur la colonne de sélection

Vous pouvez limiter le nombre de lignes en fournissant des critères dans filter() et except(), mais notez que même si une seule ligne (ou aucune!) correspond à vos critères, vous retournerez une liste en réponse.

Exemples:

#Modèles déclarés

Catégorie de classe (modèle ormar):
    ormar_config = base_ormar_config.copy(tablename="catégories")

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=40)
    sort_order: int = ormar.Integer(nullable=True)


Classe Post(modèle ormar):
    ormar_config = base_ormar_config.copy()

    id: int = ormar.Integer(primary_key=True)
    nom: str = ormar.String(max_length=200)
    Catégorie: Optional[Catégorie] = ormar.ForeignKey(Catégorie)

# sample de données
news = await Category(name="News", sort_order=0).save()
await Post(nom ="Ormar strikes again!", catégorie =news).save()
await Post(name="Why don't you use ormar yet?", category=news).save()
await Post(name="Check this out, ormar now for free", category=news).save()

Accès au modèle postal:

posts = await Post.objects.values()
assert posts == [
    {"id": 1, "name": "Ormar strikes again!", "category": 1},
    {"id": 2, "name": "Why don't you use ormar yet?", "category": 1},
    {"id": 3, "name": "Check this out, ormar now for free", "category": 1},
]

Pour sélectionner les modèles pertinents, utilisez select_lated ou prefetch_lated.

Remarquez comment les colonnes de modèle imbriquées sont préfixées depuis le chemin relationnel complet du modèle autonome (celui utilisé dans la requête).

#modèles de déclaration

Classe Utilisateur (modèle ormar):
    ormar_config = base_ormar_config.copy()

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)


Classe Role(modèle ormar):
    ormar_config = base_ormar_config.copy()

    id: int = ormar.Integer(primary_key=True)
    nom: str = ormar.String(max_length=100)
    users: List[User] = ormar.ManyToMany(User)

# sample de données
creator = await User(name="Anonymous").save()
admin = await Role(name="admin").save()
editor = await Role(name="editor").save()
await creator.roles.add(admin)
await creator.roles.add(éditeur)

Sélectionnez un utilisateur avec un rôle

user = await User.objects.select_related("roles").values()
# note nested préfixes: roleuser et roles
assert user == [
    {
        "id": 1,
        "Nom": "Anonyme",
        roleuser__id: 1,
        roleuser__role: 1,
        roleuser__user: 1,
        "roles__id": 1,
        "roles__name": "admin",
    },
    {
        "id": 1,
        "Nom": "Anonyme",
        roleuser__id: 2,
        roleuser__role: 2,
        roleuser__user: 1,
        "roles__id": 2,
        "roles__name": "éditeur",
    },
]

!!!Remarque Notez que la relation entre le rôle et l'utilisateur est plusieurs à plusieurs, vous pouvez donc également obtenir des colonnes de modèle par défaut.

Combinez les champs pertinents et les champs pour sélectionner seulement 3 champs.

Notez que nous excluons également les définitions par modèle, car par définition, chaque modèle inclus dans la connexion, mais sans aucune référence dans le champ, est supposé être entièrement sélectionné (tous les champs inclus).

!!!Notez que, contrairement aux autres méthodes d'ensemble de requêtes ici, vous pouvez exclure les modèles intermédiaires mais conserver les colonnes de fin, ce qui n'a aucun sens lorsque vous analysez les données brutes dans un modèle.

Donc dans la catégorie relation-> catégorie_x_post -> post -> utilisateur, vous pouvez exclure
category_x_post and post models but can keep the user one. (dans le modèle d'ordre)
contexte qui n'est pas possible comme si vous vouliez exclude le modèle through and post
Il n'y aurait aucun moyen de récupérer le modèle utilisateur du modèle de catégorie).


user = (
        await Role.objects.select_related("users__categories")
        .filter(nom ="admin")
        .fields({"nom": ..., "utilisateurs": {"nom": ..., "catégories":{"name"}})
        .exclude_fields("roleuser")
        . valeurs ()
    )
assert user == [
    {
        "name": "admin",
        "users__name": "Anonyme",
        "users__categories__name": "News",
    }
]

Si vous avez plusieurs modèles ManyToMany dans votre requête, vous devez exclure manuellement chaque modèle.

Pour éviter ce fardeau, ormar vous fournit le paramètre except_through=False. Si vous définissez cet indicateur sur True, tous les modèles sont complètement exclus.

# equivalent to query Above, note lack of exclude_fields call
user = (
    await Role.objects.select_related("users__categories")
    .filter(nom ="admin")
    .fields({"name": ..., "users": {"name": ..., "categories":{"name"}})
    .values(exclude_through=True)
)
assert user == [
    {
        "name": "admin",
        "users__name": "Anonyme",
        "users__categories__name": "News",
    }
]

Liste des valeurs

values_list(fields: Union[List, str, Set, Dict] = None, flatten: bool = False, exclude_through: bool = False) -> List

Renvoie une liste de tuples représentant les valeurs des colonnes de la base de données.

Vous pouvez utiliser le paramètre fields pour sélectionner un sous-ensemble de champs qui accepte le même ensemble d'arguments que la méthode fields().

Notez que passer un champ à values_list(fields) est en fait un raccourci pour appeler fields(fields).values_list().

!!!Conseil Pour en savoir plus sur ce que vous pouvez passer à un champ et comment sélectionner un champ de modèle imbriqué, lisez la documentation sur la colonne de sélection

Si vous ne sélectionnez qu 'une seule colonne/champ, vous pouvez passer flatten=True, ce qui renverra une liste de valeurs au lieu d'une liste de tuples d'éléments.

!!!Attention Si plusieurs champs (ou aucun, c'est-à-dire tous) sont sélectionnés, la définition de flatten=True lève une exception QueryDefinitionError.

Vous pouvez limiter le nombre de lignes en fournissant des critères dans filter() et except(), mais notez que même si une seule ligne (ou aucune!) correspond à vos critères, vous retournerez une liste en réponse.

Exemples:

#modèles déclarés

Catégorie de classe (modèle ormar):
    ormar_config = base_ormar_config.copy(tablename="catégories")

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=40)
    sort_order: int = ormar.Integer(nullable=True)


Classe Post(modèle ormar):
    ormar_config = base_ormar_config.copy()

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=200)
    Catégorie: Optional[Catégorie] = ormar.ForeignKey(Catégorie)

# sample de données
news = await Category(name="News", sort_order=0).save()
await Post(nom ="Ormar strikes again!", catégorie =news).save()
await Post(name="Why don't you use ormar yet?", category=news).save()
await Post(name="Check this out, ormar now for free", category=news).save()

Accès au modèle postal:

posts = await Post.objects.values_list()
# note how columns referer to id, name and category (fk)
assert posts == [
    (1, "Ormar strikes again!", 1),
    (2,« Pourquoi n'utilisez-vous pas Ormar Yet?», 1),
    (3,« Vérifiez ceci, l'ordre est maintenant libre », 1),
]

Pour sélectionner les modèles pertinents, utilisez select_lated ou prefetch_lated.

Compliquons la relation et modifions le modèle de catégorie mentionné précédemment pour faire référence au modèle utilisateur.

Catégorie de classe (modèle ormar):
    ormar_config = base_ormar_config.copy(tablename="catégories")

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=40)
    sort_order: int = ormar.Integer(nullable=True)
    #nouvelle colonne below
    created_by: Optional[User] = ormar.ForeignKey(User, related_name="categories")

Créez maintenant des exemples de données avec des liens utilisateur.

creator = await User(name="Anonymous").save()
admin = await Role(name="admin").save()
editor = await Role(name="editor").save()
await creator.roles.add(admin)
await creator.roles.add(éditeur)
news = await Category(name="News", sort_order=0, created_by=creator).save()

Combinez les champs pertinents et les champs pour sélectionner seulement 3 champs.

Notez que nous excluons également les définitions par modèle, car par définition, chaque modèle inclus dans la connexion, mais sans aucune référence dans le champ, est supposé être entièrement sélectionné (tous les champs inclus).

!!!Notez que, contrairement aux autres méthodes d'ensemble de requêtes ici, vous pouvez exclure les modèles intermédiaires mais conserver les colonnes de fin, ce qui n'a aucun sens lorsque vous analysez les données brutes dans un modèle.

Donc dans la catégorie relation-> catégorie_x_post -> post -> utilisateur, vous pouvez exclure
category_x_post and post models but can keep the user one. (dans le modèle d'ordre)
contexte qui n'est pas possible comme si vous vouliez exclude le modèle through and post
Il n'y aurait aucun moyen de récupérer le modèle utilisateur du modèle de catégorie).


user = (
        await Role.objects.select_related("users__categories")
        .filter(nom ="admin")
        .fields({"name": ..., "users": {"name": ..., "categories":{"name"}})
        .exclude_fields("roleuser")
        .values_list()
    )
assert user == [("admin", "Anonymous", "News")]

Si vous avez plusieurs modèles ManyToMany dans votre requête, vous devez exclure manuellement chaque modèle.

Pour éviter ce fardeau, ormar vous fournit le paramètre except_through=False. Si vous définissez cet indicateur sur True, tous les modèles sont complètement exclus.

# equivalent to query Above, note lack of exclude_fields call
user = (
        await Role.objects.select_related("users__categories")
        .filter(nom ="admin")
        .fields({"name": ..., "users": {"name": ..., "categories":{"name"}})
        .values_list(exclude_through=True)
    )
assert user == [("admin", "Anonymous", "News")]

Utilisez flatten pour obtenir une liste de valeurs.

# using flatten with more than one field raisonnera exception!
await Role.objects.fields({"name", "id"}).values_list(flatten=True)

#propre usage
roles = await Role. objets.fields("name").values_list(flatten=True)
assert roles == ["admin", "éditeur"]

La méthode QuerysetProxy

Lorsque vous accédez directement au champ ManyToMany associé ainsi qu'à la clé ReverseForeignKey, une liste des modèles associés est renvoyée.

Mais en même temps, il expose un sous-ensemble de l'API QuerySet, de sorte que vous pouvez filtrer, créer, sélectionner des modèles pertinents, etc. directement à partir du modèle parent.

Attention!!!Parce que l'utilisation de values et values_list ignore l'analyse et la validation du modèle, contrairement à toutes les autres méthodes de lecture dans querysetproxy, ces deux méthodes n'effacent pas le modèle en cours de chargement et n'écrasent pas le modèle en cours de chargement avec leurs propres résultats d'appel!

Les valeurs

Exactement comme la fonction valeur ci-dessus, mais vous permet d'obtenir des objets pertinents de l'autre côté de la relation.

!!!conseil Pour en savoir plus sur Querysetproxy, visitez la section Querysetproxy

Liste des valeurs

Exactement comme la fonction value_list ci-dessus, mais vous permet d'interroger ou de créer des objets associés de l'autre côté de la relation.

!!!conseil Pour en savoir plus sur Querysetproxy, visitez la section Querysetproxy