-0.4.0beta4
+=======
+CHANGES
+=======
+
+0.4.0beta
+---------
+
- fix to bind param processing such that "False" values (like blank strings)
still get processed/encoded
+
- added session.prune(), trims away instances cached in a session that are
no longer referenced elsewhere. (a utility for for strong-ref identity maps)
0.4.0beta3
+----------
+
- sql types optimization:
+
- new performance tests show a combined mass-insert/mass-select test
as having 68% fewer function calls than the same test run against 0.3.
+
- general performance improvement of result set iteration is around 10-20%.
+
- in types.AbstractType, convert_bind_param() and convert_result_value()
have migrated to callable-returning bind_processor() and result_processor()
methods. if no callable is returned, no pre/post processing function is
called.
+
- hooks added throughout base/sql/defaults to optimize the calling of bind
aram/result processors so that method call overhead is minimized.
+
- support added for executemany() scenarios such that unneeded "last row id"
logic doesn't kick in, parameters aren't excessively traversed.
+
- added 'inherit_foreign_keys' arg to mapper()
+
- added support for string date passthru in sqlite
+
- tickets fixed:
+
- [ticket:738]
- [ticket:739]
- [ticket:743]
- [ticket:744]
+
0.4.0beta2
+----------
+
- mssql improvements
+
- oracle improvements
+
- auto-commit after LOAD DATA INFILE for mysql
- a rudimental SessionExtension class has been added, allowing user-defined
functionality to take place at flush(), commit(), and rollback() boundaries.
+
- added engine_from_config() function for helping to create_engine() from an
.ini style config
+
- base_mapper() becomes a plain attribute
+
- session.execute() and scalar() can search for a Table with which to bind from
using the given ClauseElement
+
- session automatically extrapolates tables from mappers with binds, also uses
base_mapper so that inheritance hierarchies bind automatically
+
- moved ClauseVisitor traversal back to inlined non-recursive
+
- tickets fixed:
- - [ticket:730]
+
+ - [ticket:730]
- [ticket:732]
- [ticket:733]
- [ticket:734]
+
0.4.0beta1
-- beta released
+----------
-0.4.0
- orm
- - speed ! along with recent speedups to ResultProxy, total number of
- function calls significantly reduced for large loads.
- test/perf/masseagerload.py reports 0.4 as having the fewest number
- of function calls across all SA versions (0.1, 0.2, and 0.3)
-
- - new collection_class api and implementation [ticket:213]
- collections are now instrumented via decorations rather than
- proxying. you can now have collections that manage their own
- membership, and your class instance will be directly exposed on the
- relation property. the changes are transparent for most users.
- - InstrumentedList (as it was) is removed, and relation properties
- no longer have 'clear()', '.data', or any other added methods
- beyond those provided by the collection type. you are free, of
- course, to add them to a custom class.
- - __setitem__-like assignments now fire remove events for the
- existing value, if any.
- - dict-likes used as collection classes no longer need to change
- __iter__ semantics- itervalues() is used by default instead. this
- is a backwards incompatible change.
- - subclassing dict for a mapped collection is no longer needed in
- most cases. orm.collections provides canned implementations that
- key objects by a specified column or a custom function of your
- choice.
- - collection assignment now requires a compatible type- assigning
- None to clear a collection or assigning a list to a dict
- collection will now raise an argument error.
- - AttributeExtension moved to interfaces, and .delete is now
- .remove The event method signature has also been swapped around.
-
- - major overhaul for Query: all selectXXX methods
- are deprecated. generative methods are now the standard
- way to do things, i.e. filter(), filter_by(), all(), one(),
- etc. Deprecated methods are docstring'ed with their
- new replacements.
-
- - Class-level properties are now usable as query elements ...no
- more '.c.' ! "Class.c.propname" is now superceded by "Class.propname".
- All clause operators are supported, as well as higher level operators
- such as Class.prop==<some instance> for scalar attributes,
- Class.prop.contains(<some instance>) and Class.prop.any(<some expression>)
- for collection-based attributes (all are also negatable). Table-based column
- expressions as well as columns mounted on mapped classes via 'c' are of
- course still fully available and can be freely mixed with the new attributes.
- [ticket:643]
-
- - removed ancient query.select_by_attributename() capability.
- - the aliasing logic used by eager loading has been generalized, so that
- it also adds full automatic aliasing support to Query. It's no longer
- necessary to create an explicit Alias to join to the same tables multiple times;
- *even for self-referential relationships*.
-
- - join() and outerjoin() take arguments "aliased=True". this causes
- their joins to be built on aliased tables; subsequent calls
- to filter() and filter_by() will translate all table expressions
- (yes, real expressions using the original mapped Table) to be that of
- the Alias for the duration of that join() (i.e. until reset_joinpoint()
- or another join() is called).
- - join() and outerjoin() take arguments "id=<somestring>". when used
- with "aliased=True", the id can be referenced by add_entity(cls, id=<somestring>)
- so that you can select the joined instances even if they're from an alias.
- - join() and outerjoin() now work with self-referential relationships! using
- "aliased=True", you can join as many levels deep as desired, i.e.
- query.join(['children', 'children'], aliased=True); filter criterion will
- be against the rightmost joined table
-
- - added query.populate_existing() - marks the query to reload
- all attributes and collections of all instances touched in the query,
- including eagerly-loaded entities [ticket:660]
-
- - added eagerload_all(), allows eagerload_all('x.y.z') to specify eager
- loading of all properties in the given path
-
- - major overhaul for Session:
- - new function which "configures" a session called "sessionmaker()". send
- various keyword arguments to this function once, returns a new class which
- creates a Session against that stereotype.
- - SessionTransaction removed from "public" API. you now can call begin()/
- commit()/rollback() on the Session itself.
- - Session also supports SAVEPOINT transactions; call begin_nested().
- - Session supports two-phase commit behavior when vertically or horizontally
- partitioning (i.e., using more than one engine). use twophase=True.
- - Session flag "transactional=True" produces a session which always places itself
- into a transaction when first used. upon commit()/rollback()/close(), the
- transaction ends; but begins again on the next usage.
- - Session supports "autoflush=True". this issues a flush() before each query.
- Use in conjunction with transactional, and you can just save()/update()
- and then query, the new objects will be there. use commit() at the end
- (or flush() if non-transactional) to flush remaining changes.
- - new scoped_session() function replaces SessionContext and assignmapper.
- builds onto "sessionmaker()" concept to produce a class whos Session()
- construction returns the thread-local session. Or, call all Session methods
- as class methods, i.e. Session.save(foo); Session.commit(). just like the
- old "objectstore" days.
- - added new "binds" argument to Session to support configuration of multiple
- binds with sessionmaker() function.
- - a rudimental SessionExtension class has been added, allowing user-defined
- functionality to take place at flush(), commit(), and rollback() boundaries.
-
- - query-based relation()s available with dynamic_loader(). This is a *writable*
- collection (supporting append() and remove()) which is also a live Query object
- when accessed for reads. Ideal for dealing with very large collections where
- only partial loading is desired.
-
- - flush-embedded inline INSERT/UPDATE expressions. assign any SQL expression, like
- "sometable.c.column + 1", to an instance's attribute. Upon flush(), the mapper
- detects the expression and embeds it directly in the INSERT or UPDATE statement;
- the attribute gets deferred on the instance so it loads the new value
- the next time you access it.
-
- - a rudimental sharding (horizontal scaling) system is introduced. This system
- uses a modified Session which can distribute read and write operations among
- multiple databases, based on user-defined functions defining the
- "sharding strategy". Instances and their dependents can be distributed
- and queried among multiple databases based on attribute values, round-robin
- approaches or any other user-defined system. [ticket:618]
-
- - Eager loading has been enhanced to allow even more joins in more places.
- It now functions at any arbitrary depth along self-referential
- and cyclical structures. When loading cyclical structures, specify "join_depth"
- on relation() indicating how many times you'd like the table to join
- to itself; each level gets a distinct table alias. The alias names
- themselves are generated at compile time using a simple counting
- scheme now and are a lot easier on the eyes, as well as of course
- completely deterministic. [ticket:659]
-
- - added composite column properties. This allows you to create a
- type which is represented by more than one column, when using the
- ORM. Objects of the new type are fully functional in query expressions,
- comparisons, query.get() clauses, etc. and act as though they are regular
- single-column scalars..except they're not !
- Use the function composite(cls, *columns) inside of the
- mapper's "properties" dict, and instances of cls will be
- created/mapped to a single attribute, comprised of the values
- correponding to *columns [ticket:211]
-
- - improved support for custom column_property() attributes which
- feature correlated subqueries...work better with eager loading now.
-
- - primary key "collapse" behavior; the mapper will analyze all columns
- in its given selectable for primary key "equivalence", that is,
- columns which are equivalent via foreign key relationship or via an
- explicit inherit_condition. primarily for joined-table inheritance
- scenarios where different named PK columns in inheriting tables
- should "collapse" into a single-valued (or fewer-valued) primary key.
- fixes things like [ticket:611].
-
- - joined-table inheritance will now generate the primary key
- columns of all inherited classes against the root table of the
- join only. This implies that each row in the root table is distinct
- to a single instance. If for some rare reason this is not desireable,
- explicit primary_key settings on individual mappers will override it.
-
- - When "polymorphic" flags are used with joined-table or single-table
- inheritance, all identity keys are generated against the root class
- of the inheritance hierarchy; this allows query.get() to work
- polymorphically using the same caching semantics as a non-polymorphic get.
- note that this currently does not work with concrete inheritance.
-
- - secondary inheritance loading: polymorphic mappers can be
- constructed *without* a select_table argument. inheriting mappers
- whose tables were not represented in the initial load will issue a
- second SQL query immediately, once per instance (i.e. not very
- efficient for large lists), in order to load the remaining
- columns.
- - secondary inheritance loading can also move its second query into
- a column- level "deferred" load, via the "polymorphic_fetch"
- argument, which can be set to 'select' or 'deferred'
-
- - it's now possible to map only a subset of available selectable columns
- onto mapper properties, using include_columns/exclude_columns
- [ticket:696].
-
- - added undefer_group() MapperOption, sets a set of "deferred"
- columns joined by a "group" to load as "undeferred".
-
- - rewrite of the "deterministic alias name" logic to be part of the
- SQL layer, produces much simpler alias and label names more in the
- style of Hibernate
-
+ - speed! along with recent speedups to ResultProxy, total number of function
+ calls significantly reduced for large loads.
+
+ - test/perf/masseagerload.py reports 0.4 as having the fewest number of
+ function calls across all SA versions (0.1, 0.2, and 0.3)
+
+ - new collection_class api and implementation [ticket:213] collections are
+ now instrumented via decorations rather than proxying. you can now have
+ collections that manage their own membership, and your class instance will
+ be directly exposed on the relation property. the changes are transparent
+ for most users.
+
+ - InstrumentedList (as it was) is removed, and relation properties no
+ longer have 'clear()', '.data', or any other added methods beyond those
+ provided by the collection type. you are free, of course, to add them to
+ a custom class.
+
+ - __setitem__-like assignments now fire remove events for the existing
+ value, if any.
+
+ - dict-likes used as collection classes no longer need to change __iter__
+ semantics- itervalues() is used by default instead. this is a backwards
+ incompatible change.
+
+ - subclassing dict for a mapped collection is no longer needed in
+ most cases. orm.collections provides canned implementations that
+ key objects by a specified column or a custom function of your
+ choice.
+
+ - collection assignment now requires a compatible type- assigning
+ None to clear a collection or assigning a list to a dict
+ collection will now raise an argument error.
+
+ - AttributeExtension moved to interfaces, and .delete is now
+ .remove The event method signature has also been swapped around.
+
+ - major overhaul for Query
+
+ - all selectXXX methods are deprecated. generative methods are now the
+ standard way to do things, i.e. filter(), filter_by(), all(), one(),
+ etc. deprecated methods are docstring'ed with their new replacements.
+
+ - class-level properties are now usable as query elements... no more
+ '.c.'! "Class.c.propname" is now superceded by "Class.propname". all
+ clause operators are supported, as well as higher level operators such
+ as Class.prop==<some instance> for scalar attributes,
+ Class.prop.contains(<some instance>) and Class.prop.any(<some
+ expression>) for collection-based attributes (all are also
+ negatable). Table-based column expressions as well as columns mounted
+ on mapped classes via 'c' are of course still fully available and can be
+ freely mixed with the new attributes. [ticket:643]
+
+ - removed ancient query.select_by_attributename() capability.
+
+ - the aliasing logic used by eager loading has been generalized, so that
+ it also adds full automatic aliasing support to Query. It's no longer
+ necessary to create an explicit Alias to join to the same tables
+ multiple times; *even for self-referential relationships*.
+
+ - join() and outerjoin() take arguments "aliased=True". this causes
+ their joins to be built on aliased tables; subsequent calls to
+ filter() and filter_by() will translate all table expressions (yes,
+ real expressions using the original mapped Table) to be that of the
+ Alias for the duration of that join() (i.e. until reset_joinpoint() or
+ another join() is called).
+
+ - join() and outerjoin() take arguments "id=<somestring>". when used
+ with "aliased=True", the id can be referenced by add_entity(cls,
+ id=<somestring>) so that you can select the joined instances even if
+ they're from an alias.
+
+ - join() and outerjoin() now work with self-referential relationships!
+ using "aliased=True", you can join as many levels deep as desired,
+ i.e. query.join(['children', 'children'], aliased=True); filter
+ criterion will be against the rightmost joined table
+
+ - added query.populate_existing() - marks the query to reload all
+ attributes and collections of all instances touched in the query,
+ including eagerly-loaded entities [ticket:660]
+
+ - added eagerload_all(), allows eagerload_all('x.y.z') to specify eager
+ loading of all properties in the given path
+
+ - major overhaul for Session:
+
+ - new function which "configures" a session called "sessionmaker()". send
+ various keyword arguments to this function once, returns a new class
+ which creates a Session against that stereotype.
+
+ - SessionTransaction removed from "public" API. you now can call begin()/
+ commit()/rollback() on the Session itself.
+
+ - Session also supports SAVEPOINT transactions; call begin_nested().
+
+ - Session supports two-phase commit behavior when vertically or
+ horizontally partitioning (i.e., using more than one engine). use
+ twophase=True.
+
+ - Session flag "transactional=True" produces a session which always places
+ itself into a transaction when first used. upon
+ commit()/rollback()/close(), the transaction ends; but begins again on
+ the next usage.
+
+ - Session supports "autoflush=True". this issues a flush() before each
+ query. Use in conjunction with transactional, and you can just
+ save()/update() and then query, the new objects will be there. use
+ commit() at the end (or flush() if non-transactional) to flush remaining
+ changes.
+
+ - new scoped_session() function replaces SessionContext and assignmapper.
+ builds onto "sessionmaker()" concept to produce a class whos Session()
+ construction returns the thread-local session. Or, call all Session
+ methods as class methods, i.e. Session.save(foo); Session.commit().
+ just like the old "objectstore" days.
+
+ - added new "binds" argument to Session to support configuration of
+ multiple binds with sessionmaker() function.
+
+ - a rudimental SessionExtension class has been added, allowing
+ user-defined functionality to take place at flush(), commit(), and
+ rollback() boundaries.
+
+ - query-based relation()s available with dynamic_loader(). This is a
+ *writable* collection (supporting append() and remove()) which is also a
+ live Query object when accessed for reads. Ideal for dealing with very
+ large collections where only partial loading is desired.
+
+ - flush-embedded inline INSERT/UPDATE expressions. assign any SQL
+ expression, like "sometable.c.column + 1", to an instance's attribute.
+ Upon flush(), the mapper detects the expression and embeds it directly in
+ the INSERT or UPDATE statement; the attribute gets deferred on the
+ instance so it loads the new value the next time you access it.
+
+ - a rudimental sharding (horizontal scaling) system is introduced. this
+ system uses a modified Session which can distribute read and write
+ operations among multiple databases, based on user-defined functions
+ defining the "sharding strategy". Instances and their dependents can be
+ distributed and queried among multiple databases based on attribute
+ values, round-robin approaches or any other user-defined
+ system. [ticket:618]
+
+ - Eager loading has been enhanced to allow even more joins in more places.
+ It now functions at any arbitrary depth along self-referential and
+ cyclical structures. When loading cyclical structures, specify
+ "join_depth" on relation() indicating how many times you'd like the table
+ to join to itself; each level gets a distinct table alias. The alias
+ names themselves are generated at compile time using a simple counting
+ scheme now and are a lot easier on the eyes, as well as of course
+ completely deterministic. [ticket:659]
+
+ - added composite column properties. this allows you to create a type which
+ is represented by more than one column, when using the ORM. Objects of
+ the new type are fully functional in query expressions, comparisons,
+ query.get() clauses, etc. and act as though they are regular single-column
+ scalars..except they're not ! Use the function composite(cls, *columns)
+ inside of the mapper's "properties" dict, and instances of cls will be
+ created/mapped to a single attribute, comprised of the values correponding
+ to *columns [ticket:211]
+
+ - improved support for custom column_property() attributes which feature
+ correlated subqueries...work better with eager loading now.
+
+ - primary key "collapse" behavior; the mapper will analyze all columns in
+ its given selectable for primary key "equivalence", that is, columns which
+ are equivalent via foreign key relationship or via an explicit
+ inherit_condition. primarily for joined-table inheritance scenarios where
+ different named PK columns in inheriting tables should "collapse" into a
+ single-valued (or fewer-valued) primary key. fixes things like
+ [ticket:611].
+
+ - joined-table inheritance will now generate the primary key columns of all
+ inherited classes against the root table of the join only. This implies
+ that each row in the root table is distinct to a single instance. If for
+ some rare reason this is not desireable, explicit primary_key settings on
+ individual mappers will override it.
+
+ - When "polymorphic" flags are used with joined-table or single-table
+ inheritance, all identity keys are generated against the root class of the
+ inheritance hierarchy; this allows query.get() to work polymorphically
+ using the same caching semantics as a non-polymorphic get. note that this
+ currently does not work with concrete inheritance.
+
+ - secondary inheritance loading: polymorphic mappers can be constructed
+ *without* a select_table argument. inheriting mappers whose tables were
+ not represented in the initial load will issue a second SQL query
+ immediately, once per instance (i.e. not very efficient for large lists),
+ in order to load the remaining columns.
+
+ - secondary inheritance loading can also move its second query into a
+ column- level "deferred" load, via the "polymorphic_fetch" argument,
+ which can be set to 'select' or 'deferred'
+
+ - it's now possible to map only a subset of available selectable columns
+ onto mapper properties, using include_columns/exclude_columns
+ [ticket:696].
+
+ - added undefer_group() MapperOption, sets a set of "deferred" columns
+ joined by a "group" to load as "undeferred".
+
+ - rewrite of the "deterministic alias name" logic to be part of the SQL
+ layer, produces much simpler alias and label names more in the style of
+ Hibernate
+
- sql
- - speed ! clause compilation as well as the mechanics of SQL constructs
- have been streamlined and simplified to a signficant degree, for a
- 20-30% improvement of the statement construction/compilation overhead of
- 0.3
-
+
+ - speed! clause compilation as well as the mechanics of SQL constructs have
+ been streamlined and simplified to a signficant degree, for a 20-30%
+ improvement of the statement construction/compilation overhead of 0.3
+
- all "type" keyword arguments, such as those to bindparam(), column(),
- Column(), and func.<something>(), renamed to "type_". those objects
- still name their "type" attribute as "type".
-
+ Column(), and func.<something>(), renamed to "type_". those objects still
+ name their "type" attribute as "type".
+
- case_sensitive=(True|False) setting removed from schema items, since
- checking this state added a lot of method call overhead and there was
- no decent reason to ever set it to False. Table and column names which are
- all lower case will be treated as case-insenstive (yes we adjust for
+ checking this state added a lot of method call overhead and there was no
+ decent reason to ever set it to False. Table and column names which are
+ all lower case will be treated as case-insenstive (yes we adjust for
Oracle's UPPERCASE style too).
-
+
- transactions:
+
- added context manager (with statement) support for transactions
- added support for two phase commit, works with mysql and postgres so far.
- added a subtransaction implementation that uses savepoints.
- added support for savepoints.
-
+
- MetaData:
- - Tables can be reflected from the database en-masse without
- declaring them in advance. MetaData(engine, reflect=True) will load
- all tables present in the database, or use metadata.reflect() for
- finer control.
+
+ - Tables can be reflected from the database en-masse without declaring
+ them in advance. MetaData(engine, reflect=True) will load all tables
+ present in the database, or use metadata.reflect() for finer control.
- DynamicMetaData has been renamed to ThreadLocalMetaData
- The ThreadLocalMetaData constructor now takes no arguments.
- BoundMetaData has been removed- regular MetaData is equivalent
-
- - Numeric and Float types now have an "asdecimal" flag; defaults to
- True for Numeric, False for Float. when True, values are returned as
- decimal.Decimal objects; when False, values are returned as float().
- the defaults of True/False are already the behavior for PG and MySQL's
- DBAPI modules. [ticket:646]
-
- - new SQL operator implementation which removes all hardcoded operators
- from expression structures and moves them into compilation;
- allows greater flexibility of operator compilation; for example, "+"
- compiles to "||" when used in a string context, or "concat(a,b)" on
- MySQL; whereas in a numeric context it compiles to "+". fixes [ticket:475].
-
+
+ - Numeric and Float types now have an "asdecimal" flag; defaults to True for
+ Numeric, False for Float. when True, values are returned as
+ decimal.Decimal objects; when False, values are returned as float(). the
+ defaults of True/False are already the behavior for PG and MySQL's DBAPI
+ modules. [ticket:646]
+
+ - new SQL operator implementation which removes all hardcoded operators from
+ expression structures and moves them into compilation; allows greater
+ flexibility of operator compilation; for example, "+" compiles to "||"
+ when used in a string context, or "concat(a,b)" on MySQL; whereas in a
+ numeric context it compiles to "+". fixes [ticket:475].
+
- "anonymous" alias and label names are now generated at SQL compilation
time in a completely deterministic fashion...no more random hex IDs
-
- - significant architectural overhaul to SQL elements (ClauseElement).
- all elements share a common "mutability" framework which allows a
- consistent approach to in-place modifications of elements as well as
- generative behavior. improves stability of the ORM which makes
- heavy usage of mutations to SQL expressions.
-
+
+ - significant architectural overhaul to SQL elements (ClauseElement). all
+ elements share a common "mutability" framework which allows a consistent
+ approach to in-place modifications of elements as well as generative
+ behavior. improves stability of the ORM which makes heavy usage of
+ mutations to SQL expressions.
+
- select() and union()'s now have "generative" behavior. methods like
order_by() and group_by() return a *new* instance - the original instance
- is left unchanged. non-generative methods remain as well.
-
+ is left unchanged. non-generative methods remain as well.
+
- the internals of select/union vastly simplified - all decision making
regarding "is subquery" and "correlation" pushed to SQL generation phase.
- select() elements are now *never* mutated by their enclosing containers
- or by any dialect's compilation process [ticket:52] [ticket:569]
-
+ select() elements are now *never* mutated by their enclosing containers or
+ by any dialect's compilation process [ticket:52] [ticket:569]
+
- select(scalar=True) argument is deprecated; use select(..).as_scalar().
the resulting object obeys the full "column" interface and plays better
within expressions
-
+
- added select().with_prefix('foo') allowing any set of keywords to be
placed before the columns clause of the SELECT [ticket:504]
-
+
- added array slice support to row[<index>] [ticket:686]
-
- - result sets make a better attempt at matching the DBAPI types present
- in cursor.description to the TypeEngine objects defined by the dialect,
- which are then used for result-processing. Note this only takes effect
- for textual SQL; constructed SQL statements always have an explicit type map.
-
- - result sets from CRUD operations close their underlying cursor immediately.
- will also autoclose the connection if defined for the operation; this
- allows more efficient usage of connections for successive CRUD operations
- with less chance of "dangling connections".
-
- - Column defaults and onupdate Python functions (i.e. passed to ColumnDefault)
- may take zero or one arguments; the one argument is the ExecutionContext,
- from which you can call "context.parameters[someparam]" to access the other
- bind parameter values affixed to the statement [ticket:559]. The
- connection used for the execution is available as well so that you can
- pre-execute statements.
-
- - added "explcit" create/drop/execute support for sequences
- (i.e. you can pass a "connectable" to each of those methods
- on Sequence)
-
+
+ - result sets make a better attempt at matching the DBAPI types present in
+ cursor.description to the TypeEngine objects defined by the dialect, which
+ are then used for result-processing. Note this only takes effect for
+ textual SQL; constructed SQL statements always have an explicit type map.
+
+ - result sets from CRUD operations close their underlying cursor
+ immediately. will also autoclose the connection if defined for the
+ operation; this allows more efficient usage of connections for successive
+ CRUD operations with less chance of "dangling connections".
+
+ - Column defaults and onupdate Python functions (i.e. passed to
+ ColumnDefault) may take zero or one arguments; the one argument is the
+ ExecutionContext, from which you can call "context.parameters[someparam]"
+ to access the other bind parameter values affixed to the statement
+ [ticket:559]. The connection used for the execution is available as well
+ so that you can pre-execute statements.
+
+ - added "explcit" create/drop/execute support for sequences (i.e. you can
+ pass a "connectable" to each of those methods on Sequence)
+
- better quoting of identifiers when manipulating schemas
-
- - standardized the behavior for table reflection where types can't be located;
- NullType is substituted instead, warning is raised.
+
+ - standardized the behavior for table reflection where types can't be
+ located; NullType is substituted instead, warning is raised.
- ColumnCollection (i.e. the 'c' attribute on tables) follows dictionary
semantics for "__contains__" [ticket:606]
-
+
- engines
- - speed ! the mechanics of result processing and bind parameter processing
- have been overhauled, streamlined and optimized to issue as little method
+
+ - speed! the mechanics of result processing and bind parameter processing
+ have been overhauled, streamlined and optimized to issue as little method
calls as possible. bench tests for mass INSERT and mass rowset iteration
both show 0.4 to be over twice as fast as 0.3, using 68% fewer function
calls.
- - You can now hook into the pool lifecycle and run SQL statements or
- other logic at new each DBAPI connection, pool check-out and check-in.
+ - you can now hook into the pool lifecycle and run SQL statements or other
+ logic at new each DBAPI connection, pool check-out and check-in.
- Connections gain a .properties collection, with contents scoped to the
lifetime of the underlying DBAPI connection
+
- removed auto_close_cursors and disallow_open_cursors arguments from Pool;
- reduces overhead as cursors are normally closed by ResultProxy and Connection.
+ reduces overhead as cursors are normally closed by ResultProxy and
+ Connection.
- extensions
+
- proxyengine is temporarily removed, pending an actually working
replacement.
- - SelectResults has been replaced by Query. SelectResults /
- SelectResultsExt still exist but just return a slightly modified
- Query object for backwards-compatibility. join_to() method
- from SelectResults isn't present anymore, need to use join().
+
+ - SelectResults has been replaced by Query. SelectResults /
+ SelectResultsExt still exist but just return a slightly modified Query
+ object for backwards-compatibility. join_to() method from SelectResults
+ isn't present anymore, need to use join().
- mysql
- - table and column names loaded via reflection are now unicode
- - all standard column types are now supported, including SET
- - table reflection can now be performed in as little as one round-trip
- - ANSI and ANSI_QUOTES sql modes are now supported
- - indexes are now reflected
-
+
+ - table and column names loaded via reflection are now unicode
+
+ - all standard column types are now supported, including SET
+
+ - table reflection can now be performed in as little as one round-trip
+
+ - ANSI and ANSI_QUOTES sql modes are now supported
+
+ - indexes are now reflected
+
- postgres
+
- Added PGArray datatype for using postgres array datatypes
- oracle
- - very rudimental support for OUT parameters added; use sql.outparam(name, type)
- to set up an OUT parameter, just like bindparam(); after execution, values are
- avaiable via result.out_parameters dictionary. [ticket:507]
+
+ - very rudimental support for OUT parameters added; use sql.outparam(name,
+ type) to set up an OUT parameter, just like bindparam(); after execution,
+ values are avaiable via result.out_parameters dictionary. [ticket:507]
0.3.11
- orm
when using pool with threadlocal setting
- mssql
- added support for TIME columns (simulated using DATETIME) [ticket:679]
- - index names are now quoted when dropping from reflected tables [ticket:684]
+ - index names are now quoted when dropping from reflected tables
+ [ticket:684]
- postgres
- when reflecting tables from alternate schemas, the "default" placed upon
the primary key, i.e. usually a sequence name, has the "schema" name
- unconditionally quoted, so that schema names which need quoting are fine.
- its slightly unnecessary for schema names which don't need quoting
- but not harmful.
+ unconditionally quoted, so that schema names which need quoting are
+ fine. its slightly unnecessary for schema names which don't need
+ quoting but not harmful.
0.3.10
- general
projects / thirdparty / sqlalchemy / sqlalchemy.git / commitdiff
