예제 #1
0
 internal BPlusTreeNode(BPlusTree <TKey, TValue> tree, BPlusTreeIndexNode <TKey, TValue> parent)
 {
     Tree     = tree;
     Keywords = new List <TKey>();
     Parent   = parent;
     IsLeaf   = false;
 }
        public BPlusTreeIndexNode <TKey, TValue> PromoteToIndexNode()
        {
            BPlusTreeIndexNode <TKey, TValue> indexNode = null;

            try {
                BPlusTree <TKey, TValue> .LogInfo("Begin promoting leaf node to index node: " + this.ToString());

                indexNode          = new BPlusTreeIndexNode <TKey, TValue>(this.Tree, this.Parent, null);
                indexNode.Location = this.Location;
                indexNode.SlotSize = this.SlotSize;
            } finally {
                BPlusTree <TKey, TValue> .LogInfo("End promoting leaf node to index node: " + this.ToString());
            }
            return(indexNode);
        }
        protected internal BPlusTreeIndexNode(BPlusTree <TKey, TValue> tree, BPlusTreeIndexNode <TKey, TValue> parent, BinaryReader rdr)
            : base(tree, parent)
        {
            IsLeaf         = false;
            ChildLocations = new List <long>();

            if (rdr != null)
            {
                // index nodes store only children locations (which are always longs)
                short childCount = rdr.ReadInt16();
                for (int i = 0; i < childCount; i++)
                {
                    ChildLocations.Add(rdr.ReadInt64());
                }
            }
        }
예제 #4
0
        private static BPlusTreeNode <TKey, TValue> processRead(BPlusTree <TKey, TValue> tree, BPlusTreeIndexNode <TKey, TValue> parent, BinaryReader rdr, object[] args)
        {
            // stream has been positioned appropriately.
            // just read from it.

            BPlusTreeNode <TKey, TValue> node = null;

            tree.Lock(delegate() {
                long startLocation = rdr.BaseStream.Position;
                int slotSize       = rdr.ReadInt32();
                bool leaf          = rdr.ReadBoolean();
                short keywordCount = rdr.ReadInt16();

                if (leaf)
                {
                    node = new BPlusTreeLeafNode <TKey, TValue>(tree, parent, rdr);
                }
                else
                {
                    node = new BPlusTreeIndexNode <TKey, TValue>(tree, parent, rdr);
                }
                node.Location = startLocation;

                // now we must read in all the keywords (they're always at the end of the stream)
                for (short i = 0; i < keywordCount; i++)
                {
                    TKey keyManager = new TKey();
                    keyManager.Read(rdr);
                    node.Keywords.Add(keyManager);
                }

                node.SlotSize = slotSize;

                // orient the stream pointer to the end of the node (which may be past the current data in it)
                rdr.BaseStream.Position = startLocation + node.SlotSize;
            });

            return(node);
        }
        protected internal BPlusTreeLeafNode(BPlusTree <TKey, TValue> tree, BPlusTreeIndexNode <TKey, TValue> parent, BinaryReader rdr)
            : base(tree, parent)
        {
            IsLeaf = true;
//			LeftSiblingLocation = -1;
            RightSiblingLocation = -1;
            Values = new List <TValue>();

            // leaves store only sibling locations and values (keywords are handled by the base, since they're in every kind of node)
            if (rdr != null)
            {
//				LeftSiblingLocation = rdr.ReadInt64();
                RightSiblingLocation = rdr.ReadInt64();
                short valueCount = rdr.ReadInt16();

                for (int i = 0; i < valueCount; i++)
                {
                    TValue val = new TValue();
                    val.Read(rdr);
                    Values.Add(val);
                }
            }
        }
        internal BPlusTreeNode <TKey, TValue> SplitChild(BPlusTreeNode <TKey, TValue> originalChild, out int keywordIndex)
        {
            // Split the current node into two nodes:
            //   a. Left node contains all pointers/keywords to the left of the median
            //   b. Right node contains all pointers/keywords to the right of the median
            //   c. Parent node gets median keyword pushed into it
            //
            // Disk-wise: the originalChild is always written back to its original position (since we're splitting it, it's guaranteed to get smaller)
            //            the newChild is placed into either an available abandoned node or tacked on the end of the file.
            //            the parent node is written back to its original position IF IT FITS.  Since we're coyping a keyword
            //               up into the parent node, it may cause it to outgrow its allocated size in the file.  If this occurs,
            //               the call to this.Write() implicitly calls relocate().  relocate() will then either write the parent to
            //               an abandoned node or tack it onto the end of the file.



            // first, determine the offset of the current originalchild in this (the parent)
            keywordIndex = 0;

            try {
                BPlusTree <TKey, TValue> .LogInfo("Begin splitting node=" + this.ToString() + ", child=" + originalChild.ToString());

                if (ChildLocations.Count > 0)
                {
                    // TODO: troubleshoot this -- after several thousand splits, originalChild.Location is no longer found in the ChildLocations array!!!
                    //if (LastChildLocation == originalChild.Location) {
                    //    // rightmost child, on a full node.
                    //} else {
                    while (keywordIndex < ChildLocations.Count && ChildLocations[keywordIndex] != originalChild.Location)
                    {
                        keywordIndex++;
                    }
                    //}
                }

                // assign the median keyword to the parent's Keywords list (inserts just before the current one)
                //if (keywordIndex > this.Keywords.Count) {
                //    // rightmost keyword, add to the end of the list
                //    this.Keywords.Add(originalChild.MedianKeyword);
                //} else {
                // not rightmost keyword, insert it at the proper position
                this.Keywords.Insert(keywordIndex, originalChild.MedianKeyword);
                //}

                if (originalChild.IsLeaf)
                {
                    // since this is a leaf, we will copy up the median keyword to the parent (as opposed to push up for index nodes)

                    // create a leaf node
                    BPlusTreeLeafNode <TKey, TValue> origNode = (BPlusTreeLeafNode <TKey, TValue>)originalChild;
                    BPlusTreeLeafNode <TKey, TValue> newNode  = new BPlusTreeLeafNode <TKey, TValue>(this.Tree, (BPlusTreeIndexNode <TKey, TValue>) this, null);

                    // copy right half of keywords + values from originalChild to newChild
                    newNode.Keywords.AddRange(origNode.Keywords.Skip(this.Tree.Median - 1));
                    newNode.Values.AddRange(origNode.Values.Skip(this.Tree.Median - 1));

                    // remove right half of keywords + values from originalChild
                    origNode.Keywords = origNode.Keywords.Take(this.Tree.Median - 1).ToList();
                    origNode.Values   = origNode.Values.Take(this.Tree.Median - 1).ToList();

                    var nextKeywordIndex = keywordIndex + 1;
                    Tree.Lock(delegate() {
                        // write out nodes so sibling locations can be set properly

                        // note: orig node should never relocate on write since we're making it smaller (moving 1/2 of its keywords to a new node)
                        if (origNode.Write())
                        {
                            BPlusTree <TKey, TValue> .LogInfo("orig leaf node relocated during split child: " + origNode.ToString());
                        }
                        if (newNode.Write())
                        {
                            BPlusTree <TKey, TValue> .LogInfo("new leaf node relocated during split child: " + newNode.ToString());
                        }

                        // adjust sibling locations (we always add the new child to the right of the original one)
                        newNode.RightSiblingLocation = origNode.RightSiblingLocation;
                        //				newNode.LeftSiblingLocation = origNode.Location;

                        origNode.RightSiblingLocation = newNode.Location;

                        ChildLocations.Insert(nextKeywordIndex, newNode.Location);

                        // write them out again so we save sibling locations
                        if (origNode.Write())
                        {
                            BPlusTree <TKey, TValue> .LogInfo("orig leaf node relocated on 2nd write during split child: " + origNode.ToString());
                        }
                        if (newNode.Write())
                        {
                            BPlusTree <TKey, TValue> .LogInfo("new leaf node relocated on 2nd write during split child: " + newNode.ToString());
                        }

                        // and write out the parent since it changed as well
                        if (Write())
                        {
                            BPlusTree <TKey, TValue> .LogInfo("parent of leaf node relocated during split child: " + this.ToString());
                        }
                    });

                    return(newNode);
                }
                else
                {
                    // since this is an index node, we push up the keyword to the parent (as opposed to copy up for leaves)
                    // this means the median keyword will be removed from the original child but not moved to the new child

                    // create an index node
                    BPlusTreeIndexNode <TKey, TValue> origNode = (BPlusTreeIndexNode <TKey, TValue>)originalChild;
                    BPlusTreeIndexNode <TKey, TValue> newNode  = new BPlusTreeIndexNode <TKey, TValue>(this.Tree, (BPlusTreeIndexNode <TKey, TValue>) this, null);

                    // copy right half of keywords + childlocations from originalChild to newChild
                    // (since this is an index node, skip the median keyword
                    newNode.Keywords.AddRange(origNode.Keywords.Skip(this.Tree.Median));
                    newNode.ChildLocations.AddRange(origNode.ChildLocations.Skip(this.Tree.Median));

                    // remove right half of keywords + childlocations from originalChild
                    // (note we stop one shy of the median keyword -- this is because the median keyword needs to be "pushed up"
                    //  on an index node split.  However, we don't drop the corresponding ChildLocation)
                    origNode.Keywords       = origNode.Keywords.Take(this.Tree.Median - 1).ToList();
                    origNode.ChildLocations = origNode.ChildLocations.Take(this.Tree.Median).ToList();

                    var ki = keywordIndex;
                    Tree.Lock(delegate() {
                        if (origNode.Write())
                        {
                            BPlusTree <TKey, TValue> .LogInfo("orig index node relocated during split child: " + origNode.ToString());
                        }
                        if (newNode.Write())
                        {
                            BPlusTree <TKey, TValue> .LogInfo("new index node relocated during split child: " + newNode.ToString());
                        }

                        // original node may have relocated on write...
                        ChildLocations[ki] = origNode.Location;

                        ChildLocations.Insert(ki + 1, newNode.Location);

                        // and write out the parent since it changed as well
                        if (Write())
                        {
                            BPlusTree <TKey, TValue> .LogInfo("parent of index node relocated during split child: " + this.ToString());
                        }
                    });

                    return(newNode);
                }
            } finally {
                BPlusTree <TKey, TValue> .LogInfo("End splitting node=" + this.ToString() + ", child=" + originalChild.ToString());
            }
        }
예제 #7
0
        protected BPlusTreeNode <TKey, TValue> GetRightSibling(bool mustHaveSameParent)
        {
            if (this.IsLeaf)
            {
                // use the rightsibling pointer
                BPlusTreeLeafNode <TKey, TValue> leaf = this as BPlusTreeLeafNode <TKey, TValue>;
                return(BPlusTreeNode <TKey, TValue> .Read(this.Tree, this.Parent, leaf.RightSiblingLocation));
            }
            else
            {
                // look in parent for our smallest keyword, grab childlocation to the left of it
                int parentChildCount;
                int childLocationIndex = GetIndexInParent(out parentChildCount);

                if (childLocationIndex == -1)
                {
                    // never found the index, or no parent (aka root). No sibling to return.
                    return(null);
                }
                else
                {
                    if (childLocationIndex < parentChildCount - 1)
                    {
                        // we know the right sibling is attached to the same parent.
                        BPlusTreeNode <TKey, TValue> node = BPlusTreeNode <TKey, TValue> .Read(this.Tree, this.Parent, Parent.ChildLocations[childLocationIndex + 1]);

                        return(node);
                    }
                    else
                    {
                        // we are the rightmost child, as we're at the location that's 1 past the fanout size
                        if (mustHaveSameParent)
                        {
                            // caller wants the sibling only if it's from the same parent, and it's not.
                            return(null);
                        }
                        else
                        {
                            // we have to find the common ancestor between this and its right sibling.
                            // spin up until we find the first node whose child index is <= Fanoutsize
                            // then drill down the leftmost path until we're at the same depth as we started at
                            int i = 0;
                            int nodeChildLocationIndex        = -1;
                            BPlusTreeNode <TKey, TValue> node = this;
                            while (node.Parent != null)
                            {
                                i++;

                                // keep bubbling up until we're at a node whose parent has at least one child to our right.
                                nodeChildLocationIndex = node.GetIndexInParent(out parentChildCount);
                                if (nodeChildLocationIndex < parentChildCount - 1)
                                {
                                    // this node is not the rightmost child of its parent.
                                    // we're done bubbling (node contains the ancestor node, nodeChildLocationIndex can tell us the subtree to search down)
                                    break;
                                }
                                else
                                {
                                    node = node.Parent;
                                }
                            }

                            if (nodeChildLocationIndex == parentChildCount - 1)
                            {
                                // the only common ancestor has our node being the rightmost node in the tree (at this depth).
                                return(null);
                            }


                            // ok, node contains the ancestor somehwere up the tree that has the node we're looking for as its
                            // leftmost descendent at the same depth.
                            // So we just keep drilling down the leftmost path until we're at the same depth.
                            node = BPlusTreeNode <TKey, TValue> .Read(this.Tree, node as BPlusTreeIndexNode <TKey, TValue>, nodeChildLocationIndex + 1);

                            while (i > 0)
                            {
                                BPlusTreeIndexNode <TKey, TValue> indexNode = node as BPlusTreeIndexNode <TKey, TValue>;
                                node = BPlusTreeNode <TKey, TValue> .Read(this.Tree, indexNode, indexNode.ChildLocations[0]);

                                i--;
                            }

                            // node now contains the right sibling!
                            return(node);
                        }
                    }
                }



                //// bounce up to the parent
                //if (Parent != null) {
                //    TKey ourKey = FirstKeyword;
                //    for (int i=0; i < Parent.Keywords.Count; i++) {
                //        TKey parentKeyword = Parent.Keywords[i];
                //        if (parentKeyword.CompareTo(ourKey, KeywordMatchMode.ExactMatch, false) == 0) {
                //            // follow right child
                //            BPlusTreeNode<TKey, TValue> node = BPlusTreeNode<TKey, TValue>.Read(this.Tree, this.Parent, Parent.ChildLocations[i+1]);
                //            return node;
                //        }
                //    }
                //}
                //return null;
            }
        }
예제 #8
0
        protected BPlusTreeNode <TKey, TValue> GetLeftSibling(bool mustHaveSameParent)
        {
            // look in parent for our smallest keyword, grab childlocation to the left of it

            int parentChildCount;
            int childLocationIndex = GetIndexInParent(out parentChildCount);

            if (childLocationIndex == -1)
            {
                // never found the index, or no parent (aka root). No sibling to return.
                return(null);
            }
            else
            {
                if (childLocationIndex == 0)
                {
                    if (mustHaveSameParent)
                    {
                        // caller wants the sibling only if it's from the same parent, and it's not.
                        return(null);
                    }
                    else
                    {
                        // we have to find the parent of our left sibling.
                        // spin up until we find the first node whose child index is > 0
                        // then drill down the rightmost path until we're at the same depth as we started at
                        int i = 0;
                        int nodeChildLocationIndex        = -1;
                        BPlusTreeNode <TKey, TValue> node = this;
                        while (node.Parent != null)
                        {
                            i++;

                            // keep bubbling up until we're at a node whose parent has at least one child to our left.
                            nodeChildLocationIndex = node.GetIndexInParent(out parentChildCount);
                            if (nodeChildLocationIndex > 0)
                            {
                                // this node is not the leftmost child of its parent.
                                // we're done bubbling (node contains the ancestor node, nodeChildLocationIndex can tell us the subtree to search down)
                                break;
                            }
                            else
                            {
                                node = node.Parent;
                            }
                        }

                        if (nodeChildLocationIndex == 0)
                        {
                            // the only common ancestor has our node being the leftmost node in the tree (at this depth).
                            return(null);
                        }

                        // ok, node contains the ancestor somehwere up the tree that has the node we're looking for as its
                        // rightmost descendent at the same depth.
                        // So we just keep drilling down until we're at the same depth.
                        node = BPlusTreeNode <TKey, TValue> .Read(this.Tree, node as BPlusTreeIndexNode <TKey, TValue>, nodeChildLocationIndex - 1);

                        while (i > 0)
                        {
                            BPlusTreeIndexNode <TKey, TValue> indexNode = node as BPlusTreeIndexNode <TKey, TValue>;
                            node = BPlusTreeNode <TKey, TValue> .Read(this.Tree, indexNode, indexNode.LastChildLocation);

                            i--;
                        }

                        // node now contains the left sibling!
                        return(node);
                    }
                }
                else
                {
                    // we know the left sibling is attached to the same parent.
                    BPlusTreeNode <TKey, TValue> node = BPlusTreeNode <TKey, TValue> .Read(this.Tree, this.Parent, Parent.ChildLocations[childLocationIndex - 1]);

                    return(node);
                }
            }
        }
예제 #9
0
        /// <summary>
        /// Factory method for reading data from the tree's stream and returning either a BPlusTreeIndexNode or BPlusTreeLeafNode object
        /// </summary>
        /// <param name="tree"></param>
        /// <param name="location"></param>
        /// <returns></returns>
        internal static BPlusTreeNode <TKey, TValue> Read(BPlusTree <TKey, TValue> tree, BPlusTreeIndexNode <TKey, TValue> parent, long location)
        {
            if (location < 1)
            {
                return(null);
            }

            BPlusTreeNode <TKey, TValue> node = null;

            if (!tree.NodeCache.TryGetValue(location, out node))
            {
                node = tree.ReadNodeFromDisk(parent, processRead, location, null);
            }
            return(node);
        }