示例#1
0
        internal bool Delete(T id)
        {
            // write a delete record
            int rec = (int)_archive.Delete(id);

            _deleted.Set(true, rec);
            return(_index.RemoveKey(id));
        }
示例#2
0
        public bool DeleteKeyHF(string key)
        {
            lock (_lock)
            {
                int alloc;
                if (_keys.Get(key, out alloc))
                {
                    if (_isDirty == false)
                    {
                        WriteDirtyFile();
                    }

                    byte[]          keybytes = Helper.GetBytes(key);
                    AllocationBlock ab       = FillAllocationBlock(alloc);

                    ab.keylen = (byte)keybytes.Length;

                    _keys.RemoveKey(key);// remove key from index

                    // write ab
                    ab.deleteKey  = true;
                    ab.datalength = 0;

                    byte[] header = CreateAllocHeader(ab, keybytes);

                    _datastore.SeekBlock(ab.blocknumber);
                    _datastore.WriteBlockBytes(header, 0, header.Length);

                    // free old data blocks
                    _datastore.FreeBlocks(ab.Blocks);

                    return(true);
                }
            }
            return(false);
        }
示例#3
0
        private void RebuildDataFiles()
        {
            MGIndex <string> keys = null;

            try
            {
                // remove old free list
                if (File.Exists(_Path + "data.bmp"))
                {
                    File.Delete(_Path + "data.bmp");
                }

                _datastore = new StorageFileHF(Path.Combine(_Path, "data.mghf"), Global.HighFrequencyKVDiskBlockSize);
                _BlockSize = _datastore.GetBlockSize();
                if (File.Exists(_Path + "keys.idx"))
                {
                    _log.Debug("removing old keys index");
                    foreach (var f in Directory.GetFiles(_Path, "keys.*"))
                    {
                        File.Delete(f);
                    }
                }

                keys = new MGIndex <string>(_Path, "keys.idx", 255, /*Global.PageItemCount,*/ false);

                WAHBitArray visited = new WAHBitArray();

                int c = _datastore.NumberofBlocks();

                for (int i = 0; i < c; i++) // go through blocks
                {
                    if (visited.Get(i))
                    {
                        continue;
                    }
                    byte[] b    = _datastore.ReadBlockBytes(i, _blockheader.Length + 255);
                    int    bnum = Helper.ToInt32(b, 0);
                    if (bnum > 0) // check if a start block
                    {
                        visited.Set(i, true);
                        _datastore.FreeBlock(i); // mark as free
                        continue;
                    }

                    AllocationBlock ab = new AllocationBlock();
                    // start block found
                    int blocknumexpected = 0;

                    int             next     = ParseBlockHeader(ab, b, blocknumexpected);
                    int             last     = 0;
                    bool            freelast = false;
                    AllocationBlock old      = null;

                    if (keys.Get(ab.key, out last))
                    {
                        old      = this.FillAllocationBlock(last);
                        freelast = true;
                    }
                    blocknumexpected++;
                    bool failed = false;
                    if (ab.deleteKey == false)
                    {
                        while (next > 0) // read the blocks
                        {
                            ab.Blocks.Add(next);
                            b    = _datastore.ReadBlockBytes(next, _blockheader.Length + ab.keylen);
                            next = ParseBlockHeader(ab, b, blocknumexpected);
                            if (next == -1) // non matching block
                            {
                                failed = true;
                                break;
                            }
                            blocknumexpected++;
                        }
                    }
                    else
                    {
                        failed = true;
                        keys.RemoveKey(ab.key);
                    }
                    // new data ok
                    if (failed == false)
                    {
                        keys.Set(ab.key, ab.blocknumber); // valid block found
                        if (freelast)                     // free the old blocks
                        {
                            _datastore.FreeBlocks(old.Blocks);
                        }
                    }

                    visited.Set(i, true);
                }

                // all ok delete temp.$ file
                if (File.Exists(_Path + _dirtyFilename))
                {
                    File.Delete(_Path + _dirtyFilename);
                }
            }
            catch (Exception ex)
            {
                _log.Error(ex);
            }
            finally
            {
                _log.Debug("Shutting down files and index");
                _datastore.Shutdown();
                keys.SaveIndex();
                keys.Shutdown();
            }
        }