def test_update_and_read(self):
where_column_value_pairs = [('id', 2)]
with database_context.WriteTransaction(self.dc) as context:
db_class_unsharded.VtUnsharded.update_columns(
context.get_cursor(),
where_column_value_pairs,
msg="test update")
with database_context.ReadFromMaster(self.dc) as context:
rows = db_class_unsharded.VtUnsharded.select_by_id(
context.get_cursor(), 2)
self.assertEqual(len(rows), 1, "wrong number of rows fetched")
self.assertEqual(rows[0].msg, "test update", "wrong row fetched")
def setUp(self):
self.vtgate_addrs = {
"vt": [
utils.vtgate.addr(),
]
}
self.dc = database_context.DatabaseContext(self.vtgate_addrs)
self.all_ids = []
with database_context.WriteTransaction(self.dc) as context:
for x in xrange(20):
ret_id = db_class_unsharded.VtUnsharded.insert(
context.get_cursor(), msg="test message")
self.all_ids.append(ret_id)
def update_columns(self):
with database_context.WriteTransaction(self.dc) as context:
user_id = self.user_id_list[1]
where_column_value_pairs = [
('id', user_id),
]
entity_id_map = {'id': user_id}
new_username = '******' % user_id
update_cols = [
('username', new_username),
]
db_class_sharded.VtUser.update_columns(
context.get_cursor(entity_id_map=entity_id_map),
where_column_value_pairs,
update_column_value_pairs=update_cols)
# verify the updated value.
where_column_value_pairs = [
('id', user_id),
]
rows = db_class_sharded.VtUser.select_by_columns(
context.get_cursor(entity_id_map={'id': user_id}),
where_column_value_pairs)
self.assertEqual(len(rows), 1, "wrong number of rows fetched")
self.assertEqual(new_username, rows[0].username)
where_column_value_pairs = [
('user_id', user_id),
]
entity_id_map = {'user_id': user_id}
new_email = '*****@*****.**' % user_id
m = hashlib.md5()
m.update(new_email)
email_hash = m.digest()
update_cols = [('email', new_email), ('email_hash', email_hash)]
db_class_sharded.VtUserEmail.update_columns(
context.get_cursor(entity_id_map={'user_id': user_id}),
where_column_value_pairs,
update_column_value_pairs=update_cols)
# verify the updated value.
with database_context.ReadFromMaster(self.dc) as context:
where_column_value_pairs = [
('user_id', user_id),
]
entity_id_map = dict(where_column_value_pairs)
rows = db_class_sharded.VtUserEmail.select_by_ids(
context.get_cursor(entity_id_map=entity_id_map),
where_column_value_pairs)
self.assertEqual(len(rows), 1, "wrong number of rows fetched")
self.assertEqual(new_email, rows[0].email)
self.user_id_list.sort()
def tearDown(self):
with database_context.WriteTransaction(self.dc) as context:
for uid in self.user_id_list:
try:
db_class_sharded.VtUser.delete_by_columns(
context.get_cursor(entity_id_map={'id': uid}), [
('id', uid),
])
db_class_sharded.VtUserEmail.delete_by_columns(
context.get_cursor(entity_id_map={'user_id': uid}), [
('user_id', uid),
])
except dbexceptions.DatabaseError as e:
if str(e) == "DB Row not found":
pass
def test_update_and_read(self):
id_val = self.all_ids[0]
where_column_value_pairs = [('id', id_val)]
with database_context.WriteTransaction(self.dc) as context:
update_cols = [
('msg', 'test update'),
]
db_class_unsharded.VtUnsharded.update_columns(
context.get_cursor(),
where_column_value_pairs,
update_column_value_pairs=update_cols)
with database_context.ReadFromMaster(self.dc) as context:
rows = db_class_unsharded.VtUnsharded.select_by_id(
context.get_cursor(), id_val)
self.assertEqual(len(rows), 1, 'wrong number of rows fetched')
self.assertEqual(rows[0].msg, 'test update', 'wrong row fetched')
def populate_tables(self):
self.user_id_list = []
self.song_id_list = []
self.user_song_map = {}
r = random.Random()
# This should create the lookup entries and sharding key.
with database_context.WriteTransaction(self.dc) as context:
for x in xrange(20):
# vt_user - EntityRangeSharded; creates username:user_id lookup
user_id = db_class_sharded.VtUser.insert(context.get_cursor(),
username="******" % x,
msg="test message")
self.user_id_list.append(user_id)
# vt_user_email - RangeSharded; references user_id:keyspace_id hash
email = '*****@*****.**' % x
m = hashlib.md5()
m.update(email)
email_hash = m.digest()
entity_id_map = {'user_id': user_id}
db_class_sharded.VtUserEmail.insert(
context.get_cursor(entity_id_map=entity_id_map),
user_id=user_id,
email=email,
email_hash=email_hash)
# vt_song - EntityRangeSharded; creates song_id:user_id lookup
num_songs_for_user = r.randint(1, 5)
for i in xrange(num_songs_for_user):
song_id = db_class_sharded.VtSong.insert(
context.get_cursor(),
user_id=user_id,
title="Test Song")
self.song_id_list.append(song_id)
self.user_song_map.setdefault(user_id, []).append(song_id)
# vt_song_detail - RangeSharded; references song_id:user_id lookup
entity_id_map = {'song_id': song_id}
db_class_sharded.VtSongDetail.insert(
context.get_cursor(entity_id_map=entity_id_map),
song_id=song_id,
album_name="Test album",
artist="Test artist")
def delete_columns(self):
user_id = self.user_id_list[-1]
with database_context.WriteTransaction(self.dc) as context:
where_column_value_pairs = [('id', user_id),]
entity_id_map = {'id': user_id}
db_class_sharded.VtUser.delete_by_columns(context.get_cursor(entity_id_map=entity_id_map),
where_column_value_pairs)
where_column_value_pairs = [('user_id', user_id),]
entity_id_map = {'user_id': user_id}
db_class_sharded.VtUserEmail.delete_by_columns(context.get_cursor(entity_id_map=entity_id_map),
where_column_value_pairs)
with database_context.ReadFromMaster(self.dc) as context:
rows = db_class_sharded.VtUser.select_by_columns(
context.get_cursor(entity_id_map=entity_id_map),
where_column_value_pairs)
self.assertEqual(len(rows), 0, "wrong number of rows fetched")
rows = db_class_sharded.VtUserEmail.select_by_ids(
context.get_cursor(entity_id_map=entity_id_map),
where_column_value_pairs)
self.assertEqual(len(rows), 0, "wrong number of rows fetched")
self.user_id_list = self.user_id_list[:-1]
def populate_tables(self):
# vt_user
user_id_list = []
# This should create the lookup entries and sharding key.
with database_context.WriteTransaction(self.dc) as context:
for x in xrange(20):
# vt_user - EntityRangeSharded
user_id = db_class_sharded.VtUser.insert(context.get_cursor(),
username="******" % x, msg=str(x))
user_id_list.append(user_id)
# vt_user_email - RangeSharded
email = '*****@*****.**' % x
m = hashlib.md5()
m.update(email)
email_hash = m.digest()
entity_id_map={'user_id':user_id}
db_class_sharded.VtUserEmail.insert(
context.get_cursor(entity_id_map=entity_id_map),
user_id=user_id, email=email,
email_hash=email_hash)
# vt_song
# vt_song_detail
return user_id_list
def test_batch_write(self):
# TODO(sougou): fix
return
# 1. Create DMLs using DB Classes.
query_list = []
bv_list = []
# Update VtUser table.
user_id = self.user_id_list[1]
where_column_value_pairs = (('id', user_id), )
entity_id_map = dict(where_column_value_pairs)
new_username = '******' % user_id
update_cols = [
('username', new_username),
]
q, bv = db_class_sharded.VtUser.create_update_query(
where_column_value_pairs, update_column_value_pairs=update_cols)
query_list.append(q)
bv_list.append(bv)
# Update VtUserEmail table.
where_column_value_pairs = [
('user_id', user_id),
]
new_email = '*****@*****.**' % user_id
m = hashlib.md5()
m.update(new_email)
email_hash = m.digest()
update_cols = [('email', new_email), ('email_hash', email_hash)]
q, bv = db_class_sharded.VtUserEmail.create_update_query(
where_column_value_pairs, update_column_value_pairs=update_cols)
query_list.append(q)
bv_list.append(bv)
# Delete a VtSong row
where_column_value_pairs = [
('user_id', user_id),
]
q, bv = db_class_sharded.VtSong.create_delete_query(
where_column_value_pairs)
query_list.append(q)
bv_list.append(bv)
with database_context.WriteTransaction(self.dc) as context:
# 2. Routing for query_list is done by associating
# the common entity_id to the cursor.
# NOTE: cursor creation needs binding to a particular db class,
# so we create a writable cursor using the common entity (user_id).
# This entity_id is used to derive the keyspace_id for routing the dmls.
entity_id_map = {'id': user_id}
cursor = context.get_cursor(entity_id_map=entity_id_map)(
db_class_sharded.VtUser)
# 3. Execute the writable batch query.
results = db_object.execute_batch_write(cursor, query_list,
bv_list)
# 4. Verify results
self.assertEqual(len(results), len(query_list))
self.assertEqual(results[0]['rowcount'], 1,
"VtUser update didn't update 1 row")
self.assertEqual(results[1]['rowcount'], 1,
"VtUserEmail update didn't update 1 row")
self.assertEqual(
results[2]['rowcount'], len(self.user_song_map[user_id]),
"VtSong deleted '%d' rows, expected '%d'" %
(results[2]['rowcount'], len(self.user_song_map[user_id])))
