Beispiel #1
0
        /// <summary>
        /// Try to find all <see cref="Vertex"/> with a given property value.
        /// </summary>
        /// <param name="value">The property value to look for</param>
        /// <param name="polymorphic">If true, also look for property value matching vertices of property <see cref="VertexType"/> sub classes</param>
        /// <returns>Enumeration of matching vertices</returns>
        public IEnumerable <Vertex> GetPropertyVertices(T value, bool polymorphic = false)
        {
            VertexId   elementId  = -1;
            VertexType vertexType = MyGraph.VertexTypes[TypeId];

            if (m_valueIndexUnique == null || m_valueIndexUnique.TryGetValue(value, out elementId) == false)
            {
                BTreeSet <ElementId> elementIds;
                if (m_valueIndex != null && m_valueIndex.TryGetValue(value, out elementIds))
                {
                    foreach (ElementId eId in elementIds)
                    {
                        Vertex vertex = vertexType.GetVertex(eId, polymorphic, false);
                        if (vertex != null)
                        {
                            yield return(vertex);
                        }
                    }
                }
            }
            if (elementId != -1)
            {
                Vertex vertex = vertexType.GetVertex(elementId, polymorphic, false);
                if (vertex != null)
                {
                    yield return(vertex);
                }
            }
        }
        /// <summary>
        /// Gets an edge given an edge id. Throws if no such edge exist.
        /// </summary>
        /// <param name="edgeId">The id of the edge</param>
        /// <returns>The edge with matching id if it exists</returns>
        public Edge GetEdge(EdgeId edgeId)
        {
            if (Unrestricted)
            {
                UnrestrictedEdge headTail;
                if (m_unrestrictedEdges.TryGetValue(edgeId, out headTail))
                {
                    VertexType vt   = headTail.m_headVertexType;
                    Vertex     head = vt.GetVertex(headTail.m_headVertexId);
                    vt = headTail.m_tailVertexType;
                    Vertex tail = vt.GetVertex(headTail.m_tailVertexId);
                    return(new Edge(MyGraph, this, edgeId, head, tail));
                }
            }
            else
            {
                UInt64 vertexVertex;
                if (m_restrictedEdges.TryGetValue(edgeId, out vertexVertex))
                {
                    VertexId headId = (VertexId)(vertexVertex >> 32);
                    Vertex   head   = HeadType.GetVertex(headId);
                    Vertex   tail   = TailType.GetVertex((VertexId)vertexVertex);
                    return(new Edge(MyGraph, this, edgeId, head, tail));
                }
            }

            throw new EdgeDoesNotExistException();
        }
Beispiel #3
0
 /// <summary>
 /// Return the vertex referenced by the provided object identifier.
 /// If no vertex is referenced by that identifier, then return null.
 /// </summary>
 /// <param name="id">the identifier of the vertex to retrieved from the graph, must be a UInt64</param>
 /// <returns>the vertex referenced by the provided identifier or null when no such vertex exists</returns>
 public IVertex GetVertex(object id)
 {
     if (id == null)
     {
         throw new ArgumentException("id may not be null, it should be a UInt64");
     }
     if (id is UInt64)
     {
         UInt64       fullId       = (UInt64)id;
         VertexTypeId vertexTypeId = (VertexTypeId)(fullId >> 32);
         VertexType   vt           = vertexType[vertexTypeId];
         VertexId     vertexId     = (VertexId)fullId;
         Vertex       vertex       = vt.GetVertex(vertexId);
         return(vertex);
     }
     if (id is string)
     {
         UInt64 fullId;
         if (UInt64.TryParse(id as string, out fullId))
         {
             VertexTypeId vertexTypeId = (VertexTypeId)(fullId >> 32);
             VertexType   vt           = vertexType[vertexTypeId];
             VertexId     vertexId     = (VertexId)fullId;
             Vertex       vertex       = vt.GetVertex(vertexId);
             return(vertex);
         }
     }
     return(null);
 }
Beispiel #4
0
 /// <summary>
 /// Gets an edge given an edge id. Throws if no such edge exist.
 /// </summary>
 /// <param name="edgeId">The id of the edge</param>
 /// <param name="polymorphic">If true and id isn't found in this EdgeType continue search into sub types</param>
 /// <param name="errorIfNotFound">Indicate what to do if <see cref="Edge"/> does not exist</param>
 /// <returns>The edge with matching id if it exists</returns>
 public Edge GetEdge(EdgeId edgeId, bool polymorphic = false, bool errorIfNotFound = true)
 {
     if (Unrestricted)
     {
         UnrestrictedEdge headTail;
         if (m_unrestrictedEdges.TryGetValue(edgeId, out headTail))
         {
             VertexType vt   = headTail.m_headVertexType;
             Vertex     head = vt.GetVertex(headTail.m_headVertexId);
             vt = headTail.m_tailVertexType;
             Vertex tail = vt.GetVertex(headTail.m_tailVertexId);
             return(new Edge(MyGraph, this, edgeId, head, tail));
         }
     }
     else
     {
         UInt64 vertexVertex;
         if (m_restrictedEdges.TryGetValue(edgeId, out vertexVertex))
         {
             VertexId headId = (VertexId)(vertexVertex >> 32);
             Vertex   head   = HeadType.GetVertex(headId);
             Vertex   tail   = TailType.GetVertex((VertexId)vertexVertex);
             return(new Edge(MyGraph, this, edgeId, head, tail));
         }
     }
     if (polymorphic)
     {
         foreach (var et in m_subTypes)
         {
             var e = et.GetEdge(edgeId, polymorphic, false);
             if (e != null)
             {
                 return(e);
             }
         }
     }
     if (errorIfNotFound)
     {
         throw new EdgeDoesNotExistException();
     }
     return(null);
 }
Beispiel #5
0
        public IEnumerable <Vertex> GetPropertyVertices(T value, VertexType vertexType)
        {
            VertexId elementId = -1;

            if (valueIndexUnique == null || valueIndexUnique.TryGetValue(value, out elementId) == false)
            {
                BTreeSet <ElementId> elementIds;
                if (valueIndex != null && valueIndex.TryGetValue(value, out elementIds))
                {
                    foreach (ElementId eId in elementIds)
                    {
                        yield return(vertexType.GetVertex(eId));
                    }
                }
            }
            if (elementId != -1)
            {
                yield return(vertexType.GetVertex(elementId));
            }
        }
Beispiel #6
0
        public Vertex GetVertex(VertexId id)
        {
            if (VertexIdSetPerType)
            {
                throw new NotSupportedException("GetVertex by VertexId on graph level is not supported when using VertexIdSetPerType");
            }
            VertexTypeId tId;

            if (vertexIdToVertexType.TryGetValue(id, out tId))
            {
                VertexType vt = vertexType[tId];
                return(vt.GetVertex(id, false));
            }
            throw new VertexDoesNotExistException();
        }
Beispiel #7
0
        /// <summary>
        /// Try to find a <see cref="Vertex"/> with a given property value.
        /// </summary>
        /// <param name="value">The property value to look for</param>
        /// <param name="polymorphic">If true, also look for property value matching vertices of property <see cref="VertexType"/> sub classes</param>
        /// <param name="errorIfNotFound">If true, signal an error if no matching <see cref="Vertex"/> found</param>
        /// <returns>A matching Vertex</returns>
        public Vertex GetPropertyVertex(T value, bool polymorphic = false, bool errorIfNotFound = true)
        {
            VertexId elementId = -1;

            if (m_valueIndexUnique == null || m_valueIndexUnique.TryGetValue(value, out elementId) == false)
            {
                BTreeSet <ElementId> elementIds;
                if (m_valueIndex != null && m_valueIndex.TryGetValue(value, out elementIds))
                {
                    elementId = elementIds.First();
                }
            }
            if (elementId == -1)
            {
                return(null);
            }
            VertexType vertexType = MyGraph.VertexTypes[TypeId];

            return(vertexType.GetVertex(elementId, polymorphic, errorIfNotFound));
        }
Beispiel #8
0
        public Vertex GetPropertyVertex(T value, Graph g, bool errorIfNotFound = true)
        {
            VertexId elementId = -1;

            if (valueIndexUnique == null || valueIndexUnique.TryGetValue(value, out elementId) == false)
            {
                BTreeSet <ElementId> elementIds;
                if (valueIndex != null && valueIndex.TryGetValue(value, out elementIds))
                {
                    elementId = elementIds.First();
                }
            }
            if (elementId == -1)
            {
                return(null);
            }
            VertexType vertexType = g.vertexType[TypeId];

            return(vertexType.GetVertex(elementId, false, errorIfNotFound));
        }
Beispiel #9
0
 /// <summary>
 /// Enumerates all edges of this type
 /// </summary>
 /// <param name="polymorphic">If true, also include all edges of sub types</param>
 /// <returns>Enumeration of edges of this type</returns>
 public IEnumerable <Edge> GetEdges(bool polymorphic = false)
 {
     if (Unrestricted)
     {
         foreach (var m in m_unrestrictedEdges)
         {
             VertexType vt1  = m.Value.m_headVertexType;
             Vertex     head = vt1.GetVertex(m.Value.m_headVertexId);
             VertexType vt2  = m.Value.m_tailVertexType;
             Vertex     tail = vt2.GetVertex(m.Value.m_tailVertexId);
             yield return(GetEdge(m.Key, tail, head));
         }
     }
     else
     {
         foreach (var m in m_restrictedEdges)
         {
             VertexType vt1  = HeadType;
             VertexId   vId  = (VertexId)(m.Value >> 32);
             Vertex     head = vt1.GetVertex(vId);
             VertexType vt2  = TailType;
             vId = (VertexId)m.Value;
             Vertex tail = vt2.GetVertex(vId);
             yield return(GetEdge(m.Key, tail, head));
         }
     }
     if (polymorphic)
     {
         foreach (EdgeType et in m_subTypes)
         {
             foreach (Edge e in et.GetEdges(polymorphic))
             {
                 yield return(e);
             }
         }
     }
 }
Beispiel #10
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();
            }
        }
Beispiel #11
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();
            }
        }
Beispiel #12
0
        // Queries
        public void doQueries()
        {
            using (SessionNoServer session = new SessionNoServer(s_systemDir))
            {
                session.BeginRead();
                Graph        g                       = Graph.Open(session); // it takes a while to open graph fresh from databases
                VertexType   userType                = g.FindVertexType("User");
                EdgeType     friendEdgeType          = g.FindEdgeType("Friend");
                PropertyType countryProperty         = userType.FindProperty("country");
                PropertyType incomeProperty          = userType.FindProperty("income");
                PropertyType friendshipStartProperty = friendEdgeType.FindProperty("start");

                Vertex someUser  = userType.GetVertex(1);
                Vertex someUser2 = userType.GetVertex(12282);

                var someUserFriends = from Edge e in someUser.GetEdges(friendEdgeType, Direction.Out)
                                      select e.Head;
                var            someUser3LevelNetwork = someUser.Traverse(3, true, Direction.Out);
                HashSet <Edge> edges = new HashSet <Edge>();
                Edge           edge  = (Edge)someUser.GetEdges(friendEdgeType, Direction.Out).Skip(1).First();
                edges.Add(edge);
                HashSet <EdgeType> edgeTypesToTraverse = new HashSet <EdgeType>();
                edgeTypesToTraverse.Add(friendEdgeType);
                // Find Shortest path between two given user ids
                List <List <Edge> > path = someUser.Traverse(4, false, Direction.Out, someUser2, edgeTypesToTraverse);
                Debug.Assert(path.Count > 0);
                var path2 = someUser.Traverse(4, false, Direction.Out, userType.GetVertex(41), edgeTypesToTraverse);
                HashSet <Vertex> vertices = new HashSet <Vertex>();
                vertices.Add(someUser2);
                var path3  = someUser.Traverse(4, false, Direction.Out, userType.GetVertex(9465810), edgeTypesToTraverse, null, null, vertices);                // path must include vertices
                var path3b = someUser.Traverse(4, false, Direction.Out, userType.GetVertex(9465810), edgeTypesToTraverse, null, null, null, vertices);          // path must NOT include vertices
                var path3c = someUser.Traverse(4, false, Direction.Out, userType.GetVertex(9465810), edgeTypesToTraverse, null, null, null, null, edges);       // path must include edges
                var path3d = someUser.Traverse(4, false, Direction.Out, userType.GetVertex(9465810), edgeTypesToTraverse, null, null, null, null, null, edges); // path must NOT include edges
                HashSet <PropertyType> vertexPropertyTypes = new HashSet <PropertyType>();
                vertexPropertyTypes.Add(incomeProperty);
                vertexPropertyTypes.Add(countryProperty);
                var path3e = someUser.Traverse(4, false, Direction.Out, userType.GetVertex(9465810), edgeTypesToTraverse, null, null, null, null, null, edges, vertexPropertyTypes);       // path must NOT include edges and at least one vertex in path must have property in propertyTypes
                var path3f = someUser.Traverse(4, false, Direction.Out, userType.GetVertex(9465810), edgeTypesToTraverse, null, null, null, null, null, edges, null, vertexPropertyTypes); // path must NOT include edges and no vertex in path must have any property in propertyTypes
                HashSet <PropertyType> edgePropertyTypes = new HashSet <PropertyType>();
                edgePropertyTypes.Add(friendshipStartProperty);
                var path3g = someUser.Traverse(4, false, Direction.Out, userType.GetVertex(9465810), edgeTypesToTraverse, null, null, null, null, null, edges, null, null, edgePropertyTypes);
                var path3h = someUser.Traverse(4, false, Direction.Out, userType.GetVertex(9465810), edgeTypesToTraverse, null, null, null, null, null, edges, null, null, null, edgePropertyTypes);
                var path3i = someUser.Traverse(4, false, Direction.Out, userType.GetVertex(9465810), edgeTypesToTraverse, null, null, null, null, null, edges, null, null, null, null, p => { object pv = p.GetProperty(countryProperty); return(pv != null && pv.Equals("Sweden")); });
                var path3j = someUser.Traverse(4, false, Direction.Out, userType.GetVertex(9465810), edgeTypesToTraverse, null, null, null, null, null, edges, null, null, null, null, null, p => { DateTime?pv = (DateTime?)p.GetProperty(friendshipStartProperty); return(pv != null && pv.Value.CompareTo(DateTime.Now) > 0); });
                var path4  = someUser.Traverse(4, false, Direction.Out, userType.GetVertex(2798), edgeTypesToTraverse);
                var path5  = someUser.Traverse(4, false, Direction.Out, userType.GetVertex(175), edgeTypesToTraverse);
                var path6  = someUser.Traverse(4, false, Direction.Out, userType.GetVertex(1531), edgeTypesToTraverse);
                var path7  = someUser.Traverse(4, false, Direction.Out, userType.GetVertex(1537), edgeTypesToTraverse);
                Console.WriteLine();

                // Get all the paths between two user ids
                var path8 = someUser.Traverse(4, true, Direction.Out, someUser2, edgeTypesToTraverse);
                path = someUser.Traverse(4, true, Direction.Out, userType.GetVertex(41), edgeTypesToTraverse);

                // Get the number of unique 2nd level friends a given user has (friends of my friends)

                var someUsers2ndLevelFriends = (from v in someUserFriends
                                                from Edge e in v.GetEdges(friendEdgeType, Direction.Out)
                                                select e.Head).Distinct();

                Console.WriteLine("unique 2nd level friends a given user has");
                int ct = 0;
                foreach (Vertex v in someUsers2ndLevelFriends)
                {
                    if (++ct % 100 == 0)
                    {
                        Console.WriteLine("User id: " + v.VertexId);
                    }
                }
                Console.WriteLine("Some user has: " + ct + " 2nd level friends");
                Console.WriteLine();

                // Get the top 10 users with most friends
                var top10mostFriends = from vertex in userType.GetTopNumberOfEdges(friendEdgeType, 10, Direction.Out)
                                       select vertex;
                Console.WriteLine("top 10 users with most friends");
                foreach (Vertex v in top10mostFriends)
                {
                    long count = v.GetNumberOfEdges(friendEdgeType, Direction.Out);
                    Console.WriteLine("User id: " + v.VertexId + "\t number of friends: " + count);
                }
                Console.WriteLine();
                session.Commit();
            }
        }