Instructions pour la libération

0.20.1

- Changements majeurs

• Veuillez noter qu 'il s'agit de la première version non bêta d'ormar qui supporte Pydantic v2. consultez les notes de publication pour la version 0.20.0 et https://collerek.github.io/ormar/0.20.0b1/migration/

-Réparation

• Correction d'un problème de fusion du même modèle cible lors de l'utilisation de select_lated et prefetch_lated #906
• Correction d'un problème de sauvegarde lié au modèle pk uniquement #812
• Corrigez le fait d'ajouter plusieurs fois la même relation pour corrompre le cache relationnel #1335

- Caractéristiques

• Autoriser l'ajout d'un index de clé étrangère #1276 via @cmflynn

-Autres

• @Chaoyingz a corrigé quelques documents, merci!

0.20.0

- Changements majeurs

• Configuration du modèle Auma

  Maintenant, chaque modèle ormar nécessite un paramètre ormar_config qui est une instance de la classe OrmarConfig, plutôt que de définir la classe Meta. Notez que la propriété doit être nommée ormar_config et être une instance de la classe config.

  Importer des databases
  Importer à Ormar
  Import scalalchemy
  
  databases.Database("sqlite:///db.sqlite")
  metadata = sqlalchemy.MetaData()
  
  # ormar <0,20
  Classe Album(modèle ormar):
      Classe Meta:
          base de données = database
          Metadata = métadonnée
          tablename = "album"
  
      id: int = ormar.Integer(primary_key=True)
      name: str = ormar.String(max_length=100)
      Favorite: bool = ormar. booléen (default=False)
  
  # ormar >= 0,20
  Classe AlbumV20(modèle ormar):
      ormar_config = ormar.OrmarConfig(
          database=database,
          Metadata=Metadata,
          tablename="albums_v20"
      )
  
      id: int = ormar.Integer(primary_key=True)
      nom: str = ormar.String(max_length=100)
      Favorite: bool = ormar. booléen (default=False)
  

• OrmarConfig api/Paramètres

  ormar_config expose le même ensemble de paramètres que celui fourni par la classe Meta. cela signifie que vous pouvez initialiser la configuration avec l'un des paramètres suivants:

  Metadata: Optional[sqlalchemy.MetaData]
  Database: Optional[databases.Database]
  engine: Optional[sqlalchemy.Engine.engine]
  tablename: optionnel [str]
  order_by: Optional[Liste [str]]
  Abstract: bool
  exclude_parent_fields: Optional[Liste [str]]
  queryset_class: Type[QuerySet]
  Extra: supplément
  constraints: Optional[List[ColumnCollectionConstraint]]
  

• Equivalents de BaseMeta-bonnes pratiques

  Notez que pour réduire la duplication du code et simplifier le développement, il est toujours recommandé de créer une configuration de base et de fournir une copie de chaque modèle. OrmarConfig fournit une méthode de réplication pratique pour cela.

  La méthode copy accepte les mêmes arguments que l'init OrmarConfig, vous pouvez donc remplacer autant que vous le souhaitez, mais par défaut, elle retournera les propriétés déjà existantes, à l'exception de tablename, order_by et les contraintes qui sont effacées par défaut.

  Importer des databases
  Importer à Ormar
  Import sqlalchemy
  
  base_ormar_config = ormar.ormarConfig(
      database=databases.Database("sqlite:///db.sqlite"),
      metadata=sqlalchemy.MetaData()
  )
  
  Classe AlbumV20(modèle ormar):
      ormar_config = base_ormar_config.copy(
          tablename="albums_v20"
      )
  
      id: int = ormar.Integer(primary_key=True)
      name: str = ormar.String(max_length=100)
  
  Classe TrackV20(modèle ormar):
      ormar_config = base_ormar_config.copy(
          tablename="tracks_v20"
      )
  
      id: int = ormar.Integer(primary_key=True)
      name: str = ormar.String(max_length=100)
  

• Le paramètre de champ options n'est plus supporté.

  Avant la version 0.20, vous pouviez limiter les valeurs acceptables en fournissant des paramètres d'option à n'importe quel champ ormar existant. Cette fonctionnalité a été supprimée et vous devez utiliser le champ ormar.Enum conçu à cet effet. Si vous souhaitez conserver le type de champ de base de données (c'est-à-dire le champ entier), vous pouvez toujours écrire un validateur personnalisé.

  Importer des databases
  Importer à Ormar
  Import sqlalchemy
  
  databases.Database("sqlite:///db.sqlite")
  metadata = sqlalchemy.MetaData()
  
  # ormar <0,20
  Classe Artiste (modèle ormar):
      Classe Méta:
          base de données = database
          Metadata = métadonnée
  
      id: int = ormar.Integer(primary_key=True)
      name: str = ormar.String(max_length=100)
      Pays: str = ormar.String(default=False, max_length=50, choices=["UK", "US", "Vietnam", "Colombia"])
  
  # ormar >= 0,20
  De enum à import Enum
  
  Classe Pays (str, Enum):
      UK = "Royaume-Uni"
      États-Unis = "US"
      VIETNAM = "Vietnam"
      COLOMBIA = Colombie
  
  Classe ArtistV20(modèle ormar):
      ormar_config = ormar.ormarConfig(
          database=database,
          Metadata=Metadata,
          tablename= artists_v20
      )
  
      id: int = ormar.Integer(primary_key=True)
      nom: str = ormar.String(max_length=100)
      Pays: Pays = ormar.Enum(enum_class= Pays)
  

• Les arguments de champ ne sont plus supportés par pydantic_only

  Le champ pydantic_only a été déprécié et supprimé dans v 0.20. Ormar permet de définir des champs pydantiques comme un modèle pydantique normal.

  Importer des databases
  Import par Ormar
  Import sqlalchemy
  
  databases.Database("sqlite:///db.sqlite")
  metadata = sqlalchemy.MetaData()
  
  # ormar <0,20
  Classe Dish(modèle. ormar):
      Classe Meta:
          base de données = database
          Metadata = métadonnée
          tablename = "dishèses"
  
      id: int = ormar.Integer(primary_key=True)
      nom: str = ormar.String(max_length=100)
      cook: str = ormar.String(max_length=40, pydantic_only=True, default="sam")
  
  # ormar >= 0,20
  Classe DishV20(modèle. ormar):
      ormar_config = ormar.ormarConfig(
          database=database,
          Metadata=Metadata,
          tablename="dishes_v20"
      )
  
      id: int = ormar.Integer(primary_key=True)
      nom: str = ormar.String(max_length=100)
      cook: str = "sam" # this is normal Pydantic field
  

• Le décorateur property_field n'est plus supporté

  Le décorateur property_field est utilisé pour fournir un moyen de transmettre les champs calculés contenus dans la représentation json dictionnaire/sérialisée du modèle. pydantic version 2.X introduit cette possibilité, vous devriez donc passer à la version native de pydantic maintenant.

  Importer des databases
  Import par Ormar
  Import scalalchemy
  Import Pydantic
  
  databases.Database("sqlite:///db.sqlite")
  metadata = sqlalchemy.MetaData()
  
  # ormar <0,20
  Classe Employé (modèle ormar):
      Classe Méta:
          base de données = database
          Metadata = métadonnée
  
      id: int = ormar.Integer(primary_key=True)
      first_name: str = ormar.String(max_length=100)
      last_name: str = ormar.String(max_length=100)
  
      @ ormar.property_field()
      def full_name(self) -> str:
          return f"{self.first_name} {self.last_name}»
  
  # ormar >= 0,20
  Classe EmployeeV20(modèle ormar):
      ormar_config = ormar.ormarConfig(
          database=database,
          Metadata=Metadata,
      )
  
      id: int = ormar.Integer(primary_key=True)
      first_name: str = ormar.String(max_length=100)
      last_name: str = ormar.String(max_length=100)
  
      @pydantic.computed_field()
      def full_name(self) -> str:
          return f '{self.first_name} {self.last_name}»
  

• Méthodes obsolètes

  Toutes les méthodes énumérées ci-dessous sont obsolètes et seront supprimées dans la version 0.30 d'ormar.

  • dict() devient model_dump()

    Importer des databases Importer à Ormar Import sqlalchemy

    databases.Database("sqlite:///db.sqlite") metadata = sqlalchemy.MetaData()

    Classe Album(modèle ormar): ormar_config = ormar.OrmarConfig( database=database, Metadata=Metadata, tablename="album" )

    id: int = ormar.Integer(primary_key=True)
    nom: str = ormar.String(max_length=100)
    Favorite: bool = ormar. booléen (default=False)
    

    album = Album(nom ="Dark Side of the Moon")

    ormar <0,20

    album_dict = album.dict()

    ormar >= 0,20

    new_album_dict = album.model_dump()

  Notez que les paramètres restent les mêmes, c'est-à-dire inclus, exclus, etc.

  • json() devient model_dump_json()

    Importer des databases
    Importer à Ormar
    Import sqlalchemy
    
    databases.Database("sqlite:///db.sqlite")
    metadata = sqlalchemy.MetaData()
    
    Classe Album(modèle ormar):
        ormar_config = ormar.OrmarConfig(
            database=database,
            Metadata=Metadata,
            tablename="album"
        )
    
        id: int = ormar.Integer(primary_key=True)
        name: str = ormar.String(max_length=100)
        Favorite: bool = ormar. booléen (default=False)
    
    album = Album(nom ="Dark Side of the Moon")
    
    # ormar <0,20
    album_json= album.json()
    
    # ormar >= 0,20
    new_album_dict = album.model_dump_json()
    

    Notez que les paramètres restent les mêmes, c'est-à-dire inclusion, exclusion, etc.

  • construct() devient model_construct()

    Importer des databases Importer à Ormar Import sqlalchemy

    databases.Database("sqlite:///db.sqlite") metadata = sqlalchemy.MetaData()

    Classe Album(modèle ormar): ormar_config = ormar.ormarConfig( database=database, Metadata=Metadata, tablename="album" )

    id: int = ormar.Integer(primary_key=True)
    name: str = ormar.String(max_length=100)
    Favorite: bool = ormar. booléen (default=False)
    

    Params = { "Nom": "Dark Side of the Moon", « Favorite »: True, }

    ormar <0,20

    Album = Album.construct(**params)

    ormar >= 0,20

    album = Album. modèle_construct(**params)

  Pour en savoir plus sur la construction, consultez la documentation pydantique.

0.12.2

Caractéristiques

• Élever le support de FastAPI à la dernière version (0.97.0) #1110
• Ajout du support et des tests pour Python 3.11 #1110

0.12.1

Caractéristiques

• Les performances en termes de chargement des modèles ont été considérablement améliorées grâce au chargement récursif et à la mise en cache des modèles et des modèles associés.(@erichaydel -Merci!)#853

-Structure interne

• Benchmark comparant les effets de performance des changements de tendance mis en œuvre (encore une fois, par @erichaydel -merci!)#853

0.12.0

-Changements majeurs

• Queryset.bulk_create va maintenant lever une ModelListEmptyError (par @ ponytailler-merci!)#853 sur une liste de modèles vide.

-Caractéristiques

• Model.upsert() gère maintenant un drapeau__force_save__: bool qui permet de mettre à jour les modèles d'insertion, qu 'ils aient ou non une clé primaire définie. Notez que le fait de définir cet indicateur entraînera deux requêtes pour chaque modèle inséré par la mise à jour-> get vérifie si le modèle existe et met à jour/insère en conséquence plus tard.

Réparation

• Correction d'une relation vide qui détruisait la méthode de construction (par @Abdeldjalil-H -Merci!)#870
• Correction d'un problème lié à la sauvegarde qui ne sauvegardait pas les modèles avec des pks définis, y compris uuid #885
• Correction d'une relation erronée excluant selon l'ordre d'exclusion #779
• Correction d'un problème où property_fields n'hérite pas correctement #774

0.11.3

Caractéristiques

• enregistre les opérations de référence onupdate et ondelete dans ForeignKey et fournit une énumération de l'action référentielle pour spécifier le comportement de la relation (par @SepehrBazyar -Merci!)#724
• Ajout de CheckColumn aux contraintes prises en charge dans le modèle Meta (par @SepehrBazyar -merci!)#729

Réparation

• Correction pour limiter les résultats des requêtes à 0 devrait renvoyer une liste vide (par @SepehrBazyar -Merci!)#766

-Autre

• Ajouter le mode sombre au document (par @SepehrBazyar -merci!)#717
• Mise à jour de la dépendance aiomysql #778

0.11.2

Réparation

• La réparation des pilotes de base de données est nécessaire, alors qu 'ils devraient être facultatifs #713
• Correction d'un problème de champ booléen #704 dans les requêtes restreintes sans l'attribut limit_raw_sql dans postgres
• Correction de l'erreur #699 dans OpenAPI causée par le débordement de enum_class sur le schéma

0.11.1

Réparation

• Correction du problème de copie profonde #685 introduit dans Pydantic 1.9

0.11.0

-Changements majeurs

• Suppression du support pour Python 3.6
• Queryset.get_or_create renvoie maintenant un tuple contenant le modèle et une valeur booléenne indiquant si le modèle a été créé (par @MojixCoder -merci!)#554
• Queryset.count() calcule désormais le nombre de lignes de modèle parent différentes par défaut, et toutes les lignes peuvent être calculées en définissant unique=False (par @erichaydel -merci)#588

-Caractéristiques

• Ajout du support pour Python 3.10

Réparation

• Correction du comportement incohérent des champs JSON dans save et bulk_create #584
• Correction de l'erreur maximale de récursivité #580

0.10.25

Caractéristiques

• ajoute l'option queryset_class à Model.Meta, ce qui vous permet de remplacer facilement QuerySet par votre modèle (par @ponytailer -merci!)#538
• permet de transmettre des kwargs supplémentaires à IndexColumns, et ces colonnes indexées seront transmises à l'index sqlalchemy (par @zevisert -merci)#575

-Réparation

• Correction du paramètre NULL pour les champs JSON #529
• corrige un problème d'incompatibilité octets/str dans les opérations en vrac lors de l'utilisation d'orjson au lieu de json (par @ ponytailler-merci!)#538

0.10.24

Caractéristiques

• Ajout du signal post_bulk_update (par @ ponytailler-merci!)#524

Réparation

• Correction du support de pydantic==1.9.0#502
• Résoudre un problème de fuseau horaire avec la date et l'heure #504
• supprime les liaisons littérales dans la génération de requêtes pour déverrouiller le tableau postgres #/tophat/ormar-postgres-extensions/9
• Correction de la mise à jour en masse #519 pour les champs JSON

-Autre

• Améliorer les performances de bulk_create en contournant les implémentations sous-optimales de databaseexecute_many.(@Mng-dev-ai Merci!)#520
• La version de base de données requise est>=5.4.

0.10.23

Caractéristiques

• Ajout de la possibilité de passer des commentaires à sqlalchemy lors de la création de colonnes #485

-Réparation

• Correction du champ LargeBinary qui peut être vide #409
• Rendre le modèle Ormar. disponible #413
• Faire en sorte que first() et get() respectent l'ordre du modèle principal défini par l'utilisateur sans argument, en revenant à la clé primaire (asc et desc, respectivement)#453
• Correction d'une référence incorrecte à une clause de connexion non alias dans postgress #455

0.10.22

-Réparation

• Correction à chaud du validateur qui n'est pas hérité lors de la configuration du modèle ormar parent #365

0.10.21

-Réparation

• ajoute une implémentation ormar de la méthode de classe de construction, qui permet de construire des instances de modèle sans valider les entrées, pour accélérer le processus global si vos données ont déjà été validées #318
• corrige un problème d'héritage des validateurs de champ du modèle ormar lors de la génération du modèle pydanic nouvellement créé à l'aide de get_pydantic#365

0.10.20

Caractéristiques

• ajoute un paramètre supplémentaire dans le modèle.Meta qui accepte Extra.ignore et Extra.forbid (par défaut) et ignore les champs supplémentaires passés au modèle ormar ou lève l'exception #358 lorsqu 'une exception est rencontrée.

-Réparation

• Si le champ peut être vide et que l'option est définie,"Aucun"#354 n'est pas autorisé
• Indépendamment de l'incrémentation automatique et des paramètres explicitement nuls, définissez toujours la clé primaire sur non vide pour éviter les problèmes de migration #348

0.10.19

Caractéristiques

• Ajout de la prise en charge des colonnes multiples non uniques IndexColumns dans Meta.constraints#307
• Ajout d'un attribut de champ sql_nullable qui permet de définir différents paramètres nullables pour le modèle pydantic et la colonne sql sous-jacente #308

Réparation

• Activer la mise en cache des diagrammes pour améliorer les performances #337
• Clarifier et corriger le document #339 sur les champs qui peuvent être vides

-Autre

• Mise à niveau de la version de base de données prise en charge à <=5.2.

0.10.18

-Réparation

• Correction de l'ordre des champs dans le modèle pydantique #328
• Réparer la base de données 0.5.0 Support #142

0.10.17

Caractéristiques

• Type pydantique par défaut #312 qui permet de remplacer les champs du modèle
• Ajout du support pour sqlalchemy >=1.4 (base de données requise>= 0.5.0)#142

0.10.16

-Caractéristiques

• permet de transmettre votre propre configuration pydantique à ormar.Model, qui sera fusionné avec la configuration par défaut par @naturalethic (merci!)#285
• Ajout du type de champ SmallInteger via@ProgrammerPlus1998 (merci!)#297

Réparation

• Correction du schéma openapi généré en supprimant les paramètres obsolètes du champ pydantic exposés directement dans le schéma #291
• Correction des avertissements indésirables générés automatiquement par le modèle #295

0.10.15

Réparation

• Correction d'un problème de génération d'arbres de modèles pydantiques à l'aide de modèles imbriqués (par @pawamoy -merci!)#278
• Correction de la chaîne f manquante #274 dans l'avertissement concernant un champ de clé primaire manquant
• Correction du passage d'une valeur de clé externe en tant que relation (protection supplémentaire, corrigée dans la dernière version)#270

0.10.14

Caractéristiques

• permet de passer le paramètre timezone:bool = False aux champs DateTime et Time #264 de la colonne de base de données Fuseau horaire.
• permet de passer la date, l'heure et l'heure sur les champs DateTime, Time et Date à des fins de filtrage pour permettre le filtrage par date et heure au lieu de convertir la valeur en chaîne #79

-Réparation

• Correction de la dépendance de psycopg2 à psycopg2-binary #255

0.10.13

Caractéristiques

• permet de passer des accesseurs de champ dans select_lated et prefetch_lated. python style select_related#225.

  • Avant:

    await Post.objects.select_related(["author", "categories"]).get() await Author.objects.prefetch_related("posts__categories").get()

  • Et maintenant aussi:

    await Post.objects.select_related([Post.author, Post.categories]).get() await Author.objects.prefetch_related(Author.posts.categories).get()

Réparation

• Correction de la valeur par défaut qui remplace la clé primaire héritée #253

0.10.12

-Réparation

• Correction de la méthode QuerySet.create qui n'utilise pas init (si la personnalisation est fournie)#245
• Correction de ForwardRefManyToMany Relationship Settings Mauvais type de pydantic #250

0.10.11

Caractéristiques

• ajoute des valeurs et des valeurs_list à QuerySet et QuerysetProxy, ce qui permet de renvoyer les données brutes de la requête #223.
  • Permet de renvoyer une liste de tuples ou une liste de dictionnaires à partir d'une requête
  • Ignorer l'analyse des données dans le modèle ormar et donc ignorer la validation
  • Permet d'exclure les modèles entre les chaînes de relations, de sorte que vous pouvez extraire uniquement les colonnes dont vous avez besoin
  • Si une seule colonne est extraite, values_list permet d'aplatir le résultat.

-Réparation

• Correction d'un problème de création automatique via le modèle relationnel m2m avec ForwardRef #226

0.10.10

Caractéristiques

• ajoute l'attribut get_pydantic qui vous permet de générer automatiquement un arbre de modèle pydantique équivalent à partir d'ormar.Model Cet arbre de modèle nouvellement généré peut être utilisé dans les demandes et les réponses pour exclure les champs que vous ne souhaitez pas inclure dans vos données.
• Ajoutez le paramètre except_parent_fields au modèle Meta, ce qui vous permet d'exclure des champs du modèle parent pendant le processus d'héritage. Notez que la meilleure pratique consiste à combiner des modèles et des mixins, mais si vous avez plusieurs modèles similaires et un seul modèle différent, cela peut être un outil utile pour y parvenir.

-Réparation

• Correction d'un filtre vide avec pagination et relations (fourni par @erichaydel)#214
• Correction: Si vous ne sauvegardez pas avant #216, les enfants ne seront pas sauvegardés sur le revers de la relation.

-Autre

• Développez la section fastapi du document pour montrer un exemple d'utilisation d'ormar dans les demandes et les réponses de fastapi.
• Amélioration de la documentation sur les valeurs par défaut, ForeignKey.add, etc.

0.10.9

Corrections de sécurité importantes

• Mise à jour de la broche pydantic pour corriger la vulnérabilité de sécurité CVE-2021-29510

Il est recommandé de mettre à jour vers une version corrigée de pydantic. dans 0.10.9, ormar exclut les versions vulnérables dans les dépendances fixes.

Réparation

• Correction de l'architecture OpenAPI #204 de LargeBinary

0.10.8

-Réparation

• Correction du remplissage par défaut #202 dans le sous-modèle pk_only
• Utiliser base64 str pour représenter mypy #199 qui corrige le champ LargeBinary
• Correction du format de schéma OpenAPI #199 avec un champ LargeBinary sous la forme d'une représentation str Base64
• Correction du codage de sélection OpenAPI avec le champ LargeBinary sous la forme d'une représentation str Base64

0.10.7

Caractéristiques

• ajoute exclude_primary_keys: bool = False comme méthode dict(), ce qui permet d'exclure toutes les colonnes de clé primaire du dictionnaire résultant.
• ajoute le drapeau de exclude_through_models: bool = False dict(), permettant l'exclusion de tous les modèles de la relation ManyToMany #164
• Ajouter represent_as_base64_str: bool = False Permet de convertir un champ octet LargeBinary en argument d'une chaîne codée base64. lors de l'accès à la propriété, la chaîne est retournée dans dict(), et la chaîne est convertie en octets lorsqu 'elle est définie. les données dans la base de données sont stockées en octets. chapitre 187
• Ajout d'alias pk pour permettre à Model.pk d'accéder aux champs dans les filtres et les clauses order by (style python)

-Réparation

• Supprimer l'option None par défaut #186 pour max_length du champ LargeBinary
• Supprime l'option None par défaut pour le champ de chaîne max_length

-Autre

• Guide et exemples pour fournir le paramètre dict() dans la documentation
• Refactorisation principale des propriétés Get/Set dans la méthode magique en descripteurs-> amélioration significative des performances

0.10.6

-Caractéristiques

• Ajouter LargeBinary(max_length) Type de champ #166

• ajoute la prise en charge des champs pydantiques normaux (y compris les modèles) au lieu de la propriété pydantic_only, qui est maintenant obsolète #160. un champ Pydantic devrait être déclaré normalement comme dans un modèle pydantique à côté d'un champ ormar, notez que (évidemment) ormar ne sauvegarde pas et ne charge pas la valeur de ce champ dans la base de données, ce qui signifie que l'un des éléments suivants doit être vrai:

  • Les champs pydantiques déclarés sur le modèle ormar doivent être facultatifs (None par défaut)
  • Le champ pydantique doit être défini par défaut
  • Le champ pydantic a un ensemble de fonctions default_factory
  • Ormar.Model avec un champ pydantique DOIT remplacer__init__() et y fournir une valeur

  Si aucun des paramètres susmentionnés (ou plutôt pydantic) n'échoue lors du chargement des données à partir de la base de données et que la valeur requise pour le champ pydantic déclaré est manquante.

• Ormar fournit maintenant des exemples significatifs dans le schéma openapi, y compris les modèles imbriqués. le même algorithme que dict() et select/load_all est utilisé pour itérer sur les modèles pertinents sans regarder. des exemples apparaissent également dans fastapi. chapitre 157.

Réparation

• Par défaut, pydantic ne valide pas les champs pendant l'allocation, ce qui n'est pas idéal pour ORM, et tous les modèles ormar. ont maintenant la validation activée pendant l'allocation (par exemple, modèle.column = 'value')

-Autre

• Ajouter une connexion à la base de données dans QuickStart de readme #180 L'architecture OpenAPI* n'inclut plus la chaîne de documentation ormar.Model comme description, si vous ne fournissez pas votre propre chaîne de documentation, seul le nom du modèle est fourni.
• Quelques améliorations de performance.

0.10.5

Réparation

• Correction de l'erreur #73 dans fastapi-pagination
• Supprime les options inutiles #174 dans la liste[Optional[T]] dans les valeurs de retour QuerySet.all() et Querysetproxy.all()
• La couverture des tests en cours d'exécution est publiée uniquement sur les prs internes, et non dans les opérations github.

0.10.4

-Caractéristiques

• Ajouter un style Python filter et order_by utilisent l'accès par champ plutôt que des chaînes séparées par un dunner. Le champ d'accès via l'accès aux propriétés (chaîne de points) peut être utilisé pour construire des FilterGroups (ormar. et_et ormar. ou_). L'accès au champ surcharge un ensemble d'opérateurs Python et fournit un ensemble de fonctions pour permettre les mêmes fonctionnalités que les noms des paramètres séparés par dunder dans**kwargs, ce qui signifie que les requêtes à partir de l'exemple de modèle Track associé au modèle Album ont maintenant plus d'options: * Exact-correspond exactement à la valeur, colonne sql = * Old: album__name__exact ='Malibu' * NOUVEAU: peut également être écrit Track.album.name == 'Malibu * iexact -correspond exactement à la colonne sql =(insensible à la casse) * Old: album__name__iexact ='malibu' * Nouveau: peut aussi être écrit Track.album.name.iexact('malibu') * contient la colonne- sql LIKE '%%' * Old: album__name__contains ='Mal' * NOUVEAU: peut également être écrit comme Track.album.name % 'Mal') * Nouveau: peut aussi être écrit Track.album.name.contains('Mal') * icontains -colonne sql LIKE '%%'(insensible à la casse) * Old: album__name__icontains ='mal' * Nouveau: peut aussi être écrit Track.album.name.icontains('mal') * Dans-sql column IN (<VALUE1>, <VALUE2>, ...) * Vieux: album__name__in=['Malibu', 'Barclay'] * Nouveau: peut aussi être écrit Track.album.name << ['Malibu', 'Barclay'] * Nouveau: peut aussi être écrit Track.album.name.in_(['Malibu', 'Barclay']) * isnull -la colonne sql est NULL (et la colonne sql est NOT NULL) * Old: album__name__isnull=True (isnotnullalbum__name__isnull=False) * NOUVEAU: peut également être écrit comme Track.album.name>> Aucun * NOUVEAU: Peut également être écrit comme Track.album.name.isnull(True) * NOUVEAU: not null peut également être écrit Track.album.name.isnull(False) * NOUVEAU: not null peut également être écrit comme ~(Track.album.name >> None) * NOUVEAU: not null peut également être écrit ~(Track.album.name.isnull(True)) * gt -colonne sql>(plus grand que) * Ancienne: position__gt=3 * NOUVEAU: peut également être écrit comme Track.album.name> 3 * gte -colonne sql>=(supérieur ou égal à) * Ancienne: position__gte=3 * NOUVEAU: peut également être écrit comme Track.album.name>= 3 * lt -colonne sql <(inférieur à) * Ancienne: position__lt=3 * NOUVEAU: peut également être écrit comme Track.album.name < 3 * lte -colonne sql <=(inférieur à égal) * Ancienne: position__lte=3 * NOUVEAU: peut également être écrit comme Track.album.name <= 3 * startswith -colonne sql LIKE '%'(correspondance de début exacte) * Ancien: album__nom__startswith ="Mal" * Nouveau: peut aussi être écrit Track.album.name.startswith('Mal') * istartswith - sql colonne LIKE '%'(insensible à la casse) * Vieux: album__name__istartswith='mal' * Nouveau: peut aussi être écrit Track.album.name.istartswith('mal') * endswith -colonne sql LIKE '%(Fin complète du match) * Old: album__name__endswith ='ibu' * Nouveau: peut aussi être écrit Track.album.name.endswith('ibu') * iendswith -colonne sql LIKE '%'(insensible à la casse) * Old: album__name__iendswith ='IBU' * Nouveau: peut aussi être écrit Track.album.name.iendswith('IBU')
• Vous pouvez fournir FilterGroups non seulement dans filter() et except(), mais aussi dans:
  • obtenir ()
  • Acquisition ou non ()
  • Obtenir ou créer ()
  • Le premier ()
  • Tous ()
  • Supprimer ()
• Avec FilterGroups (ormar.and_and ormar.or_), vous pouvez désormais utiliser:
  • & -est imbriqué comme et_plutôt que comme la couche suivante
  • | - Imbriqué comme "ou_" plutôt que comme la couche suivante
  • ~ -La négation comme groupe de filtres

• Pour fusionner plusieurs ensembles de filtres en un ensemble de conditions, utilisez & (sql AND) et| (sql ou)

  # Following queries sont équivalents:
  # sql: (product.name = 'Test' AND product.rating >= 3.0 )
  
  # ormar OPTION 1 - OLD One
  Produit. objets.filter(nom ='Test', rating__gte=3.0).get()
  
  # ormar OPTION 2 - OLD One
  Produit. objets.filter(ormar.and_(name ='Test', rating__gte=3.0)).get()
  
  # ormar OPTION 3 - NEW ONE (accès au champ)
  Produit. objets.filter((Product.name == 'Test') & (Product.rating >=3.0)).get()
  

• Même chose pour les filtres complexes imbriqués

  # Following queries sont équivalents:
  # sql: (product.name = 'Test' AND product.rating >= 3.0 )
  #       OU (categories.name IN ('Toys', 'Books'))
  
  # ormar OPTION 1 - OLD One
  Product.objects.filter(ormar.or_()
                            ormar.and_(nom ='Test', rating__gte=3.0),
                            catégories__name__in=['Toys', 'Books'])
                        .get() pour
  
  # ormar OPTION 2 - NEW ONE (instead of nested or use `|`)
  Produit. objets.filter(
                        ormar.and_(nom ='Test', rating__gte=3.0)|
                        ormar.and_(catégories__name__in=['Toys', 'Books'])
                        ).get()
  
  # ormar OPTION 3 - NEW ONE (accès au champ)
  Produit. objets.filter(
                        ((Product.name ='Test') & (Product.rating >= 3.0))|
                        (Product.categories.name <<['Toys', 'Books'])
                        ).get()
  

• Vous pouvez désormais utiliser l'accès aux champs pour fournir des OrderActions à order_by().

  • Dans l'ordre croissant:
    • Vieux: Product.objects.order_by("name").all()
    • Le nouveau: Product.objects.order_by(Product.name.asc()).all()
  • Ordre décroissant:
    • Vieux: Product.objects.order_by("-name").all()
    • Le nouveau: Product.objects.order_by(Product.name.desc()).all()
  • Bien sûr, vous pouvez également combiner différents modèles et de nombreux ordres_by: Product.objects.order_by([Product.category.name.asc(), Product.name.desc()]).all()

-Réparation

• n'est pas vraiment une erreur, mais plutôt une incohérence. fournir des filtres avec des modèles imbriqués, c'est-à-dire album__category__name = 'AA' vérifie si les modèles d'album et de catégorie sont inclus dans select_lated(), sinon, ils y sont automatiquement ajoutés. La même fonctionnalité ne fonctionne pas avec FilterGroups (et_et or_), maintenant cela fonctionne (et fonctionne également avec les filtres de style python qui renvoient FilterGroups).

0.10.3

- Caractéristiques

• foreignKey et ManyToMany prennent désormais en charge skip_reverse: bool = False flag #118. si vous avez défini l'attribut skip_reverse en interne, le champ est toujours enregistré à l'autre extrémité de la relation, vous pouvez donc:

  • Filtrer par champ de modèle pertinent dans le modèle inverse
  • order_by Champ de modèle pertinent dans le modèle inverse

  Vous ne pouvez pas:

  • Utiliser related_name pour accéder aux champs pertinents à partir du modèle inverse
  • Même si vous sélectionnez une corrélation à partir du revers du modèle, le modèle retourné ne sera pas rempli dans l'instance inverse (les connexions ne seront pas bloquées, vous pouvez donc toujours filtrer et order_by).
  • La relation n'est pas remplie dans dict() et json().
  • ne peut pas passer un objet lié imbriqué lorsqu 'il est rempli à partir de dict() ou json()(également via fastapi). il sera ignoré ou une erreur sera générée en fonction des paramètres supplémentaires dans la configuration pydantique.

  • Model.save_lated() peut désormais sauvegarder l'ensemble de l'arbre de données #148 en une seule fois, ce qui signifie:

  • Il sait si le modèle principal ou le modèle associé doit être sauvegardé en premier pour préserver la relation.

  • Il sauvegarde le modèle principal si

    • Il n'est pas conservé,
    • Pas de valeur pk
    • ou save_all=True flag est défini

    Dans ces cas, vous n'avez pas à diviser la sauvegarde en deux appels (save() et save_lated())).

  • Il soutient également les relations plusieurs à plusieurs

  • Il prend également en charge les valeurs optionnelles du modèle Through pour les relations m2m.

• Ajout de la possibilité de personnalisation via les noms de champs de relation de modèle.

• Par défaut, le nom du modèle associé est par défaut en minuscule via le nom de la relation de modèle.

  ... ## course déclaration omitted
  Classe étudiante (modèle ormar):
      Classe Méta:
          base de données = database
          Metadata = métadonnée
  
      id: int = ormar.Integer(primary_key=True)
      name: str = ormar.String(max_length=100)
      courses = ormar.ManyToMany(Course)
  
  ##produira le défaut par modèle comme des follows (exemple simplifié)
  Classe StudentCourse(modèle. ormar):
      Classe Meta:
          base de données = database
          Metadata = métadonnée
          tablename = "étudiants_courses"
  
      id: int = ormar.Integer(primary_key=True)
      student = ormar.ForeignKey(Student) ##nom par défaut
      course = ormar.ForeignKey(Course) #nom par défaut
  

• Pour personnaliser les noms de champs/relations dans le modèle Through, vous pouvez maintenant utiliser les nouveaux paramètres de ManyToMany:

  • through_relation_name -nom du champ menant au modèle dans lequel ManyToMany est déclaré
  • through_reverse_relation_name -Nom du champ menant au modèle auquel ManyToMany mène

  Exemples:

  ... # course déclaration omitted
  Classe étudiante (modèle ormar):
      Classe Meta:
          base de données = database
          Metadata = métadonnée
  
      id: int = ormar.Integer(primary_key=True)
      nom: str = ormar.String(max_length=100)
      courses = ormar.ManyToMany(Course,
                                 through_relation_name="student_id",
                                 through_reverse_relation_name="course_id")
  
  #produira le défaut par un modèle comme des follows (exemple simplifié)
  Classe StudentCourse(modèle. ormar):
      Classe Meta:
          base de données = database
          Metadata = métadonnée
          tablename = "étudiants_courses"
  
      id: int = ormar.Integer(primary_key=True)
      student_id = ormar.ForeignKey(Student) # set by through_relation_name
      course_id = ormar.ForeignKey(Course) # set by through_reverse_relation_name
  

-Réparation

• Correction de l'erreur weakref referenceError #118
• Correction d'une erreur causée par Through fields lors de la configuration de pydantic Config.extra="forbid"
• corrige l'erreur #149 de pydantic.PrivateAttr non initialisé à__init__
• corrige une erreur exclue par pydantic-type dans dict() et la clé__all__ne fonctionne pas

-Autres

• Liens vers le traducteur automatique sqlalchemy-to-ormar pour l'introduction du modèle
• Fournir un lien vers la bibliothèque de l'écosystème fastapi qui supporte Ormar
• Ajouter une transaction à un document (support de base de données)

0.10.2

- Caractéristiques

• Model.save_related(follow=False) accepte désormais deux paramètres supplémentaires:Model.save_related(follow=False, save_all=False, exclude=None).
  • save_all:bool -> Par défaut (donc save_all=False) ormar ne met à jour que les modèles insérés non sauvegardés (donc nouveaux ou mis à jour), avec save_all=True tous les modèles pertinents sont sauvegardés quel que soit l'état de sauvegarde, ce qui peut être utile dans les cas suivants où le modèle mis à jour provient d'un appel api et ne change donc pas dans le backend.
  • exclude: Union[Set, Dict, None]-> Définit/dictionnaire les relations à exclure de la sauvegarde, qui ne seront pas sauvegardées même avec follow=True et save_all=True. Pour exclure les relations imbriquées, passez un dictionnaire imbriqué, par exemple:exclude={"child":{"sub_child": {"exclude_sub_child_realtion"}}}. Les valeurs autorisées suivent le schéma de méthode fields/exclude_fields (de QuerySet), donc en cas de doute, vous pouvez vous référer à la requête Document-> Sélectionner un sous-ensemble de champs-> Champs. La méthode Model.update() accepte désormais le paramètre_columns: List[str] = None, qui accepte la liste des noms de colonnes à mettre à jour. Si elle passe, seules ces colonnes seront mises à jour dans la base de données. Notez que update() ne rafraîchira pas les instances du modèle, donc si vous modifiez plus de colonnes que celles passées dans la liste_columns, vos instances du modèle auront une valeur différente de celle de la base de données! La méthode Model.model_dump() ne contenait auparavant que des modèles directement liés ou imbriqués (s'ils ne sont pas nuls et ne sont pas virtuels), maintenant tous les modèles liés qui n'étaient pas auparavant accessibles sans boucle sont inclus dans dict().
• QuerySet.delete(each=False, **kwargs) Auparavant, on vous demandait de passer un filtre (via**kwargs ou appelé en tant que filtre () séparé) ou set-each =True acceptent désormais également les appels exclusifs () qui génèrent des filtres NOT. Par conséquent, each=True doit être défini pour supprimer la table entière ou au moins une clause de filtrage/exclusion.
• La même chose s'applique à QuerySet.update(each=False, **kwargs) qui vous demandait auparavant de passer un filtre (via**kwargs ou en tant qu 'appel filter() séparé) ou de définir each=True Accepte désormais également les appels except() qui génèrent des filtres NOT.
• La même chose s'applique à QuerysetProxy.update(each=False, **kwargs) Il vous a également été demandé de passer un filtre (via**kwargs ou appelé en tant que filtre () séparé) ou set-each =True acceptent désormais également les appels except() qui génèrent des filtres NOT. Par conséquent, each=True doit être défini pour mettre à jour la table entière ou au moins une clause de filtrage/exclusion.

-Réparation

• Correction d'une résolution incorrecte des champs de relation dans QuerysetProxy si la colonne fk a un alias de base de données différent.
• Correction d'une erreur de récursivité avec une structure de modèle très complexe avec des boucles lors de l'appel de dict().
• Correction d'une erreur lorsque deux champs non relationnels sont fusionnés (ajoutés) dans les résultats de la requête lorsqu 'ils ne sont pas relationnels (c'est-à-dire JSON)
• Correction d'un bug qui utilisait le même nom de relation dans la chaîne lors de la traduction d'une liste vers un dictionnaire, mais qui entraînait un modèle différent
• Correction d'une erreur lorsque bulk_create essayait d'enregistrer la méthode de modification property_field et le champ pydantic
• Corriger une mauvaise fusion de chaînes profondément imbriquées de relations inverses

-Autres

• Optimisation des performances
• Diviser les tests en paquets en fonction de la zone de test

0.10.1

caractéristiques

• Ajoutez get_or_none()**La méthode kwargs) est ajoutée à QuerySet et QuerysetProxy. elle fonctionne avec get(**kwargs) est exactement la même chose, mais si aucun enregistrement de base de données ne correspond à la condition, get_or_none ne lève pas l'exception ormar.NoMatch, mais renvoie simplement None.

Réparation

• Correction d'un problème où les noms de colonnes et les références de noms de tables liés au dialecte dans la clause order_by ne fonctionnaient pas correctement dans postgres.

0.10.0

brisé

• Suppression de la prise en charge de la notation de définition de champ longtemps déconseillée, dans laquelle vous utilisez le champ ormar comme indicateur de type, c'est-à-dire test_field: ormar.Integger() = None Type-Tip amélioré par* -> mypy peut résoudre correctement les champs de modèle pertinents (ForeignKey et ManyToMany) ainsi que le type de retour de la méthode QuerySet. ceux mentionnés renvoient maintenant le bon modèle (c'est-à-dire Book) au lieu du type ormar.Model. relation et le revers de la méthode QuerysetProxy ont toujours des problèmes, afin d'atténuer le type Tip qui renvoie maintenant Any.

caractéristiques

• ajoute une méthode pour select_all(follow: bool = False) QuerySet et QuerysetProxy. Elle est similaire à la méthode load_all() du modèle, mais elle peut être utilisée directement dans une requête. select_all() ajoute uniquement les modèles directement liés par défaut, et si follow=True ajoute également les modèles associés des modèles associés sans boucle dans la relation. Notez qu 'il ne s'agit pas d'un modèle asynchrone et qu' il se termine, vous devez donc toujours émettre get(), all(), etc., car select_all() renvoie un QuerySet (ou un proxy) comme fields() ou order_by().

Structure interne

• Le champ ormar n'est plus stocké en tant que classe dans le dictionnaire Meta.model_fields, mais en tant qu 'instance.

0.9.9

caractéristiques

• Ajoute la possibilité de modifier l'ordre par défaut des relations et des modèles.
  • Pour modifier l'ordre du modèle, passez orders_by = [columns] where columns: List[str] à la métaclasse du modèle.
  • Pour modifier la relation order_by, passez order_by = [columns] where columns: List[str]
  • Pour modifier la relation inverse order_by passe related_orders_by = [columns] where columns: List[str] L'argument* peut être un nom de colonne ou-{col_name}trié par ordre décroissant.
  • Dans une relation, vous ne pouvez trier que par colonnes de modèle directement liées ou, pour les colonnes plusieurs à plusieurs, par colonnes de modèle "{through_field_name}__{column_name}"
  • La clause order_by est appliquée dans l'ordre suivant:
    • Passer explicitement l'appel order_by() dans une requête
    • S'il existe, la relation passe par orders_by
    • méta-classe de modèle orders_by
    • Colonne de clé primaire du modèle asc (sauvegarde, utilisée si aucune de celles-ci n'est fournie)
• Ajout de 4 nouvelles fonctions d'agrégation-> min, max, sum et avg sont respectivement leurs équivalents SQL correspondants.
  • Vous pouvez passer un ou plusieurs noms de colonnes, y compris les colonnes associées.
  • À partir de maintenant, chaque colonne passée est agrégée individuellement (donc sum(col1+col2) est impossible, vous pouvez utiliser sum(col1, col2) et ajouter 2 sommes retournées en python).
  • Vous ne pouvez pas additionner et moyenner des colonnes non numériques
  • Si une colonne est agrégée, une seule valeur est directement renvoyée comme résultat.
  • Si vous agrégez plusieurs colonnes, renvoie un dictionnaire avec une paire column: result
• ajoute 4 nouveaux signaux: > pre_relation_add, post_relation_add, pre_relation_remove et post_relation_remove Le signal nouvellement ajouté de est émis contre la relation ManyToMany (les deux parties) et l'inverse de la relation foreignkey (identique à QuerysetProxy public). Le signal reçoit les paramètres suivants: sender: Type[Model] -classe de l'expéditeur, instance: Model -instance du modèle associé ajouté, child: Model -modèle ajouté, relation_name: str -nom de la relation qui ajoute des enfants, par exemple le signal ajouté est également passé par_kwargs: dictionnaire-dictionnaire de kwargs passé à add()

Changement dans

• Maintenant, en instanciant le modèle de relations plusieurs-à-plusieurs lors de la création, de la suppression et de la mise à jour, vous pouvez fournir non seulement un int incrémental automatique en tant que clé primaire, mais également n'importe quel type de colonne avec des fonctionnalités par défaut.
• Puisque le modèle Through est maintenant instancié, vous pouvez également vous abonner aux signaux de sauvegarde/mise à jour/suppression avant/après le modèle Through. Le récepteur du signal* pre_update obtient maintenant également le paramètre Passed_args, qui est le dictionnaire des valeurs passées à la fonction de mise à jour, le cas échéant (sinon un dictionnaire vide).

Réparation

• Maintenant, le signal pre_update est envoyé avant l'extraction de la valeur afin que vous puissiez modifier l'instance passée sur place et que la valeur du champ modifié soit reflétée dans la base de données.
• bulk_update fonctionne désormais correctement avec le type de colonne de clé primaire UUID

0.9.8

Caractéristiques

• Ajout de la possibilité de chiffrer les champs sélectionnés dans la base de données
  • Au minimum, vous devez fournir encrypt_secret et encrypt_backend.
  • encrypt_backend peut être l'une des énumérations ormar.EncryptBackends (NONE, FERNET, HASH, CUSTOM)-par défaut: NONE
  • Lorsque vous choisissez un backend personnalisé, vous devez fournir une classe backend pour la sous-classe ormar.fields.EncryptBackend
  • Vous ne pouvez pas chiffrer les colonnes primaires_key et les séries de fermetures (FK et M2M)
  • 2 backends sont fournis: HASH et FERNET
    • HASH est un hachage à sens unique (comme un mot de passe) qui n'est jamais déchiffré lorsqu 'il est récupéré.
    • FERNET est un backend de chiffrement/décryptage bidirectionnel
  • Notez que dans le backend FERNET, vous perdez complètement la possibilité de filtrer, car une partie de la valeur cryptée est horodatée.
  • Notez que dans le backend HASH, vous pouvez filtrer par valeur complète, mais les filtres tels que contains ne fonctionneront pas car les valeurs chiffrées sont comparées.
  • Notez que l'ajout d'encrypt_backend modifie le type de colonne de la base de données en TEXT et doit être reflété dans db par migration ou modification manuelle.

Réparation

• (avancé/interne) restaure la fonctionnalité de type sqlalchemy personnalisé qui a cessé de fonctionner (via la sous-classe types. TypeColorator), donc process_result_value n'est jamais appelé.

0.9.7

caractéristiques

• Ajoutez l'opérateur isnull pour filtrer et exclure les méthodes.

  album__name__isnull=True #(sql: album.name est nul)
  album__name__isnull=False #(sql: album.name n'est pas nul)
  

• Ajoute des requêtes complexes avec des conditions imbriquées pour les fonctions ormar.or_et ormar.and_qui peuvent être utilisées pour la combinaison.

  Livres = (
      await Book.objects.select_related("author")
      . filtre (
          Ormar. et_(
              ormar.or_(année__gt=1960, année__lt=1940),
              author__name="J.R.R. Tolkien",
          )
      )
      . tout ()
  )
  

  Vérifier les documents mis à jour dans la requête-> Filtrer et trier-> Filtres complexes

Autre

• Définir une valeur par défaut sur ForeignKey ou ManyToMany lève une exception ModelDefinition, car elle n'est pas (et n'était) pas prise en charge.

0.9.6

Important

• devient maintenant facultatif via le modèle relationnel plusieurs-à-plusieurs. ce n'est pas un changement majeur, car si vous le fournissez, tout fonctionnera comme avant. vous pouvez donc l'ignorer si vous ne voulez pas ou n'avez pas besoin de "passer" par d'autres champs sur le modèle. notez qu 'il sera automatiquement créé pour vous et doit toujours être inclus dans l'exemple de migration alambic. si vous souhaitez supprimer une base de données existante, vérifiez la convention de nommage par défaut pour ajuster la structure de base de données existante.

  Notez que si vous souhaitez personnaliser le nom du modèle Through ou le nom de la table de base de données, vous devrez toujours le fournir.

caractéristiques

• Ajout d'une méthode de mise à jour à QuerysetProxy, de sorte qu 'il est maintenant possible de mettre à jour les modèles associés directement à partir du modèle parent dans la relation ManyToMany ainsi que des relations de clés étrangères inverses. Notez que les mises à jour comme celles de QuerySetupdate renvoient le nombre de modèles mis à jour et ne mettent pas à jour les modèles associés sur le modèle parent. await model_instance.related.all() ）
• ajoute la méthode load_all(follow=False, exclude=None) model, qui permet de charger l'instance actuelle du modèle ainsi que tous les modèles associés en un seul appel. par défaut, il charge uniquement les modèles directement associés, mais définir follow=True entraîne une traversée de l'arbre (en évitant les boucles). Vous pouvez également passer les mêmes paramètres d'exclusion que la méthode QuerySet.exclude_fields().
• Ajout de la possibilité d'ajouter plus de champs sur le modèle Through pour les relations plusieurs-à-plusieurs:
  • Le nom du champ de modèle through est le nom minuscule de la classe Through.
  • Vous pouvez passer des champs supplémentaires lorsque add(child, **kwargs) est appelé sur la relation (sur QuerysetProxy)
  • Vous pouvez appeler create() sur une relation (sur QuerysetProxy) lorsque l'un des arguments du mot-clé doit être un nom de modèle avec un dictionnaire de valeurs.**passer d'autres champs lorsque kwargs)
  • Vous pouvez commander via le champ Modèle
  • Vous pouvez filtrer à travers les champs du modèle
  • Vous pouvez inclure et exclure des champs via le modèle
  • Le modèle through est attaché uniquement au modèle pertinent (c'est-à-dire, si vous interrogez de A à B -> uniquement sur B)
  • Notez que le modèle pass-through est chargé explicitement sans relation-> La relation est remplie dans le champ ManyToMany.
  • Notez que, tout comme vous ne pouviez pas déclarer les champs de relation via le modèle auparavant, ils seront remplis par ormar pour vous, mais maintenant si vous essayez de le faire, une erreur de définition de modélisation sera lancée.
  • Consultez le document de relation ManyToMany mis à jour pour plus d'informations

Autres

• Documentation et documentation API mises à jour
• Le refactoring et l'optimisation impliquent principalement des filtres, des exclusions et des bases de tri.

0.9.5

Réparation

• Correction d'un problème de création de pydantic FieldInfo après la mise à jour de pydantic vers la version>=1.8
• Corrigez la version dépendante requise pour éviter de telles situations à l'avenir

0.9.4

Réparation

• Correction de la génération automatique du schéma fastapi OpenAPI pour les documents lorsque plusieurs modèles font référence au même modèle pertinent

0.9.3

Réparation

• Correction d'un problème où les champs JSON étaient doublement échappés lorsque la valeur était définie après l'initialisation
• Résout un problème où les champs JSON ne respectent pas les paramètres qui peuvent être définis pour des champs vides en raison de la structure interne de pydantic
• Correction de la validation de sélection pour les champs JSON
• Correction des options non validées lors de la configuration des propriétés après l'initialisation
• Correction d'une option non validée lors d'un appel de mise à jour QuerySet

0.9.2

Autre

• Mise à jour du Quick Start dans le document/fichier README
• Mise à jour de la documentation avec des liens vers des sous-pages de requête
• Ajout du badge pour Code Climat et Téléchargements

0.9.1

caractéristiques

• Ajoutez des valeurs d'option à la spécification OpenAPI pour qu 'elles ressemblent à des champs Enum natifs dans le schéma de résultats.

Réparation

• Le comportement de sélection de réparation est utilisé avec fastapi lorsque les champs spéciaux n'ont pas été initialisés mais passés sous forme de chaînes, etc.

0.9.0

Important pour moi

Correction du frein* : la version 0.8.0 introduisait un bug qui empêchait la génération de contraintes foreign_keys dans la base de données, soit dans alembic, soit lors de la création via sqlalchemy.engine, et le problème a été corrigé. * Par conséquent, si vous utilisez la version>=0.8.0, il est fortement recommandé de mettre à jour car, bien que la plupart des fonctions ormar soient en cours d'exécution, les bases de données créées avec ormar (ou ormar + alambic) ne sont pas pertinentes et souffrent de l'intégrité du point de vue des performances et des données. * Si vous utilisez ormar pour vous connecter à une base de données existante, vos performances et votre intégrité devraient être bonnes, mais vous devriez effectuer des mises à jour pour refléter toutes les futures mises à jour architecturales du modèle.

brisé

• Toutes les clés étrangères et les contraintes uniques ont maintenant un nom, de sorte qu 'alembic peut les reconnaître dans la base de données sans dépendre de la base de données. Violation de* : lors de la construction du modèle, si la méta-classe du modèle ne contient pas de métadonnées ou de base de données, une erreur de définition de modélisation est désormais levée au lieu d'une erreur d'attribution générique.
• détruit: L'encodage/base de données utilisé pour exécuter les requêtes n'a pas de pool de connexions pour le backend sqlite, ce qui signifie que chaque requête est exécutée avec une nouvelle connexion, et les contraintes de clé étrangère forcée ne peuvent pas être activées car elles sont désactivées par défaut sur chaque connexion. Exécutez de sorte que chaque connexion sqlite3 applique désormais les contraintes de clé étrangère par défaut, y compris la cascade.

Autres

• Mise à jour de la documentation API.
• Ajout de tests pour créer un fk dans la base de données et en cascade dans la base de données

0.8.1

Caractéristiques

• Introduction au traitement de ForwardRef dans les relations. Vous pouvez maintenant créer des modèles auto-référencés-clés étrangères et relations plusieurs-à-plusieurs. ForwardRef peut être utilisé pour to et throughModel.

• Introduire la possibilité d'effectuer deux connexions relationnelles identiques dans une requête afin de gérer des relations complexes, telles que:

      B = X = Y
    //
   A à
    \
      C = X = Y <= avant que vous puissiez lier de X à Y seulement une fois en une seule requête
                   Unless two different relation were used
                   (two champs de relation avec des noms différents)
  

• Introduction d'une méthode de pagination qui permet de limiter/décaler par page et page_size. disponible pour QuerySet et QuerysetProxy.

Autre

• Refactoring et optimisation des performances dans les requêtes et les connexions.
• Ajoutez python 3.9 aux paramètres de test et de pypi.
• Mise à jour des documents API et des documents->, c'est-à-dire la division des documents de requête.

0.8.0

brisé

• Breaking:remove() Le parent à l'extrémité neutron d'une relation de clé étrangère inverse doit maintenant passer un nom de relation, car le même modèle peut être enregistré plusieurs fois, et ormar doit savoir de quelle relation vous voulez supprimer l'enfant du parent.
• Par défaut, l'utilisation de select_lated pour appliquer des limites et des offsets s'applique uniquement à la table principale avant la connexion-> signifie que ce n'est pas le nombre total de lignes qui est limité, mais seulement le nombre de modèles principaux (le premier dans la requête, utilisé pour le construire). Vous pouvez toujours utiliser l'attribut limit_raw_sql=True sur la limite ou offset (ou les deux) pour limiter toutes les lignes dans la réponse de la base de données.
• casse: émettre first() obtient maintenant la première ligne triée par clé primaire asc (donc la première ligne insérée (qui peut être différente pour les clés primaires non numériques-c'est-à-dire l'ordre alphabétique des chaînes)) destruction de* : émettre get() sans aucun filtre récupère maintenant la première ligne triée par clé primaire desc (et devrait donc être la dernière ligne insérée (peut être différente pour les clés primaires non numériques-c'est-à-dire l'ordre alphabétique des chaînes))
• Rupture (interne): la colonne sqlalchemy conservée dans Meta.columns n'est plus liée à la table, vous ne pouvez donc pas obtenir la colonne directement à partir de là.

Caractéristiques

• Introduction de l'héritage. Actuellement, deux types d'héritage sont possibles:
  • Mixins -Ne sous-classez pas le modèle ormar.Model, définissez simplement les champs qui seront utilisés ultérieurement sur les différents modèles (par exemple, created_date et updated_date sur chaque sous-modèle), seul le modèle réel crée la table, mais ajoutez ceux des mixins.
  • héritage de table concret-signifie que le parent est marqué abstrait =True dans la classe Meta et que chaque enfant a sa propre table contenant les colonnes du parent et ses propres colonnes enfants, un peu comme Mixins, mais le parent est aussi un modèle (abstrait).
  • Pour en savoir plus, consultez la documentation relative à la section Modèle-> Héritage.
• QuerySet first() peut être utilisé avec prefetch_lated

Réparation

• Correction d'une petite erreur dans l'ordre_by du modèle principal order by
• Correction de la requête préfetch_query de plusieurs noms_related du même modèle.
• corrige un problème où l'utilisation du même nom related_sur différents modèles entraîne l'écrasement des mêmes modèles liés les uns aux autres, lève maintenant une erreur de définition de modèle et vous devez modifier le nom.
• Correction d'un problème où order_by remplaçait la condition lorsque plusieurs jointures à la même table étaient appliquées.

Documentaire

• Diviser et nettoyer dans un document:
  • Diviser la partie modèle en plusieurs petites sections
  • Diviser la section relation en sous-sections
  • Diviser une section de champ en petites sections
• Ajouter une section Héritage du modèle
• Ajouter une documentation API (Beta)

0.7.5

• Correction d'un mauvais nom de colonne de relation dans la connexion relationnelle Many_to_many (correctif #73)

0.7.4

• Plusieurs relations avec le même modèle/table associé sont autorisées.
• Correction de la famille de fermetures incorrectes utilisées dans les connexions relationnelles Many_to_many (correctif #73)
• Correction d'une population de relations erronées pour les relations m2m lorsque le même modèle a également des relations fk.
• S'il existe plusieurs relations pour la même table sur un modèle, l'ajout vérifie si l'utilisateur fournit un nom_related.
• nettoyer plus ardemment les modèles d'agents faibles morts.

0.7.3

• Correction d'un problème d'obtention des modèles pertinents à l'aide du paramètre UUDI pk, qui était la chaîne brute (correctif #71)

0.7.2

• corrige un problème où seul le pk est utilisé pour écraser les modèles pertinents Model.update() with fields passed as parameters(correctif #70)

0.7.1

• Correction d'un problème où pk écrase les modèles pertinents uniquement dans Model.save()(correctif #68)

0.7.0

Violation de* : la méthode QuerySetbulk_update lève désormais une erreur ModelPersistenceError pour le modèle non enregistré passé au lieu d'une erreur QueryDefinitionError. * L'initialisation du modèle avec un nom de champ inconnu lève désormais une ModelError au lieu d'une KeyError * a ajouté des signaux, avec des signaux de liste prédéfinis et des décorateurs: post_delete, post_save, post_update, pre_delete, pre_save, pre_update * Ajout de py.typed et modification de setup.py pour supporter mypy * Optimisation des performances * Mise à jour des documents

0.6.2

• Optimisation des performances
• Correction d'un bug qui nécessitait un champ pydantic_only
• ajoute le décorateur property_field pour enregistrer la fonction en tant qu 'attribut, qui sera inclus dans les réponses Model.model_dump() et fastapi
• Mise à jour du document

0.6.1

• Définissez None explicitement pour exclure les champs qui peuvent être vides afin d'éviter que pydantic ne définisse la valeur par défaut (correctif #60).

0.6.0

• Corruption: appeler instance.load() lors de la suppression d'une ligne d'instance de la base de données lève désormais NoMatch au lieu de ValueError
• Rupture: appeler Ajouter et supprimer sur la relation ReverseForeignKey met à jour les paramètres de la base de données/supprime les sous-modèles dans la colonne fk Percée de* : la relation ReverseForeignKey expose désormais l'API QuerySetProxy comme la relation ManyToMany
• Rupture: la requête d'un modèle associé à partir de ManyToMany efface la liste des modèles associés chargés sur le modèle parent:
  • Exemple: post.categories.first() définira post.categories comme une liste de 1 modèle associé-> le modèle retourné par first()
  • Exemple 2: Si le message a 4 catégories, len(post.categories) == 4 Appels post.categories.limit(2).all()-> Seuls 2 sous-processus assert len(post.categories) == 2 seront chargés maintenant
• Ajout de get_or_create, update_or_create, fields, exclude_fields, exclusion, prefetch_lated et order_by à QuerySetProxy, vous pouvez donc maintenant utiliser ces méthodes directement à partir de la relation.
• Mise à jour des documents

0.5.5

• corrige un problème de génération automatique d'alembic pour les colonnes UUID migrées. il ne devrait générer que CHAR(32) ou CHAR(36)
• Pour que cela fonctionne, vous devez définir user_module_prefix='sa'.(doit être égal à l'option sqlalchemy_module_prefix (par défaut "sa").)

0.5.4

• permet de passer uuid_format (permettant "hexadécimal"(par défaut) ou "string") à un champ UUID pour modifier son format de sauvegarde. par défaut, les champs sont sauvegardés au format hexadécimal (découpés à 32 caractères sans tiret), mais vous pouvez passer format='string' pour utiliser 36 (avec tiret) pour ajuster une base de données existante ou une autre bibliothèque.

  Sample de:

  • Valeur hexadécimale = c616ab438cce49dbbf4380d109251dce
  • Valeur de la chaîne = c616ab43-8cce-49db-bf43-80d109251dce

0.5.3

• Correction d'une erreur dans la méthode Model.model_dump() qui ignorait les paramètres d'exclusion et ne contenait pas d'arguments de dictionnaire.

0.5.2

• Ajout de la méthode prefetch_lated pour charger le modèle suivant dans une requête séparée.
• Mise à jour du document

0.5.1

• Passer à Github actions au lieu de travis
• Mise à jour des badges dans les documents

0.5.0

• Ajout d'un statut de sauvegarde-> Vous pouvez vérifier si le modèle a été sauvegardé avec la propriété ModelInstance.saved
  • Sauvegarder le modèle après avoir enregistré/mis à jour/chargé/mis à jour la méthode d'insertion sur le modèle
  • Après la sauvegarde du modèle create/get/first/all/get_or_create/update_or_create Méthode
  • Le modèle est sauvegardé lorsqu 'il est passé à bulk_update et bulk_create
  • Enregistrer le modèle après avoir ajouté/supprimé des objets liés à ManyToMany (enregistrement/suppression automatique via une instance de modèle)
  • Le modèle n'est pas enregistré après avoir modifié l'un de ses propres champs (y compris pk comme alias de Model.pk)
  • Le modèle n'est pas sauvegardé après l'ajout/suppression d'objets liés à ForeignKey (colonne fk non sauvegardée)
  • ne sauvegarde pas le modèle après l'instanciation avec__init__(sans QuerySet.create ou avant d'appeler save)
• Ajout de Model.upsert(**kwargs), save() si pk n'est pas défini, update() sinon**kwargs)
• Extra Model.save_related(follow=False) itère sur tous les objets pertinents dans toutes les relations et vérifie qu 'ils sont sauvegardés. sinon, il appelle upsert() pour chaque objet.
• Rupture: si vous ajoutez/supprimez un modèle non enregistré (pk = None) à une relation plusieurs-à-plusieurs, l'ajout lève une exception.
• Permet de passer des dictionnaires et des collections à fields et except_fields
• Un dictionnaire qui traduit automatiquement str et les listes en champs et except_fields
• Rupture: le passage des modèles imbriqués à fields et excre_fields se fait désormais par le nom de la clé étrangère associée au lieu du nom du modèle cible.
• Optimisation des performances-dans modelproxy, newbasemodel-réduction des requêtes>, certains attributs sont mis en cache sur le modèle
• Nettoyer le code relationnel inutilisé
• Ajout d'une dépendance de performance facultative orjson (fortement recommandée)
• Mise à jour des documents

0.4.4

• Ajout de la méthode except_fields() pour exclure les champs de sql
• Refactoriser les paramètres de nom de colonne (alias)
• Correction de la façon dont les colonnes avec des alias sont triées
• Tests supplémentaires sur fields et except_fields
• Mise à jour des documents

0.4.3

• Contient les propriétés de models.model_dump() et model.model_dump_json()

0.4.2

• Modifier la création d'un modèle pydantique pour permettre le retour d'un modèle associé rempli uniquement de pk

0.4.1

• Ajouter la méthode order_by à un ensemble de requêtes pour permettre le tri
• Mise à jour du document

0.4.0

• a changé la notation dans la définition du modèle-> utilise maintenant name = ormar.Field() au lieu de name: ormar.Field()
  • Notez que les anciennes notations sont toujours supportées, mais sont obsolètes et ne fonctionnent pas bien avec les inspecteurs statiques tels que les plug-ins mypy et pydantic pycharm.
• Entrez un document d'invite et testez
• Vous ne pouvez pas non plus tester avec mypy, seulement avec le paquet ormar.
• Correction des conversions d'échelle et de précision avec les champs max_digits et decimal_places pydantic Decimal
• Mise à jour de la documentation-Bonnes pratiques pour ajouter des dépendances
• Refactoriser les métaclasses et les modèles_fields pour mieux utiliser les indices de type
• Ajouter des plugins mypy et pydantic à la documentation
• Développer un document sur les relations plusieurs à plusieurs

0.3.11

• Correction du paramètre server_default à la valeur de champ par défaut en python

0.3.10

• Correction de la vérification postgresql pour éviter les exceptions de pilotes non installés lors de l'utilisation de différents backends

0.3.9

• Correction de la génération du mode json à partir de #19
• Correction d'un problème avec la relation ManyToMany non initialisée dans la copie fastapi d'ormar.Models
• Mise à jour de la documentation sur l'utilisation de fastapi
• Ajouter des tests pour vérifier que fastapi/docs est généré correctement

0.3.8

• Ajout de la possibilité de fournir des noms de colonne de base de données alternatifs avec des paramètres de noms à tous les champs.
• Correction d'une erreur qui sélectionnait les champs ManyToMany pertinents s'ils étaient vides avec fields().
• Mise à jour du document

0.3.7

• Publier le document et mettre à jour le fichier README

0.3.6

• Ajoutez la méthode fields() pour limiter les colonnes sélectionnées dans la base de données-seules les colonnes pouvant être vides peuvent être exclues.
• Ajout d'UniqueColumns et d'une liste de contraintes dans le méta modèle pour créer des contraintes uniques sur la liste des colonnes.
• Ajout d'un type de champ UUID basé sur le type de colonne Char(32).

0.3.5

• Ajout de bulk_create et bulk_update pour les opérations sur plusieurs objets.

0.3.4

Ajouter une méthode de niveau Query Set

• Supprimé
• Actualités
• Obtenir ou créer
• Mettre à jour ou créer

0.3.3

• Ajouter des filtres supplémentaires-Début et fin

0.3.2

• Ajouter un paramètre d'option à tous les champs-limiter les valeurs acceptées à celles fournies

0.3.1

• Des exclusions ont été ajoutées pour filtrer la condition where not.
• Ajout de tests pour mysql et postgres et correction de postgres.
• Rafactors et le nettoyage.

0.3.0

• Ajout du champ ManyToMany et prise en charge des relations plusieurs à plusieurs