Sync oslo-incubator db.sqlalchemy b9e2499

oslo-incubator db.sqlalchemy has a change that's needed to
support SQLAlchemy 0.9.x. This syncs the change from
oslo-incubator and any other changes that have been made
since the last sync. The oslo-incubator commit hash is
b9e249962128b72a118252216eb4f0bcafd46da0

Here's the list of changes:

9fed4ed Fix Keystone doc build errors with SQLAlchemy 0.9
5b7e61c Dispose db connections pool on disconnect
d1988b9 Set sql_mode callback on connect instead of checkout

Do this to recreate:

 $ python update.py --nodeps --base keystone \
     --dest-dir ../keystone --modules db.sqlalchemy

Change-Id: I93b310d30fc471f52487087597c4d9974a0d722c
Partial-Bug: #1296333

keystone/openstack/common/db/sqlalchemy/models.py

@@ -29,7 +29,7 @@ from sqlalchemy.orm import object_mapper
 from keystone.openstack.common import timeutils
 
 
-class ModelBase(object):
+class ModelBase(six.Iterator):
     """Base class for models."""
     __table_initialized__ = False
 
@@ -78,10 +78,14 @@ class ModelBase(object):
         self._i = iter(columns)
         return self
 
-    def next(self):
+    # In Python 3, __next__() has replaced next().
+    def __next__(self):
         n = six.advance_iterator(self._i)
         return n, getattr(self, n)
 
+    def next(self):
+        return self.__next__()
+
     def update(self, values):
         """Make the model object behave like a dict."""
         for k, v in six.iteritems(values):

keystone/openstack/common/db/sqlalchemy/session.py

@@ -505,13 +505,20 @@ def _ping_listener(engine, dbapi_conn, connection_rec, connection_proxy):
         if engine.dialect.is_disconnect(ex, dbapi_conn, cursor):
             msg = _LW('Database server has gone away: %s') % ex
             LOG.warning(msg)
+
+            # if the database server has gone away, all connections in the pool
+            # have become invalid and we can safely close all of them here,
+            # rather than waste time on checking of every single connection
+            engine.dispose()
+
+            # this will be handled by SQLAlchemy and will force it to create
+            # a new connection and retry the original action
             raise sqla_exc.DisconnectionError(msg)
         else:
             raise
 
 
-def _set_session_sql_mode(dbapi_con, connection_rec,
-                          connection_proxy, sql_mode=None):
+def _set_session_sql_mode(dbapi_con, connection_rec, sql_mode=None):
     """Set the sql_mode session variable.
 
     MySQL supports several server modes. The default is None, but sessions
@@ -566,7 +573,7 @@ def _mysql_set_mode_callback(engine, sql_mode):
     if sql_mode is not None:
         mode_callback = functools.partial(_set_session_sql_mode,
                                           sql_mode=sql_mode)
-        sqlalchemy.event.listen(engine, 'checkout', mode_callback)
+        sqlalchemy.event.listen(engine, 'connect', mode_callback)
     _mysql_check_effective_sql_mode(engine)
 
 

keystone/openstack/common/db/sqlalchemy/utils.py

@@ -32,7 +32,6 @@ from sqlalchemy import MetaData
 from sqlalchemy import or_
 from sqlalchemy.sql.expression import literal_column
 from sqlalchemy.sql.expression import UpdateBase
-from sqlalchemy.sql import select
 from sqlalchemy import String
 from sqlalchemy import Table
 from sqlalchemy.types import NullType
@@ -362,9 +361,9 @@ def drop_old_duplicate_entries_from_table(migrate_engine, table_name,
     columns_for_select = [func.max(table.c.id)]
     columns_for_select.extend(columns_for_group_by)
 
-    duplicated_rows_select = select(columns_for_select,
-                                    group_by=columns_for_group_by,
-                                    having=func.count(table.c.id) > 1)
+    duplicated_rows_select = sqlalchemy.sql.select(
+        columns_for_select, group_by=columns_for_group_by,
+        having=func.count(table.c.id) > 1)
 
     for row in migrate_engine.execute(duplicated_rows_select):
         # NOTE(boris-42): Do not remove row that has the biggest ID.
@@ -374,7 +373,8 @@ def drop_old_duplicate_entries_from_table(migrate_engine, table_name,
         for name in uc_column_names:
             delete_condition &= table.c[name] == row[name]
 
-        rows_to_delete_select = select([table.c.id]).where(delete_condition)
+        rows_to_delete_select = sqlalchemy.sql.select(
+            [table.c.id]).where(delete_condition)
         for row in migrate_engine.execute(rows_to_delete_select).fetchall():
             LOG.info(_LI("Deleting duplicated row with id: %(id)s from table: "
                          "%(table)s") % dict(id=row[0], table=table_name))
@@ -485,7 +485,7 @@ def _change_deleted_column_type_to_boolean_sqlite(migrate_engine, table_name,
         else:
             c_select.append(table.c.deleted == table.c.id)
 
-    ins = InsertFromSelect(new_table, select(c_select))
+    ins = InsertFromSelect(new_table, sqlalchemy.sql.select(c_select))
     migrate_engine.execute(ins)
 
     table.drop()