[PonyORM-list] Pony ORM Release 0.5rc1

[Alexey Malashkevich]

Hi all,

We are moving forward to the Pony ORM 0.5 Release and today we've
prepared the release candidate which includes several bug fixes and
a couple of new features. You can obtain the update at our github page
https://github.com/ponyorm/pony
Please let us know if you have any issues with it.

Below is the list of updates:

- Before this release Pony used the exact letter case of an entity for
the MySQL database table names (unless you specify the table name
explicitly using the _table_ option).
This approach turned out to be not reliable on all platforms: “MySQL
table names are case-sensitive depending on the filesystem of the server.
Since Windows and Mac are a case-insensitive OS, and Linux is
case-sensitive;
the MySQL database treats the uppercase table name differently than
lowercase table name on Linux machines.”

The official MySQL documentation reads:
To avoid problems caused by such differences, it is best to adopt a
consistent convention, such as always creating and referring to databases
and tables using lowercase names. This convention is recommended for
maximum portability and ease of use. Following this recommendation,
starting with this release, Pony converts all the table names during its
creation in accordance with the style of the respective database system.
In MySQL and PostgreSQL Pony converts the table names to the lower case.
In Oracle – to the upper case. In SQLite there is no need to convert the
letter case – SQLite works with the table name letter case equally on all
platforms.In order to make the new release compatible with your tables
created with the previous Pony releases you have a couple of options:

Specify the table names for each entity explicitly:

    class MyEntity(db.Entity):
        _table_ = "MyEnity"
        ...

Convert the names of your tables to the lower case using SQL commands
manually:

    RENAME TABLE `MyEntity` TO `myentity`

- Starting with this release the names of tables, indexes and constraints
in the database creation script are sorted in the alphabetical order.
Now you can use lambdas instead of parenthesis for the entities which are
declared later in your code:

    class User(db.Entity):
        name = Required(unicode)
        photos = Set(lambda: Photo)

    class Photo(db.Entity):
        content = Required(buffer)
        user = Required(User)

This can be useful if you want your IDE to check the names of declared
entities and highlight typos.

- Instances now have the before_insert, before_update, before_delete hooks:
    class MyEntity(db.Entity):
        ...
        def before_insert(self):
            print '%s is about to be inserted!' % self
        def before_update(self):
            print '%s is about to be updated!' % self
        def before_delete(self):
            print '%s is about to be deleted!' % self

- Now options.MAX_FETCH_COUNT is set to None by default. Before this
release
Pony would throw the TooManyRowsFound exception if the number of instances
returned by a query exceeds the MAX_FETCH_COUNT. Since this parameter
can vary greatly, Pony doesn’t set it by default anymore.

- We have added the concat() function and now you can do the following:

select(concat(s.name, ':', s.dob.year, ':', s.scholarship) for s in Student)

- With the new Pony release you have the read-only access to the entity
instances outside of the db_session. Before this release any attempt
to use an instance outside of the db_session would result in a
TransactionRolledBack exception. Now you can get the attribute values,
but if the attribute that you’re trying to access was not loaded, then
you’ll get the DatabaseSessionIsOver exception. The same exception will
be raised in case you want to change attribute values.
We hope that this option will not be misused. Most of the time you want
to use entity instances within the db_session. If you find yourself using
the instances outside of the db_session often, you probably doing something
strange.

- Now when you create new instances you can use the value of the primary
key
instead of the object. This is how you created an instance of a Student
before:

    student = Student(name='Student name', group=Group[123])

and now you can pass a primary key of the Group object instead:

    student = Student(name='Student name', group=123)

The same approach can be used for the get() method.

- Now you can specify the sequence name for PrimaryKey attributes for
Oracle
databases using the keyword argument sequence_name=’seq_name’

- The bug #41 was fixed. Now you can use the same variable name in
subsequent
filters and it can have different values.

- Numerous other bugs were fixed.

You can get the latest update from https://github.com/ponyorm/pony

Regards,
Alexey Malashkevich
-------------- next part --------------
An HTML attachment was scrubbed...
URL: </ponyorm-list/attachments/20140526/8f9f9132/attachment.html>