// Есть конструктор, задающий все предыдущее 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; }