- New improvements to the :func:`.text` construct, including

more flexible ways to set up bound parameters and return types;
in particular, a :func:`.text` can now be turned into a full
FROM-object, embeddable in other statements as an alias or CTE
using the new method :meth:`.TextClause.columns`.
[ticket:2877]

1 files changed, 0 insertions, 166 deletions

diff --git a/test/sql/test_compiler.py b/test/sql/test_compiler.py
index f1f852ddc..36dfa2ff1 100644
--- a/test/sql/test_compiler.py
+++ b/test/sql/test_compiler.py
@@ -1134,172 +1134,6 @@ class SelectTest(fixtures.TestBase, AssertsCompiledSQL):
             dialect=mysql.dialect()
         )
 
-    def test_text(self):
-        self.assert_compile(
-            text("select * from foo where lala = bar"),
-            "select * from foo where lala = bar"
-        )
-
-        # test bytestring
-        self.assert_compile(select(
-            ["foobar(a)", "pk_foo_bar(syslaal)"],
-            "a = 12",
-            from_obj=["foobar left outer join lala on foobar.foo = lala.foo"]
-            ),
-            "SELECT foobar(a), pk_foo_bar(syslaal) FROM foobar "
-            "left outer join lala on foobar.foo = lala.foo WHERE a = 12"
-        )
-
-        # test unicode
-        self.assert_compile(select(
-            ["foobar(a)", "pk_foo_bar(syslaal)"],
-            "a = 12",
-            from_obj=["foobar left outer join lala on foobar.foo = lala.foo"]
-            ),
-            "SELECT foobar(a), pk_foo_bar(syslaal) FROM foobar "
-            "left outer join lala on foobar.foo = lala.foo WHERE a = 12"
-        )
-
-        # test building a select query programmatically with text
-        s = select()
-        s.append_column("column1")
-        s.append_column("column2")
-        s.append_whereclause("column1=12")
-        s.append_whereclause("column2=19")
-        s = s.order_by("column1")
-        s.append_from("table1")
-        self.assert_compile(s, "SELECT column1, column2 FROM table1 WHERE "
-                                "column1=12 AND column2=19 ORDER BY column1")
-
-        self.assert_compile(
-            select(["column1", "column2"],
-                            from_obj=table1).alias('somealias').select(),
-            "SELECT somealias.column1, somealias.column2 FROM "
-            "(SELECT column1, column2 FROM mytable) AS somealias"
-        )
-
-        # test that use_labels doesnt interfere with literal columns
-        self.assert_compile(
-            select(["column1", "column2", table1.c.myid], from_obj=table1,
-                        use_labels=True),
-            "SELECT column1, column2, mytable.myid AS mytable_myid "
-            "FROM mytable"
-        )
-
-        # test that use_labels doesnt interfere
-        # with literal columns that have textual labels
-        self.assert_compile(
-            select(["column1 AS foobar", "column2 AS hoho", table1.c.myid],
-                        from_obj=table1, use_labels=True),
-            "SELECT column1 AS foobar, column2 AS hoho, "
-            "mytable.myid AS mytable_myid FROM mytable"
-        )
-
-        # test that "auto-labeling of subquery columns"
-        # doesnt interfere with literal columns,
-        # exported columns dont get quoted
-        self.assert_compile(
-            select(["column1 AS foobar", "column2 AS hoho", table1.c.myid],
-                            from_obj=[table1]).select(),
-            "SELECT column1 AS foobar, column2 AS hoho, myid FROM "
-            "(SELECT column1 AS foobar, column2 AS hoho, "
-                "mytable.myid AS myid FROM mytable)"
-        )
-
-        self.assert_compile(
-            select(['col1', 'col2'], from_obj='tablename').alias('myalias'),
-            "SELECT col1, col2 FROM tablename"
-        )
-
-    def test_binds_in_text(self):
-        self.assert_compile(
-            text("select * from foo where lala=:bar and hoho=:whee",
-                bindparams=[bindparam('bar', 4), bindparam('whee', 7)]),
-                "select * from foo where lala=:bar and hoho=:whee",
-                checkparams={'bar': 4, 'whee': 7},
-        )
-
-        self.assert_compile(
-            text("select * from foo where clock='05:06:07'"),
-                "select * from foo where clock='05:06:07'",
-                checkparams={},
-                params={},
-        )
-
-        dialect = postgresql.dialect()
-        self.assert_compile(
-            text("select * from foo where lala=:bar and hoho=:whee",
-                bindparams=[bindparam('bar', 4), bindparam('whee', 7)]),
-                "select * from foo where lala=%(bar)s and hoho=%(whee)s",
-                checkparams={'bar': 4, 'whee': 7},
-                dialect=dialect
-        )
-
-        # test escaping out text() params with a backslash
-        self.assert_compile(
-            text("select * from foo where clock='05:06:07' "
-                    "and mork='\:mindy'"),
-            "select * from foo where clock='05:06:07' and mork=':mindy'",
-            checkparams={},
-            params={},
-            dialect=dialect
-        )
-
-        dialect = sqlite.dialect()
-        self.assert_compile(
-            text("select * from foo where lala=:bar and hoho=:whee",
-                bindparams=[bindparam('bar', 4), bindparam('whee', 7)]),
-                "select * from foo where lala=? and hoho=?",
-                checkparams={'bar': 4, 'whee': 7},
-                dialect=dialect
-        )
-
-        self.assert_compile(select(
-            [table1, table2.c.otherid, "sysdate()", "foo, bar, lala"],
-            and_(
-                "foo.id = foofoo(lala)",
-                "datetime(foo) = Today",
-                table1.c.myid == table2.c.otherid,
-            )
-        ),
-        "SELECT mytable.myid, mytable.name, mytable.description, "
-        "myothertable.otherid, sysdate(), foo, bar, lala "
-        "FROM mytable, myothertable WHERE foo.id = foofoo(lala) AND "
-        "datetime(foo) = Today AND mytable.myid = myothertable.otherid")
-
-        self.assert_compile(select(
-            [alias(table1, 't'), "foo.f"],
-            "foo.f = t.id",
-            from_obj=["(select f from bar where lala=heyhey) foo"]
-        ),
-        "SELECT t.myid, t.name, t.description, foo.f FROM mytable AS t, "
-        "(select f from bar where lala=heyhey) foo WHERE foo.f = t.id")
-
-        # test Text embedded within select_from(), using binds
-        generate_series = text(
-                            "generate_series(:x, :y, :z) as s(a)",
-                            bindparams=[bindparam('x', None),
-                                bindparam('y', None), bindparam('z', None)]
-                        )
-
-        s = select([
-                    (func.current_date() +
-                            literal_column("s.a")).label("dates")
-                ]).select_from(generate_series)
-        self.assert_compile(
-                    s,
-                    "SELECT CURRENT_DATE + s.a AS dates FROM "
-                                        "generate_series(:x, :y, :z) as s(a)",
-                    checkparams={'y': None, 'x': None, 'z': None}
-                )
-
-        self.assert_compile(
-                    s.params(x=5, y=6, z=7),
-                    "SELECT CURRENT_DATE + s.a AS dates FROM "
-                                        "generate_series(:x, :y, :z) as s(a)",
-                    checkparams={'y': 6, 'x': 5, 'z': 7}
-                )
-
     @testing.emits_warning('.*empty sequence.*')
     def test_render_binds_as_literal(self):
         """test a compiler that renders binds inline into