Sorry to beat on this old horse again, but I just thought I'd share another
solution: using the graph matching component (in Java, but you could
probably translate it quite easily to Scala):
public class VisibleMessagesByFollowedUsers implements IterableNode
{
private final
Hi!
Interesting thread :-)
Craig Taverner wrote:
of original data. The developers answered that they would store the node-ids
of the original data in an int[] property. That answer totally took me by
surprise, and it took a few seconds for me to realize that it would work for
the initial use
the results or to compose different traversals.
Kind regards,
Niels Hoogeveen
From: linxbet...@gmail.com
Date: Wed, 17 Mar 2010 19:39:07 -0400
To: user@lists.neo4j.org
Subject: Re: [Neo] basic questions
I really like that syntax, however I'm concerned that although
in relationshipfilters and
nodefilters, but allows for nicer organization of the code.
Kind regards,
Niels Hoogeveen
From: okramma...@gmail.com
To: user@lists.neo4j.org
Date: Wed, 17 Mar 2010 21:59:27 -0600
Subject: Re: [Neo] basic questions
Hi,
The example I provided is in effect nothing but a couple
:49 -0500
To: user@lists.neo4j.org
Subject: Re: [Neo] basic questions
That sounds pretty cool. Do you have a github project?
On Wed, Mar 17, 2010 at 7:23 PM, Niels Hoogeveen
pd_aficion...@hotmail.comwrote:
The example I provided is in effect nothing but a couple of nested
iterations
in Scala.
Scala version 2.8 is required.
Kind regards,
Niels Hoogeveen
From: linxbet...@gmail.com
Date: Wed, 17 Mar 2010 22:21:49 -0500
To: user@lists.neo4j.org
Subject: Re: [Neo] basic questions
That sounds pretty cool. Do you have a github project?
On Wed, Mar 17, 2010 at 7
I'm uncertain about one ambiguity in your model, you are able to find
messages through FOLLOWS and IS_VISIBLE_BY. These will give two different
sets, and my first impression was that FOLLOWS gives you the right answer.
In other words you want to query for 'all messages by users I follow'? In
that
Thanks Craig,
I'd like to clarify my question (I don't think it changes your answer
though).
I wanted all messages visible to me created by users I follow. Thus, the
FOLLOWS relationship is not enough. I'd need to see messages that are
visible to me and then check if they were created by users
Hi Lincoln,
So it sounds like you don't need the IS_VISIBLE relations after all. The
traverser works by following all relationships of the specified types and
directions from each current node (as you traverse, or walk the graph). You
can have a complex graph and traverse to high depth very fast
Hey,
You might want to consider Blueprints Pipes for a more controlled traverser
framework that doesn't require the use of for-loops and allows you to specify
arbitrary paths through a graph.
http://wiki.github.com/tinkerpop/blueprints/pipes-traversal-framework
For the example
I guess I could say that the approach is totally different, but in reality
you start at the same point, working out what query you want. But after that
things change. Let's consider two cases, the huge network and the paging
examples you used below.
For the first, keep in mind that if you scale
Ok I get it. I keep not thinking about relationships flexibly enough. I
need to take a little time to get used to thinking about problems this way.
Thanks for your help!
On Wed, Mar 17, 2010 at 5:43 PM, Craig Taverner cr...@amanzi.com wrote:
I guess I could say that the approach is totally
Good point :)
In training our new devs (who typically have a RDBC background) it
often takes a leap of understanding for them to realise that whilst a
join is very expensive, creating and traversing a relationship is very
cheap
T
Sent from my iPhone so please excuse typos adn brevity
Tim
This is a cool idea. Seems a bit like the pattern matching stuff in neo4j,
except you setup a traversal pattern. We have done a similar thing in Ruby
with a set of nested closures that each define the starting node for the
traversal of the outer closure, allowing a kind of multi-step traversal (or
Hey Craig,
That looks like this thing called Linq (some Microsoft .NET thing --
http://en.wikipedia.org/wiki/Language_Integrated_Query ). It allows you to
talk all SQL-like using dot notation. I don't know much about it, but seems
super useful for those who like that type of graph searching.
I was reminded recently of this 'context switch' between relational and
graph when I asked a group of developers I was training how to structure the
nodes behind a table of results, where each result was a number representing
the number of other results conforming to some criteria. So basically a
Hey Marko,
I've not looked at linq, and am not really a fan of using SQL-like syntax
for non-SQL things. I did take a peek at GQL and did not really like it. Way
too SQL-ish.
This syntax was devised by a developer new to Ruby, so this style is not
specifically Ruby-esque either. However, once I
of j
if(k.getProperty(CREATED) = 2010-03-17); // filters the properties of
the relation bound to k
)yield{
println(k.getProperty(name))
}
Kind regards,
Niels Hoogeveen
From: okramma...@gmail.com
Date: Wed, 17 Mar 2010 14:37:32 -0700
To: user@lists.neo4j.org
Subject: Re: [Neo] basic
regards,
Niels Hoogeveen
From: okramma...@gmail.com
Date: Wed, 17 Mar 2010 14:37:32 -0700
To: user@lists.neo4j.org
Subject: Re: [Neo] basic questions
Hey,
You might want to consider Blueprints Pipes for a more controlled
traverser framework that doesn't require the use of for-loops
Hi,
The example I provided is in effect nothing but a couple of nested
iterations, so nothing like a real traversal, but certainly
comparable to the the java pipes or the Gremlin path expressions.
I am working on a Scala based traverser, having higher order
functions makes it possible
20 matches
Mail list logo
