public void performWork(LuceneWork work, IndexWriter writer) {
    final Class<?> entityType = work.getEntityClass();
    final Serializable id = work.getId();
    log.tracef("Removing %s#%s by query.", entityType, id);
    DocumentBuilderIndexedEntity<?> builder = workspace.getDocumentBuilder(entityType);

    BooleanQuery entityDeletionQuery = new BooleanQuery();

    Query idQueryTerm;
    if (isIdNumeric(builder)) {
      idQueryTerm = NumericFieldUtils.createExactMatchQuery(builder.getIdKeywordName(), id);
    } else {
      idQueryTerm = new TermQuery(builder.getTerm(id));
    }
    entityDeletionQuery.add(idQueryTerm, BooleanClause.Occur.MUST);

    Term classNameQueryTerm = new Term(ProjectionConstants.OBJECT_CLASS, entityType.getName());
    TermQuery classNameQuery = new TermQuery(classNameQueryTerm);
    entityDeletionQuery.add(classNameQuery, BooleanClause.Occur.MUST);

    try {
      writer.deleteDocuments(entityDeletionQuery);
    } catch (Exception e) {
      String message = "Unable to remove " + entityType + "#" + id + " from index.";
      throw new SearchException(message, e);
    }
  }
 @Override
 public final void performOperation(
     LuceneWork work,
     IndexShardingStrategy shardingStrategy,
     WorkQueuePerIndexSplitter context) {
   IndexManager indexManager =
       shardingStrategy.getIndexManagerForAddition(
           work.getEntityClass(), work.getId(), work.getIdInString(), work.getDocument());
   context.getIndexManagerQueue(indexManager).add(work);
 }
 @Override
 public final void performOperation(
     LuceneWork work,
     IndexShardingStrategy shardingStrategy,
     WorkQueuePerIndexSplitter context) {
   IndexManager[] indexManagers =
       shardingStrategy.getIndexManagersForDeletion(
           work.getEntityClass(), work.getId(), work.getIdInString());
   for (IndexManager indexManager : indexManagers) {
     context.getIndexManagerQueue(indexManager).add(work);
   }
 }
  public void testFieldBridge() throws Exception {
    LeakingLuceneBackend.reset();

    PersonPK johnDoePk = new PersonPK();
    johnDoePk.setFirstName("John");
    johnDoePk.setLastName("Doe");
    PersonCustomDocumentId johnDoe = new PersonCustomDocumentId();
    johnDoe.setFavoriteColor("Blue");
    johnDoe.setPersonNames(johnDoePk);
    johnDoe.setSecurityNumber("AB123");

    Session s = openSession();
    Transaction tx = s.beginTransaction();
    s.save(johnDoe);
    tx.commit();
    s.clear();

    List<LuceneWork> lastProcessedQueue = LeakingLuceneBackend.getLastProcessedQueue();
    assertEquals(1, lastProcessedQueue.size());
    LuceneWork luceneWork = lastProcessedQueue.get(0);
    assertEquals("AB123", luceneWork.getIdInString());

    tx = s.beginTransaction();

    QueryBuilder queryBuilder =
        getSearchFactory().buildQueryBuilder().forEntity(PersonCustomDocumentId.class).get();
    Query query =
        queryBuilder.keyword().onField("id").ignoreAnalyzer().matching("AB123").createQuery();

    List results =
        Search.getFullTextSession(s)
            .createFullTextQuery(query, PersonCustomDocumentId.class)
            .list();
    assertEquals(1, results.size());
    johnDoe = (PersonCustomDocumentId) results.get(0);
    johnDoe.setFavoriteColor("Red");
    tx.commit();
    s.clear();

    tx = s.beginTransaction();
    results =
        Search.getFullTextSession(s)
            .createFullTextQuery(query, PersonCustomDocumentId.class)
            .list();
    assertEquals(1, results.size());
    johnDoe = (PersonCustomDocumentId) results.get(0);
    assertEquals("Red", johnDoe.getFavoriteColor());
    s.delete(results.get(0));
    tx.commit();
    s.close();
  }
 private void sendWorkToShards(LuceneWork work, boolean forceAsync) {
   final Class<?> entityType = work.getEntityClass();
   EntityIndexBinding entityIndexBinding = searchFactoryImplementor.getIndexBinding(entityType);
   IndexShardingStrategy shardingStrategy = entityIndexBinding.getSelectionStrategy();
   if (forceAsync) {
     work.getWorkDelegate(StreamingSelectionVisitor.INSTANCE)
         .performStreamOperation(work, shardingStrategy, progressMonitor, forceAsync);
   } else {
     WorkQueuePerIndexSplitter workContext = new WorkQueuePerIndexSplitter();
     work.getWorkDelegate(TransactionalSelectionVisitor.INSTANCE)
         .performOperation(work, shardingStrategy, workContext);
     workContext.commitOperations(
         progressMonitor); // FIXME I need a "Force sync" actually for when using PurgeAll before
                           // the indexing starts
   }
 }
 @Override
 public void performWork(LuceneWork work, IndexWriterDelegate delegate, IndexingMonitor monitor) {
   final Serializable id = work.getId();
   final String tenantId = work.getTenantId();
   final Class<?> managedType = work.getEntityClass();
   DocumentBuilderIndexedEntity builder = workspace.getDocumentBuilder(managedType);
   try {
     if (DeleteWorkExecutor.isIdNumeric(builder)) {
       log.tracef(
           "Deleting %s#%s by query using an IndexWriter#updateDocument as id is Numeric",
           managedType, id);
       Query exactMatchQuery =
           NumericFieldUtils.createExactMatchQuery(builder.getIdKeywordName(), id);
       BooleanQuery.Builder deleteDocumentsQueryBuilder = new BooleanQuery.Builder();
       deleteDocumentsQueryBuilder.add(exactMatchQuery, Occur.FILTER);
       if (tenantId != null) {
         TermQuery tenantTermQuery =
             new TermQuery(new Term(DocumentBuilderIndexedEntity.TENANT_ID_FIELDNAME, tenantId));
         deleteDocumentsQueryBuilder.add(tenantTermQuery, Occur.FILTER);
       }
       delegate.deleteDocuments(deleteDocumentsQueryBuilder.build());
       // no need to log the Add operation as we'll log in the delegate
       this.addDelegate.performWork(work, delegate, monitor);
     } else {
       log.tracef("Updating %s#%s by id using an IndexWriter#updateDocument.", managedType, id);
       Term idTerm = new Term(builder.getIdKeywordName(), work.getIdInString());
       Map<String, String> fieldToAnalyzerMap = work.getFieldToAnalyzerMap();
       ScopedAnalyzerReference analyzerReference = builder.getAnalyzerReference();
       analyzerReference =
           AddWorkExecutor.updateAnalyzerMappings(
               workspace, analyzerReference, fieldToAnalyzerMap);
       delegate.updateDocument(idTerm, work.getDocument(), analyzerReference);
     }
     workspace.notifyWorkApplied(work);
   } catch (Exception e) {
     String message = "Unable to update " + managedType + "#" + id + " in index.";
     throw new SearchException(message, e);
   }
   if (monitor != null) {
     monitor.documentsAdded(1l);
   }
 }