C# Transaction.ReadTree方法代码示例

        public Searcher(FullTextIndex index)
        {
            _index = index;
            _tx = _index.StorageEnvironment.NewTransaction(TransactionFlags.Read);

            _docs = _tx.ReadTree("Docs");
        }

		private static void SetCurrentTopologyInternal(Topology currentTopology, long index, Transaction tx)
		{
			if (currentTopology.TopologyId == Guid.Empty)
				throw new InvalidOperationException("Cannot set topology with an empty TopologyId");

			var metadata = tx.ReadTree(MetadataTreeName);

			var current = metadata.Read("current-topology");
			metadata.Add("previous-topology", current == null ? "{}" : current.Reader.ToStringValue());
			metadata.Add("current-topology", JsonConvert.SerializeObject(currentTopology));
			metadata.Add("current-topology-index", EndianBitConverter.Little.GetBytes(index));
		}

		public static Tree GetTree(this StorageEnvironmentState state, Transaction tx, string treeName)
		{			
			if (String.IsNullOrEmpty(treeName))
				throw new InvalidOperationException("Cannot fetch tree with empty name");

            if (treeName.Equals(Constants.RootTreeName, StringComparison.InvariantCultureIgnoreCase))
                return state.Root;

            if (treeName.Equals(Constants.FreeSpaceTreeName, StringComparison.InvariantCultureIgnoreCase))
                return state.FreeSpaceRoot;

		    Tree tree = tx.ReadTree(treeName);

			if (tree != null)
				return tree;

			throw new InvalidOperationException("No such tree: " + treeName);			
		}

        public Tree GetTree(Transaction tx, string treeName)
        {
            if (String.IsNullOrEmpty(treeName))
                throw new InvalidOperationException("Cannot fetch tree with empty name");

            Tree tree = tx.ReadTree(treeName);

            if (tree != null)
                return tree;

            if (treeName.Equals(Constants.RootTreeName, StringComparison.InvariantCultureIgnoreCase))
                return Root;

            if (treeName.Equals(Constants.FreeSpaceTreeName, StringComparison.InvariantCultureIgnoreCase))
                return FreeSpaceRoot;

            if (tx.Flags == TransactionFlags.ReadWrite)
                return tx.Environment.CreateTree(tx, treeName, Options.ShouldUseKeyPrefix(treeName));

            throw new InvalidOperationException("No such tree: " + treeName);
        }

        public unsafe Tree CreateTree(Transaction tx, string name, bool keysPrefixing = false)
        {
            if (tx.Flags == (TransactionFlags.ReadWrite) == false)
                throw new ArgumentException("Cannot create a new tree with a read only transaction");

            Tree tree = tx.ReadTree(name);
            if (tree != null)
                return tree;


	        if (name.Equals(Constants.RootTreeName, StringComparison.InvariantCultureIgnoreCase) ||
	            name.Equals(Constants.FreeSpaceTreeName, StringComparison.InvariantCultureIgnoreCase))
		        throw new InvalidOperationException("Cannot create a tree with reserved name: " + name);


            Slice key = (Slice)name;

            // we are in a write transaction, no need to handle locks
            var header = (TreeRootHeader*)tx.State.Root.DirectRead(key);
            if (header != null)
            {
                tree = Tree.Open(tx, header);
                tree.Name = name;
                tx.AddTree(name, tree);
                return tree;
            }

            tree = Tree.Create(tx, keysPrefixing);
            tree.Name = name;
            var space = tx.State.Root.DirectAdd(key, sizeof(TreeRootHeader));

            tree.State.CopyTo((TreeRootHeader*)space);
            tree.State.IsModified = true;
            tx.AddTree(name, tree);

			if(IsDebugRecording)
				DebugJournal.RecordWriteAction(DebugActionType.CreateTree, tx, Slice.Empty,name,Stream.Null);

            return tree;
        }

	    public unsafe void RenameTree(Transaction tx, string fromName, string toName)
	    {
			if (tx.Flags == (TransactionFlags.ReadWrite) == false)
				throw new ArgumentException("Cannot rename a new tree with a read only transaction");

			if (toName.Equals(Constants.RootTreeName, StringComparison.InvariantCultureIgnoreCase) ||
				toName.Equals(Constants.FreeSpaceTreeName, StringComparison.InvariantCultureIgnoreCase))
				throw new InvalidOperationException("Cannot create a tree with reserved name: " + toName);

		    if (tx.ReadTree(toName) != null)
			    throw new ArgumentException("Cannot rename a tree with the name of an existing tree: " + toName);

		    Tree fromTree = tx.ReadTree(fromName);
		    if (fromTree == null)
			    throw new ArgumentException("Tree " + fromName + " does not exists");

            Slice key = (Slice)toName;

	        tx.State.Root.Delete((Slice)fromName);
			var ptr = tx.State.Root.DirectAdd(key, sizeof(TreeRootHeader));
		    fromTree.State.CopyTo((TreeRootHeader*) ptr);
		    fromTree.Name = toName;
		    fromTree.State.IsModified = true;
		    
			tx.RemoveTree(fromName);
			tx.RemoveTree(toName);

			tx.AddTree(toName, fromTree);

			if (IsDebugRecording)
                DebugJournal.RecordWriteAction(DebugActionType.RenameTree, tx, (Slice)toName, fromName, Stream.Null);
	    }

	    public void DeleteTree(Transaction tx, string name)
        {
            if (tx.Flags == (TransactionFlags.ReadWrite) == false)
                throw new ArgumentException("Cannot create a new newRootTree with a read only transaction");

	        Tree tree = tx.ReadTree(name);
	        if (tree == null)
	            return;

            foreach (var page in tree.AllPages())
            {
                tx.FreePage(page);
            }

            tx.State.Root.Delete((Slice) name);

            tx.RemoveTree(name);
        }

        private void ReplayWriteAction(WriteActivityEntry activityEntry, ref Transaction tx)
        {
            var tree = tx.ReadTree(activityEntry.TreeName);

            switch (activityEntry.ActionType)
            {
                case DebugActionType.Add:
                    tree.Add(activityEntry.Key, activityEntry.ValueStream);
                    break;
                case DebugActionType.Delete:
                    tree.Delete(activityEntry.Key);
                    break;
                case DebugActionType.MultiAdd:
                    tree.MultiAdd(activityEntry.Key, new Slice(Encoding.UTF8.GetBytes(activityEntry.Value.ToString())));
                    break;
                case DebugActionType.MultiDelete:
                    tree.MultiDelete(activityEntry.Key, new Slice(Encoding.UTF8.GetBytes(activityEntry.Value.ToString())));
                    break;
                case DebugActionType.CreateTree:
                    _env.CreateTree(tx, activityEntry.TreeName);
                    break;
                case DebugActionType.Increment:
                    var buffer = new byte[sizeof(long)];
                    activityEntry.ValueStream.Read(buffer, 0, buffer.Length);
                    var delta = EndianBitConverter.Little.ToInt64(buffer, 0);
                    tree.Increment(activityEntry.Key, delta);
                    break;
                case DebugActionType.AddStruct:
                    tree.Add(activityEntry.Key, activityEntry.ValueStream);
                    break;
                case DebugActionType.RenameTree:
                    _env.RenameTree(tx, activityEntry.TreeName, activityEntry.Key.ToString());
                    break;
                default: //precaution against newly added action types
                    throw new InvalidOperationException("unsupported tree action type: " + activityEntry.ActionType);
            }
        }

        public StorageReport GenerateReport(Transaction tx, bool computeExactSizes = false)
        {
            var numberOfAllocatedPages = Math.Max(_dataPager.NumberOfAllocatedPages, NextPageNumber - 1); // async apply to data file task
            var numberOfFreePages = _freeSpaceHandling.AllPages(tx).Count;

            var trees = new List<Tree>();
            using (var rootIterator = tx.Root.Iterate())
            {
                if (rootIterator.Seek(Slice.BeforeAllKeys))
                {
                    do
                    {
                        var tree = tx.ReadTree(rootIterator.CurrentKey.ToString());
                        trees.Add(tree);

                    }
                    while (rootIterator.MoveNext());
                }
            }

            var generator = new StorageReportGenerator(tx);

            return generator.Generate(new ReportInput
            {
                NumberOfAllocatedPages = numberOfAllocatedPages,
                NumberOfFreePages = numberOfFreePages,
                NextPageNumber = NextPageNumber,
                Journals = Journal.Files.ToList(),
                Trees = trees,
                IsLightReport = !computeExactSizes
            });
        }

        public unsafe Tree CreateTree(Transaction tx, string name, bool keysPrefixing = false)
        {
            Tree tree = tx.ReadTree(name);
            if (tree != null)
                return tree;

            if (name.Equals(Constants.RootTreeName, StringComparison.InvariantCultureIgnoreCase))
                return tx.Root;
            if (name.Equals(Constants.FreeSpaceTreeName, StringComparison.InvariantCultureIgnoreCase))
                return tx.FreeSpaceRoot;

            if (tx.Flags == (TransactionFlags.ReadWrite) == false)
                throw new InvalidOperationException("No such tree: " + name + " and cannot create trees in read transactions");

            Slice key = name;

            tree = Tree.Create(tx, keysPrefixing);
            tree.Name = name;
            var space = tx.Root.DirectAdd(key, sizeof(TreeRootHeader));

            tree.State.CopyTo((TreeRootHeader*)space);
            tree.State.IsModified = true;
            tx.AddTree(name, tree);

            if(IsDebugRecording)
                DebugJournal.RecordWriteAction(DebugActionType.CreateTree, tx, Slice.Empty,name,Stream.Null);

            return tree;
        }

		private static LogEntry GetLastLogEntryFromSnapshot(Transaction tx)
		{
			var metadata = tx.ReadTree(MetadataTreeName);
			// maybe there is a snapshot?
			var snapshotTerm = metadata.Read("snapshot-term");
			var snapshotIndex = metadata.Read("snapshot-index");

			if (snapshotIndex == null || snapshotTerm == null)
				return new LogEntry();

			return new LogEntry
			{
				Term = snapshotTerm.Reader.ReadLittleEndianInt64(),
				Index = snapshotIndex.Reader.ReadLittleEndianInt64()
			};
		}

		private static long GetLastEntryNumber(Tree logs, Transaction tx)
		{
			long lastEntry;
			var lastKey = logs.LastKeyOrDefault();
			if (lastKey != null)
			{
				lastEntry = lastKey.CreateReader().ReadBigEndianInt64();
			}
			else
			{
				var metadata = tx.ReadTree(MetadataTreeName);
				// maybe there is a snapshot?
				var snapshotIndex = metadata.Read("snapshot-index");
				if (snapshotIndex != null)
					lastEntry = snapshotIndex.Reader.ReadLittleEndianInt64();
				else
					lastEntry = 0;
			}
			return lastEntry;
		}

        public unsafe Tree CreateTree(Transaction tx, string name)
        {
            if (tx.Flags == (TransactionFlags.ReadWrite) == false)
                throw new ArgumentException("Cannot create a new tree with a read only transaction");

            Tree tree = tx.ReadTree(name);
            if (tree != null)
                return tree;

            Slice key = name;

            // we are in a write transaction, no need to handle locks
            var header = (TreeRootHeader*)tx.State.Root.DirectRead(key);
            if (header != null)
            {
                tree = Tree.Open(tx, _sliceComparer, header);
                tree.Name = name;
                tx.AddTree(name, tree);
                return tree;
            }

            tree = Tree.Create(tx, _sliceComparer);
            tree.Name = name;
            var space = tx.State.Root.DirectAdd(key, sizeof(TreeRootHeader));

            tree.State.CopyTo((TreeRootHeader*)space);
            tree.State.IsModified = true;
            tx.AddTree(name, tree);

			if(IsDebugRecording)
				DebugJournal.RecordAction(DebugActionType.CreateTree, Slice.Empty,name,Stream.Null);

            return tree;
        }

 public static void RenderFreeSpace(Transaction tx)
 {
     RenderAndShow(tx, tx.ReadTree(tx.Environment.State.FreeSpaceRoot.Name).State.RootPageNumber, 1);
 }