Helix DB planning

[xav-db]

This discussion is focussed on the planning of the project. How we will actually implement everything and the approaches we should take.

The initial technical plan is to write everything in Rust. It is a strongly typed and powerful language which I believe to be a good choice for a project such as this.

[xav-db]

Initial ideas for basic query

use Schema::{User}                                          // import the schema

QUERY GetFollowers(userID: String) =>                       // declare new query
    GET Followers <- User(userID)::In::Follows                   // get all the followers of a user returning the user
        WHERE User::Status::Active                          // filter out followers who are not active
    LIMIT 50                                                // limit the number of followers to 50
    RETURN User::{Username, FollowerCount, FollowingCount}  // return the username, follower count, and following count of the followers

One thing I am unsure about is whether to start the query with something similar to gremlin like doing G::User or V::User to some other way to explicitly show the start of a traversal.

Idea for being able to return group together results to be returned as a sub field (thing project by in gremlin)
Node Values are automatically unwrapped unless explicitly told otherwise, i.e. the user automatically unwraps into it's full object
Custom projections can be done in a separate function then applied here.

use Schema::{Restaurant};

QUERY GetRestaurantAndReviews(restaurantID: String) =>
    GET Res <- Restaurant                               // same as g.V().as('res')
    ADD_FIELD Res {                                     // Access fetched node      
        Reviews: [                                      // Define name for new field, square brackets indicate list, curly braces indicate single object
            Rating <- InE::Review::Rating               // Get the rating from the incoming edge of type Review - Same as Res::InE::Review::Rating
            User <- OutV::User                          // Get the user from the outgoing edge of type User - Same as Rating::OutV::User
        ]
    }
    RETURN Res

Equivalent gremlin query:

g.V(restaurantID).as('Restaurant')
    .inE('Review')
    .values('Rating').as('Rating')
    .outV().as('User')
    .project('Restaurant')
    .by(
        project('Reviews'/* SOME OTHER FIELDS IN HERE FOR REST OF RESTAURANT*/ ) 
        .by(Project('Rating', 'User')
            .by(select('Rating'))
            .by(
                project('Username', 'Email')
                .by(select('User').values('Username'))
                .by(select('User').values('Email'))
            )
        )
        // MORE PROJECTIONS FOR REST OF RESTAURANT
    )
    .toList()

[xav-db]

I think that's too hard to understand from the syntax of the language alone. Surely there's no benefit to omitting a boolean comparison like COUNT User::InE > 0

In fact I think most of the (all caps) query keywords should be on the outer most reasonable level of a query statement, to help with readability.

Fair point. We could do something like

QUERY GetUsersThatHavePostedAndPosts(userID: String) => 
       GET User <- V::User(userID)
               WHERE (
                       User::Has(?::OutE::Count()::Gt(0))  // or User::Has(?::OutE::Count() >0)
               )
               Posts <- User::Out::Created
       RETURN User, Posts

[willbowden]

Yeah I like that, and I think we can definitely keep boolean operators in.

If we're using a Has check on the User:; type, is ? even necessary in the predicate? Surely the fact we're starting from the user is inferred by the fact it's User::Has()?

[xav-db]

Yes the user node as the source for the inner traversal is inferred but the ? is to signify an anonymous traversal i.e a traversal with no side effects. in gremlin this would be
g.V(userID).has(__.outE().count()......

At the end of this traversal

User::Has(OutE::Count()::Gt(0))

you would be on the outgoing edges of the user (assuming the OutE traversed from the User).
Meaning you wouldn't be able to directly do

Posts <- User::Out::Created

On the next line.

[willbowden]

Ahh okay I understand the need for anonymous traversal now.

Looks good to me!

[Gand4lf]

You left out the parameter...
e.g:
QUERY GetFollowers(userID: String)

[Gand4lf]

Schema example. Schema would have to be in file called schema.hx

N::User {
   Name: String,
   Age: Integer,
}

E::Follows{
   From: User,
   To: User,
   Properties{
   }
}