Hey list -

I've just put out 0.5rc1.   This release is *great*, as I am using it  
heavily every day for a project here - it's got my personal seal of  
approval.  0.5 truly rocks in general.    In my particular  
application, I'm making very heavy usage of declarative, single table  
inheritance, SessionExtension, synonyms, and pretty involved column- 
oriented ORM queries.    I've used it to rewrite a CMS driven  
application that was formerly written with Hibernate and it runs about  
five times faster.   So if its good enough for me, it should be good  
enough for anyone :).

In this case "release candidate 1" means, API is complete and ready to  
be used, and we'd like to get user feedback to ensure things work as  
well for them as they are working for us.

The migration guide has been updated and cleaned up, a good read of it  
at http://www.sqlalchemy.org/trac/wiki/05Migration should make the  
upgrade path from 0.4 pretty clear.

Download SQLA 0.5.0rc1 at:  http://www.sqlalchemy.org/download.html

0.5.0rc1
========

- orm
     - Query now has delete() and update(values) methods. This allows
       to perform bulk deletes/updates with the Query object.

     - The RowTuple object returned by Query(*cols) now features
       keynames which prefer mapped attribute names over column keys,
       column keys over column names, i.e.  Query(Class.foo,
       Class.bar) will have names "foo" and "bar" even if those are
       not the names of the underlying Column objects.  Direct Column
       objects such as Query(table.c.col) will return the "key"
       attribute of the Column.

     - Added scalar() and value() methods to Query, each return a
       single scalar value.  scalar() takes no arguments and is
       roughly equivalent to first()[0], value()
       takes a single column expression and is roughly equivalent to
       values(expr).next()[0].

     - Improved the determination of the FROM clause when placing SQL
       expressions in the query() list of entities.  In particular
       scalar subqueries should not "leak" their inner FROM objects
       out into the enclosing query.

     - Joins along a relation() from a mapped class to a mapped
       subclass, where the mapped subclass is configured with single
       table inheritance, will include an IN clause which limits the
       subtypes of the joined class to those requsted, within the ON
       clause of the join.  This takes effect for eager load joins as
       well as query.join().  Note that in some scenarios the IN
       clause will appear in the WHERE clause of the query as well
       since this discrimination has multiple trigger points.

     - AttributeExtension has been refined such that the event
       is fired before the mutation actually occurs.  Addtionally,
       the append() and set() methods must now return the given value,
       which is used as the value to be used in the mutation operation.
       This allows creation of validating AttributeListeners which
       raise before the action actually occurs, and which can change
       the given value into something else before its used.

     - column_property(), composite_property(), and relation() now
       accept a single or list of AttributeExtensions using the
       "extension" keyword argument.

     - query.order_by().get() silently drops the "ORDER BY" from
       the query issued by GET but does not raise an exception.

     - Added a Validator AttributeExtension, as well as a
       @validates decorator which is used in a similar fashion
       as @reconstructor, and marks a method as validating
       one or more mapped attributes.

     - class.someprop.in_() raises NotImplementedError pending the
       implementation of "in_" for relation [ticket:1140]

     - Fixed primary key update for many-to-many collections where
       the collection had not been loaded yet [ticket:1127]

     - Fixed bug whereby deferred() columns with a group in conjunction
       with an otherwise unrelated synonym() would produce
       an AttributeError during deferred load.

     - The before_flush() hook on SessionExtension takes place before
       the list of new/dirty/deleted is calculated for the final
       time, allowing routines within before_flush() to further
       change the state of the Session before the flush proceeds.
       [ticket:1128]

     - The "extension" argument to Session and others can now
       optionally be a list, supporting events sent to multiple
       SessionExtension instances.  Session places SessionExtensions
       in Session.extensions.

     - Reentrant calls to flush() raise an error.  This also serves
       as a rudimentary, but not foolproof, check against concurrent
       calls to Session.flush().

     - Improved the behavior of query.join() when joining to
       joined-table inheritance subclasses, using explicit join
       criteria (i.e. not on a relation).

     - @orm.attributes.on_reconsitute and
       MapperExtension.on_reconstitute have been renamed to
       @orm.reconstructor and MapperExtension.reconstruct_instance

     - Fixed @reconstructor hook for subclasses which inherit from a
       base class.  [ticket:1129]

     - The composite() property type now supports a
       __set_composite_values__() method on the composite class which
       is required if the class represents state using attribute
       names other than the column's keynames; default-generated
       values now get populated properly upon flush.  Also,
       composites with attributes set to None compare correctly.
       [ticket:1132]

     - The 3-tuple of iterables returned by attributes.get_history()
       may now be a mix of lists and tuples.  (Previously members
       were always lists.)

     - Fixed bug whereby changing a primary key attribute on an
       entity where the attribute's previous value had been expired
       would produce an error upon flush(). [ticket:1151]

     - Fixed custom instrumentation bug whereby get_instance_dict()
       was not called for newly constructed instances not loaded
       by the ORM.

     - Session.delete() adds the given object to the session if
       not already present.  This was a regression bug from 0.4.
       [ticket:1150]

     - The `echo_uow` flag on `Session` is deprecated, and unit-of-work
       logging is now application-level only, not per-session level.

     - Removed conflicting `contains()` operator from
       `InstrumentedAttribute` which didn't accept `escape` kwaarg
       [ticket:1153].

- declarative
     - Fixed bug whereby mapper couldn't initialize if a composite
       primary key referenced another table that was not defined
       yet. [ticket:1161]

     - Fixed exception throw which would occur when string-based
       primaryjoin condition was used in conjunction with backref.

- schema
     - Added "sorted_tables" accessor to MetaData, which returns
       Table objects sorted in order of dependency as a list.
       This deprecates the MetaData.table_iterator() method.
       The "reverse=False" keyword argument has also been
       removed from util.sort_tables(); use the Python
       'reversed' function to reverse the results.
       [ticket:1033]

     - The 'length' argument to all Numeric types has been renamed
       to 'scale'.  'length' is deprecated and is still accepted
       with a warning.

     - Dropped 0.3-compatibility for user defined types
       (convert_result_value, convert_bind_param).

- sql
     - Temporarily rolled back the "ORDER BY" enhancement from
       [ticket:1068].  This feature is on hold pending further
       development.

     - The exists() construct won't "export" its contained list
       of elements as FROM clauses, allowing them to be used more
       effectively in the columns clause of a SELECT.

     - and_() and or_() now generate a ColumnElement, allowing
       boolean expressions as result columns, i.e.
       select([and_(1, 0)]).  [ticket:798]

     - Bind params now subclass ColumnElement which allows them to be
       selectable by orm.query (they already had most ColumnElement
       semantics).

     - Added select_from() method to exists() construct, which becomes
       more and more compatible with a regular select().

     - Added func.min(), func.max(), func.sum() as "generic functions",
       which basically allows for their return type to be determined
       automatically.  Helps with dates on SQLite, decimal types,
       others. [ticket:1160]

     - added decimal.Decimal as an "auto-detect" type; bind parameters
       and generic functions will set their type to Numeric when a
       Decimal is used.

- mysql
     - The 'length' argument to MSInteger, MSBigInteger, MSTinyInteger,
       MSSmallInteger and MSYear has been renamed to 'display_width'.

     - Added MSMediumInteger type [ticket:1146].

     - the function func.utc_timestamp() compiles to UTC_TIMESTAMP,  
without
       the parenthesis, which seem to get in the way when using in
       conjunction with executemany().

- oracle
     - limit/offset no longer uses ROW NUMBER OVER to limit rows,
       and instead uses subqueries in conjunction with a special
       Oracle optimization comment.  Allows LIMIT/OFFSET to work
       in conjunction with DISTINCT. [ticket:536]
     - has_sequence() now takes the current "schema" argument into
       account [ticket:1155]
     - added BFILE to reflected type names [ticket:1121]


--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups 
"sqlalchemy" group.
To post to this group, send email to sqlalchemy@googlegroups.com
To unsubscribe from this group, send email to [EMAIL PROTECTED]
For more options, visit this group at 
http://groups.google.com/group/sqlalchemy?hl=en
-~----------~----~----~----~------~----~------~--~---

Reply via email to