def test_fk_cant_drop_cycled_unnamed(self):
        metadata = MetaData()

        Table("a", metadata, Column('id', Integer, primary_key=True),
              Column('bid', Integer), ForeignKeyConstraint(["bid"], ["b.id"]))
        Table("b", metadata, Column('id', Integer, primary_key=True),
              Column("aid", Integer), ForeignKeyConstraint(["aid"], ["a.id"]))
        metadata.create_all(testing.db)
        if testing.db.dialect.supports_alter:
            assert_raises_message(
                exc.CircularDependencyError,
                "Can't sort tables for DROP; an unresolvable foreign key "
                "dependency exists between tables: a, b.  Please ensure "
                "that the ForeignKey and ForeignKeyConstraint objects "
                "involved in the cycle have names so that they can be "
                "dropped using DROP CONSTRAINT.", metadata.drop_all,
                testing.db)
        else:
            with expect_warnings("Can't sort tables for DROP; an unresolvable "
                                 "foreign key dependency "):
                with self.sql_execution_asserter() as asserter:
                    metadata.drop_all(testing.db, checkfirst=False)

            asserter.assert_(
                AllOf(CompiledSQL("DROP TABLE a"),
                      CompiledSQL("DROP TABLE b")))
示例#2
0
    def test_fk_cant_drop_cycled_unnamed(self):
        metadata = MetaData()

        Table(
            "a",
            metadata,
            Column("id", Integer, primary_key=True),
            Column("bid", Integer),
            ForeignKeyConstraint(["bid"], ["b.id"]),
        )
        Table(
            "b",
            metadata,
            Column("id", Integer, primary_key=True),
            Column("aid", Integer),
            ForeignKeyConstraint(["aid"], ["a.id"]),
        )
        metadata.create_all(testing.db)
        if testing.db.dialect.supports_alter:
            assert_raises_message(
                exc.CircularDependencyError,
                "Can't sort tables for DROP; an unresolvable foreign key "
                "dependency exists between tables: a, b.  Please ensure "
                "that the ForeignKey and ForeignKeyConstraint objects "
                "involved in the cycle have names so that they can be "
                "dropped using DROP CONSTRAINT.",
                metadata.drop_all,
                testing.db,
            )
        else:
            with expect_warnings("Can't sort tables for DROP; an unresolvable " "foreign key dependency "):
                with self.sql_execution_asserter() as asserter:
                    metadata.drop_all(testing.db, checkfirst=False)

            asserter.assert_(AllOf(CompiledSQL("DROP TABLE a"), CompiledSQL("DROP TABLE b")))
示例#3
0
    def _assert_sql(self, element, legacy_sql, modern_sql=None):
        dialect = mssql.dialect()

        with assertions.expect_warnings(
                "legacy_schema_aliasing flag is defaulted to True.*"):
            self.assert_compile(element, legacy_sql, dialect=dialect)

        dialect = mssql.dialect(legacy_schema_aliasing=False)
        self.assert_compile(element, modern_sql or "foob", dialect=dialect)
示例#4
0
    def _assert_cyclic_constraint_no_alter(self,
                                           metadata,
                                           auto=False,
                                           sqlite_warning=False):
        table_assertions = []
        if auto:
            table_assertions.append(
                DialectSQL("CREATE TABLE b ("
                           "id INTEGER NOT NULL, "
                           "aid INTEGER, "
                           "PRIMARY KEY (id), "
                           "CONSTRAINT bfk FOREIGN KEY(aid) REFERENCES a (id)"
                           ")"))
            table_assertions.append(
                DialectSQL("CREATE TABLE a ("
                           "id INTEGER NOT NULL, "
                           "bid INTEGER, "
                           "PRIMARY KEY (id), "
                           "FOREIGN KEY(bid) REFERENCES b (id)"
                           ")"))
        else:
            table_assertions.append(
                DialectSQL("CREATE TABLE b ("
                           "id INTEGER NOT NULL, "
                           "aid INTEGER, "
                           "PRIMARY KEY (id), "
                           "CONSTRAINT bfk FOREIGN KEY(aid) REFERENCES a (id)"
                           ")"))

            table_assertions.append(
                DialectSQL("CREATE TABLE a ("
                           "id INTEGER NOT NULL, "
                           "bid INTEGER, "
                           "PRIMARY KEY (id), "
                           "FOREIGN KEY(bid) REFERENCES b (id)"
                           ")"))

        assertions = [AllOf(*table_assertions)]

        with self.sql_execution_asserter() as asserter:
            metadata.create_all(testing.db, checkfirst=False)
        asserter.assert_(*assertions)

        assertions = [
            AllOf(CompiledSQL("DROP TABLE a"), CompiledSQL("DROP TABLE b"))
        ]

        if sqlite_warning:
            with expect_warnings("Can't sort tables for DROP; "):
                with self.sql_execution_asserter() as asserter:
                    metadata.drop_all(testing.db, checkfirst=False),
        else:
            with self.sql_execution_asserter() as asserter:
                metadata.drop_all(testing.db, checkfirst=False),
        asserter.assert_(*assertions)
示例#5
0
    def test_more_cols_than_sql(self):
        c1, c2, c3, c4 = column('q'), column('p'), column('r'), column('d')
        stmt = text("select a, b from text1").columns(c1, c2, c3, c4)

        with assertions.expect_warnings(
                r"Number of columns in textual SQL \(4\) is "
                "smaller than number of columns requested \(2\)"):
            result = testing.db.execute(stmt)

        row = result.first()
        eq_(row[c2], "b1")

        assert_raises_message(exc.NoSuchColumnError, "in row for column 'r'",
                              lambda: row[c3])
示例#6
0
    def _assert_sql(self, element, legacy_sql, modern_sql=None):
        dialect = mssql.dialect()

        with assertions.expect_warnings(
                "legacy_schema_aliasing flag is defaulted to True.*"):
            self.assert_compile(
                element,
                legacy_sql,
                dialect=dialect
            )

        dialect = mssql.dialect(legacy_schema_aliasing=False)
        self.assert_compile(
            element,
            modern_sql or "foob",
            dialect=dialect
        )
示例#7
0
    def test_more_cols_than_sql(self):
        c1, c2, c3, c4 = column('q'), column('p'), column('r'), column('d')
        stmt = text("select a, b from text1").columns(c1, c2, c3, c4)

        with assertions.expect_warnings(
                r"Number of columns in textual SQL \(4\) is "
                "smaller than number of columns requested \(2\)"):
            result = testing.db.execute(stmt)

        row = result.first()
        eq_(row[c2], "b1")

        assert_raises_message(
            exc.NoSuchColumnError,
            "in row for column 'r'",
            lambda: row[c3]
        )
示例#8
0
    def test_same_module_same_name(self):

        base = registry()
        f1 = MockClass(base, "foo.bar.Foo")
        f2 = MockClass(base, "foo.bar.Foo")
        clsregistry.add_class("Foo", f1, base._class_registry)
        gc_collect()

        with expect_warnings(
                "This declarative base already contains a class with the "
                "same class name and module name as foo.bar.Foo, and "
                "will be replaced in the string-lookup table."):
            clsregistry.add_class(
                "Foo",
                f2,
                base._class_registry,
            )
示例#9
0
    def test_cycle_unnamed_fks(self):
        metadata = MetaData(testing.db)

        Table("a", metadata, Column("id", Integer, primary_key=True), Column("bid", Integer, ForeignKey("b.id")))

        Table("b", metadata, Column("id", Integer, primary_key=True), Column("aid", Integer, ForeignKey("a.id")))

        assertions = [
            AllOf(
                CompiledSQL("CREATE TABLE b (" "id INTEGER NOT NULL, " "aid INTEGER, " "PRIMARY KEY (id)" ")"),
                CompiledSQL("CREATE TABLE a (" "id INTEGER NOT NULL, " "bid INTEGER, " "PRIMARY KEY (id)" ")"),
            ),
            AllOf(
                CompiledSQL("ALTER TABLE b ADD " "FOREIGN KEY(aid) REFERENCES a (id)"),
                CompiledSQL("ALTER TABLE a ADD " "FOREIGN KEY(bid) REFERENCES b (id)"),
            ),
        ]
        with self.sql_execution_asserter() as asserter:
            metadata.create_all(checkfirst=False)

        if testing.db.dialect.supports_alter:
            asserter.assert_(*assertions)

            assert_raises_message(
                exc.CircularDependencyError,
                "Can't sort tables for DROP; an unresolvable foreign key "
                "dependency exists between tables: a, b.  "
                "Please ensure that the "
                "ForeignKey and ForeignKeyConstraint objects involved in the "
                "cycle have names so that they can be dropped using "
                "DROP CONSTRAINT.",
                metadata.drop_all,
                checkfirst=False,
            )
        else:
            with expect_warnings(
                "Can't sort tables for DROP; an unresolvable " "foreign key dependency exists between tables"
            ):
                with self.sql_execution_asserter() as asserter:
                    metadata.drop_all(checkfirst=False)

            asserter.assert_(AllOf(CompiledSQL("DROP TABLE b"), CompiledSQL("DROP TABLE a")))
示例#10
0
    def test_replace_function_case_insensitive(self):
        class replaceable_func(GenericFunction):
            type = Integer
            identifier = 'replaceable_func'

        assert isinstance(func.Replaceable_Func().type, Integer)
        assert isinstance(func.RePlAcEaBlE_fUnC().type, Integer)
        assert isinstance(func.replaceable_func().type, Integer)

        with expect_warnings(
                "The GenericFunction 'replaceable_func' is already registered and "
                "is going to be overriden.",
                regex=False):

            class replaceable_func_override(GenericFunction):
                type = DateTime
                identifier = 'REPLACEABLE_Func'

        assert isinstance(func.Replaceable_Func().type, DateTime)
        assert isinstance(func.RePlAcEaBlE_fUnC().type, DateTime)
        assert isinstance(func.replaceable_func().type, DateTime)
示例#11
0
    def test_replace_function_case_insensitive(self):
        class replaceable_func(GenericFunction):
            type = Integer
            identifier = 'replaceable_func'

        assert isinstance(func.Replaceable_Func().type, Integer)
        assert isinstance(func.RePlAcEaBlE_fUnC().type, Integer)
        assert isinstance(func.replaceable_func().type, Integer)

        with expect_warnings(
            "The GenericFunction 'replaceable_func' is already registered and "
            "is going to be overriden.",
            regex=False
        ):
            class replaceable_func_override(GenericFunction):
                type = DateTime
                identifier = 'REPLACEABLE_Func'

        assert isinstance(func.Replaceable_Func().type, DateTime)
        assert isinstance(func.RePlAcEaBlE_fUnC().type, DateTime)
        assert isinstance(func.replaceable_func().type, DateTime)
示例#12
0
    def test_cycle_unnamed_fks(self):
        metadata = MetaData()

        Table(
            "a",
            metadata,
            Column("id", Integer, primary_key=True),
            Column("bid", Integer, ForeignKey("b.id")),
        )

        Table(
            "b",
            metadata,
            Column("id", Integer, primary_key=True),
            Column("aid", Integer, ForeignKey("a.id")),
        )

        assertions = [
            AllOf(
                CompiledSQL("CREATE TABLE b ("
                            "id INTEGER NOT NULL, "
                            "aid INTEGER, "
                            "PRIMARY KEY (id)"
                            ")"),
                CompiledSQL("CREATE TABLE a ("
                            "id INTEGER NOT NULL, "
                            "bid INTEGER, "
                            "PRIMARY KEY (id)"
                            ")"),
            ),
            AllOf(
                CompiledSQL("ALTER TABLE b ADD "
                            "FOREIGN KEY(aid) REFERENCES a (id)"),
                CompiledSQL("ALTER TABLE a ADD "
                            "FOREIGN KEY(bid) REFERENCES b (id)"),
            ),
        ]
        with self.sql_execution_asserter() as asserter:
            metadata.create_all(testing.db, checkfirst=False)

        if testing.db.dialect.supports_alter:
            asserter.assert_(*assertions)

            assert_raises_message(
                exc.CircularDependencyError,
                "Can't sort tables for DROP; an unresolvable foreign key "
                "dependency exists between tables: a, b.  "
                "Please ensure that the "
                "ForeignKey and ForeignKeyConstraint objects involved in the "
                "cycle have names so that they can be dropped using "
                "DROP CONSTRAINT.",
                metadata.drop_all,
                testing.db,
                checkfirst=False,
            )
        else:
            with expect_warnings(
                    "Can't sort tables for DROP; an unresolvable "
                    "foreign key dependency exists between tables"):
                with self.sql_execution_asserter() as asserter:
                    metadata.drop_all(testing.db, checkfirst=False)

            asserter.assert_(
                AllOf(CompiledSQL("DROP TABLE b"),
                      CompiledSQL("DROP TABLE a")))
示例#13
0
    def _assert_cyclic_constraint_no_alter(
            self, metadata, auto=False, sqlite_warning=False):
        table_assertions = []
        if auto:
            table_assertions.append(
                DialectSQL(
                    'CREATE TABLE b ('
                    'id INTEGER NOT NULL, '
                    'aid INTEGER, '
                    'PRIMARY KEY (id), '
                    'CONSTRAINT bfk FOREIGN KEY(aid) REFERENCES a (id)'
                    ')'
                )
            )
            table_assertions.append(
                DialectSQL(
                    'CREATE TABLE a ('
                    'id INTEGER NOT NULL, '
                    'bid INTEGER, '
                    'PRIMARY KEY (id), '
                    'FOREIGN KEY(bid) REFERENCES b (id)'
                    ')'
                )
            )
        else:
            table_assertions.append(
                DialectSQL(
                    'CREATE TABLE b ('
                    'id INTEGER NOT NULL, '
                    'aid INTEGER, '
                    'PRIMARY KEY (id), '
                    'CONSTRAINT bfk FOREIGN KEY(aid) REFERENCES a (id)'
                    ')'
                )
            )

            table_assertions.append(
                DialectSQL(
                    'CREATE TABLE a ('
                    'id INTEGER NOT NULL, '
                    'bid INTEGER, '
                    'PRIMARY KEY (id), '
                    'FOREIGN KEY(bid) REFERENCES b (id)'
                    ')'
                )
            )

        assertions = [AllOf(*table_assertions)]

        with self.sql_execution_asserter() as asserter:
            metadata.create_all(checkfirst=False)
        asserter.assert_(*assertions)

        assertions = [AllOf(
            CompiledSQL("DROP TABLE a"),
            CompiledSQL("DROP TABLE b")
        )]

        if sqlite_warning:
            with expect_warnings("Can't sort tables for DROP; "):
                with self.sql_execution_asserter() as asserter:
                    metadata.drop_all(checkfirst=False),
        else:
            with self.sql_execution_asserter() as asserter:
                metadata.drop_all(checkfirst=False),
        asserter.assert_(*assertions)