- add tentative 'changelog' documentation on #3244

- add test_get_unnamed_unique_constraints to SQLite reflection tests

- fix unique constraint parsing for sqlite -- may return '' for name, however

- Added new method :meth:`.Session.invalidate`, functions similarly
to :meth:`.Session.close`, except also calls
:meth:`.Connection.invalidate`
on all connections, guaranteeing that they will not be returned to
the connection pool.  This is useful in situations e.g. dealing
with gevent timeouts when it is not safe to use the connection further,
even for rollbacks.
references #3258

- update zoomark

- fix up query update /delete documentation, make warnings
a lot clearer, partial fixes for #3252

- keep working on fixing #3266, more cases, more tests

- rework the handle error on connect tests from test_parsconnect where
they don't really belong into a new suite in test_execute

Merge remote-tracking branch 'origin/pr/153'

Removing unneeded space.

- identify another spot where _handle_dbapi_error() needs to do something
differently for the case where it is called in an already-invalidated state;
don't call upon self.connection

- simplify the "noconnection" error handling, setting
_handle_dbapi_exception_noconnection() to only invoke in the case
of raw_connection() in the constructor of Connection.   in all other
cases the Connection proceeds with _handle_dbapi_exception() including
revalidate.

- autoinc here for oracle

- force the _has_events flag to True on engines, so that
profiling is more predictable
- restore the profiling from before this change

- some profile changes likely due to the change in event listening
on engines

- A new series of :class:`.Session` methods which provide hooks
directly into the unit of work's facility for emitting INSERT
and UPDATE statements has been created.  When used correctly,
this expert-oriented system can allow ORM-mappings to be used
to generate bulk insert and update statements batched into
executemany groups, allowing the statements to proceed at
speeds that rival direct use of the Core.
fixes #3100

start docs...

- add an option for bulk_save -> update to not do history

- fix inheritance persistence
- start writing docs

- initial tests for bulk

- rework the assert_sql system so that we have a context manager to work with,
use events that are local to the engine and to the run and are removed afterwards.

Merge branch 'master' into ticket_3100

- SQL Server 2012 now recommends VARCHAR(max), NVARCHAR(max),
VARBINARY(max) for large text/binary types.  The MSSQL dialect will
now respect this based on version detection, as well as the new
``deprecate_large_types`` flag.
fixes #3039

- enhance only_on() to work with compound specs
- fix "temporary_tables" requirement

pep8

- adjust _revalidate_connection() again such that we pass a _wrap=False
to it, so that we say we will do the wrapping just once right here
in _execute_context() / _execute_default().  An adjustment is made
to _handle_dbapi_error() to not assume self.__connection in case
we are already in an invalidated state

further adjustment to
0639c199a547343d62134d2f233225fd2862ec45, 41e7253dee168b8c26c49, #3266

- move inner calls to _revalidate_connection() outside of existing
_handle_dbapi_error(); these are now handled already and the reentrant
call is not needed / breaks things.  Adjustment to 41e7253dee168b8c26c49 /

- The SQLite dialect, when using the :class:`.sqlite.DATE`,
:class:`.sqlite.TIME`,
or :class:`.sqlite.DATETIME` types, and given a ``storage_format`` that
only renders numbers, will render the types in DDL as
``DATE_CHAR``, ``TIME_CHAR``, and ``DATETIME_CHAR``, so that despite the
lack of alpha characters in the values, the column will still
deliver the "text affinity".  Normally this is not needed, as the
textual values within the default storage formats already
imply text.
fixes #3257

- pep8

- document / work around that dialect_options isn't necessarily there

- The engine-level error handling and wrapping routines will now
take effect in all engine connection use cases, including
when user-custom connect routines are used via the
:paramref:`.create_engine.creator` parameter, as well as when
the :class:`.Connection` encounters a connection error on
revalidation.
fixes #3266

- pep8 cleanup

- New Oracle DDL features for tables, indexes: COMPRESS, BITMAP.
Patch courtesy Gabor Gombas.
fixes #3127

- the refactor of the visit_alias() method in Oracle revealed
that quoting should be applied in %(name)s under with_hint.

- Added support for CTEs under Oracle.  This includes some tweaks
to the aliasing syntax, as well as a new CTE feature
:meth:`.CTE.suffix_with`, which is useful for adding in special
Oracle-specific directives to the CTE.
fixes #3220

- Updated the "supports_unicode_statements" flag to True for MySQLdb
and Pymysql under Python 2.   This refers to the SQL statements
themselves, not the parameters, and affects issues such as table
and column names using non-ASCII characters.   These drivers both
appear to support Python 2 Unicode objects without issue in modern
versions.
fixes #3121

- The :meth:`.Operators.match` operator is now handled such that the
return type is not strictly assumed to be boolean; it now
returns a :class:`.Boolean` subclass called :class:`.MatchType`.
The type will still produce boolean behavior when used in Python
expressions, however the dialect can override its behavior at
result time.  In the case of MySQL, while the MATCH operator
is typically used in a boolean context within an expression,
if one actually queries for the value of a match expression, a
floating point value is returned; this value is not compatible
with SQLAlchemy's C-based boolean processor, so MySQL's result-set
behavior now follows that of the :class:`.Float` type.
A new operator object ``notmatch_op`` is also added to better allow
dialects to define the negation of a match operation.
fixes #3263

- The :meth:`.PGDialect.has_table` method will now query against
``pg_catalog.pg_table_is_visible(c.oid)``, rather than testing
for an exact schema match, when the schema name is None; this
so that the method will also illustrate that temporary tables
are present.  Note that this is a behavioral change, as Postgresql
allows a non-temporary table to silently overwrite an existing
temporary table of the same name, so this changes the behavior
of ``checkfirst`` in that unusual scenario.
fixes #3264

Merge remote-tracking branch 'origin/pr/151' into pr151

- Fixed bug in :meth:`.Table.tometadata` method where the
:class:`.CheckConstraint` associated with a :class:`.Boolean`
or :class:`.Enum` type object would be doubled in the target table.
The copy process now tracks the production of this constraint object
as local to a type object.
fixes #3260

- Updated the :ref:`examples_versioned_history` example such that
mapped columns are re-mapped to
match column names as well as grouping of columns; in particular,
this allows columns that are explicitly grouped in a same-column-named
joined inheritance scenario to be mapped in the same way in the
history mappings, avoiding warnings added in the 0.9 series
regarding this pattern and allowing the same view of attribute
keys.

- formatting

- set default dialect here

- changelog, improve docstring/test for #3217.  fixes #3217

Merge branch 'issue_bb_3217' of https://bitbucket.org/jvanasco/sqlalchemy-alt into pr32

Merged in jon_nelson/sqlalchemy/minor_spelling_error (pull request #37)

- fix minor spelling error

Merged in jvanasco/sqlalchemy-alt/issue_docs_event_statement (pull request #33)

added docs to clarify that sql statement is already in a dialect

- add an order_by here

- use self.parent, not table here as there's an attributeerror
trap for self.table that behaves differently in py3k

- refresh all zoomark profiles

- add a new option --force-write-profiles to rewrite profiles even if they
are passing

- The behavioral contract of the :attr:`.ForeignKeyConstraint.columns`
collection has been made consistent; this attribute is now a
:class:`.ColumnCollection` like that of all other constraints and
is initialized at the point when the constraint is associated with
a :class:`.Table`.
fixes #3243

- The :meth:`.PropComparator.of_type` modifier has been
improved in conjunction with loader directives such as
:func:`.joinedload` and :func:`.contains_eager` such that if
two :meth:`.PropComparator.of_type` modifiers of the same
base type/path are encountered, they will be joined together
into a single "polymorphic" entity, rather than replacing
the entity of type A with the one of type B.  E.g.
a joinedload of ``A.b.of_type(BSub1)->BSub1.c`` combined with
joinedload of ``A.b.of_type(BSub2)->BSub2.c`` will create a
single joinedload of ``A.b.of_type((BSub1, BSub2)) -> BSub1.c, BSub2.c``,
without the need for the ``with_polymorphic`` to be explicit
in the query.
fixes #3256

- add some logging to path_registry to help debug eager loading
issues

- Fixed a bug in the examples/generic_assocaitions/discriminator_on_association.py
example, where the subclasses of AddressAssociation were not being
mapped as "single table inheritance", leading to problems when trying
to use the mappings further.

- fix minor spelling error

Merged zzzeek/sqlalchemy into master

- callcounts

- correct this to rewrite a multiple profile line correctly

- Fixed a leak which would occur in the unsupported and highly
non-recommended use case of replacing a relationship on a fixed
mapped class many times, referring to an arbitrarily growing number of
target mappers.  A warning is emitted when the old relationship is
replaced, however if the mapping were already used for querying, the
old relationship would still be referenced within some registries.
fixes #3251

Merged in jon_nelson/sqlalchemy/logging_interpolation (pull request #35)

- don't do inline string interpolation when logging

- don't do inline string interpolation when logging

- Fixed issue where the columns from a SELECT embedded in an
INSERT, either through the values clause or as a "from select",
would pollute the column types used in the result set produced by
the RETURNING clause when columns from both statements shared the
same name, leading to potential errors or mis-adaptation when
retrieving the returning rows.
fixes #3248

- in lieu of adding a new system of translating bound parameter names
for psycopg2 and others, encourage users to take advantage of positional
styles by documenting "paramstyle".   A section is added to psycopg2
specifically as this is a pretty common spot for named parameters
that may be unusually named.  fixes #3246.

- The :attr:`.Column.key` attribute is now used as the source of
anonymous bound parameter names within expressions, to match the
existing use of this value as the key when rendered in an INSERT
or UPDATE statement.   This allows :attr:`.Column.key` to be used
as a "substitute" string to work around a difficult column name
that doesn't translate well into a bound parameter name.   Note that
the paramstyle is configurable on :func:`.create_engine` in any case,
and most DBAPIs today support a named and positional style.
fixes #3245

Merge branch 'master' into ticket_3100

Conflicts:
lib/sqlalchemy/orm/persistence.py

Merge pull request #149 from pbu88/small_error_reporting_improvement_update

Small improvement on FlushError can't update error message

bulk_updates

Merge branch 'master' into ticket_3100

Small improvement on FlushError can't update error message

Output in the error message the table name and the column name.

- edits to the subqueryload ordering merge

Merge branch 'subqueryload_order' of https://bitbucket.org/univerio/sqlalchemy into pr26

Merge pull request #148 from pbu88/small_error_reporting_improvement

Small improvement on FlushError can't delete error message

Small improvement on FlushError can't delete error message

Output in the error message the table name and the column name.

- Fixed bug regarding expression mutations which could express
itself as a "Could not locate column" error when using
:class:`.Query` to  select from multiple, anonymous column
entities when querying against SQLite, as a side effect of the
"join rewriting" feature used by the SQLite dialect.
fixes #3241

It now calls raise_from_cause

master was updated to call util.raise_from_cause which is better
than what I had

Merge branch 'master' into fdbsql-tests

Conflicts:
lib/sqlalchemy/testing/exclusions.py

- ensure kwargs are passed for limit clause on a compound select as well,
further fixes for #3034

Removed accidental print statements

Added requirement for temporary tables

Set the length for MyType implementation

Mysql drops the type in these tests, when it does visit_typeclause,
 since it's an unkown type it just says none,
and doesn't do a cast.
Firebird also doesn't support varchar with length, it throws an
error on these types.

- added new backend for pysqlcipher, as we will probably get
requests for it soon.

changelog

changed connnection to connection

require check constraints for tests

Added requirement to test for bind limit

Forgot to update usage of ex to exc_value

Added new requirement for check_constraints

Print useful traceback on error

_expect_failure was rethrowing the exception without keeping the
traceback, so it was really hard to find out what was actually wrong

typo

move this into behavioral changes

- Fixed bug in single table inheritance where a chain of joins
that included the same single inh entity more than once
(normally this should raise an error) could, in some cases
depending on what was being joined "from", implicitly alias the
second case of the single inh entity, producing
a query that "worked".   But as this implicit aliasing is not
intended in the case of single table inheritance, it didn't
really "work" fully and was very misleading, since it wouldn't
always appear.
fixes #3233

- Fixed bug where the ON clause for :meth:`.Query.join`,
and :meth:`.Query.outerjoin` to a single-inheritance subclass
using ``of_type()`` would not render the "single table criteria" in
the ON clause if the ``from_joinpoint=True`` flag were set.
fixes #3232

Support additional args/kwargs on cursor method

fdbsql has an optional nested kwarg, which is supported in the
actual code, but not in the testing proxy

- changelog for pullreq github:139
- add support for self-referential foreign keys to move over as well when
the table name is changed.

Merge remote-tracking branch 'origin/pr/139' into pr139

- changelog

Merge remote-tracking branch 'origin/pr/137' into pr137

- Reversing a change that was made in 0.9, the "singleton" nature
of the "constants" :func:`.null`, :func:`.true`, and :func:`.false`
has been reverted.   These functions returning a "singleton" object
had the effect that different instances would be treated as the
same regardless of lexical use, which in particular would impact
the rendering of the columns clause of a SELECT statement.
fixes #3170

- Fixed bug where :meth:`.Session.expunge` would not fully detach
the given object if the object had been subject to a delete
operation that was flushed, but not committed.  This would also
affect related operations like :func:`.make_transient`.
fixes #3139