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.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.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.
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.
- 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.
3.0.9
- Add deprecation notice if passing autocommit as keyword argument to
the Database initializer.
- Add JSONPath and "J" helpers to sqlite extension.
3.0.8
- Add support for passing cascade=True when dropping tables.
- Fix issues with backrefs and inherited foreign-keys.
3.0.7
- Add select_extend() method to extend existing SELECT-ion.
- Accept set() as iterable value type
- Add test for model/field inheritance and fix bug relating to
recursion error when inheriting foreign-key field.
- Fix regression where consecutive calls to ModelSelect.select() with
no parameters resulted in an empty selection.
3.0.6
- Add constraints for ON UPDATE/ON DELETE to foreign-key constraint
3.0.5
- Adds Model.index(), a short-hand method for declaring ModelIndex
instances.
3.0.4
- Re-add a shim for PrimaryKeyField (renamed to AutoField) and log a
deprecation warning if you try to use it
3.0.3
- Includes fix for bug where column-name to field-name translation was
not being done when running select queries on models whose field
name differed from the underlying column name.
3.0.2
- Fixes missing pysqlite header files, which are needed to compile
certain C extensions.
3.0.0
- Complete rewrite of SQL AST and code-generation.
- Inclusion of new, low-level query builder APIs.
- List of backwards-incompatible changes since 2.x:
http://docs.peewee-orm.com/en/latest/peewee/changes.html
## 2.9.2
- Fixed significant bug in the `savepoint` commit/rollback implementation.
- Added support for postgresql `INTERVAL` columns.
- Fixed bug where missing `sqlite3` library was causing other, unrelated
libraries to throw errors when attempting to import.
- Added a `case_sensitive` parameter to the SQLite `REGEXP` function
implementation. The default is `False`, to preserve backwards-compatibility.
- Fixed bug that caused tables not to be created when using the `dataset`
extension.
- Modified `drop_table` to raise an exception if the user attempts to drop
tables with `CASCADE` when the database backend does not support it.
- Fixed Python3 issue in the `AESEncryptedField`.
- Modified the behavior of string-typed fields to treat the addition operator
as concatenation
## 2.9.1
- Fixed#1218, where the use of `playhouse.flask_utils` was requiring the
`sqlite3` module to be installed.
- Fixed#1219 regarding the SQL generation for composite key sub-selects,
joins, etc.
## 2.9.0
In this release there are two notable changes:
- The ``Model.create_or_get()`` method was removed.
- The SQLite closure table extension gained support for many-to-many
relationships thanks to a nice PR by @necoro.
## 2.8.8
This release contains a single important bugfix for a regression in specifying
the type of lock to use when opening a SQLite transaction.
## 2.8.7
This release contains numerous cleanups.
### Bugs fixed
- #1087 - Fixed a misuse of the iteration protocol in the `sqliteq` extension.
- #1096 - Fix representation of recursive foreign key relations when using the
`model_to_dict` helper.
- #1126 - Allow `pskel` to be installed into `bin` directory.
- #1105 - Added a `Tuple()` type to Peewee to enable expressing arbitrary
tuple expressions in SQL.
- #1133 - Fixed bug in the conversion of objects to `Decimal` instances in the
`DecimalField`.
- Fixed an issue renaming a unique foreign key in MySQL.
- Remove the join predicate from CROSS JOINs.
- #1148 - Ensure indexes are created when a column is added using a schema
migration.
- #1165 - Fix bug where the primary key was being overwritten in queries using
the closure-table extension.
### New stuff
- Added properties to the `SqliteExtDatabase` to expose common `PRAGMA`
settings.
- Clarified documentation on calling `commit()` or `rollback()` from within the
scope of an atomic block.
- Allow table creation dependencies to be specified using new `depends_on` meta
option.
- Allow specification of the lock type used in SQLite transactions.
- Added support for `CROSS JOIN` expressions in select queries.
- Docs on how to implement optimistic locking
- Documented optional dependencies.
- Generic support for specifying select queries as locking the selected rows
`FOR X`, e.g. `FOR UPDATE` or `FOR SHARE`.
- Support for specifying the frame-of-reference in window queries, e.g.
specifying `UNBOUNDED PRECEDING`, etc.
### Backwards-incompatible changes
- As of 9e76c99, an `OperationalError` is raised if the user calls `connect()`
on an already-open Database object. Previously, the existing connection would
remain open and a new connection would overwrite it, making it impossible to
close the previous connection. If you find this is causing breakage in your
application, you can switch the `connect()` call to `get_conn()` which will
only open a connection if necessary. The error **is** indicative of a real
issue, though, so audit your code for places where you may be opening a
connection without closing it (module-scope operations, e.g.).
2.8.5
- Starting docs on sqliteq
- Use parentheses for compound select with MySQL.
- Remove "clean_prefetch_subquery" as I'm not sure why it exists in the
first place.
2.8.4
- New playhouse extension module for working with SQLite in
multi-threaded / concurrent environments. The new module is called
playhouse.sqliteq and it works by serializing queries using a dedicated
worker thread (or greenlet). The performance is quite good, hopefully
this proves useful to someone besides myself! You can learn more by
reading the sqliteq documentation.
- #1061 - @akrs patched a bug in TimestampField which affected the
accuracy of sub-second timestamps (for resolution > 1).
- #1071, small python 3 fix.
- #1072, allow DeferredRelation to be used multiple times if there are
multiple references to a given deferred model.
- #1073, fixed regression in the speedups module that caused SQL
functions to always coerce return values, regardless of the coerce
flag.
- #1083, another Python 3 issue - this time regarding the use of
exc.message.
Bugs fixed
- #821 - issue warning if Cython is old
- #822 - better handling of MySQL connections point for advanced
use-cases.
- #313 - support equality/inequality with generic foreign key
queries, and ensure get_or_create works with GFKs.
- #834 - fixed Python3 incompatibilities in the PasswordField,
thanks @mosquito.
- #836 - fix handling of last_insert_id() when using APSWDatabase.
- #845 - add connection hooks to APSWDatabase.
- #852 - check SQLite library version to avoid calls to missing
APIs.
- #857 - allow database definition to be deferred when using the
connection pool.
- #878 - formerly .limit(0) had no effect. Now adds LIMIT 0.
- #879 - implement a __hash__ method for Model
- #886 - fix count() for compound select queries.
- #895 - allow writing to the foreign_key_id descriptor to set the
foreign key value.
- #893 - fix boolean logic bug in model_to_dict().
- #904 - fix side-effect in clean_prefetch_query, thanks to
@p.kamayev
- #907 - package includes pskel now.
- #852 - fix sqlite version check in BerkeleyDB backend.
- #919 - add runtime check for sqlite3 library to match MySQL and
Postgres. Thanks @M157q
New features
- Added a number of SQLite user-defined functions and aggregates.
- Use the DB-API2 Binary type for BlobField.
- Implemented the lucene scoring algorithm in the sqlite_ext
Cython library.
- #825 - allow a custom base class for ModelOptions, providing an
extension
- #830 - added SmallIntegerField type.
- #838 - allow using a custom descriptor class with
ManyToManyField.
- #855 - merged change from @lez which included docs on using
peewee with Pyramid.
- #858 - allow arguments to be passed on query-string when using
the db_url module. Thanks @RealSalmon
- #862 - add support for truncate table, thanks @dev-zero for the
sample code.
- Allow the related_name model Meta option to be a callable that
accepts the foreign key field instance.
This release includes a couple new field types and greatly improved
C extension support for both speedups and SQLite enhancements. Also
includes some work, suggested by @foxx, to remove some places where
Proxy was used in favor of more obvious APIs.
New features
- C extension speedups now enabled by default, includes faster
implementations for dict and tuple QueryResultWrapper classes,
faster date formatting, and a faster field and model sorting.
- C implementations of SQLite functions is now enabled by default.
SQLite extension is now compatible with APSW and can be used in
standalone form directly from Python.
- SQLite C extension now supports murmurhash2.
- UUIDField is now supported for SQLite and MySQL, using text and
varchar respectively, thanks @foxx!
- Added BinaryField, thanks again, @foxx!
- Added PickledField to playhouse.fields.
- ManyToManyField now accepts a list of primary keys when adding or
removing values from the through relationship.
- Added support for SQLite table-valued functions using the
sqlite-vtfunc library.
- Significantly simplified the build process for compiling the
C extensions.
Backwards-incompatible changes
- Instead of using a Proxy for defining circular foreign key
relationships, you now need to use DeferredRelation.
- Instead of using a Proxy for defining many-to-many through tables,
you now need to use DeferredThroughModel.
- SQLite Virtual Models must now use Meta.extension_module and
Meta.extension_options to declare extension and any options.
- MySQL database will now issue COMMIT statements for SELECT queries.
Bugs fixed
- #766, fixed bug with PasswordField and Python3. Fuck Python 3.
- #768, fixed SortedFieldList and remove_field(). Thanks @klen!
- #771, clarified docs for APSW.
- #773, added docs for request hooks in Pyramid
- #774, prefetch() only loads first ForeignKeyField
for a given relation.
- #782, fixed typo in docs.
- #791, foreign keys were not correctly handling coercing to
the appropriate python value.
- #792, cleaned up some CSV utils code.
- #798, cleaned up iteration protocol in QueryResultWrappers.
- #806, not really a bug, but MySQL users were clowning around
and needed help.
2.7.4
This is another small release which adds code to automatically build
the SQLite C extension if libsqlite is available. The release also
includes:
- Support for UUIDField with SQLite.
- Support for registering additional database classes with the db_url
module via register_database.
- prefetch() supports fetching multiple foreign-keys to the same model
class.
- Added method to validate FTS5 search queries.
2.7.3
Small release which includes some changes to the BM25 sorting
algorithm and the addition of a JSONField for use with the new
JSON1 extension.
2.7.2
Small release with bugfixes to the setup script.
I've also cleaned up some missing APIs in the FTS5Model to
support more flexible use of either FTSModel or FTS5Model.
2.7.1
Small release which includes fixes to the setup script.
Particularly, if you did not have Cython installed, the
installation would completely fail. This was fixed.
2.7.0
New APIs, features, and performance improvements.
Notable changes and new features
- PasswordField that uses the bcrypt module.
- Added new Model Meta.only_save_dirty flag to, by default,
only save fields that have been modified.
- Added support for upsert() on MySQL (in addition to SQLite).
- Implemented SQLite ranking functions (rank and bm25) in Cython,
and changed both the Cython and Python APIs to accept weight
values for every column in the search index. This more closely
aligns with the APIs provided by FTS5. In fact, made the APIs
for FTS4 and FTS5 result ranking compatible.
- Major changes to the :ref:sqlite_ext module. Function callbacks
implemented in Python were implemented in Cython (e.g. date
manipulation and regex processing) and will be used if Cython
is available when Peewee is installed.
- Support for the experimental new FTS5 SQLite search extension.
- Added :py:class:SearchField for use with the SQLite FTS
extensions.
- Added :py:class:RowIDField for working with the special rowid
column in SQLite.
- Added a model class validation hook to allow model subclasses
to perform any validation after class construction. This is
currently used to ensure that FTS5Model subclasses do not
violate any rules required by the FTS5 virtual table.
Bugs fixed
- #751, fixed some very broken behavior in the MySQL migrator
code. Added more tests.
- #718, added a RetryOperationalError mixin that will try
automatically reconnecting after a failed query. There was
a bug in the previous error handler implementation that
made this impossible, which is also fixed.
Bugs fixed
- fixed a bug with the Cython speedups not being included
in package.
- documented how to create models with no primary key.
- allow bare INSERT statements.
- regarding foreign key / one-to-one relationships.
- allow ArrayField to accept tuples in addition to lists.
- fix regarding unsaved relations.
- refactored QueryResultWrapper to allow multiple independent
iterations over the same underlying result cache.
- fix bug with multiple joins to same table + eager loading.
- fix bug when connection fails while using an execution context.
- use correct column names with non-standard django foreign keys.
- return datetime.time instead of timedelta for MySQL time fields.
- fixed SQLite migrator regular expressions. Thanks @sroebert.
New features
- added support for RETURNING clauses. Update, Insert and Delete
queries can now be called with RETURNING to retrieve the rows
that were affected.
- added web request hook docs.
- allowed arbitrary model attributes and methods to be serialized
by model_to_dict(). Docs.
- allow model_to_dict() to introspect query for which fields
to serialize.
- Added backend-agnostic truncate_date() implementation.
- Added a FixedCharField which uses column type CHAR.
- Added support for arbitrary PRAGMA statements to be run on new
SQLite connections. Docs.
- Removed berkeley_build.sh script. See instructions on my blog
instead.
2.6.3
- New `fields` module.
- Fix runtests to not run dupes.
- Add `FixedCharField`, fixes#631
2.6.2
- #641, fixed bug with exception wrapping and Python 2.6
- #634, fixed bug where correct query result wrapper was not being used
for certain composite queries.
- #625, cleaned up some example code.
- #614, fixed bug with aggregate_rows() when there are multiple joins
to the same table.
- Added create_or_get() as a companion to get_or_create().
- Added support for ON CONFLICT clauses for UPDATE and INSERT queries. Docs.
- Added a JSONKeyStore to playhouse.kv.
- Added Cythonized version of strip_parens(), with plans to perhaps move
more performance-critical code to Cython in the future.
- Added docs on specifying vendor-specific database parameters.
- Added docs on specifying field default values (both client and server-side).
- Added docs on foreign key field back-references.
- Added docs for models without a primary key.
- Cleaned up docs on prefetch() and aggregate_rows().
2.6.1
- #606, support self-referential joins with prefetch and aggregate_rows()
methods.
- #588, accomodate changes in SQLite's PRAGMA index_list() return value.
- #607, fixed bug where pwiz was not passing table names to introspector.
- #591, fixed bug with handling of named cursors in older psycopg2 version.
- Removed some cruft from the APSWDatabase implementation.
- Added CompressedField and AESEncryptedField
- #609, #610, added Django-style foreign key ID lookup.
- Added support for Hybrid Attributes (cool idea courtesy of SQLAlchemy).
- Added upsert keyword argument to the Model.save() function (SQLite only).
- #587, added support for ON CONFLICT SQLite clause for INSERT and UPDATE
queries.
- #601, added hook for programmatically defining table names.
- #581, #611, support connection pools with playhouse.db_url.connect().
- Added Contributing section section to docs.
2.6.0
- get_or_create() now returns a 2-tuple consisting of the model instance
and a boolean indicating whether the instance was created. The function
now behaves just like the Django equivalent.
- #574, better support for setting the character encoding on Postgresql
database connections. Thanks @klen!
- Improved implementation of get_or_create().
2.5.1
- #566, fixed a bug regarding parentheses around compound SELECT queries
(i.e. UNION, INTERSECT, etc).
- Fixed unreported bug where table aliases were not generated correctly
for compound SELECT queries.
- #559, add option to preserve original column order with pwiz. Thanks @elgow!
- Fixed unreported bug where selecting all columns from a ModelAlias
does not use the appropriate FieldAlias objects.
- #561, added an option for bulk insert queries to return the list
of auto-generated primary keys. See docs for InsertQuery.return_id_list.
- #569, added parse function to the playhouse.db_url module. Thanks @stt!
- Added hacks section to the docs. Please contribute your hacks!
- Calls to Node.in_() and Node.not_in() do not take *args anymore and
instead take a single argument.
2.5.0
- #534, CSV utils was erroneously stripping the primary key from CSV data.
- #537, fix upserts when using insert_many.
- #541, respect autorollback with PostgresqlExtDatabase. Thanks @davidmcclure.
- #551, fix for QueryResultWrapper's implementation of the iterator protocol.
- #554, allow SQLite journal_mode to be set at run-time.
- Fixed case-sensitivity issue with DataSet.
- Added support for CAST expressions.
- Added a hook for extending Node with custom methods.
- JOIN_<type> became JOIN.<type>, e.g. .join(JOIN.LEFT_OUTER).
- OP_<code> became OP.<code>.
- #556, allowed using + and - prefixes to indicate ascending/descending
ordering.
- #550, added Database.initialize_connection() hook.
- #549, bind selected columns to a particular model. Thanks @jhorman, nice PR!
- #531, support for swapping databases at run-time via Using.
- #530, support for SQLCipher and Python3.
- New RowIDField for sqlite_ext playhouse module. This field can be used
to interact with SQLite rowid fields.
- Added LateralJoin helper to the postgres_ext playhouse module.
2.4.7
- #504, Docs updates.
- #506, Fixed regression in aggregate_rows()
- #510, Fixes bug in pwiz overwriting columns.
- #514, Correctly cast foreign keys in prefetch().
- #515, Simplifies queries issued when doing recursive deletes.
- #516, Fix cloning of Field objects.
- #519, Aggregate rows now correctly preserves ordering of joined instances.
- Unreported, fixed bug to not leave expired connections sitting around
in the pool.
- Added support for Postgresql's jsonb type with BinaryJSONField.
- Add some basic Flask helpers.
- Add support for UNION ALL queries in #512
- Add SqlCipherExtDatabase, which combines the sqlcipher database with
the sqlite extensions.
- Add option to print metadata when generating code with pwiz.
2.4.6
- #503, fixes behavior of aggregate_rows() when used with a CompositeKey.
- #498, fixes value coercion for field aliases.
- #492, fixes bug with pwiz and composite primary keys.
- #486, correctly handle schemas with reflection module.
- Peewee has a new ManyToManyField available in the playhouse.shortcuts
module.
- Peewee now has proper support for NOT IN queries through the Node.not_in()
method.
- Models now support iteration. This is equivalent to Model.select().
2.4.5
- #471, #482 and #484, all of which had to do with how joins were handled
by the aggregate_rows() query result wrapper.
- #472 removed some needless special-casing in Model.save().
- #466 fixed case-sensitive issues with the SQLite migrator.
- #474 fixed a handful of bugs that cropped up migrating foreign keys
with SQLite.
- #475 fixed the behavior of the SQLite migrator regarding auto-generated
indexes.
- #479 fixed a bug in the code that stripped extra parentheses
in the SQL generator.
- Fixed a handful of bugs in the APSW extension.
- Added connection abstraction called ExecutionContext (see docs).
- Made all context managers work as decorators (atomic, transaction,
savepoint, execution_context).
- Added explicit methods for IS NULL and IS NOT NULL queries. The latter was
actually necessary since the behavior is different from NOT IS NULL (...).
- Allow disabling backref validation (#465)
- Made quite a few improvements to the documentation, particularly sections
on transactions.
- Added caching to the DataSet extension, which should improve performance.
- Made the SQLite migrator smarter with regards to preserving indexes
when a table copy is necessary.
2.4.4
=====
* Backwards-incompatible changes
- The argument signature for the SqliteExtDatabase.aggregate() decorator
changed so that the aggregate name is the first parameter, and
the number of parameters is the second parameter. If no values are
specified, peewee will choose the name of the class and an un-specified
number of arguments (-1).
- The logic for saving a model with a composite key changed slightly.
Previously, if a model had a composite primary key and you called save(),
only the dirty fields would be saved.
* Bugs fixed
- #462
- #465, add hook for disabling backref validation.
- #466, fix case-sensitive table names with migration module.
- #469, save only dirty fields.
* New features
- Lots of enhancements and cleanup to the playhouse.apsw_ext module.
- The playhouse.reflection module now supports introspecting indexes.
- Added a model option for disabling backref validation.
- Added support for the SQLite closure table extension.
- Added support for virtual fields, which act on dynamically-created
virtual table fields.
- Added a new example: a virtual table implementation that exposes Redis
as a relational database table.
- Added a module playhouse.sqlite_aggregates that contains a handful of
aggregates you may find useful when developing with SQLite.
- Small documentation updates here and there.
2.4.3
=====
* Bugs fixed
- #466, table names are case sensitive in the SQLite migrations module.
- #465, added option to disable backref validation.
- #462, use the schema name consistently with postgres reflection.
* New features
- New model Meta option to disable backref validation. See
validate_backrefs.
- Added documentation on ordering by calculated values.
- Added basic PyPy compatibility.
- Added logic to close cursors after they have been exhausted.
- Structured and consolidated database metadata introspection, including
improvements for introspecting indexes.
- Added support to prefetch for traversing up the query tree.
- Added introspection option to skip invalid models while introspecting.
- Added option to limit the tables introspected.
- Added closed connection detection to the MySQL connection pool.
- Enhancements to passing options to creating virtual tables with SQLite.
- Added factory method for generating Closure tables for use with the
transitive_closure SQLite extension.
- Added support for loading SQLite extensions.
- Numerous test-suite enhancements and new test-cases.
2.4.2
=====
* Bugs fixed
- #449, typo in the db_url extension, thanks to @malea for the fix.
- #457 and #458, fixed documentation deficiences.
* New features
- Added support for importing data when using the DataSet extension.
- Added an encrypted diary app to the examples.
- Better index reconstruction when altering columns on SQLite databases
with the migrate module.
- Support for multi-column primary keys in the reflection module.
- Close cursors more aggressively when executing SELECT queries.
Changes in 2.4.1:
- Fixed#448, add hook to the connection pool for detecting closed
connections.
- Fixed#229, fix join attribute detection.
- Fixed#447, fixed documentation typo.
Changes in 2.4.0:
- Most of the introspection logic was moved out of the pwiz module and
into playhouse.reflection.
- Created a new reflection extension for introspecting databases. The
reflection module additionally can generate actual peewee Model classes
dynamically.
- Created a dataset library (based on the SQLAlchemy project of the same
name). For more info check out the blog post announcing playhouse.dataset.
- Added a db_url module which creates Database objects from a connection
string.
- Added csv dump functionality to the CSV utils extension.
- Added an atomic context manager to support nested transactions.
- Added support for HStore, JSON and TSVector to the reflection module.
- More documentation updates.
- Fixed#440, which fixes a bug where Model.dirty_fields did not return
an empty set for some subclasses of QueryResultWrapper.
Peewee is a simple and small ORM. It has few (but expressive)
concepts, making it easy to learn and intuitive to use.
Supports SQLite, MySQL and PostgreSQL.
