- The behavior of :meth:`.Table.tometadata` has been adjusted such that

the schema target of a :class:`.ForeignKey` will not be changed unless
that schema matches that of the parent table.  That is, if
a table "schema_a.user" has a foreign key to "schema_b.order.id",
the "schema_b" target will be maintained whether or not the
"schema" argument is passed to :meth:`.Table.tometadata`.  However
if a table "schema_a.user" refers to "schema_a.order.id", the presence
of "schema_a" will be updated on both the parent and referred tables.
This is a behavioral change hence isn't likely to be backported to
0.8; it is assumed that the previous behavior is pretty buggy
however and that it's unlikely anyone was relying upon it.

Additionally, a new parameter has been added
:paramref:`.Table.tometadata.referred_schema_fn`.  This refers to a
callable function which will be used to determine the new referred
schema for any :class:`.ForeignKeyConstraint` encountered in the
tometadata operation.  This callable can be used to revert to the
previous behavior or to customize how referred schemas are treated
on a per-constraint basis.  [ticket:2913]

- rework the tests in test.sql.test_metadata, all the "tometadata" tests
now under new class ToMetaDataTest

diff --git a/doc/build/changelog/changelog_09.rst b/doc/build/changelog/changelog_09.rst
index 573548cfa4276bbb23fa23706ba1a75192a2238c..dbd26bd1f71817730d8232a7bc08eb8fbf7857fd 100644 (file)
--- a/doc/build/changelog/changelog_09.rst
+++ b/doc/build/changelog/changelog_09.rst
@@ -14,6 +14,30 @@
 .. changelog::
     :version: 0.9.2
 
+    .. change::
+        :tags: bug, sql
+        :tickets: 2913
+
+        The behavior of :meth:`.Table.tometadata` has been adjusted such that
+        the schema target of a :class:`.ForeignKey` will not be changed unless
+        that schema matches that of the parent table.  That is, if
+        a table "schema_a.user" has a foreign key to "schema_b.order.id",
+        the "schema_b" target will be maintained whether or not the
+        "schema" argument is passed to :meth:`.Table.tometadata`.  However
+        if a table "schema_a.user" refers to "schema_a.order.id", the presence
+        of "schema_a" will be updated on both the parent and referred tables.
+        This is a behavioral change hence isn't likely to be backported to
+        0.8; it is assumed that the previous behavior is pretty buggy
+        however and that it's unlikely anyone was relying upon it.
+
+        Additionally, a new parameter has been added
+        :paramref:`.Table.tometadata.referred_schema_fn`.  This refers to a
+        callable function which will be used to determine the new referred
+        schema for any :class:`.ForeignKeyConstraint` encountered in the
+        tometadata operation.  This callable can be used to revert to the
+        previous behavior or to customize how referred schemas are treated
+        on a per-constraint basis.
+
     .. change::
         :tags: bug, orm
         :tickets: 2932

diff --git a/lib/sqlalchemy/sql/schema.py b/lib/sqlalchemy/sql/schema.py
index 621ac20e8f1b72883776c206658977c40e719c62..ef4b4cfa56103745535cb658b1004b6284db625d 100644 (file)
--- a/lib/sqlalchemy/sql/schema.py
+++ b/lib/sqlalchemy/sql/schema.py
@@ -661,31 +661,61 @@ class Table(DialectKWArgs, SchemaItem, TableClause):
                             self,
                             checkfirst=checkfirst)
 
-    def tometadata(self, metadata, schema=RETAIN_SCHEMA):
+    def tometadata(self, metadata, schema=RETAIN_SCHEMA, referred_schema_fn=None):
         """Return a copy of this :class:`.Table` associated with a different
         :class:`.MetaData`.
 
         E.g.::
 
-            some_engine = create_engine("sqlite:///some.db")
+            m1 = MetaData()
 
-            # create two metadata
-            meta1 = MetaData()
-            meta2 = MetaData()
+            user = Table('user', m1, Column('id', Integer, priamry_key=True))
 
-            # load 'users' from the sqlite engine
-            users_table = Table('users', meta1, autoload=True,
-                                    autoload_with=some_engine)
+            m2 = MetaData()
+            user_copy = user.tometadata(m2)
 
-            # create the same Table object for the plain metadata
-            users_table_2 = users_table.tometadata(meta2)
+        :param metadata: Target :class:`.MetaData` object, into which the
+         new :class:`.Table` object will be created.
 
-        :param metadata: Target :class:`.MetaData` object.
-        :param schema: Optional string name of a target schema, or
-         ``None`` for no schema.  The :class:`.Table` object will be
-         given this schema name upon copy.   Defaults to the special
-         symbol :attr:`.RETAIN_SCHEMA` which indicates no change should be
-         made to the schema name of the resulting :class:`.Table`.
+        :param schema: optional string name indicating the target schema.
+         Defaults to the special symbol :attr:`.RETAIN_SCHEMA` which indicates
+         that no change to the schema name should be made in the new
+         :class:`.Table`.  If set to a string name, the new :class:`.Table`
+         will have this new name as the ``.schema``.  If set to ``None``, the
+         schema will be set to that of the schema set on the target
+         :class:`.MetaData`, which is typically ``None`` as well, unless
+         set explicitly::
+
+            m2 = MetaData(schema='newschema')
+
+            # user_copy_one will have "newschema" as the schema name
+            user_copy_one = user.tometadata(m2, schema=None)
+
+            m3 = MetaData()  # schema defaults to None
+
+            # user_copy_two will have None as the schema name
+            user_copy_two = user.tometadata(m3, schema=None)
+
+        :param referred_schema_fn: optional callable which can be supplied
+         in order to provide for the schema name that should be assigned
+         to the referenced table of a :class:`.ForeignKeyConstraint`.
+         The callable accepts this parent :class:`.Table`, the
+         target schema that we are changing to, the :class:`.ForeignKeyConstraint`
+         object, and the existing "target schema" of that constraint.  The
+         function should return the string schema name that should be applied.
+         E.g.::
+
+                def referred_schema_fn(table, to_schema,
+                                                constraint, referred_schema):
+                    if referred_schema == 'base_tables':
+                        return referred_schema
+                    else:
+                        return to_schema
+
+                new_table = table.tometadata(m2, schema="alt_schema",
+                                        referred_schema_fn=referred_schema_fn)
+
+         .. versionadded:: 0.9.2
 
         """
 
@@ -707,8 +737,16 @@ class Table(DialectKWArgs, SchemaItem, TableClause):
             *args, **self.kwargs
             )
         for c in self.constraints:
-            table.append_constraint(c.copy(schema=schema, target_table=table))
+            if isinstance(c, ForeignKeyConstraint):
+                referred_schema = c._referred_schema
+                if referred_schema_fn:
+                    fk_constraint_schema = referred_schema_fn(self, schema, c, referred_schema)
+                else:
+                    fk_constraint_schema = schema if referred_schema == self.schema else None
+                table.append_constraint(c.copy(schema=fk_constraint_schema, target_table=table))
 
+            else:
+                table.append_constraint(c.copy(schema=schema, target_table=table))
         for index in self.indexes:
             # skip indexes that would be generated
             # by the 'index' flag on Column
@@ -1429,6 +1467,10 @@ class ForeignKey(DialectKWArgs, SchemaItem):
         else:
             return self._colspec
 
+    @property
+    def _referred_schema(self):
+        return self._column_tokens[0]
+
 
     def _table_key(self):
         if self._table_column is not None:
@@ -1465,7 +1507,7 @@ class ForeignKey(DialectKWArgs, SchemaItem):
     def _column_tokens(self):
         """parse a string-based _colspec into its component parts."""
 
-        m = self._colspec.split('.')
+        m = self._get_colspec().split('.')
         if m is None:
             raise exc.ArgumentError(
                 "Invalid foreign key column specification: %s" %
@@ -2447,6 +2489,13 @@ class ForeignKeyConstraint(Constraint):
                 columns[0].table is not None:
             self._set_parent_with_dispatch(columns[0].table)
 
+    @property
+    def _referred_schema(self):
+        for elem in self._elements.values():
+            return elem._referred_schema
+        else:
+            return None
+
     def _validate_dest_table(self, table):
         table_keys = set([elem._table_key() for elem in self._elements.values()])
         if None not in table_keys and len(table_keys) > 1:

diff --git a/test/sql/test_metadata.py b/test/sql/test_metadata.py
index 36c777c9a2aec49eee592069ac8d7da059bf8251..dd3f4fc3d7ef1fc5c6d5ad501804bcb1f2a46c2f 100644 (file)
--- a/test/sql/test_metadata.py
+++ b/test/sql/test_metadata.py
@@ -306,8 +306,168 @@ class MetaDataTest(fixtures.TestBase, ComparesTables):
         )
 
 
-    @testing.exclude('mysql', '<', (4, 1, 1), 'early types are squirrely')
-    def test_to_metadata(self):
+
+    def test_pickle_metadata_sequence_restated(self):
+        m1 = MetaData()
+        Table('a', m1,
+             Column('id', Integer, primary_key=True),
+             Column('x', Integer, Sequence("x_seq")))
+
+        m2 = pickle.loads(pickle.dumps(m1))
+
+        s2 = Sequence("x_seq")
+        t2 = Table('a', m2,
+             Column('id', Integer, primary_key=True),
+             Column('x', Integer, s2),
+             extend_existing=True)
+
+        assert m2._sequences['x_seq'] is t2.c.x.default
+        assert m2._sequences['x_seq'] is s2
+
+
+    def test_sequence_restated_replaced(self):
+        """Test restatement of Sequence replaces."""
+
+        m1 = MetaData()
+        s1 = Sequence("x_seq")
+        t = Table('a', m1,
+             Column('x', Integer, s1)
+        )
+        assert m1._sequences['x_seq'] is s1
+
+        s2 = Sequence('x_seq')
+        Table('a', m1,
+             Column('x', Integer, s2),
+             extend_existing=True
+        )
+        assert t.c.x.default is s2
+        assert m1._sequences['x_seq'] is s2
+
+
+    def test_pickle_metadata_sequence_implicit(self):
+        m1 = MetaData()
+        Table('a', m1,
+             Column('id', Integer, primary_key=True),
+             Column('x', Integer, Sequence("x_seq")))
+
+        m2 = pickle.loads(pickle.dumps(m1))
+
+        t2 = Table('a', m2, extend_existing=True)
+
+        eq_(m2._sequences, {'x_seq': t2.c.x.default})
+
+    def test_pickle_metadata_schema(self):
+        m1 = MetaData()
+        Table('a', m1,
+             Column('id', Integer, primary_key=True),
+             Column('x', Integer, Sequence("x_seq")),
+             schema='y')
+
+        m2 = pickle.loads(pickle.dumps(m1))
+
+        Table('a', m2, schema='y',
+             extend_existing=True)
+
+        eq_(m2._schemas, m1._schemas)
+
+    def test_metadata_schema_arg(self):
+        m1 = MetaData(schema='sch1')
+        m2 = MetaData(schema='sch1', quote_schema=True)
+        m3 = MetaData(schema='sch1', quote_schema=False)
+        m4 = MetaData()
+
+        for i, (name, metadata, schema, quote_schema,
+                        exp_schema, exp_quote_schema) in enumerate([
+                                ('t1', m1, None, None, 'sch1', None),
+                                ('t2', m1, 'sch2', None, 'sch2', None),
+                                ('t3', m1, 'sch2', True, 'sch2', True),
+                                ('t4', m1, 'sch1', None, 'sch1', None),
+                                ('t1', m2, None, None, 'sch1', True),
+                                ('t2', m2, 'sch2', None, 'sch2', None),
+                                ('t3', m2, 'sch2', True, 'sch2', True),
+                                ('t4', m2, 'sch1', None, 'sch1', None),
+                                ('t1', m3, None, None, 'sch1', False),
+                                ('t2', m3, 'sch2', None, 'sch2', None),
+                                ('t3', m3, 'sch2', True, 'sch2', True),
+                                ('t4', m3, 'sch1', None, 'sch1', None),
+                                ('t1', m4, None, None, None, None),
+                                ('t2', m4, 'sch2', None, 'sch2', None),
+                                ('t3', m4, 'sch2', True, 'sch2', True),
+                                ('t4', m4, 'sch1', None, 'sch1', None),
+                        ]):
+            kw = {}
+            if schema is not None:
+                kw['schema'] = schema
+            if quote_schema is not None:
+                kw['quote_schema'] = quote_schema
+            t = Table(name, metadata, **kw)
+            eq_(t.schema, exp_schema, "test %d, table schema" % i)
+            eq_(t.schema.quote if t.schema is not None else None,
+                            exp_quote_schema,
+                            "test %d, table quote_schema" % i)
+            seq = Sequence(name, metadata=metadata, **kw)
+            eq_(seq.schema, exp_schema, "test %d, seq schema" % i)
+            eq_(seq.schema.quote if seq.schema is not None else None,
+                            exp_quote_schema,
+                            "test %d, seq quote_schema" % i)
+
+    def test_manual_dependencies(self):
+        meta = MetaData()
+        a = Table('a', meta, Column('foo', Integer))
+        b = Table('b', meta, Column('foo', Integer))
+        c = Table('c', meta, Column('foo', Integer))
+        d = Table('d', meta, Column('foo', Integer))
+        e = Table('e', meta, Column('foo', Integer))
+
+        e.add_is_dependent_on(c)
+        a.add_is_dependent_on(b)
+        b.add_is_dependent_on(d)
+        e.add_is_dependent_on(b)
+        c.add_is_dependent_on(a)
+        eq_(
+            meta.sorted_tables,
+            [d, b, a, c, e]
+        )
+
+    def test_nonexistent(self):
+        assert_raises(tsa.exc.NoSuchTableError, Table,
+                          'fake_table',
+                          MetaData(testing.db), autoload=True)
+
+    def test_assorted_repr(self):
+        t1 = Table("foo", MetaData(), Column("x", Integer))
+        i1 = Index("bar", t1.c.x)
+        ck = schema.CheckConstraint("x > y", name="someconstraint")
+
+        for const, exp in (
+            (Sequence("my_seq"),
+                "Sequence('my_seq')"),
+            (Sequence("my_seq", start=5),
+                "Sequence('my_seq', start=5)"),
+            (Column("foo", Integer),
+                "Column('foo', Integer(), table=None)"),
+            (Table("bar", MetaData(), Column("x", String)),
+                "Table('bar', MetaData(bind=None), "
+                "Column('x', String(), table=<bar>), schema=None)"),
+            (schema.DefaultGenerator(for_update=True),
+                "DefaultGenerator(for_update=True)"),
+            (schema.Index("bar", "c"), "Index('bar')"),
+            (i1, "Index('bar', Column('x', Integer(), table=<foo>))"),
+            (schema.FetchedValue(), "FetchedValue()"),
+            (ck,
+                    "CheckConstraint("
+                    "%s"
+                    ", name='someconstraint')" % repr(ck.sqltext)),
+        ):
+            eq_(
+                repr(const),
+                exp
+            )
+
+
+class ToMetaDataTest(fixtures.TestBase, ComparesTables):
+
+    def test_copy(self):
         from sqlalchemy.testing.schema import Table
         meta = MetaData()
 
@@ -403,7 +563,7 @@ class MetaDataTest(fixtures.TestBase, ComparesTables):
         finally:
             meta.drop_all(testing.db)
 
-    def test_col_key_fk_parent_tometadata(self):
+    def test_col_key_fk_parent(self):
         # test #2643
         m1 = MetaData()
         a = Table('a', m1, Column('x', Integer))
@@ -416,70 +576,7 @@ class MetaDataTest(fixtures.TestBase, ComparesTables):
         assert b2.c.y.references(a2.c.x)
 
 
-    def test_pickle_metadata_sequence_restated(self):
-        m1 = MetaData()
-        Table('a', m1,
-             Column('id', Integer, primary_key=True),
-             Column('x', Integer, Sequence("x_seq")))
-
-        m2 = pickle.loads(pickle.dumps(m1))
-
-        s2 = Sequence("x_seq")
-        t2 = Table('a', m2,
-             Column('id', Integer, primary_key=True),
-             Column('x', Integer, s2),
-             extend_existing=True)
-
-        assert m2._sequences['x_seq'] is t2.c.x.default
-        assert m2._sequences['x_seq'] is s2
-
-
-    def test_sequence_restated_replaced(self):
-        """Test restatement of Sequence replaces."""
-
-        m1 = MetaData()
-        s1 = Sequence("x_seq")
-        t = Table('a', m1,
-             Column('x', Integer, s1)
-        )
-        assert m1._sequences['x_seq'] is s1
-
-        s2 = Sequence('x_seq')
-        Table('a', m1,
-             Column('x', Integer, s2),
-             extend_existing=True
-        )
-        assert t.c.x.default is s2
-        assert m1._sequences['x_seq'] is s2
-
-
-    def test_pickle_metadata_sequence_implicit(self):
-        m1 = MetaData()
-        Table('a', m1,
-             Column('id', Integer, primary_key=True),
-             Column('x', Integer, Sequence("x_seq")))
-
-        m2 = pickle.loads(pickle.dumps(m1))
-
-        t2 = Table('a', m2, extend_existing=True)
-
-        eq_(m2._sequences, {'x_seq': t2.c.x.default})
-
-    def test_pickle_metadata_schema(self):
-        m1 = MetaData()
-        Table('a', m1,
-             Column('id', Integer, primary_key=True),
-             Column('x', Integer, Sequence("x_seq")),
-             schema='y')
-
-        m2 = pickle.loads(pickle.dumps(m1))
-
-        Table('a', m2, schema='y',
-             extend_existing=True)
-
-        eq_(m2._schemas, m1._schemas)
-
-    def test_tometadata_with_schema(self):
+    def test_change_schema(self):
         meta = MetaData()
 
         table = Table('mytable', meta,
@@ -504,7 +601,7 @@ class MetaDataTest(fixtures.TestBase, ComparesTables):
         eq_(str(table_c.join(table2_c).onclause),
             'someschema.mytable.myid = someschema.othertable.myid')
 
-    def test_tometadata_with_default_schema(self):
+    def test_retain_table_schema(self):
         meta = MetaData()
 
         table = Table('mytable', meta,
@@ -531,7 +628,144 @@ class MetaDataTest(fixtures.TestBase, ComparesTables):
         eq_(str(table_c.join(table2_c).onclause),
             'myschema.mytable.myid = myschema.othertable.myid')
 
-    def test_tometadata_copy_info(self):
+    def _assert_fk(self, t2, schema, expected, referred_schema_fn=None):
+        m2 = MetaData()
+        existing_schema = t2.schema
+        if schema:
+            t2c = t2.tometadata(m2, schema=schema,
+                                    referred_schema_fn=referred_schema_fn)
+            eq_(t2c.schema, schema)
+        else:
+            t2c = t2.tometadata(m2, referred_schema_fn=referred_schema_fn)
+            eq_(t2c.schema, existing_schema)
+        eq_(list(t2c.c.y.foreign_keys)[0]._get_colspec(), expected)
+
+    def test_fk_has_schema_string_retain_schema(self):
+        m = MetaData()
+
+        t2 = Table('t2', m, Column('y', Integer, ForeignKey('q.t1.x')))
+        self._assert_fk(t2, None, "q.t1.x")
+
+        Table('t1', m, Column('x', Integer), schema='q')
+        self._assert_fk(t2, None, "q.t1.x")
+
+    def test_fk_has_schema_string_new_schema(self):
+        m = MetaData()
+
+        t2 = Table('t2', m, Column('y', Integer, ForeignKey('q.t1.x')))
+        self._assert_fk(t2, "z", "q.t1.x")
+
+        Table('t1', m, Column('x', Integer), schema='q')
+        self._assert_fk(t2, "z", "q.t1.x")
+
+    def test_fk_has_schema_col_retain_schema(self):
+        m = MetaData()
+
+        t1 = Table('t1', m, Column('x', Integer), schema='q')
+        t2 = Table('t2', m, Column('y', Integer, ForeignKey(t1.c.x)))
+
+        self._assert_fk(t2, "z", "q.t1.x")
+
+    def test_fk_has_schema_col_new_schema(self):
+        m = MetaData()
+
+        t1 = Table('t1', m, Column('x', Integer), schema='q')
+        t2 = Table('t2', m, Column('y', Integer, ForeignKey(t1.c.x)))
+
+        self._assert_fk(t2, "z", "q.t1.x")
+
+    def test_fk_and_referent_has_same_schema_string_retain_schema(self):
+        m = MetaData()
+
+        t2 = Table('t2', m, Column('y', Integer,
+                                    ForeignKey('q.t1.x')), schema="q")
+
+        self._assert_fk(t2, None, "q.t1.x")
+
+        Table('t1', m, Column('x', Integer), schema='q')
+        self._assert_fk(t2, None, "q.t1.x")
+
+    def test_fk_and_referent_has_same_schema_string_new_schema(self):
+        m = MetaData()
+
+        t2 = Table('t2', m, Column('y', Integer,
+                                    ForeignKey('q.t1.x')), schema="q")
+
+        self._assert_fk(t2, "z", "z.t1.x")
+
+        Table('t1', m, Column('x', Integer), schema='q')
+        self._assert_fk(t2, "z", "z.t1.x")
+
+    def test_fk_and_referent_has_same_schema_col_retain_schema(self):
+        m = MetaData()
+
+        t1 = Table('t1', m, Column('x', Integer), schema='q')
+        t2 = Table('t2', m, Column('y', Integer,
+                                    ForeignKey(t1.c.x)), schema='q')
+        self._assert_fk(t2, None, "q.t1.x")
+
+
+    def test_fk_and_referent_has_same_schema_col_new_schema(self):
+        m = MetaData()
+
+        t1 = Table('t1', m, Column('x', Integer), schema='q')
+        t2 = Table('t2', m, Column('y', Integer,
+                                    ForeignKey(t1.c.x)), schema='q')
+        self._assert_fk(t2, 'z', "z.t1.x")
+
+    def test_fk_and_referent_has_diff_schema_string_retain_schema(self):
+        m = MetaData()
+
+        t2 = Table('t2', m, Column('y', Integer,
+                                    ForeignKey('p.t1.x')), schema="q")
+
+        self._assert_fk(t2, None, "p.t1.x")
+
+        Table('t1', m, Column('x', Integer), schema='p')
+        self._assert_fk(t2, None, "p.t1.x")
+
+    def test_fk_and_referent_has_diff_schema_string_new_schema(self):
+        m = MetaData()
+
+        t2 = Table('t2', m, Column('y', Integer,
+                                    ForeignKey('p.t1.x')), schema="q")
+
+        self._assert_fk(t2, "z", "p.t1.x")
+
+        Table('t1', m, Column('x', Integer), schema='p')
+        self._assert_fk(t2, "z", "p.t1.x")
+
+    def test_fk_and_referent_has_diff_schema_col_retain_schema(self):
+        m = MetaData()
+
+        t1 = Table('t1', m, Column('x', Integer), schema='p')
+        t2 = Table('t2', m, Column('y', Integer,
+                                    ForeignKey(t1.c.x)), schema='q')
+        self._assert_fk(t2, None, "p.t1.x")
+
+
+    def test_fk_and_referent_has_diff_schema_col_new_schema(self):
+        m = MetaData()
+
+        t1 = Table('t1', m, Column('x', Integer), schema='p')
+        t2 = Table('t2', m, Column('y', Integer,
+                                    ForeignKey(t1.c.x)), schema='q')
+        self._assert_fk(t2, 'z', "p.t1.x")
+
+    def test_fk_custom_system(self):
+        m = MetaData()
+        t2 = Table('t2', m, Column('y', Integer,
+                                    ForeignKey('p.t1.x')), schema='q')
+
+        def ref_fn(table, to_schema, constraint, referred_schema):
+            assert table is t2
+            eq_(to_schema, "z")
+            eq_(referred_schema, "p")
+            return "h"
+        self._assert_fk(t2, 'z', "h.t1.x", referred_schema_fn=ref_fn)
+
+
+    def test_copy_info(self):
         m = MetaData()
         fk = ForeignKey('t2.id')
         c = Column('c', Integer, fk)
@@ -573,7 +807,7 @@ class MetaDataTest(fixtures.TestBase, ComparesTables):
         eq_(ck2.info, {"ckinfo": True})
 
 
-    def test_tometadata_kwargs(self):
+    def test_dialect_kwargs(self):
         meta = MetaData()
 
         table = Table('mytable', meta,
@@ -588,7 +822,7 @@ class MetaDataTest(fixtures.TestBase, ComparesTables):
 
         eq_(table.kwargs, table_c.kwargs)
 
-    def test_tometadata_indexes(self):
+    def test_indexes(self):
         meta = MetaData()
 
         table = Table('mytable', meta,
@@ -612,7 +846,7 @@ class MetaDataTest(fixtures.TestBase, ComparesTables):
         )
 
     @emits_warning("Table '.+' already exists within the given MetaData")
-    def test_tometadata_already_there(self):
+    def test_already_exists(self):
 
         meta1 = MetaData()
         table1 = Table('mytable', meta1,
@@ -629,66 +863,7 @@ class MetaDataTest(fixtures.TestBase, ComparesTables):
         # d'oh!
         assert table_c is table_d
 
-    def test_metadata_schema_arg(self):
-        m1 = MetaData(schema='sch1')
-        m2 = MetaData(schema='sch1', quote_schema=True)
-        m3 = MetaData(schema='sch1', quote_schema=False)
-        m4 = MetaData()
-
-        for i, (name, metadata, schema, quote_schema,
-                        exp_schema, exp_quote_schema) in enumerate([
-                                ('t1', m1, None, None, 'sch1', None),
-                                ('t2', m1, 'sch2', None, 'sch2', None),
-                                ('t3', m1, 'sch2', True, 'sch2', True),
-                                ('t4', m1, 'sch1', None, 'sch1', None),
-                                ('t1', m2, None, None, 'sch1', True),
-                                ('t2', m2, 'sch2', None, 'sch2', None),
-                                ('t3', m2, 'sch2', True, 'sch2', True),
-                                ('t4', m2, 'sch1', None, 'sch1', None),
-                                ('t1', m3, None, None, 'sch1', False),
-                                ('t2', m3, 'sch2', None, 'sch2', None),
-                                ('t3', m3, 'sch2', True, 'sch2', True),
-                                ('t4', m3, 'sch1', None, 'sch1', None),
-                                ('t1', m4, None, None, None, None),
-                                ('t2', m4, 'sch2', None, 'sch2', None),
-                                ('t3', m4, 'sch2', True, 'sch2', True),
-                                ('t4', m4, 'sch1', None, 'sch1', None),
-                        ]):
-            kw = {}
-            if schema is not None:
-                kw['schema'] = schema
-            if quote_schema is not None:
-                kw['quote_schema'] = quote_schema
-            t = Table(name, metadata, **kw)
-            eq_(t.schema, exp_schema, "test %d, table schema" % i)
-            eq_(t.schema.quote if t.schema is not None else None,
-                            exp_quote_schema,
-                            "test %d, table quote_schema" % i)
-            seq = Sequence(name, metadata=metadata, **kw)
-            eq_(seq.schema, exp_schema, "test %d, seq schema" % i)
-            eq_(seq.schema.quote if seq.schema is not None else None,
-                            exp_quote_schema,
-                            "test %d, seq quote_schema" % i)
-
-    def test_manual_dependencies(self):
-        meta = MetaData()
-        a = Table('a', meta, Column('foo', Integer))
-        b = Table('b', meta, Column('foo', Integer))
-        c = Table('c', meta, Column('foo', Integer))
-        d = Table('d', meta, Column('foo', Integer))
-        e = Table('e', meta, Column('foo', Integer))
-
-        e.add_is_dependent_on(c)
-        a.add_is_dependent_on(b)
-        b.add_is_dependent_on(d)
-        e.add_is_dependent_on(b)
-        c.add_is_dependent_on(a)
-        eq_(
-            meta.sorted_tables,
-            [d, b, a, c, e]
-        )
-
-    def test_tometadata_default_schema_metadata(self):
+    def test_default_schema_metadata(self):
         meta = MetaData(schema='myschema')
 
         table = Table('mytable', meta,
@@ -712,7 +887,7 @@ class MetaDataTest(fixtures.TestBase, ComparesTables):
         eq_(str(table_c.join(table2_c).onclause),
                 "someschema.mytable.myid = someschema.othertable.myid")
 
-    def test_tometadata_strip_schema(self):
+    def test_strip_schema(self):
         meta = MetaData()
 
         table = Table('mytable', meta,
@@ -737,41 +912,6 @@ class MetaDataTest(fixtures.TestBase, ComparesTables):
         eq_(str(table_c.join(table2_c).onclause),
             'mytable.myid = othertable.myid')
 
-    def test_nonexistent(self):
-        assert_raises(tsa.exc.NoSuchTableError, Table,
-                          'fake_table',
-                          MetaData(testing.db), autoload=True)
-
-    def test_assorted_repr(self):
-        t1 = Table("foo", MetaData(), Column("x", Integer))
-        i1 = Index("bar", t1.c.x)
-        ck = schema.CheckConstraint("x > y", name="someconstraint")
-
-        for const, exp in (
-            (Sequence("my_seq"),
-                "Sequence('my_seq')"),
-            (Sequence("my_seq", start=5),
-                "Sequence('my_seq', start=5)"),
-            (Column("foo", Integer),
-                "Column('foo', Integer(), table=None)"),
-            (Table("bar", MetaData(), Column("x", String)),
-                "Table('bar', MetaData(bind=None), "
-                "Column('x', String(), table=<bar>), schema=None)"),
-            (schema.DefaultGenerator(for_update=True),
-                "DefaultGenerator(for_update=True)"),
-            (schema.Index("bar", "c"), "Index('bar')"),
-            (i1, "Index('bar', Column('x', Integer(), table=<foo>))"),
-            (schema.FetchedValue(), "FetchedValue()"),
-            (ck,
-                    "CheckConstraint("
-                    "%s"
-                    ", name='someconstraint')" % repr(ck.sqltext)),
-        ):
-            eq_(
-                repr(const),
-                exp
-            )
-
 class TableTest(fixtures.TestBase, AssertsCompiledSQL):
     @testing.skip_if('mssql', 'different col format')
     def test_prefixes(self):