Create initial 2.0 engine implementation

Implemented the SQLAlchemy 2 :func:`.future.create_engine` function which
is used for forwards compatibility with SQLAlchemy 2.   This engine
features always-transactional behavior with autobegin.

Allow execution options per statement execution.  This includes
that the before_execute() and after_execute() events now accept
an additional dictionary with these options, empty if not
passed; a legacy event decorator is added for backwards compatibility
which now also emits a deprecation warning.

Add some basic tests for execution, transactions, and
the new result object.   Build out on a new testing fixture
that swaps in the future engine completely to start with.

Change-Id: I70e7338bb3f0ce22d2f702537d94bb249bd9fb0a
Fixes: #4644

3 files changed, 119 insertions, 4 deletions

diff --git a/test/sql/test_defaults.py b/test/sql/test_defaults.py
index fd5aec503..7352810ae 100644
--- a/test/sql/test_defaults.py
+++ b/test/sql/test_defaults.py
@@ -535,7 +535,7 @@ class DefaultRoundTripTest(fixtures.TablesTest):
         result = connection.execute(t.select().order_by(t.c.col1))
         today = datetime.date.today()
         eq_(
-            result.fetchall(),
+            list(result),
             [
                 (
                     x,
@@ -715,9 +715,11 @@ class DefaultRoundTripTest(fixtures.TablesTest):
             "group 1",
             connection.execute,
             t.insert(),
-            {"col4": 7, "col7": 12, "col8": 19},
-            {"col4": 7, "col8": 19},
-            {"col4": 7, "col7": 12, "col8": 19},
+            [
+                {"col4": 7, "col7": 12, "col8": 19},
+                {"col4": 7, "col8": 19},
+                {"col4": 7, "col7": 12, "col8": 19},
+            ],
         )
 
     def test_insert_values(self, connection):
@@ -834,6 +836,13 @@ class DefaultRoundTripTest(fixtures.TablesTest):
         eq_(55, row._mapping["col3"])
 
 
+class FutureDefaultRoundTripTest(
+    fixtures.FutureEngineMixin, DefaultRoundTripTest
+):
+
+    __backend__ = True
+
+
 class CTEDefaultTest(fixtures.TablesTest):
     __requires__ = ("ctes", "returning", "ctes_on_dml")
     __backend__ = True
diff --git a/test/sql/test_resultset.py b/test/sql/test_resultset.py
index 470417dd3..1611dc1ba 100644
--- a/test/sql/test_resultset.py
+++ b/test/sql/test_resultset.py
@@ -29,6 +29,7 @@ from sqlalchemy.engine import default
 from sqlalchemy.engine import result as _result
 from sqlalchemy.engine import Row
 from sqlalchemy.ext.compiler import compiles
+from sqlalchemy.future import select as future_select
 from sqlalchemy.sql import ColumnElement
 from sqlalchemy.sql import expression
 from sqlalchemy.sql.selectable import TextualSelect
@@ -2237,3 +2238,98 @@ class AlternateResultProxyTest(fixtures.TablesTest):
             le_(len(result.cursor_strategy._rowbuffer), max_size)
 
         eq_(checks, assertion)
+
+
+class FutureResultTest(fixtures.FutureEngineMixin, fixtures.TablesTest):
+    __backend__ = True
+
+    @classmethod
+    def define_tables(cls, metadata):
+        Table(
+            "users",
+            metadata,
+            Column("user_id", INT, primary_key=True, autoincrement=False),
+            Column("user_name", VARCHAR(20)),
+            Column("x", Integer),
+            Column("y", Integer),
+            test_needs_acid=True,
+        )
+        Table(
+            "users_autoinc",
+            metadata,
+            Column(
+                "user_id", INT, primary_key=True, test_needs_autoincrement=True
+            ),
+            Column("user_name", VARCHAR(20)),
+            test_needs_acid=True,
+        )
+
+    def test_fetchall(self, connection):
+        users = self.tables.users
+        connection.execute(
+            users.insert(),
+            [
+                {"user_id": 7, "user_name": "jack", "x": 1, "y": 2},
+                {"user_id": 8, "user_name": "ed", "x": 2, "y": 3},
+                {"user_id": 9, "user_name": "fred", "x": 15, "y": 20},
+            ],
+        )
+
+        result = connection.execute(
+            future_select(users).order_by(users.c.user_id)
+        )
+        eq_(
+            result.all(),
+            [(7, "jack", 1, 2), (8, "ed", 2, 3), (9, "fred", 15, 20)],
+        )
+
+    @testing.combinations(
+        ((1, 0), [("jack", 7), ("ed", 8), ("fred", 9)]),
+        ((3,), [(2,), (3,), (20,)]),
+        ((-2, -1), [(1, 2), (2, 3), (15, 20)]),
+        argnames="columns, expected",
+    )
+    def test_columns(self, connection, columns, expected):
+        users = self.tables.users
+        connection.execute(
+            users.insert(),
+            [
+                {"user_id": 7, "user_name": "jack", "x": 1, "y": 2},
+                {"user_id": 8, "user_name": "ed", "x": 2, "y": 3},
+                {"user_id": 9, "user_name": "fred", "x": 15, "y": 20},
+            ],
+        )
+
+        result = connection.execute(
+            future_select(users).order_by(users.c.user_id)
+        )
+        eq_(result.columns(*columns).all(), expected)
+
+    def test_partitions(self, connection):
+        users = self.tables.users
+        connection.execute(
+            users.insert(),
+            [
+                {
+                    "user_id": i,
+                    "user_name": "user %s" % i,
+                    "x": i * 5,
+                    "y": i * 20,
+                }
+                for i in range(500)
+            ],
+        )
+
+        result = connection.execute(
+            future_select(users).order_by(users.c.user_id)
+        )
+
+        start = 0
+        for partition in result.columns(0, 1).partitions(20):
+            eq_(
+                partition,
+                [(i, "user %s" % i) for i in range(start, start + 20)],
+            )
+            start += 20
+
+        assert result._soft_closed
diff --git a/test/sql/test_sequences.py b/test/sql/test_sequences.py
index 8beee514a..1d78c0904 100644
--- a/test/sql/test_sequences.py
+++ b/test/sql/test_sequences.py
@@ -279,6 +279,11 @@ class SequenceExecTest(fixtures.TestBase):
             self._assert_seq_result(r.inserted_primary_key[0])
 
 
+class FutureSequenceExecTest(fixtures.FutureEngineMixin, SequenceExecTest):
+    __requires__ = ("sequences",)
+    __backend__ = True
+
+
 class SequenceTest(fixtures.TestBase, testing.AssertsCompiledSQL):
     __requires__ = ("sequences",)
     __backend__ = True
@@ -396,6 +401,11 @@ class SequenceTest(fixtures.TestBase, testing.AssertsCompiledSQL):
         eq_(result.inserted_primary_key, [1])
 
 
+class FutureSequenceTest(fixtures.FutureEngineMixin, SequenceTest):
+    __requires__ = ("sequences",)
+    __backend__ = True
+
+
 class TableBoundSequenceTest(fixtures.TablesTest):
     __requires__ = ("sequences",)
     __backend__ = True