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 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 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 Clear()
{
stringsCell.Clear();
stringsCell.Fill(new object[0]);
Codes.Clear();
NameSpaceStrings.Clear();
namespacesByPrefix.Clear();
@type = GetShortFromFullOrPrefixed("<http://www.w3.org/1999/02/22-rdf-syntax-ns#type>");
}
public void Clear()
{
keyvalue_seq.Clear();
keyvalue_seq.Fill(new object[0]);
keys.Clear(); keys.Fill(new object[0]);
offsets.Clear(); offsets.Fill(new object[0]);
dic1 = new Dictionary <int, long>();
dic2 = new Dictionary <int, long>();
}
public void FillInit()
{
index_cell.Clear();
index_cell.Fill(new object[0]);
if (KeyProducer == null)
{
throw new Exception("Err: KeyProducer not defined");
}
}
public void Clear()
{
Open(false);
nc_cell.Clear();
c_index.Clear();
md5_index.Clear();
nc_cell.Fill(new object[0]);
c_index.Fill(new object[0]);
md5_index.Fill(new object[0]);
Count = 0;
}
public void Clear()
{
Open(false);
encodedCell.Clear();
c_index.Clear();
encodedCell.Fill(new object[0]);
c_index.Fill(new object[0]);
Count = 0;
coding.Clear();
}
public void Clear()
{
Open(false);
nc_cell.Clear();
c_index.Clear();
md5_index.Clear();
nc_cell.Fill(new object[0]);
c_index.Fill(new object[0]);
md5_index.Fill(new object[0]);
Count = 0;
offsetsByMd5Cache.Clear();
}
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 void Clear()
{
Open(false);
nc_cell.Clear();
c_index.Clear();
md5_index.Clear();
collisionsCell.Clear();
collisionsCell.Fill(new object[0]);
nc_cell.Fill(new object[0]);
c_index.Fill(new object[0]);
md5_index.Fill(new object[0]);
Count = 0;
offsetByMd5.Clear();
collisionsByMD5.Clear();
}
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();
}
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 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 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 });
}));
}
public override void Clear()
{
stringsCell.Clear();
typedObjectsCell.Clear();
stringsCell.Fill(new object[0]);
typedObjectsCell.Fill(new object[0]);
}
public NameTableInt(string path)
{
this.path = path;
this.nc_cell = new PaCell(new PTypeSequence(new PTypeRecord(
new NamedType("code", new PType(PTypeEnumeration.integer)),
new NamedType("name", new PType(PTypeEnumeration.sstring))
)),
path + "_nc.pac", false);
if (nc_cell.IsEmpty)
{
nc_cell.Fill(new object[0]);
}
//PaEntry nc_entry =
this.n_index = new DynaIndex <string>(path, "_n", off =>
{
PaEntry ent = nc_cell.Root.Element(0); // это возможно только если есть элемент, надо проверить
ent.offset = (long)off;
return((string)ent.Field(1).Get());
});
this.c_index = new DynaIndex <int>(path, "_c", off =>
{
PaEntry ent = nc_cell.Root.Element(0); // это возможно только если есть элемент, надо проверить
ent.offset = (long)off;
return((int)ent.Field(0).Get());
});
// Кодирование будет - номер записи, в которую попал идентификатор
next_code = (int)n_index.Count();
// Количество записей должно совпадать
if (n_index.Count() != c_index.Count())
{
throw new Exception("Assert error: 9434");
}
}
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 ConstructGroupedEntities(DiapLinksScanner[] scanners)
{
getable.Clear();
getable.Fill(new object[0]);
//foreach (var scanner in scanners) scanner.Start();
while (scanners.Any(dls => dls.HasValue))
{
int key = scanners.Where(dls => dls.HasValue).Select(dls => dls.KeyCurrent).Min(); //Least(scanners);
DiapLinks[] diaplinks = new DiapLinks[3];
object[] pval = new object[4];
pval[0] = key;
for (int ind = 0; ind < 3; ind++)
{
DiapLinks di;
if (scanners[ind].HasValue && scanners[ind].KeyCurrent == key)
{
di = scanners[ind].Scan();
diaplinks[ind] = di;
}
else
{
di = new DiapLinks();
}
pval[ind + 1] = di.ToPObject(); //diaplinks[ind].ToPObject();
}
getable.Root.AppendElement(pval);
}
getable.Close();
}
// Использовать надо следующим образом:
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 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);
}
// Проверка метода AppendElement
public void Load2(int numb)
{
cell.Clear();
int portion = 200;
cell.Fill(new object[0]);
for (int i = 0; i < numb / portion; i++)
{
if (i % 1000 == 0)
{
Console.WriteLine("{0}%", (double)i * 100.0 / (double)numb * (double)portion);
}
for (int j = 0; j < portion; j++)
{
int value = i * portion + j; // rnd.Next();
cell.Root.AppendElement(value);
}
}
cell.Root.AppendElement(1111111111);
for (int i = 0; i < 10; i++)
{
cell.Root.AppendElement(i * 100000000 + 77777777);
}
cell.Flush();
}
public DataNode(string path)
{
this.path = path;
//this.tp_element = tp_element;
string dbpath = path + "DataNodeStorage.bin";
bool fob_exists = File.Exists(dbpath);
FileStream fs = new FileStream(dbpath, FileMode.OpenOrCreate, FileAccess.ReadWrite);
fob = new FileOfBlocks(fs);
Stream first_stream = fob.GetFirstAsStream();
if (!fob_exists)
{
PagedStream.InitPagedStreamHead(first_stream, 8L, 0, PagedStream.HEAD_SIZE);
fob.Flush();
}
main_stream = new PagedStream(fob, fob.GetFirstAsStream(), 8L);
//long sz = PagedStream.HEAD_SIZE;
// Если main_stream нулевой длины, надо инициировать конфигурацию стримов
bool toinit = main_stream.Length == 0;
if (toinit)
{
// инициируем 2 головы для потоков
PagedStream.InitPagedStreamHead(main_stream, 0L, 0L, -1L);
PagedStream.InitPagedStreamHead(main_stream, PagedStream.HEAD_SIZE, 0L, -1L);
//PagedStream.InitPagedStreamHead(main_stream, 2 * sz, 0L, -1L);
main_stream.Flush(); fob.Flush();
}
// создадим 2 потока
Stream stream_common_params = new FileStream(path + "common.pac", FileMode.OpenOrCreate, FileAccess.ReadWrite); //new PagedStream(fob, main_stream, 0L);
Stream stream_SP_list = new FileStream(path + "splist.pac", FileMode.OpenOrCreate, FileAccess.ReadWrite); //new PagedStream(fob, main_stream, 1 * PagedStream.HEAD_SIZE);
//PagedStream stream_offsets = new PagedStream(fob, main_stream, 2 * sz); // пока не знаю для чего...
// Создадим ячейки
tp_common = new PTypeRecord(
new NamedType("configuration", tp_configuration));
cell_common = new PaCell(tp_common, stream_common_params, false);
tp_list = new PTypeSequence(KVSequencePortion.tp_pobj);
cell_list = new PaCell(tp_list, stream_SP_list, false);
// Инициализируем
if (toinit)
{
cell_common.Fill(new object[] { new object[0] });
cell_list.Fill(new object[0]);
}
common_data = cell_common.Root.Get();
foreach (object[] p in cell_list.Root.ElementValues())
{
KVSequencePortion kvsp = new KVSequencePortion(this, p);
sportion_list.Add(kvsp);
}
}
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 LiteralStore(string path, NameSpaceStore nameSpaceStore) : base(path, nameSpaceStore)
{
dataCellPath = path + "data.pac";
dataCell = new PaCell(tp_data_seq, dataCellPath, false);
if (dataCell.IsEmpty)
{
dataCell.Fill(new object[0]);
}
}
public void Clear()
{
mapper.Clear();
otriples.Clear();
otriples.Fill(new object[0]);
dtriples.Clear();
dtriples.Fill(new object[0]);
literals.Clear();
literals.Fill(new object[0]);
}
public void Clear()
{
dtriples.Clear();
otriples.Clear();
dtriples.Fill(new object[0]);
otriples.Fill(new object[0]);
dataCell.Clear();
dataCell.Fill(new object[0]);
namespaceMaper.Clear();
}
public void Clear()
{
cell.Clear();
cell.Fill(new object[0]);
key_index.Load();
foreach (var index in indexes)
{
index.Load();
}
}
public FixedIndex(string indexName, PaEntry table, Func <PaEntry, Tkey> keyProducer)
{
this.table = table;
this.keyProducer = keyProducer;
index_cell = new PaCell(new PTypeSequence(new PType(PTypeEnumeration.longinteger)), indexName + ".pac", false);
if (index_cell.IsEmpty)
{
index_cell.Fill(new object[0]);
}
}