Esempio n. 1
0
 /// <summary>
 /// Return the vertices adjacent to the vertex according to the provided direction and edge labels.
 /// This method does not remove duplicate vertices (i.e. those vertices that are connected by more than one edge).
 /// </summary>
 /// <param name="direction">the direction of the edges of the adjacent vertices</param>
 /// <param name="labels">the labels of the edges of the adjacent vertices</param>
 /// <returns>an IEnumerable of adjacent vertices</returns>
 public IEnumerable <IVertex> GetVertices(Direction direction, params string[] labels)
 {
     if (labels.Length == 0)
     {
         HashSet <EdgeType> edgeTypes = new HashSet <EdgeType>();
         foreach (Edge edge in GetEdges(direction, labels))
         {
             edgeTypes.Add(edge.EdgeType);
         }
         foreach (EdgeType edgeType in edgeTypes)
         {
             foreach (IVertex vertex in m_vertexType.GetVertices(edgeType, this, direction))
             {
                 yield return(vertex);
             }
         }
     }
     else
     {
         foreach (string label in labels)
         {
             EdgeType edgeType = Graph.FindEdgeType(label);
             foreach (IVertex vertex in m_vertexType.GetVertices(edgeType, this, direction))
             {
                 yield return(vertex);
             }
         }
     }
 }
Esempio n. 2
0
 /// <summary>
 /// numerates all elements satisfying the given condition for the given property and value range
 /// </summary>
 /// <param name="property">Property we are looking for</param>
 /// <param name="condition"> filter function, applied with in graph value as 1st parameter, lower as 2nd and higher as 3rd parameter.</param>
 /// <param name="lower">lower value in filtering</param>
 /// <param name="higher">higher value in filtering</param>
 /// <returns></returns>
 public IEnumerable <IElement> Select(PropertyType property, Func <IComparable, IComparable, IComparable, Boolean> condition, IComparable lower, IComparable higher)
 {
     if (property.IsVertexProperty)
     {
         VertexType vt = vertexType[property.TypeId];
         foreach (Vertex vertex in vt.GetVertices())
         {
             IComparable v = property.GetPropertyValue(vertex.VertexId);
             if (condition(v, lower, higher))
             {
                 yield return(vertex);
             }
         }
     }
     else
     {
         EdgeType et = edgeType[property.TypeId];
         foreach (Edge edge in et.GetEdges())
         {
             IComparable v = property.GetPropertyValue(edge.EdgeId);
             if (condition(v, lower, higher))
             {
                 yield return(edge);
             }
         }
     }
 }
        static void QueryGraph()
        {
            using (SessionNoServer session = new SessionNoServer(systemDir))
            {
                // Start a read only transaction
                session.BeginRead();
                Graph g = Graph.Open(session);
                // Cache SCHEMA
                VertexType   movieType      = g.FindVertexType("Movie");
                PropertyType movieTitleType = movieType.FindProperty("title");
                VertexType   actorType      = g.FindVertexType("Actor");
                PropertyType actorNameType  = actorType.FindProperty("name");

                // How many vertices do we have?
                Console.WriteLine("Number of Vertices: " + g.CountVertices());

                // Find a movie by name
                Vertex movie = movieTitleType.GetPropertyVertex("The Matrix");

                // Get all actors
                var actors = actorType.GetVertices();

                // Count the actors
                int actorCount = actors.Count();
                Console.WriteLine("Number of Actors: " + actorCount);

                // Get only the actors whose names end with “s”
                foreach (Vertex vertex in actors)
                {
                    string actorName = (string)actorNameType.GetPropertyValue(vertex.VertexId);
                    if (actorName.EndsWith("s"))
                    {
                        Console.WriteLine("Found actor with name ending with \"s\" " + actorName);
                    }
                }

                // Get a count of property types
                var properties = session.AllObjects <PropertyType>();
                Console.WriteLine("Number of Property types: " + properties.Count());

                // All vertices and their edges
                var edges     = g.GetEdges();
                int edgeCount = edges.Count();
                g.ExportToGraphJson("c:/QuickStart.json");
                string exported;
                using (MemoryStream ms = new MemoryStream())
                {
                    g.ExportToGraphJson(ms);
                    exported = Encoding.UTF8.GetString(ms.ToArray());
                }
                session.Commit();
            }
        }
Esempio n. 4
0
 /// <summary>
 /// Removes a <see cref="VertexType"/> from this graph. An exception is thrown if the <see cref="VertexType"/> is in use.
 /// </summary>
 /// <param name="type">a <see cref="VertexType"/> instance</param>
 public void RemoveVertexType(VertexType type)
 {
     if (type.GetVertices().ElementAtOrDefault(0) != null)
     {
         throw new VertexTypeInUseException();
     }
     if (type.subType.Count > 0)
     {
         throw new VertexTypeInUseException();
     }
     type.Unpersist(Session);
 }
Esempio n. 5
0
 protected override void LoadChildren()
 {
     if (_vertexType != null)
     {
         m_session.LoadFields(_vertexType);
         foreach (var vertex in _vertexType.GetVertices())
         {
             base.Children.Add(new VertexViewModel(vertex, this, m_session));
         }
         foreach (var pt in _vertexType.GetPropertyTypes())
         {
             base.Children.Add(new PropertyTypeViewModel(pt, this, m_session));
         }
     }
 }
Esempio n. 6
0
 /// <summary>
 /// Removes a property type except if any vertex or edge is using it
 /// </summary>
 /// <param name="pt">property type to remove</param>
 public void RemovePropertyType(PropertyType pt)
 {
     if (pt.IsVertexProperty)
     {
         VertexType vt = vertexType[pt.TypeId];
         foreach (Vertex vertex in vt.GetVertices())
         {
             IComparable v = pt.GetPropertyValue(vertex.VertexId);
             if (v != null)
             {
                 throw new PropertyTypeInUseException();
             }
         }
     }
     else
     {
         EdgeType et = edgeType[pt.TypeId];
         foreach (Edge edge in et.GetEdges())
         {
             IComparable v = pt.GetPropertyValue(edge.EdgeId);
             if (v != null)
             {
                 throw new PropertyTypeInUseException();
             }
         }
     }
     if (pt.IsVertexProperty)
     {
         VertexType vt = vertexType[pt.TypeId];
         vt.stringToPropertyType.Remove(pt.Name);
     }
     else
     {
         EdgeType et = edgeType[pt.TypeId];
         et.stringToPropertyType.Remove(pt.Name);
     }
     Update();
     propertyType[pt.PropertyId] = null;
     pt.Unpersist(Session, true);
 }
Esempio n. 7
0
        static void Main(string[] args)
        {
            bool import   = args.Length > 0 && args[0].ToLower() == "-import";
            bool dirExist = Directory.Exists(s_systemDir);

            SessionBase.ClearAllCachedObjectsWhenDetectingUpdatedDatabase = false;
            if (import || !dirExist)
            {
                if (dirExist)
                {
                    Directory.Delete(s_systemDir, true); // remove systemDir from prior runs and all its databases.
                }
                Directory.CreateDirectory(s_systemDir);
                using (SessionNoServer session = new SessionNoServer(s_systemDir))
                {
                    DataCache.MaximumMemoryUse = 12000000000;        // 12 GB, set this to what fits your case
                    SessionBase.BTreeAddFastTransientBatchSize = 10; // reduces memory usage
                    Vertex[] ratingVertices = new Vertex[10];
                    session.BeginUpdate();
                    session.DefaultDatabaseLocation().CompressPages = PageInfo.compressionKind.LZ4;
                    Graph g = new Graph(session);

                    // SCHEMA
                    VertexType   userType   = g.NewVertexType("User");
                    PropertyType genderType = userType.NewProperty("Gender", DataType.Integer, PropertyKind.Indexed);

                    VertexType   ratingType = g.NewVertexType("Rating");
                    PropertyType ratingValuePropertyType = ratingType.NewProperty("RatingValue", DataType.Integer, PropertyKind.Indexed);

                    EdgeType ratingEdgeType = g.NewEdgeType("UserToRating", true, userType, ratingType);

                    EdgeType     ratingOfType           = g.NewEdgeType("RatingOf", false, userType, userType);
                    PropertyType ratingEdgePropertyType = ratingOfType.NewProperty("Rating", DataType.Integer, PropertyKind.Indexed);

                    // DATA
                    using (FileStream stream = File.OpenRead(System.IO.Path.Combine(s_inputDataDir, "gender.dat")))
                    {
                        using (StreamReader file = new System.IO.StreamReader(stream))
                        {
                            string line;
                            int    lineNumber = 0;
                            while ((line = file.ReadLine()) != null)
                            {
                                lineNumber++;
                                string[] fields = line.Split(',');
                                Vertex   aUser  = userType.NewVertex();
                                aUser.SetProperty(genderType, (int)fields[1][0] == 'M' ? Gender.Male : fields[1][0] == 'F' ? Gender.Female : Gender.Unknown);
                            }
                            Console.WriteLine("Done importing " + lineNumber + " users");
                        }
                    }

                    using (FileStream stream = File.OpenRead(System.IO.Path.Combine(s_inputDataDir, "ratings.dat")))
                    {
                        using (StreamReader file = new System.IO.StreamReader(stream))
                        {
                            string line;
                            int    lineNumber = 0;
                            Vertex rater      = null;
                            int    raterId;
                            int    priorRaterId = -1;

                            while ((line = file.ReadLine()) != null)
                            {
                                lineNumber++;
                                if (lineNumber % 1000000 == 0)
                                {
                                    Console.WriteLine("Parsing rating # " + lineNumber);
                                }
                                string[] fields = line.Split(',');
                                raterId = int.Parse(fields[0]);
                                if (raterId != priorRaterId)
                                {
                                    rater = userType.GetVertex(raterId);
                                }
                                priorRaterId = raterId;
                                int    ratedId      = int.Parse(fields[1]);
                                int    rating       = int.Parse(fields[2]);
                                Vertex ratingVertex = ratingVertices[rating - 1];
                                if (ratingVertex == null)
                                {
                                    ratingVertex = ratingType.NewVertex();
                                    ratingVertex.SetProperty(ratingValuePropertyType, rating);
                                    ratingVertices[rating - 1] = ratingVertex;
                                }
                                Vertex rated     = userType.GetVertex(ratedId);
                                Edge   aRatingOf = ratingOfType.NewEdge(rater, rated);
                                aRatingOf.SetProperty(ratingEdgePropertyType, rating);
                                Edge userRating = ratingEdgeType.NewEdge(rated, ratingVertex);
                            }
                            Console.WriteLine("Done importing " + lineNumber + " ratings");
                        }
                    }
                    session.Commit();
                }
            }
            // Query
            using (SessionNoServer session = new SessionNoServer(s_systemDir))
            {
                session.BeginRead();
                Graph        g          = Graph.Open(session);
                VertexType   userType   = g.FindVertexType("User");
                PropertyType genderType = userType.FindProperty("Gender");

                VertexType   ratingType = g.FindVertexType("Rating");
                PropertyType ratingValuePropertyType = ratingType.FindProperty("RatingValue");

                EdgeType ratingEdgeType = g.FindEdgeType("UserToRating");

                EdgeType     ratingOfType           = g.FindEdgeType("RatingOf");
                PropertyType ratingEdgePropertyType = ratingOfType.FindProperty("Rating");
                // Complex queries
                int ct = 0;

// Given a user id, and based on the rated profiles, find other users who have rated similarly on the same profiles, and find other profiles to recommend based on what those other users have rated
                Vertex someUser       = userType.GetVertex(1);
                var    similarRatings = (from Edge e in someUser.GetEdges(ratingOfType, Direction.Out)
                                         from Edge edge in e.Head.GetEdges(ratingOfType, Direction.Out)
                                         where someUser != edge.Head
                                         where ((int)e.GetProperty(ratingEdgePropertyType) == (int)edge.GetProperty(ratingEdgePropertyType))
                                         select edge.Tail).Distinct();

                var someUserRated = from Edge e in someUser.GetEdges(ratingOfType, Direction.Out)
                                    select e.Head;

                var recommendedProfles = from v in similarRatings
                                         from Edge e in v.GetEdges(ratingOfType, Direction.Out)
                                         where someUserRated.Contains(e.Head) == false
                                         select e.Head;

                Console.WriteLine("Some user's rated profiles");
                ct = 0;
                foreach (Vertex v in someUserRated)
                {
                    if (ct++ % 50 == 0) // don't print them all !
                    {
                        Console.WriteLine("User id: " + v.VertexId);
                    }
                }
                Console.WriteLine("Number of some user's rated profiles: " + ct);

                Console.WriteLine("Given a user id, and based on the rated profiles, find other users who have rated similarly on the same profiles");
                ct = 0;
                foreach (Vertex v in similarRatings)
                {
                    if (ct++ % 50 == 0) // don't print them all !
                    {
                        Console.WriteLine("User id: " + v.VertexId);
                    }
                }
                Console.WriteLine("Number of matching profiles: " + ct);

                Console.WriteLine("Given a user id, and based on the rated profiles, find other users who have rated similarly on the same profiles, and find other profiles to recommend based on what those other users have rated");
                ct = 0;
                foreach (Vertex v in recommendedProfles)
                {
                    if (ct++ % 5000 == 0) // don't print them all !
                    {
                        Console.WriteLine("User id: " + v.VertexId);
                    }
                }
                Console.WriteLine("Number of matching profiles: " + ct);

// Get all female users with less than 50 ratings
                Console.WriteLine();
                var females = from u in userType.GetVertices()
                              where ((Gender)u.GetProperty(genderType)) == Gender.Female
                              select u;
                var femalesLess50Ratings = from f in females
                                           where f.GetNumberOfEdges(ratingEdgeType, Direction.Out) < 50
                                           select f;
                Console.WriteLine("Female users with less than 50 ratings");
                ct = 0;
                foreach (Vertex f in femalesLess50Ratings)
                {
                    long count = f.GetNumberOfEdges(ratingEdgeType, Direction.Out);
                    if (ct++ % 5000 == 0) // don't print them all !
                    {
                        Console.WriteLine("User id: " + f.VertexId + "\tnumber of ratings: " + count);
                    }
                }
                Console.WriteLine("Number of females with fewer than 50 ratings: " + ct);
                Console.WriteLine();

// Get all male users with at least one 10 rating
                Console.WriteLine();
                var rated10vertex = (from v in ratingType.GetVertices()
                                     where ((int)v.GetProperty(ratingValuePropertyType)) == 10
                                     select v).First();

                var rated10 = (from e in rated10vertex.GetEdges(ratingEdgeType, Direction.In)
                               select e.GetVertex(Direction.Out)).Distinct();

                var rated10male = from Vertex v in rated10
                                  where ((Gender)v.GetProperty(genderType)) == Gender.Male
                                  select v;

                Console.WriteLine("Males with at least one 10 rating");
                ct = 0;
                foreach (Vertex v in rated10male)
                {
                    if (ct++ % 5000 == 0) // don't print them all !
                    {
                        Console.WriteLine("User id: " + v.VertexId);
                    }
                }
                Console.WriteLine("Number of males with at least one 10 rating: " + ct);
                Console.WriteLine();

// Get the first 10 male users who have rated at least 3 of the same profiles as the given user.
                Console.WriteLine("10 male users who have rated at least 3 of the same profiles as the given user");
                var males = from u in userType.GetVertices()
                            where ((Gender)u.GetProperty(genderType)) == Gender.Male
                            select u;

                var someUserHasRated = from Edge o in someUser.GetEdges(ratingOfType, Direction.Out)
                                       select o.Head;

                var first10withSame3ratedAs = from m in males
                                              where (from Edge r in m.GetEdges(ratingOfType, Direction.Out) select r.Head).Intersect(someUserHasRated).ToArray().Length >= 3
                                              select m;
                ct = 0;
                foreach (Vertex v in first10withSame3ratedAs)
                {
                    if (++ct > 10)
                    {
                        break;
                    }
                    Console.WriteLine("User id: " + v.VertexId);
                }
                Console.WriteLine();

                // Statistical queries
// Get the 20 profiles with the most ratings
                var top20mostRatings = (from v in userType.GetVertices()
                                        orderby v.GetNumberOfEdges(ratingEdgeType, Direction.Out) descending
                                        select v).Take(20);
                Console.WriteLine("20 profiles with the most ratings");
                ct = 0;
                foreach (Vertex v in top20mostRatings)
                {
                    int count = (int)v.GetNumberOfEdges(ratingEdgeType, Direction.Out);
                    Console.WriteLine("User id: " + v.VertexId + "\tnumber of ratings: " + count);
                }
                Console.WriteLine();

                var ratingsVertexEnum = from v in ratingType.GetVertices() orderby v.GetProperty(ratingValuePropertyType) descending select v;

                Vertex rating10Vertex = ratingsVertexEnum.First();
// Get the 20 best rated profiles regardless of gender
                var top = from u in userType.GetVertices()
                          let edgeCt = u.GetNumberOfEdges(ratingEdgeType, rating10Vertex, Direction.Out)
                                       orderby edgeCt descending
                                       select new { u, edgeCt };

                Console.WriteLine("20 best rated profiles regardless of gender");
                ct = 0;
                foreach (var v in top)
                {
                    if (++ct > 20)
                    {
                        break;
                    }
                    Console.WriteLine("User id: " + v.u.VertexId + "\t10 ratings: " + v.edgeCt);
                }
                Console.WriteLine();

// Get the 20 best rated males
                Console.WriteLine("20 best rated male profiles");
                var top20males = from u in userType.GetVertices()
                                 where ((Gender)u.GetProperty(genderType)) == Gender.Male
                                 let edgeCt = u.GetNumberOfEdges(ratingEdgeType, rating10Vertex, Direction.Out)
                                              orderby edgeCt descending
                                              select new { u, edgeCt };

                ct = 0;
                foreach (var v in top20males)
                {
                    if (++ct > 20)
                    {
                        break;
                    }
                    Console.WriteLine("Male User id: " + v.u.VertexId + " \t10 ratings: " + v.edgeCt);
                }
                Console.WriteLine();

// Get the 20 best rated females
                Console.WriteLine("20 best rated female profiles");
                var top20females = from u in userType.GetVertices()
                                   where ((Gender)u.GetProperty(genderType)) == Gender.Female
                                   let edgeCt = u.GetNumberOfEdges(ratingEdgeType, rating10Vertex, Direction.Out)
                                                orderby edgeCt descending
                                                select new { u, edgeCt };
                ct = 0;
                foreach (var v in top20females)
                {
                    if (++ct > 20)
                    {
                        break;
                    }
                    Console.WriteLine("Female User id: " + v.u.VertexId + "\t10 ratings: " + v.edgeCt);
                }
                session.Commit();
            }
        }
Esempio n. 8
0
        public void Create1Vertices(bool vertexIdSetPerVertexType)
        {
            DataCache.MaximumMemoryUse = 10000000000; // 10 GB
            bool dirExist = Directory.Exists(systemDir);

            try
            {
                if (Directory.Exists(systemDir))
                {
                    Directory.Delete(systemDir, true); // remove systemDir from prior runs and all its databases.
                }
                Directory.CreateDirectory(systemDir);
                File.Copy(licenseDbFile, Path.Combine(systemDir, "4.odb"));
            }
            catch
            {
                File.Copy(licenseDbFile, Path.Combine(systemDir, "4.odb"));
            }

            using (SessionNoServer session = new SessionNoServer(systemDir, 5000, false, true))
            {
                session.BeginUpdate();
                Graph g = new Graph(session, vertexIdSetPerVertexType);
                session.Persist(g);
                VertexType   userType               = g.NewVertexType("User");
                VertexType   otherType              = g.NewVertexType("Other");
                PropertyType userNamePropertyType   = g.NewVertexProperty(userType, "NAME", DataType.String, PropertyKind.Indexed);
                VertexType   powerUserType          = g.NewVertexType("PowerUser", userType);
                EdgeType     userFriendEdgeType     = g.NewEdgeType("Friend", true, userType, userType);
                EdgeType     userBestFriendEdgeType = g.NewEdgeType("Best Friend", true, userType, userType, userFriendEdgeType);
                EdgeType     otherEdgeType          = g.NewEdgeType("Other", true, userType, userType);
                PropertyType bestFriendPropertyType = g.NewEdgeProperty(userFriendEdgeType, "START", DataType.DateTime, PropertyKind.Indexed);
                Vertex       kinga      = userType.NewVertex();
                Vertex       robin      = userType.NewVertex();
                Vertex       mats       = powerUserType.NewVertex();
                Vertex       chiran     = powerUserType.NewVertex();
                Vertex       other      = otherType.NewVertex();
                Edge         bestFriend = kinga.AddEdge(userBestFriendEdgeType, robin);
                Edge         otherEdge  = kinga.AddEdge(otherEdgeType, robin);
                DateTime     now        = DateTime.Now;
                mats.SetProperty("Address", 1);
                bestFriend.SetProperty(bestFriendPropertyType, now);
                kinga.SetProperty(userNamePropertyType, "Kinga");
                if (g.VertexIdSetPerType == false)
                {
                    mats.SetProperty(userNamePropertyType, "Mats");
                }
                else
                {
                    try
                    {
                        mats.SetProperty(userNamePropertyType, "Mats");
                        Assert.Fail("Invalid property for VertexType not handled");
                    }
                    catch (Exception)
                    {
                    }
                }
                try
                {
                    other.SetProperty(userNamePropertyType, "Mats");
                    Assert.Fail("Invalid property for VertexType not handled");
                }
                catch (Exception)
                {
                }
                try
                {
                    otherEdge.SetProperty(bestFriendPropertyType, now);
                    Assert.Fail("Invalid property for VertexType not handled");
                }
                catch (Exception)
                {
                }
                Vertex findMats = userNamePropertyType.GetPropertyVertex("Mats", true);
                var    list     = userNamePropertyType.GetPropertyVertices("Mats", true).ToList();
                //Edge findWhen = bestFriendPropertyType.GetPropertyEdge(now);
                //var list2 = bestFriendPropertyType.GetPropertyEdges(now);
                Console.WriteLine(findMats);
                // session.Commit();
                // session.BeginRead();
                PropertyType adressProperty = g.FindVertexProperty(powerUserType, "Address");
                Vertex       find1          = adressProperty.GetPropertyVertex(1, true);
                session.Abort();

                /*session.BeginUpdate();
                 * g.Unpersist(session);
                 * session.Commit();
                 * dirExist = Directory.Exists(systemDir);
                 * try
                 * {
                 * if (Directory.Exists(systemDir))
                 *  Directory.Delete(systemDir, true); // remove systemDir from prior runs and all its databases.
                 * Directory.CreateDirectory(systemDir);
                 * File.Copy(licenseDbFile, Path.Combine(systemDir, "4.odb"));
                 * }
                 * catch
                 * {
                 * File.Copy(licenseDbFile, Path.Combine(systemDir, "4.odb"));
                 * }*/
            }

            using (SessionNoServer session = new SessionNoServer(systemDir, 5000, false, true))
            {
                session.BeginUpdate();
                session.DefaultDatabaseLocation().CompressPages = PageInfo.compressionKind.None;
                Graph g = new Graph(session, vertexIdSetPerVertexType);
                session.Persist(g);
                Graph g2 = new Graph(session);
                session.Persist(g2);
                Graph g3 = new Graph(session);
                session.Persist(g3);
                UInt32 dbNum = session.DatabaseNumberOf(typeof(Graph));
                Graph  g4    = (Graph)session.Open(dbNum, 2, 1, true); // g4 == g
                Graph  g5    = (Graph)session.Open(dbNum, 2, 2, true); // g5 == g2
                Graph  g6    = (Graph)session.Open(dbNum, 2, 3, true); // g6 == g3
                for (int i = 4; i < 8; i++)
                {
                    Graph gt = new Graph(session);
                    session.Persist(gt);
                }
                Graph     g7    = new Graph(session);
                Placement place = new Placement(dbNum, 15);
                session.Persist(place, g7);
                // SCHEMA
                VertexType userType     = g.NewVertexType("User");
                VertexType locationType = g.NewVertexType("Location");
                VertexType aVertexType  = g.NewVertexType("A");
                VertexType bVertexType  = g.NewVertexType("B");
                VertexType cVertexType  = g.NewVertexType("C");
                EdgeType   uEdge        = g.NewEdgeType("unrestricted", true);
                Vertex     aVertex      = g.NewVertex(aVertexType);
                Vertex     bVertex      = g.NewVertex(bVertexType);
                Vertex     cVertex      = g.NewVertex(cVertexType);
                Edge       abEdge       = (Edge)aVertex.AddEdge("unrestricted", bVertex);
                Edge       bcEdge       = (Edge)aVertex.AddEdge("unrestricted", cVertex);
                Dictionary <Vertex, HashSet <Edge> > traverse = aVertex.Traverse(uEdge, Direction.Out);
                abEdge.Remove();
                Dictionary <Vertex, HashSet <Edge> > traverse2 = aVertex.Traverse(uEdge, Direction.Out);

                EdgeType friendEdgeType       = g.NewEdgeType("Friend", true, userType, userType);
                EdgeType userLocationEdgeType = g.NewEdgeType("UserLocation", true, userType, locationType);

                // DATA
                Random rand = new Random(5);
                for (int i = 0; i < numberOfUserVertices / 100; i++)
                {
                    int vId = rand.Next(numberOfUserVertices);
                    try
                    {
                        if (g.VertexIdSetPerType)
                        {
                            userType.GetVertex(vId);
                        }
                        else
                        {
                            g.GetVertex(vId);
                        }
                        try
                        {
                            userType.NewVertex(vId);
                            Assert.Fail();
                        }
                        catch (VertexAllreadyExistException)
                        {
                        }
                    }
                    catch (VertexDoesNotExistException)
                    {
                        userType.NewVertex(vId);
                        userType.GetVertex(vId);
                    }
                }
                for (int i = 0; i < numberOfUserVertices / 10000; i++)
                {
                    int vId = rand.Next(numberOfUserVertices);
                    try
                    {
                        Vertex v = userType.GetVertex(vId);
                        v.SetProperty("test", 1);
                    }
                    catch (VertexDoesNotExistException)
                    {
                    }
                }
                for (int i = 0; i < numberOfUserVertices / 10000; i++)
                {
                    int vId = rand.Next(numberOfUserVertices);
                    try
                    {
                        Vertex v = userType.GetVertex(vId);
                        userType.RemoveVertex(v);
                    }
                    catch (VertexDoesNotExistException)
                    {
                    }
                }
                foreach (Vertex v in userType.GetVertices().ToArray())
                {
                    userType.RemoveVertex(v);
                }
                Assert.AreEqual(0, userType.GetVertices().Count());
                for (int i = 100000; i < numberOfUserVertices; i++)
                {
                    userType.NewVertex();
                }
                for (int i = 1; i < 100000; i++)
                {
                    userType.NewVertex();
                }
                for (int i = 1; i < numberOfLocationVertices; i++)
                {
                    locationType.NewVertex();
                }
                session.Commit();
                session.BeginRead();
                foreach (var x in session.AllObjects <BTreeSet <Range <VertexId> > >(false, true))
                {
                    Assert.True(x.ToDoBatchAddCount == 0);
                }
                foreach (var x in session.AllObjects <BTreeSet <EdgeType> >(false, true))
                {
                    Assert.True(x.ToDoBatchAddCount == 0);
                }
                foreach (var x in session.AllObjects <BTreeSet <EdgeIdVertexId> >(false, true))
                {
                    Assert.True(x.ToDoBatchAddCount == 0);
                }
                foreach (var x in session.AllObjects <BTreeMap <EdgeId, VelocityDbList <ElementId> > >(false, true))
                {
                    Assert.True(x.ToDoBatchAddCount == 0);
                }
                foreach (var x in session.AllObjects <BTreeMap <string, PropertyType> >(false, true))
                {
                    Assert.True(x.ToDoBatchAddCount == 0);
                }
                foreach (var x in session.AllObjects <BTreeMap <string, EdgeType> >(false, true))
                {
                    Assert.True(x.ToDoBatchAddCount == 0);
                }
                foreach (var x in session.AllObjects <BTreeMap <string, VertexType> >(false, true))
                {
                    Assert.True(x.ToDoBatchAddCount == 0);
                }
                foreach (var x in session.AllObjects <BTreeMap <VertexId, BTreeSet <EdgeIdVertexId> > >(false, true))
                {
                    Assert.True(x.ToDoBatchAddCount == 0);
                }
                foreach (var x in session.AllObjects <BTreeMap <VertexType, BTreeMap <VertexId, BTreeSet <EdgeIdVertexId> > > >(false, true))
                {
                    Assert.True(x.ToDoBatchAddCount == 0);
                }
                foreach (var x in session.AllObjects <BTreeMap <EdgeType, BTreeMap <VertexType, BTreeMap <VertexId, BTreeSet <EdgeIdVertexId> > > > >(false, true))
                {
                    Assert.True(x.ToDoBatchAddCount == 0);
                }
                session.Commit();
                Validate();
            }
        }