public List <long> GetSome(Int64 SectionStartPosition, int takecount)
{
JumpRecord start = getStartPointerRecord(SectionStartPosition);
while (start.Buttom > 0)
{
start = getJumpRecord(start.Buttom);
}
if (start.Next <= 0)
{
return(null);
}
List <long> recordlist = new List <long>();
int counter = 0;
while (start.Next > 0)
{
start = getJumpRecord(start.Next);
recordlist.Add(start.BlockPosition);
counter += 1;
if (counter >= takecount)
{
return(recordlist);
}
}
return(recordlist);
}
/// <summary>
/// delete the record and all the chains.
/// </summary>
/// <param name="record"></param>
/// <returns></returns>
private void deleteRecord(JumpRecord record)
{
updateNavigator(record.Previous, record.Next, enumPosition.next);
updateNavigator(record.Next, record.Previous, enumPosition.previous);
markAsDeleted(record.diskLocation);
JumpRecord toprecord = record;
JumpRecord buttomreocrd = record;
while (toprecord.TOP > 0)
{
toprecord = getJumpRecord(toprecord.TOP);
updateNavigator(toprecord.Previous, toprecord.Next, enumPosition.next);
updateNavigator(toprecord.Next, toprecord.Previous, enumPosition.previous);
markAsDeleted(toprecord.diskLocation);
}
while (buttomreocrd.Buttom > 0)
{
buttomreocrd = getJumpRecord(buttomreocrd.Buttom);
updateNavigator(buttomreocrd.Previous, buttomreocrd.Next, enumPosition.next);
updateNavigator(buttomreocrd.Next, buttomreocrd.Previous, enumPosition.previous);
markAsDeleted(buttomreocrd.diskLocation);
}
}
/// <summary>
/// promote items up.
/// </summary>
/// <param name="sectionStartPosition"></param>
/// <param name="loadchains"></param>
/// <param name="blockposition"></param>
private void promoteItems(Int64 sectionStartPosition, Dictionary <int, JumpRecord> loadchains, Int64 blockposition)
{
/// we now use a temp counter on each level, and reset that temp counter when item promoted.
foreach (var item in loadchains.OrderByDescending(o => o.Key))
{
int level = item.Key;
JumpRecord newrecord = insertNewRecord(blockposition);
JumpRecord ItemCurrentLevel = item.Value;
updateNavigator(ItemCurrentLevel.diskLocation, newrecord.diskLocation, enumPosition.next);
updateNavigator(ItemCurrentLevel.Next, newrecord.diskLocation, enumPosition.previous);
updateNavigator(newrecord.diskLocation, ItemCurrentLevel.diskLocation, enumPosition.previous);
updateNavigator(newrecord.diskLocation, ItemCurrentLevel.Next, enumPosition.next);
int counter = getLevelCounter(sectionStartPosition, level);
counter = counter + 1;
if (counter < this.counterBeforePromotion)
{
setLevelCounter(sectionStartPosition, (byte)counter, level);
//STOP, not promot up again.
return;
}
else
{
// reSet counter and continue loop up.
setLevelCounter(sectionStartPosition, (byte)0, level);
}
}
}
public List <Int64> GetAll(Int64 SectionStartPosition)
{
JumpRecord start = getStartPointerRecord(SectionStartPosition);
while (start.Buttom > 0)
{
start = getJumpRecord(start.Buttom);
}
if (start.Next <= 0)
{
return(null);
}
List <Int64> recordlist = new List <Int64>();
while (start.Next > 0)
{
start = getJumpRecord(start.Next);
recordlist.Add(start.BlockPosition);
}
return(recordlist);
}
public bool HasKey(Int64 sectionStartPosition, Int64 blockposition)
{
if (getIndicator(sectionStartPosition) != enumSectionType.StartSection)
{
throw new Exception("wrong start section");
}
JumpRecord startSearchRecord = getStartPointerRecord(sectionStartPosition);
JumpRecord currentRecord = startSearchRecord;
JumpRecord previousrecord = currentRecord;
while (true)
{
if (blockposition == currentRecord.BlockPosition)
{
return(true);
}
else if (blockposition > currentRecord.BlockPosition)
{
if (currentRecord.Next > 0)
{
previousrecord = currentRecord;
currentRecord = getJumpRecord(currentRecord.Next);
continue;
}
else if (currentRecord.Buttom > 0)
{
previousrecord = currentRecord;
currentRecord = getJumpRecord(currentRecord.Buttom);
continue;
}
else
{
//reach end, not found.
return(false);
}
}
else
{
if (previousrecord.Buttom > 0)
{
currentRecord = getJumpRecord(previousrecord.Buttom);
continue;
}
else
{
//reach end, not found.
return(false);
}
}
}
}
public bool Del(Int64 SectionStartPosition, Int64 blockPosition)
{
JumpRecord startSearchRecord = getStartPointerRecord(SectionStartPosition);
JumpRecord currentRecord = startSearchRecord;
JumpRecord previousrecord = currentRecord;
while (true)
{
if (blockPosition == currentRecord.BlockPosition)
{
deleteRecord(currentRecord);
return(true);
}
else if (blockPosition > currentRecord.BlockPosition)
{
if (currentRecord.Next > 0)
{
previousrecord = currentRecord;
currentRecord = getJumpRecord(currentRecord.Next);
continue;
}
else if (currentRecord.Buttom > 0)
{
previousrecord = currentRecord;
currentRecord = getJumpRecord(currentRecord.Buttom);
continue;
}
else
{
//reach end, not found.
return(false);
}
}
else
{
if (previousrecord.Buttom > 0)
{
currentRecord = getJumpRecord(previousrecord.Buttom);
continue;
}
else
{
//reach end, not found.
return(false);
}
}
}
}
public bool MoveNext()
{
if (this.current.Next > 0)
{
current = this.duplicate.getJumpRecord(current.Next);
return(true);
}
else
{
return(false);
}
}
public BtreeIndexDuplicateCollection getCollection(Int64 SectionStartPosition)
{
JumpRecord start = getStartPointerRecord(SectionStartPosition);
while (start.Buttom > 0)
{
start = getJumpRecord(start.Buttom);
}
BtreeIndexDuplicateCollection collection = new BtreeIndexDuplicateCollection(this, start);
return(collection);
}
public BtreeIndexDuplicateReader getReader(Int64 SectionStartPosition)
{
JumpRecord start = getStartPointerRecord(SectionStartPosition);
while (start != null && start.Buttom > 0)
{
start = getJumpRecord(start.Buttom);
}
BtreeIndexDuplicateReader reader = new BtreeIndexDuplicateReader(this, start);
return(reader);
}
public Int64 ReadNext()
{
if (this.current.Next > 0)
{
current = this.duplicate.getJumpRecord(current.Next);
if (current != null)
{
return(current.BlockPosition);
}
}
return(-1);
}
public byte[] ReadNextPointerBytes()
{
if (this.current.Next > 0)
{
current = this.duplicate.getJumpRecord(current.Next);
if (current != null)
{
return(current.pointerBytes);
}
}
return(null);
}
private JumpRecord insertNewRecord(Int64 blockposition)
{
JumpRecord record = new JumpRecord();
record.BlockPosition = blockposition;
record.Indicator = enumSectionType.Record;
Int64 insertposition = getInsertPosition();
IndexStream.Position = insertposition;
IndexStream.Write(record.ToBytes(), 0, sectionlen);
record.diskLocation = insertposition;
return(record);
}
public List <Int64> Get(Int64 SectionStartPosition, int skip, int take)
{
JumpRecord start = getStartPointerRecord(SectionStartPosition);
while (start.Buttom > 0)
{
start = getJumpRecord(start.Buttom);
}
if (start.Next <= 0)
{
return(null);
}
int skipcount = 0;
int takecount = 0;
List <Int64> recordlist = new List <Int64>();
while (start.Next > 0)
{
start = getJumpRecord(start.Next);
if (skipcount < skip)
{
skipcount += 1;
continue;
}
recordlist.Add(start.BlockPosition);
takecount += 1;
if (takecount >= take)
{
break;
}
}
return(recordlist);
}
public Int64 GetOne(Int64 SectionStartPosition)
{
JumpRecord start = getStartPointerRecord(SectionStartPosition);
while (start.Buttom > 0)
{
start = getJumpRecord(start.Buttom);
}
if (start.Next <= 0)
{
return(0);
}
else
{
start = getJumpRecord(start.Next);
return(start.BlockPosition);
}
}
public int count(Int64 SectionStartPosition)
{
JumpRecord start = getStartPointerRecord(SectionStartPosition);
while (start.Buttom > 0)
{
start = getJumpRecord(start.Buttom);
}
int counter = 0;
while (start.Next > 0)
{
start = getJumpRecord(start.Next);
counter += 1;
}
return(counter);
}
private JumpRecord getJumpRecord(Int64 sectionposition)
{
byte[] recordbyte = new byte[46];
IndexStream.Position = sectionposition;
IndexStream.Read(recordbyte, 0, 46);
JumpRecord record = new JumpRecord();
record.pointerBytes = recordbyte;
record.diskLocation = sectionposition;
if (record.Indicator == enumSectionType.DeletedAvailable)
{
return(null);
}
return(record);
}
/// <summary>
/// used to determine that there are more than one record so that it can NOT be removed yet.
/// </summary>
/// <param name="SectionStartPosition"></param>
/// <returns></returns>
public bool hasMoreThanOne(Int64 SectionStartPosition)
{
JumpRecord start = getStartPointerRecord(SectionStartPosition);
while (start.Buttom > 0)
{
start = getJumpRecord(start.Buttom);
}
int counter = 0;
while (start.Next > 0)
{
start = getJumpRecord(start.Next);
counter += 1;
if (counter > 1)
{
return(true);
}
}
return(false);
}
public void Dispose()
{
this.duplicate = null;
this.start = null;
this.current = null;
}
public BtreeIndexDuplicateCollection(BtreeIndexDuplicate duplicate, JumpRecord start)
{
this.duplicate = duplicate;
this.start = start;
}
public Enumerator(BtreeIndexDuplicate duplicate, JumpRecord start)
{
this.duplicate = duplicate;
this.start = start;
this.current = start;
}
public void Reset()
{
this.current = this.start;
}
public bool Add(Int64 sectionStartPosition, Int64 blockposition)
{
//if (getIndicator(sectionStartPosition) != enumSectionType.StartSection)
//{
// throw new Exception("wrong start section");
//}
JumpRecord startSearchRecord = getStartPointerRecord(sectionStartPosition);
Dictionary <int, JumpRecord> loadChain = new Dictionary <int, JumpRecord>();
JumpRecord currentRecord = startSearchRecord;
JumpRecord previousrecord = currentRecord;
while (true)
{
if (currentRecord == null)
{
return(false);
}
if (blockposition == currentRecord.BlockPosition)
{
// record already exists.
return(false);
}
else if (blockposition > currentRecord.BlockPosition)
{
if (currentRecord.Next > 0)
{
previousrecord = currentRecord;
currentRecord = getJumpRecord(currentRecord.Next);
continue;
}
else if (currentRecord.Buttom > 0)
{
int currentlevel = currentRecord.level;
loadChain.Add(currentlevel, currentRecord);
previousrecord = currentRecord;
currentRecord = getJumpRecord(currentRecord.Buttom);
currentRecord.level = (byte)(currentlevel + 1);
continue;
}
else
{
// found
previousrecord = currentRecord;
break;
}
}
else
{
if (previousrecord.Buttom > 0)
{
int currentlevel = previousrecord.level;
loadChain.Add(currentlevel, previousrecord);
currentRecord = getJumpRecord(previousrecord.Buttom);
if (currentRecord == null)
{
continue;
}
currentRecord.level = (byte)(currentlevel + 1);
//this currentRecord has the same block position as previous record,
//so blockposition must > currentRecord.blockPosition;
continue;
}
else
{
//found
break;
}
}
}
// now we should insert the block position after this previous record.
JumpRecord newrecord = insertNewRecord(blockposition);
updateNavigator(previousrecord.diskLocation, newrecord.diskLocation, enumPosition.next);
updateNavigator(newrecord.diskLocation, previousrecord.diskLocation, enumPosition.previous);
if (previousrecord.Next > 0)
{
updateNavigator(newrecord.diskLocation, previousrecord.Next, enumPosition.next);
updateNavigator(previousrecord.Next, newrecord.diskLocation, enumPosition.previous);
}
// now determine whether to promote the record or not.
int counter = getLevelCounter(sectionStartPosition, previousrecord.level);
if (counter < this.counterBeforePromotion)
{
counter = counter + 1;
setLevelCounter(sectionStartPosition, (byte)counter, previousrecord.level);
}
else
{
// we need to promote this item.
promoteItems(sectionStartPosition, loadChain, blockposition);
reloadStartRecordPointer(sectionStartPosition);
}
this.updateTotalCounter(sectionStartPosition, 1);
return(true);
}
public bool Del(Int64 SectionStartPosition, Int64 blockPosition)
{
JumpRecord startSearchRecord = getStartPointerRecord(SectionStartPosition);
if (startSearchRecord == null)
{
return(false);
}
JumpRecord currentRecord = startSearchRecord;
JumpRecord previousrecord = currentRecord;
while (currentRecord != null)
{
if (blockPosition == currentRecord.BlockPosition)
{
// record found, delete it.
deleteRecord(currentRecord);
this.updateTotalCounter(SectionStartPosition, -1);
return(true);
}
else if (blockPosition > currentRecord.BlockPosition)
{
if (currentRecord.Next > 0)
{
previousrecord = currentRecord;
currentRecord = getJumpRecord(currentRecord.Next);
continue;
}
else if (currentRecord.Buttom > 0)
{
previousrecord = currentRecord;
currentRecord = getJumpRecord(currentRecord.Buttom);
continue;
}
else
{
//reach end, not found.
return(false);
}
}
else
{
if (previousrecord.Buttom > 0)
{
currentRecord = getJumpRecord(previousrecord.Buttom);
continue;
}
else
{
//reach end, not found.
return(false);
}
}
}
return(false);
}
private Int64 createNewStartSection()
{
/// in the format of
/// [8] start search pointer. Pointer to the highest jump table.
/// [2] * = number of counter of each level. start pointer =
// header section + number levels.
int totallen = sectionlen + this.maxJumpTableLevel * sectionlen;
byte[] totalbytes = new byte[totallen];
byte[] header = new byte[sectionlen];
header[0] = startbyteone;
header[1] = startbytetwo;
header[44] = startbyteone;
header[45] = startbytetwo;
header[2] = (byte)enumSectionType.StartSection;
List <JumpRecord> tablelist = new List <JumpRecord>();
for (int i = 0; i < this.maxJumpTableLevel; i++)
{
JumpRecord newrecord = new JumpRecord();
newrecord.BlockPosition = Int64.MinValue;
newrecord.Indicator = enumSectionType.Record;
newrecord.level = (byte)i;
tablelist.Add(newrecord);
}
for (int i = 0; i < tablelist.Count; i++)
{
if (i == 0)
{
updateNavigator(tablelist[i].diskLocation, tablelist[i + 1].diskLocation, enumPosition.next);
}
else if (i == tablelist.Count - 1)
{
updateNavigator(tablelist[i].diskLocation, tablelist[i - 1].diskLocation, enumPosition.previous);
}
else
{
// in the middle.
updateNavigator(tablelist[i].diskLocation, tablelist[i - 1].diskLocation, enumPosition.previous);
updateNavigator(tablelist[i].diskLocation, tablelist[i + 1].diskLocation, enumPosition.next);
}
}
Int64 writeposition = getInsertPosition();
//write position for each start of level table.
for (int i = 0; i < tablelist.Count; i++)
{
tablelist[i].diskLocation = writeposition + 46 + i * 46;
}
Int64 lastitemindex = tablelist[tablelist.Count - 1].diskLocation;
System.Buffer.BlockCopy(BitConverter.GetBytes(lastitemindex), 0, header, 3, 8);
lock (_object)
{
IndexStream.Position = writeposition;
IndexStream.Write(header, 0, sectionlen);
foreach (var item in tablelist)
{
IndexStream.Position = item.diskLocation;
IndexStream.Write(item.ToBytes(), 0, sectionlen);
}
}
return(writeposition);
}
/// <summary>
///
/// </summary>
/// <param name="duplicate"></param>
/// <param name="start"> the start jumprecord in the most bottom</param>
public BtreeIndexDuplicateReader(BtreeIndexDuplicate duplicate, JumpRecord start)
{
this.duplicate = duplicate;
this.start = start;
this.current = start;
}
