def test_get_character_set_info(self):
cmy = MySQL()
self.assertRaises(MySQLInterfaceError, cmy.get_character_set_info)
cmy.connect(**self.connect_kwargs)
# We go by the default of MySQL, which is latin1/swedish_ci
exp = {
'comment': '',
'name': 'latin1_swedish_ci',
'csname': 'latin1',
'mbmaxlen': 1,
'number': 8,
'mbminlen': 1
}
result = cmy.get_character_set_info()
# make 'comment' deterministic
result['comment'] = ''
self.assertEqual(exp, result)
cmy.query("SET NAMES utf8")
cmy.set_character_set('utf8')
exp = {
'comment': '',
'name': 'utf8_general_ci',
'csname': 'utf8',
'mbmaxlen': 3,
'number': 33,
'mbminlen': 1
}
result = cmy.get_character_set_info()
# make 'comment' deterministic
result['comment'] = ''
self.assertEqual(exp, result)
def test_query(self):
config = self.connect_kwargs.copy()
cmy = MySQL(buffered=True)
self.assertRaises(MySQLInterfaceError, cmy.query)
cmy.connect(**config)
self.assertRaises(MySQLInterfaceError, cmy.query, "SELECT spam")
self.assertTrue(cmy.query("SET @ham = 4"))
self.assertEqual(None, cmy.num_fields())
self.assertEqual(0, cmy.field_count())
self.assertTrue(cmy.query("SELECT @ham"))
self.assertEqual(4, cmy.fetch_row()[0])
self.assertEqual(None, cmy.fetch_row())
cmy.free_result()
self.assertTrue(cmy.query("SELECT 'ham', 'spam', 5", raw=True))
row = cmy.fetch_row()
self.assertTrue(isinstance(row[0], bytearray))
self.assertEqual(bytearray(b'spam'), row[1])
self.assertEqual(None, cmy.fetch_row())
cmy.free_result()
def test_query(self):
config = self.connect_kwargs.copy()
cmy = MySQL(buffered=True)
self.assertRaises(MySQLInterfaceError, cmy.query)
cmy.connect(**config)
self.assertRaises(MySQLInterfaceError, cmy.query, "SELECT spam")
self.assertTrue(cmy.query("SET @ham = 4"))
self.assertEqual(None, cmy.num_fields())
self.assertEqual(0, cmy.field_count())
self.assertTrue(cmy.query("SELECT @ham"))
self.assertEqual(4, cmy.fetch_row()[0])
self.assertEqual(None, cmy.fetch_row())
cmy.free_result()
self.assertTrue(cmy.query("SELECT 'ham', 'spam', 5", raw=True))
row = cmy.fetch_row()
self.assertTrue(isinstance(row[0], bytearray))
self.assertEqual(bytearray(b'spam'), row[1])
self.assertEqual(None, cmy.fetch_row())
cmy.free_result()
def test_warning_count(self):
cmy = MySQL()
cmy.connect(**self.connect_kwargs)
cmy.query("SELECT 'a' + 'b'", buffered=False)
fetch_rows(cmy)
self.assertEqual(2, cmy.warning_count())
cmy.query("SELECT 1 + 1", buffered=True)
self.assertEqual(0, cmy.warning_count())
fetch_rows(cmy)
def test_warning_count(self):
cmy = MySQL()
cmy.connect(**self.connect_kwargs)
cmy.query("SELECT 'a' + 'b'", buffered=False)
fetch_rows(cmy)
self.assertEqual(2, cmy.warning_count())
cmy.query("SELECT 1 + 1", buffered=True)
self.assertEqual(0, cmy.warning_count())
fetch_rows(cmy)
def test_hex_string(self):
config = self.connect_kwargs.copy()
cmy = MySQL(buffered=True)
table = "hex_string"
cases = {
'utf8': [
(u'ham', b"X'68616D'"),
],
'big5': [
(u'\u5C62', b"X'B9F0'")
],
'sjis': [
(u'\u005c', b"X'5C'"),
],
'gbk': [
(u'赵孟頫', b"X'D5D4C3CFEE5C'"),
(u'赵\孟\頫\\', b"X'D5D45CC3CF5CEE5C5C'"),
(u'遜', b"X'DF64'")
],
'ascii': [
('\x5c\x00\x5c', b"X'5C005C'"),
],
}
cmy.connect(**config)
def create_table(charset):
cmy.query("DROP TABLE IF EXISTS {0}".format(table))
cmy.query("CREATE TABLE {0} (id INT, "
"c1 VARCHAR(400)) CHARACTER SET {1}".format(
table, charset))
insert = "INSERT INTO {0} (id, c1) VALUES ({{id}}, {{hex}})".format(
table)
select = "SELECT c1 FROM {0} WHERE id = {{id}}".format(table)
for encoding, data in cases.items():
create_table(encoding)
for i, info in enumerate(data):
case, exp = info
cmy.set_character_set(encoding)
hexed = cmy.hex_string(case.encode(encoding))
self.assertEqual(exp, hexed)
cmy.query(insert.format(id=i, hex=hexed.decode()))
cmy.query(select.format(id=i))
try:
fetched = fetch_rows(cmy)[0][0]
except UnicodeEncodeError:
self.fail("Could not encode {0}".format(encoding))
self.assertEqual(case, fetched,
"Failed with case {0}/{1}".format(i, encoding))
def test_select_db(self):
cmy = MySQL(buffered=True)
cmy.connect(**self.connect_kwargs)
cmy.select_db('mysql')
cmy.query("SELECT DATABASE()")
self.assertEqual(b'mysql', cmy.fetch_row()[0])
cmy.free_result()
cmy.select_db('myconnpy')
cmy.query("SELECT DATABASE()")
self.assertEqual(b'myconnpy', cmy.fetch_row()[0])
cmy.free_result()
def test_select_db(self):
cmy = MySQL(buffered=True)
cmy.connect(**self.connect_kwargs)
cmy.select_db('mysql')
cmy.query("SELECT DATABASE()")
self.assertEqual(b'mysql', cmy.fetch_row()[0])
cmy.free_result()
cmy.select_db('myconnpy')
cmy.query("SELECT DATABASE()")
self.assertEqual(b'myconnpy', cmy.fetch_row()[0])
cmy.free_result()
def test_st_server_status(self):
config = self.connect_kwargs.copy()
cmy = MySQL(buffered=True)
self.assertEqual(0, cmy.st_server_status())
cmy.connect(**config)
self.assertTrue(cmy.st_server_status() & ServerFlag.STATUS_AUTOCOMMIT)
cmy.autocommit(False)
self.assertFalse(cmy.st_server_status() & ServerFlag.STATUS_AUTOCOMMIT)
cmy.query("START TRANSACTION")
self.assertTrue(cmy.st_server_status() & ServerFlag.STATUS_IN_TRANS)
cmy.query("ROLLBACK")
self.assertFalse(cmy.st_server_status() & ServerFlag.STATUS_IN_TRANS)
def test_insert_id(self):
cmy = MySQL(buffered=True)
cmy.connect(**self.connect_kwargs)
table = "insert_id_test"
cmy.query("DROP TABLE IF EXISTS {0}".format(table))
cmy.query("CREATE TABLE {0} (id INT AUTO_INCREMENT KEY)".format(table))
self.assertEqual(0, cmy.insert_id())
cmy.query("INSERT INTO {0} VALUES ()".format(table))
self.assertEqual(1, cmy.insert_id())
# Multiple-row
cmy.query("INSERT INTO {0} VALUES (), ()".format(table))
self.assertEqual(2, cmy.insert_id())
cmy.query("DROP TABLE IF EXISTS {0}".format(table))
def test_insert_id(self):
cmy = MySQL(buffered=True)
cmy.connect(**self.connect_kwargs)
table = "insert_id_test"
cmy.query("DROP TABLE IF EXISTS {0}".format(table))
cmy.query("CREATE TABLE {0} (id INT AUTO_INCREMENT KEY)".format(table))
self.assertEqual(0, cmy.insert_id())
cmy.query("INSERT INTO {0} VALUES ()".format(table))
self.assertEqual(1, cmy.insert_id())
# Multiple-row
cmy.query("INSERT INTO {0} VALUES (), ()".format(table))
self.assertEqual(2, cmy.insert_id())
cmy.query("DROP TABLE IF EXISTS {0}".format(table))
def test_next_result(self):
cmy = MySQL()
cmy.connect(**self.connect_kwargs)
table = "next_result_test"
cmy.query("DROP TABLE IF EXISTS {0}".format(table))
cmy.query("CREATE TABLE {0} (c1 INT AUTO_INCREMENT KEY)".format(table))
var_names = ('"HAVE_CRYPT"', '"CHARACTER_SET_CONNECTION"')
queries = (
"SELECT VARIABLE_NAME FROM INFORMATION_SCHEMA.SESSION_VARIABLES "
"WHERE VARIABLE_NAME IN ({0})".format(','.join(var_names)),
"SELECT 'HAM'",
"INSERT INTO {0} () VALUES ()".format(table),
"SELECT 'SPAM'",
)
exp = [
[(b'HAVE_CRYPT',), (b'CHARACTER_SET_CONNECTION',)],
[(b'HAM',)],
{'insert_id': 1, 'affected': 1},
[(b'SPAM',)]
]
result = []
have_more = cmy.query(';'.join(queries))
self.assertTrue(have_more)
while have_more:
if cmy.have_result_set:
rows = []
row = cmy.fetch_row()
while row:
rows.append(row)
row = cmy.fetch_row()
result.append(rows)
else:
result.append({
"affected": cmy.affected_rows(),
"insert_id": cmy.insert_id()
})
have_more = cmy.next_result()
self.assertEqual(exp, result)
def test_st_server_status(self):
config = self.connect_kwargs.copy()
cmy = MySQL(buffered=True)
self.assertEqual(0, cmy.st_server_status())
cmy.connect(**config)
self.assertTrue(
cmy.st_server_status() & ServerFlag.STATUS_AUTOCOMMIT)
cmy.autocommit(False)
self.assertFalse(
cmy.st_server_status() & ServerFlag.STATUS_AUTOCOMMIT)
cmy.query("START TRANSACTION")
self.assertTrue(
cmy.st_server_status() & ServerFlag.STATUS_IN_TRANS)
cmy.query("ROLLBACK")
self.assertFalse(
cmy.st_server_status() & ServerFlag.STATUS_IN_TRANS)
def test_next_result(self):
cmy = MySQL()
cmy.connect(**self.connect_kwargs)
table = "next_result_test"
cmy.query("DROP TABLE IF EXISTS {0}".format(table))
cmy.query("CREATE TABLE {0} (c1 INT AUTO_INCREMENT KEY)".format(table))
var_names = ('"HAVE_CRYPT"', '"CHARACTER_SET_CONNECTION"')
queries = (
"SELECT VARIABLE_NAME FROM INFORMATION_SCHEMA.SESSION_VARIABLES "
"WHERE VARIABLE_NAME IN ({0})".format(','.join(var_names)),
"SELECT 'HAM'",
"INSERT INTO {0} () VALUES ()".format(table),
"SELECT 'SPAM'",
)
exp = [[(b'HAVE_CRYPT', ), (b'CHARACTER_SET_CONNECTION', )],
[(b'HAM', )], {
'insert_id': 1,
'affected': 1
}, [(b'SPAM', )]]
result = []
have_more = cmy.query(';'.join(queries))
self.assertTrue(have_more)
while have_more:
if cmy.have_result_set:
rows = []
row = cmy.fetch_row()
while row:
rows.append(row)
row = cmy.fetch_row()
result.append(rows)
else:
result.append({
"affected": cmy.affected_rows(),
"insert_id": cmy.insert_id()
})
have_more = cmy.next_result()
self.assertEqual(exp, result)
def test_get_character_set_info(self):
cmy = MySQL()
self.assertRaises(MySQLInterfaceError, cmy.get_character_set_info)
cmy.connect(**self.connect_kwargs)
# We go by the default of MySQL, which is latin1/swedish_ci
exp = {'comment': '', 'name': 'latin1_swedish_ci',
'csname': 'latin1', 'mbmaxlen': 1, 'number': 8, 'mbminlen': 1}
result = cmy.get_character_set_info()
# make 'comment' deterministic
result['comment'] = ''
self.assertEqual(exp, result)
cmy.query("SET NAMES utf8")
cmy.set_character_set('utf8')
exp = {'comment': '', 'name': 'utf8_general_ci',
'csname': 'utf8', 'mbmaxlen': 3, 'number': 33, 'mbminlen': 1}
result = cmy.get_character_set_info()
# make 'comment' deterministic
result['comment'] = ''
self.assertEqual(exp, result)
def test_hex_string(self):
config = self.connect_kwargs.copy()
cmy = MySQL(buffered=True)
table = "hex_string"
cases = {
'utf8': [
(u'ham', b"X'68616D'"),
],
'big5': [
(u'\u5C62', b"X'B9F0'")
],
'sjis': [
(u'\u005c', b"X'5C'"),
],
'gbk': [
(u'赵孟頫', b"X'D5D4C3CFEE5C'"),
(u'赵\孟\頫\\', b"X'D5D45CC3CF5CEE5C5C'"),
(u'遜', b"X'DF64'")
],
'ascii': [
('\x5c\x00\x5c', b"X'5C005C'"),
],
}
cmy.connect(**config)
def create_table(charset):
cmy.query("DROP TABLE IF EXISTS {0}".format(table))
cmy.query("CREATE TABLE {0} (id INT, "
"c1 VARCHAR(400)) CHARACTER SET {1}".format(
table, charset))
insert = "INSERT INTO {0} (id, c1) VALUES ({{id}}, {{hex}})".format(
table)
select = "SELECT c1 FROM {0} WHERE id = {{id}}".format(table)
for encoding, data in cases.items():
create_table(encoding)
for i, info in enumerate(data):
case, exp = info
cmy.set_character_set(encoding)
hexed = cmy.hex_string(case.encode(encoding))
self.assertEqual(exp, hexed)
cmy.query(insert.format(id=i, hex=hexed.decode()))
cmy.query(select.format(id=i))
try:
fetched = fetch_rows(cmy)[0][0]
except UnicodeEncodeError:
self.fail("Could not encode {0}".format(encoding))
self.assertEqual(case, fetched.decode(encoding),
"Failed with case {0}/{1}".format(i, encoding))
cmy.query("DROP TABLE IF EXISTS {0}".format(table))
def test_affected_rows(self):
cmy = MySQL(buffered=True)
cmy.connect(**self.connect_kwargs)
table = "affected_rows"
cmy.select_db('myconnpy')
cmy.query("DROP TABLE IF EXISTS {0}".format(table))
cmy.query("CREATE TABLE {0} (c1 INT, c2 INT)".format(table))
cmy.query("INSERT INTO {0} (c1, c2) VALUES "
"(1, 10), (2, 20), (3, 30)".format(table))
self.assertEqual(3, cmy.affected_rows())
cmy.query("UPDATE {0} SET c2 = c2 + 1 WHERE c1 < 3".format(table))
self.assertEqual(2, cmy.affected_rows())
cmy.query("DELETE FROM {0} WHERE c1 IN (1, 2, 3)".format(table))
self.assertEqual(3, cmy.affected_rows())
cmy.query("DROP TABLE IF EXISTS {0}".format(table))
def test_change_user(self):
connect_kwargs = self.connect_kwargs.copy()
connect_kwargs['unix_socket'] = None
cmy1 = MySQL(buffered=True)
cmy1.connect(**connect_kwargs)
cmy2 = MySQL(buffered=True)
cmy2.connect(**connect_kwargs)
new_user = {
'user': '******',
'host': self.config['host'],
'database': self.connect_kwargs['database'],
'password': '******',
}
try:
cmy1.query("DROP USER '{user}'@'{host}'".format(**new_user))
except MySQLInterfaceError:
# Probably not created
pass
stmt = ("CREATE USER '{user}'@'{host}' IDENTIFIED WITH "
"mysql_native_password").format(**new_user)
cmy1.query(stmt)
cmy1.query("SET old_passwords = 0")
res = cmy1.query("SET PASSWORD FOR '{user}'@'{host}' = "
"PASSWORD('{password}')".format(**new_user))
cmy1.query("GRANT ALL ON {database}.* "
"TO '{user}'@'{host}'".format(**new_user))
cmy2.query("SHOW GRANTS FOR {user}@{host}".format(**new_user))
cmy2.query("SELECT USER()")
orig_user = cmy2.fetch_row()[0]
cmy2.free_result()
cmy2.change_user(user=new_user['user'], password=new_user['password'],
database=new_user['database'])
cmy2.query("SELECT USER()")
current_user = cmy2.fetch_row()[0]
self.assertNotEqual(orig_user, current_user)
self.assertTrue(
u"{user}@".format(**new_user) in current_user.decode('utf8'))
cmy2.free_result()
def test_autocommit(self):
cmy1 = MySQL(buffered=True)
cmy1.connect(**self.connect_kwargs)
cmy2 = MySQL(buffered=True)
cmy2.connect(**self.connect_kwargs)
self.assertRaises(ValueError, cmy1.autocommit, 'ham')
self.assertRaises(ValueError, cmy1.autocommit, 1)
self.assertRaises(ValueError, cmy1.autocommit, None)
table = "autocommit_test"
# For the test we start off by making sure the autocommit is off
# for both sessions
cmy1.query("SELECT @@global.autocommit")
if cmy1.fetch_row()[0] != 1:
cmy1.query("SET @@session.autocommit = 0")
cmy2.query("SET @@session.autocommit = 0")
cmy1.query("DROP TABLE IF EXISTS {0}".format(table))
cmy1.query("CREATE TABLE {0} (c1 INT)".format(table))
# Turn AUTOCOMMIT on
cmy1.autocommit(True)
cmy1.query("INSERT INTO {0} (c1) VALUES "
"(1), (2), (3)".format(table))
cmy2.query("SELECT * FROM {0}".format(table))
self.assertEqual(3, cmy2.num_rows())
rows = fetch_rows(cmy2)
# Turn AUTOCOMMIT off
cmy1.autocommit(False)
cmy1.query("INSERT INTO {0} (c1) VALUES "
"(4), (5), (6)".format(table))
cmy2.query("SELECT * FROM {0} WHERE c1 > 3".format(table))
self.assertEqual([], fetch_rows(cmy2))
cmy1.commit()
cmy2.query("SELECT * FROM {0} WHERE c1 > 3".format(table))
self.assertEqual([(4,), (5,), (6,)], fetch_rows(cmy2))
cmy1.close()
cmy2.close()
def test_field_count(self):
cmy = MySQL(buffered=True)
cmy.connect(**self.connect_kwargs)
table = "field_count"
cmy.select_db('myconnpy')
cmy.query("DROP TABLE IF EXISTS {0}".format(table))
cmy.query("CREATE TABLE {0} (c1 INT, c2 INT, c3 INT)".format(table))
cmy.query("SELECT * FROM {0}".format(table))
self.assertEqual(3, cmy.field_count())
cmy.free_result()
cmy.query("INSERT INTO {0} (c1, c2, c3) VALUES "
"(1, 10, 100)".format(table))
cmy.commit()
cmy.query("SELECT * FROM {0}".format(table))
self.assertEqual(3, cmy.field_count())
cmy.free_result()
cmy.query("DROP TABLE IF EXISTS {0}".format(table))
def test_affected_rows(self):
cmy = MySQL(buffered=True)
cmy.connect(**self.connect_kwargs)
table = "affected_rows"
cmy.select_db('myconnpy')
cmy.query("DROP TABLE IF EXISTS {0}".format(table))
cmy.query("CREATE TABLE {0} (c1 INT, c2 INT)".format(table))
cmy.query("INSERT INTO {0} (c1, c2) VALUES "
"(1, 10), (2, 20), (3, 30)".format(table))
self.assertEqual(3, cmy.affected_rows())
cmy.query("UPDATE {0} SET c2 = c2 + 1 WHERE c1 < 3".format(table))
self.assertEqual(2, cmy.affected_rows())
cmy.query("DELETE FROM {0} WHERE c1 IN (1, 2, 3)".format(table))
self.assertEqual(3, cmy.affected_rows())
cmy.query("DROP TABLE IF EXISTS {0}".format(table))
def test_field_count(self):
cmy = MySQL(buffered=True)
cmy.connect(**self.connect_kwargs)
table = "field_count"
cmy.select_db('myconnpy')
cmy.query("DROP TABLE IF EXISTS {0}".format(table))
cmy.query("CREATE TABLE {0} (c1 INT, c2 INT, c3 INT)".format(table))
cmy.query("SELECT * FROM {0}".format(table))
self.assertEqual(3, cmy.field_count())
cmy.free_result()
cmy.query("INSERT INTO {0} (c1, c2, c3) VALUES "
"(1, 10, 100)".format(table))
cmy.commit()
cmy.query("SELECT * FROM {0}".format(table))
self.assertEqual(3, cmy.field_count())
cmy.free_result()
cmy.query("DROP TABLE IF EXISTS {0}".format(table))
def test_autocommit(self):
cmy1 = MySQL(buffered=True)
cmy1.connect(**self.connect_kwargs)
cmy2 = MySQL(buffered=True)
cmy2.connect(**self.connect_kwargs)
self.assertRaises(ValueError, cmy1.autocommit, 'ham')
self.assertRaises(ValueError, cmy1.autocommit, 1)
self.assertRaises(ValueError, cmy1.autocommit, None)
table = "autocommit_test"
# For the test we start off by making sure the autocommit is off
# for both sessions
cmy1.query("SELECT @@global.autocommit")
if cmy1.fetch_row()[0] != 1:
cmy1.query("SET @@session.autocommit = 0")
cmy2.query("SET @@session.autocommit = 0")
cmy1.query("DROP TABLE IF EXISTS {0}".format(table))
cmy1.query("CREATE TABLE {0} (c1 INT)".format(table))
# Turn AUTOCOMMIT on
cmy1.autocommit(True)
cmy1.query("INSERT INTO {0} (c1) VALUES "
"(1), (2), (3)".format(table))
cmy2.query("SELECT * FROM {0}".format(table))
self.assertEqual(3, cmy2.num_rows())
rows = fetch_rows(cmy2)
# Turn AUTOCOMMIT off
cmy1.autocommit(False)
cmy1.query("INSERT INTO {0} (c1) VALUES "
"(4), (5), (6)".format(table))
cmy2.query("SELECT * FROM {0} WHERE c1 > 3".format(table))
self.assertEqual([], fetch_rows(cmy2))
cmy1.commit()
cmy2.query("SELECT * FROM {0} WHERE c1 > 3".format(table))
self.assertEqual([(4, ), (5, ), (6, )], fetch_rows(cmy2))
cmy1.query("DROP TABLE IF EXISTS {0}".format(table))
cmy1.close()
cmy2.close()
def test_change_user(self):
connect_kwargs = self.connect_kwargs.copy()
connect_kwargs['unix_socket'] = None
connect_kwargs['ssl_disabled'] = False
cmy1 = MySQL(buffered=True)
cmy1.connect(**connect_kwargs)
cmy2 = MySQL(buffered=True)
cmy2.connect(**connect_kwargs)
new_user = {
'user': '******',
'host': self.config['host'],
'database': self.connect_kwargs['database'],
'password': '******',
}
try:
cmy1.query("DROP USER '{user}'@'{host}'".format(**new_user))
except MySQLInterfaceError:
# Probably not created
pass
stmt = ("CREATE USER '{user}'@'{host}' IDENTIFIED WITH "
"caching_sha2_password").format(**new_user)
cmy1.query(stmt)
if tests.MYSQL_VERSION < (8, 0, 5):
cmy1.query("SET old_passwords = 0")
res = cmy1.query("SET PASSWORD FOR '{user}'@'{host}' = "
"PASSWORD('{password}')".format(**new_user))
else:
res = cmy1.query("ALTER USER '{user}'@'{host}' IDENTIFIED BY "
"'{password}'".format(**new_user))
cmy1.query("GRANT ALL ON {database}.* "
"TO '{user}'@'{host}'".format(**new_user))
cmy2.query("SHOW GRANTS FOR {user}@{host}".format(**new_user))
cmy2.query("SELECT USER()")
orig_user = cmy2.fetch_row()[0]
cmy2.free_result()
cmy2.change_user(user=new_user['user'],
password=new_user['password'],
database=new_user['database'])
cmy2.query("SELECT USER()")
current_user = cmy2.fetch_row()[0]
self.assertNotEqual(orig_user, current_user)
self.assertTrue(u"{user}@".format(
**new_user) in current_user.decode('utf8'))
cmy2.free_result()
def test_rollback(self):
cmy1 = MySQL(buffered=True)
cmy1.connect(**self.connect_kwargs)
cmy2 = MySQL(buffered=True)
cmy2.connect(**self.connect_kwargs)
table = "commit_test"
cmy1.query("DROP TABLE IF EXISTS {0}".format(table))
cmy1.query("CREATE TABLE {0} (c1 INT)".format(table))
cmy1.query("START TRANSACTION")
cmy1.query("INSERT INTO {0} (c1) VALUES "
"(1), (2), (3)".format(table))
cmy1.commit()
cmy2.query("SELECT * FROM {0}".format(table))
self.assertEqual([(1,), (2,), (3,)], fetch_rows(cmy2))
cmy1.query("START TRANSACTION")
cmy1.query("INSERT INTO {0} (c1) VALUES "
"(4), (5), (6)".format(table))
cmy1.rollback()
cmy2.query("SELECT * FROM {0}".format(table))
self.assertEqual(3, cmy2.num_rows())
cmy1.query("DROP TABLE IF EXISTS {0}".format(table))
def test_rollback(self):
cmy1 = MySQL(buffered=True)
cmy1.connect(**self.connect_kwargs)
cmy2 = MySQL(buffered=True)
cmy2.connect(**self.connect_kwargs)
table = "commit_test"
cmy1.query("DROP TABLE IF EXISTS {0}".format(table))
cmy1.query("CREATE TABLE {0} (c1 INT)".format(table))
cmy1.query("START TRANSACTION")
cmy1.query("INSERT INTO {0} (c1) VALUES "
"(1), (2), (3)".format(table))
cmy1.commit()
cmy2.query("SELECT * FROM {0}".format(table))
self.assertEqual([(1, ), (2, ), (3, )], fetch_rows(cmy2))
cmy1.query("START TRANSACTION")
cmy1.query("INSERT INTO {0} (c1) VALUES "
"(4), (5), (6)".format(table))
cmy1.rollback()
cmy2.query("SELECT * FROM {0}".format(table))
self.assertEqual(3, cmy2.num_rows())
cmy1.query("DROP TABLE IF EXISTS {0}".format(table))
