public ReadTree ( string treeName ) : Voron.Trees.Tree | ||
treeName | string | |
Результат | Voron.Trees.Tree |
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); }