Le domaine

Il existe 12 types de champs de modèle de base, ainsi que des champs spéciaux ForeignKey et ManyToMany pour établir des relations entre les modèles.

!!!tip Description de la relation de vérification des champs ForeignKey et ManyToMany.

Chaque champ se voit attribuer la classe de colonne sqlalchemy et le type python utilisé pour créer le modèle pydantique.

Types de champs

String à

String(max_length: int, min_length: int = None, regex: str = None,) Il y a un paramètre max_length obligatoire.

Colonne Sqlalchemy: sqlalchemy.String
Type (pour Pydantic): str

!!!tip Pour une description des autres paramètres, consultez la documentation pydantique.

Le texte est

Text() n'a pas d'argument requis.

Colonne Sqlalchemy: sqlalchemy.Text
Type (pour pydantic): str

!!!tip Pour une description des autres paramètres, consultez la documentation pydantique.

Valeur booléenne

Boolean() n'a pas d'argument obligatoire.

Colonne Sqlalchemy: sqlalchemy.Boolean
Type (pour pydantic): bool

Intégrale

Integer(minimum: int = None, maximum: int = None, multiple_of: int = None) Il n'y a pas de paramètres obligatoires

Colonne Sqlalchemy: sqlalchemy.Integer
Type (pour Pydantic): int

!!!tip Pour une description des autres paramètres, consultez la documentation pydantique.

Les grands nombres entiers

BigInteger(minimum: int = None, maximum: int = None, multiple_of: int = None) Il n'y a pas de paramètres requis.

Colonne Sqlalchemy: sqlalchemy.BigInteger
Type (pour Pydantic): int

!!!tip Pour une description des autres paramètres, consultez la documentation pydantique.

Petits nombres entiers

SmallInteger(minimum: int = None, maximum: int = None, multiple_of: int = None) Il n'y a pas de paramètres obligatoires

Colonne Sqlalchemy: SmallInteger
Type (pour Pydantic): int

!!!tip Pour une description des autres paramètres, consultez la documentation pydantique.

Flottant

Float(minimum: float = None, maximum: float = None, multiple_of: int = None) Il n'y a pas de paramètres requis.

Colonne Sqlalchemy: sqlalchemy.Float
Type (pour pydantic): float

!!!tip Pour une description des autres paramètres, consultez la documentation pydantique.

Décimal

Decimal(minimum: float = None, maximum: float = None, multiple_of: int = None, precision: int = None, scale: int = None, max_digits: int = None, decimal_places: int = None) Aucun paramètre requis

Vous pouvez utiliser les paramètres Longueur et Précision ou max_digits et decimal_places.

Colonne Sqlalchemy: sqlalchemy.DECIMAL
Type (pour pydantic): Decimal.Decimal

!!!tip Pour une description des autres paramètres, consultez la documentation pydantique.

Date de la

Date() n'a pas d'argument obligatoire.

Colonne Sqlalchemy: sqlalchemy.Date
Type (pour pydantic): datetime.date

Temps pour

Time(timezone: bool = False) n'a pas d'argument obligatoire.

Vous pouvez passer timezone=True à une colonne de base de données sensible au fuseau horaire.

Colonne Sqlalchemy: sqlalchemy.Time
Type (pour pydantic): datetime.time.

Date et heure

DateTime(timezone: bool = False) Il n'y a pas de paramètres obligatoires

Vous pouvez passer timezone=True pour une colonne de base de données sensible au fuseau horaire.

Colonne Sqlalchemy: sqlalchemy.DateTime
Type (pour pydantic): datetime.datetime

par JSON

JSON() n'a pas de paramètres obligatoires.

Colonne Sqlalchemy: sqlalchemy.JSON
Type (pour pydantic): pydantic.Json

Les grands binaires

LargeBinary(max_length) a un paramètre max_length obligatoire.

Colonne Sqlalchemy: sqlalchemy.LargeBinary
Type (pour pydantic): Bytes

LargeBinary longueur est utilisée dans certains backends (c'est-à-dire mysql) pour déterminer la taille d'un champ, dans d'autres il est simplement ignoré, mais il est toujours nécessaire dans ormar.

LargeBinary dispose également d'un drapeau optionnel represent_as_base64_str: bool = False. lorsqu 'il est défini sur Trueormar, les valeurs d'octets sont automatiquement converties en chaînes décodées en Base64, et vous pouvez également définir les valeurs en passant une chaîne codée en Base64.

De cette façon, vous pouvez définir des valeurs via l'API, même si les valeurs ne sont pas compatibles avec utf-8, sinon elles échoueront lors de la conversion json.

Import base64
... #autres importations skippées pour le brevet


base_ormar_config = ormar.OrmarConfig(
    Metadata= métadonnée
    database=database
)


Classe LargeBinaryStr(modèle ormar):
    ormar_config = base_ormar_config.copy(tablename="my_str_blobs")

    id: int = ormar.Integer(primary_key=True)
    test_binary: str = ormar.LargeBinary(
        max_length=100000, represent_as_base64_str=True
    )

# set non utf-8 valeur compliante- note que cela peut être passé par api (i.e. fastapi) en json
item = LargeBinaryStr(test_binary=base64.b64encode(b"\xc3\x28").decode()))

assert item.test_binary == base64.b64encode(b"\xc3\x28").decode()

#Note technique que la valeur underlying est stable en octets et sera sauvée comme telle
assert item.__dict__["test_binary"] == b"\xc3\x28"

Identifiant unique universel

UUID(uuid_format: str = 'hex') Il n'y a pas de paramètres requis.

colonne* Sqlalchemy: ormar.UUID basé sur les champs sqlalchemy.CHAR(36) ou sqlalchemy.CHAR(32)(respectivement pour les formats string ou hexadécimal) * Type (pour pydantic): uuid.UUID

Le paramètre uuid_format autorise les valeurs "hexadécimal"(par défaut) ou "string".

En fonction du format, 32 ou 36 caractères sont utilisés dans la base de données

Sample de:

Valeur de format "hexadécimal"=c616ab438cce49dbbf4380d109251dce(caractère (32))
"string" valeur =c616ab43-8cce-49db-bf43-80d109251dce(caractère (36))

Il s'agit toujours d'un UUID python lorsqu 'il est chargé, vous pouvez donc le comparer et comparer les valeurs entre les deux valeurs de format.

énumération

Il existe deux façons d'utiliser l'énumération dans ormar ->, soit en utilisant un champ d'énumération dédié du type de colonne sqlalchemy.Enum, soit en définissant une sélection sur n'importe quel champ dans ormar.

Le champ Enum utilise le type de colonne Enum spécifique au dialecte de la base de données (si disponible), mais si ce type de champ n'est pas disponible, il retombe dans varchar.

Les options de sélection suivent toujours le type de champ de base de données sélectionné.

Par conséquent, celui que vous utilisez dépend du backend que vous utilisez et du type de colonne/données que vous souhaitez utiliser dans le champ énuméré.

Énumération-champs

Enum(enum_class=Type[Enum]) possède un paramètre enum_class obligatoire.

Colonne Sqlalchemy: sqlalchemy.Enum
Type (pour pydantic): Type[Enum]