infinitegraph: All content tagged as infinitegraph in NoSQL databases and polyglot persistence

InfiniteGraph Graph Database Reaches 1.0 Release

About:

graphdb

,

Firstly announced just a bit over a month ago, InfiniteGraph, the graph database from Objectivity, has already reached the 1.0 release. At this time I don’t have yet the details of these release.

InfiniteGraph offers a 2-month free version to developers requiring afterwards a $999/year license. According to this comparison of NoSQL graph databases, I cannot say that’s the most “generous” offer in the graph database market.

Release: InfiniteGraph 0.9, 64bit versions and weighted edges

About:

infinitegraph

,

graph database

,

It looks like InfiniteGraph, the newcomer in the graph database world, is moving fast towards its first 1.0 release.

In this ☞ latest release, they’ve added support for 64bit Linux and Windows platforms (nb I’m still waiting for the Mac OS version and also wondering what the final license will be).

Another feature present in this version is weighted edges, a notion pretty common for graphs.

Thanks to Todd Stavish the sample app implemented so far using InfoGrid, Neo4j, sones GraphDB^[1] and Filament has now a version in InfiniteGraph. Go check it out!

In case you missed it, sones GraphDB is offering now an open source version (↩)

Release: First Public Beta of InfiniteGraph

About:

infinitegraph

,

graph database

,

releases

,

InfiniteGraph is a new product in the space of graph databases coming from the producers of Objectivity/db, an object database with a long history. While still in early beta, InfiniteGraph promise is to provide “uniquely distributed capabilities and virtually unlimited scalability”. As we’ve learned, scaling graph databases is a challenging problem, so we’ll have to keep our eyes on InfiniteGraph and see what approaches it will take to tackle these complex problems.

About the first public beta release:

This first public beta release includes fully distributed capabilities, and an addressing scheme that supports virtually unlimited scalability.

InfiniteGraph 0.8 beta supports Java programmers, on 32-bit Linux and Windows platforms. Support for 64-bit Linux, Windows and Mac platforms, and a C# language binding are also slated for upcoming releases.

The InfiniteGraph 1.0 RTM and GA public releases are planned for later in July.

To get into the InfiniteGraph beta program use the following ☞ link.

Get a Taste of Graph Databases: InfoGrid and Neo4j

About:

csharp

,

filament

,

graph database

,

infogrid

,

java

,

neo4j

,

sones

,

infinitegraph

,

As I said in MongoDB MapReduce tutorial, the best way to validate that you’ve got the basics right about a system is to use some basic code. And this is exactly the idea behind this post: to take a look at a very (very) basic tagging app in InfoGrid and Neo4j.

InfoGrid version

public class FirstStep {

  public static void main( String[] args ) throws Throwable {
      MeshBase mb = MMeshBase.create();

      Transaction tx = mb.createTransactionNow();

      MeshObject tagLibrary = mb.getMeshBaseLifecycleManager().createMeshObject();
      tagLibrary.bless( TaggingSubjectArea.TAGLIBRARY );

      MeshObject tag_funny = mb.getMeshBaseLifecycleManager().createMeshObject( TaggingSubjectArea.TAG );
      MeshObject tag_good  = mb.getMeshBaseLifecycleManager().createMeshObject( TaggingSubjectArea.TAG );

      tag_funny.setPropertyValue( TaggingSubjectArea.TAG_LABEL, 
      StringValue.create( “funny” ));
      tag_good.setPropertyValue(  TaggingSubjectArea.TAG_LABEL, 
      StringValue.create( “good”  ));

      tagLibrary.relateAndBless( TaggingSubjectArea.TAGLIBRARY_COLLECTS_TAG.getSource(), 
      tag_funny );
      tagLibrary.relateAndBless( TaggingSubjectArea.TAGLIBRARY_COLLECTS_TAG.getSource(), 
      tag_good );

      MeshObject cnn = mb.getMeshBaseLifecycleManager().createMeshObject(
                mb.getMeshObjectIdentifierFactory().fromExternalForm( “http://cnn.com/” ), WebSubjectArea.WEBRESOURCE );
      MeshObject onion = mb.getMeshBaseLifecycleManager().createMeshObject(
                mb.getMeshObjectIdentifierFactory().fromExternalForm( “http://theonion.com/” ), WebSubjectArea.WEBRESOURCE );
      MeshObject xkcd = mb.getMeshBaseLifecycleManager().createMeshObject(
                mb.getMeshObjectIdentifierFactory().fromExternalForm( “http://xkcd.com/” ), WebSubjectArea.WEBRESOURCE );

      tag_good.relateAndBless( TaggingSubjectArea.TAG_TAGS_MESHOBJECT.getSource(),  cnn );
      tag_good.relateAndBless( TaggingSubjectArea.TAG_TAGS_MESHOBJECT.getSource(),  xkcd );
      tag_funny.relateAndBless( TaggingSubjectArea.TAG_TAGS_MESHOBJECT.getSource(), onion );
      tag_funny.relateAndBless( TaggingSubjectArea.TAG_TAGS_MESHOBJECT.getSource(), xkcd );

      tx.commitTransaction();

      // Here are some example traversals:
        
      System.err.println( “All tags in the tag library, and the sites they tag:” );
      for( MeshObject tag : tagLibrary.traverse( TaggingSubjectArea.TAGLIBRARY_COLLECTS_TAG.getSource() )) {
          System.err.println( “\t” + tag.getPropertyValue( TaggingSubjectArea.TAG_LABEL ));

          for( MeshObject site : tag.traverse( TaggingSubjectArea.TAG_TAGS_MESHOBJECT.getSource() )) {
              System.err.println( “\t\t” + site.getIdentifier().toExternalForm() );
          }
      }

      System.err.println( “Xkcd is tagged by:” );
      for( MeshObject tag : xkcd.traverse( TaggingSubjectArea.TAG_TAGS_MESHOBJECT.getDestination() )) {
          System.err.println( “\t” + tag.getPropertyValue( TaggingSubjectArea.TAG_LABEL ));
      }

      System.err.println( “All tagged sites (note there are no duplicates: set semantics)” );
      for( MeshObject site : tagLibrary.traverse( TaggingSubjectArea.TAGLIBRARY_COLLECTS_TAG.getSource() ).traverse( TaggingSubjectArea.TAG_TAGS_MESHOBJECT.getSource() )) {
          System.err.println( “\t” + site.getIdentifier().toExternalForm() );
      }
    }
}

The code with more details can be found ☞ here.

Neo4j version

public class TagExample 
{
    private static final String KEY_URI = “uri”;
    private static final String KEY_LABEL = “label”;
    
    private static enum RelTypes implements RelationshipType
    {
        TAG,
        TAGGED_WITH,
    }
    
    private static GraphDatabaseService graphDb;
    private static IndexService index;
    
    public static void main( String[] args )
    {
        graphDb = new EmbeddedGraphDatabase( “neo4j-db” );
        index = new LuceneIndexService( graphDb );
        
        Transaction tx = graphDb.beginTx();
        try
        {
            // Tag some resources
            Node tagLibrary = getTagLibrary();
            Node cnn = getOrCreateResource( “http://cnn.com/” );
            Node onion = getOrCreateResource( “http://theonion.com/” );
            Node xkcd = getOrCreateResource( “http://xkcd.com/” );
            
            Node funny = getOrCreateTag( “funny” );
            Node good = getOrCreateTag( “good” );
            
            tagResource( cnn, good );
            tagResource( xkcd, good );
            tagResource( onion, funny );
            tagResource( xkcd, funny );
            
            // Do some querying
            System.out.println( “Listing all tags and resources” );
            for ( Relationship tagRelationship : graphDb.getReferenceNode().getRelationships(
                    RelTypes.TAG ) )
            {
                Node tag = tagRelationship.getEndNode();
                System.out.println( ”    ” + tag.getProperty( KEY_LABEL ) );
                for ( Relationship resourceRelationship : tag.getRelationships(
                        RelTypes.TAGGED_WITH ) )
                {
                    Node resource = resourceRelationship.getOtherNode( tag );
                    System.out.println( ”        ” + resource.getProperty( KEY_URI ) );
                }
            }
            
            // Find out which tags xkcd is tagged with
            System.out.println( “Xkcd is tagged with:” );
            for ( Relationship relationship : xkcd.getRelationships( RelTypes.TAGGED_WITH ) )
            {
                Node tag = relationship.getOtherNode( xkcd );
                System.out.println( ”    ” + tag.getProperty( KEY_LABEL ) );
            }
            
            // List tagged sites
            System.out.println( “All tagged sites (note there are no duplicates)” );
            ReturnableEvaluator returnEvaluator = new ReturnableEvaluator()
            {
                public boolean isReturnableNode( TraversalPosition currentPos )
                {
                    return currentPos.lastRelationshipTraversed() != null &&
                            currentPos.lastRelationshipTraversed().getType().name().equals(
                                    RelTypes.TAGGED_WITH.name() );
                }
            };
            for ( Node resource : tagLibrary.traverse( Order.BREADTH_FIRST,
                    StopEvaluator.END_OF_GRAPH, returnEvaluator,
                    RelTypes.TAG, Direction.OUTGOING,
                    RelTypes.TAGGED_WITH, Direction.INCOMING ) )
            {
                System.out.println( ”    ” + resource.getProperty( KEY_URI ) );
            }

            
            tx.success();
        }
        finally
        {
            tx.finish();
        }
        
        index.shutdown();
        graphDb.shutdown();
    }

    
    private static Node getTagLibrary()
    {
        // TODO Just for this example use the reference node, but you could
        // consider creating a sub-reference node instead…
        return graphDb.getReferenceNode();
    }

    private static void tagResource( Node resource, Node tag )
    {
        // See if it’s already tagged?
        for ( Relationship relationship : resource.getRelationships( RelTypes.TAGGED_WITH ) )
        {
            if ( relationship.getOtherNode( resource ).equals( tag ) )
            {
                return;
            }
        }
        
        // Tag it
        resource.createRelationshipTo( tag, RelTypes.TAGGED_WITH );
    }

    private static Node getOrCreateTag( String label )
    {
        Node node = index.getSingleNode( KEY_LABEL, label);
        if ( node == null )
        {
            node = graphDb.createNode();
            node.setProperty( KEY_LABEL, label );
            getTagLibrary().createRelationshipTo( node, RelTypes.TAG );
            index.index( node, KEY_LABEL, label );
        }
        return node;
    }

    private static Node getOrCreateResource( String uri )
    {
        Node node = index.getSingleNode( KEY_URI, uri );
        if ( node == null )
        {
            node = graphDb.createNode();
            node.setProperty( KEY_URI, uri );
            index.index( node, KEY_URI, uri );
        }
        return node;
    }
}

The Neo4j code was contributed by Mattias Persson from Neo Technology (thanks Mattias).

Note: I couldn’t figure out a way to make the code more readable that this. But you can hover over the code snippets and you’ll get the option to see the original source code.

Here are my notes about the two code snippets above:

everything in Neo4j must happen inside a transaction even if it’s a graph traversal operation (this gives a very strong Isolation level). The InfoGrid traversal code seem to happen outside the transaction, so it sounds like it supports a more relaxed isolation level (interesting question here is: if traversal would happen inside a transaction, would that isolate it from seeing possible external modifications?)
InfoGrid’s central element is MeshObject, while Neo4j has Node and Relationship. Generally speaking I have found the terminology in InfoGrid a bit more unusual (f.e. MeshObject, relateAndBless, etc.)
the Neo4j uses also the LuceneIndexService for indexing both the tag and web resources nodes, but that’s only becaus e the code there makes sure not to duplicate either tags or web resources (i.e. this functionality is not present in the InfoGrid code and I don’t know how that would look like)
in both cases a relationship gives you access at both its ends. While both InfoGrid and Neo4j documentation speak about bidirectional arcs

If someone would contribute the code for ☞ HyperGraphDB and/or ☞ VertexDB I think this post would get even more interesting!

Update: The guys from Sones picked up my challenge and they show up their C# implementation on this ☞ post. I have included below the code for reference

Sones version

namespace TagExample
{

    public class Tag : DBObject {

        // Will inherit an UUID and RevisionID property from DBObject

        [CreateIndex(DBIndexTypes.HashTable)]
        public String Name { get; set; }

        // Backwardedges to the attribute Tags of type Websites
        [BackwardEdge(“Tags”)]
        public List<Website> TaggedWebsites { get; set; }

        public Tag() { }

    }

    public class Website : DBObject
    {

        // Will inherit an UUID and RevisionID property from DBObject

        [CreateIndex(DBIndexTypes.HashTable)]
        public String Name { get; set; }

        public String URL  { get; set; }

        // Edges to the tags
        public List<Tag> Tags { get; set; }

        public Website() { }

    }

    public class TagExample
    {

        private void CheckResult(QueryResult myQueryResult)
        {
            Console.WriteLine(“{0} => {1}”,
                myQueryResult.Query,
                myQueryResult.ResultType);
        }

        private void Run()
        {

            // Create a new in-memory database
            var GDB = new GraphDBSharp()
            {
                DatabaseName        = “TagExampleDB”,
                Username            = “Dr.Falken”,
                Password            = “Joshua”
                // For persistence use:
                //StorageLocation   = “file://TagExampleDB.fs”,
                //StorageLocation   = “net.tcp://127.0.0.1:8000”,
            };

            GDB.CreateDatabase(true);

            // Create types tag and website using reflection
            GDB.CreateTypes(CheckResult, new Tag(), new Website());

            // Insert tags
            var _good  = new Tag() { Name = “good”  };
            var _funny = new Tag() { Name = “funny” };
            GDB.Insert(CheckResult, _good, _funny);

            // Insert websites and link them to their tags
            var _cnn   = new Website() {
                            Name = “CNN”,
                            URL  = “http://cnn.com/”,
                            Tags = new List<Tag>() { _good }
                         };

            var _xkcd  = new Website() {
                            Name = “xkcd”,
                            URL  = “http://xkcd.com/”,
                            Tags = new List<Tag>() { _good, _funny }
                         };

            var _onion = new Website() {
                            Name = “onion”,
                            URL  = “http://theonion.com/”,
                            Tags = new List<Tag>() { _funny }
                         };

            GDB.Insert(CheckResult, _cnn, _xkcd, _onion);

            // Find out which tags xkcd is tagged with
            var _xkcdtags = GDB.Query(“FROM Website w SELECT w.Tags ” +
                                      “WHERE w.Name = ‘xkcd’ DEPTH 1”);
            foreach (var _tag in (List<DBObjectReadout>) _xkcdtags[“Tags”])
                Console.WriteLine(_tag[“Name”]);

            // List tagged sites
            var _taggedsites = GDB.Query(“FROM Website w SELECT w.Name, ” +
                                         “Count(w.Tags) AS Counter ” +
                                         “WHERE Count(w.Tags)>0”);
            foreach (var _sites in (List<DBObjectReadout>) _taggedsites[0])
                Console.WriteLine(“{0} => {1}”, _sites[“Name”], _sites[“Counter”]);

            // Start a REST service on localhost port 9975
            GDB.StartREST(new Uri(“http://localhost:9975”));

            // Start the GraphDB command line interface
            GDB.OpenCLI(typeof(ABasicFSCLICommands),
                        typeof(AAdvancedFSCLICommands),
                        typeof(ABasicDBCLICommands),
                        typeof(AAdvancedDBCLICommands));

            GDB.Shutdown();

        }

        public static void Main(string[] myArgs)
        {
            var w = new TagExample();
            w.Run();
        }

    }
}

Update: I’ve just got another submission from Filament. Code is included below and their original post is ☞ here

Filament version

public class FirstStepDemo {

    public static final String KEY_LABEL = “label”;
    public static final String KEY_URI = “uri”;

    // These could also be an enum but I find the
    // values to be unrelated from a ‘type’ perspective.
    public static final String TAG = “tag”;
    public static final String TAGGED_WITH = “taggedWith”;

    private static SimpleGraph graph;

    public static void main( String[] args ) throws Exception {

        Connection conn = getJdbcConnection(args);
        conn.setAutoCommit(false);

        graph = DefaultGraph.create(new SqlStoreFactory(conn));

        try {
            Node tagLibrary = getTagLibrary();

            Node cnn = getOrCreateResource(“http://cnn.com/”);
            Node onion = getOrCreateResource(“http://theonion.com/”);
            Node xkcd = getOrCreateResource(“http://xkcd.com/”);

            Node funny = getOrCreateTag(“funny”);
            Node good = getOrCreateTag(“good”);

            tagResource( cnn, good );
            tagResource( xkcd, good );
            tagResource( onion, funny );
            tagResource( xkcd, funny );

            System.out.println( “Listing all tags and resources” );
            for( Edge tagEdge : getTagLibrary().edges( TAG ) ) {
                Node tag = tagEdge.getHead();
                System.out.println(“\t” + tag.get( KEY_LABEL ));
                for( Edge taggedEdge : tag.edges( TAGGED_WITH ) ) {
                    Node resource = taggedEdge.otherEnd(tag);
                    System.out.println(“\t\t” + resource.get(KEY_URI));
                }
            }

            System.out.println( “Xkcd is tagged with:” );
            for( Edge e : xkcd.edges( TAGGED_WITH ) ) {
                Node tag = e.otherEnd(xkcd);
                System.out.println(“\t” + tag.get(KEY_LABEL));
            }

            System.out.println( “All tagged sites (note there are no duplicates)” );
            Predicate tagFilter = new Predicate() {
                    public boolean apply( Step step ) {
                        // Return true for any steps traversing
                        // through a TAGGED_WITH edge.
                        return TAGGED_WITH.equals( step.getEdge().getType() );
                    }
                };

            NodeTraverser traverser = new FilteredNodeTraverser(false)
                            .out(TAG)
                            .in(TAGGED_WITH)
                            .onlyReturn(tagFilter);

            for( Node n : traverser.nodes( getTagLibrary() ) ) {
                System.out.println( “\t” + n.get( KEY_URI ) );
            }

            conn.commit();
        } finally {
            graph.close();
            conn.close();
        }
    }

    private static Node getTagLibrary() {
        // For now, just use the cardinal root node as in the neo4j
        // example.
        return graph.rootNode();
    }

    private static void tagResource( Node resource, Node tag ) {

        // See if it’s already been tagges with this tag
        if( resource.connection( tag, TAGGED_WITH, Direction.OUT ) != null )
            return;

        resource.addEdge( tag, TAGGED_WITH );
    }

    private static Node getOrCreateTag( String label ) {

        Collection found = graph.findObjects( KEY_LABEL, label );
        Node result;
        if( !found.isEmpty() ) {
            result = (Node)found.iterator().next();
        } else {
            result = graph.newNode();
            result.put( KEY_LABEL, label );
            getTagLibrary().addEdge( result, TAG );
        }
        return result;
    }

    private static Node getOrCreateResource( String uri )  {

        Collection found = graph.findObjects( KEY_URI, uri );
        Node result;
        if( !found.isEmpty() ) {
            result = (Node)found.iterator().next();
        } else {
            result = graph.newNode();
            result.put( KEY_URI, uri );
        }
        return result;
    }

    /**
     *  Creates a JDBC connection for driver, JDBC URL, and optional
     *  user and password.
     */
    public static Connection getJdbcConnection( String… args ) throws Exception {

        if( args.length < 2 )
            throw new RuntimeException( “Must specify at least driver and JDBC URL.” );

        Class.forName( args[0] );
        String jdbcUrl = args[1];
        String user = null;
        String pword = null;
        if( args.length == 4 ) {
            user = args[2];
            pword = args[3];
        }

        return DriverManager.getConnection( jdbcUrl, user, pword );
    }
}

InfiniteGraph version

Update: Thanks to ☞ Todd Stavish we now have a version of this sample code for InfiniteGraph

public class TagExample
{

  public static void main(String[] args)
  { 
    Transaction tx = null;
    GraphDatabase graphDB = null;
    try
    {
      // Create graph database
      String graphName = “TagGraph”;
      String props = “graph.properties”;
      GraphFactory.create(graphName, props);
      graphDB = GraphFactory.open(graphName, props);

      // Start transaction
      tx = graphDB.beginTransaction(AccessMode.READ_WRITE);
      
      // Create resources and tags
      Resource cnn = new Resource(“http://cnn.com/”);
      Resource onion = new Resource(“http://theonion.com/”);
      Resource xkcd = new Resource(“http://xkcd.com/”);
      Tag good = new Tag(“good”);
      Tag funny = new Tag(“funny”);
      
      // Timestamp the tags
      java.util.Date date = new java.util.Date();
      Timestamp time = new Timestamp(date.getTime());
      TaggedWith tagT1 = new TaggedWith(time);
      TaggedWith tagT2 = new TaggedWith(time);
      TaggedWith tagT3 = new TaggedWith(time);
      TaggedWith tagT4 = new TaggedWith(time);
      
      // Add vertices to graph
      graphDB.addVertex(cnn);
      graphDB.addVertex(onion);
      graphDB.addVertex(xkcd);
      graphDB.addVertex(good);
      graphDB.addVertex(funny);
      
      // Connect the vertices: Resources to tags
      cnn.addEdge(tagT1, good, EdgeKind.BIDIRECTIONAL);
      xkcd.addEdge(tagT2, good, EdgeKind.BIDIRECTIONAL);
      onion.addEdge(tagT3, funny, EdgeKind.BIDIRECTIONAL);
      xkcd.addEdge(tagT4, funny, EdgeKind.BIDIRECTIONAL);

      // Name the vertex for search capability
      graphDB.nameVertex(“xkcd”, xkcd);
      
      // Commit the graph additions, downgrading to read
      tx.checkpoint(true);
      
      // Do some querying
      System.out.println(“Listing all tags and resources:”);
      System.out.println(“Tag: ” + good.toString());
      for (EdgeHandle edge: good.getEdges())
    	System.out.println(” Resource: ” + edge.getEdge().getOrigin().toString());
      System.out.println(“Tag: ” + funny.toString());
      for (EdgeHandle edge: funny.getEdges())
    	System.out.println(” Resource: ” + edge.getEdge().getOrigin().toString());
      
      // Find xkcd’s tags
      // Note: using named vertex retrieval instead of existing reference
      System.out.println(“xkcd is tagged with:”);
      Resource resource = (Resource)graphDB.getNamedVertex(“xkcd”);
      for (EdgeHandle edge: resource.getEdges())
      	System.out.println(” Tag: ” + edge.getEdge().getTarget().toString());
      
      // List all paths to tagged sites
      System.out.println(“Listing all paths to tagged sites:”);
      PrintPathResultsHandler resultPrinter = new PrintPathResultsHandler();
      isResource qualifier = new isResource();
      Navigator navigator;
      navigator = good.navigate(Guide.SIMPLE_BREADTH_FIRST, Qualifier.ANY, qualifier, resultPrinter);
      navigator.start();
      navigator.stop();
      navigator = funny.navigate(Guide.SIMPLE_BREADTH_FIRST, Qualifier.ANY, qualifier, resultPrinter);
      navigator.start();
      navigator.stop();
      
      // Commit transaction
      tx.commit();
      
      //Delete the Database from the System
      System.out.println();
      System.out.println(“Tag Database removed”);
      GraphFactory.delete(graphName, props);
      
    }
    catch (ConfigurationException cE)
    {
      System.out.println(” Configuration Exception was thrown .. “);
      System.out.println(cE.getMessage());
    }
    finally
    {
      // If the transaction was not committed, complete
      // will roll it back
      if (tx != null)
        tx.complete();
      if (graphDB != null)
        graphDB.close();
    }
  }
}

/*
* The persistent class definition for the Resource Vertex type
*/
class Resource extends BaseVertex
{
  private String uri;

  public Resource(String uri)
  {
    setURI(uri);
  }

  public String getURI() 
  {
    fetch();
    return this.uri;
  }

  public void setURI(String uri) 
  { 
    markModified();
    this.uri = uri; 
  } 

  @Override
  public String toString()
  {
    return this.uri;
  }

};

/*
* The persistent class definition for the Tag Vertex type
*/
class Tag extends BaseVertex
{
  private String label;

  public Tag(String label)
  {
    setLabel(label);
  }

  public String getLabel() 
  {
    fetch();
    return this.label;
  }

  public void setLabel(String label) 
  { 
    markModified();
    this.label = label; 
  } 

  @Override
  public String toString()
  {
    return this.label;
  }

};

/*
* The persistent class definition for the TaggedWith Edge type
*/
class TaggedWith extends BaseEdge
{
  private Timestamp stamp;
  
  public TaggedWith(Timestamp stamp)
  {
    setStamp(stamp);
  }

  public Timestamp getstamp() 
  {
    fetch();
    return this.stamp;
  }

  public void setStamp(Timestamp stamp) 
  { 
    markModified();
    this.stamp = stamp; 
  } 

  public String getStamp()
  {
    return “Created on ” + stamp;
  }
  
};

/*
 * For every result passing through all the qualifiers in the navigation,
 * this will print out all the possible paths.
 */
class PrintPathResultsHandler implements NavigationResultHandler
{
  public void handleResultPath(Path result, Navigator navigator)
  {
    System.out.print(“Found matching path : “);
    System.out.print(result.get(0).getVertex().toString());

    // For h in p
    for(Hop h : result)
    {
      if(h.hasEdge())
      {
        System.out.print(“<->” + h.getVertex().toString());
      } 
    }
    System.out.println();
  }
};

/*
 * This qualifier only return true if the end of the path is a resource
 */
class isResource implements Qualifier
{
  public boolean qualify(Path currentPath)
  {
    //this is a qualifying path if the last vertex of this path is a Resource
    if (currentPath.getFinalHop().getVertex().hasProperty(“uri”))
      return true;
    else
      return false;
  }
};

myNoSQL

NoSQL Databases and Polyglot Persistence: A Curated Guide

Tuesday, 3 August 2010

InfiniteGraph Graph Database Reaches 1.0 Release

infinitegraph

releases

graph database

graphdb

Thursday, 8 July 2010

Release: InfiniteGraph 0.9, 64bit versions and weighted edges

infinitegraph

graph database

Friday, 25 June 2010

Release: First Public Beta of InfiniteGraph

infinitegraph

graph database

releases

Monday, 22 February 2010

Get a Taste of Graph Databases: InfoGrid and Neo4j

csharp

filament

graph database

infogrid

java

neo4j

sones

infinitegraph

InfoGrid version

Neo4j version

Sones version

Filament version

InfiniteGraph version

Most Popular Articles