@Override public EngineException[] bulk(Bulk bulk) throws EngineException { EngineException[] failures = null; rwl.readLock().lock(); try { IndexWriter writer = this.indexWriter; if (writer == null) { throw new EngineClosedException(shardId); } for (int i = 0; i < bulk.ops().length; i++) { Operation op = bulk.ops()[i]; if (op == null) { continue; } try { switch (op.opType()) { case CREATE: Create create = (Create) op; writer.addDocument(create.doc(), create.analyzer()); translog.add(new Translog.Create(create)); break; case INDEX: Index index = (Index) op; writer.updateDocument(index.uid(), index.doc(), index.analyzer()); translog.add(new Translog.Index(index)); break; case DELETE: Delete delete = (Delete) op; writer.deleteDocuments(delete.uid()); translog.add(new Translog.Delete(delete)); break; } } catch (Exception e) { if (failures == null) { failures = new EngineException[bulk.ops().length]; } switch (op.opType()) { case CREATE: failures[i] = new CreateFailedEngineException(shardId, (Create) op, e); break; case INDEX: failures[i] = new IndexFailedEngineException(shardId, (Index) op, e); break; case DELETE: failures[i] = new DeleteFailedEngineException(shardId, (Delete) op, e); break; } } } dirty = true; } finally { rwl.readLock().unlock(); } return failures; }
@Override public void delete(Delete delete) throws EngineException { rwl.readLock().lock(); try { IndexWriter writer = this.indexWriter; if (writer == null) { throw new EngineClosedException(shardId); } writer.deleteDocuments(delete.uid()); translog.add(new Translog.Delete(delete)); dirty = true; if (delete.refresh()) { refresh(new Refresh(false)); } } catch (IOException e) { throw new DeleteFailedEngineException(shardId, delete, e); } finally { rwl.readLock().unlock(); } }
private void innerDelete(Delete delete) throws IOException { synchronized (dirtyLock(delete.uid())) { lastWriteNanos = delete.startTime(); final long currentVersion; final boolean deleted; VersionValue versionValue = versionMap.getUnderLock(delete.uid().bytes()); if (versionValue == null) { currentVersion = loadCurrentVersionFromIndex(delete.uid()); deleted = currentVersion == Versions.NOT_FOUND; } else { deleted = versionValue.delete(); if (engineConfig.isEnableGcDeletes() && versionValue.delete() && (engineConfig.getThreadPool().estimatedTimeInMillis() - versionValue.time()) > getGcDeletesInMillis()) { currentVersion = Versions.NOT_FOUND; // deleted, and GC } else { currentVersion = versionValue.version(); } } long updatedVersion; long expectedVersion = delete.version(); if (delete .versionType() .isVersionConflictForWrites(currentVersion, expectedVersion, deleted)) { if (delete.origin() == Operation.Origin.RECOVERY) { return; } else { throw new VersionConflictEngineException( shardId, delete.type(), delete.id(), delete .versionType() .explainConflictForWrites(currentVersion, expectedVersion, deleted)); } } updatedVersion = delete.versionType().updateVersion(currentVersion, expectedVersion); final boolean found; if (currentVersion == Versions.NOT_FOUND) { // doc does not exist and no prior deletes found = false; } else if (versionValue != null && versionValue.delete()) { // a "delete on delete", in this case, we still increment the version, log it, and return // that version found = false; } else { // we deleted a currently existing document indexWriter.deleteDocuments(delete.uid()); found = true; } delete.updateVersion(updatedVersion, found); Translog.Location translogLocation = translog.add(new Translog.Delete(delete)); versionMap.putUnderLock( delete.uid().bytes(), new DeleteVersionValue( updatedVersion, engineConfig.getThreadPool().estimatedTimeInMillis(), translogLocation)); delete.setTranslogLocation(translogLocation); } }