public void ConfigNode(object commondata)
{
common_data = commondata;
object conf = ((object[])common_data)[0];
foreach (object[] tab in (object[])conf)
{
PType tp_tab_element = PType.FromPObject(tab[2]);
object[] key_grades = (object[])tab[3];
for (int i = 0; i < key_grades.Length; i++)
{
var sportion = KVSequencePortion.Create(this, tp_tab_element);
cell_list.Root.AppendElement(sportion.pobj);
int iportion = sportion_list.Count;
sportion_list.Add(sportion);
key_grades[i] = new object[] { iportion };
}
}
cell_list.Flush(); // Этот Flush нужен
fob.Flush();
object v = cell_list.Root.Get();
cell_common.Clear();
cell_common.Fill(common_data);
}
public void Load()
{
// Маленький массив будет после загрузки пустым
index_cell_small.Clear();
index_cell_small.Fill(new object[0]); index_cell_small.Flush();
index_cell.Clear();
index_cell.Fill(new object[0]);
foreach (var rec in table.Elements().Where(ent => (bool)ent.Field(0).Get() == false)) // загрузка всех элементов за исключением уничтоженных
{
long offset = rec.offset;
index_cell.Root.AppendElement(offset);
}
index_cell.Flush();
if (index_cell.Root.Count() == 0)
{
return; // потому что следующая операция не пройдет
}
// Сортировать index_cell специальным образом: значение (long) используется как offset ячейки и там прочитывается нулевое поле
var ptr = table.Element(0);
//index_cell.Root.SortByKey<Tkey>((object v) =>
index_cell.Root.SortByKey <Tkey>((object v) =>
{
ptr.offset = (long)v;
return(keyProducer(ptr));
}, comparer);
}
public void Load(IEnumerable <object[]> keyvalueflow)
{
foreach (object[] keyvalue in keyvalueflow)
{
long offset = keyvalue_seq.Root.AppendElement(keyvalue);
//dic1.Add((int)keyvalue[0], offset);
}
keyvalue_seq.Flush();
}
public void Flush()
{
cell.Flush();
// Кроме сброса размера в ячейку, произведем вычисление индекса
key_index.Load();
foreach (var index in indexes)
{
index.Load();
}
}
public void Load(IEnumerable <XElement> element_flow)
{
cell.Clear();
cell.Fill(new object[0]);
foreach (XElement element in element_flow)
{
var fd_el = element.Element(ONames.tag_fromdate);
string id = element.Attribute(ONames.rdfabout).Value;
string name = element.Element(ONames.tag_name).Value;
string fd = fd_el == null ? "" : fd_el.Value;
cell.Root.AppendElement(new object[] { id, name, fd, false });
}
cell.Flush();
si.Load(cell.Root.Elements().Select(r4 =>
{
object[] o4 = (object[])r4.Get();
return(new object[] { o4[0], r4.offset });
}));
ni.Load(cell.Root.Elements().Select(r4 =>
{
object[] o4 = (object[])r4.Get();
return(new object[] { ((string)o4[1]).ToLower(), r4.offset });
}));
}
void WriteOffsetsByMD5()
{
md5_index.Clear();
//Array.Sort(codeByMd5.ToArray());
md5_index.Fill(offsetByMd5.Select(pair => new object[] { pair.Key, pair.Value }).ToArray());
md5_index.Flush();
}
// Использовать надо следующим образом:
public static void Test()
{
PType objectTriplets = new PTypeSequence(new PTypeRecord(
new NamedType("deleted", new PType(PTypeEnumeration.boolean)),
new NamedType("s", new PType(PTypeEnumeration.sstring)),
new NamedType("p", new PType(PTypeEnumeration.sstring)),
new NamedType("o", new PType(PTypeEnumeration.sstring))
));
// инициализация таблицы
var directCell = new PaCell(objectTriplets, "path", false);
// Более компактный способ заполнения ячейки
directCell.Clear();
directCell.Fill(new object[0]);
//foreach (var element in elements) // Закомментарил из-за отсутствия перечислителя elements
{
directCell.Root.AppendElement(new object[] { false, "subject", "predicate", "object" });
}
directCell.Flush();
// Создание индекса
FixedIndex <SubjPred> sp_index = new FixedIndex <SubjPred>("..sp", directCell.Root, entry =>
{
return(new SubjPred()
{
subj = (string)entry.Field(1).Get(), pred = (string)entry.Field(1).Get()
});
});
}
public void Load(XElement db)
{
records.Clear();
records.Fill(new object[0]);
foreach (XElement el in db.Elements())
{
var id_att = el.Attribute(ONames.rdfabout);
if (id_att == null)
{
continue;
}
string type = el.Name.NamespaceName + el.Name.LocalName;
object[] fields = el.Elements()
.Where(sel => sel.Attribute(ONames.rdfresource) == null)
.Select(sel =>
{
var lang_att = sel.Attribute(ONames.xmllang);
return(new object[] { sel.Name.NamespaceName + sel.Name.LocalName,
sel.Value,
lang_att == null? "" : lang_att.Value });
}).ToArray();
object[] direct = el.Elements()
.Where(sel => sel.Attribute(ONames.rdfresource) != null)
.Select(sel =>
{
return(new object[] { sel.Name.NamespaceName + sel.Name.LocalName,
sel.Attribute(ONames.rdfresource).Value });
}).ToArray();
records.Root.AppendElement(new object[] { false, id_att.Value, type, fields, direct, Int64.MinValue, Int64.MinValue });
}
records.Flush();
}
public void TestPaCellInit()
{
// чистим
cell.Clear();
// заполняем
cell.Fill(new object[] { 7777, "Pupkin Vasya", 0.0001 });
cell.Flush();
// читаем
object oval = cell.Root.Get();
Assert.AreEqual(tp_rec.Interpret(oval), "{7777,\"Pupkin Vasya\",0.0001}");
// читаем поле
oval = cell.Root.Field(1).Get();
Assert.IsTrue(oval is string);
Assert.IsTrue((string)oval == "Pupkin Vasya");
// читаем другое поле
oval = cell.Root.Field(2).Get();
Assert.IsTrue((double)oval == 0.0001);
// Читаем десериализацией
PaEntry ent = cell.Root.Field(0);
long offset = ent.offset;
Assert.IsTrue(offset == 32L, "offset: " + offset);
BinaryReader br = new BinaryReader(ss);
ss.Position = offset;
object bval = ByteFlow.Deserialize(br, new PType(PTypeEnumeration.integer));
Assert.IsTrue((int)bval == 7777, "" + (int)bval);
// читаем запись
ss.Position = offset;
bval = ByteFlow.Deserialize(br, tp_rec);
Assert.IsTrue(tp_rec.Interpret(bval) == "{7777,\"Pupkin Vasya\",0.0001}", tp_rec.Interpret(bval));
// повторно, но с русским текстом
cell.Clear();
cell.Fill(new object[] { 7777, "Pupkin Вася", 0.0001 });
ss.Position = offset;
bval = ByteFlow.Deserialize(br, tp_rec);
Assert.IsTrue(tp_rec.Interpret(bval) == "{7777,\"Pupkin Вася\",0.0001}", tp_rec.Interpret(bval));
// теперь синтезирую значение ячейки
cell.Clear();
BinaryWriter bw = new BinaryWriter(ss);
ss.Position = offset;
bw.Write(7777);
bw.Write("Pupkin Vasya");
bw.Write((double)0.0001);
bw.Flush();
oval = cell.Root.Get();
Assert.IsTrue(tp_rec.Interpret(oval) == "{7777,\"Pupkin Vasya\",0.0001}", tp_rec.Interpret(oval));
// Теперь по-другому, через сериализацию
cell.Clear();
ss.Position = offset;
ByteFlow.Serialize(bw, new object[] { 7777, "Pupkin Vasya", 0.0001 }, tp_rec);
oval = cell.Root.Get();
Assert.IsTrue(tp_rec.Interpret(oval) == "{7777,\"Pupkin Vasya\",0.0001}", tp_rec.Interpret(oval));
}
public void Build(long n)
{
this.n = n;
long[] numbers = new long[n];
CreateMethodToPosition();
// Заполнение количеств элементов в диапазонах
index_cell.Root.Scan((long off, object val) =>
{
object[] pair = (object[])val;
int position = ToPosition((int)pair[0]);
// Предполагаю, что начальная разметка массива - нули
numbers[position] += 1;
return(true);
});
// Заполнение начал диапазонов
this.scell.Clear();
this.scell.Fill(new object[0]);
long sum = 0;
for (int i = 0; i < n; i++)
{
long start = sum;
sum += numbers[i];
scell.Root.AppendElement(start);
}
scell.Flush();
}
public void MakeIndexed()
{
// Подготовим индексы для заполнения
n_index.Close();
c_index.Close();
n_index = new PaCell(tp_ind, niCell, false);
n_index.Clear();
n_index.Fill(new object[0]);
c_index = new PaCell(tp_ind, ciCell, false);
c_index.Clear();
c_index.Fill(new object[0]);
foreach (PaEntry ent in nc_cell.Root.Elements())
{
long off = ent.offset;
n_index.Root.AppendElement(off);
c_index.Root.AppendElement(off);
}
n_index.Flush();
c_index.Flush();
// Индекс n_index отсортирован по построению. Надо сортировать c_index
PaEntry nc_entry = nc_cell.Root.Element(0);
c_index.Root.SortByKey(obj =>
{
nc_entry.offset = (long)obj;
return(nc_entry.Field(0).Get());
});
Open(true);
}
private void PrepareArrays()
{
// Создание и упорядочивание дополнительных структур
otriples_op.Clear();
otriples_op.Fill(new object[0]);
foreach (object v in otriples.Root.ElementValues())
{
otriples_op.Root.AppendElement(v);
}
otriples_op.Flush();
dtriples_sp.Clear();
dtriples_sp.Fill(new object[0]);
//foreach (PaEntry entry in dtriples.Root.Elements())
//{
// int s = (int)entry.Field(0).Get();
// int p = (int)entry.Field(1).Get();
// dtriples_sp.Root.AppendElement(new object[] { s, p, entry.offset });
//}
dtriples.Root.Scan((off, pobj) =>
{
object[] tri = (object[])pobj;
int s = (int)tri[0];
int p = (int)tri[1];
dtriples_sp.Root.AppendElement(new object[] { s, p, off });
return(true);
});
dtriples_sp.Flush();
}
public override void Flush()
{
typedObjectsCell.Flush();
stringsCell.Flush();
boolsCell.Flush();
doublesCell.Flush();
}
public void Load()
{
ewtable.Clear();
ewtable.Fill(new object[0]);
foreach (var scanner in scanners)
{
scanner.Start();
}
while (NotFinished(scanners))
{
string key = Least(scanners);
Diapason[] diaps = Enumerable.Repeat <Diapason>(new Diapason()
{
start = 0L, numb = 0L
}, 3).ToArray();
object[] pval = new object[4];
pval[0] = key;
for (int ind = 0; ind < 3; ind++)
{
if (scanners[ind].HasValue && scanners[ind].KeyCurrent == key)
{
Diapason di = scanners[ind].Scan();
diaps[ind] = di;
}
pval[ind + 1] = new object[] { diaps[ind].start, diaps[ind].numb };
}
ewtable.Root.AppendElement(pval);
}
ewtable.Flush();
}
public void Flush()
{
FlushPool();
n_index.Flush();
c_index.Flush();
nc_cell.Flush();
}
public void Insert(string predicate, LiteralVidEnumeration?vid)
{
Open(false);
List <string> stringByCodeList = new List <string>(stringByCode);
List <LiteralVidEnumeration?> literalsTypes = new List <LiteralVidEnumeration?>(LiteralVid);
var code = GetCode(predicate);
if (code == Int32.MinValue)
{
codeByString.Add(predicate, code = Count++);
nc_cell.Root.AppendElement(new object[] { code, predicate, (object)vid ?? -1 });
stringByCodeList.Add(predicate);
literalsTypes.Add(vid);
}
else
{
if (LiteralVid[code] != vid)
{
throw new Exception("literal types different in same predicate " + predicate);
}
}
nc_cell.Flush();
stringByCode = stringByCodeList.ToArray();
LiteralVid = literalsTypes.ToArray();
}
public void CalculateStaticIndex()
{
dic1 = new Dictionary <int, long>(); // Не используем накопленное содержание
dic2 = new Dictionary <int, long>();
int ind = 0;
int nelements = (int)keyvalue_seq.Root.Count();
keys_arr = new int[nelements];
long[] offs_arr = new long[nelements];
keyvalue_seq.Root.Scan((off, obj) =>
{
int key = (int)((object[])obj)[0];
keys_arr[ind] = key;
offs_arr[ind] = off;
ind++;
return(true);
});
Array.Sort(keys_arr, offs_arr);
keys.Clear(); keys.Fill(new object[0]);
List <int> keys_list = new List <int>();
offsets.Clear(); offsets.Fill(new object[0]);
// Будем убирать повторы
int prev_key = Int32.MaxValue;
long prev_offset = Int64.MinValue;
for (int i = 0; i < nelements; i++)
{
int key = keys_arr[i];
long offset = offs_arr[i];
if (key != prev_key)
{ // Надо сохранить пару, но только если предыдущий ключ не фиктивный
if (prev_key != Int32.MaxValue)
{
keys.Root.AppendElement(prev_key);
keys_list.Add(prev_key);
offsets.Root.AppendElement(prev_offset);
}
prev_key = key;
prev_offset = offset;
}
else
{
if (offset > prev_offset)
{
prev_offset = offset;
}
}
}
keys.Root.AppendElement(prev_key);
keys_list.Add(prev_key);
offsets.Root.AppendElement(prev_offset);
// Доделаем массив ключей
keys_arr = keys_list.ToArray();
keys.Flush();
offsets.Flush();
//dn.Flush();
}
public void Load() // В стандартном случае, задается null
{
offsetsCell.Clear();
if (!offsetsOnOffsetsCell.IsEmpty && offsetsOnOffsetsCell.Root.Count() != (long)Int32.MaxValue + Int32.MaxValue)
{
offsetsOnOffsetsCell.Clear();
}
if (offsetsOnOffsetsCell.IsEmpty)
{
offsetsOnOffsetsCell.Fill(new object[0]);
for (int i = Int32.MinValue; i < Int32.MaxValue; i++)
{
offsetsOnOffsetsCell.Root.AppendElement(long.MinValue);
}
offsetsOnOffsetsCell.Flush();
}
else
{
for (long i = 0; i < (long)Int32.MaxValue + Int32.MaxValue; i++)
{
offsetsOnOffsetsCell.Root.Element(i).Set(long.MinValue);
}
}
offsetsCell.Fill(new object[0]);
ArrayIntMax <bool> hashExists = new ArrayIntMax <bool>();
foreach (var rec in table.Root.Elements()) //.Where(ent => (bool)ent.Field(0).Get() == false) загрузка всех элементов за исключением уничтоженных
{
Tkey key = keyProducer(rec);
Int32 hash = hashProducer(key);
var offsetOnOffsetEntry = offsetsOnOffsetsCell.Root.Element((long)hash + (long)Int32.MaxValue);
if (hashExists[hash])
{
entryOffsetCell.offset = (long)offsetOnOffsetEntry.Get() + 8; //пропускаем первый.
int i = 1;
while ((long)entryOffsetCell.Get() != long.MinValue)
{
if (++i == CollisionMax)
{
throw new Exception(
"Достигнуо максимально допустимое количество ключей с одинаковым хэш-значением");
}
entryOffsetCell.offset += 8;
}
entryOffsetCell.Set(rec.offset);
}
else
{
hashExists[hash] = true;
offsetOnOffsetEntry.Set(offsetsCell.Root.AppendElement(rec.offset));
for (int i = 1; i < CollisionMax; i++)
{
offsetsCell.Root.AppendElement(long.MinValue);
}
}
}
offsetsCell.Flush();
}
//START_SOURCE_CODE
public void Run()
{
Console.WriteLine("Start Task03_PolarDB");
dbpath = System.IO.Path.GetTempPath();
PType tp = new PType(PTypeEnumeration.sstring);
PaCell cell = new PaCell(tp, dbpath + "test.pac", false);
cell.Clear();
cell.Fill("Привет из ячейки базы данных!");
Console.WriteLine("Содержимое ячейки: {0}", cell.Root.Get());
PType tp_rec = new PTypeRecord(
new NamedType("имя", new PType(PTypeEnumeration.sstring)),
new NamedType("возраст", new PType(PTypeEnumeration.integer)),
new NamedType("мужчина", new PType(PTypeEnumeration.boolean)));
object rec_value = new object[] { "Пупкин", 22, true };
PaCell cell_rec = new PaCell(tp_rec, dbpath + "test_rec.pac", false);
cell_rec.Clear();
cell_rec.Fill(rec_value);
object from_rec = cell_rec.Root.Get();
Console.WriteLine(tp_rec.Interpret(from_rec));
PType tp_seq = new PTypeSequence(tp_rec);
object seq_value = new object[]
{
new object[] { "Иванов", 24, true },
new object[] { "Петрова", 18, false },
new object[] { "Пупкин", 22, true }
};
PaCell cell_seq = new PaCell(tp_seq, dbpath + "test_seq.pac", false);
cell_seq.Clear();
cell_seq.Fill(seq_value);
object from_seq = cell_seq.Root.Get();
Console.WriteLine(tp_seq.Interpret(from_seq));
cell_seq.Root.AppendElement(new object[] { "Сидоров", 23, true });
Console.WriteLine(tp_seq.Interpret(cell_seq.Root.Get()));
long v0 = cell_seq.Root.Count();
var v1 = cell_seq.Root.Element(2).Field(0).Get();
var v2 = cell_seq.Root.Element(3).Field(1).Get();
Console.WriteLine($"{v0} {v1} {v2}");
cell_seq.Root.Element(1).Field(1).Set(19);
cell_seq.Root.Element(1).Field(2).Set(true);
Console.WriteLine(tp_seq.Interpret(cell_seq.Root.Get()));
cell_seq.Flush();
cell_seq.Close();
cell_rec.Flush();
cell_rec.Close();
cell.Flush();
cell.Close();
}
public void Flush()
{
cell_common.Clear();
cell_common.Fill(common_data);
cell_common.Flush();
cell_list.Flush();
fob.Flush();
}
public void Load()
{
index_cell.Clear();
index_cell.Fill(new object[0]);
foreach (var rec in table.Elements().Where(ent => (bool)ent.Field(0).Get() == false))
{
long offset = rec.offset;
index_cell.Root.AppendElement(offset);
}
index_cell.Flush();
if (index_cell.Root.Count() == 0)
{
return; // потому что следующая операция не пройдет
}
// Попробую сортировать index_cell специальным образом: значение (long) используется как offset ячейки и там прочитывается нулевое поле
var ptr = table.Element(0);
if (columnType.Vid == PTypeEnumeration.integer)
{
index_cell.Root.SortByKey <int>((object v) =>
{
ptr.offset = (long)v;
return((int)ptr.Field(i_field).Get());
});
}
else if (columnType.Vid == PTypeEnumeration.longinteger)
{
index_cell.Root.SortByKey <long>((object v) =>
{
ptr.offset = (long)v;
return((long)ptr.Field(i_field).Get());
});
}
else if (columnType.Vid == PTypeEnumeration.sstring)
{
index_cell.Root.SortByKey <string>((object v) =>
{
ptr.offset = (long)v;
return((string)ptr.Field(i_field).Get());
});
}
else if (columnType.Vid == PTypeEnumeration.real)
{
index_cell.Root.SortByKey <double>((object v) =>
{
ptr.offset = (long)v;
return((double)ptr.Field(i_field).Get());
});
}
else
{
throw new Exception("Wrong type of column for indexing");
}
}
private void LoadXML(string xmldb_name)
{
cell_persons.Clear(); cell_persons.Fill(new object[0]);
cell_photo_docs.Clear(); cell_photo_docs.Fill(new object[0]);
cell_reflections.Clear(); cell_reflections.Fill(new object[0]);
XElement db = XElement.Load(xmldb_name);
foreach (XElement element in db.Elements())
{
int id = Int32.Parse(element.Attribute("id").Value);
if (element.Name == "person")
{
var name_el = element.Element("name");
string name = name_el == null ? "" : name_el.Value;
var sex_el = element.Element("sex");
string sex = sex_el == null ? "" : sex_el.Value;
var fd_el = element.Element("from-date");
string fd = fd_el == null ? "" : fd_el.Value;
var td_el = element.Element("to-date");
string td = td_el == null ? "" : td_el.Value;
var des_el = element.Element("description");
string des = des_el == null ? "" : des_el.Value;
cell_persons.Root.AppendElement(new object[] { id, name, sex, fd, td, des });
}
else if (element.Name == "photo-doc")
{
var name_el = element.Element("name");
string name = name_el == null ? "" : name_el.Value;
var fd_el = element.Element("from-date");
string fd = fd_el == null ? "" : fd_el.Value;
var des_el = element.Element("description");
string des = des_el == null ? "" : des_el.Value;
cell_photo_docs.Root.AppendElement(new object[] { id, name, fd, des });
}
else if (element.Name == "reflection")
{
var ground_el = element.Element("ground");
string ground = ground_el == null ? "" : ground_el.Value;
if (element.Element("reflected") == null || element.Element("in-doc") == null)
{
continue;
}
int reflected = Int32.Parse(element.Element("reflected").Attribute("ref").Value);
int in_doc = Int32.Parse(element.Element("in-doc").Attribute("ref").Value);
cell_reflections.Root.AppendElement(new object[] { id, ground, reflected, in_doc });
}
}
cell_persons.Flush();
cell_photo_docs.Flush();
cell_reflections.Flush();
LoadIndexes();
}
public Dictionary <string, int> InsertPortion(HashSet <string> portion)
{
Console.Write("c0 ");
// foreach (var t in md5_index.Root.ElementValues()) ;
// foreach (var q in nc_cell.Root.ElementValues()) ; //14гб
// Console.Write("c_warm ");
// List<long> ofsets2NC = new List<long>(portion.Count);
// List<long> checkSumList = new List<long>(portion.Count);
var insertPortion = new Dictionary <string, int>(portion.Count);
foreach (var newString in portion)
{
insertPortion.Add(newString, InsertOne(newString));
}
nc_cell.Flush();
Console.Write("c_nc ");
return(insertPortion);
}
//public void Load<Tkey>(Func<PaEntry, Tkey> keyProducer)
public void Load()
{
// Маленький массв будет после загрузки пустым
indexCellSmall.Clear();
indexCellSmall.Fill(new object[0]); indexCellSmall.Flush();
indexCell.Clear();
indexCell.Fill(new object[0]);
foreach (var rec in table.Elements().Where(ent => !(bool)ent.Field(0).Get())) // загрузка всех элементов за исключением уничтоженных
{
var offset = rec.offset;
indexCell.Root.AppendElement(offset);
}
indexCell.Flush();
if (indexCell.Root.Count() == 0)
{
return; // потому что следующая операция не пройдет
}
// Сортировать index_cell специальным образом: значение (long) используется как offset ячейки и там прочитывается нулевое поле
indexCell.Root.Sort <FlexIndex <TKey> >();
}
public static void Main1(string[] args)
{
System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
PType tp_rec = new PTypeRecord(
new NamedType("id", new PType(PTypeEnumeration.integer)),
new NamedType("name", new PType(PTypeEnumeration.sstring)),
new NamedType("age", new PType(PTypeEnumeration.integer)));
PaCell cell = new PaCell(new PTypeSequence(tp_rec), path + "people.pac", false);
PType tp_pair = new PTypeRecord(
new NamedType("id", new PType(PTypeEnumeration.integer)),
new NamedType("offset", new PType(PTypeEnumeration.longinteger)));
PaCell cell_index = new PaCell(new PTypeSequence(tp_pair), path + "people_index.pac", false);
int npersons = 1_000_000;
Random rnd = new Random();
Console.WriteLine("Start Task04: Main1");
// Загрузка данных
sw.Restart();
cell.Clear();
cell.Fill(new object[0]);
cell_index.Clear();
cell_index.Fill(new object[0]);
for (int i = 0; i < npersons; i++)
{
int code = npersons - i;
long offset = cell.Root.AppendElement(new object[] { code, "=" + code + "=", rnd.Next(120) });
cell_index.Root.AppendElement(new object[] { code, offset });
}
cell.Flush();
cell_index.Flush();
cell_index.Root.SortByKey <int>(pair => (int)((object[])pair)[0]);
sw.Stop();
Console.WriteLine($"load {npersons} records. duration {sw.ElapsedMilliseconds}");
// Поиск
int key = npersons * 2 / 3;
int ntests = 10000;
sw.Restart();
PaEntry entry = cell.Root.Element(0);
for (int j = 0; j < ntests; j++)
{
key = rnd.Next(npersons);
PaEntry en = cell_index.Root.BinarySearchFirst(ent => ((int)((object[])ent.Get())[0]).CompareTo(key));
object operson = entry.SetOffset((long)((object[])en.Get())[1]).Get();
//Console.WriteLine($"val={tp_rec.Interpret(operson)}");
}
sw.Stop();
Console.WriteLine($"getByKey {ntests} times. duration {sw.ElapsedMilliseconds}");
}
public void CreateCollection(string collectionname, PType collectionelementtype)
{
if (collections.ContainsKey(collectionname))
{
throw new Exception("collection name [" + collectionname + "] already exists");
}
// Глубина типового объекта ограничена 8
cell_catalogue.Root.AppendElement(new object[] { collectionname, collectionelementtype.ToPObject(8) });
cell_catalogue.Flush();
Collection collection = new Collection(collectionname, collectionelementtype, this);
collections.Add(collectionname, collection);
}
void WriteCollisions()
{
collisionsCell.Clear();
collisionsCell.Fill(new object[0]);
foreach (KeyValuePair <long, List <long> > pair in collisionsByMD5)
{
foreach (long offset in pair.Value)
{
collisionsCell.Root.AppendElement(new object[] { pair.Key, offset });
}
}
collisionsCell.Flush();
}
public StringIntRAMDIctionary(string path, Dictionary <string, int> ReWrite)
{
niCell = path + "n_index.pac";
// Создание ячеек, предполагается, что все либо есть либо их нет и надо создавать
Clear();
foreach (var str_code in ReWrite)
{
nc_cell.Root.AppendElement(new object[]
{
str_code.Value, str_code.Key
});
}
nc_cell.Flush();
// Открытие ячеек в режиме работы (чтения)
codeByString = ReWrite;
stringByCode = ReWrite.Select(pair => pair.Key).ToList();
Count = stringByCode.Count;
Close();
}
public void Build()
{
index_cell.Clear();
index_cell.Fill(new object[0]);
if (Key1Producer == null)
{
throw new Exception("Err: Key1Producer not defined");
}
if (Key2Producer == null)
{
throw new Exception("Err: Key2Producer not defined");
}
Table.Scan((offset, o) =>
{
var k1 = Key1Producer(o);
var k2 = Key2Producer(o);
int hk2 = Half2Producer(k2);
index_cell.Root.AppendElement(new object[] { offset, k1, hk2 });
return(true);
});
index_cell.Flush();
PaEntry entry = Table.Element(0);
index_cell.Root.SortByKey <GroupElement>(ob =>
new GroupElement((int)((object[])ob)[1], (int)((object[])ob)[2], () =>
{
long off = (long)((object[])ob)[0];
entry.offset = off;
return(Key2Producer(entry.Get()));
}));
// BuildGroupsIndexSpecial:
groups_index.Clear();
groups_index.Fill(new object[0]);
int key1 = Int32.MinValue;
int i = 0; // Теоретически, здесь есть проблема в том, что элементы могут выдаватьс не по индексу.
foreach (object[] va in index_cell.Root.ElementValues())
{
int k1 = (int)va[1];
if (k1 > key1)
{
groups_index.Root.AppendElement(i);
key1 = k1;
}
i++;
}
groups_index.Flush();
//CreateGroupDictionary();
CreateDiscaleDictionary();
}
public void Load(IEnumerable <object[]> rec_flow)
{
acell.Clear();
acell.Fill(new object[0]);
foreach (object[] rec in rec_flow)
{
acell.Root.AppendElement(new object[] { rec[0], rec[1], false });
}
acell.Flush();
xcell.Clear();
xcell.Fill2(acell.Root.Get());
xcell.Flush();
xcell.Root.Sort((PxEntry entry) => (string)entry.Field(0).Get()); // Это надо привести в соответствие с типом ключа
}