updated docs for delete()

reset managed attributes on mapped classes when clear_mappers called

empty out ClassKey registry when clear_mappers() is called

fixes to quoting on "fake" column when used off its table

removed erroneous "lazy"

removed various print statements

added regexp search for "schema" in sequence reflection for [ticket:442], courtesy david.mugnai@spacespa.it

merged the polymorphic relationship refactoring branch in.  i want to go further on that branch and introduce the foreign_keys argument, and further centralize the "intelligence" about the joins and selectables into PropertyLoader so that lazyloader/sync can be simplified, but the current branch goes pretty far.
  - relations keep track of "polymorphic_primaryjoin", "polymorphic_secondaryjoin" which it derives from the plain primaryjoin/secondaryjoin.
  - lazy/eagerloaders work from those polymorphic join objects.
  - the join exported by PropertyLoader to Query/SelectResults is the polymorphic join, so that join_to/etc work properly.
  - Query builds itself against the base Mapper again, not the "polymorphic" mapper.  uses the "polymorphic" version
 only as appropriate.  this helps join_by/join_to/etc to work with polymorphic mappers.
  - Query will also adapt incoming WHERE criterion to the polymorphic mapper, i.e. the "people" table becomes the "person_join" automatically.
  - quoting has been modified since labels made out of non-case-sensitive columns could themselves require quoting..so case_sensitive defaults to True if not otherwise specified (used to be based on the identifier itself).
  - the test harness gets an ORMTest base class and a bunch of the ORM unit tests are using it now, decreases a lot of redundancy.

fixed "eager=True"

- added a standardized test harness for ORM tests
- added three-level mapping test.  needed some massaging for postgres

- fix for multi-level polymorphic mappers

- eager relation to an inheriting mapper wont fail if no rows returned for
the relationship.

added a close() to the single SQL execute, useful for testing pool behavior with the ORM

removed print line

pool_size was there already of course :-|

r/m unused import

add pool_size to "list of all standard options"

- fix to reflection on older DB's that might return array() type for
"show variables like" statements

- calling corresponding_column with keys_ok matches columns on name, not key, since
the name is meaningful with regards to SQL relationships, the key is not
- adjustments to the recent polymorphic relationship refactorings, specifically
for many-to-one relationships to polymorphic unions that did not contain the
base table [ticket:439].  the lazy/eager clause adaption to the selectable
will match up on straight column names (i.e. its a more liberal policy)
- lazy loader will not attempt to adapt the clause to the selectable if
loads_polymorphic is not enabled, since the more liberal policy of adapting
columns fails for more elaborate join conditions
- will have to see if ppl want to do complex joins with polymorphic relations...
may have to add "polymorphic_primaryjoin" in that case as a last resort (would make
working around these issues a snap, tho...)

added unit tests illustrating current workaround for assignmapper method name/collection class collision

raise exception if invalid collection class used

changeset

oracle can conditionally decide if it wants to say "use rowid" in a select statement.
needs to be tweaked vs. when ROW NUMBER OVER ORDER BY is being used, but currently
fixes [ticket:436]

note support for LIMIT in firebird and mssql

formatting

test patches from [ticket:422]

- *slight* support for binary, but still need to figure out how to insert reasonably large
values (over 4K).  requires auto_setinputsizes=True sent to create_engine(), rows must
be fully fetched individually, etc.

attempting to get oracle binary working

0.3.4

- added support for column "key" attribute to be useable in row[<key>]/row.<key>

justify text

add example of joining to labeled table

split out SelectableClassType from TableClassType, so we don't have to do an isinstance check for each dml op

relationships no longer compile against the "selectable" mapper (i.e. the polymorphic mapper).  join conditions, foreign keys etc. are configured against the actual mappers used in the relationship in all cases.  the lazy and eager loaders in turn "adapt" their lazy/eager clauses to that of the "selectable" mapper if one is present.  this is because the join conditions between the mapper's base tables are *far* easier to work with and detect direction etc. compared to an enormous polymorphic union; dealing with the polymorphic union is pushed further out into select query construction.

added "instances" to assign_mapper funcs  [ticket:433]

added a session transaction test

oops, change from yesterday fails the zblog tests...now i understand !

better error message from [ticket:429]

added merge unit test from [ticket:430]

added recursion check to merge

selectby -> select_by

docs:  [ticket:345], [ticket:356], [ticket:48], [ticket:403], [ticket:394],
cleanup/completion of keyword arg documentation for create_engine(), mapper(), and
relation()

- mysql table create options work on a generic passthru now, i.e. Table(..., mysql_engine='InnoDB',
mysql_collate="latin1_german2_ci", mysql_auto_increment="5", mysql_<somearg>...),
helps [ticket:418]

- added "validate=False" argument to assign_mapper, if True will insure that only mapped
attributes are named [ticket:426]

starting to refactor adaptation of inherited properties out of the MapperProperty and into the mapper for now

- tightened down conditions used to locate "relation direction", associating
  the "foreignkey" of the relationship with the "primaryjoin".  the column match now
  must be exact, not just "corresponding".  this enables self-referential relationships on a
  polymorphic mapper.
  - a little bit of improvement to the concept of a "concrete" inheritance mapping, though that concept
  is not well fleshed out yet (added test case to support concrete mappers on top of a polymorphic base).

removed

- fix to "proxy=True" behavior on synonym()

- trailing underscores are trimmed from func.<xxx> calls, such as func.if_()

- changed "BooleanExpression" to subclass from "BinaryExpression", so that boolean
expressions can also follow column-clause behaviors (i.e. label(), etc).
- query.select() had to become more picky about what it considers to be a full "selectable"
and what it considers to be a fragment that represents a WHERE criterion - looks for the presence
of a FromClause now (which is still pretty liberal, since i originally intended the check to be
for select() only).  the previous exception-catch method also added a little stack tracing
overhead anyway.

- fixed bug where delete-orphan basically didn't work with many-to-many relationships [ticket:427],
backref presence generally hid the symptom

added testcase for upcoming ticket

- another fix to subquery correlation so that a subquery which has only one FROM
element will *not* correlate that single element, since at least one FROM element is
required in a query.

has_table wasnt handling case-sensitive table names

 - some deeper error checking when compiling relations, to detect an ambiguous "primaryjoin"
 in the case that both sides of the relationship have foreign key references in the primary
 join condition

removed unnecessary value grab

tweaks

updates, verbiage

- fix to the initial checkfirst for tables to take current schema into account [ticket:424]

document "Accessing the Session"

added testcase to ensure that type gets propigated from scalar subquery to its label

added "options" to exported query API

verbiage updates, this is a work-in-progress (WIP)

- added optional constructor to sql.ColumnCollection
- mapper sets its "primary_key" attribute to be the ultimately decided primary_key column collection post-compilation
- added compare() method to MapperProperty, defines a comparison operation of the columns represented by the property to some value
- all the above combines into today's controversial feature: saying query.select_by(somerelationname=someinstance) will create the join of the primary key columns represented by "somerelationname"'s mapper to the actual primary key in "someinstance".
- docs for the above

- trying to redefine a reflected primary key column as non-primary key raises an error

[ticket:398]

- default cascade is "save-update, merge"
- added another merge unit test

- postgres cursor option is now server_side_cursors=False; some users get bad results using them
so theyre off by default
- type system slightly modified to support TypeDecorators that can be overridden by the dialect
- added an NVarchar type to mssql (produces NVARCHAR), also MSUnicode which provides Unicode-translation
for the NVarchar regardless of dialect convert_unicode setting.

- basic idea of "session.merge()" actually implemented.  needs more testing.

more insure->ensure.  this is going to be a hard habit to break...

- mysql is inconsistent with what kinds of quotes it uses in foreign keys during a
  SHOW CREATE TABLE, reflection updated to accomodate for all three styles [ticket:420]

  - added "fetchmany()" support to ResultProxy

- postgres no longer uses client-side cursors, uses more efficient server side
  cursors via apparently undocumented psycopg2 behavior recently discovered on the
  mailing list.  disable it via create_engine('postgres://', client_side_cursors=True)

add test for max_order non_primary mapper from the list today

- the "op()" function is now treated as an "operation", rather than a "comparison".
  the difference is, an operation produces a BinaryExpression from which further operations
  can occur whereas comparison produces the more restrictive BooleanExpression

brief mention of defer, undefer

added SVN link to setup.py description

typo fix (thanks Paul J)

- added a mutex to the mapper compilation step.  ive been reluctant to add any kind
of threading anything to SA but this is one spot that its its really needed since mappers
are typically "global", and while their state does not change during normal operation, the
initial compilation step does modify internal state significantly, and this step usually
occurs not at module-level initialization time (unless you call compile()) but at first-request
time
- added "compile_mappers()" function as a shortcut to compiling all mappers

tweak to support reflecting eqlite columns that didnt specify a type

- added an error message if you actually try to modify primary key values on an entity
and then flush it.

copyright update

- default "timezone" setting is now False.  this corresponds to Python's datetime
behavior as well as Postgres' timestamp/time types (which is the only timezone-sensitive
dialect at the moment) [ticket:414]

- fix to post_update to insure rows are updated even for non insert/delete scenarios
[ticket:413]

Removed "burned-in" schema name of "dbo". Suggested by janezj

Patch from Paul Johnston that refactors adodbapi vs. pymssql a bit, fixes broken COMMITS in adodbapi

- Firebird fix to autoload multifield foreign keys [ticket:409]
- Firebird NUMERIC type properly handles a type without precision [ticket:409]

- order of constraint creation puts primary key first before all other constraints;
required for firebird, not a bad idea for others [ticket:408]

- fixed bug in mapper refresh/expire whereby eager loaders didnt properly re-populate
item lists [ticket:407]

- added "none" to the list of cascades, although im not sure if we should really allow "none" since it currently doesnt do anything (what should it do, cancel out the other cascades?)

- invalid options sent to 'cascade' string will raise an exception [ticket:406]

- global "insure"->"ensure" change.  in US english "insure" is actually
largely interchangeable with "ensure" (so says the dictionary), so I'm not
completely illiterate, but its definitely sub-optimal to "ensure" which is
non-ambiguous.

- speed enhancements to ORM object instantiation, eager loading of rows

- fix to correlation of subqueries when the column list of the select statement
is constructed with individual calls to append_column(); this fixes an ORM
bug whereby nested select statements were not getting correlated with the
main select generated by the Query object.

- fixes to postgres reflection to better handle when schema names are present;
thanks to jason (at) ncsmags.com [ticket:402]

- fix to MapperExtension create_instance so that entity_name properly associated
with new instance

reversing last commit

added missing ref to between in sql.py __all__

- added "BIGSERIAL" support for postgres table with PGBigInteger/autoincrement

PGBigInteger subclasses PGInteger so it gets used