Пример #1
0
 public static DataBaseSizeCommand ReadResponse(BinaryReader reader)
 {
     return(new DataBaseSizeCommand()
     {
         DataBaseSize = (long)CountCompression.Deserialize(reader)
     });
 }
Пример #2
0
            public void Load(WTree tree, BinaryReader reader)
            {
                int count = (int)CountCompression.Deserialize(reader);

                Capacity = count;

                NodeType nodeType = (NodeType)reader.ReadByte();

                for (int i = 0; i < count; i++)
                {
                    //read fullKey
                    var locator = tree.DeserializeLocator(reader);
                    var key     = locator.KeyPersist.Read(reader);
                    var fullKey = new FullKey(locator, key);

                    //read branch info
                    long      nodeID    = reader.ReadInt64();
                    NodeState nodeState = (NodeState)reader.ReadInt32();

                    Branch branch = new Branch(tree, nodeType, nodeID);
                    branch.NodeState = nodeState;

                    branch.Cache.Load(tree, reader);

                    Add(new KeyValuePair <FullKey, Branch>(fullKey, branch));
                }
            }
Пример #3
0
            public override void Load(Stream stream)
            {
                BinaryReader reader = new BinaryReader(stream);

                if (reader.ReadByte() != VERSION)
                {
                    throw new Exception("Invalid LeafNode version.");
                }

                long id = (long)CountCompression.Deserialize(reader);

                if (id != Branch.NodeHandle)
                {
                    throw new Exception("Wtree logical error.");
                }

                int count = (int)CountCompression.Deserialize(reader);

                for (int i = 0; i < count; i++)
                {
                    Locator path = Branch.Tree.DeserializeLocator(reader);
                    IOrderedSet <IData, IData> data = path.OrderedSetPersist.Read(reader);
                    Container[path] = data;

                    RecordCount += data.Count;
                }

                IsModified = false;
            }
Пример #4
0
            public void Store(WTree tree, BinaryWriter writer)
            {
                CountCompression.Serialize(writer, checked ((ulong)Count));

                Debug.Assert(Count > 0);
                writer.Write((byte)this[0].Value.NodeType);

                for (int i = 0; i < Count; i++)
                {
                    var     kv      = this[i];
                    FullKey fullkey = kv.Key;
                    Branch  branch  = kv.Value;
                    //lock (branch)
                    //{
                    //}

                    //write locator
                    tree.SerializeLocator(writer, fullkey.Locator);
                    fullkey.Locator.KeyPersist.Write(writer, fullkey.Key);

                    //write branch info
                    writer.Write(branch.NodeHandle);
                    writer.Write((int)branch.NodeState);

                    branch.Cache.Store(tree, writer);
                }
            }
Пример #5
0
            public override void Load(Stream stream)
            {
                BinaryReader reader  = new BinaryReader(stream);
                int          version = (int)CountCompression.Deserialize(reader);

                switch (version)
                {
                case 1:
                {
                    long id = (long)CountCompression.Deserialize(reader);
                    if (id != Branch.NodeHandle)
                    {
                        throw new Exception("Wtree logical error.");
                    }

                    HaveChildrenForMaintenance = reader.ReadBoolean();
                    Branches.Load(Branch.Tree, reader);

                    RebuildOptimizator();
                }
                break;

                default:
                    throw new NotSupportedException(string.Format("Inernal node version {0}", version));
                }

                IsModified = false;
            }
Пример #6
0
 public static ObtainHandleCommand ReadResponse(BinaryReader reader)
 {
     return(new ObtainHandleCommand()
     {
         Handle = (long)CountCompression.Deserialize(reader)
     });
 }
Пример #7
0
            public override void Load(Stream stream)
            {
                BinaryReader reader = new BinaryReader(stream);

                int version = (int)CountCompression.Deserialize(reader);

                switch (version)
                {
                case 1:
                {
                    long id = (long)CountCompression.Deserialize(reader);
                    if (id != Branch.NodeHandle)
                    {
                        throw new Exception("Wtree logical error.");
                    }

                    int count = (int)CountCompression.Deserialize(reader);
                    for (int i = 0; i < count; i++)
                    {
                        ILocator       path = Branch.Tree.Deserialize(reader);
                        IDataContainer data = path.PersistDataContainer.Read(reader);
                        Container[path] = data;

                        FillPercentage += data.FillPercentage;
                    }
                }
                break;

                default:
                    throw new NotSupportedException(string.Format("Leaf node version {0}", version));
                }

                IsModified = false;
            }
Пример #8
0
 public static HandleExistCommand ReadRequest(BinaryReader reader)
 {
     return(new HandleExistCommand()
     {
         Handle = (long)CountCompression.Deserialize(reader)
     });
 }
Пример #9
0
 public static ReadCommand ReadResponse(BinaryReader reader)
 {
     return(new ReadCommand()
     {
         Buffer = reader.ReadBytes((int)CountCompression.Deserialize(reader))
     });
 }
Пример #10
0
 public static GetTagCommand ReadResponse(BinaryReader reader)
 {
     return(new GetTagCommand()
     {
         Tag = reader.ReadBoolean() ? reader.ReadBytes((int)CountCompression.Deserialize(reader)) : null
     });
 }
Пример #11
0
        private void LoadExampleSingleSlot(BinaryReader reader, Action <int, IData> values, int count)
        {
            byte[] buffer = reader.ReadBytes((int)CountCompression.Deserialize(reader));

            //String
            using (MemoryStream ms = new MemoryStream(buffer))
                ((IIndexerPersist <string>)Persists[0]).Load(new BinaryReader(ms), (idx, value) => { values(idx, new Data <string>(value)); }, count);
        }
Пример #12
0
        public static Locator Deserialize(BinaryReader reader)
        {
            if (reader.ReadByte() != VERSION)
            {
                throw new Exception("Invalid Locator version.");
            }

            long id = reader.ReadInt64();

            if (id == Locator.MIN.ID)
            {
                return(Locator.MIN);
            }

            bool isDeleted = reader.ReadBoolean();

            string name          = reader.ReadString();
            int    structureType = reader.ReadByte();

            //data types
            DataType keyDataType    = DataType.Deserialize(reader);
            DataType recordDataType = DataType.Deserialize(reader);

            //types
            string sKeyType = reader.ReadString();
            Type   keyType  = (sKeyType != "") ? TypeCache.GetType(sKeyType) : DataTypeUtils.BuildType(keyDataType);

            string sRecordType = reader.ReadString();
            Type   recordType  = (sRecordType != "") ? TypeCache.GetType(sRecordType) : DataTypeUtils.BuildType(recordDataType);

            //key & record members
            var keyMembers    = ReadMembers(reader);
            var recordMembers = ReadMembers(reader);

            //create time
            DateTime createTime   = new DateTime(reader.ReadInt64());
            DateTime modifiedTime = new DateTime(reader.ReadInt64());
            DateTime accessTime   = new DateTime(reader.ReadInt64());

            //tag
            byte[] tag = reader.ReadBoolean() ? reader.ReadBytes((int)CountCompression.Deserialize(reader)) : null;

            var locator = new Locator(id, name, structureType, keyDataType, recordDataType, keyType, recordType);

            locator.IsDeleted = isDeleted;

            locator.keyMembers    = keyMembers;
            locator.recordMembers = recordMembers;

            locator.CreateTime   = createTime;
            locator.ModifiedTime = modifiedTime;
            locator.AccessTime   = accessTime;

            locator.Tag = tag;

            return(locator);
        }
Пример #13
0
 public static void WriteResponse(BinaryWriter writer, byte[] tag)
 {
     writer.Write(tag != null);
     if (tag != null)
     {
         CountCompression.Serialize(writer, (ulong)tag.Length);
         writer.Write(tag, 0, tag.Length);
     }
 }
Пример #14
0
        public void Load(BinaryReader reader, Action <int, byte[]> values, int count)
        {
            if (reader.ReadByte() != VERSION)
            {
                throw new Exception("Invalid ByteArrayIndexerPersist version.");
            }

            int index = 0;

            byte format = reader.ReadByte();

            if (format == 1)
            {
                if (count == 0)
                {
                    return;
                }

                int c      = reader.ReadInt32();
                int length = reader.ReadInt32();

                if (length < 0)
                {
                    for (int i = 0; i < c; i++)
                    {
                        values(index++, null);
                    }
                }
                else
                {
                    for (int i = 0; i < c; i++)
                    {
                        values(index++, reader.ReadBytes(length));
                    }
                }

                if (index == count)
                {
                    return;
                }
            }

            for (int i = index; i < count; i++)
            {
                int length = (int)CountCompression.Deserialize(reader);

                if (length == 0)
                {
                    values(i, null);
                }
                else
                {
                    values(i, reader.ReadBytes(length - 1));
                }
            }
        }
Пример #15
0
 private void StoreExampleSingleSlot(BinaryWriter writer, Func <int, IData> values, int count)
 {
     //String
     using (MemoryStream ms = new MemoryStream())
     {
         ((IIndexerPersist <String>)Persists[0]).Store(new BinaryWriter(ms), (idx) => { return(((Data <string>)values(idx)).Slot0); }, count);
         CountCompression.Serialize(writer, checked ((ulong)ms.Length));
         writer.Write(ms.GetBuffer(), 0, (int)ms.Length);
     }
 }
Пример #16
0
        public void Load(BinaryReader reader, Action <int, long> values, int count)
        {
            long        factor    = (long)CountCompression.Deserialize(reader);
            List <long> rawValues = (List <long>)DeltaCompression.CoreDecompress(reader);

            for (int i = 0; i < count; i++)
            {
                values(i, factor * rawValues[i]);
            }
        }
Пример #17
0
 public static void WriteRequest(BinaryWriter writer, byte[] tag)
 {
     writer.Write((byte)RemoteHeapCommandCodes.SetTag);
     writer.Write(tag != null);
     if (tag != null)
     {
         CountCompression.Serialize(writer, (ulong)tag.Length);
         writer.Write(tag, 0, tag.Length);
     }
 }
Пример #18
0
        public void Load(BinaryReader reader, Action <int, long> values, int count)
        {
            if (reader.ReadByte() != VERSION)
            {
                throw new Exception("Invalid Int64IndexerPersist version.");
            }

            long factor = (long)CountCompression.Deserialize(reader);

            DeltaCompression.Decompress(reader, (idx, val) => values(idx, factor * val), count);
        }
Пример #19
0
        public static void WriteRequest(BinaryWriter writer, long handle, int index, int count, byte[] buffer)
        {
            writer.Write((byte)RemoteHeapCommandCodes.WriteCommand);
            CountCompression.Serialize(writer, (ulong)handle);

            CountCompression.Serialize(writer, (ulong)index);
            CountCompression.Serialize(writer, (ulong)count);

            CountCompression.Serialize(writer, (ulong)(count + index));
            writer.Write(buffer, 0, index + count);
        }
Пример #20
0
        public static WriteCommand ReadRequest(BinaryReader reader)
        {
            return(new WriteCommand()
            {
                Handle = (long)CountCompression.Deserialize(reader),

                Index = (int)CountCompression.Deserialize(reader),
                Count = (int)CountCompression.Deserialize(reader),

                Buffer = reader.ReadBytes((int)CountCompression.Deserialize(reader))
            });
        }
Пример #21
0
        public IDataContainer Read(BinaryReader reader)
        {
            int  count     = (int)CountCompression.Deserialize(reader);
            bool isOrdered = reader.ReadBoolean();

            IData[] keys    = new IData[count];
            IData[] records = new IData[count];

            Action[] actions = new Action[2];
            byte[][] buffers = new byte[2][];

            for (int i = 0; i < buffers.Length; i++)
            {
                buffers[i] = reader.ReadBytes((int)CountCompression.Deserialize(reader));
            }

            actions[0] = () =>
            {
                using (MemoryStream ms = new MemoryStream(buffers[0]))
                    keyIndexerPersist.Load(new BinaryReader(ms), (idx, value) => { keys[idx] = value; }, count);
            };

            actions[1] = () =>
            {
                using (MemoryStream ms = new MemoryStream(buffers[1]))
                    recordIndexerPersist.Load(new BinaryReader(ms), (idx, value) => { records[idx] = value; }, count);
            };

            Parallel.Invoke(actions);

            var data = Locator.CreateDataContainer();
            var set  = (IOrderedSet <IData, IData>)data;

            if (!isOrdered)
            {
                for (int i = 0; i < count; i++)
                {
                    set.Add(keys[i], records[i]);
                }
            }
            else
            {
                KeyValuePair <IData, IData>[] orderedArray = new KeyValuePair <IData, IData> [count];
                for (int i = 0; i < orderedArray.Length; i++)
                {
                    orderedArray[i] = new KeyValuePair <IData, IData>(keys[i], records[i]);
                }

                set.AddOrdered(orderedArray, 0, orderedArray.Length);
            }

            return(data);
        }
Пример #22
0
            public override void Store(Stream stream)
            {
                BinaryWriter writer = new BinaryWriter(stream);

                writer.Write(VERSION);

                CountCompression.Serialize(writer, checked ((ulong)Branch.NodeHandle));

                writer.Write(HaveChildrenForMaintenance);
                Branches.Store(Branch.Tree, writer);

                IsModified = false;
            }
Пример #23
0
        private void WriteVertical(BinaryWriter writer, IOrderedSet <IData, IData> data)
        {
            KeyValuePair <IData, IData>[] rows;

            bool isInternallyOrdered;

            lock (data)
            {
                isInternallyOrdered = data.IsInternallyOrdered;

                rows = new KeyValuePair <IData, IData> [data.Count];
                int index = 0;
                foreach (var kv in data.InternalEnumerate())
                {
                    rows[index++] = kv;
                }

                CountCompression.Serialize(writer, checked ((ulong)rows.Length));
                writer.Write(data.IsInternallyOrdered);
            }

            Action[]       actions = new Action[2];
            MemoryStream[] streams = new MemoryStream[2];

            actions[0] = () =>
            {
                streams[0] = new MemoryStream();
                keyIndexerPersist.Store(new BinaryWriter(streams[0]), (idx) => { return(rows[idx].Key); }, rows.Length);
            };

            actions[1] = () =>
            {
                streams[1] = new MemoryStream();
                recordIndexerPersist.Store(new BinaryWriter(streams[1]), (idx) => { return(rows[idx].Value); }, rows.Length);
            };

            Parallel.Invoke(actions);

            foreach (var stream in streams)
            {
                using (stream)
                {
                    CountCompression.Serialize(writer, checked ((ulong)stream.Length));
                    writer.Write(stream.GetBuffer(), 0, (int)stream.Length);
                }
            }
        }
Пример #24
0
            public override void Store(Stream stream)
            {
                BinaryWriter writer = new BinaryWriter(stream);

                CountCompression.Serialize(writer, 1); //structure version

                CountCompression.Serialize(writer, checked ((ulong)Branch.NodeHandle));

                CountCompression.Serialize(writer, checked ((ulong)Container.Count));
                foreach (var kv in Container)
                {
                    Branch.Tree.Serialize(writer, kv.Key);
                    kv.Key.PersistDataContainer.Write(writer, kv.Value);
                }

                IsModified = false;
            }
Пример #25
0
            public override void Store(Stream stream)
            {
                BinaryWriter writer = new BinaryWriter(stream);

                writer.Write(VERSION);

                CountCompression.Serialize(writer, checked ((ulong)Branch.NodeHandle));

                CountCompression.Serialize(writer, checked ((ulong)Container.Count));
                foreach (var kv in Container)
                {
                    Branch.Tree.SerializeLocator(writer, kv.Key);
                    kv.Key.OrderedSetPersist.Write(writer, kv.Value);
                }

                IsModified = false;
            }
        private StorageEngineGetEnumeratorCommand ReadStorageEngineGetEnumeratorCommand(BinaryReader reader)
        {
            bool isListNull = reader.ReadBoolean();
            List <IDescriptor> descriptions = new List <IDescriptor>();

            if (!isListNull)
            {
                int listCount = (int)CountCompression.Deserialize(reader);

                for (int i = 0; i < listCount; i++)
                {
                    descriptions.Add((Descriptor)DeserializeDescriptor(reader));
                }
            }

            return(new StorageEngineGetEnumeratorCommand(descriptions));
        }
Пример #27
0
        private void InternalSerialize(BinaryWriter writer)
        {
            //StructureType
            writer.Write(checked ((byte)StructureType));

            if (Object.ReferenceEquals(this, Locator.MIN))
            {
                return;
            }

            //descriptor
            descriptor.Serialize(writer);

            //Items
            CountCompression.Serialize(writer, checked ((ulong)Path.Length));
            for (int i = 0; i < Path.Length; i++)
            {
                writer.Write(Path[i]);
            }
        }
Пример #28
0
        private void LoadExample(BinaryReader reader, Action <int, IData> values, int count)
        {
            Data <int, string, double>[] array = new Data <int, string, double> [count];
            for (int i = 0; i < count; i++)
            {
                var data = new Data <int, string, double>();
                array[i] = data;
                values(i, data);
            }

            Action[] actions = new Action[DataType.TypesCount];
            byte[][] buffers = new byte[DataType.TypesCount][];

            for (int i = 0; i < DataType.TypesCount; i++)
            {
                buffers[i] = reader.ReadBytes((int)CountCompression.Deserialize(reader));
            }

            //Int32
            actions[0] = () =>
            {
                using (MemoryStream ms = new MemoryStream(buffers[0]))
                    ((IIndexerPersist <Int32>)Persists[0]).Load(new BinaryReader(ms), (idx, value) => { array[idx].Slot0 = value; }, count);
            };

            //String
            actions[1] = () =>
            {
                using (MemoryStream ms = new MemoryStream(buffers[1]))
                    ((IIndexerPersist <String>)Persists[0]).Load(new BinaryReader(ms), (idx, value) => { array[idx].Slot1 = value; }, count);
            };

            //Double
            actions[2] = () =>
            {
                using (MemoryStream ms = new MemoryStream(buffers[2]))
                    ((IIndexerPersist <Double>)Persists[0]).Load(new BinaryReader(ms), (idx, value) => { array[idx].Slot2 = value; }, count);
            };

            Parallel.Invoke(actions);
        }
        private void WriteStorageEngineGetEnumeratorCommand(BinaryWriter writer, ICommand command)
        {
            var cmd = (StorageEngineGetEnumeratorCommand)command;

            if (cmd.Descriptions == null)
            {
                writer.Write(true);
            }
            else
            {
                writer.Write(false);

                int listCount = cmd.Descriptions.Count;
                CountCompression.Serialize(writer, (ulong)listCount);

                for (int i = 0; i < listCount; i++)
                {
                    SerializeDescriptor(writer, cmd.Descriptions[i]);
                }
            }
        }
Пример #30
0
        public static Locator Deserialize(BinaryReader reader)
        {
            //StructureType
            int structureType = reader.ReadByte();

            if (structureType == Locator.MIN.StructureType)
            {
                return(Locator.MIN);
            }

            //descriptor
            var descriptor = StructureDescriptor.Deserialize(reader);

            //Items
            string[] items = new string[CountCompression.Deserialize(reader)];
            for (int i = 0; i < items.Length; i++)
            {
                items[i] = reader.ReadString();
            }

            return(new Locator(structureType, descriptor, items));
        }