// Есть конструктор, задающий все предыдущее
public ScaleInMemory(PaEntry seq, long start, long number, Func<object, int> keyFunction, int n_scale)
{
this.sequence = seq;
this.start = start;
this.number = number;
this.KeyFunction = keyFunction;
this.n_scale = n_scale;
}
// Целостное действие слабой динамики: ДОбавление элемента в таблицу, фиксация его и вызов хендлеров у индексов
public PaEntry AppendValue(object value)
{
long offset = table_cell.Root.AppendElement(new object[] { false, value });
table_cell.Flush();
PaEntry entry = new PaEntry(tp_rec, offset, table_cell);
foreach (var index in indexes) index.OnAppendElement(entry);
return entry;
}
// Есть конструктор, задающий все предыдущее
public ScalePaCell(string scale_cell_path, PaEntry seq, long start, long number, Func<object, int> keyFunction, int n_scale)
{
this.sequence = seq;
this.start = start;
this.number = number;
this.KeyFunction = keyFunction;
this.n_scale = n_scale;
this.scell = new PaCell(new PTypeSequence(new PType(PTypeEnumeration.longinteger)),
scale_cell_path + "_scale.pac", false);
if (!this.scell.IsEmpty)
{
var existsNScale = this.scell.Root.Count();
if (n_scale != existsNScale)
{
Build();
}
}
}
public IEnumerable <PaEntry> GetAllByKey(long start, long number, Tkey key)
{
if (Table == null || Table.Count() == 0)
{
return(Enumerable.Empty <PaEntry>());
}
PaEntry entry = Table.Element(0);
PaEntry entry1 = entry;
var query = index_cell.Root.BinarySearchAll(start, number, ent =>
{
var ob = (Tkey)(ent.Field(0).Get());
return(ob.CompareTo(key));
});
return(query.Select(ent =>
{
entry1.offset = (long)ent.Field(1).Get();
return entry1;
}));
}
public string GetName(int code)
{
Open(true);
if (Count == 0)
{
return(string.Empty);
}
if (code == int.MinValue)
{
return(string.Empty);
}
if (Count <= code)
{
return(string.Empty);
}
ncEntry = encodedCell.Root.Element(0);
ncEntry.offset = (long)c_index.Root.Element(code).Get();
return(staticFreqEncoding.Decode(((object[])ncEntry.Get()).Cast <byte>().ToArray()));
}
public IEnumerable <object> GetAllInDiap(Diapason dia)
{
if (dia.IsEmpty())
{
return(Enumerable.Empty <object>());
}
PaEntry entry = Table.Element(0);
var query2 = index_cell.Root.ElementValues(dia.start, dia.numb)
.Select(va =>
{
long off = (long)((object[])va)[0];
entry.offset = off;
return(entry.Get());
})
.Where(two => !(bool)((object[])two)[0])
.Select(two => ((object[])((object[])two)[1]));
return(query2);
}
public void Search(string ss)
{
ss = ss.ToLower();
int n = ss.Length;
foreach (var off in ni.FindAll(obj => {
if (((string)obj).StartsWith(ss))
{
return(0);
}
return(((string)obj).CompareTo(ss));
}))
{
PaEntry entry = cell.Root.Element(0);
entry.offset = off;
var rec = entry.GetValue();
//Console.WriteLine("VAlu=" + rec.Type.Interpret(rec.Value));
}
}
public string GetName(int code)
{
Open(true);
if (Count == 0)
{
return(string.Empty);
}
if (code == int.MinValue)
{
return(string.Empty);
}
if (Count <= code)
{
return(string.Empty);
}
PaEntry paEntry = nc_cell.Root.Element(0);
paEntry.offset = (long)c_index.Root.Element(code).Get();
return((string)paEntry.Field(1).Get());
}
public PaEntry GetFirst(Func <PaEntry, int> elementDepth)
{
if (table.Count() == 0)
{
return(new PaEntry(null, Int64.MinValue, null));
}
PaEntry entry = table.Element(0);
PaEntry entry_in_index = index_cell.Root.BinarySearchFirst(ent =>
{
long off = (long)ent.Get();
entry.offset = off;
return(elementDepth(entry.Field(i_field)));
});
if (entry_in_index.offset == Int64.MinValue)
{
return(entry_in_index); // не найден
}
entry.offset = (long)entry_in_index.Get();
return(entry);
}
// Возвращает первый вход опорной таблицы, для которого сгенерированный ключ совпадает с образцом
public PaEntry GetFirstByKey0(Tkey key)
{
if (table.Count() == 0)
{
return(PaEntry.Empty);
}
PaEntry entry = table.Element(0);
var candidate = index_cell.Root.BinarySearchFirst(ent =>
{
long off = (long)ent.Get();
entry.offset = off;
return(((IComparable)keyProducer(entry)).CompareTo(key));
});
if (candidate.IsEmpty)
{
return(PaEntry.Empty);
}
entry.offset = (long)candidate.Get();
return(entry);
}
protected override void AddInIndex(PaEntry entry)
{
int node;
if (entry.Type.Vid == PTypeEnumeration.integer)
{
node = (int) entry.Get();
if (!searchIndex.ContainsKey(node))
searchIndex.Add(node, entry.offset);
}
else
{
node = (int) entry.Field(0).Get();
if (!searchIndex.ContainsKey(node))
searchIndex.Add(node, entry.offset);
foreach (var chiledEntry in entry.Field(1).Elements())
{
AddInIndex(chiledEntry);
}
}
}
private Dictionary <Tkey, List <PaEntry> > keyents = new Dictionary <Tkey, List <PaEntry> >(); // стандартно
public void OnAppendElement(PaEntry entry)
{
Tkey key = KeyProducer(entry.Get());
if (_unique)
{
keyent.Add(key, entry); // Надо бы что-то проверить...
}
else
{
List <PaEntry> entset;
if (keyents.TryGetValue(key, out entset))
{
entset.Add(entry);
}
else
{
keyents.Add(key, Enumerable.Repeat <PaEntry>(entry, 1).ToList());
}
}
}
public IEnumerable <Triple> GetTriples()
{
PaEntry paEntry = dataCell.Root.Element(0);
//foreach (var element in entitiesTree.Root.Elements())
for (int i = 0; i < entitiesTree.Root.Count(); i++)
{
var element = entitiesTree.Root.Element(i);
//(int)element.Field(0).Get(),=WRONG
SUriNode sUriNode = new SUriNode(i, this);
foreach (object[] po in (object[])element.Field(1).Get())
{
paEntry.offset = (long)po[1];
yield return(new Triple(sUriNode, new SUriNode((int)po[0], this), new SLiteralNode(paEntry.Get(), this)));
}
foreach (object[] po in (object[])element.Field(2).Get())
{
yield return(new Triple(sUriNode, new SUriNode((int)po[0], this), new SUriNode((int)po[1], this)));
}
}
}
internal IEnumerable <Literal> GetDataBySubjPred0(int subj, int pred)
{
var rec_ent = tree_fix.Root.BinarySearchFirst(ent => ((int)ent.Field(0).Get()).CompareTo(subj));
if (rec_ent.IsEmpty)
{
return(Enumerable.Empty <Literal>());
}
var fields = (object[])rec_ent.Field(1).Get();
PaEntry lit_ent = literals.Root.Element(0);
var offsets = fields.Where(pair => (int)((object[])pair)[0] == pred)
.Select(pair => (long)((object[])pair)[1]);
var lits = offsets.Select(off =>
{
lit_ent.offset = off;
object[] pair = (object[])lit_ent.Get();
return(new Literal(pair));
});
return(lits);
}
private PaEntry GetFirstFrom(PaCell i_cell, Func <PaEntry, int> elementDepth)
{
PaEntry entry = table.Element(0);
PaEntry entry2 = table.Element(0); // сделан, потому что может entry во внешнем и внутренниц циклах проинтерферируют?
var candidate = i_cell.Root.BinarySearchAll(ent =>
{
long off = (long)ent.Get();
entry.offset = off;
return(elementDepth(entry));
}) // здесь мы имеем множество найденных входов в ячейку i_cell
.Select(ent =>
{
entry2.offset = (long)ent.Get(); // вход в запись таблицы
return(entry2);
}) // множество входов, удовлетворяющих условиям
.Where(t_ent => !(bool)t_ent.Field(0).Get()) // остаются только неуничтоженные
.DefaultIfEmpty(PaEntry.Empty) // а вдруг не останется ни одного, тогда - пустышка
.First(); // обязательно есть хотя бы пустышка
return(candidate);
}
public IEnumerable <PaEntry> GetAllByKey(long start, long number, Tkey key)
{
if (Table == null || Table.Count() == 0)
{
return(Enumerable.Empty <PaEntry>());
}
PaEntry entry = Table.Element(0);
PaEntry entry1 = entry;
var query = index_cell.Root.BinarySearchAll(start, number, ent =>
{
long off = (long)ent.Get();
entry.offset = off;
return(KeyProducer((object[])entry.Get()).CompareTo(key));
});
return(query.Select(ent =>
{
entry1.offset = (long)ent.Get();
return entry1;
}));
}
internal IEnumerable <Literal> GetDataBySubjPred1(int subj, int pred)
{
record rec;
if (!codeRec.TryGetValue(subj, out rec))
{
return(Enumerable.Empty <Literal>());
}
var offsets = rec.fields
.Where(pair => pair.Key == pred)
.Select(pair => pair.Value);
PaEntry lit_ent = literals.Root.Element(0);
var lits = offsets.Select(off =>
{
lit_ent.offset = off;
object[] pair = (object[])lit_ent.Get();
return(new Literal(pair));
});
return(lits);
}
public int SetNameGetCode(string name)
{
long off = n_index.GetFirst(name);
if (off != Int64.MinValue)
{ // Есть такой
PaEntry ent = nc_cell.Root.Element(0);
ent.offset = off;
return((int)ent.Field(0).Get());
}
else
{
int code = next_code;
next_code++;
var r_off = nc_cell.Root.AppendElement(new object[] { code, name });
//nc_cell.Flush();
n_index.Add(name, r_off);
c_index.Add(code, r_off);
return(code);
}
}
public IEnumerable <Literal> GetDataBySubjPred4(int subj, int pred)
{
object[] diapason = GetDiapasonFromHash(subj, pred, 2);
if (diapason == null)
{
return(Enumerable.Empty <Literal>());
}
PaEntry dtriple_entry = dtriples.Root.Element(0);
return(dtriples_sp.Root.Elements((long)diapason[0], (long)diapason[1])
//.Where(entry => pred == (int)((object[])entry.Get())[1])
.Select(en =>
{
dtriple_entry.offset = (long)en.Field(2).Get();
object[] uni = (object[])dtriple_entry.Field(2).Get();
Literal lit = new Literal();
int vid = (int)uni[0];
if (vid == 1)
{
lit.vid = LiteralVidEnumeration.integer;
lit.value = (int)uni[1];
}
if (vid == 3)
{
lit.vid = LiteralVidEnumeration.date;
lit.value = (long)uni[1];
}
else if (vid == 2)
{
lit.vid = LiteralVidEnumeration.text;
object[] txt = (object[])uni[1];
lit.value = new Text()
{
s = (string)txt[0], l = (string)txt[1]
};
}
return lit;
}));
}
public IEnumerable <PaEntry> GetAllByLevel(Func <PaEntry, int> levelFunc)
{
if (Table == null || Table.Count() == 0)
{
return(Enumerable.Empty <PaEntry>());
}
PaEntry entry = Table.Element(0);
PaEntry entry1 = entry;
var query = index_cell.Root.BinarySearchAll(ent =>
{
long off = (long)ent.Get();
entry.offset = off;
//return KeyProducer((object[])entry.Get()).CompareTo(key);
return(levelFunc(entry));
}).ToArray();
return(query.Select(ent =>
{
entry1.offset = (long)ent.Get();
return entry1;
}));
}
public IEnumerable <PaEntry> GetAllByKey2(long start, long number, Tkey key)
{
if (Table == null || Table.Count() == 0)
{
return(Enumerable.Empty <PaEntry>());
}
PaEntry entry = Table.Element(0);
PaEntry entry1 = entry;
int hkey = HalfProducer(key);
var entries = index_cell.Root.ElementValues(start, number)
.Cast <object[]>()
.TakeWhile(va => (int)va[0] <= hkey)
.Where(va => (int)va[0] == hkey)
.Select(va => { long off = (long)va[1]; entry.offset = off; return(entry); })
.Where(va =>
{
var ka = KeyProducer(entry.Get());
return(ka.CompareTo(key) == 0);
});
return(entries);
}
// Возвращает множество входов в записи опорной таблицы, удовлетворяющие elementDepth == 0
public IEnumerable <PaEntry> GetAll(Func <PaEntry, int> elementDepth)
{
if (table.Count() == 0)
{
return(Enumerable.Empty <PaEntry>());
}
PaEntry entry = table.Element(0);
Diapason dia = index_cell.Root.BinarySearchDiapason((PaEntry ent) =>
{
long off = (long)ent.Get();
entry.offset = off;
return(elementDepth(entry));
});
var query = index_cell.Root.Elements(dia.start, dia.numb)
.Select(ent =>
{
entry.offset = (long)ent.Get();
return(entry);
})
; //.Where(t_ent => !(bool)t_ent.Field(0).Get()); // остаются только неуничтоженные
return(query);
}
public XElement GetPortraitByIdIn(int id, string type)
{
PaEntry entry = PaEntry.Empty;
if (type == "person")
{
entry = index_persons_id.GetFirstByKey0(id);
}
else if (type == "photo-doc")
{
entry = index_photo_docs_id.GetFirstByKey0(id);
}
if (entry.IsEmpty)
{
return(null);
}
object[] val = (object[])entry.Get();
var res = new XElement("record", new XAttribute("id", id), new XAttribute("type", type),
new XElement("field", new XAttribute("prop", "name"), (string)val[1]),
null);
if (type == "person")
{
foreach (PaEntry ent in index_reflection_reflected.GetAllByKey(id))
{
object[] reflect_obj = (object[])ent.Get();
int cod = (int)reflect_obj[3];
XElement port = GetPortraitByIdIn(cod, "photo-doc");
res.Add(new XElement("inverse", new XAttribute("prop", "reflected"),
new XElement("record", new XAttribute("id", reflect_obj[0]),
new XElement("field", new XAttribute("prop", "ground"), reflect_obj[1]),
new XElement("direct", new XAttribute("prop", "in-doc"), port),
null)));
}
}
return(res);
}
public IEnumerable <PaEntry> GetAll(Func <PaEntry, int> elementDepth)
{
if (table.Count() > 0)
{
PaEntry entry = table.Element(0);
Diapason dia = index_cell.Root.BinarySearchDiapason((PaEntry ent) =>
{
long off = (long)ent.Get();
entry.offset = off;
return(elementDepth(entry.Field(i_field)));
});
var query = index_cell.Root.Elements(dia.start, dia.numb)
.Select(ent =>
{
entry.offset = (long)ent.Get();
return(entry);
});
return(query);
}
else
{
return(Enumerable.Empty <PaEntry>());
}
}
public override void Fill(IEnumerable <object> values)
{
Clear();
foreach (var index in indexes)
{
index.FillInit();
}
List <TableRow> buffer = new List <TableRow>(10000);
foreach (var el in values)
{
if (buffer.Count == 10000)
{
foreach (var index in indexes)
{
index.FillPortion(buffer);
}
buffer.Clear();
}
object v = new object[] { false, el };
long offset = table_cell.Root.AppendElement(v);
PaEntry entry = new PaEntry(tp_rec, offset, table_cell);
//foreach (var index in indexes) index.OnAppendElement(entry);
buffer.Add(new TableRow(v, offset));
}
foreach (var index in indexes)
{
index.FillPortion(buffer);
}
foreach (var index in indexes)
{
index.FillFinish();
}
table_cell.Flush();
}
public void Compress(PaCell dtriplets, PredicatesCoding predicatesCoding)
{
stringsArhive.WriteCell();
PaEntry paEntry = stringsCell.Root.Element(0);
foreach (var dtripletElement in dtriplets.Root.Elements())
{
int predicateCode = (int)dtripletElement.Field(1).Get();
if (predicatesCoding.LiteralVid[predicateCode] == LiteralVidEnumeration.text)
{
PaEntry offsetElement = dtripletElement.Field(2);
long offset = (long)offsetElement.Get();
paEntry.offset = offset;
object[] stri_lang = (object[])paEntry.Get();
offsetElement.Set(
StringsArchedCell.Root.AppendElement(new object[] {
Enumerable.Cast <object>(stringsArhive.Compress((string)stri_lang[0])).ToArray(),
Enumerable.Cast <object>(stringsArhive.Compress((string)stri_lang[01])).ToArray()
}));
}
}
StringsArchedCell.Flush();
}
public static void Main(string[] args)
{
Random rnd = new Random();
string path = @"..\..\..\Databases\";
PType tp_oprops = new PTypeSequence(new PTypeRecord(
new NamedType("subject", new PType(PTypeEnumeration.integer)),
new NamedType("predicate", new PType(PTypeEnumeration.integer)),
new NamedType("object", new PType(PTypeEnumeration.integer))));
PType tp_subject_index = new PTypeSequence(new PType(PTypeEnumeration.longinteger));
PaCell oprops = new PaCell(tp_oprops, path + "opreps.pac", false);
PaCell subject_index = new PaCell(tp_subject_index, path + "subj_ind.pac", false);
Console.WriteLine("Start");
DateTime tt0 = DateTime.Now;
bool toload = true;
if (toload)
{
oprops.Clear();
subject_index.Clear();
oprops.Fill(new object[0]);
subject_index.Fill(new object[0]);
for (int i = 0; i < 100000000; i++)
{
object[] valu = new object[] { rnd.Next(), rnd.Next(), 999 };
long offset = oprops.Root.AppendElement(valu);
subject_index.Root.AppendElement(offset);
if (i % 1000000 == 0)
{
Console.Write(" " + i);
}
}
Console.WriteLine();
int[][] samples =
{
new int[] { 777, 21 },
new int[] { 777, 19 },
new int[] { 777, 22 },
new int[] { 7777777, 21 },
new int[] { 777, 18 }
};
foreach (int[] sa in samples)
{
object[] valu = new object[] { sa[0], sa[1], 999 };
long offset = oprops.Root.AppendElement(valu);
subject_index.Root.AppendElement(offset);
}
oprops.Flush();
subject_index.Flush();
Console.WriteLine("Loading ok. duration=" + (DateTime.Now - tt0).Ticks / 10000L); tt0 = DateTime.Now;
PaEntry.bufferBytes = 400000000;
PaEntry oentry = oprops.Root.Element(0);
//subject_index.Root.SortByKey<int>(off =>
//{
// oentry.offset = (long)off;
// return (int)oentry.Field(0).Get();
//});
subject_index.Root.SortByKey <PairInt>(off =>
{
oentry.offset = (long)off;
object[] triple = (object[])oentry.Get();
return(new PairInt()
{
first = (int)triple[0], second = (int)triple[1]
});
});
Console.WriteLine("Sort ok. duration=" + (DateTime.Now - tt0).Ticks / 10000L); tt0 = DateTime.Now;
}
PaEntry oentry2 = oprops.Root.Element(0);
var query = subject_index.Root.BinarySearchAll(ent =>
{
long off = (long)ent.Get();
oentry2.offset = off;
int sub = (int)oentry2.Field(0).Get();
return(sub.CompareTo(777));
});
Console.WriteLine("BinarySearch ok. duration=" + (DateTime.Now - tt0).Ticks / 10000L); tt0 = DateTime.Now;
foreach (var ent in query)
{
oentry2.offset = (long)ent.Get();
object[] valu = (object[])oentry2.Get();
Console.WriteLine("{0} {1} {2}", valu[0], valu[1], valu[2]);
}
Console.WriteLine("Finish. duration=" + (DateTime.Now - tt0).Ticks / 10000L); tt0 = DateTime.Now;
}
public int InsertOne(string entity)
{
var newMD5 = BitConverter.ToInt64(md5.ComputeHash(Encoding.UTF8.GetBytes(entity)), 0);
int code = 0;
List <long> offsets;
if (collisionsByMD5.TryGetValue(newMD5, out offsets))
{
PaEntry ncEntry = nc_cell.Root.Element(0);
bool newCollision = true;
foreach (int offset in offsets)
{
ncEntry.offset = offset;
var code_name = (object[])ncEntry.Get();
if ((string)code_name[1] != entity)
{
continue;
}
code = (int)code_name[0];
newCollision = false;
break;
}
if (newCollision)
{
//checkSumList.Add(newMD5);
long newOffset = nc_cell.Root.AppendElement(new object[] { code = Count++, entity });
// ofsets2NC.Add(newOffset);
offsetByMd5.Add(newMD5, newOffset);
}
}
else
{
long offsetOnCodeName = 0;
if (offsetByMd5.TryGetValue(newMD5, out offsetOnCodeName))
{
//может появилась коллизия
PaEntry ncEntry = nc_cell.Root.Element(0);
ncEntry.offset = offsetOnCodeName;
string existsName = (string)((object[])ncEntry.Get())[1];
if (existsName == entity)
{
code = (int)((object[])ncEntry.Get())[0];
}
else
{
//новая коллизия, добавляем строку
collisionsByMD5.Add(newMD5, offsets = new List <long>());
offsets.Add(offsetOnCodeName);
long newOffset = nc_cell.Root.AppendElement(new object[] { code = Count++, entity });
offsets.Add(newOffset);
}
}
else
{
long newOffset = nc_cell.Root.AppendElement(new object[] { code = Count++, entity });
offsetByMd5.Add(newMD5, newOffset);
}
}
return(code);
}
private XElement GetPortraitById(PaEntry ent, XElement format)
{
if (ent.IsEmpty)
{
return(null);
}
string type = format.Attribute("type").Value;
Collection2 collection = collections[type];
object[] three = (object[])ent.Get();
int key = (int)three[1];
object[] pvalues = (object[])three[2];
XElement[] fels = format.Elements().Where(el => el.Name == "field" || el.Name == "direct").ToArray();
XElement[] schem = collection.FRecord //schema.Elements("record").First(re => re.Attribute("type").Value == type)
.Elements().Where(el => el.Name == "field" || el.Name == "direct").ToArray();
// Элементы pvalues по количеству и по сути соответствуют определениям schem
if (pvalues.Length != schem.Length)
{
throw new Exception("Assert Error 9843");
}
XElement result = new XElement("record", new XAttribute("id", key), new XAttribute("type", type));
var fields_directs = fels.Select(fd =>
{
string prop = fd.Attribute("prop").Value;
int ind = FirstProp(schem, prop);
XElement sch_el = schem[ind];
XElement res = null;
if (sch_el.Name == "field")
{
res = new XElement("field", new XAttribute("prop", prop), pvalues[ind]);
}
else if (sch_el.Name == "direct")
{
int forward_key = (int)pvalues[ind];
res = new XElement("direct", new XAttribute("prop", prop), GetPortraitById(forward_key, fd.Element("record")));
}
return(res);
});
result.Add(fields_directs);
XElement[] iels = format.Elements("inverse").ToArray();
foreach (var inv in format.Elements("inverse"))
{
string iprop = inv.Attribute("prop").Value;
XElement rec = inv.Element("record");
string itype = rec.Attribute("type").Value;
var inde = external_indexes.FirstOrDefault(context => context.totype == type && context.prop == iprop && context.type == itype);
if (inde == null)
{
continue;
}
foreach (PaEntry en in ((FlexIndex2 <int>)inde.index).GetAllByKey(key))
{
//int ccod = (int)en.Field(1).Get();
result.Add(new XElement("inverse", new XAttribute("prop", iprop), GetPortraitById(en, rec)));
}
}
return(result);
}
public override void Fill(IEnumerable<object> values)
{
Clear();
foreach (var index in indexes) index.FillInit();
List<TableRow> buffer=new List<TableRow>(10000);
foreach (var el in values)
{
if (buffer.Count == 10000)
{
foreach (var index in indexes) index.FillPortion(buffer);
buffer.Clear();
}
object v = new object[] {false, el};
long offset = table_cell.Root.AppendElement(v);
PaEntry entry = new PaEntry(tp_rec, offset, table_cell);
//foreach (var index in indexes) index.OnAppendElement(entry);
buffer.Add(new TableRow(v, offset));
}
foreach (var index in indexes) index.FillPortion(buffer);
foreach (var index in indexes) index.FillFinish();
table_cell.Flush();
}
public void DeleteEntry(PaEntry record)
{
record.Field(0).Set(true);
}
public int GetSetCode(string key)
{
int ind = F1(key);
int f2 = F2(key);
if (search_key.IsEmpty && cell_keys_offsets.Root.Count() > 0) search_key = cell_keys.Root.Element(0);
object[] nd;
//counter++;
while (((int)((nd = (object[])cell_hash2codes.Root.Element(ind).Get())[1])) != -1)
{
//counter++;
if ((int)nd[0] == f2)
{ // Если найден, то выход, иначе это коллизия - надо продолжать.
// найдем offset, а потом вычислим ключ
int code = (int)nd[1];
long offset = (long)cell_keys_offsets.Root.Element(code).Get();
search_key.offset = offset;
if ((string)search_key.Get() == key) return code;
}
ind = (ind + 1) % arrLength;
}
//return -1;
int k = (int)cell_keys_offsets.Root.Count();
long off = cell_keys.Root.AppendElement(key);
cell_keys_offsets.Root.AppendElement(off);
cell_hash2codes.Root.Element(ind).Set(new object[] { f2, k });
return k;
}
public static void Main2()
{
Random rnd = new Random();
System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
Console.WriteLine("Start demo of table and simple indexes");
// ============ Таблица и простые индексы к ней =============
// Создадим ячейку с последовательностью записей. Заполним последовательность тестовами значениями.
PType tp_pers = new PTypeRecord(
new NamedType("id", new PType(PTypeEnumeration.integer)),
new NamedType("name", new PType(PTypeEnumeration.sstring)),
new NamedType("age", new PType(PTypeEnumeration.real)));
Stream stream = new FileStream(dbpath + "recordsequence.pac", FileMode.OpenOrCreate, FileAccess.ReadWrite);
PaCell cell = new PaCell(new PTypeSequence(tp_pers), stream, false);
// Простой индекс, это отсортированная последовательность пар: ключ-офсет, в данном случае, ключ - идентификатор, офсет - смещение записи в ячейке cell
PType tp_index = new PTypeSequence(new PTypeRecord(
new NamedType("key", new PType(PTypeEnumeration.integer)),
new NamedType("offset", new PType(PTypeEnumeration.longinteger))
));
PaCell cell_index = new PaCell(tp_index, new FileStream(dbpath + "id_index.pac", FileMode.OpenOrCreate, FileAccess.ReadWrite), false);
int nelements = 1000000;
bool toload = true; // Загружать или нет новую базу данных
if (toload)
{
sw.Restart();
// Очистим ячейки последовательности и индекса
cell.Clear();
cell_index.Clear();
// Запишем пустую последовательность длиной n элементов
cell.Fill(new object[0]);
cell_index.Fill(new object[0]);
for (int i = 0; i < nelements; i++)
{
int id = nelements - i; // обратный порядок для того, чтобы сортировка была не тривиальной
string name = "=" + id.ToString() + "="; // лексикографический порядок будет отличаться от числового
var offset = cell.Root.AppendElement(new object[] { id, name, rnd.NextDouble() * 100.0 });
cell_index.Root.AppendElement(new object[] { id, offset });
}
// обязательно надо зафиксировать добавленное
cell.Flush();
cell_index.Flush();
// Теперь надо отсортировать индексный массив по ключу
cell_index.Root.SortByKey <int>(ob => (int)((object[])ob)[0]);
sw.Stop();
Console.WriteLine("Load ok. duration for {0} elements: {1} ms", nelements, sw.ElapsedMilliseconds);
}
// Указатель на нулевой элемент последовательности
PaEntry entry0 = cell.Root.Element(0);
// Немножко проверим
int search_key = nelements * 2 / 3;
var entry = cell_index.Root.BinarySearchFirst(ent => ((int)ent.Field(0).Get()).CompareTo(search_key));
if (entry.IsEmpty)
{
Console.WriteLine("no entry for key {0} found!", search_key);
}
else
{
// По найденой в индексе записи с совпадающим значением ключа, получаем офсет
long seq_off = (long)entry.Field(1).Get();
entry0.offset = seq_off;
Console.WriteLine("name for key {0} is {1}!", search_key, entry0.Field(1).Get());
}
// Засечем скорость выборок
sw.Restart();
for (int i = 0; i < 1000; i++)
{
search_key = rnd.Next(nelements) + 1;
entry = cell_index.Root.BinarySearchFirst(ent => ((int)ent.Field(0).Get()).CompareTo(search_key));
if (entry.IsEmpty)
{
Console.WriteLine("no entry for key {0} found!", search_key);
}
else
{
// По найденой в индексе записи с совпадающим значением ключа, получаем офсет
long seq_off = (long)entry.Field(1).Get();
entry0.offset = seq_off;
string name = (string)entry0.Field(1).Get();
}
}
sw.Stop();
Console.WriteLine("Duration for 1000 search in {0} elements: {1} ms", nelements, sw.ElapsedMilliseconds);
}
//=========================================================
public void GetById(string id)
{
PaEntry ent = id_index.GetFirst(id);
var val = ent.GetValue();
//Console.WriteLine(val.Type.Interpret(val.Value));
}
private static DateTime TestsOfMethods(string[] ids, TripleStoreInt ts)
{
System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
DateTime tt0 = DateTime.Now;
// ======================= Сравнение бинарного поиска с вычислением диапазона =============
int pf19 = ids[5].GetHashCode();
List <long> trace = new List <long>();
Func <PaEntry, int> fdepth = ent => { counter++; trace.Add(ent.offset); return(((int)ent.Field(2).Get()).CompareTo(pf19)); };
sw.Restart();
counter = 0; trace.Clear();
var query = ts.otriples_op.Root.BinarySearchAll(fdepth);
tt0 = DateTime.Now;
int cc = query.Count();
sw.Stop();
Console.Write("Test BinarySearchAll: {0} ", cc);
Console.WriteLine("Test swduration={0} duration={2} counter={1}", sw.Elapsed.Ticks, counter, (DateTime.Now - tt0).Ticks); tt0 = DateTime.Now;
//foreach (int point in trace) Console.Write("{0} ", point); Console.WriteLine();
sw.Restart();
counter = 0; trace.Clear();
ts.otriples_op.Root.BinarySearchScan(0, ts.otriples_op.Root.Count(), fdepth);
sw.Stop();
Console.Write("Test of BinaryScan: ");
Console.WriteLine("swduration={0} counter={1}", sw.ElapsedTicks, trace.Count()); tt0 = DateTime.Now;
//foreach (int point in trace) Console.Write("{0} ", point); Console.WriteLine();
sw.Restart();
counter = 0; trace.Clear();
ts.otriples_op.Root.BinarySearchScan(0, ts.otriples_op.Root.Count(), fdepth);
sw.Stop();
Console.Write("Test of BinaryScan: ");
Console.WriteLine("swduration={0} counter={1}", sw.ElapsedTicks, trace.Count()); tt0 = DateTime.Now;
//foreach (int point in trace) Console.Write("{0} ", point); Console.WriteLine();
sw.Restart();
counter = 0; trace.Clear();
ts.otriples_op.Root.BinarySearchFirst(fdepth);
sw.Stop();
Console.Write("Test of BinarySearchFirst: ");
Console.WriteLine("swduration={0} counter={1}", sw.ElapsedTicks, trace.Count()); tt0 = DateTime.Now;
//foreach (int point in trace) Console.Write("{0} ", point); Console.WriteLine();
sw.Restart();
counter = 0; trace.Clear();
Diapason diap = ts.otriples_op.Root.BinarySearchDiapason(0, ts.otriples_op.Root.Count(), fdepth);
sw.Stop();
Console.Write("Test of Diapason: {0} {1} ", diap.start, diap.numb);
Console.WriteLine(" swduration={0} counter={1}", sw.ElapsedTicks, counter); tt0 = DateTime.Now;
//foreach (int point in trace) Console.Write("{0} ", point); Console.WriteLine();
sw.Restart();
counter = 0; trace.Clear();
ts.otriples_op.Root.BinarySearchFirst(fdepth);
sw.Stop();
Console.Write("Test of BinarySearchFirst: ");
Console.WriteLine("swduration={0} counter={1}", sw.ElapsedTicks, trace.Count()); tt0 = DateTime.Now;
//foreach (int point in trace) Console.Write("{0} ", point); Console.WriteLine();
sw.Restart();
PaEntry test_ent = ts.otriples_op.Root.Element(0).Field(2);
int val = -1;
foreach (var point in trace)
{
test_ent.offset = point;
val = (int)test_ent.Get();
}
sw.Stop();
Console.Write("Test of series: ");
Console.WriteLine("swduration={0}", sw.ElapsedTicks); tt0 = DateTime.Now;
// ============ Конец сравнения ================
return(tt0);
}
public PaCell(PType typ, string filePath, bool readOnly = true)
: base(typ, false, filePath, readOnly)
{
_filePath = filePath;
rt = new PaEntry(typ, this.dataStart, this);
}
public void DeleteEntry(PaEntry record)
{
record.Field(0).Set(true);
}
//========================================================= для тестирования, не для использования
public PValue GetById(string id)
{
PaEntry ent = id_index.GetFirst(id);
return(ent.GetValue());
}
public string GetString(int c)
{
if (search_key.IsEmpty && cell_keys_offsets.Root.Count() > 0) search_key = cell_keys.Root.Element(0);
search_key.offset = (long) cell_keys_offsets.Root.Element(c).Get();
return (string) search_key.Get();
}
public int GetSetCode(string key)
{
uint ind = F1(key);
int f2 = F2(key);
if (search_key.IsEmpty && cell_keys_offsets.Root.Count() > 0) search_key = cell_keys.Root.Element(0);
uint counter = ind;
foreach (object[] hash_key_pair in cell_hash2codes.Root.ElementValues(ind, arrLength-ind))
{
int code = (int)hash_key_pair[1];
if (code == -1)
{
//return -1;
int k = (int) cell_keys_offsets.Root.Count();
long off = cell_keys.Root.AppendElement(key);
cell_keys_offsets.Root.AppendElement(off);
cell_hash2codes.Root.Element(counter).Set(new object[] {f2, k});
return k;
}
if ((int) hash_key_pair[0] == f2)
{
// Если найден, то выход, иначе это коллизия - надо продолжать.
// найдем offset, а потом вычислим ключ
long offset = (long)cell_keys_offsets.Root.Element(code).Get();
search_key.offset = offset;
if ((string)search_key.Get() == key) return code;
}
counter++;
}
counter = 0;
foreach (object[] hash_key_pair in cell_hash2codes.Root.ElementValues(0, ind))
{
int code = (int)hash_key_pair[1];
if (code == -1)
{
//return -1;
int k = (int)cell_keys_offsets.Root.Count();
long off = cell_keys.Root.AppendElement(key);
cell_keys_offsets.Root.AppendElement(off);
cell_hash2codes.Root.Element(counter).Set(new object[] { f2, k });
return k;
}
if ((int)hash_key_pair[0] == f2)
{
// Если найден, то выход, иначе это коллизия - надо продолжать.
// найдем offset, а потом вычислим ключ
long offset = (long)cell_keys_offsets.Root.Element(code).Get();
search_key.offset = offset;
if ((string)search_key.Get() == key) return code;
}
counter++;
}
throw new Exception("Name table can't add new key.");
}
public int GetCode(string key)
{
uint ind = F1(key);
int f2 = F2(key);
PaEntry search_key = PaEntry.Empty;
if (cell_keys_offsets.Root.Count() > 0) search_key = cell_keys.Root.Element(0);
// Цикл по последовательным элементам
object[] nd;
while (((int)((nd = (object[])cell_hash2codes.Root.Element(ind).Get())[1])) != -1)
{
//counter++;
if ((int)nd[0] == f2)
{ // Если найден, то выход, иначе это коллизия - надо продолжать.
// найдем offset, а потом вычислим ключ
int code = (int)nd[1];
long offset = (long)cell_keys_offsets.Root.Element(code).Get();
search_key.offset = offset;
if ((string)search_key.Get() == key) return code;
}
ind = (ind + 1) % arrLength;
}
//// Альтернативный вариант - 2 сканирования ElementValues()
//int arr_length = (int)cell_hash2codes.Root.Count();
//foreach (object[] pa in cell_hash2codes.Root.ElementValues(ind, arr_length - ind))
//{
// counter++;
// if ((int)pa[1] == -1) return -1;
// if ((int)pa[0] == f2)
// {
// int code = (int)pa[1];
// long offset = (long)cell_keys_offsets.Root.Element(code).Get();
// search_key.offset = offset;
// if ((string)search_key.Get() == key) return code;
// }
//}
//foreach (object[] pa in cell_hash2codes.Root.ElementValues(0, ind))
//{
// counter++;
// if ((int)pa[1] == -1) return -1;
// if ((int)pa[0] == f2)
// {
// int code = (int)pa[1];
// long offset = (long)cell_keys_offsets.Root.Element(code).Get();
// search_key.offset = offset;
// if ((string)search_key.Get() == key) return code;
// }
//}
// Не найден
return -1;
}
