def insertTuple(self, tupleData):
if self.header and tupleData and self.header.validTuple(tupleData):
(tupleIndex, start, end) = self.header.nextTupleRange()
if start and end:
self.setDirty(True)
self.getbuffer()[start:end] = tupleData
return TupleId(self.pageId, tupleIndex)
def __next__(self):
t = self.getTuple(TupleId(self.pageId, self.iterTupleIdx))
if t:
self.iterTupleIdx += 1
return t
else:
raise StopIteration
def __next__(self):
if self.iterTupleIdx < len(self.header.slotUsed):
t = self.getTuple(TupleId(self.pageId, self.header.slotUsed[self.iterTupleIdx]));
self.iterTupleIdx += 1;
return t;
else:
raise StopIteration
def __next__(self):
t = self.getTuple(TupleId(self.pageId, self.iterTupleIdx))
if t and self.count < len(self.tuples):
self.iterTupleIdx += self.header.tupleSize
self.count += 1
return t
else:
raise StopIteration
def insertTuple(self, tupleData):
if self.header.hasFreeTuple():
# identify the tupleindex and insert range
(tupleIndex, start, end) = self.header.nextTupleRange()
self.getbuffer()[start:end] = tupleData
return TupleId(self.pageId, tupleIndex)
self.setDirty(True)
raise ValueError("The page is full!")
def insertTuple(self, tupleData):
tupleRange = self.header.nextTupleRange()
if tupleRange:
buffer = self.getbuffer()
buffer[tupleRange[1]:tupleRange[2]] = tupleData
self.setDirty(True)
return TupleId(self.pageId, tupleRange[0])
def insertTuple(self, tupleData):
self.index = self.header.nextFreeTuple()
if self.index:
self.getbuffer()[self.index * self.header.tupleSize +
self.header.headerSize():(self.index + 1) *
self.header.tupleSize +
self.header.headerSize()] = tupleData
return TupleId(self.pageId, self.index)
self.header.setDirty(True)
def insertTuple(self, tupleData):
if self.header.hasFreeTuple():
slotIndex = self.header.nextFreeTuple()
tupleIndex = self.header.offsetOfSlot(slotIndex)
self.getbuffer()[tupleIndex: (tupleIndex+self.header.tupleSize)] = tupleData
self.header.setDirty(True)
return TupleId(self.pageId, slotIndex)
else:
raise ValueError("Page is full!")
def __next__(self):
if self.iterTupleIdx < self.header.usedSlots_num:
t = self.getTuple(TupleId(self.pageId, self.header.usedSlots[self.iterTupleIdx]));
self.iterTupleIdx += 1
return t
else:
raise StopIteration
def deleteTuple(self, tupleId):
if self.header and tupleId:
(start, end) = self.header.tupleRange(tupleId)
if start and end:
self.setDirty(True)
shiftLen = self.header.freeSpaceOffset - end
self.getbuffer()[start:start+shiftLen] = self.getbuffer()[end:end+shiftLen]
resetTupleIndex = self.header.tupleIndex(self.header.freeSpaceOffset - self.header.tupleSize)
self.header.resetTuple(TupleId(self.pageId, resetTupleIndex))
def insertTuple(self, tupleData):
if self.header.hasFreeTuple():
# identify the tupleindex and insert range
(tupleIndex, start, end) = self.header.nextTupleRange()
self.getbuffer()[start:end] = tupleData
return TupleId(self.pageId, tupleIndex)
self.setDirty(True)
else:
raise ValueError("No enough memory for insertion!")
def insertTuple(self, tupleData):
if self.header.hasFreeTuple():
tupleIndex = self.header.nextFreeTuple()
self.getbuffer()[tupleIndex:(tupleIndex +
self.header.tupleSize)] = tupleData
self.setDirty(True)
return TupleId(self.pageId,
self.header.numTuples() - 1)
else:
raise ValueError("This page is full!")
def insertTuple(self, tupleData):
self.index = self.header.nextFreeTuple()
if self.index:
self.getbuffer()[self.index:self.index +
self.header.tupleSize] = tupleData
self.header.setDirty(True)
return TupleId(
self.pageId,
int((self.index - self.header.headerSize()) /
self.header.tupleSize))
def __next__(self):
if self.it < len(self.filledSlots):
self.iterSlot = self.filledSlots[self.it]
t = self.getTuple(TupleId(self.pageId, self.iterSlot))
self.it += 1
return t
else:
raise StopIteration
def insertTuple(self, tupleData):
if self.header.hasFreeTuple():
(tupleIndex, start, end) = self.header.nextTupleRange()
self.buffer[start:end] = tupleData
tId = TupleId(self.pageId, tupleIndex)
self.tuples.append(tId)
return tId
else:
return None
def insertTuple(self, tupleData):
if self.header.hasFreeTuple():
(slot, tupleStart, tupleEnd) = self.header.nextTupleRange(
) # Slot will be 'None' When there is no more space
self.buffer[tupleStart:tupleEnd] = tupleData
self.header.setSlot(slot, 1)
tId = TupleId(self.pageId, slot)
return tId
else:
return None
def __next__(self):
while self.iterTupleIdx < self.header.numSlots and not self.header.getSlot(
self.iterTupleIdx):
self.iterTupleIdx += 1
if self.iterTupleIdx < self.header.numSlots and self.header.getSlot(
self.iterTupleIdx):
self.iterTupleIdx += 1
return self.getTuple(TupleId(self.pageId, self.iterTupleIdx - 1))
else:
raise StopIteration
def __next__(self):
t = self.getTuple(TupleId(self.pageId, self.iterTupleIdx))
if t:
nextIdx = self.header.slotBuffer.find('0b1', self.iterTupleIdx + 1)
if nextIdx == ():
self.iterTupleIdx = -1
else:
self.iterTupleIdx = nextIdx[0]
return t
else:
raise StopIteration
def lookupByIndex(self, indexId, keyData):
result = []
indexDb = self.getIndex(indexId)
if indexDb is not None:
crsr = indexDb.cursor()
data = crsr.set(keyData)
while data and data[0] == keyData:
result.append(TupleId.unpack(data[1]))
data = crsr.next()
crsr.close()
return iter(result)
def lookupByIndex(self, indexId, keyData):
result = []
indexDb = self.getIndex(indexId)
if indexDb is not None:
crsr = indexDb.cursor()
data = crsr.set(keyData)
while data and data[0] == keyData:
result.append(TupleId.unpack(data[1]))
data = crsr.next()
crsr.close()
return iter(result)
def insertTuple(self, tupleData):
if not self.header.hasFreeTuple():
return None
tupleOffset = self.header.nextFreeTuple()
tupleIndex = (tupleOffset - self.header.size) // self.header.tupleSize
tupleID = TupleId(self.pageId, tupleIndex)
view = self.getbuffer()
view[tupleOffset:tupleOffset + self.header.tupleSize] = tupleData
self.setDirty(0b1)
return tupleID
def __next__(self):
(start, end) = (None, None)
while (start is None or end is None
) and self.iterTupleIdx < self.page.header.maxTuples():
tId = TupleId(self.page.pageId, self.iterTupleIdx)
(start, end) = self.page.header.tupleRange(tId)
self.iterTupleIdx += 1
if start and end:
t = self.page.getTuple(tId)
if t:
return t
raise StopIteration
def deleteTuple(self, tupleId):
# If I check the validation of tupleId, one of the unittest fails, why?
buffer = self.getbuffer()
offset = self.header.headerSize(
) + tupleId.tupleIndex * self.header.tupleSize
subsequentLength = self.header.freeSpaceOffset - (
offset + self.header.tupleSize)
buffer[offset:offset +
subsequentLength] = buffer[offset + self.header.tupleSize:self.
header.freeSpaceOffset]
self.clearTuple(TupleId(self.pageId, self.header.numTuples() - 1))
self.setDirty(True)
self.header.freeSpaceOffset -= self.header.tupleSize
def insertTuple(self, tupleData):
if self.header.hasFreeTuple():
slotIndex = self.header.nextFreeTuple();
start = self.header.offsetOfSlot(slotIndex);
tupleSt = 0;
for i in range(0, len(self.header.schemaSizes)):
self.getbuffer()[start[i] : (start[i] + self.header.schemaSizes[i])] = \
tupleData[ tupleSt : (tupleSt + self.header.schemaSizes[i]) ];
tupleSt += self.header.schemaSizes[i];
self.header.setDirty( True );
return TupleId(self.pageId, slotIndex);
else:
raise ValueError("This page is full!");
def deleteTuple(self, tupleId):
tupleOff = (tupleId.tupleIndex *
self.header.tupleSize) + self.header.size
view = self.getbuffer()
tuplesToShift = self.header.numTuples() - tupleId.tupleIndex - 1
for i in range(tupleOff,
tupleOff + (tuplesToShift * self.header.tupleSize)):
view[i:i + 1] = view[i + self.header.tupleSize:i +
self.header.tupleSize + 1]
toClearID = TupleId(self.pageId, self.header.numTuples() - 1)
self.clearTuple(toClearID)
self.header.freeSpaceOffset -= self.header.tupleSize
self.setDirty(0b1)
def insertTuple(self, tupleData):
bitTuple = self.header.bitmap.find('0b0')
if bitTuple == ():
return None
tupleID = TupleId(self.pageId, bitTuple[0])
view = self.getbuffer()
offset = (bitTuple[0] * self.header.tupleSize) + self.header.size
if self.header.pageCapacity - offset < 8:
return None
view[offset:offset + self.header.tupleSize] = tupleData
self.header.bitmap[bitTuple[0]] = '0b1'
self.header.setDirty(0b1)
return tupleID
def insertTuple(self, tupleData):
# page = self.availablePage()
# page.insertTuple(tupleData)
# # need to make sure heap readjusts, and has a custom compare
# # have tuple inserted into heap with first element being
# # what should be compared, in this case #num tuple free space
# still need to write to disk the changed page or maybe not?
pId = self.availablePage()
page = self.bufferPool.getPage(pId)
tId = TupleId(pId, page.header.numTuples())
page.insertTuple(tupleData)
if page.header.hasFreeTuple() == False:
del self.freePages[0]
# raise NotImplementedError
self.bufferPool.updateBuffer(pId, page.pack())
return tId
def lookupByKey(self, relId, keyData):
indexDb = self.getPrimaryIndex(relId)
if indexDb:
return TupleId.unpack(indexDb.get(keyData))
def tupleId(self, tupleIndex): return TupleId(self.pageId, tupleIndex);
def lookupByKey(self, relId, keyData):
indexDb = self.getPrimaryIndex(relId)
if indexDb:
return TupleId.unpack(indexDb.get(keyData))
