def test_conditional_constraint_deprecated(self):
metadata, users = self.metadata, self.users
nonpg_mock = engines.mock_engine(dialect_name="sqlite")
pg_mock = engines.mock_engine(dialect_name="postgresql")
constraint = CheckConstraint("a < b",
name="my_test_constraint",
table=users)
# by placing the constraint in an Add/Drop construct, the
# 'inline_ddl' flag is set to False
AddConstraint(constraint,
on="postgresql").execute_at("after-create", users)
DropConstraint(constraint,
on="postgresql").execute_at("before-drop", users)
metadata.create_all(bind=nonpg_mock)
strings = " ".join(str(x) for x in nonpg_mock.mock)
assert "my_test_constraint" not in strings
metadata.drop_all(bind=nonpg_mock)
strings = " ".join(str(x) for x in nonpg_mock.mock)
assert "my_test_constraint" not in strings
metadata.create_all(bind=pg_mock)
strings = " ".join(str(x) for x in pg_mock.mock)
assert "my_test_constraint" in strings
metadata.drop_all(bind=pg_mock)
strings = " ".join(str(x) for x in pg_mock.mock)
assert "my_test_constraint" in strings
def test_conditional_constraint(self):
metadata, users, engine = self.metadata, self.users, self.engine
nonpg_mock = engines.mock_engine(dialect_name="sqlite")
pg_mock = engines.mock_engine(dialect_name="postgresql")
constraint = CheckConstraint("a < b",
name="my_test_constraint",
table=users)
# by placing the constraint in an Add/Drop construct, the
# 'inline_ddl' flag is set to False
event.listen(
users,
"after_create",
AddConstraint(constraint).execute_if(dialect="postgresql"),
)
event.listen(
users,
"before_drop",
DropConstraint(constraint).execute_if(dialect="postgresql"),
)
metadata.create_all(bind=nonpg_mock)
strings = " ".join(str(x) for x in nonpg_mock.mock)
assert "my_test_constraint" not in strings
metadata.drop_all(bind=nonpg_mock)
strings = " ".join(str(x) for x in nonpg_mock.mock)
assert "my_test_constraint" not in strings
metadata.create_all(bind=pg_mock)
strings = " ".join(str(x) for x in pg_mock.mock)
assert "my_test_constraint" in strings
metadata.drop_all(bind=pg_mock)
strings = " ".join(str(x) for x in pg_mock.mock)
assert "my_test_constraint" in strings
def test_conditional_constraint_deprecated(self):
metadata, users, engine = self.metadata, self.users, self.engine
nonpg_mock = engines.mock_engine(dialect_name='sqlite')
pg_mock = engines.mock_engine(dialect_name='postgresql')
constraint = CheckConstraint('a < b', name='my_test_constraint',
table=users)
# by placing the constraint in an Add/Drop construct, the
# 'inline_ddl' flag is set to False
AddConstraint(constraint, on='postgresql'
).execute_at('after-create', users)
DropConstraint(constraint, on='postgresql'
).execute_at('before-drop', users)
metadata.create_all(bind=nonpg_mock)
strings = ' '.join(str(x) for x in nonpg_mock.mock)
assert 'my_test_constraint' not in strings
metadata.drop_all(bind=nonpg_mock)
strings = ' '.join(str(x) for x in nonpg_mock.mock)
assert 'my_test_constraint' not in strings
metadata.create_all(bind=pg_mock)
strings = ' '.join(str(x) for x in pg_mock.mock)
assert 'my_test_constraint' in strings
metadata.drop_all(bind=pg_mock)
strings = ' '.join(str(x) for x in pg_mock.mock)
assert 'my_test_constraint' in strings
def test_conditional_constraint(self):
metadata, users, engine = self.metadata, self.users, self.engine
nonpg_mock = engines.mock_engine(dialect_name="sqlite")
pg_mock = engines.mock_engine(dialect_name="postgresql")
constraint = CheckConstraint("a < b", name="my_test_constraint", table=users)
# by placing the constraint in an Add/Drop construct, the
# 'inline_ddl' flag is set to False
event.listen(users, "after_create", AddConstraint(constraint).execute_if(dialect="postgresql"))
event.listen(users, "before_drop", DropConstraint(constraint).execute_if(dialect="postgresql"))
metadata.create_all(bind=nonpg_mock)
strings = " ".join(str(x) for x in nonpg_mock.mock)
assert "my_test_constraint" not in strings
metadata.drop_all(bind=nonpg_mock)
strings = " ".join(str(x) for x in nonpg_mock.mock)
assert "my_test_constraint" not in strings
metadata.create_all(bind=pg_mock)
strings = " ".join(str(x) for x in pg_mock.mock)
assert "my_test_constraint" in strings
metadata.drop_all(bind=pg_mock)
strings = " ".join(str(x) for x in pg_mock.mock)
assert "my_test_constraint" in strings
def test_conditional_constraint_deprecated(self):
metadata, users, engine = self.metadata, self.users, self.engine
nonpg_mock = engines.mock_engine(dialect_name='sqlite')
pg_mock = engines.mock_engine(dialect_name='postgresql')
constraint = CheckConstraint('a < b', name='my_test_constraint'
, table=users)
# by placing the constraint in an Add/Drop construct, the
# 'inline_ddl' flag is set to False
AddConstraint(constraint, on='postgresql'
).execute_at('after-create', users)
DropConstraint(constraint, on='postgresql'
).execute_at('before-drop', users)
metadata.create_all(bind=nonpg_mock)
strings = ' '.join(str(x) for x in nonpg_mock.mock)
assert 'my_test_constraint' not in strings
metadata.drop_all(bind=nonpg_mock)
strings = ' '.join(str(x) for x in nonpg_mock.mock)
assert 'my_test_constraint' not in strings
metadata.create_all(bind=pg_mock)
strings = ' '.join(str(x) for x in pg_mock.mock)
assert 'my_test_constraint' in strings
metadata.drop_all(bind=pg_mock)
strings = ' '.join(str(x) for x in pg_mock.mock)
assert 'my_test_constraint' in strings
def test_use_alter(self):
m = MetaData()
Table("t", m, Column("a", Integer))
Table(
"t2",
m,
Column("a", Integer, ForeignKey("t.a",
use_alter=True,
name="fk_ta")),
Column("b", Integer, ForeignKey("t.a", name="fk_tb")),
)
e = engines.mock_engine(dialect_name="postgresql")
m.create_all(e)
m.drop_all(e)
e.assert_sql([
"CREATE TABLE t (a INTEGER)",
"CREATE TABLE t2 (a INTEGER, b INTEGER, CONSTRAINT fk_tb "
"FOREIGN KEY(b) REFERENCES t (a))",
"ALTER TABLE t2 "
"ADD CONSTRAINT fk_ta FOREIGN KEY(a) REFERENCES t (a)",
"ALTER TABLE t2 DROP CONSTRAINT fk_ta",
"DROP TABLE t2",
"DROP TABLE t",
])
def setup(self):
self.engine = engines.mock_engine()
self.metadata = MetaData(self.engine)
self.users = Table('users', self.metadata,
Column('user_id', Integer, primary_key=True),
Column('user_name', String(40)),
)
def test_use_alter(self):
m = MetaData()
Table(
't',
m,
Column('a', Integer),
)
Table(
't2', m,
Column('a', Integer, ForeignKey('t.a',
use_alter=True,
name='fk_ta')),
Column('b', Integer, ForeignKey('t.a', name='fk_tb')))
e = engines.mock_engine(dialect_name='postgresql')
m.create_all(e)
m.drop_all(e)
e.assert_sql([
'CREATE TABLE t (a INTEGER)',
'CREATE TABLE t2 (a INTEGER, b INTEGER, CONSTRAINT fk_tb '
'FOREIGN KEY(b) REFERENCES t (a))', 'ALTER TABLE t2 '
'ADD CONSTRAINT fk_ta FOREIGN KEY(a) REFERENCES t (a)',
'ALTER TABLE t2 DROP CONSTRAINT fk_ta', 'DROP TABLE t2',
'DROP TABLE t'
])
def test_use_alter(self):
m = MetaData()
Table('t', m,
Column('a', Integer),
)
Table('t2', m,
Column('a', Integer, ForeignKey('t.a', use_alter=True,
name='fk_ta')),
Column('b', Integer, ForeignKey('t.a', name='fk_tb'))
)
e = engines.mock_engine(dialect_name='postgresql')
m.create_all(e)
m.drop_all(e)
e.assert_sql([
'CREATE TABLE t (a INTEGER)',
'CREATE TABLE t2 (a INTEGER, b INTEGER, CONSTRAINT fk_tb '
'FOREIGN KEY(b) REFERENCES t (a))',
'ALTER TABLE t2 '
'ADD CONSTRAINT fk_ta FOREIGN KEY(a) REFERENCES t (a)',
'ALTER TABLE t2 DROP CONSTRAINT fk_ta',
'DROP TABLE t2',
'DROP TABLE t'
])
def test_use_alter(self):
m = MetaData()
Table("t", m, Column("a", Integer))
Table(
"t2",
m,
Column("a", Integer, ForeignKey("t.a", use_alter=True, name="fk_ta")),
Column("b", Integer, ForeignKey("t.a", name="fk_tb")),
)
e = engines.mock_engine(dialect_name="postgresql")
m.create_all(e)
m.drop_all(e)
e.assert_sql(
[
"CREATE TABLE t (a INTEGER)",
"CREATE TABLE t2 (a INTEGER, b INTEGER, CONSTRAINT fk_tb " "FOREIGN KEY(b) REFERENCES t (a))",
"ALTER TABLE t2 " "ADD CONSTRAINT fk_ta FOREIGN KEY(a) REFERENCES t (a)",
"ALTER TABLE t2 DROP CONSTRAINT fk_ta",
"DROP TABLE t2",
"DROP TABLE t",
]
)
def setup(self):
self.engine = engines.mock_engine()
self.metadata = MetaData(self.engine)
self.users = Table('users', self.metadata,
Column('user_id', Integer, primary_key=True),
Column('user_name', String(40)),
)
def setup_test(self):
self.engine = engines.mock_engine()
self.metadata = MetaData()
self.users = Table(
"users",
self.metadata,
Column("user_id", Integer, primary_key=True),
Column("user_name", String(40)),
)
def setup(self):
self.bind = self.engine = engines.mock_engine()
self.metadata = MetaData(self.bind)
self.table = Table("t", self.metadata, Column("id", Integer))
self.users = Table(
"users",
self.metadata,
Column("user_id", Integer, primary_key=True),
Column("user_name", String(40)),
)
def setup(self):
self.bind = self.engine = engines.mock_engine()
self.metadata = MetaData(self.bind)
self.table = Table("t", self.metadata, Column("id", Integer))
self.users = Table(
"users",
self.metadata,
Column("user_id", Integer, primary_key=True),
Column("user_name", String(40)),
)
def setup(self):
self.bind = engines.mock_engine()
self.metadata = MetaData()
self.table = Table('t', self.metadata, Column('id', Integer))
def test_inline_ddl_if_dialect_name(self, ddl_if_type):
nonpg_mock = engines.mock_engine(dialect_name="sqlite")
pg_mock = engines.mock_engine(dialect_name="postgresql")
metadata = MetaData()
capture_mock = Mock()
state = object()
if ddl_if_type == "dialect":
ddl_kwargs = dict(dialect="postgresql")
elif ddl_if_type == "callable":
def is_pg(ddl, target, bind, **kw):
capture_mock.is_pg(ddl, target, bind, **kw)
return kw["dialect"].name == "postgresql"
ddl_kwargs = dict(callable_=is_pg)
elif ddl_if_type == "callable_w_state":
def is_pg(ddl, target, bind, **kw):
capture_mock.is_pg(ddl, target, bind, **kw)
return kw["dialect"].name == "postgresql"
ddl_kwargs = dict(callable_=is_pg, state=state)
else:
assert False
data_col = Column("data", String)
t = Table(
"a",
metadata,
Column("id", Integer, primary_key=True),
Column("num", Integer),
data_col,
Index("my_pg_index", data_col).ddl_if(**ddl_kwargs),
CheckConstraint("num > 5").ddl_if(**ddl_kwargs),
)
metadata.create_all(nonpg_mock)
eq_(len(nonpg_mock.mock), 1)
self.assert_compile(
nonpg_mock.mock[0],
"CREATE TABLE a (id INTEGER NOT NULL, num INTEGER, "
"data VARCHAR, PRIMARY KEY (id))",
dialect=nonpg_mock.dialect,
)
metadata.create_all(pg_mock)
eq_(len(pg_mock.mock), 2)
self.assert_compile(
pg_mock.mock[0],
"CREATE TABLE a (id SERIAL NOT NULL, num INTEGER, "
"data VARCHAR, PRIMARY KEY (id), CHECK (num > 5))",
dialect=pg_mock.dialect,
)
self.assert_compile(
pg_mock.mock[1],
"CREATE INDEX my_pg_index ON a (data)",
dialect="postgresql",
)
the_index = list(t.indexes)[0]
the_constraint = list(c for c in t.constraints
if isinstance(c, CheckConstraint))[0]
if ddl_if_type in ("callable", "callable_w_state"):
if ddl_if_type == "callable":
check_state = None
else:
check_state = state
eq_(
capture_mock.mock_calls,
[
mock.call.is_pg(
mock.ANY,
the_index,
mock.ANY,
state=check_state,
dialect=nonpg_mock.dialect,
compiler=None,
),
mock.call.is_pg(
mock.ANY,
the_constraint,
None,
state=check_state,
dialect=nonpg_mock.dialect,
compiler=mock.ANY,
),
mock.call.is_pg(
mock.ANY,
the_index,
mock.ANY,
state=check_state,
dialect=pg_mock.dialect,
compiler=None,
),
mock.call.is_pg(
mock.ANY,
the_constraint,
None,
state=check_state,
dialect=pg_mock.dialect,
compiler=mock.ANY,
),
],
)
def setup(self):
self.bind = engines.mock_engine()
self.metadata = MetaData()
self.table = Table('t', self.metadata, Column('id', Integer))
def setup(self):
self.bind = engines.mock_engine()
self.metadata = MetaData()
self.table = Table("t", self.metadata, Column("id", Integer))
def setup(self):
self.bind = engines.mock_engine()
self.metadata = MetaData()
self.table = Table("t", self.metadata, Column("id", Integer))
