com.orientechnologies.orient.core.storage.ORecordDuplicatedException Java Examples

@Test(expected = ORecordDuplicatedException.class)
public void testIndex_EnforceUniqueName() {
  try (ODatabaseDocumentTx db = database.getInstance().connect()) {
    entityAdapter.register(db);

    OrientKeyStoreData entity = new OrientKeyStoreData();
    entity.setName(KEY_STORE_NAME);
    entity.setBytes(KEY_STORE_DATA);
    entityAdapter.save(db, entity);

    entity = new OrientKeyStoreData();
    entity.setName(KEY_STORE_NAME);
    entity.setBytes(KEY_STORE_DATA);
    entityAdapter.addEntity(db, entity);
  }
}
 

@Override
@Guarded(by = STARTED)
public char[] createApiKey(final String domain, final PrincipalCollection principals) {
  checkNotNull(domain);
  checkNotNull(principals);
  try {
    final char[] apiKeyCharArray = makeApiKey(domain, principals);
    persistApiKey(domain, principals, apiKeyCharArray);
    return apiKeyCharArray;
  }
  catch (ORecordDuplicatedException e) { // NOSONAR
    // There is a chance here that if multiple threads enter this method for the same principal that create can be
    // called multiple times resulting in a ORecordDuplicatedException. In that case we know the record must already
    // exist and can call getApiKey again. This avoids locking and gives us eventual-consistency.
    return getApiKey(domain, principals);
  }
}
 

@Override
public void addRole(final CRole role) {
  checkNotNull(role);
  checkNotNull(role.getId());
  checkRole(role);
  log.trace("Adding role: {}", role.getId());

  try {
    inTxRetry(databaseInstance).run(db -> {
      if (roleEntityAdapter.read(db, role.getId()) != null) {
        throw new DuplicateRoleException(role.getId());
      }
      roleEntityAdapter.addEntity(db, (OrientCRole) role);
    });
  }
  catch (ORecordDuplicatedException e) {
    throw new DuplicateRoleException(role.getId(), e);
  }
}
 

@Override
public Object executeTransform(final Object input) {
  vertexClass = (String) resolve(vertexClass);
  if (vertexClass != null) {
    final OClass cls = pipeline.getGraphDatabase().getVertexType(vertexClass);
    if (cls == null)
      pipeline.getGraphDatabase().createVertexType(vertexClass);
  }

  final OrientVertex v = pipeline.getGraphDatabase().getVertex(input);
  if (v == null)
    return null;

  if (vertexClass != null && !vertexClass.equals(v.getRecord().getClassName()))
    try {
      v.setProperty("@class", vertexClass);
    } catch (ORecordDuplicatedException e) {
      if (skipDuplicates) {
        return null;
      } else {
        throw e;
      }
    }
  return v;
}
 

@Test(expected = ORecordDuplicatedException.class)
public void whenUsingDuplicateNameShouldNotBeCreated() throws Exception {
  underTest.add(item);

  underTest.add(
      new OrientCleanupPolicy(item.getName(), "abcd", "OtherFormat", "OtherMode",
          newHashMap()));
}
 

@Override
@Guarded(by = STARTED)
public void createComponentNode(final String repositoryName,
                                final String format,
                                final List<BrowsePath> paths,
                                final Component component)
{
  inTxRetry(databaseInstance)
      // handle case where assets try to create the exact same component-level path at once
      .retryOn(ONeedRetryException.class, ORecordDuplicatedException.class)
      .run(db -> entityAdapter.createComponentNode(db, repositoryName, format, paths, component));
}
 

@Override
@Guarded(by = STARTED)
public void createAssetNode(final String repositoryName,
                            final String format,
                            final List<BrowsePath> paths,
                            final Asset asset)
{
  inTxRetry(databaseInstance)
      // handle case where an asset and its component try to create the exact same path at once
      .retryOn(ONeedRetryException.class, ORecordDuplicatedException.class)
      .run(db -> entityAdapter.createAssetNode(db, repositoryName, format, paths, asset));
}
 

@Override
public CPrivilege addPrivilege(final CPrivilege privilege) {
  checkNotNull(privilege);
  checkNotNull(privilege.getId());
  log.trace("Adding privilege: {}", privilege.getId());

  try {
    OrientCPrivilege persistedPrivilege = convert(privilege);
    inTxRetry(databaseInstance).run(db -> privilegeEntityAdapter.addEntity(db, persistedPrivilege));
    return persistedPrivilege;
  }
  catch (ORecordDuplicatedException e) {
    throw new DuplicatePrivilegeException(privilege.getId(), e);
  }
}
 

private void persist(BiConsumer<ODatabaseDocumentTx, OrientRoutingRule> entityFunction, RoutingRule rule) {
  try {
    inTxRetry(databaseInstance).run(db -> entityFunction.accept(db, castToOrientRoutingRule(rule)));
  }
  catch (ORecordDuplicatedException e) {
    if (OrientRoutingRuleEntityAdapter.I_NAME.equals(e.getIndexName())) {
      throw new ValidationErrorsException("name", "A rule with the same name already exists. Name must be unique.");
    }
    throw e;
  }
}
 

private void makeDataItem(String oClass, String name, String alias){
	try {
		ODocument doc = new ODocument(oClass);
		doc.field("name",name);
		doc.field("alias",alias);
		doc.save();		
	} catch (ORecordDuplicatedException e) {
		//ignore duplication
	}
}
 

@Test(expected = ORecordDuplicatedException.class)
public void duplicateComponentName() throws Exception {
  createComponent(null, "name", null);
  createComponent(null, "name", null);
}
 

@Test(expected = ORecordDuplicatedException.class)
public void duplicateComponentGroupName() throws Exception {
  createComponent("group", "name", null);
  createComponent("group", "name", null);
}
 

@Test(expected = ORecordDuplicatedException.class)
public void duplicateComponentNameVersion() throws Exception {
  createComponent(null, "name", "1");
  createComponent(null, "name", "1");
}
 

@Test(expected = ORecordDuplicatedException.class)
public void duplicateComponentGroupNameVersion() throws Exception {
  createComponent("group", "name", "1");
  createComponent("group", "name", "1");
}
 

@Test(expected = ORecordDuplicatedException.class)
public void duplicateAssetComponentName() throws Exception {
  Component component = createComponent("group", "name", "1");
  createAsset(component, "name");
  createAsset(component, "name");
}
 

@Test(expected = ORecordDuplicatedException.class)
public void duplicateAssetName() throws Exception {
  createAsset(null, "name");
  createAsset(null, "name");
}