CVS commit: pkgsrc/databases/py-sqlalchemy

["Tonnerre Lombard" <tonnerre%netbsd.org@localhost>]

Module Name:    pkgsrc
Committed By:   tonnerre
Date:           Mon Oct 14 17:57:30 UTC 2013

Modified Files:
        pkgsrc/databases/py-sqlalchemy: Makefile PLIST distinfo

Log Message:
Update py-sqlalchemy to version 0.8.2.

Changes since 0.7.10:
 - Compatibility for Python 2.4 is being dropped.
 - The primaryjoin argument is no longer needed when constructing a
   relationship() against a class that has multiple foreign key paths to the
   target.
 - Relationships against self-referential, composite foreign keys where a
   column points to itself are now supported.
 - Previously difficult custom join conditions, like those involving
   functions and/or CASTing of types, will now function as expected in most
   cases.
 - New Class/Object Inspection System.
 - A new enhancement to the aliased() construct has been added called
   with_polymorphic() which allows any entity to be “aliased” into a
   “polymorphic” version of itself, freely usable anywhere.
 - The PropComparator.of_type() method can now be used to target any number
   of target subtypes, by combining it with the new with_polymorphic()
   function.
 - Mapper and instance events can now be associated with an unmapped
   superclass, where those events will be propagated to subclasses as those
   subclasses are mapped. The propagate=True flag should be used.
 - The registry of class names is now sensitive to the owning module and
   package of a given class. The classes can be referred to via dotted name
   in expressions.
 - The “deferred reflection” feature allows the construction of declarative
   mapped classes with only placeholder Table metadata, until a prepare()
   step is called, given an Engine with which to reflect fully all tables
   and establish actual mappings. The system supports overriding of columns,
   single and joined inheritance, as well as distinct bases-per-engine.
 - A new SQL registration system allows a mapped class to be accepted as a
   FROM clause within the core.
 - The new UPDATE..FROM mechanics work in query.update().
 - Upon rollback(), only those objects that were made dirty since the last
   flush will be expired, the rest of the Session remains intact.
 - Caching Example now uses dogpile.cache.
 - The new operator system in Core associates new and overridden operators
   with types.
 - SQL expressions can now be associated with types.
 - The inspect() function introduced in New Class/Object Inspection System
   also applies to the core.
 - select() now has a method Select.correlate_except() which specifies
   “correlate on all FROM clauses except those specified”.
 - Support for Postgresql’s HSTORE type is now available as
   postgresql.HSTORE. This type makes great usage of the new operator system
   to provide a full range of operators for HSTORE types, including index
   access, concatenation, and containment methods such as has_key(),
   has_any(), and matrix().
 - The postgresql.ARRAY type will accept an optional “dimension” argument,
   pinning it to a fixed number of dimensions and greatly improving
   efficiency when retrieving results.
 - SQLite has no built-in DATE, TIME, or DATETIME types, and instead
   provides some support for storage of date and time values either as
   strings or integers.
 - The “collate” keyword, long accepted by the MySQL dialect, is now
   established on all String types and will render on any backend, including
   when features such as MetaData.create_all() and cast() is used.
 - Geared towards MySQL, a “prefix” can be rendered within any of these
   constructs.
 - The consideration of a “pending” object as an “orphan” has been made more
   aggressive.
 - The after_attach event fires after the item is associated with the
   Session instead of before; before_attach added.
 - Query now auto-correlates like a select() does.
 - Correlation is now always context-specific.
 - create_all() and drop_all() will now honor an empty list as such.
 - Repaired the Event Targeting of InstrumentationEvents.
 - No more magic coercion of “=” to IN when comparing to subquery in
   MS-SQL.
 - The Session.is_modified() method accepts an argument passive which
   basically should not be necessary, the argument in all cases should be
   the value True - when left at its default of False it would have the
   effect of hitting the database, and often triggering autoflush which
   would itself change the results. In 0.8 the passive argument will have no
   effect, and unloaded attributes will never be checked for history since
   by definition there can be no pending state change on an unloaded
   attribute.
 - Column.key is honored in the Select.c attribute of select() with
   Select.apply_labels().
 - A relationship() that is many-to-one or many-to-many and specifies
   “cascade=’all, delete-orphan’”, which is an awkward but nonetheless
   supported use case (with restrictions) will now raise an error if the
   relationship does not specify the single_parent=True option.
 - Adding the inspector argument to the column_reflect event.
 - The MySQL dialect does two calls, one very expensive, to load all
   possible collations from the database as well as information on casing,
   the first time an Engine connects. Neither of these collections are used
   for any SQLAlchemy functions, so these calls will be changed to no longer
   be emitted automatically. Applications that might have relied on these
   collections being present on engine.dialect will need to call upon
   _detect_collations() and _detect_casing() directly.
 - Inspector.get_primary_keys() is deprecated, use
   Inspector.get_pk_constraint.
 - Case-insensitive result row names will be disabled in most cases. It will
   be available only optionally, by passing the flag `case_sensitive=False`
   to `create_engine()`, but otherwise column names requested from the row
   must match as far as casing.
 - The sqlalchemy.orm.interfaces.InstrumentationManager class is moved to
   sqlalchemy.ext.instrumentation.InstrumentationManager.
 - SQLSoup is now moved into its own project and documented/released
   separately; see https://bitbucket.org/zzzeek/sqlsoup.
 - The older “mutable” system within the SQLAlchemy ORM has been removed.
 - We had left in an alias sqlalchemy.exceptions to attempt to make it
   slightly easier for some very old libraries that hadn’t yet been upgraded
   to use sqlalchemy.exc. Some users are still being confused by it however
   so in 0.8 we’re taking it out entirely to eliminate any of that confusion.


To generate a diff of this commit:
cvs rdiff -u -r1.7 -r1.8 pkgsrc/databases/py-sqlalchemy/Makefile \
    pkgsrc/databases/py-sqlalchemy/PLIST
cvs rdiff -u -r1.5 -r1.6 pkgsrc/databases/py-sqlalchemy/distinfo

Please note that diffs are not public domain; they are subject to the
copyright notices on the relevant files.