private static void setLabelSystem() {
    IndexDefinition indexDefinition;
    try (Transaction tx = graphDb.beginTx()) {
      Schema schema = graphDb.schema();
      indexDefinition = schema.indexFor(DynamicLabel.label("Nome")).on("name").create();
      tx.success();
    }

    try (Transaction tx = graphDb.beginTx()) {
      Schema schema = graphDb.schema();
      schema.awaitIndexOnline(indexDefinition, 10, TimeUnit.SECONDS);
    }
  }
示例#2
0
 protected void waitUntilIndexesAreOnline() {
   LOGGER.debug("Waiting for Indizes to Come Online.");
   try (Transaction ignored = graphDatabase.beginTx()) {
     graphDatabase.schema().awaitIndexesOnline(120, TimeUnit.SECONDS);
     LOGGER.debug("Indizes are online");
   }
 }
示例#3
0
  public IndexDefinition _createIndex(Label label, String key) {
    Schema schema = graphDb.schema();

    for (IndexDefinition index : schema.getIndexes(label))
      for (String property : index.getPropertyKeys())
        if (property.equals(key)) return index; // already existing

    return schema.indexFor(label).on(key).create();
  }
示例#4
0
  public ConstraintDefinition _createConstrant(Label label, String key) {
    Schema schema = graphDb.schema();

    for (ConstraintDefinition constraint : schema.getConstraints(label))
      for (String property : constraint.getPropertyKeys())
        if (property.equals(key)) return constraint; // already existing

    return schema.constraintFor(label).assertPropertyIsUnique(key).create();
  }
  @Test
  public void nodeCanBecomeSchemaIndexableInBeforeCommitByAddingLabel() throws Exception {
    // Given we have a schema index...
    GraphDatabaseService db = dbRule.getGraphDatabaseService();
    final Label label = DynamicLabel.label("Label");
    IndexDefinition index;
    try (Transaction tx = db.beginTx()) {
      index = db.schema().indexFor(label).on("indexed").create();
      tx.success();
    }

    // ... and a transaction event handler that likes to add the indexed property on nodes
    db.registerTransactionEventHandler(
        new TransactionEventHandler.Adapter<Object>() {
          @Override
          public Object beforeCommit(TransactionData data) throws Exception {
            Iterator<Node> nodes = data.createdNodes().iterator();
            if (nodes.hasNext()) {
              Node node = nodes.next();
              node.addLabel(label);
            }
            return null;
          }
        });

    // When we create a node with the right property, but not the right label...
    try (Transaction tx = db.beginTx()) {
      db.schema().awaitIndexesOnline(10, TimeUnit.SECONDS);
      Node node = db.createNode();
      node.setProperty("indexed", "value");
      node.setProperty("random", 42);
      tx.success();
    }

    // Then we should be able to look it up through the index.
    try (Transaction ignore = db.beginTx()) {
      Node node = db.findNode(label, "indexed", "value");
      assertThat(node.getProperty("random"), is((Object) 42));
    }
  }
示例#6
0
  @Test
  public void insert() throws InterruptedException {
    // START SNIPPET: insert
    BatchInserter inserter = null;
    try {
      inserter =
          BatchInserters.inserter(
              new File("target/batchinserter-example").getAbsolutePath(), fileSystem);

      Label personLabel = DynamicLabel.label("Person");
      inserter.createDeferredSchemaIndex(personLabel).on("name").create();

      Map<String, Object> properties = new HashMap<>();

      properties.put("name", "Mattias");
      long mattiasNode = inserter.createNode(properties, personLabel);

      properties.put("name", "Chris");
      long chrisNode = inserter.createNode(properties, personLabel);

      RelationshipType knows = DynamicRelationshipType.withName("KNOWS");
      inserter.createRelationship(mattiasNode, chrisNode, knows, null);
    } finally {
      if (inserter != null) {
        inserter.shutdown();
      }
    }
    // END SNIPPET: insert

    // try it out from a normal db
    GraphDatabaseService db =
        new TestGraphDatabaseFactory()
            .setFileSystem(fileSystem)
            .newImpermanentDatabase(new File("target/batchinserter-example").getAbsolutePath());
    try (Transaction tx = db.beginTx()) {
      Label personLabelForTesting = DynamicLabel.label("Person");
      Node mNode = db.findNode(personLabelForTesting, "name", "Mattias");
      Node cNode =
          mNode
              .getSingleRelationship(DynamicRelationshipType.withName("KNOWS"), Direction.OUTGOING)
              .getEndNode();
      assertThat((String) cNode.getProperty("name"), is("Chris"));
      assertThat(db.schema().getIndexes(personLabelForTesting).iterator().hasNext(), is(true));
    } finally {
      db.shutdown();
    }
  }
  private File databaseWithUniquenessConstraint(String label, String propertyKey) {
    File storeDir = new File(targetDir.directory(), "seed");
    GraphDatabaseService graphDb =
        new GraphDatabaseFactory().newEmbeddedDatabase(storeDir.getAbsolutePath());
    try {
      Transaction tx = graphDb.beginTx();
      try {
        graphDb.schema().constraintFor(label(label)).assertPropertyIsUnique(propertyKey).create();

        tx.success();
      } finally {
        tx.finish();
      }
    } finally {
      graphDb.shutdown();
    }
    return storeDir;
  }
示例#8
0
  /**
   * Defines constraints for the graph property model. Creates indexes for blocks and transactions.
   */
  protected void createIndexesAndUniqueConstraints() {
    try (Transaction tx = graphDatabase.beginTx()) {
      Schema schema = graphDatabase.schema();

      if (!schema.getIndexes().iterator().hasNext()) {
        LOGGER.debug("Creating Indexes and Unique Constraints.");

        schema.constraintFor(LabelType.Block).assertPropertyIsUnique("hash").create();

        schema.constraintFor(LabelType.Block).assertPropertyIsUnique("height").create();

        // No unique constraints for transactions (see BIP30)
        schema.indexFor(LabelType.Transaction).on("hash").create();

        schema.constraintFor(LabelType.Address).assertPropertyIsUnique("hash").create();

        schema.indexFor(LabelType.Coinbase).on("hash").create();

        schema.indexFor(LabelType.LatestBlock).on("height").create();
      }
      tx.success();
    }
  }
 @Override
 public Iterable<ConstraintDefinition> getConstraints() {
   return gdb.schema().getConstraints();
 }
 @Override
 public Iterable<IndexDefinition> getIndexes() {
   return gdb.schema().getIndexes();
 }