This PR updates tortoise-orm from 0.13.2 to 0.16.13.
Changelog
### 0.16.13
```
-------
- Default install of ``tortoise-orm`` now installs with no C-dependencies, if you want to use the C accelerators, please do a ``pip install tortoise-orm[accel]`` instead.
- Added ``<instance>.clone()`` method that will create a cloned instance in memory. To persist it you still need to call ``.save()``
- ``.clone()`` will raise a ``ParamsError`` if tortoise can't generate a primary key. In that case do a ``.clone(pk=<newval>)``
- If manually setting the primary key value to ``None`` and the primary key can be automatically generated, this will create a new record. We however still recommend the ``.clone()`` method instead.
- ``.save()`` can be forced to do a create by setting ``force_create=True``
- ``.save()`` can be forced to do an update by setting ``force_update=True``
- Setting ``update_fields`` for a ``.save()`` operation will strongly prefer to do an update if possible
```
### 0.16.12
```
-------
- Make ``Field.default`` effect on db level when generate table
- Add converters instead of importing from pymysql
- Fix postgres BooleanField default value convent
- Fix ``JSONField`` typed in ``pydantic_model_creator``
- Add ``.sql()`` method on ``QuerySet``
```
### 0.16.11
```
-------
- fix: ``sqlite://:memory:`` in Windows thrown ``OSError: [WinError 123]``
- Support ``bulk_create()`` insertion of records with overridden primary key when the primary key is DB-generated
- Add ``queryset.exists()`` and ``Model.exists()``.
- Add model subscription lookup, ``Model[<pkval>]`` that will return the object or raise ``KeyError``
```
### 0.16.10
```
-------
- Fix bad import of ``basestring``
- Better handling of NULL characters in strings. Fixes SQLite, raises better error for PostgreSQL.
- Support ``.group_by()`` with join now
```
### 0.16.9
```
------
- Support ``F`` expression in ``.save()`` now
- ``IntEnumField`` accept valid int value and ``CharEnumField`` accept valid str value
- Pydantic models get created with globally unique identifier
- Leaf-detection to minimize duplicate Pydantic model creation
- Pydantic models with a Primary Key that is also a raw field of a relation is now not hidden when ``exclude_raw_fields=True`` as it is a critically important field
- Raise an informative error when a field is set as nullable and primary key at the same time
- Foreign key id's are now described to have the positive-integer range of the field it is related to
- Fixed prefetching over OneToOne relations
- Fixed ``__contains`` for non-text fields (e.g. ``JSONB``)
```
### 0.16.8
```
------
- Allow ``Q`` expression to function with ``_filter`` parameter on aggregations
- Add manual ``.group_by()`` support
- Fixed regression where ``GROUP BY`` class is missing for an aggregate with a specified order.
```
### 0.16.7
```
------
- Added preliminary support for Python 3.9
- ``TruncationTestCase`` now properly quotes table names when it clears them out.
- Add model signals support
- Added ``app_label`` to ``test initializer(...)`` and ``TORTOISE_TEST_APP`` as test environment variable.
```
### 0.16.6
```
------
.. warning::
This is a security fix release. We recommend everyone update.
Security fixes
^^^^^^^^^^^^^^
- Fixed SQL injection issue in MySQL
- Fixed SQL injection issues in MySQL when using ``contains``, ``starts_with`` or ``ends_with`` filters (and their case-insensitive counterparts)
- Fixed malformed SQL for PostgreSQL and SQLite when using ``contains``, ``starts_with`` or ``ends_with`` filters (and their case-insensitive counterparts)
Other changes
^^^^^^^^^^^^^
* Added support for partial models:
To create a partial model, one can do a ``.only(<fieldnames-as-strings>)`` as part of the QuerySet.
This will create model instances that only have those values fetched.
Persisting changes on the model is allowed only when:
* All the fields you want to update is specified in ``<model>.save(update_fields=[...])``
* You included the Model primary key in the ``.only(...)``
To protect against common mistakes we ensure that errors get raised:
* If you access a field that is not specified, you will get an ``AttributeError``.
* If you do a ``<model>.save()`` a ``IncompleteInstanceError`` will be raised as the model is, as requested, incomplete.
* If you do a ``<model>.save(update_fields=[...])`` and you didn't include the primary key in the ``.only(...)``,
then ``IncompleteInstanceError`` will be raised indicating that updates can't be done without the primary key being known.
* If you do a ``<model>.save(update_fields=[...])`` and one of the fields in ``update_fields`` was not in the ``.only(...)``,
then ``IncompleteInstanceError`` as that field is not available to be updated.
- Fixed bad SQL generation when doing a ``.values()`` query over a Foreign Key
- Added `<model>.update_from_dict({...})` that will mass update values safely from a dictionary
- Fixed processing URL encoded password in connection string
```
### 0.16.5
```
------
* Moved ``Tortoise.describe_model(<MODEL>, ...)`` to ``<MODEL>.describe(...)``
* Deprecated ``Tortoise.describe_model()``
* Fix for ``generate_schemas`` param being ignored in ``tortoise.contrib.quart.register_tortoise``
* Fix join query with `source_field` param
```
### 0.16.4
```
------
* More consistent escaping of db columns, fixes using SQL reserved keywords as field names with a function.
* Fix the aggregates using the wrong side of the join when doing a self-referential aggregation.
* Fix ``F`` funtions wrapped forgetting about ``distinct=True``
```
### 0.16.3
```
------
* Fixed invalid ``var IN ()`` SQL generated using ``__in=`` and ``__not_in`` filters.
* Fix bug with order_by on nested fields
* Fix joining with self by reverse-foreign-key for filtering and annotation
```
### 0.16.2
```
------
* Default ``values()`` & ``values_list()`` now includes annotations.
* Annotations over joins now work correctly with ``values()`` & ``values_list()``
* Ensure ``GROUP BY`` precedes ``HAVING`` to ensure that filtering by aggregates work correctly.
* Fix bug with join query with aggregation
* Cast ``BooleanField`` values correctly on SQLite & MySQL
```
### 0.16.1
```
------
* ``QuerySetSingle`` now has better code completion
* Created Pydantic models will now have the basic validation elements:
* ``required`` is correctly populated for required fields
* ``nullable`` is added to the schema where nulls are accepted
* ``maxLength`` for CharFields
* ``minimum`` & ``maximum`` values for integer fields
To get Pydantic to handle nullable/default fields correctly one should do a ``**user.dict(exclude_unset=True)`` when passing values to a Model class.
* Added ``FastAPI`` helper that is based on the ``starlette`` helper but optionally adds helpers to catch and report with proper error ``DoesNotExist`` and ``IntegrityError`` Tortoise exceptions.
* Allows a Pydantic model to exclude all read-only fields by setting ``exclude_readonly=True`` when calling ``pydantic_model_creator``.
* a Tortoise ``PydanticModel`` now provides two extra helper functions:
* ``from_queryset``: Returns a ``List[PydanticModel]`` which is the format that e.g. FastAPI expects
* ``from_queryset_single``: allows one to avoid calling ``await`` multiple times to get the object and all its related items.
```
### 0.16
```
====
```
### 0.16.0
```
------
.. caution::
**This release drops support for Python 3.6:**
Tortoise ORM now requires a minimum of CPython 3.7
New features:
^^^^^^^^^^^^^
* Model docstrings and ``:`` comments directly preceding Field definitions are now used as docstrings and DDL descriptions.
This is now cleaned and carried as part of the ``docstring`` parameter in ``describe_model(...)``
If one doesn't explicitly specify a Field ``description=`` or Model ``Meta.table_description=`` then we default to the first line as the description.
This is done because a description is submitted to the DB, and needs to be short (depending on DB, 63 chars) in size.
Usage example:
.. code-block:: python3
class Something(Model):
"""
A Docstring.
Some extra info.
"""
A regular comment
name = fields.CharField(max_length=50)
: A docstring comment
chars = fields.CharField(max_length=50, description="Some chars")
: A docstring comment
: Some more detail
blip = fields.CharField(max_length=50)
When looking at the describe model:
{
"description": "A Docstring.",
"docstring": "A Docstring.\n\nSome extra info.",
...
"data_fields": [
{
"name": "name",
...
"description": null,
"docstring": null
},
{
"name": "chars",
...
"description": "Some chars",
"docstring": "A docstring comment"
},
{
"name": "blip",
...
"description": "A docstring comment",
"docstring": "A docstring comment\nSome more detail"
}
]
}
* Early Partial Init of models.
We now have an early init of models, which can be useful when needing Models that are not bound to a DB, but otherwise complete.
e.g. Schema generation without needing to be properly set up.
Usage example:
.. code-block:: python3
Lets say you defined your models in "some/models.py", and "other/ddef.py"
And you are going to use them in the "model" namespace:
Tortoise.init_models(["some.models", "other.ddef"], "models")
Now the models will have relationships built, so introspection of schema will be comprehensive
* Pydantic serialisation.
We now include native support for automatically building a Pydantic model from Tortoise ORM models.
This will correctly model:
* Data Fields
* Relationships (FK/O2O/M2M)
* Callables
At this stage we only suport serialisation, not deserialisation.
For mode information, please see :ref:`contrib_pydantic`
- Allow usage of ``F`` expressions to in annotations. (301)
- Now negative number with ``limit(...)`` and ``offset(...)`` raise ``ParamsError``. (306)
- Allow usage of Function to ``queryset.update()``. (308)
- Add ability to supply ``distinct`` flag to Aggregate (312)
Bugfixes:
^^^^^^^^^
- Fix default type of ``JSONField``
Removals:
^^^^^^^^^
- Removed ``tortoise.aggregation`` as this was deprecated since 0.14.0
- Removed ``start_transaction`` as it has been broken since 0.15.0
- Removed support for Python 3.6 / PyPy-3.6, as it has been broken since 0.15.0
If you still need Python 3.6 support, you can install ``tortoise-orm<0.16`` as we will still backport critical bugfixes to the 0.15 branch for a while.
.. rst-class:: emphasize-children
```
### 0.15.24
```
-------
- Fixed regression where ``GROUP BY`` class is missing for an aggregate with a specified order.
```
### 0.15.23
```
-------
- Fixed SQL injection issue in MySQL
- Fixed SQL injection issues in MySQL when using ``contains``, ``starts_with`` or ``ends_with`` filters (and their case-insensitive counterparts)
- Fixed malformed SQL for PostgreSQL and SQLite when using ``contains``, ``starts_with`` or ``ends_with`` filters (and their case-insensitive counterparts)
```
### 0.15.22
```
-------
* Fix the aggregates using the wrong side of the join when doing a self-referential aggregation.
* Fix for ``generate_schemas`` param being ignored in ``tortoise.contrib.quart.register_tortoise``
```
### 0.15.21
```
-------
* Fixed invalid ``var IN ()`` SQL generated using ``__in=`` and ``__not_in`` filters.
* Fix bug with order_by on nested fields
* Fix joining with self by reverse-foreign-key for filtering and annotation
```
### 0.15.20
```
-------
* Default ``values()`` & ``values_list()`` now includes annotations.
* Annotations over joins now work correctly with ``values()`` & ``values_list()``
* Ensure ``GROUP BY`` precedes ``HAVING`` to ensure that filtering by aggregates work correctly.
* Cast ``BooleanField`` values correctly on SQLite & MySQL
```
### 0.15.19
```
-------
- Fix Function with ``source_field`` option. (311)
```
### 0.15.18
```
-------
- Install on Windows does not require a C compiler any more.
- Fix ``IntegrityError`` with unique field and ``get_or_create``
```
### 0.15.17
```
-------
- Now ``get_or_none(...)``, classmethod of ``Model`` class, works in the same way as ``queryset``
```
### 0.15.16
```
-------
- ``get_or_none(...)`` now raises ``MultipleObjectsReturned`` if multiple object fetched. (298)
```
### 0.15.15
```
-------
- Add ability to suppply a ``to_field=`` parameter for FK/O2O to a non-PK but still uniquely indexed remote field. (287)
```
### 0.15.14
```
-------
- add F expression support in ``queryset.update()`` - This allows for atomic updates of data in the database. (294)
```
### 0.15.13
```
-------
- Applies default ordering on related queries
- Fix post-ManyToMany related queries not being evaluated correctly
- Ordering is now preserved on ManyToMany related fetches
- Fix aggregate function on joined table to use correct primary key
- Fix filtering by backwards FK to use correct primary key
```
### 0.15.12
```
-------
- Added ``range`` filter to support ``between and`` syntax
```
### 0.15.11
```
-------
- Added ``ordering`` option for model ``Meta`` class to apply default ordering
```
### 0.15.10
```
-------
- Bumped requirements to cater for newer feature use (282)
```
### 0.15.9
```
------
- Alias Foreign Key joins as we can have both self-referencing and duplicate joins to the same table.
This generates SQL that differentiates between which instance of the table to work with.
```
### 0.15.8
```
------
- ``TextField`` now recommends usage of ``CharField`` if wanting unique indexing instead of just saying "indexing not supported"
- ``.count()`` now honours offset and limit
- Testing un-awaited ``ForeignKeyField`` as a boolean expression will automatically resolve as ``False`` if it is None
- Awaiting a nullable ``ForeignKeyField`` won't touch the DB if it is ``None``
```
### 0.15.7
```
------
- ``QuerySet.Update()`` now returns the count of the no of rows affected. Note, that
- ``QuerySet.Delete()`` now returns the count of the no of rows deleted.
- Note that internal API of ``db_connection.execute_query()`` now returns ``rows_affected, results``. (This is informational only)
- Added ``get_or_none(...)`` as syntactic sugar for ``filter(...).first()``
```
### 0.15.6
```
------
- Added ``BinaryField`` for storing binary objects (``bytes``).
- Changed ``TextField`` to use ``LONGTEXT`` for MySQL to allow for larger than 64KB of text.
- De-duplicate index if specified on both ``index=true`` and as part of ``indexes``
- Primary Keyed ``TextField`` is marked as deprecated.
We can't guarnatee that it will be properly indexed or unique in all cases.
- One can now disable the backwards relation for FK/O2O relations by passing ``related_name=False``
- One can now pass a PK value to a generated field, and Tortoise ORM will use that as the PK as expected.
This allows one to have a model that has a autonumber PK, but setting it explicitly if required.
```
### 0.15.5
```
------
* Refactored Fields:
Fields have been refactored, for better maintenance. There should be no change for most users.
- More accurate auto-completion.
- Fields now contain their own SQL schema by dialect, which significantly simplifies adding field types.
- ``describe_model()`` now returns the DB type, and dialect overrides.
- ``JSONField`` will now automatically use ``python-rapidjson`` as an accelerator if it is available.
- ``DecimalField`` and aggregations on it, now behaves much more like expected on SQLite (256)
- Check whether charset name is valid for the MySQL connection (261)
- Default DB driver parameters are now applied consistently, if you use the URI schema or manual.
```
### 0.15.4
```
------
- Don't generate a schema if there is no models (254)
- Emit a ``RuntimeWarning`` when a module has no models to import (254)
- Allow passing in a custom SSL context (255)
```
### 0.15.3
```
------
* Added ``OneToOneField`` implementation:
``OneToOneField`` describes a one to one relation between two models.
It can be set from the primary side only, but resolved from both sides in the same way.
``describe_model(...)`` now also reports OneToOne relations in both directions.
Usage example:
.. code-block:: python3
event: fields.OneToOneRelation[Event] = fields.OneToOneField(
"models.Event", on_delete=fields.CASCADE, related_name="address"
)
- Prefetching is done concurrently now, sending all prefetch requests at the same time instead of in sequence.
- Enabe foreign key enforcement on SQLite for builds where it was optional.
```
### 0.15.2
```
------
- The ``auto_now_add`` argument of ``DatetimeField`` is handled correctly in the SQLite backend.
- ``unique_together`` now creates named constrains, to prevent the DB from auto-assigning a potentially non-unique constraint name.
- Filtering by an ``auto_now`` field doesn't replace the filter value with ``now()`` anymore.
```
### 0.15.1
```
------
- Handle OR'ing a blank ``Q()`` correctly (240)
```
### 0.15
```
====
```
### 0.15.0
```
-------
New features:
^^^^^^^^^^^^^
- Pooling has been implemented, allowing for multiple concurrent databases and all the benefits that comes with it.
- Enabled by default for databases that support it (mysql and postgres) with a minimum pool size of 1, and a maximum of 5
- Not supported by sqlite
- Can be changed by passing the ``minsize`` and ``maxsize`` connection parameters
- Many small performance tweaks:
- Overhead of query generation has been reduced by about 6%
- Bulk inserts are ensured to be wrapped in a transaction for >50% speedup
- PostgreSQL prepared queries now use a LRU cache for significant >2x speedup on inserts/updates/deletes
- ``DateField`` & ``DatetimeField`` deserializes faster on PostgreSQL & MySQL.
- Optimized ``.values()`` to do less copying, resulting in a slight speedup.
- One can now pass kwargs and ``Q()`` objects as parameters to ``Q()`` objects simultaneously.
Bugfixes:
^^^^^^^^^
- ``indexes`` will correctly map the foreign key if referenced by name.
- Setting DB generated PK in constructor/create generates exception instead of silently being ignored.
Deprecations:
^^^^^^^^^^^^^
- ``start_transaction`` is deprecated, please use ``atomic()`` or ``async with in_transaction():`` instead.
- **This release brings with it, deprecation of Python 3.6 / PyPy-3.6:**
This is due to small differences with how the backported ``aiocontextvars`` behaves
in comparison to the built-in in Python 3.7+.
There is a known context confusion, specifically regarding nested transactions.
.. rst-class:: emphasize-children
```
### 0.14.2
```
------
- A Field name of ``alias`` is now no longer reserved.
- Restored support for inheriting from Abstract classes. Order is now also deterministic,
with the inherited classes' fields being placed before the current.
```
### 0.14.1
```
-------
- ``ManyToManyField`` is now a function that has the type of the relation for autocomplete,
this allows for better type hinting at less effort.
- Added section on adding better autocomplete for relations in editors.
```
### 0.14
```
====
```
### 0.14.0
```
------
.. caution::
**This release drops support of Python 3.5:**
Tortoise ORM now requires a minimum of CPython 3.6 or PyPy3.6-7.1
Enhancements:
^^^^^^^^^^^^^
- Models, Fields & QuerySets have significant type annotation improvements,
leading to better IDE integration and more comprehensive static analysis.
- Fetching records from the DB is now up to 25% faster.
- Database functions ``Trim()``, ``Length()``, ``Coalesce()``, ``Lower()``, ``Upper()`` added to tortoise.functions module.
- Annotations can be selected inside ``Queryset.values()`` and ``Queryset.values_list()`` expressions.
- Added support for Python 3.8
- The Foreign Key property is now ``await``-able as long as one didn't populate it via ``.prefetch_related()``
- One can now specify compound indexes in the ``Meta:`` class using ``indexes``. It works just like ``unique_toghether``.
Bugfixes:
^^^^^^^^^
- The generated index name now has significantly lower chance of collision.
- The compiled SQL query contains HAVING and GROUP BY only for aggregation functions.
- Fields for FK relations are quoted properly.
- Fields are quoted properly in ``UNIQUE`` statements.
- Fields are quoted properly in ``KEY`` statements.
- Comment Fields are quoted properly in PostgreSQL dialect.
- ``unique_together`` will correctly map the foreign key if referenced by name.
Deprecations:
^^^^^^^^^^^^^
- ``import from tortoise.aggregation`` is deprecated, please do ``import from tortoise.functions`` instead.
Breaking Changes:
^^^^^^^^^^^^^^^^^
- The hash used to make generated indexes unique has changed.
The old algorithm had a very high chance of collisions,
the new hash algorithm is much better in this regard.
- Dropped support for Python 3.5
.. rst-class:: emphasize-children
```
### 0.13.12
```
-------
- Reverted "The ``Field`` class now calls ``super().__init__``, so mixins are properly initialised."
as it was causing issues on Python 3.6.
```
### 0.13.11
```
-------
- Fixed the ``_FieldMeta`` class not to checking if the 1st base class was Field, so would break with mixins.
- The ``Field`` class now calls ``super().__init__``, so mixins are properly initialised.
```
### 0.13.10
```
-------
- Names ForeignKey constraints in a consistent way
```
### 0.13.9
```
------
- Fields can have 2nd base class which makes IDEs know python type (str, int, datetime...) of the field.
- The ``type`` parameter of ``Field.__init__`` is removed, instead we use the 2nd base class
- Foreign keys and indexes are now defined correctly in MySQL so that they take effect as expected
- MySQL now doesn't warn of unsafe index creation anymore
```
### 0.13.8
```
------
- Fixed bug in schema creation for MySQL where non-int PK did not get declared properly (195)
```
### 0.13.7
```
------
- ``iexact`` filter modifier was implemented. Queries like ``«queryset».filter(name__iexact=...)`` will perform case-insensitive search.
```
### 0.13.6
```
------
- Fix minor bug in ``Model.__init__`` where we raise the wrong error on setting RFK/M2M values directly.
- Fields in ``Queryset.values_list()`` is now in the defined Model order.
- Fields in ``Queryset.values()`` is now in the defined Model order.
```
### 0.13.5
```
------
- Sample Starlette integration
- Relational fields are now lazily constructed via properties instead of in the constructor,
this results in a significant overhead reduction for Model instantiation with many relationships.
```
### 0.13.4
```
------
- Assigning to the FK field will correctly set the associated db-field
- Reading a nullalble FK field can now be None
- Nullalble FK fields reverse-FK is now also nullable
- Deleting a nullable FK field sets it to None
```
### 0.13.3
```
------
- Fixed installing Tortoise-ORM in non-unicode systems. (180)
- ``«queryset».update(…)`` now correctly uses the DB-specific ``to_db_value()``
- ``fetch_related(…)`` now correctly encodes non-integer keys.
- ``ForeignKey`` fields of type ``UUIDField`` are now escaped consistently.
- Pre-generated ForeignKey fields (e.g. UUIDField) is now checked for persistence correctly.
- Duplicate M2M ``.add(…)`` now checks using consistent field encoding.
- ``source_field`` Fields are now handled correctly for ordering.
- ``source_field`` Fields are now handled correctly for updating.
```
Links
- PyPI: https://pypi.org/project/tortoise-orm
- Changelog: https://pyup.io/changelogs/tortoise-orm/
- Repo: https://github.com/tortoise/tortoise-orm
This PR updates tortoise-orm from 0.13.2 to 0.16.13.
Changelog
### 0.16.13 ``` ------- - Default install of ``tortoise-orm`` now installs with no C-dependencies, if you want to use the C accelerators, please do a ``pip install tortoise-orm[accel]`` instead. - Added ``<instance>.clone()`` method that will create a cloned instance in memory. To persist it you still need to call ``.save()`` - ``.clone()`` will raise a ``ParamsError`` if tortoise can't generate a primary key. In that case do a ``.clone(pk=<newval>)`` - If manually setting the primary key value to ``None`` and the primary key can be automatically generated, this will create a new record. We however still recommend the ``.clone()`` method instead. - ``.save()`` can be forced to do a create by setting ``force_create=True`` - ``.save()`` can be forced to do an update by setting ``force_update=True`` - Setting ``update_fields`` for a ``.save()`` operation will strongly prefer to do an update if possible ``` ### 0.16.12 ``` ------- - Make ``Field.default`` effect on db level when generate table - Add converters instead of importing from pymysql - Fix postgres BooleanField default value convent - Fix ``JSONField`` typed in ``pydantic_model_creator`` - Add ``.sql()`` method on ``QuerySet`` ``` ### 0.16.11 ``` ------- - fix: ``sqlite://:memory:`` in Windows thrown ``OSError: [WinError 123]`` - Support ``bulk_create()`` insertion of records with overridden primary key when the primary key is DB-generated - Add ``queryset.exists()`` and ``Model.exists()``. - Add model subscription lookup, ``Model[<pkval>]`` that will return the object or raise ``KeyError`` ``` ### 0.16.10 ``` ------- - Fix bad import of ``basestring`` - Better handling of NULL characters in strings. Fixes SQLite, raises better error for PostgreSQL. - Support ``.group_by()`` with join now ``` ### 0.16.9 ``` ------ - Support ``F`` expression in ``.save()`` now - ``IntEnumField`` accept valid int value and ``CharEnumField`` accept valid str value - Pydantic models get created with globally unique identifier - Leaf-detection to minimize duplicate Pydantic model creation - Pydantic models with a Primary Key that is also a raw field of a relation is now not hidden when ``exclude_raw_fields=True`` as it is a critically important field - Raise an informative error when a field is set as nullable and primary key at the same time - Foreign key id's are now described to have the positive-integer range of the field it is related to - Fixed prefetching over OneToOne relations - Fixed ``__contains`` for non-text fields (e.g. ``JSONB``) ``` ### 0.16.8 ``` ------ - Allow ``Q`` expression to function with ``_filter`` parameter on aggregations - Add manual ``.group_by()`` support - Fixed regression where ``GROUP BY`` class is missing for an aggregate with a specified order. ``` ### 0.16.7 ``` ------ - Added preliminary support for Python 3.9 - ``TruncationTestCase`` now properly quotes table names when it clears them out. - Add model signals support - Added ``app_label`` to ``test initializer(...)`` and ``TORTOISE_TEST_APP`` as test environment variable. ``` ### 0.16.6 ``` ------ .. warning:: This is a security fix release. We recommend everyone update. Security fixes ^^^^^^^^^^^^^^ - Fixed SQL injection issue in MySQL - Fixed SQL injection issues in MySQL when using ``contains``, ``starts_with`` or ``ends_with`` filters (and their case-insensitive counterparts) - Fixed malformed SQL for PostgreSQL and SQLite when using ``contains``, ``starts_with`` or ``ends_with`` filters (and their case-insensitive counterparts) Other changes ^^^^^^^^^^^^^ * Added support for partial models: To create a partial model, one can do a ``.only(<fieldnames-as-strings>)`` as part of the QuerySet. This will create model instances that only have those values fetched. Persisting changes on the model is allowed only when: * All the fields you want to update is specified in ``<model>.save(update_fields=[...])`` * You included the Model primary key in the ``.only(...)`` To protect against common mistakes we ensure that errors get raised: * If you access a field that is not specified, you will get an ``AttributeError``. * If you do a ``<model>.save()`` a ``IncompleteInstanceError`` will be raised as the model is, as requested, incomplete. * If you do a ``<model>.save(update_fields=[...])`` and you didn't include the primary key in the ``.only(...)``, then ``IncompleteInstanceError`` will be raised indicating that updates can't be done without the primary key being known. * If you do a ``<model>.save(update_fields=[...])`` and one of the fields in ``update_fields`` was not in the ``.only(...)``, then ``IncompleteInstanceError`` as that field is not available to be updated. - Fixed bad SQL generation when doing a ``.values()`` query over a Foreign Key - Added `<model>.update_from_dict({...})` that will mass update values safely from a dictionary - Fixed processing URL encoded password in connection string ``` ### 0.16.5 ``` ------ * Moved ``Tortoise.describe_model(<MODEL>, ...)`` to ``<MODEL>.describe(...)`` * Deprecated ``Tortoise.describe_model()`` * Fix for ``generate_schemas`` param being ignored in ``tortoise.contrib.quart.register_tortoise`` * Fix join query with `source_field` param ``` ### 0.16.4 ``` ------ * More consistent escaping of db columns, fixes using SQL reserved keywords as field names with a function. * Fix the aggregates using the wrong side of the join when doing a self-referential aggregation. * Fix ``F`` funtions wrapped forgetting about ``distinct=True`` ``` ### 0.16.3 ``` ------ * Fixed invalid ``var IN ()`` SQL generated using ``__in=`` and ``__not_in`` filters. * Fix bug with order_by on nested fields * Fix joining with self by reverse-foreign-key for filtering and annotation ``` ### 0.16.2 ``` ------ * Default ``values()`` & ``values_list()`` now includes annotations. * Annotations over joins now work correctly with ``values()`` & ``values_list()`` * Ensure ``GROUP BY`` precedes ``HAVING`` to ensure that filtering by aggregates work correctly. * Fix bug with join query with aggregation * Cast ``BooleanField`` values correctly on SQLite & MySQL ``` ### 0.16.1 ``` ------ * ``QuerySetSingle`` now has better code completion * Created Pydantic models will now have the basic validation elements: * ``required`` is correctly populated for required fields * ``nullable`` is added to the schema where nulls are accepted * ``maxLength`` for CharFields * ``minimum`` & ``maximum`` values for integer fields To get Pydantic to handle nullable/default fields correctly one should do a ``**user.dict(exclude_unset=True)`` when passing values to a Model class. * Added ``FastAPI`` helper that is based on the ``starlette`` helper but optionally adds helpers to catch and report with proper error ``DoesNotExist`` and ``IntegrityError`` Tortoise exceptions. * Allows a Pydantic model to exclude all read-only fields by setting ``exclude_readonly=True`` when calling ``pydantic_model_creator``. * a Tortoise ``PydanticModel`` now provides two extra helper functions: * ``from_queryset``: Returns a ``List[PydanticModel]`` which is the format that e.g. FastAPI expects * ``from_queryset_single``: allows one to avoid calling ``await`` multiple times to get the object and all its related items. ``` ### 0.16 ``` ==== ``` ### 0.16.0 ``` ------ .. caution:: **This release drops support for Python 3.6:** Tortoise ORM now requires a minimum of CPython 3.7 New features: ^^^^^^^^^^^^^ * Model docstrings and ``:`` comments directly preceding Field definitions are now used as docstrings and DDL descriptions. This is now cleaned and carried as part of the ``docstring`` parameter in ``describe_model(...)`` If one doesn't explicitly specify a Field ``description=`` or Model ``Meta.table_description=`` then we default to the first line as the description. This is done because a description is submitted to the DB, and needs to be short (depending on DB, 63 chars) in size. Usage example: .. code-block:: python3 class Something(Model): """ A Docstring. Some extra info. """ A regular comment name = fields.CharField(max_length=50) : A docstring comment chars = fields.CharField(max_length=50, description="Some chars") : A docstring comment : Some more detail blip = fields.CharField(max_length=50) When looking at the describe model: { "description": "A Docstring.", "docstring": "A Docstring.\n\nSome extra info.", ... "data_fields": [ { "name": "name", ... "description": null, "docstring": null }, { "name": "chars", ... "description": "Some chars", "docstring": "A docstring comment" }, { "name": "blip", ... "description": "A docstring comment", "docstring": "A docstring comment\nSome more detail" } ] } * Early Partial Init of models. We now have an early init of models, which can be useful when needing Models that are not bound to a DB, but otherwise complete. e.g. Schema generation without needing to be properly set up. Usage example: .. code-block:: python3 Lets say you defined your models in "some/models.py", and "other/ddef.py" And you are going to use them in the "model" namespace: Tortoise.init_models(["some.models", "other.ddef"], "models") Now the models will have relationships built, so introspection of schema will be comprehensive * Pydantic serialisation. We now include native support for automatically building a Pydantic model from Tortoise ORM models. This will correctly model: * Data Fields * Relationships (FK/O2O/M2M) * Callables At this stage we only suport serialisation, not deserialisation. For mode information, please see :ref:`contrib_pydantic` - Allow usage of ``F`` expressions to in annotations. (301) - Now negative number with ``limit(...)`` and ``offset(...)`` raise ``ParamsError``. (306) - Allow usage of Function to ``queryset.update()``. (308) - Add ability to supply ``distinct`` flag to Aggregate (312) Bugfixes: ^^^^^^^^^ - Fix default type of ``JSONField`` Removals: ^^^^^^^^^ - Removed ``tortoise.aggregation`` as this was deprecated since 0.14.0 - Removed ``start_transaction`` as it has been broken since 0.15.0 - Removed support for Python 3.6 / PyPy-3.6, as it has been broken since 0.15.0 If you still need Python 3.6 support, you can install ``tortoise-orm<0.16`` as we will still backport critical bugfixes to the 0.15 branch for a while. .. rst-class:: emphasize-children ``` ### 0.15.24 ``` ------- - Fixed regression where ``GROUP BY`` class is missing for an aggregate with a specified order. ``` ### 0.15.23 ``` ------- - Fixed SQL injection issue in MySQL - Fixed SQL injection issues in MySQL when using ``contains``, ``starts_with`` or ``ends_with`` filters (and their case-insensitive counterparts) - Fixed malformed SQL for PostgreSQL and SQLite when using ``contains``, ``starts_with`` or ``ends_with`` filters (and their case-insensitive counterparts) ``` ### 0.15.22 ``` ------- * Fix the aggregates using the wrong side of the join when doing a self-referential aggregation. * Fix for ``generate_schemas`` param being ignored in ``tortoise.contrib.quart.register_tortoise`` ``` ### 0.15.21 ``` ------- * Fixed invalid ``var IN ()`` SQL generated using ``__in=`` and ``__not_in`` filters. * Fix bug with order_by on nested fields * Fix joining with self by reverse-foreign-key for filtering and annotation ``` ### 0.15.20 ``` ------- * Default ``values()`` & ``values_list()`` now includes annotations. * Annotations over joins now work correctly with ``values()`` & ``values_list()`` * Ensure ``GROUP BY`` precedes ``HAVING`` to ensure that filtering by aggregates work correctly. * Cast ``BooleanField`` values correctly on SQLite & MySQL ``` ### 0.15.19 ``` ------- - Fix Function with ``source_field`` option. (311) ``` ### 0.15.18 ``` ------- - Install on Windows does not require a C compiler any more. - Fix ``IntegrityError`` with unique field and ``get_or_create`` ``` ### 0.15.17 ``` ------- - Now ``get_or_none(...)``, classmethod of ``Model`` class, works in the same way as ``queryset`` ``` ### 0.15.16 ``` ------- - ``get_or_none(...)`` now raises ``MultipleObjectsReturned`` if multiple object fetched. (298) ``` ### 0.15.15 ``` ------- - Add ability to suppply a ``to_field=`` parameter for FK/O2O to a non-PK but still uniquely indexed remote field. (287) ``` ### 0.15.14 ``` ------- - add F expression support in ``queryset.update()`` - This allows for atomic updates of data in the database. (294) ``` ### 0.15.13 ``` ------- - Applies default ordering on related queries - Fix post-ManyToMany related queries not being evaluated correctly - Ordering is now preserved on ManyToMany related fetches - Fix aggregate function on joined table to use correct primary key - Fix filtering by backwards FK to use correct primary key ``` ### 0.15.12 ``` ------- - Added ``range`` filter to support ``between and`` syntax ``` ### 0.15.11 ``` ------- - Added ``ordering`` option for model ``Meta`` class to apply default ordering ``` ### 0.15.10 ``` ------- - Bumped requirements to cater for newer feature use (282) ``` ### 0.15.9 ``` ------ - Alias Foreign Key joins as we can have both self-referencing and duplicate joins to the same table. This generates SQL that differentiates between which instance of the table to work with. ``` ### 0.15.8 ``` ------ - ``TextField`` now recommends usage of ``CharField`` if wanting unique indexing instead of just saying "indexing not supported" - ``.count()`` now honours offset and limit - Testing un-awaited ``ForeignKeyField`` as a boolean expression will automatically resolve as ``False`` if it is None - Awaiting a nullable ``ForeignKeyField`` won't touch the DB if it is ``None`` ``` ### 0.15.7 ``` ------ - ``QuerySet.Update()`` now returns the count of the no of rows affected. Note, that - ``QuerySet.Delete()`` now returns the count of the no of rows deleted. - Note that internal API of ``db_connection.execute_query()`` now returns ``rows_affected, results``. (This is informational only) - Added ``get_or_none(...)`` as syntactic sugar for ``filter(...).first()`` ``` ### 0.15.6 ``` ------ - Added ``BinaryField`` for storing binary objects (``bytes``). - Changed ``TextField`` to use ``LONGTEXT`` for MySQL to allow for larger than 64KB of text. - De-duplicate index if specified on both ``index=true`` and as part of ``indexes`` - Primary Keyed ``TextField`` is marked as deprecated. We can't guarnatee that it will be properly indexed or unique in all cases. - One can now disable the backwards relation for FK/O2O relations by passing ``related_name=False`` - One can now pass a PK value to a generated field, and Tortoise ORM will use that as the PK as expected. This allows one to have a model that has a autonumber PK, but setting it explicitly if required. ``` ### 0.15.5 ``` ------ * Refactored Fields: Fields have been refactored, for better maintenance. There should be no change for most users. - More accurate auto-completion. - Fields now contain their own SQL schema by dialect, which significantly simplifies adding field types. - ``describe_model()`` now returns the DB type, and dialect overrides. - ``JSONField`` will now automatically use ``python-rapidjson`` as an accelerator if it is available. - ``DecimalField`` and aggregations on it, now behaves much more like expected on SQLite (256) - Check whether charset name is valid for the MySQL connection (261) - Default DB driver parameters are now applied consistently, if you use the URI schema or manual. ``` ### 0.15.4 ``` ------ - Don't generate a schema if there is no models (254) - Emit a ``RuntimeWarning`` when a module has no models to import (254) - Allow passing in a custom SSL context (255) ``` ### 0.15.3 ``` ------ * Added ``OneToOneField`` implementation: ``OneToOneField`` describes a one to one relation between two models. It can be set from the primary side only, but resolved from both sides in the same way. ``describe_model(...)`` now also reports OneToOne relations in both directions. Usage example: .. code-block:: python3 event: fields.OneToOneRelation[Event] = fields.OneToOneField( "models.Event", on_delete=fields.CASCADE, related_name="address" ) - Prefetching is done concurrently now, sending all prefetch requests at the same time instead of in sequence. - Enabe foreign key enforcement on SQLite for builds where it was optional. ``` ### 0.15.2 ``` ------ - The ``auto_now_add`` argument of ``DatetimeField`` is handled correctly in the SQLite backend. - ``unique_together`` now creates named constrains, to prevent the DB from auto-assigning a potentially non-unique constraint name. - Filtering by an ``auto_now`` field doesn't replace the filter value with ``now()`` anymore. ``` ### 0.15.1 ``` ------ - Handle OR'ing a blank ``Q()`` correctly (240) ``` ### 0.15 ``` ==== ``` ### 0.15.0 ``` ------- New features: ^^^^^^^^^^^^^ - Pooling has been implemented, allowing for multiple concurrent databases and all the benefits that comes with it. - Enabled by default for databases that support it (mysql and postgres) with a minimum pool size of 1, and a maximum of 5 - Not supported by sqlite - Can be changed by passing the ``minsize`` and ``maxsize`` connection parameters - Many small performance tweaks: - Overhead of query generation has been reduced by about 6% - Bulk inserts are ensured to be wrapped in a transaction for >50% speedup - PostgreSQL prepared queries now use a LRU cache for significant >2x speedup on inserts/updates/deletes - ``DateField`` & ``DatetimeField`` deserializes faster on PostgreSQL & MySQL. - Optimized ``.values()`` to do less copying, resulting in a slight speedup. - One can now pass kwargs and ``Q()`` objects as parameters to ``Q()`` objects simultaneously. Bugfixes: ^^^^^^^^^ - ``indexes`` will correctly map the foreign key if referenced by name. - Setting DB generated PK in constructor/create generates exception instead of silently being ignored. Deprecations: ^^^^^^^^^^^^^ - ``start_transaction`` is deprecated, please use ``atomic()`` or ``async with in_transaction():`` instead. - **This release brings with it, deprecation of Python 3.6 / PyPy-3.6:** This is due to small differences with how the backported ``aiocontextvars`` behaves in comparison to the built-in in Python 3.7+. There is a known context confusion, specifically regarding nested transactions. .. rst-class:: emphasize-children ``` ### 0.14.2 ``` ------ - A Field name of ``alias`` is now no longer reserved. - Restored support for inheriting from Abstract classes. Order is now also deterministic, with the inherited classes' fields being placed before the current. ``` ### 0.14.1 ``` ------- - ``ManyToManyField`` is now a function that has the type of the relation for autocomplete, this allows for better type hinting at less effort. - Added section on adding better autocomplete for relations in editors. ``` ### 0.14 ``` ==== ``` ### 0.14.0 ``` ------ .. caution:: **This release drops support of Python 3.5:** Tortoise ORM now requires a minimum of CPython 3.6 or PyPy3.6-7.1 Enhancements: ^^^^^^^^^^^^^ - Models, Fields & QuerySets have significant type annotation improvements, leading to better IDE integration and more comprehensive static analysis. - Fetching records from the DB is now up to 25% faster. - Database functions ``Trim()``, ``Length()``, ``Coalesce()``, ``Lower()``, ``Upper()`` added to tortoise.functions module. - Annotations can be selected inside ``Queryset.values()`` and ``Queryset.values_list()`` expressions. - Added support for Python 3.8 - The Foreign Key property is now ``await``-able as long as one didn't populate it via ``.prefetch_related()`` - One can now specify compound indexes in the ``Meta:`` class using ``indexes``. It works just like ``unique_toghether``. Bugfixes: ^^^^^^^^^ - The generated index name now has significantly lower chance of collision. - The compiled SQL query contains HAVING and GROUP BY only for aggregation functions. - Fields for FK relations are quoted properly. - Fields are quoted properly in ``UNIQUE`` statements. - Fields are quoted properly in ``KEY`` statements. - Comment Fields are quoted properly in PostgreSQL dialect. - ``unique_together`` will correctly map the foreign key if referenced by name. Deprecations: ^^^^^^^^^^^^^ - ``import from tortoise.aggregation`` is deprecated, please do ``import from tortoise.functions`` instead. Breaking Changes: ^^^^^^^^^^^^^^^^^ - The hash used to make generated indexes unique has changed. The old algorithm had a very high chance of collisions, the new hash algorithm is much better in this regard. - Dropped support for Python 3.5 .. rst-class:: emphasize-children ``` ### 0.13.12 ``` ------- - Reverted "The ``Field`` class now calls ``super().__init__``, so mixins are properly initialised." as it was causing issues on Python 3.6. ``` ### 0.13.11 ``` ------- - Fixed the ``_FieldMeta`` class not to checking if the 1st base class was Field, so would break with mixins. - The ``Field`` class now calls ``super().__init__``, so mixins are properly initialised. ``` ### 0.13.10 ``` ------- - Names ForeignKey constraints in a consistent way ``` ### 0.13.9 ``` ------ - Fields can have 2nd base class which makes IDEs know python type (str, int, datetime...) of the field. - The ``type`` parameter of ``Field.__init__`` is removed, instead we use the 2nd base class - Foreign keys and indexes are now defined correctly in MySQL so that they take effect as expected - MySQL now doesn't warn of unsafe index creation anymore ``` ### 0.13.8 ``` ------ - Fixed bug in schema creation for MySQL where non-int PK did not get declared properly (195) ``` ### 0.13.7 ``` ------ - ``iexact`` filter modifier was implemented. Queries like ``«queryset».filter(name__iexact=...)`` will perform case-insensitive search. ``` ### 0.13.6 ``` ------ - Fix minor bug in ``Model.__init__`` where we raise the wrong error on setting RFK/M2M values directly. - Fields in ``Queryset.values_list()`` is now in the defined Model order. - Fields in ``Queryset.values()`` is now in the defined Model order. ``` ### 0.13.5 ``` ------ - Sample Starlette integration - Relational fields are now lazily constructed via properties instead of in the constructor, this results in a significant overhead reduction for Model instantiation with many relationships. ``` ### 0.13.4 ``` ------ - Assigning to the FK field will correctly set the associated db-field - Reading a nullalble FK field can now be None - Nullalble FK fields reverse-FK is now also nullable - Deleting a nullable FK field sets it to None ``` ### 0.13.3 ``` ------ - Fixed installing Tortoise-ORM in non-unicode systems. (180) - ``«queryset».update(…)`` now correctly uses the DB-specific ``to_db_value()`` - ``fetch_related(…)`` now correctly encodes non-integer keys. - ``ForeignKey`` fields of type ``UUIDField`` are now escaped consistently. - Pre-generated ForeignKey fields (e.g. UUIDField) is now checked for persistence correctly. - Duplicate M2M ``.add(…)`` now checks using consistent field encoding. - ``source_field`` Fields are now handled correctly for ordering. - ``source_field`` Fields are now handled correctly for updating. ```Links
- PyPI: https://pypi.org/project/tortoise-orm - Changelog: https://pyup.io/changelogs/tortoise-orm/ - Repo: https://github.com/tortoise/tortoise-orm