def test_mariadb_normalized_version(
self, expected, raw_version, version, is_mariadb
):
dialect = mysql.dialect()
eq_(dialect._parse_server_version(raw_version), version)
dialect.server_version_info = version
eq_(dialect._mariadb_normalized_version_info, expected)
assert dialect._is_mariadb is is_mariadb
def test_generic_now(self):
assert isinstance(func.now().type, sqltypes.DateTime)
for ret, dialect in [
("CURRENT_TIMESTAMP", sqlite.dialect()),
("now()", postgresql.dialect()),
("now()", mysql.dialect()),
("CURRENT_TIMESTAMP", oracle.dialect()),
]:
self.assert_compile(func.now(), ret, dialect=dialect)
def test_generic_random(self):
assert func.random().type == sqltypes.NULLTYPE
assert isinstance(func.random(type_=Integer).type, Integer)
for ret, dialect in [
("random()", sqlite.dialect()),
("random()", postgresql.dialect()),
("rand()", mysql.dialect()),
("random()", oracle.dialect()),
]:
self.assert_compile(func.random(), ret, dialect=dialect)
def test_mariadb_check_warning(self, expect_, version):
dialect = mysql.dialect()
dialect.server_version_info = version
if expect_:
with expect_warnings(
".*before 10.2.9 has known issues regarding "
"CHECK constraints"
):
dialect._warn_for_known_db_issues()
else:
dialect._warn_for_known_db_issues()
def test_update_from_join_mysql_no_whereclause_two(self):
users, addresses = self.tables.users, self.tables.addresses
j = users.join(addresses)
self.assert_compile(
update(j).values({users.c.name: addresses.c.email_address}),
""
"UPDATE users "
"INNER JOIN addresses ON users.id = addresses.user_id "
"SET users.name=addresses.email_address",
checkparams={},
dialect=mysql.dialect(),
)
def test_update_from_join_mysql_no_whereclause_one(self):
users, addresses = self.tables.users, self.tables.addresses
j = users.join(addresses)
self.assert_compile(
update(j).values(name="newname"),
""
"UPDATE users "
"INNER JOIN addresses ON users.id = addresses.user_id "
"SET users.name=%s",
checkparams={"name": "newname"},
dialect=mysql.dialect(),
)
def test_prefix_with(self):
table1 = self.tables.mytable
stmt = (
table1.delete()
.prefix_with("A", "B", dialect="mysql")
.prefix_with("C", "D")
)
self.assert_compile(stmt, "DELETE C D FROM mytable")
self.assert_compile(
stmt, "DELETE A B C D FROM mytable", dialect=mysql.dialect()
)
def test_render_table_mysql(self):
users, addresses = self.tables.users, self.tables.addresses
self.assert_compile(
users.update()
.values(name="newname")
.where(users.c.id == addresses.c.user_id)
.where(addresses.c.email_address == "e1"),
"UPDATE users, addresses "
"SET users.name=%s "
"WHERE "
"users.id = addresses.user_id AND "
"addresses.email_address = %s",
checkparams={"email_address_1": "e1", "name": "newname"},
dialect=mysql.dialect(),
)
def test_update_from_join_mysql_whereclause(self):
users, addresses = self.tables.users, self.tables.addresses
j = users.join(addresses)
self.assert_compile(
update(j)
.values(name="newname")
.where(addresses.c.email_address == "e1"),
""
"UPDATE users "
"INNER JOIN addresses ON users.id = addresses.user_id "
"SET users.name=%s "
"WHERE "
"addresses.email_address = %s",
checkparams={"email_address_1": "e1", "name": "newname"},
dialect=mysql.dialect(),
)
def test_update_from_join_mysql_no_whereclause_three(self):
users, addresses, dingalings = (
self.tables.users,
self.tables.addresses,
self.tables.dingalings,
)
j = users.join(addresses).join(dingalings)
self.assert_compile(
update(j).values({users.c.name: dingalings.c.id}),
""
"UPDATE users "
"INNER JOIN addresses ON users.id = addresses.user_id "
"INNER JOIN dingalings ON addresses.id = dingalings.address_id "
"SET users.name=dingalings.id",
checkparams={},
dialect=mysql.dialect(),
)
def test_prefix_with(self):
table1 = self.tables.mytable
stmt = (table1.insert().prefix_with("A", "B",
dialect="mysql").prefix_with(
"C", "D"))
self.assert_compile(
stmt,
"INSERT C D INTO mytable (myid, name, description) "
"VALUES (:myid, :name, :description)",
)
self.assert_compile(
stmt,
"INSERT A B C D INTO mytable (myid, name, description) "
"VALUES (%s, %s, %s)",
dialect=mysql.dialect(),
)
def test_prefix_with(self):
table1 = self.tables.mytable
stmt = (
table1.update()
.prefix_with("A", "B", dialect="mysql")
.prefix_with("C", "D")
)
self.assert_compile(
stmt,
"UPDATE C D mytable SET myid=:myid, name=:name, "
"description=:description",
)
self.assert_compile(
stmt,
"UPDATE A B C D mytable SET myid=%s, name=%s, description=%s",
dialect=mysql.dialect(),
)
def test_update_bound_ordering(self):
"""test that bound parameters between the UPDATE and FROM clauses
order correctly in different SQL compilation scenarios.
"""
table1 = self.tables.mytable
table2 = self.tables.myothertable
sel = select([table2]).where(table2.c.otherid == 5).alias()
upd = (
table1.update()
.where(table1.c.name == sel.c.othername)
.values(name="foo")
)
dialect = default.StrCompileDialect()
dialect.positional = True
self.assert_compile(
upd,
"UPDATE mytable SET name=:name FROM (SELECT "
"myothertable.otherid AS otherid, "
"myothertable.othername AS othername "
"FROM myothertable "
"WHERE myothertable.otherid = :otherid_1) AS anon_1 "
"WHERE mytable.name = anon_1.othername",
checkpositional=("foo", 5),
dialect=dialect,
)
self.assert_compile(
upd,
"UPDATE mytable, (SELECT myothertable.otherid AS otherid, "
"myothertable.othername AS othername "
"FROM myothertable "
"WHERE myothertable.otherid = %s) AS anon_1 SET mytable.name=%s "
"WHERE mytable.name = anon_1.othername",
checkpositional=(5, "foo"),
dialect=mysql.dialect(),
)