def test_unicode_enum(self):
metadata = self.metadata
t1 = Table(
"table",
metadata,
Column("id", Integer, primary_key=True),
Column("value", Enum(u("réveillé"), u("drôle"), u("S’il"))),
Column("value2", mysql.ENUM(u("réveillé"), u("drôle"), u("S’il"))),
)
metadata.create_all()
t1.insert().execute(value=u("drôle"), value2=u("drôle"))
t1.insert().execute(value=u("réveillé"), value2=u("réveillé"))
t1.insert().execute(value=u("S’il"), value2=u("S’il"))
eq_(
t1.select().order_by(t1.c.id).execute().fetchall(),
[
(1, u("drôle"), u("drôle")),
(2, u("réveillé"), u("réveillé")),
(3, u("S’il"), u("S’il")),
],
)
# test reflection of the enum labels
m2 = MetaData(testing.db)
t2 = Table("table", m2, autoload=True)
# TODO: what's wrong with the last element ? is there
# latin-1 stuff forcing its way in ?
eq_(
t2.c.value.type.enums[0:2], [u("réveillé"), u("drôle")]
) # u'S’il') # eh ?
eq_(
t2.c.value2.type.enums[0:2], [u("réveillé"), u("drôle")]
) # u'S’il') # eh ?
def test_broken_enum_returns_blanks(self, metadata, connection):
t = Table(
"enum_missing",
metadata,
Column("id", Integer, primary_key=True),
Column("e1", sqltypes.Enum("one", "two", "three")),
Column("e2", mysql.ENUM("one", "two", "three")),
)
t.create(connection)
connection.execute(
t.insert(),
[
{
"e1": "nonexistent",
"e2": "nonexistent"
},
{
"e1": "",
"e2": ""
},
{
"e1": "two",
"e2": "two"
},
{
"e1": None,
"e2": None
},
],
)
eq_(
connection.execute(select(t.c.e1,
t.c.e2).order_by(t.c.id)).fetchall(),
[("", ""), ("", ""), ("two", "two"), (None, None)],
)
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_enum(self, metadata, connection):
"""Exercise the ENUM type."""
e1 = mysql.ENUM("a", "b")
e2 = mysql.ENUM("a", "b")
e3 = mysql.ENUM("a", "b", strict=True)
e4 = mysql.ENUM("a", "b", strict=True)
enum_table = Table(
"mysql_enum",
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(connection)
assert_raises(
exc.DBAPIError,
connection.execute,
enum_table.insert(),
dict(
e1=None,
e2=None,
e3=None,
e4=None,
),
)
assert enum_table.c.e2generic.type.validate_strings
assert_raises(
exc.StatementError,
connection.execute,
enum_table.insert(),
dict(
e1="c",
e2="c",
e2generic="c",
e3="c",
e4="c",
e5="c",
e5generic="c",
e6="c",
e7="c",
e8="c",
),
)
connection.execute(enum_table.insert())
connection.execute(
enum_table.insert(),
dict(
e1="a",
e2="a",
e2generic="a",
e3="a",
e4="a",
e5="a",
e5generic="a",
e6="'a'",
e7="a",
e8="AMember",
),
)
connection.execute(
enum_table.insert(),
dict(
e1="b",
e2="b",
e2generic="b",
e3="b",
e4="b",
e5="b",
e5generic="b",
e6="b",
e7="b",
e8="BMember",
),
)
res = connection.execute(enum_table.select()).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_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")),
)
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')")
enum_table.create()
assert_raises(exc.DBAPIError,
enum_table.insert().execute,
e1=None,
e2=None,
e3=None,
e4=None)
assert_raises(exc.StatementError,
enum_table.insert().execute,
e1='c',
e2='c',
e2generic='c',
e3='c',
e4='c',
e5='c',
e5generic='c',
e6='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'")
enum_table.insert().execute(e1='b',
e2='b',
e2generic='b',
e3='b',
e4='b',
e5='b',
e5generic='b',
e6='b')
res = enum_table.select().execute().fetchall()
expected = [(None, 'a', 'a', None, 'a', None, None, None),
('a', 'a', 'a', 'a', 'a', 'a', 'a', "'a'"),
('b', 'b', 'b', 'b', 'b', 'b', 'b', 'b')]
eq_(res, expected)
def test_legacy_enum_types(self):
specs = [(mysql.ENUM("", "fleem"), mysql.ENUM("", "fleem"))]
self._run_test(specs, ["enums"])
def test_type_reflection(self):
# (ask_for, roundtripped_as_if_different)
specs = [(String(1), mysql.MSString(1), ),
(String(3), mysql.MSString(3), ),
(Text(), mysql.MSText(), ),
(Unicode(1), mysql.MSString(1), ),
(Unicode(3), mysql.MSString(3), ),
(UnicodeText(), mysql.MSText(), ),
(mysql.MSChar(1), ),
(mysql.MSChar(3), ),
(NCHAR(2), mysql.MSChar(2), ),
(mysql.MSNChar(2), mysql.MSChar(2), ), # N is CREATE only
(mysql.MSNVarChar(22), mysql.MSString(22), ),
(SmallInteger(), mysql.MSSmallInteger(), ),
(SmallInteger(), mysql.MSSmallInteger(4), ),
(mysql.MSSmallInteger(), ),
(mysql.MSSmallInteger(4), mysql.MSSmallInteger(4), ),
(mysql.MSMediumInteger(), mysql.MSMediumInteger(), ),
(mysql.MSMediumInteger(8), mysql.MSMediumInteger(8), ),
(LargeBinary(3), mysql.TINYBLOB(), ),
(LargeBinary(), mysql.BLOB() ),
(mysql.MSBinary(3), mysql.MSBinary(3), ),
(mysql.MSVarBinary(3),),
(mysql.MSTinyBlob(),),
(mysql.MSBlob(),),
(mysql.MSBlob(1234), mysql.MSBlob()),
(mysql.MSMediumBlob(),),
(mysql.MSLongBlob(),),
(mysql.ENUM("''","'fleem'"), ),
]
columns = [Column('c%i' % (i + 1), t[0]) for i, t in enumerate(specs)]
db = testing.db
m = MetaData(db)
t_table = Table('mysql_types', m, *columns)
try:
m.create_all()
m2 = MetaData(db)
rt = Table('mysql_types', m2, autoload=True)
try:
db.execute('CREATE OR REPLACE VIEW mysql_types_v '
'AS SELECT * from mysql_types')
rv = Table('mysql_types_v', m2, autoload=True)
expected = [len(c) > 1 and c[1] or c[0] for c in specs]
# Early 5.0 releases seem to report more "general" for columns
# in a view, e.g. char -> varchar, tinyblob -> mediumblob
#
# Not sure exactly which point version has the fix.
if db.dialect.server_version_info < (5, 0, 11):
tables = rt,
else:
tables = rt, rv
for table in tables:
for i, reflected in enumerate(table.c):
assert isinstance(reflected.type,
type(expected[i])), \
'element %d: %r not instance of %r' % (i,
reflected.type, type(expected[i]))
finally:
db.execute('DROP VIEW mysql_types_v')
finally:
m.drop_all()
