How Gremlin Query Same SQL Like for Search Feature

How Gremlin query same sql like for search feature

Try:

g.V().filter({ it.getProperty("foo").startsWith("search") })

or

g.V().filter({ it.getProperty("foo").contains("search") })

Gremlin - search for multiple substrings

You can use the new text filter predicates. On the modern sample graph you could do this for example:

gremlin> TinkerFactory.createModern().traversal().V().
           has("name", containing("ark").or(containing("os"))).values("name")
==>marko
==>josh

OrientDB: text searching using gremlin

I tried with 2.1.15 and I had no problem.

These are the records.

EDITED

I added some vertexes to my DB and now the count() is 11

QUERY:

g.V.has('eBodyText').filter{it.eBodyText.contains('Syria')}.count()

OUTPUT:

==>11

Hope it helps.

How to fire match query in gremlin . Filter query not working in cosmos db with java driver

This traversal:

g.V().hasLabel('url').
  has('name','sw10707').as('a').
  outE().filter(it.name.matches('.pri.'))

requires a lambda expression in filter() and should be written as a Groovy closure:

g.V().hasLabel('url').
  has('name','sw10707').
  outE().filter{it.name.matches('.pri.')}

Unfortunately, CosmosDB does not support lambdas so your traversal will fail. At this time, there isn't a workaround that I know of short of returning the edges to filter them on the client and then using them to start a second traversal...not great. Hopefully the issue you raised will bring some relief soon.

Note that I commented on that issue to mention that TinkerPop is considering making those text predicates available - the discussion is here.

Gremlin text comparison predicates

For now you should add your own predicates for text comparisons. TinkerPop has had discussion in the past about adding such support, but no consensus has been achieved on a direction to take.

Gremlin: Between function

I was silently corrected by the Gremlin Guru on that answer I'd given (it's updated now), but the second argument to between is exclusive so if you want all "name" that start with "m" then you need the second argument to be "n".

Gremlin query (SQL self-join)

With graphs you should try to think of terms of "navigating connected things" rather than "joining disparate things" because with a graph the things are already joined explicitly. It also helps to think in terms of streams of things being lazily evaluated (i.e. objects going from one Gremlin step to the next).

First of all, the picture is nice but it's always more helpful to provide some sample data in the form of a Gremlin script like this:

g = TinkerGraph.open().traversal()
g.addV('route').property('rid',1).as('r1').
  addV('route').property('rid',2).as('r2').
  addV('route').property('rid',3).as('r3').
  addV('leg').property('lid',1).property('source','ES').property('dest','FR').as('l1').
  addV('leg').property('lid',2).property('source','FR').property('dest','FR').as('l2').
  addV('leg').property('lid',3).property('source','FR').property('dest','ES').as('l3').
  addV('leg').property('lid',4).property('source','ES').property('dest','FR').as('l4').
  addV('leg').property('lid',5).property('source','FR').property('dest','FR').as('l5').
  addV('leg').property('lid',6).property('source','FR').property('dest','US').as('l6').
  addE('has_leg').from('r1').to('l1').property('order',1).
  addE('has_leg').from('r1').to('l2').property('order',2).
  addE('has_leg').from('r1').to('l3').property('order',3).
  addE('has_leg').from('r3').to('l4').property('order',1).
  addE('has_leg').from('r3').to('l5').property('order',2).
  addE('has_leg').from('r3').to('l6').property('order',3).
  addE('has_leg').from('r2').to('l2').property('order',1).iterate()

Your question was:

which routes travel from one country to another, and then back to the previous country?

Note that I added some extra data that didn't meet the requirements of that question to be sure my traversal was working properly. I suppose I assumed that you were open to getting routes that just stayed in the country like a leg that just went from "FR" to FR" as it started in "FR" and ended in that "previous country". I guess I could revise this further to do that if you really needed me to, but for now I will stick with that assumption since you're just learning.

After considering the data and reading that question I immediately thought, let's find the routes which you did well enough and then let's just see what it takes to get the start leg of the trip and the end leg of the trip for that route:

gremlin> g.V().hasLabel('route').
......1>   map(outE('has_leg').
......2>       order().by('order').
......3>       union(limit(1).inV().values('source'), tail().inV().values('dest')).
......4>       fold())
==>[ES,ES]
==>[FR,FR]
==>[ES,US]

So, I find a "route" vertex with hasLabel('route') and then I convert each into a List of the start and end country (i.e. a pair where the first item is the "source" country and the second item is the "dest" country). To do that I traverse outgoing "has_leg" edges, order them. Once ordered I grab the first edge in the stream (i.e with limit(1)) and traverse to the incoming "leg" vertex and grab its "source" value and do the same for the last incoming vertex of the edge (i.e. with tail()) but this time grab its "dest" value. We then use fold() to push that two item stream from union() into a List. Again, because this all happens inside of map() we are effectively doing it for each "route" vertex so we get three pairs as a result.

With that output we just now need to compare the start/end values in the pairs to determine which represent a route starting and ending in the same country.

gremlin> g.V().hasLabel('route').
......1>   filter(outE('has_leg').
......2>          order().by('order').
......3>          fold().
......4>          project('start','end').
......5>            by(unfold().limit(1).inV().values('source')).
......6>            by(unfold().tail().inV().values('dest')).
......7>          where('start', eq('end'))).
......8>   elementMap()
==>[id:0,label:route,rid:1]
==>[id:2,label:route,rid:2]

At line 1, note that we changed map() to filter(). I only used map() initially so that I could see the results of what I was traversing before I worried about how to use those results to get rid of the data I didn't want. That's a common practice with Gremlin as you build more and more complexity in your traversals. So we are now ready to apply a filter() to each "route" vertex. I imagine that there are a number of ways to do this, but I chose to gather all the ordered edges into a List at line 3. I then project() that step at line 4 and transform the edge list for both "start" and "end" keys using the associated by() modulators. In both cases I must unfold() the edge list to a stream and then apply the same limit(1) and tail() sort of traversal that was explained earlier. The result is a Map with "start" and "end" keys which can be compared using where() step. As you can see from the result, the third route that started in "ES" and ended in "US" has been filtered away.

I'll expand my answer based on your comment - Since all of my previous data seems to align with your more general case of wanting to find any route that returns to a country in any sense:

g = TinkerGraph.open().traversal()
g.addV('route').property('rid',1).as('r1').
  addV('route').property('rid',2).as('r2').
  addV('route').property('rid',3).as('r3').
  addV('route').property('rid',4).as('r4').
  addV('leg').property('lid',1).property('source','ES').property('dest','FR').as('l1').
  addV('leg').property('lid',2).property('source','FR').property('dest','FR').as('l2').
  addV('leg').property('lid',3).property('source','FR').property('dest','ES').as('l3').
  addV('leg').property('lid',4).property('source','ES').property('dest','FR').as('l4').
  addV('leg').property('lid',5).property('source','FR').property('dest','FR').as('l5').
  addV('leg').property('lid',6).property('source','FR').property('dest','US').as('l6').
  addV('leg').property('lid',7).property('source','ES').property('dest','FR').as('l7').
  addV('leg').property('lid',8).property('source','FR').property('dest','CA').as('l8').
  addV('leg').property('lid',9).property('source','CA').property('dest','US').as('l9').
  addE('has_leg').from('r1').to('l1').property('order',1).
  addE('has_leg').from('r1').to('l2').property('order',2).
  addE('has_leg').from('r1').to('l3').property('order',3).
  addE('has_leg').from('r3').to('l4').property('order',1).
  addE('has_leg').from('r3').to('l5').property('order',2).
  addE('has_leg').from('r3').to('l6').property('order',3).
  addE('has_leg').from('r4').to('l7').property('order',1).
  addE('has_leg').from('r4').to('l8').property('order',2).
  addE('has_leg').from('r4').to('l9').property('order',3).
  addE('has_leg').from('r2').to('l2').property('order',1).iterate()

If I have this right the newly added "rid=4" route should be filtered as its route never revisits the same country. I think this bit of Gremlin is even easier than what I suggested previously because now we just need to look for unique routes which means that if we satisfy one of these two situations then we've found a route we care about:

1. There is one leg and it starts/ends in the same country
2. There are multiple legs and if the number of times that country appears in the route exceeds 2 (because we are taking into account "source" and "dest")

Here's the Gremlin:

gremlin> g.V().hasLabel('route').
......1>   filter(out('has_leg').
......2>          union(values('source'), 
......3>                values('dest')).
......4>          groupCount().
......5>          or(select(values).unfold().is(gt(2)),
......6>             count(local).is(1))).
......7>   elementMap()
==>[id:0,label:route,rid:1]
==>[id:2,label:route,rid:2]
==>[id:4,label:route,rid:3]

If you understood my earlier explanations of the code, then you likely follow everything up to line 5 where we take the Map produced by the groupCount() on country names and apply the two filter conditions I just described. At line 5, we apply the second condition which extracts the values from the Map (i.e. the counts of the number of times each country appears) and detects if any are greater than 2. On line 6, we count the entries in the Map which maps to the first condition. Note that we use local there because we aren't counting the Map-objects in the stream but the entries within the Map (i.e. local to the Map).

---

Related Topics