Query assistance

[mholland]

Hi there,

Firstly, thanks for all the effort involved in Gremlinq, so far it's been a huge help in writing queries. I'm currently working on a project in which I'm having trouble constructing a query to find vertices that share multiple relations. I've included a small toy project below:

Click to expand

using System;
using System.Linq.Expressions;
using System.Threading.Tasks;
using ExRam.Gremlinq.Core;
using ExRam.Gremlinq.Providers.WebSocket;
using Microsoft.Extensions.Logging;
using static ExRam.Gremlinq.Core.GremlinQuerySource;

namespace GremLinqDemo
{
    class Program
    {
        static async Task Main(string[] args)
        {
            var gremlin = g
                .ConfigureEnvironment(env => env.UseLogger(LoggerFactory.Create(builder => builder
                        .AddFilter(_ => true)
                        .AddConsole())
                    .CreateLogger("Queries")))
                .ConfigureEnvironment(env => env
                    .UseModel(GraphModel.FromBaseTypes<Vertex, Edge>(lookup => lookup.IncludeAssembliesOfBaseTypes()))
                    .ConfigureOptions(options => options.SetValue(WebSocketGremlinqOptions.QueryLogLogLevel, LogLevel.Information))
                    .UseGremlinServer(builder => builder.AtLocalhost()));

            Console.WriteLine("Clearing database...");
            await gremlin.V().Drop();

            await SetUp(gremlin, "Alice", "Maths", "A", 1);
            await SetUp(gremlin, "Bob", "Maths", "B", 1);
            await SetUp(gremlin, "Charlie", "Maths", "A", 1);
            await SetUp(gremlin, "Dan", "History", "A", 2);
            await SetUp(gremlin, "Elizabeth", "English", "C", 2);
            await SetUp(gremlin, "Fred", "Biology", "C", 2);

            var vertexCount = await gremlin.V().Count().FirstAsync();
            var edgeCount = await gremlin.E().Count().FirstAsync();

            Console.WriteLine("vertices: {0}, edges: {1}", vertexCount, edgeCount);

            var students = await gremlin
                .V<Student>()
                .Where(s => s.Name == "Alice")
                .As((__, alice) => __
                    .Out<Studies>()
                    .OfType<Subject>()
                    .Both<Studies>()
                    .OfType<Student>()
                    .Where(s => s.Id != alice.Value.Id))
                .Values(x => x.Name);

            Console.WriteLine("Students studying the same as Alice: {0}", string.Join(", ", students));
        }

        private static async Task SetUp(IGremlinQuerySource gremlin, string studentName, string subject, string letterGrade, int year)
        {
            var student = await GetOrCreateVertex<Student>(gremlin, new Student(studentName), v => v.Name == studentName);
            var subj = await GetOrCreateVertex<Subject>(gremlin, new Subject(subject), v => v.SubjectName == subject);
            var grade = await GetOrCreateVertex<Grade>(gremlin, new Grade(letterGrade), v => v.Letter == letterGrade);
            var yearNumber = await GetOrCreateVertex<Year>(gremlin, new Year(year), v => v.Number == year);

            await gremlin
                .V(student.Id!)
                .AddE<Studies>()
                .To(__ => __.V(subj.Id!))
                .FirstAsync();

            await gremlin
                .V(student.Id!)
                .AddE<HasGrade>()
                .To(__ => __.V(grade.Id!))
                .FirstAsync();

            await gremlin
                .V(student.Id!)
                .AddE<InYear>()
                .To(__ => __.V(yearNumber.Id!))
                .FirstAsync();
        }

        private static async Task<Vertex> GetOrCreateVertex<T>(IGremlinQuerySource gremlin, T vertex, Expression<Func<T, bool>> selector) where T : Vertex =>
            await gremlin
                .V<T>()
                .Where(selector)
                .Fold()
                .Coalesce(
                    __ => __.Unfold(),
                    __ => __.AddV<T>(vertex)
                )
                .FirstAsync();

        class Vertex
        {
            public object? Id { get; set; }
            public string? Label { get; set; }
        }

        class Student : Vertex
        {
            public string Name { get; set; }

            public Student(string name)
            {
                Name = name;
            }
        }

        class Subject : Vertex
        {
            public string SubjectName { get; }
            public Subject(string subjectName)
            {
                SubjectName = subjectName;
            }

        }

        class Grade : Vertex
        {
            public Grade(string letter)
            {
                Letter = letter;
            }

            public string Letter { get; }
        }

        class Year : Vertex
        {
            public Year(int number)
            {
                Number = number;
            }

            public int Number { get; }
        }

        class Studies : Edge { }
        class HasGrade : Edge { }
        class InYear : Edge { }

        class Edge
        {
            public object? Id { get; set; }
            public string? Label { get; set; }
        }
    }
}

I can currently construct a query that returns vertices that share a single relation, in this example all Students who study the same Subject as Alice: Bob and Charlie who all share a Studies edge with the same Subject vertex.

However I would also like to find vertices with more than one relationship. For example: vertices that share the same Grade and Year vertex as Elizabeth. In this case, it would result in the Fred vertex which also has a C and is in year 2.

Similarly finding vertices that share the same Subject, Grade and Year as Charlie, would result in Alice who studies Maths, has an A Grade and is InYear 1.

I've struggled to find and convert gremlin queries that do exactly as I want and have had trouble constructing what I want with Gremlinq so far. Any assistance would be much appreciated, any questions or clarifications I can provide them.

Thanks,
Matt.

[danielcweber]

You mean something like a union ?

_g.V().Union(__ => __.Out<Studies>(), __.Out<HasGrade>(), __ => __.Out<InYear>())

More on the union step in Gremlin.