3.14.0
This release has been a bit overdue and there are numerous small improvements
and bug-fixes. The bugfix that prompted this release is 2293, which is a
regression in the Django-inspired .filter() APIs that could cause some
filter expressions to be discarded from the generated SQL. Many thanks for the
excellent bug report, Jakub.
Add an experimental helper, shortcuts.resolve_multimodel_query(), for resolving multiple models used in a compound select query.
Add a lateral() method to select query for use with lateral joins.
Added support for nested transactions (savepoints) in cockroach-db (requires 20.1 or newer).
Automatically escape wildcards passed to string-matching methods.
Allow index-type to be specified on MySQL.
Added a new API, converter() to be used for specifying a function to use to convert a row-value pulled off the cursor.
Add set() and clear() method to the bitfield flag descriptor.
Add support for range types with IN and other expressions.
Support CTEs bound to compound select queries.
Bug-fixes
Fix to return related object id when accessing via the object-id descriptor, when the related object is not populated.
Fix to ensure we do not insert a NULL value for a primary key.
Fix to conditionally set the field/column on an added column in a migration.
Apply field conversion logic to model-class values.
Clone node before modifying it to be flat in an enclosed nodelist expr.
Fix an invalid item assignment in nodelist.
Fix an incorrect truthiness check used with save() and only=.
Fix regression in filter() where using both *args and **kwargs caused the expressions passed as args to be discarded.
Thes are not supported by pkg_alternatives, and lead to breakage as found
in <http://mail-index.netbsd.org/tech-pkg/2020/05/06/msg023089.html>.
In many cases these were unnecessary anyway, as they match the corresponding
command that pkg_alternatives will have automatically detected manual page
entries for, plus many of them did not support PKGMANDIR.
In the one case (databases/py-peewee) where the manual page does not match
the command name, pkg_alternatives will need to be enhanced to support this
before it can be re-enabled.
3.13.3
Allow arbitrary keyword arguments to be passed to DataSet constructor, which are then passed to the instrospector.
Allow scalar subqueries to be compared using numeric operands.
Fix bulk_create() when model being inserted uses FK identifiers.
Fix bulk_update() so that PK values are properly coerced to the right data-type (e.g. UUIDs to strings for Sqlite).
Allow array indices to be used as dict keys, e.g. for the purposes of updating a single array index value.
3.13.2
* Allow aggregate functions to support an `ORDER BY` clause, via the addition
of an `order_by()` method to the function (`fn`) instance.
* Fix `prefetch()` bug, where related "backref" instances were marked as dirty,
even though they had no changes.
* Support `LIMIT 0`. Previously a limit of 0 would be translated into
effectively an unlimited query on MySQL.
* Support indexing into arrays using expressions with Postgres array fields.
* Ensure postgres introspection methods return the columns for multi-column
indexes in the correct order.
* Add support for arrays of UUIDs to postgres introspection.
* Fix introspection of columns w/capitalized table names in postgres.
* Fix to ensure correct exception is raised in SqliteQueueDatabase when
iterating over cursor/result-set.
* Fix bug comparing subquery against a scalar value.
* Fix issue resolving composite primary-keys that include foreign-keys when
building the model-graph.
* Allow model-classes to be passed as arguments, e.g., to a table function.
* Ensure postgres `JSONField.concat()` accepts expressions as arguments.
3.13.1
Fix a regression when specifying keyword arguments to the atomic() or
transaction() helper methods. Note: this only occurs if you were using Sqlite
and were explicitly setting the lock_type= parameter.
3.13.0
CockroachDB support added
This will be a notable release as it adds support for
CockroachDB, a distributed, horizontally-scalable
SQL database.
CockroachDB usage overview
CockroachDB API documentation
Other features and fixes
Allow FOR UPDATE clause to specify one or more tables (FOR UPDATE OF...).
Support for Postgres LATERAL join.
Properly wrap exceptions raised during explicit commit/rollback in the appropriate peewee-specific exception class.
Capture original exception object and expose it as exc.orig on the wrapped exception.
Properly introspect SMALLINT columns in Postgres schema reflection.
More flexible handling of passing database-specific arguments to atomic() and transaction() context-manager/decorator.
Fix non-deterministic join ordering issue when using the filter() API across several tables
3.12.0
* Bulk insert (`insert_many()` and `insert_from()`) will now return the row
count instead of the last insert ID. If you are using Postgres, peewee will
continue to return a cursor that provides an iterator over the newly-inserted
primary-key values by default. This behavior is being retained by default for
compatibility. Postgres users can simply specify an empty `returning()` call
to disable the cursor and retrieve the rowcount instead.
* Migration extension now supports altering a column's data-type, via the new
`alter_column_type()` method.
* Added `Database.is_connection_usabe()` method, which attempts to look at the
status of the underlying DB-API connection to determine whether the
connection is usable.
* Common table expressions include a `materialized` parameter, which can be
used to control Postgres' optimization fencing around CTEs.
* Added `BloomFilter.from_buffer()` method for populating a bloom-filter from
the output of a previous call to the `to_buffer()` method.
* Fixed APSW extension's `commit()` and `rollback()` methods to no-op if the
database is in auto-commit mode.
* Added `generate_always=` option to the `IdentityField` (defaults to False).
3.11.2
* Implement `hash` interface for `Alias` instances, allowing them to be used in
multi-source queries.
3.11.1
* Fix bug in new `_pk` / `get_id()` implementation for models that explicitly
have disabled a primary-key.
3.11.0
* Fixes 1991. This particular issue involves joining 3 models together in a
chain, where the outer two models are empty. Previously peewee would make the
middle model an empty model instance (since a link might be needed from the
source model to the outermost model). But since both were empty, it is more
correct to make the intervening model a NULL value on the foreign-key field
rather than an empty instance.
* An unrelated fix came out of the work on 1991 where hashing a model whose
primary-key happened to be a foreign-key could trigger the FK resolution
query. This patch fixes the `Model._pk` and `get_id()` interfaces so they
no longer introduce the possibility of accidentally resolving the FK.
* Allow `Field.contains()`, `startswith()` and `endswith()` to compare against
another column-like object or expression.
* Workaround for MySQL prior to 8 and MariaDB handling of union queries inside
of parenthesized expressions (like IN).
* Be more permissive in letting invalid values be stored in a field whose type
is INTEGER or REAL, since Sqlite allows this.
* `TimestampField` resolution cleanup. Now values 0 *and* 1 will resolve to a
timestamp resolution of 1 second. Values 2-6 specify the number of decimal
places (hundredths to microsecond), or alternatively the resolution can still
be provided as a power of 10, e.g. 10, 1000 (millisecond), 1e6 (microsecond).
* When self-referential foreign-keys are inherited, the foreign-key on the
subclass will also be self-referential (rather than pointing to the parent
model).
* Add TSV import/export option to the `dataset` extension.
* Add item interface to the `dataset.Table` class for doing primary-key lookup,
assignment, or deletion.
* Extend the mysql `ReconnectMixin` helper to work with mysql-connector.
* Fix mapping of double-precision float in postgres schema reflection.
Previously it mapped to single-precision, now it correctly uses a double.
* Fix issue where `PostgresqlExtDatabase` and `MySQLConnectorDatabase` did not
respect the `autoconnect` setting.
3.10.0
Add a helper to playhouse.mysql_ext for creating Match full-text search expressions.
Added date-part properties to TimestampField for accessing the year, month, day, etc., within a SQL expression.
Added to_timestamp() helper for DateField and DateTimeField that produces an expression returning a unix timestamp.
Add autoconnect parameter to Database classes. This parameter defaults to True and is compatible with previous versions of Peewee, in which executing a query on a closed database would open a connection automatically. To make it easier to catch inconsistent use of the database connection, this behavior can now be disabled by specifying autoconnect=False, making an explicit call to Database.connect() needed before executing a query.
Added database-agnostic interface for obtaining a random value.
Allow isolation_level to be specified when initializing a Postgres db.
Allow hybrid properties to be used on model aliases.
Support aggregates with FILTER predicates on the latest Sqlite.
Changes
-------
More aggressively slot row values into the appropriate field when building objects from the database cursor (rather than using whatever cursor.description tells us, which is buggy in older Sqlite).
Be more permissive in what we accept in the insert_many() and insert() methods.
When implicitly joining a model with multiple foreign-keys, choose the foreign-key whose name matches that of the related model. Previously, this would have raised a ValueError stating that multiple FKs existed.
Improved date truncation logic for Sqlite and MySQL to make more compatible with Postgres' date_trunc() behavior. Previously, truncating a datetime to month resolution would return '2019-08' for example. As of 3.10.0, the Sqlite and MySQL date_trunc implementation returns a full datetime, e.g. '2019-08-01 00:00:00'.
Apply slightly different logic for casting JSON values with Postgres. Previously, Peewee just wrapped the value in the psycopg2 Json() helper. In this version, Peewee now dumps the json to a string and applies an explicit cast to the underlying JSON data-type (e.g. json or jsonb).
Bug fixes
---------
Save hooks can now be called for models without a primary key.
Fixed bug in the conversion of Python values to JSON when using Postgres.
Fix for differentiating empty values from NULL values in model_to_dict.
Fixed a bug referencing primary-key values that required some kind of conversion (e.g., a UUID).
Add small jitter to the pool connection timestamp to avoid issues when multiple connections are checked-out at the same exact time.
3.9.6
Support nesting the Database instance as a context-manager. The outermost block will handle opening and closing the connection along with wrapping everything in a transaction. Nested blocks will use savepoints.
Add new session_start(), session_commit() and session_rollback() interfaces to the Database object to support using transactional controls in situations where a context-manager or decorator is awkward.
Fix error that would arise when attempting to do an empty bulk-insert.
Set isolation_level=None in SQLite connection constructor rather than afterwards using the setter.
Add create_table() method to Select query to implement CREATE TABLE AS.
Cleanup some declarations in the Sqlite C extension.
Add new example showing how to implement Reddit's ranking algorithm in SQL.
3.9.5
* Added small helper for setting timezone when using Postgres.
* Improved SQL generation for `VALUES` clause.
* Support passing resolution to `TimestampField` as a power-of-10.
* Small improvements to `INSERT` queries when the primary-key is not an
auto-incrementing integer, but is generated by the database server (eg uuid).
* Cleanups to virtual table implementation and python-to-sqlite value
conversions.
* Fixed bug related to binding previously-unbound models to a database using a
context manager.
3.9.4:
* Add Model.bulk_update() method for bulk-updating fields across multiple
model instances.
* Add lazy_load parameter to ForeignKeyField. When initialized with
lazy_load=False, the foreign-key will not use an additional query to
resolve the related model instance. Instead, if the related model instance is
not available, the underlying FK column value is returned (behaving like the
"_id" descriptor).
* Added Model.truncate_table() method.
* The reflection and pwiz extensions now attempt to be smarter about
converting database table and column names into snake-case. To disable this,
you can set snake_case=False when calling the Introspector.introspect()
method or use the -L (legacy naming) option with the pwiz script.
* Bulk insert via insert_many() no longer require specification of the
fields argument when the inserted rows are lists/tuples. In that case, the
fields will be inferred to be all model fields except any auto-increment id.
* Add DatabaseProxy, which implements several of the Database class context
managers. This allows you to reference some of the special features of the
database object without directly needing to initialize the proxy first.
* Add support for window function frame exclusion and added built-in support
for the GROUPS frame type.
* Add support for chaining window functions by extending a previously-declared
window function.
* Playhouse Postgresql extension TSVectorField.match() method supports an
additional argument plain, which can be used to control the parsing of the
TS query.
* Added very minimal JSONField to the playhouse MySQL extension.
3.9.3
* Added cross-database support for NULLS FIRST/LAST when specifying the
ordering for a query. Previously this was only supported for Postgres. Peewee
will now generate an equivalent CASE statement for Sqlite and MySQL.
* Added [EXCLUDED](http://docs.peewee-orm.com/en/latest/peewee/api.html#EXCLUDED)
helper for referring to the EXCLUDED namespace used with INSERT...ON CONFLICT
queries, when referencing values in the conflicting row data.
* Added helper method to the model Metadata class for setting the table name
at run-time. Setting the Model._meta.table_name directly may have appeared
to work in some situations, but could lead to subtle bugs. The new API is
Model._meta.set_table_name().
* Enhanced helpers for working with Peewee interactively, [see doc](http://docs.peewee-orm.com/en/latest/peewee/interactive.html).
* Fix cache invalidation bug in DataSet that was originally reported on the
sqlite-web project.
* New example script implementing a [hexastore]
3.9.2:
This release contains a fix for a test that was failing when 3.9.1 was tagged and released.
3.9.1:
Includes a bugfix for an AttributeError that occurs when using MySQL with the MySQLdb client.
3.9.0:
New and improved stuff
Added new document describing how to use peewee interactively.
Added convenience functions for generating model classes from a pre-existing database, printing model definitions and printing CREATE TABLE sql for a model. See the "use peewee interactively" section for details.
Added a __str__ implementation to all Query subclasses which converts the query to a string and interpolates the parameters.
Improvements to sqlite_ext.JSONField regarding the serialization of data, as well as the addition of options to override the JSON serialization and de-serialization functions.
Added index_type parameter to Field
Added DatabaseProxy, which allows one to use database-specific decorators with an uninitialized Proxy object.
Added support for INSERT ... ON CONFLICT when the conflict target is a partial index (e.g., contains a WHERE clause). The OnConflict and on_conflict() APIs now take an additional conflict_where parameter to represent the WHERE clause of the partial index in question.
Enhanced the playhouse.kv extension to use efficient upsert for all database engines. Previously upsert was only supported for sqlite and mysql.
Re-added the orwhere() query filtering method, which will append the given expressions using OR instead of AND.
Added some new examples to the examples/ directory
Added select_from() API for wrapping a query and selecting one or more columns from the wrapped subquery. Docs.
Added documentation on using row values.
Removed the (defunct) "speedups" C extension, which as of 3.8.2 only contained a barely-faster function for quoting entities.
Bugfixes
Fix bug in SQL generation when there was a subquery that used a common table expressions.
Enhanced prefetch() and fixed bug that could occur when mixing self-referential foreign-keys and model aliases.
MariaDB 10.3.3 introduces backwards-incompatible changes to the SQL used for upsert. Peewee now introspects the MySQL server version at connection time to ensure proper handling of version-specific features.
Fixed bug where TimestampField would treat zero values as None when reading from the database.
3.8.2
Backwards-incompatible changes
The default row-type for INSERT queries executed with a non-default RETURNING clause has changed from tuple to Model instances. This makes INSERT behavior consistent with UPDATE and DELETE queries that specify a RETURNING clause. To revert back to the old behavior, just append a call to .tuples() to your INSERT ... RETURNING query.
Removing support for the table_alias model Meta option. Previously, this attribute could be used to specify a "vanity" alias for a model class in the generated SQL. As a result of some changes to support more robust UPDATE and DELETE queries, supporting this feature will require some re-working. As of the 3.8.0 release, it was broken and resulted in incorrect SQL for UPDATE queries, so now it is removed.
New features
Added playhouse.shortcuts.ReconnectMixin, which can be used to implement automatic reconnect under certain error conditions (notably the MySQL error 2006 - server has gone away).
Bugfixes
Fix SQL generation bug when using an inline window function in the ORDER BY clause of a query.
Fix possible zero-division in user-defined implementation of BM25 ranking algorithm for SQLite full-text search.
3.8.1
New features
Sqlite SearchField now supports the match() operator, allowing full-text search to be performed on a single column (as opposed to the whole table).
Changes
Remove minimum passphrase restrictions in SQLCipher integration.
Bugfixes
Support inheritance of ManyToManyField instances.
Ensure operator overloads are invoked when generating filter expressions.
Fix incorrect scoring in Sqlite BM25, BM25f and Lucene ranking algorithms.
Support string field-names in data dictionary when performing an ON CONFLICT ... UPDATE query, which allows field-specific conversions to be applied.
3.8.0
**New features**
* Postgres BinaryJSONField now supports has_key(), concat() and
remove() methods (though remove may require pg10+).
* Add python_value() method to the SQL-function helper fn, to allow
specifying a custom function for mapping database values to Python values.
**Changes**
* Better support for UPDATE ... FROM queries, and more generally, more robust
support for UPDATE and RETURNING clauses. This means that the
QualifiedNames helper is no longer needed for certain types of queries.
* The SqlCipherDatabase no longer accepts a kdf_iter parameter. To
configure the various SQLCipher encryption settings, specify the setting
values as pragmas when initializing the database.
* Introspection will now, by default, only strip "_id" from introspected column
names if those columns are foreign-keys.
* Allow UUIDField and BinaryUUIDField to accept hexadecimal UUID strings as
well as raw binary UUID bytestrings (in addition to UUID instances, which
are already supported).
* Allow ForeignKeyField to be created without an index.
* Allow multiple calls to cast() to be chained.
* Add logic to ensure foreign-key constraint names that exceed 64 characters
are truncated using the same logic as is currently in place for long indexes.
* ManyToManyField supports foreign-keys to fields other than primary-keys.
* When linked against SQLite 3.26 or newer, support SQLITE_CONSTRAINT to
designate invalid queries against virtual tables.
* SQL-generation changes to aid in supporting using queries within expressions
following the SELECT statement.
**Bugfixes**
* Fixed bug in order_by_extend(), thanks @nhatHero.
* Fixed bug where the DataSet CSV import/export did not support non-ASCII
characters in Python 3.x.
* Fixed bug where model_to_dict would attempt to traverse explicitly disabled
foreign-key backrefs.
* Fixed bug when attempting to migrate SQLite tables that have a field whose
column-name begins with "primary_".
* Fixed bug with inheriting deferred foreign-keys.
3.7.1:
New features
* Added table_settings model Meta option, which should be a list of strings
specifying additional options for CREATE TABLE, which are placed *after*
the closing parentheses.
* Allow specification of on_update and on_delete behavior for many-to-many
relationships when using ManyToManyField.
Bugfixes
* Fixed incorrect SQL generation for Postgresql ON CONFLICT clause when the
conflict_target is a named constraint (rather than an index expression). This
introduces a new keyword-argument to the on_conflict() method:
conflict_constraint, which is currently only supported by Postgresql.
* Fixed incorrect SQL for sub-selects used on the right side of IN
expressions. Previously the query would be assigned an alias, even though an
alias was not needed.
* Fixed incorrect SQL generation for Model indexes which contain SQL functions
as indexed columns.
* Fixed bug in the generation of special queries used to perform operations on
SQLite FTS5 virtual tables.
* Allow frozenset to be correctly parameterized as a list of values.
* Allow multi-value INSERT queries to specify columns as a list of strings.
* Support CROSS JOIN for model select queries.
3.7.0:
Backwards-incompatible changes
* Pool database close_all() method renamed to close_idle() to better
reflect the actual behavior.
* Databases will now raise InterfaceError when connect() or close() are
called on an uninitialized, deferred database object.
New features
* Add methods to the migrations extension to support adding and dropping table
constraints.
* Add Model.bulk_create() method for bulk-inserting unsaved model instances.
* Add close_stale() method to the connection pool to support closing stale
connections.
* The FlaskDB class in playhouse.flask_utils now accepts a model_class
parameter, which can be used to specify a custom base-class for models.
Bugfixes
* Parentheses were not added to subqueries used in function calls with more
than one argument.
* Fixed bug when attempting to serialize many-to-many fields which were created
initially with a DeferredThroughModel.
* Fixed bug when using the Postgres ArrayField with an array of BlobField.
* Allow Proxy databases to be used as a context-manager.
* Fixed bug where the APSW driver was referring to the SQLite version from the
standard library sqlite3 driver, rather than from apsw.
* Reflection library attempts to wrap server-side column defaults in quotation
marks if the column data-type is text/varchar.
* Missing import in migrations library, which would cause errors when
attempting to add indexes whose name exceeded 64 chars.
* When using the Postgres connection pool, ensure any open/pending transactions
are rolled-back when the connection is recycled.
* Even *more* changes to the setup.py script. In this case I've added a
helper function which will reliably determine if the SQLite3 extensions can
be built. This follows the approach taken by the Python YAML package.
3.6.4:
Take a whole new approach, following what simplejson does. Allow the
build_ext command class to fail, and retry without extensions in the event we
run into issues building extensions.
3.6.3:
Add check in setup.py to determine if a C compiler is available before
building C extensions.
3.6.2:
Use ctypes.util.find_library to determine if libsqlite3 is installed.
Should fix problems people are encountering installing when SQLite3 is not
available.
3.6.1:
Fixed issue with setup script.
3.6.0:
* Support for Python 3.7, including bugfixes related to new StopIteration
handling inside of generators.
* Support for specifying ROWS or RANGE window frame types.
* Add APIs for user-defined window functions if using [pysqlite3](https://github.com/coleifer/pysqlite3)
and sqlite 3.25.0 or newer.
* TimestampField now uses 64-bit integer data-type for storage.
* Added support to pwiz and playhouse.reflection to enable generating
models from VIEWs.
* Added lower-level database API for introspecting VIEWs.
* Revamped continuous integration setup for better coverage, including 3.7 and
3.8-dev.
* Allow building C extensions even if Cython is not installed, by distributing
pre-generated C source files.
* Switch to using setuptools for packaging.
3.5.2:
New guide to using window functions in Peewee.
New and improved table name auto-generation. This feature is not backwards compatible, so it is disabled by default. To enable, set legacy_table_names=False in your model's Meta options. For more details, see table names documentation.
Allow passing single fields/columns to window function order_by and partition_by arguments.
Support for FILTER (WHERE...) clauses with window functions and aggregates.
Added IdentityField class suitable for use with Postgres 10's new identity column type. It can be used anywhere AutoField or BigAutoField was being used previously.
Fixed bug creating indexes on tables that are in attached databases (SQLite).
Fixed obscure bug when using prefetch() and ModelAlias to populate a back-reference related model.
3.5.1:
New features
------------
New documentation for working with relationships in Peewee.
Improved tests and documentation for MySQL upsert functionality.
Allow database parameter to be specified with ModelSelect.get() method.
Add QualifiedNames helper to peewee module exports.
Add temporary= meta option to support temporary tables.
Allow a Database object to be passed to constructor of DataSet helper.
Bug fixes
---------
Fixed edge-case where attempting to alias a field to it's underlying column-name (when different), Peewee would not respect the alias and use the field name instead.
Raise a ValueError when joining and aliasing the join to a foreign-key's object_id_name descriptor. Should prevent accidentally introducing O(n) queries or silently ignoring data from a joined-instance.
Fixed bug for MySQL when creating a foreign-key to a model which used the BigAutoField for it's primary-key.
Fixed bugs in the implementation of user-defined aggregates and extensions with the APSW SQLite driver.
Fixed regression introduced in 3.5.0 which ignored custom Model __repr__().
Fixed regression from 2.x in which inserting from a query using a SQL() was no longer working.
Backwards-incompatible changes
- Custom Model repr no longer use the convention of overriding
__unicode__, and now use __str__.
- Redesigned the sqlite json1 integration and changed some of the APIs
and semantics of various JSONField methods.
New features
- Better default repr for model classes and fields.
- ForeignKeyField() accepts a new initialization parameter,
deferrable, for specifying when constraints should be enforced.
- BitField.flag() can be called without a value parameter for the
common use-case of using flags that are powers-of-2.
- SqliteDatabase pragmas can be specified as a dict (previously
required a list of 2-tuples).
- SQLite TableFunction (docs) will print Python exception tracebacks
raised in the initialize and iterate callbacks, making debugging
significantly easier.
Bug fixes
- Fixed bug in migrator.add_column() where, if the field being added
declared a non-standard index type (e.g., binary json field with GIN
index), this index type was not being respected.
- Fixed bug in database.table_exists() where the implementation did
not match the documentation.
- Fixed bug in SQLite TableFunction implementation which raised errors
if the return value of the iterate() method was not a tuple.
Backwards-incompatible changes
- The regexp() operation is now case-sensitive for MySQL and Postgres.
To perform case-insensitive regexp operations, use iregexp().
- The SQLite BareField() field-type now supports all column
constraints except specifying the data-type. Previously it silently
ignored any column constraints.
- LIMIT and OFFSET parameters are now treated as parameterized values
instead of literals.
- The schema parameter for SQLite database introspection methods is no
longer ignored by default. The schema corresponds to the name given
to an attached database.
- ArrayField now accepts a new parameter field_kwargs, which is used
to pass information to the array field's field_class initializer.
New features and other changes
- SQLite backup interface supports specifying page-counts and a
user-defined progress handler.
- GIL is released when doing backups or during SQLite busy timeouts
(when using the peewee SQLite busy-handler).
- Add NATURAL join-type to the JOIN helper.
- Improved identifier quoting to allow specifying distinct
open/close-quote characters. Enables adding support for MSSQL, for
instance, which uses square brackets, e.g. [table].[column].
- Unify timeout interfaces for SQLite databases (use seconds
everywhere rather than mixing seconds and milliseconds, which was
confusing).
- Added attach() and detach() methods to SQLite database, making it
possible to attach additional databases (e.g. an in-memory cache
db).
3.3.4
- Added a BinaryUUIDField class for efficiently storing UUIDs in
16-bytes.
- Fix dataset's update_cache() logic so that when updating a single
table that was newly-added, we also ensure that all dependent tables
are updated at the same time.
3.3.3
- More efficient implementation of model dependency-graph generation.
Improves performance of recursively deleting related objects by
omitting unnecessary subqueries.
- Added union(), union_all(), intersect() and except_() to the
Model-specific query implementations. This was an oversight that
should have been patched in 3.3.2, but is fixed in 3.3.3.
- Major cleanup to test runner and standardized test skipping logic to
integrate with standard-library unittest conventions.
3.3.2
- Add methods for union(), union_all, intersect() and except_().
Previously, these methods were only available as operator overloads.
- Removed some Python 2.6-specific support code, as 2.6 is no longer
officially supported.
- Fixed model-graph resolution logic for deferred foreign-keys.
- Better support for UPDATE...FROM queries (Postgresql).
- Fixed long-standing bug in 3.x regarding using column aliases with
queries that utilize the ModelCursorWrapper (typically queries with
one or more joins).
- Fix typo in model metadata code, thanks @klen.
- Add examples of using recursive CTEs to docs.
- Added support for SQLite's new ON CONFLICT clause, which is modelled
on the syntax used by Postgresql and will be available in SQLite
3.24.0 and onward.
- Added better support for using common table expressions and a
cleaner way of implementing recursive CTEs, both of which are also
tested with integration tests (as opposed to just checking the
generated SQL).
- Modernized the CI environment to utilize the latest MariaDB
features, so we can test window functions and CTEs with MySQL (when
available).
- Reorganized and unified the feature-flags in the test suite.
- Added ValuesList for representing values lists.
- DateTimeField, DateField and TimeField will parse formatted-string
before sending to the database. Previously this only occurred when
reading values from the database.
- Smarter handling of model-graph when dealing with compound queries
(union, intersect, etc).
- If the same column-name is selected multiple times, first value
wins.
- If ModelSelect.switch() is called without any arguments, default to
the query's model.
- Fix issue where cloning a ModelSelect query did not result in the
joins being cloned.
- pwiz tool will capture column defaults defined as part of the
table schema.
- Fixed a misleading error message.
- Ensure reuse_if_open parameter has effect on pooled databases.
- Added support for on update/delete when migrating foreign-key.
- Fixed bug in SQL generation for subqueries in aliased functions.
3.2.2
- Added support for passing Model classes to the returning() method
when you intend to return all columns for the given model.
- Fixed a bug when using user-defined sequences, and the underlying
sequence already exists.
- Added drop_sequences parameter to drop_table() method which allows
you to conditionally drop any user-defined sequences when dropping
the table.
3.2.1
- If both mysql-python and pymysql libraries are installed, Peewee
will use pymysql by default.
- Added new module playhouse.mysql_ext which includes
MySQLConnectorDatabase, a database implementation that works with
the mysql-connector driver.
- Added new field to ColumnMetadata class which captures a database
column's default value. ColumnMetadata is returned by
Database.get_columns().
- Added documentation on making Peewee async.
3.2.0
- Potentially backwards-incompatible change: Field.coerce renamed to
Field.adapt.
3.1.6
- Added rekey() method to SqlCipher database for changing encryption
key and documentation for set_passphrase() method.
- Added convert_values parameter to ArrayField constructor, which will
cause the array values to be processed using the underlying
data-type's conversion logic.
- Fixed unreported bug using TimestampField with sub-second
resolutions.
- Fixed bug where options were not being processed when calling
drop_table().
- Some fixes and improvements to signals extension.
## 3.1.5
- Fixed Python 2/3 incompatibility with `itertools.izip_longest()`.
## 3.1.4
- Added `BigAutoField` to support 64-bit auto-incrementing primary
keys.
- Use Peewee-compatible datetime serialization when exporting JSON
from a `DataSet`. Previously the JSON export used ISO-8601 by default.
- Added `Database.batch_commit` helper to wrap iterators in chunked
transactions.
## 3.1.3
- Fixed issue where scope-specific settings were being updated
in-place instead of copied.
- Fixed bug where setting a `ForeignKeyField` did not add it to the
model's "dirty" fields list.
- Use pre-fetched data when using `prefetch()` with `ManyToManyField`.
- Use `JSON` data-type for SQLite `JSONField` instances.
- Add a `json_contains` function for use with SQLite `json1` extension.
- Various documentation updates and additions.
- Fixed issue where scope-specific settings were being updated
in-place instead of copied.
- Fixed bug where setting a ForeignKeyField did not add it to
the model's "dirty" fields list.
- Use pre-fetched data when using prefetch() with ManyToManyField.
- Use JSON data-type for SQLite JSONField instances.
- Add a json_contains function for use with SQLite json1 extension.
- Various documentation updates and additions.
- Fixed bug when using Model.alias() when the model defined a
particular database schema.
- Added SchemaManager.create_foreign_key API to simplify adding
constraints when dealing with circular foreign-key relationships.
- Improved implementation of Migrator.add_foreign_key_constraint so
that it can be used with Postgresql (in addition to MySQL).
- Added PickleField to the playhouse.fields module. Docs.
- Fixed bug in implementation of CompressedField when using Python 3.
- Added KeyValue API in playhouse.kv module. Docs.
- More test cases for joining on sub-selects or common table
expressions.
Backwards-incompatible changes
- Database.bind() has been renamed to Database.bind_ctx(), to more closely
match the semantics of the corresponding model methods, Model.bind() and
Model.bind_ctx(). The new Database.bind() method is a one-time operation
that binds the given models to the database. See documentation:
Other changes
- Removed Python 2.6 support code from a few places.
- Fixed example analytics app code to ensure hstore extension is registered.
- Small efficiency improvement to bloom filter.
- Removed "attention!" from README.
3.0.20
- Include schema (if specified) when checking for table-existence.
- Correct placement of ORDER BY / LIMIT clauses in compound select
queries.
- Fix bug in back-reference lookups when using filter() API.
- Fix bug in SQL generation for ON CONFLICT queries with Postgres
3.0.19
- Support for more types of mappings in insert_many()
- Lots of documentation improvements.
- Fix bug when calling tuples() on a ModelRaw query. This was reported
originally as a bug with sqlite-web CSV export
- Improved error messages when attempting to use a database class
for which the corresponding driver is not installed.
- Added tests showing the use of custom operator (a-la the docs).
- Fixed indentation issue in docs
- Fixed issue with the SQLite date_part issue
3.0.17
- Fix schema inheritance regression
- Add helper method to postgres migrator for setting search_path
3.0.16
- Improve model graph resolution when iterating results of a query
- Allow Model._meta.schema to be changed at run-time
1.0.5
- Use same schema used for reflection in generated models.
- Preserve pragmas set on deferred Sqlite database if database is
re-initialized without re-specifying pragmas.
1.0.4
- Fix bug creating model instances on Postgres when model does not
have a primary key column.
- Extend postgresql reflection to support array types.
