View Javadoc

    1   /**
    2    * Copyright (c) 2002-2011 "Neo Technology,"
    3    * Network Engine for Objects in Lund AB [http://neotechnology.com]
    4    *
    5    * This file is part of Neo4j.
    6    *
    7    * Neo4j is free software: you can redistribute it and/or modify
    8    * it under the terms of the GNU General Public License as published by
    9    * the Free Software Foundation, either version 3 of the License, or
    10   * (at your option) any later version.
    11   *
    12   * This program is distributed in the hope that it will be useful,
    13   * but WITHOUT ANY WARRANTY; without even the implied warranty of
    14   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    15   * GNU General Public License for more details.
    16   *
    17   * You should have received a copy of the GNU General Public License
    18   * along with this program.  If not, see <http://www.gnu.org/licenses/>.
    19   */
    20  package org.neo4j.server.rest.domain;
    21
    22  import java.util.ArrayList;
    23  import java.util.Collection;
    24  import java.util.HashMap;
    25  import java.util.Map;
    26
    27  import org.neo4j.graphdb.DynamicRelationshipType;
    28  import org.neo4j.graphdb.Node;
    29  import org.neo4j.graphdb.PropertyContainer;
    30  import org.neo4j.graphdb.Relationship;
    31  import org.neo4j.graphdb.Transaction;
    32  import org.neo4j.graphdb.index.Index;
    33  import org.neo4j.helpers.collection.MapUtil;
    34  import org.neo4j.kernel.EmbeddedGraphDatabase;
    35  import org.neo4j.server.database.Database;
    36  import org.neo4j.server.database.DatabaseBlockedException;
    37
    38  public class GraphDbHelper
    39  {
    40      private final Database database;
    41
    42      public GraphDbHelper( Database database )
    43      {
    44          this.database = database;
    45      }
    46
    47      public int getNumberOfNodes() throws DatabaseBlockedException
    48      {
    49          return numberOfEntitiesFor( Node.class );
    50      }
    51
    52      public int getNumberOfRelationships() throws DatabaseBlockedException
    53      {
    54          return numberOfEntitiesFor( Relationship.class );
    55      }
    56
    57      private int numberOfEntitiesFor( Class<? extends PropertyContainer> type ) throws DatabaseBlockedException
    58      {
    59          return (int) ((EmbeddedGraphDatabase) database.graph).getConfig().getGraphDbModule().getNodeManager().getNumberOfIdsInUse( type );
    60      }
    61
    62      public Map<String, Object> getNodeProperties( long nodeId ) throws DatabaseBlockedException
    63      {
    64          Transaction tx = database.graph.beginTx();
    65          try
    66          {
    67              Node node = database.graph.getNodeById( nodeId );
    68              Map<String, Object> allProperties = new HashMap<String, Object>();
    69              for ( String propertyKey : node.getPropertyKeys() )
    70              {
    71                  allProperties.put( propertyKey, node.getProperty( propertyKey ) );
    72              }
    73              tx.success();
    74              return allProperties;
    75          } finally
    76          {
    77              tx.finish();
    78          }
    79      }
    80
    81      public void setNodeProperties( long nodeId, Map<String, Object> properties ) throws DatabaseBlockedException
    82      {
    83          Transaction tx = database.graph.beginTx();
    84          try
    85          {
    86              Node node = database.graph.getNodeById( nodeId );
    87              for ( Map.Entry<String, Object> propertyEntry : properties.entrySet() )
    88              {
    89                  node.setProperty( propertyEntry.getKey(), propertyEntry.getValue() );
    90              }
    91              tx.success();
    92          } finally
    93          {
    94              tx.finish();
    95          }
    96      }
    97
    98      public long createNode() throws DatabaseBlockedException
    99      {
    100         Transaction tx = database.graph.beginTx();
    101         try
    102         {
    103             Node node = database.graph.createNode();
    104             tx.success();
    105             return node.getId();
    106         } finally
    107         {
    108             tx.finish();
    109         }
    110     }
    111
    112     public long createNode( Map<String, Object> properties ) throws DatabaseBlockedException
    113     {
    114         Transaction tx = database.graph.beginTx();
    115         try
    116         {
    117             Node node = database.graph.createNode();
    118             for ( Map.Entry<String, Object> entry : properties.entrySet() )
    119             {
    120                 node.setProperty( entry.getKey(), entry.getValue() );
    121             }
    122             tx.success();
    123             return node.getId();
    124         } finally
    125         {
    126             tx.finish();
    127         }
    128     }
    129
    130     public void deleteNode( long id ) throws DatabaseBlockedException
    131     {
    132         Transaction tx = database.graph.beginTx();
    133         try
    134         {
    135             Node node = database.graph.getNodeById( id );
    136             node.delete();
    137             tx.success();
    138         } finally
    139         {
    140             tx.finish();
    141         }
    142     }
    143
    144     public long createRelationship( String type, long startNodeId, long endNodeId ) throws DatabaseBlockedException
    145     {
    146         Transaction tx = database.graph.beginTx();
    147         try
    148         {
    149             Node startNode = database.graph.getNodeById( startNodeId );
    150             Node endNode = database.graph.getNodeById( endNodeId );
    151             Relationship relationship = startNode.createRelationshipTo( endNode, DynamicRelationshipType.withName( type ) );
    152             tx.success();
    153             return relationship.getId();
    154         } finally
    155         {
    156             tx.finish();
    157         }
    158     }
    159
    160     public long createRelationship( String type ) throws DatabaseBlockedException
    161     {
    162         Transaction tx = database.graph.beginTx();
    163         try
    164         {
    165             Node startNode = database.graph.createNode();
    166             Node endNode = database.graph.createNode();
    167             Relationship relationship = startNode.createRelationshipTo( endNode, DynamicRelationshipType.withName( type ) );
    168             tx.success();
    169             return relationship.getId();
    170         } finally
    171         {
    172             tx.finish();
    173         }
    174     }
    175
    176     public void setRelationshipProperties( long relationshipId, Map<String, Object> properties ) throws DatabaseBlockedException
    177     {
    178         Transaction tx = database.graph.beginTx();
    179         try
    180         {
    181             Relationship relationship = database.graph.getRelationshipById( relationshipId );
    182             for ( Map.Entry<String, Object> propertyEntry : properties.entrySet() )
    183             {
    184                 relationship.setProperty( propertyEntry.getKey(), propertyEntry.getValue() );
    185             }
    186             tx.success();
    187         } finally
    188         {
    189             tx.finish();
    190         }
    191     }
    192
    193     public Map<String, Object> getRelationshipProperties( long relationshipId ) throws DatabaseBlockedException
    194     {
    195         Transaction tx = database.graph.beginTx();
    196         try
    197         {
    198             Relationship relationship = database.graph.getRelationshipById( relationshipId );
    199             Map<String, Object> allProperties = new HashMap<String, Object>();
    200             for ( String propertyKey : relationship.getPropertyKeys() )
    201             {
    202                 allProperties.put( propertyKey, relationship.getProperty( propertyKey ) );
    203             }
    204             tx.success();
    205             return allProperties;
    206         } finally
    207         {
    208             tx.finish();
    209         }
    210     }
    211
    212     public Relationship getRelationship( long relationshipId ) throws DatabaseBlockedException
    213     {
    214         Transaction tx = database.graph.beginTx();
    215         try
    216         {
    217             Relationship relationship = database.graph.getRelationshipById( relationshipId );
    218             tx.success();
    219             return relationship;
    220         } finally
    221         {
    222             tx.finish();
    223         }
    224     }
    225
    226     public void addNodeToIndex( String indexName, String key, Object value, long id ) throws DatabaseBlockedException
    227     {
    228         Index<Node> index = database.getNodeIndex( indexName );
    229         Transaction tx = database.graph.beginTx();
    230         try
    231         {
    232             index.add( database.graph.getNodeById( id ), key, value );
    233             tx.success();
    234         } finally
    235         {
    236             tx.finish();
    237         }
    238     }
    239
    240
    241     public Collection<Long> queryIndexedNodes( String indexName, String key, Object value ) throws DatabaseBlockedException
    242     {
    243         // TODO: refactor this and getIndexedNodes to avoid dupe code
    244         Index<Node> index =  database.getNodeIndex( indexName );
    245         Transaction tx = database.graph.beginTx();
    246         try
    247         {
    248             Collection<Long> result = new ArrayList<Long>();
    249             for ( Node node : index.query( key, value ) )
    250             {
    251                 result.add( node.getId() );
    252             }
    253             tx.success();
    254             return result;
    255         } finally
    256         {
    257             tx.finish();
    258         }
    259     }
    260     public Collection<Long> getIndexedNodes( String indexName, String key, Object value ) throws DatabaseBlockedException
    261     {
    262
    263         Index<Node> index =  database.getNodeIndex( indexName );
    264         Transaction tx = database.graph.beginTx();
    265         try
    266         {
    267             Collection<Long> result = new ArrayList<Long>();
    268             for ( Node node : index.get( key, value ) )
    269             {
    270                 result.add( node.getId() );
    271             }
    272             tx.success();
    273             return result;
    274         } finally
    275         {
    276             tx.finish();
    277         }
    278     }
    279
    280     public Collection<Long> getIndexedRelationships( String indexName, String key, Object value ) throws DatabaseBlockedException
    281     {
    282
    283         Index<Relationship> index =  database.getRelationshipIndex( indexName );
    284         Transaction tx = database.graph.beginTx();
    285         try
    286         {
    287             Collection<Long> result = new ArrayList<Long>();
    288             for ( Relationship relationship : index.get( key, value ) )
    289             {
    290                 result.add( relationship.getId() );
    291             }
    292             tx.success();
    293             return result;
    294         } finally
    295         {
    296             tx.finish();
    297         }
    298     }
    299
    300     public void addRelationshipToIndex( String indexName, String key, String value, long relationshipId )
    301     {
    302         Index<Relationship> index = database.getRelationshipIndex( indexName );
    303         Transaction tx = database.graph.beginTx();
    304         try
    305         {
    306             index.add( database.graph.getRelationshipById( relationshipId ), key, value );
    307             tx.success();
    308         } finally
    309         {
    310             tx.finish();
    311         }
    312     }
    313
    314     public String[] getNodeIndexes()
    315     {
    316         return database.getIndexManager().nodeIndexNames();
    317     }
    318
    319     public Index<Node> getNodeIndex( String indexName )
    320     {
    321         return database.getIndexManager().forNodes( indexName );
    322     }
    323
    324     public Index<Node> createNodeFullTextIndex( String named )
    325     {
    326         return database.getIndexManager().forNodes( named, MapUtil.stringMap( "provider", "lucene", "type", "fulltext" ) );
    327     }
    328
    329     public Index<Node> createNodeIndex( String named )
    330     {
    331         return database.getIndexManager().forNodes( named );
    332     }
    333
    334     public String[] getRelationshipIndexes()
    335     {
    336         return database.getIndexManager().relationshipIndexNames();
    337     }
    338
    339     public long getReferenceNode()
    340     {
    341         return database.graph.getReferenceNode().getId();
    342     }
    343
    344     public Index<Relationship> getRelationshipIndex( String indexName )
    345     {
    346         return database.getIndexManager().forRelationships( indexName );
    347     }
    348
    349     public Index<Relationship> createRelationshipFullTextIndex( String named )
    350     {
    351         return database.getIndexManager().forRelationships( named, MapUtil.stringMap( "provider", "lucene", "type", "fulltext" ) );
    352     }
    353
    354     public Index<Relationship> createRelationshipIndex( String named )
    355     {
    356         return database.getIndexManager().forRelationships( named );
    357     }
    358 }