- pick around gaining modest dings in callcounts here and there

- start locking down querying for cols after observing yesterdays
callcount bump due to the slots thing
- rewrite profiles using new technique

- we really don't want to force lib here, but we do need
it for the plain "pytest" case, so do an append instead of an insert
- add a new tox file to do a full regen of callcounts

- random performance whacking vs. 0.9, in particular we have to watch
for the slots-based __getattr__ thing getting hit

- add this for testing

- fix some more result_map calls

- rename _select_wraps
- replace force_result_map with a mini-API for nested result sets, add
coverage

foo

- the change for #918 was of course not nearly that simple.
The "wrapping" employed by the mssql and oracle dialects using the
"iswrapper" argument was not being used intelligently by the compiler,
and the result map was being written incorrectly, using
*more* columns in the result map than were actually returned by
the statement, due to "row number" columns that are inside the
subquery.   The compiler now writes out result map on the
"top level" select in all cases
fully, and for the mssql/oracle wrapping case extracts out
the "proxied" columns in a second step, which only includes
those columns that are proxied outwards to the top level.

This change might have implications for 3rd party dialects that
might be imitating oracle's approach.   They can safely continue
to use the "iswrapper" kw which is now ignored, but they may
need to also add the _select_wraps argument as well.

- do a full rewrite of callcounts

- The SQL compiler now generates the mapping of expected columns
such that they are matched to the received result set positionally,
rather than by name.  Originally, this was seen as a way to handle
cases where we had columns returned with difficult-to-predict names,
though in modern use that issue has been overcome by anonymous
labeling.   In this version, the approach basically reduces function
call count per-result by a few dozen calls, or more for larger
sets of result columns.  The approach still degrades into a modern
version of the old approach if textual elements modify the result
map, or if any discrepancy in size exists between
the compiled set of columns versus what was received, so there's no
issue for partially or fully textual compilation scenarios where these
lists might not line up.  fixes #918
- callcounts still need to be adjusted down for this so zoomark
tests won't pass at the moment

Merged in jocmeh/sqlalchemy (pull request #46)

minor docstring fix in MappedCollection class

minor docstring fix in MappedCollection class

- changelog and migration notes for new pg8000 features from
pullreq github:132

- add a skip for JSONB on pg8000 if we are on 1.10.1 or earlier

Merge remote-tracking branch 'origin/pr/132' into pr132

- squash-merge the final row_proc integration branch.  this is
a much more modest outcome than what we started with.   The
work of create_row_processor() for ColumnProperty objects
is essentially done at query setup time combined with some
lookups in _instance_processor().
- to allow this change for deferred columns, deferred columns
no longer search for themselves in the result.   If they've been
set up as deferred without any explicit directive to undefer them,
then this is what was asked for.  if we don't do this,
then we're stuck with this performance penalty for all deferred
columns which in the vast majority of typical use cases (e.g. loading
large, legacy tables or tables with many/large very seldom
used values) won't be present in the result and won't be accessed at all.

Update migration_09.rst

typo fix: indivdual -> individual.

- repair issue in declared_attr.cascading such that within a
subclass, the value returned by the descriptor is not available
because the superclass is already mapped with the InstrumentedAttribute,
until the subclass is mapped.  We add a setattr() to set up that
attribute so that the __mapper_args__ hook and possibly others
have access to the "cascaded" version of the attribute within
the call.

- Fixed bugs in ORM object comparisons where comparison of
many-to-one ``!= None`` would fail if the source were an aliased
class, or if the query needed to apply special aliasing to the
expression due to aliased joins or polymorphic querying; also fixed
bug in the case where comparing a many-to-one to an object state
would fail if the query needed to apply special aliasing
due to aliased joins or polymorphic querying.
fixes #3310

- remove the need for a recursive call here

- Fixed bug where internal assertion would fail in the case where
an ``after_rollback()`` handler for a :class:`.Session` incorrectly
adds state to that :class:`.Session` within the handler, and the task
to warn and remove this state (established by :ticket:`2389`) attempts
to proceed.
fixes #3309

- expect_warnings was not expecting and neither was assert_warnings
asserting.

- repair merge failure

- autopep8

- Mapped state internals have been reworked to allow for a 50% reduction
in callcounts specific to the "expiration" of objects, as in
the "auto expire" feature of :meth:`.Session.commit` and
for :meth:`.Session.expire_all`, as well as in the "cleanup" step
which occurs when object states are garbage collected.
fixes #3307

- add the test_expire_lots test for comparison

- add a new section regarding multiprocessing

- additional mysql cast-related test fixes

- The MySQL dialect now supports CAST on types that are constructed
as :class:`.TypeDecorator` objects.

- add a fix to MySQL re: #3074 tests, make sure we check table is present

- test skips for MySQL w new cast warning

- A warning is emitted when :func:`.cast` is used with the MySQL
dialect on a type where MySQL does not support CAST; MySQL only
supports CAST on a subset of datatypes.   SQLAlchemy has for a long
time just omitted the CAST for unsupported types in the case of
MySQL.  While we don't want to change this now, we emit a warning
to show that it's taken place.   A warning is also emitted when
a CAST is used with an older MySQL version (< 4) that doesn't support
CAST at all, it's skipped in this case as well.
fixes #3237

- flake8

- Literal values within a :class:`.DefaultClause`, which is invoked
when using the :paramref:`.Column.server_default` parameter, will
now be rendered using the "inline" compiler, so that they are rendered
as-is, rather than as bound parameters.
fixes #3087

- remove meaningless assignment

- test + changelog

Merge remote-tracking branch 'origin/pr/147' into pr147

Conflicts:
lib/sqlalchemy/orm/query.py

- add versionadded for service_name

Changed pg8000 dialect to cope with native JSON

For versions > 1.10.1 pg8000 returns de-serialized JSON objects rather
than a string. SQL parameters are still strings though.

Make pg8000 version detection more robust

pg8000 uses Versioneer, which means that development versions have
version strings that don't fit into the dotted triple number format.
Released versions will always fit the triple format though.

pg8000 client_encoding in create_engine()

The pg8000 dialect now supports the setting of the PostgreSQL parameter
client_encoding from create_engine().

- automap isn't new anymore

- rework sqlite FK and unique constraint system to combine both PRAGMA
and regexp parsing of SQL in order to form a complete picture of
constraints + their names.  fixes #3244 fixes #3261
- factor various PRAGMA work to be centralized into one call

- 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