Java Mapping类代码示例

import org.elasticsearch.index.mapper.Mapping; //导入依赖的package包/类
private Engine.IndexingOperation updateMappingIfRequired(ShardUpsertRequest request,
                                                         ShardUpsertRequest.Item item,
                                                         long version,
                                                         IndexShard indexShard,
                                                         Engine.IndexingOperation operation) throws Throwable {
    Mapping update = operation.parsedDoc().dynamicMappingsUpdate();
    if (update != null) {
        mappingUpdatedAction.updateMappingOnMasterSynchronously(
                request.shardId().getIndex(), request.type(), update);

        operation = prepareIndexOnPrimary(indexShard, version, request, item);
        if (operation.parsedDoc().dynamicMappingsUpdate() != null) {
            throw new RetryOnPrimaryException(request.shardId(),
                    "Dynamics mappings are not available on the node that holds the primary yet");
        }
    }
    return operation;
}
 

import org.elasticsearch.index.mapper.Mapping; //导入依赖的package包/类
public void updateMappingOnMaster(String index, String type, Mapping mappingUpdate, final TimeValue timeout, final MappingUpdateListener listener) {
    final PutMappingRequestBuilder request = updateMappingRequest(index, type, mappingUpdate, timeout);
    if (listener == null) {
        request.execute();
    } else {
        final ActionListener<PutMappingResponse> actionListener = new ActionListener<PutMappingResponse>() {
            @Override
            public void onResponse(PutMappingResponse response) {
                if (response.isAcknowledged()) {
                    listener.onMappingUpdate();
                } else {
                    listener.onFailure(new TimeoutException("Failed to acknowledge the mapping response within [" + timeout + "]"));
                }
            }

            @Override
            public void onFailure(Throwable e) {
                listener.onFailure(e);
            }
        };
        request.execute(actionListener);
    }
}
 

import org.elasticsearch.index.mapper.Mapping; //导入依赖的package包/类
private void maybeAddMappingUpdate(String type, Mapping update, String docId, boolean allowMappingUpdates) {
    if (update == null) {
        return;
    }
    if (allowMappingUpdates == false) {
        throw new MapperException("mapping updates are not allowed (type: [" + type + "], id: [" + docId + "])");
    }
    Mapping currentUpdate = recoveredTypes.get(type);
    if (currentUpdate == null) {
        recoveredTypes.put(type, update);
    } else {
        currentUpdate = currentUpdate.merge(update, false);
    }
}
 

import org.elasticsearch.index.mapper.Mapping; //导入依赖的package包/类
private PutMappingRequestBuilder updateMappingRequest(Index index, String type, Mapping mappingUpdate, final TimeValue timeout) {
    if (type.equals(MapperService.DEFAULT_MAPPING)) {
        throw new IllegalArgumentException("_default_ mapping should not be updated");
    }
    return client.preparePutMapping().setConcreteIndex(index).setType(type).setSource(mappingUpdate.toString(), XContentType.JSON)
            .setMasterNodeTimeout(timeout).setTimeout(timeout);
}
 

import org.elasticsearch.index.mapper.Mapping; //导入依赖的package包/类
private static ParsedDocument testParsedDocument(String id, String type, String routing, Document document, BytesReference source, Mapping mappingUpdate) {
    Field uidField = new Field("_uid", Uid.createUid(type, id), UidFieldMapper.Defaults.FIELD_TYPE);
    Field versionField = new NumericDocValuesField("_version", 0);
    SeqNoFieldMapper.SequenceID seqID = SeqNoFieldMapper.SequenceID.emptySeqID();
    document.add(uidField);
    document.add(versionField);
    document.add(seqID.seqNo);
    document.add(seqID.seqNoDocValue);
    document.add(seqID.primaryTerm);
    return new ParsedDocument(versionField, seqID, id, type, routing, Arrays.asList(document), source, XContentType.JSON,
        mappingUpdate);
}
 

import org.elasticsearch.index.mapper.Mapping; //导入依赖的package包/类
private ParsedDocument testParsedDocument(String id, String type, String routing, ParseContext.Document document, BytesReference source, Mapping mappingsUpdate) {
    Field uidField = new Field("_uid", Uid.createUid(type, id), UidFieldMapper.Defaults.FIELD_TYPE);
    Field versionField = new NumericDocValuesField("_version", 0);
    SeqNoFieldMapper.SequenceID seqID = SeqNoFieldMapper.SequenceID.emptySeqID();
    document.add(uidField);
    document.add(versionField);
    document.add(seqID.seqNo);
    document.add(seqID.seqNoDocValue);
    document.add(seqID.primaryTerm);
    document.add(new LongPoint("point_field", 42)); // so that points report memory/disk usage
    return new ParsedDocument(versionField, seqID, id, type, routing, Arrays.asList(document), source, XContentType.JSON,
        mappingsUpdate);
}
 

import org.elasticsearch.index.mapper.Mapping; //导入依赖的package包/类
private ParsedDocument testParsedDocument(String id, String type, String routing,
                                          ParseContext.Document document, BytesReference source, Mapping mappingUpdate) {
    Field uidField = new Field("_uid", Uid.createUid(type, id), UidFieldMapper.Defaults.FIELD_TYPE);
    Field versionField = new NumericDocValuesField("_version", 0);
    SeqNoFieldMapper.SequenceID seqID = SeqNoFieldMapper.SequenceID.emptySeqID();
    document.add(uidField);
    document.add(versionField);
    document.add(seqID.seqNo);
    document.add(seqID.seqNoDocValue);
    document.add(seqID.primaryTerm);
    return new ParsedDocument(versionField, seqID, id, type, routing, Arrays.asList(document), source, XContentType.JSON,
        mappingUpdate);
}
 

import org.elasticsearch.index.mapper.Mapping; //导入依赖的package包/类
private ParsedDocument testParsedDocument(String id, String type, String routing, long seqNo,
                                          ParseContext.Document document, BytesReference source, XContentType xContentType,
                                          Mapping mappingUpdate) {
    Field uidField = new Field("_uid", Uid.createUid(type, id), UidFieldMapper.Defaults.FIELD_TYPE);
    Field versionField = new NumericDocValuesField("_version", 0);
    SeqNoFieldMapper.SequenceID seqID = SeqNoFieldMapper.SequenceID.emptySeqID();
    document.add(uidField);
    document.add(versionField);
    document.add(seqID.seqNo);
    document.add(seqID.seqNoDocValue);
    document.add(seqID.primaryTerm);
    return new ParsedDocument(versionField, seqID, id, type, routing,
            Collections.singletonList(document), source, xContentType, mappingUpdate);
}
 

import org.elasticsearch.index.mapper.Mapping; //导入依赖的package包/类
private void validateMappingUpdate(final String indexName, final String type, Mapping update) {
    final CountDownLatch latch = new CountDownLatch(1);
    final AtomicReference<Throwable> error = new AtomicReference<>();
    mappingUpdatedAction.updateMappingOnMaster(indexName, type, update, waitForMappingUpdatePostRecovery, new MappingUpdatedAction.MappingUpdateListener() {
        @Override
        public void onMappingUpdate() {
            latch.countDown();
        }

        @Override
        public void onFailure(Throwable t) {
            latch.countDown();
            error.set(t);
        }
    });
    cancellableThreads.execute(new CancellableThreads.Interruptable() {
        @Override
        public void run() throws InterruptedException {
            try {
                if (latch.await(waitForMappingUpdatePostRecovery.millis(), TimeUnit.MILLISECONDS) == false) {
                    logger.debug("waited for mapping update on master for [{}], yet timed out", type);
                } else {
                    if (error.get() != null) {
                        throw new IndexShardRecoveryException(shardId, "Failed to propagate mappings on master post recovery", error.get());
                    }
                }
            } catch (InterruptedException e) {
                logger.debug("interrupted while waiting for mapping update");
                throw e;
            }
        }
    });
}
 

import org.elasticsearch.index.mapper.Mapping; //导入依赖的package包/类
/**
 * After the store has been recovered, we need to start the engine in order to apply operations
 */
public Map<String, Mapping> performTranslogRecovery(boolean indexExists) {
    if (indexExists == false) {
        // note: these are set when recovering from the translog
        final RecoveryState.Translog translogStats = recoveryState().getTranslog();
        translogStats.totalOperations(0);
        translogStats.totalOperationsOnStart(0);
    }
    final Map<String, Mapping> recoveredTypes = internalPerformTranslogRecovery(false, indexExists);
    assert recoveryState.getStage() == RecoveryState.Stage.TRANSLOG : "TRANSLOG stage expected but was: " + recoveryState.getStage();
    return recoveredTypes;
}
 

import org.elasticsearch.index.mapper.Mapping; //导入依赖的package包/类
private Map<String, Mapping> internalPerformTranslogRecovery(boolean skipTranslogRecovery, boolean indexExists) {
    if (state != IndexShardState.RECOVERING) {
        throw new IndexShardNotRecoveringException(shardId, state);
    }

    recoveryState.setStage(RecoveryState.Stage.VERIFY_INDEX);
    // also check here, before we apply the translog
    if (Booleans.parseBoolean(checkIndexOnStartup, false)) {
        try {
            checkIndex();
        } catch (IOException ex) {
            throw new RecoveryFailedException(recoveryState, "check index failed", ex);
        }
    }
    recoveryState.setStage(RecoveryState.Stage.TRANSLOG);
    // we disable deletes since we allow for operations to be executed against the shard while recovering
    // but we need to make sure we don't loose deletes until we are done recovering
    engineConfig.setEnableGcDeletes(false);
    engineConfig.setCreate(indexExists == false);
    if (recoveryState.getType() == RecoveryState.Type.SNAPSHOT) {
        engineConfig.setIgnoreTranslogStatus(true);
    } else {
        engineConfig.setIgnoreTranslogStatus(false);
    }
    if (skipTranslogRecovery == false) {
        // This will activate our shard so we get our fair share of the indexing buffer during recovery:
        markLastWrite();
    }
    createNewEngine(skipTranslogRecovery, engineConfig);
    return engineConfig.getTranslogRecoveryPerformer().getRecoveredTypes();
}
 

import org.elasticsearch.index.mapper.Mapping; //导入依赖的package包/类
private PutMappingRequestBuilder updateMappingRequest(String index, String type, Mapping mappingUpdate, final TimeValue timeout) {
    if (type.equals(MapperService.DEFAULT_MAPPING)) {
        throw new IllegalArgumentException("_default_ mapping should not be updated");
    }
    return client.preparePutMapping(index).setType(type).setSource(mappingUpdate.toString())
        .setMasterNodeTimeout(timeout).setTimeout(timeout);
}
 

import org.elasticsearch.index.mapper.Mapping; //导入依赖的package包/类
/**
 * Returns the recovered types modifying the mapping during the recovery
 */
public Map<String, Mapping> getRecoveredTypes() {
    return recoveredTypes;
}
 

import org.elasticsearch.index.mapper.Mapping; //导入依赖的package包/类
/**
 * Update mappings synchronously on the master node, waiting for at most
 * {@code timeout}. When this method returns successfully mappings have
 * been applied to the master node and propagated to data nodes.
 */
public void updateMappingOnMaster(Index index, String type, Mapping mappingUpdate, TimeValue timeout) throws Exception {
    if (updateMappingRequest(index, type, mappingUpdate, timeout).get().isAcknowledged() == false) {
        throw new TimeoutException("Failed to acknowledge mapping update within [" + timeout + "]");
    }
}
 

import org.elasticsearch.index.mapper.Mapping; //导入依赖的package包/类
private Mapping dynamicUpdate() {
    BuilderContext context = new BuilderContext(
        Settings.builder().put(IndexMetaData.SETTING_VERSION_CREATED, Version.CURRENT).build(), new ContentPath());
    final RootObjectMapper root = new RootObjectMapper.Builder("some_type").build(context);
    return new Mapping(Version.CURRENT, root, new MetadataFieldMapper[0], emptyMap());
}