Fields

Usage

Fields are defined as properties of a Model class object:

from tortoise.models import Model
from tortoise import fields

class Tournament(Model):
    id = fields.IntField(pk=True)
    name = fields.CharField(max_length=255)

Reference

Here is the list of fields available with custom options of these fields:

Base Field

class tortoise.fields.base.Field(source_field=None, generated=False, pk=False, null=False, default=None, unique=False, index=False, description=None, model=None, validators=None, **kwargs)[source]

Base Field type.

Parameters:
source_field=None

Provide a source_field name if the DB column name needs to be something specific instead of generated off the field name.

generated=False

Is this field DB-generated?

pk=False

Is this field a Primary Key? Can only have a single such field on the Model, and if none is specified it will autogenerate a default primary key called id.

null=False

Is this field nullable?

default=None

A default value for the field if not specified on Model creation. This can also be a callable for dynamic defaults in which case we will call it. The default value will not be part of the schema.

unique=False

Is this field unique?

index=False

Should this field be indexed by itself?

description=None

Field description. Will also appear in Tortoise.describe_model() and as DB comments in the generated DDL.

validators=None

Validators for this field.

Class Attributes: These attributes needs to be defined when defining an actual field type.

field_type Type[Any]

The Python type the field is. If adding a type as a mixin, _FieldMeta will automatically set this to that.

indexable bool = True

Is the field indexable? Set to False if this field can’t be indexed reliably.

has_db_field bool = True

Does this field have a direct corresponding DB column? Or is the field virtualized?

skip_to_python_if_native bool = False

If the DB driver natively supports this Python type, should we skip it? This is for optimization purposes only, where we don’t need to force type conversion between Python and the DB.

allows_generated bool = False

Is this field able to be DB-generated?

function_cast Optional[pypika.Term] = None

A casting term that we need to apply in case the DB needs emulation help.

SQL_TYPE str

The SQL type as a string that the DB will use.

GENERATED_SQL str

The SQL that instructs the DB to auto-generate this field. Required if allows_generated is True.

Per-DB overrides:

One can specify per-DB overrides of any of the class attributes, or the to_db_value or to_python_value methods.

To do so, specify a inner class in the form of class _db__SQL_DIALECT: like so:

class _db_sqlite:
    SQL_TYPE = "VARCHAR(40)"
    skip_to_python_if_native = False

    def function_cast(self, term: Term) -> Term:
        return functions.Cast(term, SqlTypes.NUMERIC)

Tortoise will then use the overridden attributes/functions for that dialect. If you need a dynamic attribute, you can use a property.

property constraints : dict

Returns a dict with constraints defined in the Pydantic/JSONSchema format.

Return type:

dict

describe(serializable)[source]

Describes the field.

Parameters:
serializable

False if you want raw python objects, True for JSON-serializable data. (Defaults to True)

Return type:

dict

Returns:

A dictionary containing the field description.

(This assumes serializable=True, which is the default):

{
    "name":         str     # Field name
    "field_type":   str     # Field type
    "db_column":    str     # Name of DB column
                            #  Optional: Only for pk/data fields
    "raw_field":    str     # Name of raw field of the Foreign Key
                            #  Optional: Only for Foreign Keys
    "db_field_types": dict  # DB Field types for default and DB overrides
    "python_type":  str     # Python type
    "generated":    bool    # Is the field generated by the DB?
    "nullable":     bool    # Is the column nullable?
    "unique":       bool    # Is the field unique?
    "indexed":      bool    # Is the field indexed?
    "default":      ...     # The default value (coerced to int/float/str/bool/null)
    "description":  str     # Description of the field (nullable)
    "docstring":    str     # Field docstring (nullable)
}

When serializable=False is specified some fields are not coerced to valid JSON types. The changes are:

{
    "field_type":   Field   # The Field class used
    "python_type":  Type    # The actual Python type
    "default":      ...     # The default value as native type OR a callable
}

get_db_field_types()[source]

Returns the DB types for this field.

Return type:

Optional[Dict[str, str]]

Returns:

A dictionary that is keyed by dialect. A blank dialect “” means it is the default DB field type.

get_for_dialect(dialect, key)[source]

Returns a field by dialect override.

Parameters:
dialect

The requested SQL Dialect.

key

The attribute/method name.

Return type:

Any

property required : bool

Returns True if the field is required to be provided.

It needs to be non-nullable and not have a default or be DB-generated to be required.

Return type:

bool

to_db_value(value, instance)[source]

Converts from the Python type to the DB type.

Parameters:
value

Current python value in model.

instance

Model class or Model instance provided to look up.

Due to metacoding, to determine if this is an instance reliably, please do a:

if hasattr(instance, "_saved_in_db"):

Return type:

Any

to_python_value(value)[source]

Converts from the DB type to the Python type.

Parameters:
value

Value from DB

Return type:

Any

validate(value)[source]

Validate whether given value is valid

Parameters:
value

Value to be validation

Raises:

ValidationError – If validator check is not passed

class tortoise.fields.base.OnDelete(value)[source]

An enumeration.

CASCADE = 'CASCADE'
NO_ACTION = 'NO ACTION'
RESTRICT = 'RESTRICT'
SET_DEFAULT = 'SET DEFAULT'
SET_NULL = 'SET NULL'
class tortoise.fields.base.StrEnum(value)[source]

An enumeration.

Data Fields

class tortoise.fields.data.BigIntField(pk=False, **kwargs)[source]

Big integer field. (64-bit signed)

pk (bool):

True if field is Primary Key.

property constraints : dict

Returns a dict with constraints defined in the Pydantic/JSONSchema format.

Return type:

dict

field_type

alias of int

class tortoise.fields.data.BinaryField(source_field=None, generated=False, pk=False, null=False, default=None, unique=False, index=False, description=None, model=None, validators=None, **kwargs)[source]

Binary field.

This is for storing bytes objects. Note that filter or queryset-update operations are not supported.

field_type

alias of bytes

class tortoise.fields.data.BooleanField(source_field=None, generated=False, pk=False, null=False, default=None, unique=False, index=False, description=None, model=None, validators=None, **kwargs)[source]

Boolean field.

field_type

alias of bool

tortoise.fields.data.CharEnumField(enum_type, description=None, max_length=0, **kwargs)[source]

Char Enum Field

A field representing a character enumeration.

Warning: If max_length is not specified or equals to zero, the size of represented char fields is automatically detected. So if later you update the enum, you need to update your table schema as well.

Note: Valid str value of enum_type is acceptable.

enum_type:

The enum class

description:

The description of the field. It is set automatically if not specified to a multiline list of “name: value” pairs.

max_length:

The length of the created CharField. If it is zero it is automatically detected from enum_type.

Return type:

Enum

class tortoise.fields.data.CharField(max_length, **kwargs)[source]

Character field.

You must provide the following:

max_length (int):

Maximum length of the field in characters.

property constraints : dict

Returns a dict with constraints defined in the Pydantic/JSONSchema format.

Return type:

dict

field_type

alias of str

class tortoise.fields.data.DateField(source_field=None, generated=False, pk=False, null=False, default=None, unique=False, index=False, description=None, model=None, validators=None, **kwargs)[source]

Date field.

field_type

alias of date

class tortoise.fields.data.DatetimeField(auto_now=False, auto_now_add=False, **kwargs)[source]

Datetime field.

auto_now and auto_now_add is exclusive. You can opt to set neither or only ONE of them.

auto_now (bool):

Always set to datetime.utcnow() on save.

auto_now_add (bool):

Set to datetime.utcnow() on first save only.

property constraints : dict

Returns a dict with constraints defined in the Pydantic/JSONSchema format.

Return type:

dict

describe(serializable)[source]

Describes the field.

Parameters:
serializable

False if you want raw python objects, True for JSON-serializable data. (Defaults to True)

Return type:

dict

Returns:

A dictionary containing the field description.

(This assumes serializable=True, which is the default):

{
    "name":         str     # Field name
    "field_type":   str     # Field type
    "db_column":    str     # Name of DB column
                            #  Optional: Only for pk/data fields
    "raw_field":    str     # Name of raw field of the Foreign Key
                            #  Optional: Only for Foreign Keys
    "db_field_types": dict  # DB Field types for default and DB overrides
    "python_type":  str     # Python type
    "generated":    bool    # Is the field generated by the DB?
    "nullable":     bool    # Is the column nullable?
    "unique":       bool    # Is the field unique?
    "indexed":      bool    # Is the field indexed?
    "default":      ...     # The default value (coerced to int/float/str/bool/null)
    "description":  str     # Description of the field (nullable)
    "docstring":    str     # Field docstring (nullable)
}

When serializable=False is specified some fields are not coerced to valid JSON types. The changes are:

{
    "field_type":   Field   # The Field class used
    "python_type":  Type    # The actual Python type
    "default":      ...     # The default value as native type OR a callable
}

field_type

alias of datetime

class tortoise.fields.data.DecimalField(max_digits, decimal_places, **kwargs)[source]

Accurate decimal field.

You must provide the following:

max_digits (int):

Max digits of significance of the decimal field.

decimal_places (int):

How many of those significant digits is after the decimal point.

field_type

alias of Decimal

class tortoise.fields.data.FloatField(source_field=None, generated=False, pk=False, null=False, default=None, unique=False, index=False, description=None, model=None, validators=None, **kwargs)[source]

Float (double) field.

field_type

alias of float

tortoise.fields.data.IntEnumField(enum_type, description=None, **kwargs)[source]

Enum Field

A field representing an integer enumeration.

The description of the field is set automatically if not specified to a multiline list of “name: value” pairs.

Note: Valid int value of enum_type is acceptable.

enum_type:

The enum class

description:

The description of the field. It is set automatically if not specified to a multiline list of “name: value” pairs.

Return type:

IntEnum

class tortoise.fields.data.IntField(pk=False, **kwargs)[source]

Integer field. (32-bit signed)

pk (bool):

True if field is Primary Key.

property constraints : dict

Returns a dict with constraints defined in the Pydantic/JSONSchema format.

Return type:

dict

field_type

alias of int

class tortoise.fields.data.JSONField(encoder=<function <lambda>>, decoder=<built-in function loads>, **kwargs)[source]

JSON field.

This field can store dictionaries or lists of any JSON-compliant structure.

You can specify your own custom JSON encoder/decoder, leaving at the default should work well. If you have orjson installed, we default to using that, else the default json module will be used.

encoder:

The custom JSON encoder.

decoder:

The custom JSON decoder.

class tortoise.fields.data.SmallIntField(pk=False, **kwargs)[source]

Small integer field. (16-bit signed)

pk (bool):

True if field is Primary Key.

property constraints : dict

Returns a dict with constraints defined in the Pydantic/JSONSchema format.

Return type:

dict

field_type

alias of int

class tortoise.fields.data.TextField(pk=False, unique=False, index=False, **kwargs)[source]

Large Text field.

field_type

alias of str

class tortoise.fields.data.TimeDeltaField(source_field=None, generated=False, pk=False, null=False, default=None, unique=False, index=False, description=None, model=None, validators=None, **kwargs)[source]

A field for storing time differences.

class tortoise.fields.data.UUIDField(**kwargs)[source]

UUID Field

This field can store uuid value.

If used as a primary key, it will auto-generate a UUID4 by default.

field_type

alias of UUID

Relational Fields

tortoise.fields.relational.ForeignKeyField(model_name: str, related_name: str | None | False = None, on_delete: OnDelete = CASCADE, db_constraint: bool = True, *, null: True, **kwargs: Any) ForeignKeyFieldInstance[MODEL] | None[source]
tortoise.fields.relational.ForeignKeyField(model_name: str, related_name: str | None | False = None, on_delete: OnDelete = CASCADE, db_constraint: bool = True, null: False = False, **kwargs: Any) ForeignKeyFieldInstance[MODEL]

ForeignKey relation field.

This field represents a foreign key relation to another model.

See Foreign Key for usage information.

You must provide the following:

model_name:

The name of the related model in a 'app.model' format.

The following is optional:

related_name:

The attribute name on the related model to reverse resolve the foreign key.

on_delete:
One of:
field.CASCADE:

Indicate that the model should be cascade deleted if related model gets deleted.

field.RESTRICT:

Indicate that the related model delete will be restricted as long as a foreign key points to it.

field.SET_NULL:

Resets the field to NULL in case the related model gets deleted. Can only be set if field has null=True set.

field.SET_DEFAULT:

Resets the field to default value in case the related model gets deleted. Can only be set is field has a default set.

field.NO_ACTION:

Take no action.

to_field:

The attribute name on the related model to establish foreign key relationship. If not set, pk is used

db_constraint:

Controls whether or not a constraint should be created in the database for this foreign key. The default is True, and that’s almost certainly what you want; setting this to False can be very bad for data integrity.

tortoise.fields.relational.ManyToManyField(model_name, through=None, forward_key=None, backward_key='', related_name='', on_delete=OnDelete.CASCADE, db_constraint=True, **kwargs)[source]

ManyToMany relation field.

This field represents a many-to-many between this model and another model.

See Many to Many for usage information.

You must provide the following:

model_name:

The name of the related model in a 'app.model' format.

The following is optional:

through:

The DB table that represents the through table. The default is normally safe.

forward_key:

The forward lookup key on the through table. The default is normally safe.

backward_key:

The backward lookup key on the through table. The default is normally safe.

related_name:

The attribute name on the related model to reverse resolve the many to many.

db_constraint:

Controls whether or not a constraint should be created in the database for this foreign key. The default is True, and that’s almost certainly what you want; setting this to False can be very bad for data integrity.

on_delete:
One of:
field.CASCADE:

Indicate that the model should be cascade deleted if related model gets deleted.

field.RESTRICT:

Indicate that the related model delete will be restricted as long as a foreign key points to it.

field.SET_NULL:

Resets the field to NULL in case the related model gets deleted. Can only be set if field has null=True set.

field.SET_DEFAULT:

Resets the field to default value in case the related model gets deleted. Can only be set is field has a default set.

field.NO_ACTION:

Take no action.

Return type:

ManyToManyRelation[Any]

tortoise.fields.relational.OneToOneField(model_name: str, related_name: str | None | False = None, on_delete: OnDelete = CASCADE, db_constraint: bool = True, *, null: True, **kwargs: Any) OneToOneFieldInstance[MODEL] | None[source]
tortoise.fields.relational.OneToOneField(model_name: str, related_name: str | None | False = None, on_delete: OnDelete = CASCADE, db_constraint: bool = True, null: False = False, **kwargs: Any) OneToOneFieldInstance[MODEL]

OneToOne relation field.

This field represents a foreign key relation to another model.

See One to One for usage information.

You must provide the following:

model_name:

The name of the related model in a 'app.model' format.

The following is optional:

related_name:

The attribute name on the related model to reverse resolve the foreign key.

on_delete:
One of:
field.CASCADE:

Indicate that the model should be cascade deleted if related model gets deleted.

field.RESTRICT:

Indicate that the related model delete will be restricted as long as a foreign key points to it.

field.SET_NULL:

Resets the field to NULL in case the related model gets deleted. Can only be set if field has null=True set.

field.SET_DEFAULT:

Resets the field to default value in case the related model gets deleted. Can only be set is field has a default set.

field.NO_ACTION:

Take no action.

to_field:

The attribute name on the related model to establish foreign key relationship. If not set, pk is used

db_constraint:

Controls whether or not a constraint should be created in the database for this foreign key. The default is True, and that’s almost certainly what you want; setting this to False can be very bad for data integrity.

DB Specific Fields

MySQL

class tortoise.contrib.mysql.fields.GeometryField(source_field=None, generated=False, pk=False, null=False, default=None, unique=False, index=False, description=None, model=None, validators=None, **kwargs)[source]

Postgres

class tortoise.contrib.postgres.fields.TSVectorField(source_field=None, generated=False, pk=False, null=False, default=None, unique=False, index=False, description=None, model=None, validators=None, **kwargs)[source]

Extending A Field

It is possible to subclass fields allowing use of arbitrary types as long as they can be represented in a database compatible format. An example of this would be a simple wrapper around the CharField to store and query Enum types.

from enum import Enum
from typing import Type

from tortoise import ConfigurationError
from tortoise.fields import CharField


class EnumField(CharField):
    """
    An example extension to CharField that serializes Enums
    to and from a str representation in the DB.
    """

    def __init__(self, enum_type: Type[Enum], **kwargs):
        super().__init__(128, **kwargs)
        if not issubclass(enum_type, Enum):
            raise ConfigurationError("{} is not a subclass of Enum!".format(enum_type))
        self._enum_type = enum_type

    def to_db_value(self, value: Enum, instance) -> str:
        return value.value

    def to_python_value(self, value: str) -> Enum:
        try:
            return self._enum_type(value)
        except Exception:
            raise ValueError(
                "Database value {} does not exist on Enum {}.".format(value, self._enum_type)
            )

When subclassing, make sure that the to_db_value returns the same type as the superclass (in the case of CharField, that is a str) and that, naturally, to_python_value accepts the same type in the value parameter (also str).