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(), )