def test_year(self):
"""Exercise YEAR."""
year_table = Table(
"mysql_year",
self.metadata,
Column("y1", mysql.MSYear),
Column("y2", mysql.MSYear),
Column("y3", mysql.MSYear),
Column("y5", mysql.MSYear(4)),
)
for col in year_table.c:
self.assert_(repr(col))
year_table.create()
reflected = Table("mysql_year", MetaData(testing.db), autoload=True)
for table in year_table, reflected:
with testing.db.connect() as conn:
conn.execute(table.insert(["1950", "50", None, 1950]))
row = conn.execute(table.select()).first()
eq_(list(row), [1950, 2050, None, 1950])
conn.execute(table.delete())
self.assert_(colspec(table.c.y1).startswith("y1 YEAR"))
eq_regex(colspec(table.c.y5), r"y5 YEAR(?:\(4\))?")
def test_reflection_with_unique_constraint(self):
insp = inspect(testing.db)
meta = self.metadata
uc_table = Table(
"mysql_uc",
meta,
Column("a", String(10)),
UniqueConstraint("a", name="uc_a"),
)
uc_table.create()
# MySQL converts unique constraints into unique indexes.
# separately we get both
indexes = dict((i["name"], i) for i in insp.get_indexes("mysql_uc"))
constraints = set(i["name"]
for i in insp.get_unique_constraints("mysql_uc"))
self.assert_("uc_a" in indexes)
self.assert_(indexes["uc_a"]["unique"])
self.assert_("uc_a" in constraints)
# reflection here favors the unique index, as that's the
# more "official" MySQL construct
reflected = Table("mysql_uc", MetaData(testing.db), autoload=True)
indexes = dict((i.name, i) for i in reflected.indexes)
constraints = set(uc.name for uc in reflected.constraints)
self.assert_("uc_a" in indexes)
self.assert_(indexes["uc_a"].unique)
self.assert_("uc_a" not in constraints)
def test_enum_parse(self):
with testing.expect_deprecated("Manually quoting ENUM value literals"):
enum_table = Table(
"mysql_enum",
self.metadata,
Column("e1", mysql.ENUM("'a'")),
Column("e2", mysql.ENUM("''")),
Column("e3", mysql.ENUM("a")),
Column("e4", mysql.ENUM("")),
Column("e5", mysql.ENUM("'a'", "''")),
Column("e6", mysql.ENUM("''", "'a'")),
Column("e7", mysql.ENUM("''", "'''a'''", "'b''b'", "''''")),
)
for col in enum_table.c:
self.assert_(repr(col))
enum_table.create()
reflected = Table("mysql_enum", MetaData(testing.db), autoload=True)
for t in enum_table, reflected:
eq_(t.c.e1.type.enums, ["a"])
eq_(t.c.e2.type.enums, [""])
eq_(t.c.e3.type.enums, ["a"])
eq_(t.c.e4.type.enums, [""])
eq_(t.c.e5.type.enums, ["a", ""])
eq_(t.c.e6.type.enums, ["", "a"])
eq_(t.c.e7.type.enums, ["", "'a'", "b'b", "'"])
def test_precision_float_roundtrip(self):
t = Table(
"t",
self.metadata,
Column(
"scale_value",
mysql.DOUBLE(precision=15, scale=12, asdecimal=True),
),
Column(
"unscale_value",
mysql.DOUBLE(decimal_return_scale=12, asdecimal=True),
),
)
with testing.db.connect() as conn:
t.create(conn)
conn.execute(
t.insert(),
scale_value=45.768392065789,
unscale_value=45.768392065789,
)
result = conn.scalar(select([t.c.scale_value]))
eq_(result, decimal.Decimal("45.768392065789"))
result = conn.scalar(select([t.c.unscale_value]))
eq_(result, decimal.Decimal("45.768392065789"))
def test_checksfor_sequence(self):
meta1 = self.metadata
seq = Sequence("fooseq")
t = Table("mytable", meta1, Column("col1", Integer, seq))
seq.drop()
testing.db.execute("CREATE SEQUENCE fooseq")
t.create(checkfirst=True)
def test_empty_set_no_empty_string(self):
t = Table(
"t",
self.metadata,
Column("id", Integer),
Column("data", mysql.SET("a", "b")),
)
t.create()
with testing.db.begin() as conn:
conn.execute(
t.insert(),
{
"id": 1,
"data": set()
},
{
"id": 2,
"data": set([""])
},
{
"id": 3,
"data": set(["a", ""])
},
{
"id": 4,
"data": set(["b"])
},
)
eq_(
conn.execute(t.select().order_by(t.c.id)).fetchall(),
[(1, set()), (2, set()), (3, set(["a"])), (4, set(["b"]))],
)
def test_reflection_on_include_columns(self):
"""Test reflection of include_columns to be sure they respect case."""
case_table = Table(
"mysql_case",
MetaData(testing.db),
Column("c1", String(10)),
Column("C2", String(10)),
Column("C3", String(10)),
)
try:
case_table.create()
reflected = Table(
"mysql_case",
MetaData(testing.db),
autoload=True,
include_columns=["c1", "C2"],
)
for t in case_table, reflected:
assert "c1" in t.c.keys()
assert "C2" in t.c.keys()
reflected2 = Table(
"mysql_case",
MetaData(testing.db),
autoload=True,
include_columns=["c1", "c2"],
)
assert "c1" in reflected2.c.keys()
for c in ["c2", "C2", "C3"]:
assert c not in reflected2.c.keys()
finally:
case_table.drop()
def setup_class(cls):
# TODO: figure out which databases/which identifiers allow special
# characters to be used, such as: spaces, quote characters,
# punctuation characters, set up tests for those as well.
global table1, table2
metadata = MetaData(testing.db)
table1 = Table(
"WorstCase1",
metadata,
Column("lowercase", Integer, primary_key=True),
Column("UPPERCASE", Integer),
Column("MixedCase", Integer),
Column("ASC", Integer, key="a123"),
)
table2 = Table(
"WorstCase2",
metadata,
Column("desc", Integer, primary_key=True, key="d123"),
Column("Union", Integer, key="u123"),
Column("MixedCase", Integer),
)
table1.create()
table2.create()
def test_dates(self):
"Exercise type specification for date types."
columns = [
# column type, args, kwargs, expected ddl
(mssql.MSDateTime, [], {}, "DATETIME", []),
(types.DATE, [], {}, "DATE", [">=", (10, )]),
(types.Date, [], {}, "DATE", [">=", (10, )]),
(types.Date, [], {}, "DATETIME", ["<", (10, )], mssql.MSDateTime),
(mssql.MSDate, [], {}, "DATE", [">=", (10, )]),
(mssql.MSDate, [], {}, "DATETIME", ["<",
(10, )], mssql.MSDateTime),
(types.TIME, [], {}, "TIME", [">=", (10, )]),
(types.Time, [], {}, "TIME", [">=", (10, )]),
(mssql.MSTime, [], {}, "TIME", [">=", (10, )]),
(mssql.MSTime, [1], {}, "TIME(1)", [">=", (10, )]),
(types.Time, [], {}, "DATETIME", ["<", (10, )], mssql.MSDateTime),
(mssql.MSTime, [], {}, "TIME", [">=", (10, )]),
(mssql.MSSmallDateTime, [], {}, "SMALLDATETIME", []),
(mssql.MSDateTimeOffset, [], {}, "DATETIMEOFFSET", [">=", (10, )]),
(
mssql.MSDateTimeOffset,
[1],
{},
"DATETIMEOFFSET(1)",
[">=", (10, )],
),
(mssql.MSDateTime2, [], {}, "DATETIME2", [">=", (10, )]),
(mssql.MSDateTime2, [0], {}, "DATETIME2(0)", [">=", (10, )]),
(mssql.MSDateTime2, [1], {}, "DATETIME2(1)", [">=", (10, )]),
]
table_args = ["test_mssql_dates", metadata]
for index, spec in enumerate(columns):
type_, args, kw, res, requires = spec[0:5]
if (requires and testing._is_excluded("mssql", *requires)
or not requires):
c = Column("c%s" % index, type_(*args, **kw), nullable=None)
testing.db.dialect.type_descriptor(c.type)
table_args.append(c)
dates_table = Table(*table_args)
gen = testing.db.dialect.ddl_compiler(testing.db.dialect,
schema.CreateTable(dates_table))
for col in dates_table.c:
index = int(col.name[1:])
testing.eq_(
gen.get_column_specification(col),
"%s %s" % (col.name, columns[index][3]),
)
self.assert_(repr(col))
dates_table.create(checkfirst=True)
reflected_dates = Table("test_mssql_dates",
MetaData(testing.db),
autoload=True)
for col in reflected_dates.c:
self.assert_types_base(col, dates_table.c[col.key])
def test_time_roundtrip(self):
t = Table("mysql_time", self.metadata, Column("t1", mysql.TIME()))
with testing.db.connect() as conn:
t.create(conn)
conn.execute(t.insert().values(t1=datetime.time(8, 37, 35)))
eq_(
conn.execute(select([t.c.t1])).scalar(),
datetime.time(8, 37, 35),
)
def _test_specific_type(self, type_obj, ddl):
metadata = self.metadata
table = Table("type_test", metadata, Column("col1", type_obj))
table.create()
m2 = MetaData()
table2 = Table("type_test", m2, autoload_with=testing.db)
self.assert_compile(
schema.CreateTable(table2),
"CREATE TABLE type_test (col1 %s NULL)" % ddl,
)
def test_insertid_schema_legacy(self):
meta = self.metadata
eng = engines.testing_engine(options=dict(legacy_schema_aliasing=True))
meta.bind = eng
con = eng.connect()
con.execute("create schema paj")
@event.listens_for(meta, "after_drop")
def cleanup(target, connection, **kw):
connection.execute("drop schema paj")
tbl = Table(
"test", meta, Column("id", Integer, primary_key=True), schema="paj"
)
tbl.create()
tbl.insert().execute({"id": 1})
eq_(tbl.select().scalar(), 1)
def _test_round_trip(self,
type_,
data,
deprecate_large_types=True,
expected=None):
if (testing.db.dialect.deprecate_large_types
is not deprecate_large_types):
engine = engines.testing_engine(
options={"deprecate_large_types": deprecate_large_types})
else:
engine = testing.db
binary_table = Table(
"binary_table",
self.metadata,
Column("id", Integer, primary_key=True),
Column("data", type_),
)
binary_table.create(engine)
if expected is None:
expected = data
with engine.connect() as conn:
conn.execute(binary_table.insert(), data=data)
eq_(conn.scalar(select([binary_table.c.data])), expected)
eq_(
conn.scalar(
text("select data from binary_table").columns(
binary_table.c.data)),
expected,
)
conn.execute(binary_table.delete())
conn.execute(binary_table.insert(), data=None)
eq_(conn.scalar(select([binary_table.c.data])), None)
eq_(
conn.scalar(
text("select data from binary_table").columns(
binary_table.c.data)),
None,
)
def test_unicode_roundtrip(self):
set_table = Table(
"t",
self.metadata,
Column("id", Integer, primary_key=True),
Column("data", mysql.SET(u("réveillé"), u("drôle"), u("S’il"))),
)
set_table.create()
with testing.db.begin() as conn:
conn.execute(
set_table.insert(),
{"data": set([u("réveillé"), u("drôle")])})
row = conn.execute(set_table.select()).first()
eq_(row, (1, set([u("réveillé"), u("drôle")])))
def test_identity(self):
metadata = self.metadata
table = Table(
"identity_test",
metadata,
Column(
"col1",
Integer,
mssql_identity_start=2,
mssql_identity_increment=3,
primary_key=True,
),
)
table.create()
meta2 = MetaData(testing.db)
table2 = Table("identity_test", meta2, autoload=True)
eq_(table2.c["col1"].dialect_options["mssql"]["identity_start"], 2)
eq_(table2.c["col1"].dialect_options["mssql"]["identity_increment"], 3)
def test_set_roundtrip_plus_reflection(self):
set_table = Table(
"mysql_set",
self.metadata,
Column("s1", mysql.SET("dq", "sq")),
Column("s2", mysql.SET("a")),
Column("s3", mysql.SET("5", "7", "9")),
)
eq_(colspec(set_table.c.s1), "s1 SET('dq','sq')")
eq_(colspec(set_table.c.s2), "s2 SET('a')")
eq_(colspec(set_table.c.s3), "s3 SET('5','7','9')")
set_table.create()
reflected = Table("mysql_set", MetaData(testing.db), autoload=True)
for table in set_table, reflected:
def roundtrip(store, expected=None):
expected = expected or store
table.insert(store).execute()
row = table.select().execute().first()
eq_(row, tuple(expected))
table.delete().execute()
roundtrip([None, None, None], [None] * 3)
roundtrip(["", "", ""], [set([])] * 3)
roundtrip([set(["dq"]), set(["a"]), set(["5"])])
roundtrip(["dq", "a", "5"], [set(["dq"]), set(["a"]), set(["5"])])
roundtrip([1, 1, 1], [set(["dq"]), set(["a"]), set(["5"])])
roundtrip([set(["dq", "sq"]), None, set(["9", "5", "7"])])
set_table.insert().execute(
{"s3": set(["5"])},
{"s3": set(["5", "7"])},
{"s3": set(["5", "7", "9"])},
{"s3": set(["7", "9"])},
)
rows = (select([set_table.c.s3],
set_table.c.s3.in_([set(["5"]),
["5", "7"]])).execute().fetchall())
found = set([frozenset(row[0]) for row in rows])
eq_(found, set([frozenset(["5"]), frozenset(["5", "7"])]))
def test_charset_collate_table(self):
t = Table(
"foo",
self.metadata,
Column("id", Integer),
Column("data", UnicodeText),
mysql_default_charset="utf8",
mysql_collate="utf8_bin",
)
t.create()
m2 = MetaData(testing.db)
t2 = Table("foo", m2, autoload=True)
eq_(t2.kwargs["mysql_collate"], "utf8_bin")
eq_(t2.kwargs["mysql_default charset"], "utf8")
# test [ticket:2906]
# in order to test the condition here, need to use
# MySQLdb 1.2.3 and also need to pass either use_unicode=1
# or charset=utf8 to the URL.
t.insert().execute(id=1, data=u("some text"))
assert isinstance(testing.db.scalar(select([t.c.data])),
util.text_type)
def setup_class(cls):
metadata = MetaData(testing.db)
global info_table
info_table = Table(
"infos",
metadata,
Column("pk", Integer, primary_key=True),
Column("info", String(30)),
)
info_table.create()
info_table.insert().execute(
{
"pk": 1,
"info": "pk_1_data"
},
{
"pk": 2,
"info": "pk_2_data"
},
{
"pk": 3,
"info": "pk_3_data"
},
{
"pk": 4,
"info": "pk_4_data"
},
{
"pk": 5,
"info": "pk_5_data"
},
{
"pk": 6,
"info": "pk_6_data"
},
)
def test_schema_roundtrips(self):
meta = self.metadata
users = Table(
"users",
meta,
Column("id", Integer, primary_key=True),
Column("name", String(50)),
schema="test_schema",
)
users.create()
users.insert().execute(id=1, name="name1")
users.insert().execute(id=2, name="name2")
users.insert().execute(id=3, name="name3")
users.insert().execute(id=4, name="name4")
eq_(
users.select().where(users.c.name == "name2").execute().fetchall(),
[(2, "name2")],
)
eq_(
users.select(use_labels=True)
.where(users.c.name == "name2")
.execute()
.fetchall(),
[(2, "name2")],
)
users.delete().where(users.c.id == 3).execute()
eq_(
users.select().where(users.c.name == "name3").execute().fetchall(),
[],
)
users.update().where(users.c.name == "name4").execute(name="newname")
eq_(
users.select(use_labels=True)
.where(users.c.id == 4)
.execute()
.fetchall(),
[(4, "newname")],
)
def test_set_parse(self):
with testing.expect_deprecated("Manually quoting SET value literals"):
set_table = Table(
"mysql_set",
self.metadata,
Column("e1", mysql.SET("'a'")),
Column("e2", mysql.SET("''", retrieve_as_bitwise=True)),
Column("e3", mysql.SET("a")),
Column("e4", mysql.SET("", retrieve_as_bitwise=True)),
Column("e5", mysql.SET("'a'", "''", retrieve_as_bitwise=True)),
Column("e6", mysql.SET("''", "'a'", retrieve_as_bitwise=True)),
Column(
"e7",
mysql.SET(
"''",
"'''a'''",
"'b''b'",
"''''",
retrieve_as_bitwise=True,
),
),
)
for col in set_table.c:
self.assert_(repr(col))
set_table.create()
# don't want any warnings on reflection
reflected = Table("mysql_set", MetaData(testing.db), autoload=True)
for t in set_table, reflected:
eq_(t.c.e1.type.values, ("a", ))
eq_(t.c.e2.type.values, ("", ))
eq_(t.c.e3.type.values, ("a", ))
eq_(t.c.e4.type.values, ("", ))
eq_(t.c.e5.type.values, ("a", ""))
eq_(t.c.e6.type.values, ("", "a"))
eq_(t.c.e7.type.values, ("", "'a'", "b'b", "'"))
def test_reflection_with_table_options(self):
comment = r"""Comment types type speedily ' " \ '' Fun!"""
def_table = Table(
"mysql_def",
MetaData(testing.db),
Column("c1", Integer()),
mysql_engine="MEMORY",
comment=comment,
mysql_default_charset="utf8",
mysql_auto_increment="5",
mysql_avg_row_length="3",
mysql_password="******",
mysql_connection="fish",
)
def_table.create()
try:
reflected = Table("mysql_def", MetaData(testing.db), autoload=True)
finally:
def_table.drop()
assert def_table.kwargs["mysql_engine"] == "MEMORY"
assert def_table.comment == comment
assert def_table.kwargs["mysql_default_charset"] == "utf8"
assert def_table.kwargs["mysql_auto_increment"] == "5"
assert def_table.kwargs["mysql_avg_row_length"] == "3"
assert def_table.kwargs["mysql_password"] == "secret"
assert def_table.kwargs["mysql_connection"] == "fish"
assert reflected.kwargs["mysql_engine"] == "MEMORY"
assert reflected.comment == comment
assert reflected.kwargs["mysql_comment"] == comment
assert reflected.kwargs["mysql_default charset"] == "utf8"
assert reflected.kwargs["mysql_avg_row_length"] == "3"
assert reflected.kwargs["mysql_connection"] == "fish"
def test_broken_enum_returns_blanks(self):
t = Table(
"enum_missing",
self.metadata,
Column("id", Integer, primary_key=True),
Column("e1", sqltypes.Enum("one", "two", "three")),
Column("e2", mysql.ENUM("one", "two", "three")),
)
t.create()
with testing.db.connect() as conn:
conn.execute(t.insert(), {
"e1": "nonexistent",
"e2": "nonexistent"
})
conn.execute(t.insert(), {"e1": "", "e2": ""})
conn.execute(t.insert(), {"e1": "two", "e2": "two"})
conn.execute(t.insert(), {"e1": None, "e2": None})
eq_(
conn.execute(select([t.c.e1,
t.c.e2]).order_by(t.c.id)).fetchall(),
[("", ""), ("", ""), ("two", "two"), (None, None)],
)
def test_index_functional_create(self):
metadata = self.metadata
t = Table(
"sometable",
metadata,
Column("id", Integer, primary_key=True),
Column("data", String(50)),
)
Index("myindex", t.c.data.desc())
self.assert_sql_execution(
testing.db,
lambda: t.create(testing.db),
CompiledSQL("CREATE TABLE sometable (id INTEGER NOT NULL, "
"data VARCHAR(50), PRIMARY KEY (id))"),
CompiledSQL("CREATE INDEX myindex ON sometable (data DESC)"),
)
def test_index_create_inline(self):
# test an index create using index=True, unique=True
metadata = self.metadata
events = Table(
"events",
metadata,
Column("id", Integer, primary_key=True),
Column("name", String(30), index=True, unique=True),
Column("location", String(30), index=True),
Column("sport", String(30)),
Column("announcer", String(30)),
Column("winner", String(30)),
)
Index("sport_announcer",
events.c.sport,
events.c.announcer,
unique=True)
Index("idx_winners", events.c.winner)
eq_(
set(ix.name for ix in events.indexes),
set([
"ix_events_name",
"ix_events_location",
"sport_announcer",
"idx_winners",
]),
)
self.assert_sql_execution(
testing.db,
lambda: events.create(testing.db),
RegexSQL("^CREATE TABLE events"),
AllOf(
CompiledSQL("CREATE UNIQUE INDEX ix_events_name ON events "
"(name)"),
CompiledSQL("CREATE INDEX ix_events_location ON events "
"(location)"),
CompiledSQL("CREATE UNIQUE INDEX sport_announcer ON events "
"(sport, announcer)"),
CompiledSQL("CREATE INDEX idx_winners ON events (winner)"),
),
)
def test_enum(self):
"""Exercise the ENUM type."""
with testing.expect_deprecated("Manually quoting ENUM value literals"):
e1, e2 = mysql.ENUM("'a'", "'b'"), mysql.ENUM("'a'", "'b'")
e3 = mysql.ENUM("'a'", "'b'", strict=True)
e4 = mysql.ENUM("'a'", "'b'", strict=True)
enum_table = Table(
"mysql_enum",
self.metadata,
Column("e1", e1),
Column("e2", e2, nullable=False),
Column(
"e2generic",
Enum("a", "b", validate_strings=True),
nullable=False,
),
Column("e3", e3),
Column("e4", e4, nullable=False),
Column("e5", mysql.ENUM("a", "b")),
Column("e5generic", Enum("a", "b")),
Column("e6", mysql.ENUM("'a'", "b")),
Column(
"e7",
mysql.ENUM(
EnumSetTest.SomeEnum,
values_callable=EnumSetTest.get_enum_string_values,
),
),
Column("e8", mysql.ENUM(EnumSetTest.SomeEnum)),
)
eq_(colspec(enum_table.c.e1), "e1 ENUM('a','b')")
eq_(colspec(enum_table.c.e2), "e2 ENUM('a','b') NOT NULL")
eq_(colspec(enum_table.c.e2generic),
"e2generic ENUM('a','b') NOT NULL")
eq_(colspec(enum_table.c.e3), "e3 ENUM('a','b')")
eq_(colspec(enum_table.c.e4), "e4 ENUM('a','b') NOT NULL")
eq_(colspec(enum_table.c.e5), "e5 ENUM('a','b')")
eq_(colspec(enum_table.c.e5generic), "e5generic ENUM('a','b')")
eq_(colspec(enum_table.c.e6), "e6 ENUM('''a''','b')")
eq_(colspec(enum_table.c.e7), "e7 ENUM('1','2','3','a','b')")
eq_(
colspec(enum_table.c.e8),
"e8 ENUM('one','two','three','AMember','BMember')",
)
enum_table.create()
assert_raises(
exc.DBAPIError,
enum_table.insert().execute,
e1=None,
e2=None,
e3=None,
e4=None,
)
assert enum_table.c.e2generic.type.validate_strings
assert_raises(
exc.StatementError,
enum_table.insert().execute,
e1="c",
e2="c",
e2generic="c",
e3="c",
e4="c",
e5="c",
e5generic="c",
e6="c",
e7="c",
e8="c",
)
enum_table.insert().execute()
enum_table.insert().execute(
e1="a",
e2="a",
e2generic="a",
e3="a",
e4="a",
e5="a",
e5generic="a",
e6="'a'",
e7="a",
e8="AMember",
)
enum_table.insert().execute(
e1="b",
e2="b",
e2generic="b",
e3="b",
e4="b",
e5="b",
e5generic="b",
e6="b",
e7="b",
e8="BMember",
)
res = enum_table.select().execute().fetchall()
expected = [
(None, "a", "a", None, "a", None, None, None, None, None),
(
"a",
"a",
"a",
"a",
"a",
"a",
"a",
"'a'",
EnumSetTest.SomeEnum.AMember,
EnumSetTest.SomeEnum.AMember,
),
(
"b",
"b",
"b",
"b",
"b",
"b",
"b",
"b",
EnumSetTest.SomeEnum.BMember,
EnumSetTest.SomeEnum.BMember,
),
]
eq_(res, expected)
def test_default_reflection(self):
"""Test reflection of column defaults."""
from sqlalchemy_1_3.dialects.mysql import VARCHAR
def_table = Table(
"mysql_def",
MetaData(testing.db),
Column(
"c1",
VARCHAR(10, collation="utf8_unicode_ci"),
DefaultClause(""),
nullable=False,
),
Column("c2", String(10), DefaultClause("0")),
Column("c3", String(10), DefaultClause("abc")),
Column("c4", TIMESTAMP, DefaultClause("2009-04-05 12:00:00")),
Column("c5", TIMESTAMP),
Column(
"c6",
TIMESTAMP,
DefaultClause(
sql.text("CURRENT_TIMESTAMP "
"ON UPDATE CURRENT_TIMESTAMP")),
),
)
def_table.create()
try:
reflected = Table("mysql_def", MetaData(testing.db), autoload=True)
finally:
def_table.drop()
assert def_table.c.c1.server_default.arg == ""
assert def_table.c.c2.server_default.arg == "0"
assert def_table.c.c3.server_default.arg == "abc"
assert def_table.c.c4.server_default.arg == "2009-04-05 12:00:00"
assert str(reflected.c.c1.server_default.arg) == "''"
assert str(reflected.c.c2.server_default.arg) == "'0'"
assert str(reflected.c.c3.server_default.arg) == "'abc'"
assert (str(
reflected.c.c4.server_default.arg) == "'2009-04-05 12:00:00'")
assert reflected.c.c5.default is None
assert reflected.c.c5.server_default is None
assert reflected.c.c6.default is None
assert re.match(
r"CURRENT_TIMESTAMP(\(\))? ON UPDATE CURRENT_TIMESTAMP(\(\))?",
str(reflected.c.c6.server_default.arg).upper(),
)
reflected.create()
try:
reflected2 = Table("mysql_def",
MetaData(testing.db),
autoload=True)
finally:
reflected.drop()
assert str(reflected2.c.c1.server_default.arg) == "''"
assert str(reflected2.c.c2.server_default.arg) == "'0'"
assert str(reflected2.c.c3.server_default.arg) == "'abc'"
assert (str(
reflected2.c.c4.server_default.arg) == "'2009-04-05 12:00:00'")
assert reflected.c.c5.default is None
assert reflected.c.c5.server_default is None
assert reflected.c.c6.default is None
assert re.match(
r"CURRENT_TIMESTAMP(\(\))? ON UPDATE CURRENT_TIMESTAMP(\(\))?",
str(reflected.c.c6.server_default.arg).upper(),
)
