def init_data():
page_num = 3
table_name1 = '/home/latin/code/latin/python/latin_database/version3/data/test1'
tuples_case = TestUtil.gen_tuples(table_name1, page_num)
for t in tuples_case:
operator = Insert(table_name1, t)
operator.execute()
Database.get_buffer().clear_buffer()
def clear():
catalog_file = '/home/latin/code/latin/python/latin_database/version3/data/catalog'
data_file1 = '/home/latin/code/latin/python/latin_database/version3/data/test1'
data_file2 = '/home/latin/code/latin/python/latin_database/version3/data/test2'
open(catalog_file, 'wb+').close()
open(data_file1, 'wb+').close()
open(data_file2, 'wb+').close()
os.remove(catalog_file)
os.remove(data_file1)
os.remove(data_file2)
Catalog.clear()
Database.clear()
def test_transaction(self):
tuples_case = TestUtil.get_tuples_case(self.table_name1)
for t in tuples_case:
tran_id = 0
operator = Insert(self.table_name1, t, tran_id)
operator.execute()
Database.get_buffer().clear_buffer()
hf = Catalog.name_to_file(self.table_name1)
tuples = hf.get_all_tuples()
assert(len(tuples) == 2)
for i in range(len(tuples)):
tuple1 = tuples_case[i]
tuple2 = tuples[i]
assert(tuple1.equal(tuple2))
def test_waitlist_2_tran(self):
page_id = TestUtil.gen_page_id1(0)
arg1 = [0, page_id, 'S']
arg2 = [1, page_id, 'X']
args = [arg1, arg2]
grabs = []
for arg in args:
tran_id = arg[0]
pid = arg[1]
lock_type = arg[2]
g = GrabLock(tran_id, pid, lock_type)
g.start()
grabs.append(g)
wait_time = 1
time.sleep(wait_time)
buffer_ = Database.get_buffer()
lm = buffer_.get_lock_manager()
locks = lm.get_locks(page_id)
wl = lm.waitlist
assert(1 in wl)
assert(len(locks) == 1)
assert(locks[0].match_holder(0))
assert(locks[0].get_type() == 'S')
assert (grabs[0].success == True)
for i in range(1, len(grabs)):
assert (grabs[i].success == False)
def test_different_tran_acquire_S(self):
tran_id1 = 1
tran_id2 = 2
page_id = TestUtil.gen_page_id1(0)
lock_type1 = 'S'
lock_type2 = 'S'
array = [(page_id, tran_id1, lock_type1),
(page_id, tran_id2, lock_type2)
]
buffer_ = Database.get_buffer()
with Pool() as pool:
p1, p2 = pool.starmap(buffer_.get_page, array)
lm = buffer_.get_lock_manager()
locks = lm.get_locks(page_id)
assert (len(locks) == 2)
assert(locks[0].match_holder(tran_id1))
assert(locks[1].match_holder(tran_id2))
assert(locks[0].get_type() == lock_type1)
assert(locks[1].get_type() == lock_type1)
assert(p1.dirty == p2.dirty)
assert(p1.capacity == p2.capacity)
assert(p1.get_id().equal(p2.get_id()))
assert(len(p1.tuples) == len(p2.tuples))
def run(self):
buffer_ = Database.get_buffer()
try:
buffer_.get_page(self.page_id, self.tran_id, self.lock_type)
self.success = True
except DeadlockException:
self.deadlock = True
def get_last_page(self, tran_id, lock_type):
n = self.get_page_num()
pid = n - 1
tid = self.get_id()
pid = PageId(tid, pid)
b = Database.get_buffer()
p = b.get_page(pid, tran_id, lock_type)
return p
def get_all_tuples(self):
all_tuples = []
b = Database.get_buffer()
tid = self.get_id()
n = self.get_page_num()
for pid in range(n):
pid = PageId(tid, pid)
p = b.get_page(pid)
all_tuples += p.get_tuples()
return all_tuples
def delete_tuple(self, filt_fields):
tid = self.get_id()
b = Database.get_buffer()
n = self.get_page_num()
for pid in range(n):
pid = PageId(tid, pid)
p = b.get_page(pid)
tuples = p.get_match_tuples(filt_fields)
for t in tuples:
p.delete_tuple(t)
def get_insertable_page(self, tran_id=None, lock_type=None):
tid = self.get_id()
n = self.get_page_num()
b = Database.get_buffer()
for page_index in range(n):
page_id = PageId(tid, page_index)
p = b.get_page(page_id, tran_id, lock_type)
if p.has_empty_entry():
return p
self.create_new_page()
p = self.get_last_page(tran_id, lock_type)
return p
def test_acquire_lock(self):
tran_id = 3
page_id = TestUtil.gen_page_id1(0)
lock_type = 'S'
buffer_ = Database.get_buffer()
lm = buffer_.get_lock_manager()
lm.acquire_lock(tran_id, page_id, lock_type)
locks = lm.get_locks(page_id)
lock = locks[0]
assert(len(locks) == 1)
assert(locks[0].match_holder(tran_id))
assert(lock.get_type() == lock_type)
def test_same_tran_acquire_S(self):
tran_id1 = 3
page_id = TestUtil.gen_page_id1(0)
lock_type1 = 'S'
buffer_ = Database.get_buffer()
p1 = buffer_.get_page(page_id, tran_id1, lock_type1)
p2 = buffer_.get_page(page_id, tran_id1, lock_type1)
lm = buffer_.get_lock_manager()
locks = lm.get_locks(page_id)
lock = locks[0]
assert(len(locks) == 1)
assert(locks[0].match_holder(tran_id1))
assert(lock.get_type() == lock_type1)
assert(p1.dirty == p2.dirty)
assert(p1.capacity == p2.capacity)
assert(p1.get_id().equal(p2.get_id()))
assert(len(p1.tuples) == len(p2.tuples))
def flush_page_num(self):
n = self.__page_num
tid = self.get_id()
b = Database.get_buffer()
b.flush_page_num(tid, n)
def tearDown(self):
os.remove(self.catalog_file)
os.remove(self.table_name1)
os.remove(self.table_name2)
Catalog.clear()
Database.clear()