Changelogs » Tortoise-orm



- Extra parameters now get passed through to the MySQL & PostgreSQL drivers


- Fixed SQLite handling of DatetimeField


- Code has been reformatted using ``black``, and minor code cleanups (120 123)
- Sample Quart integration (121)
- Better isolation of connection handling — Allows more dynamic connections so we can do pooling & reconnections.
- Added automatic MySQL connection retry


- Fixed ``.count()`` when a join happens (109)


- Fixed 'unique_together' for foreign keys (114)
- Fixed Field.to_db_value method to handle Enum (113 115 116)


- Added ability to use "unique_together" meta Model option


- Fixed concurrency isolation when attempting to do multiple concurrent operations on a single connection.


- Fixed several convenince issues with foreign relations:

- FIXED: ``.all()`` actually returns the _query property as was documented.
- New models with FK don't automatically fail to resolve any data. They can now be evaluated lazily.

- Some DB's don't support OFFSET without Limit, added caps to signal workaround, which is to automatically add limit of 1000000
- Pylint plugin to know about default `related_name` for ForeignKey fields.
- Simplified capabilities to be static, and defined at class level.


* Added basic DB driver Capabilities.

Test runner now has the ability to skip tests conditionally, based on the DB driver Capabilities:

.. code-block:: python3

async def test_run_sqlite_only(self):

* Added per-field indexes.

When setting `index=True` on a field, Tortoise will now generate an index for it.

.. note::
Due to MySQL limitation of not supporting conditional index creation,
if `safe=True` (the default) is set, it won't create the index and emit a warning about it.

We plan to work around this limitation in a future release.

- Performance fix with PyPika for small fetch queries
- Remove parameter hack now that PyPika support Parametrized queries
- Fix typos in JSONField docstring
- Added `.explain()` method on `QuerySet`.
- Add `required` read-only property to fields


- Added "safe" schema generation
- Correctly convert values to their db representation when using the "in" filter
- Added some common missing field types:

- ``BigIntField``
- ``TimeDeltaField``

- ``BigIntField`` can also be used as a primary key field.


- Test class isolation fixes & contextvars update
- Turned on autocommit for MySQL
- db_url now supports defaults and casting parameters to the right types


- Added `.exclude()` method for QuerySet
- Q objects can now be negated for `NOT` query (`~Q(...)`)
- Support subclassing on existing fields
- Numerous bug fixes
- Removed known broken connection pooling


- Pre-build some query & filters statically, 15-30% speed up for smaller queries.
- Required field params are now positional, so Python and IDE linters will pick up on it easier.
- Filtering also applies DB-specific transforms, Fixes 62
- Fixed recursion error on m2m management with big lists


- Refactor ``Tortoise.init()`` and test runner to not re-create connections per test, so now tests pass when using an SQLite in-memory database
- Can pass event loop to test initializer function: ``initializer(loop=loop)``
- Fix relative URI for SQLite
- Better error message for invalid filter param.
- Better error messages for missing/bad field params.
- ``nose2`` plugin
- Test utilities compatible with ``py.test``


- Uses macros on SQLite driver to minimise syncronisation. ``aiosqlite>=0.7.0``
- Uses prepared statements for insert, large insert performance increase.
- Pre-generate base pypika query object per model, providing general purpose speedup.


- Performance fixes from ``pypika>=0.15.6``
- Significant reduction in object creation time


- Fixed SQLite relative db path and :memory: now also works
- Removed confusing error message for missing db driver dependency
- Added ``aiosqlite`` as a required dependency
- ``execute_script()`` now annotates errors just like ``execute_query()``, to reduce confusion
- Bumped ``aiosqlite>=0.6.0`` for performance fix
- Added ``tortoise.run_async()`` helper function to make smaller scripts easier to run. It cleans up connections automatically.
- SQLite does autocommit by default.


- Fixed atomic decorator to get connection only on function call


- Fixed pre-init queryset objects creation


- Added support for running separate transactions in multidb config


- Changed default app label from 'models' to None
- Fixed ConfigurationError message for wrong connection name


- Set single_connection to True by default, as there is known issues with conection pooling
- Updated documentation


- Fixed M2M manager methods to correctly work with transactions
- Fixed mutating of queryset on select queries


* Refactored ``Tortoise.init()`` to init all connections and discover models from config passed
as argument.

.. caution::
This is a breaking change.

You no longer need to import the models module for discovery,
instead you need to provide an app ⇒ modules map with the init call:

.. code-block:: python3

async def init():
Here we create a SQLite DB using file "db.sqlite3"
also specify the app name of "models"
which contain models from "app.models"
await Tortoise.init(
modules={'models': ['app.models']}
Generate the schema
await Tortoise.generate_schemas()

For more info, please have a look at :ref:`init_app`

- New ``transactions`` module for implicit working with transactions
- Test frameworks overhauled:
- Better performance for test runner, using transactions to keep tests isolated.
- Now depends on an ``initializer()`` and ``finalizer()`` to set up and tear down DB state.
- Exceptions have been further clarified
- Support for CPython 3.7
- Added support for MySQL/MariaDB


- No more asserts, only Tortoise Exceptions
- Fixed PyLint plugin to work with pylint>=2.0.0
- Formalised unittest classes & documented them.
- ``__slots__`` where it was easy to do. (Changes class instances from dicts into tuples, memory savings)


- Fixed backward incompatibility for Python 3.7


- ``JSONField`` is now promoted to a standard field.
- Fixed ``DecimalField`` and ``BooleanField`` to work as expected on SQLite.
- Added ``FloatField``.
- Minimum supported version of PostgreSQL is 9.4
- Added ``.get(...)`` shortcut on query set.
- ``values()`` and ``values_list()`` now converts field values to python types


- Fixed ``through`` parameter honouring for ``ManyToManyField``


* Added support for nested queries for ``values`` and ``values_list``:

.. code-block:: python3

result = await Event.filter('id', 'name', tournament='tournament__name')
result = await Event.filter('id', 'participants__name')

- Fixed ``DatetimeField`` and ``DateField`` to work as expected on SQLite.
- Added ``PyLint`` plugin.
- Added test class to mange DB state for testing isolation.


- Added PostgreSQL ``JSONField``


- Added ``.annotate()`` method and basic aggregation funcs


- Added ``Prefetch`` object


- Added ``contains`` and other filter modifiers.
- Field kwarg ``default`` now accepts functions.


- Immutable QuerySet. ``unique`` flag for fields


* Added schema generation and more options for fields:

.. code-block:: python3

from tortoise import Tortoise
from tortoise.backends.sqlite.client import SqliteClient
from tortoise.utils import generate_schema

client = SqliteClient(db_name)
await client.create_connection()
await generate_schema(client)


* Added filtering and ordering by related models fields:

.. code-block:: python3

await Tournament.filter(
events__name__in=['1', '3']