Java CreateIndexRequestBuilder.setSettings方法代码示例

import org.elasticsearch.action.admin.indices.create.CreateIndexRequestBuilder; //导入方法依赖的package包/类
@Override
protected void createIndex() throws JsonProcessingException {
    logger.info(String.format("Creating index [%s]", INDEX));

    CreateIndexRequestBuilder createIndexRequestBuilder = client.admin().indices().prepareCreate(INDEX);
    org.elasticsearch.common.settings.Settings indexSettings = org.elasticsearch.common.settings.Settings.settingsBuilder()
            .put("number_of_shards", 3)
            .put("number_of_replicas", 1)
            //.put("analyzer", createDefaultAnalyzer())
            .build();
    createIndexRequestBuilder.setSettings(indexSettings);
    createIndexRequestBuilder.addMapping(recordDao.getType(), recordDao.createTypeMapping());
    createIndexRequestBuilder.addMapping(commentDao.getType(), commentDao.createTypeMapping());
    createIndexRequestBuilder.addMapping(MarketIndexDao.CATEGORY_TYPE, createCategoryTypeMapping());
    createIndexRequestBuilder.execute().actionGet();

    // Fill categories
    fillRecordCategories();
}
 

import org.elasticsearch.action.admin.indices.create.CreateIndexRequestBuilder; //导入方法依赖的package包/类
@Override
protected void createIndex() throws JsonProcessingException {
    logger.info(String.format("Creating index [%s]", INDEX));

    CreateIndexRequestBuilder createIndexRequestBuilder = client.admin().indices().prepareCreate(INDEX);
    org.elasticsearch.common.settings.Settings indexSettings = org.elasticsearch.common.settings.Settings.settingsBuilder()
            .put("number_of_shards", 3)
            .put("number_of_replicas", 1)
            //.put("analyzer", createDefaultAnalyzer())
            .build();
    createIndexRequestBuilder.setSettings(indexSettings);
    createIndexRequestBuilder.addMapping(recordDao.getType(), recordDao.createTypeMapping());
    createIndexRequestBuilder.addMapping(commentDao.getType(), commentDao.createTypeMapping());
    createIndexRequestBuilder.addMapping(RegistryIndexDao.CATEGORY_TYPE, createCategoryTypeMapping());
    createIndexRequestBuilder.execute().actionGet();

    // Fill categories
    fillRecordCategories();
}
 

import org.elasticsearch.action.admin.indices.create.CreateIndexRequestBuilder; //导入方法依赖的package包/类
@Override
public Observable<Boolean> call(String index) {
    Elasticsearch elasticsearch = vertxContext.verticle().elasticsearch();
    CreateIndexRequestBuilder request = elasticsearch.get().admin().indices().prepareCreate(index);
    for (Map.Entry<String, String> entry : mappings.entrySet()) {
        String type = entry.getKey();
        String mapping = entry.getValue();
        request = request.addMapping(type, mapping);
    }
    if (settings != null) {
        request.setSettings(settings);
    }

    if (LOGGER.isDebugEnabled()) {
        LOGGER.debug(format("Request %s", Jsonify.toString(request)));
    }

    return elasticsearch.execute(vertxContext, request, elasticsearch.getDefaultAdminTimeout())
            .map(Optional::get)
            .doOnNext(createIndexResponse -> {
                if (LOGGER.isDebugEnabled()) {
                    LOGGER.debug(format("Response %s", Jsonify.toString(createIndexResponse)));
                }
            })
            .map(AcknowledgedResponse::isAcknowledged);
}
 

import org.elasticsearch.action.admin.indices.create.CreateIndexRequestBuilder; //导入方法依赖的package包/类
protected boolean createMapping(MappingConfiguration mapping, String indexId) {
    IndicesAdminClient indices = getClient().admin().indices();

    Map<String, Object> schema = schemaGenerator.generate(mapping);
    log.trace("Built schema creation request:\n{}", Arrays.toString(schema.entrySet().toArray()));

    // create metadata mapping and schema mapping
    CreateIndexRequestBuilder request = indices.prepareCreate(indexId)
            .addMapping(MetadataDataMapping.METADATA_TYPE_NAME, getMetadataSchema())
            .addMapping(mapping.getType(), schema);
    if (mapping.hasIndexCreationRequest()) {
        request.setSettings(mapping.getIndexCreationRequest());
    }

    CreateIndexResponse response = request.get();
    log.debug("Created indices: {}, acknowledged: {}", response, response.isAcknowledged());

    Map<String, Object> mdRecord = createMetadataRecord(mapping.getVersion(), mapping.getName());
    IndexResponse mdResponse = getClient().prepareIndex(indexId, MetadataDataMapping.METADATA_TYPE_NAME, MetadataDataMapping.METADATA_ROW_ID).setSource(mdRecord).get();
    log.debug("Saved mapping metadata '{}': {}", mdResponse.isCreated(), Arrays.toString(mdRecord.entrySet().toArray()));

    return (mdResponse.isCreated() && response.isAcknowledged());
}
 

import org.elasticsearch.action.admin.indices.create.CreateIndexRequestBuilder; //导入方法依赖的package包/类
private void addSchema(int iter) {
       String indexIter = "";
       if (iter > 0) {
           indexIter += iter;
       }

       String mappingJSON = "{\"" + indexType + "\":{\"_timestamp\":{\"enabled\":true,\"store\":true,\"index\":\"not_analyzed\"},\"_all\":{\"enabled\":false},\"properties\":{\"trackId\":{\"type\":\"string\"},\"timestamp\":{\"type\":\"date\"},\"speed\":{\"type\":\"float\",\"index\":\"no\"}}}}";

       CreateIndexRequestBuilder builder = client.admin().indices().prepareCreate(indexName + indexIter);
       builder.addMapping(indexType, mappingJSON);

//builder.setSettings("index.number_of_shards", 1);
       //builder.setSettings("index.number_of_replicas", 0);
       //builder.setSettings("refresh_interval", "120s");
       builder.setSettings("index.store.type", "memory");

       CreateIndexResponse createResponse = builder.execute().actionGet();
       if (!createResponse.isAcknowledged()) {
           System.err.println("Index was not created!");
       }
   }
 

import org.elasticsearch.action.admin.indices.create.CreateIndexRequestBuilder; //导入方法依赖的package包/类
@Override
public BaseMetricTransportClient newIndex(String index, Settings settings, Map<String, String> mappings) {
    if (client == null) {
        logger.warn("no client for create index");
        return this;
    }
    if (index == null) {
        logger.warn("no index name given to create index");
        return this;
    }
    CreateIndexRequestBuilder createIndexRequestBuilder =
            new CreateIndexRequestBuilder(client(), CreateIndexAction.INSTANCE).setIndex(index);
    if (settings != null) {
        logger.info("settings = {}", settings.getAsStructuredMap());
        createIndexRequestBuilder.setSettings(settings);
    }
    if (mappings != null) {
        for (String type : mappings.keySet()) {
            logger.info("found mapping for {}", type);
            createIndexRequestBuilder.addMapping(type, mappings.get(type));
        }
    }
    createIndexRequestBuilder.execute().actionGet();
    logger.info("index {} created", index);
    return this;
}
 

import org.elasticsearch.action.admin.indices.create.CreateIndexRequestBuilder; //导入方法依赖的package包/类
@Override
public void createIndexIfNotExists(String settings, String mapping) {
    if (!checkStatus()) {
        return;
    }
    String realIndex = getRealIndex(indexTemplate);

    if (client.admin().indices().prepareExists(realIndex).execute().actionGet().isExists()) {
        if (Strings.hasLength(settings)) {
            client.admin().indices().prepareUpdateSettings(realIndex).setSettings(settings).execute().actionGet();
        }
        if (Strings.hasLength(mapping)) {
            client.admin().indices().preparePutMapping(realIndex).setType(type).setSource(mapping).execute().actionGet();
        }
        return;
    }
    CreateIndexRequestBuilder builder = client.admin().indices().prepareCreate(realIndex);
    if (Strings.hasLength(settings)) {
        builder.setSettings(settings);
    }
    builder.execute().actionGet();
    if (Strings.hasLength(mapping)) {
        client.admin().indices().preparePutMapping(realIndex).setType(type).setSource(mapping).execute().actionGet();
    }
}
 

import org.elasticsearch.action.admin.indices.create.CreateIndexRequestBuilder; //导入方法依赖的package包/类
/**
 * Create index need for category registry
 * @throws JsonProcessingException
 */
public void createIndex() throws JsonProcessingException {
    log.info(String.format("Creating index [%s/%s]", INDEX, CITY_TYPE));

    CreateIndexRequestBuilder createIndexRequestBuilder = client.admin().indices().prepareCreate(INDEX);
    org.elasticsearch.common.settings.Settings indexSettings = org.elasticsearch.common.settings.Settings.settingsBuilder()
            .put("number_of_shards", 1)
            .put("number_of_replicas", 1)
            //.put("analyzer", createDefaultAnalyzer())
            .build();
    createIndexRequestBuilder.setSettings(indexSettings);
    createIndexRequestBuilder.addMapping(CITY_TYPE, createIndexMapping());
    createIndexRequestBuilder.execute().actionGet();
}
 

import org.elasticsearch.action.admin.indices.create.CreateIndexRequestBuilder; //导入方法依赖的package包/类
/**
 * Create a new index with an initial mapping.
 *
 * @param indexName the name of the index to create
 * @param type      the mapping type
 * @param mapping   the mapping source
 *
 * @return true if the index was successfully created, false otherwise
 */
public static boolean create(String indexName, String type, String mapping) {
  synchronized (Indices.class) {
    if (exists(indexName)) {
      return true;
    }

    CreateIndexRequestBuilder builder = self.client.getClient().admin().indices().prepareCreate(indexName);
    builder.setSettings(Settings.builder()
        .put("number_of_shards", self.properties.getShardsPerIndex())
        .put("number_of_replicas", self.properties.getReplicasPerShard())
        .build());

    if (mapping != null) {
      builder.addMapping(type, mapping, XContentType.JSON);
    }

    log.debug("Creating new index with name {}", indexName);
    boolean created;

    try {
      CreateIndexResponse response = builder.get();
      created = response.isAcknowledged();
    } catch (ResourceAlreadyExistsException ex) {
      created = true;
    }

    self.client.waitForYellowStatus();

    if (created) {
      self.indexCache.add(indexName);
    }

    return created;
  }
}
 

import org.elasticsearch.action.admin.indices.create.CreateIndexRequestBuilder; //导入方法依赖的package包/类
public HttpBulkClient newIndex(String index, Settings settings, Map<String, String> mappings) {
    if (closed) {
        throw new ElasticsearchException("client is closed");
    }
    if (client == null) {
        logger.warn("no client for create index");
        return this;
    }
    if (index == null) {
        logger.warn("no index name given to create index");
        return this;
    }
    CreateIndexRequestBuilder createIndexRequestBuilder =
            new CreateIndexRequestBuilder(client(), CreateIndexAction.INSTANCE).setIndex(index);
    if (settings != null) {
        logger.info("settings for creating index {} = {}", index, settings.getAsStructuredMap());
        createIndexRequestBuilder.setSettings(settings);
    }
    if (mappings != null) {
        for (Map.Entry<String,String> entry : mappings.entrySet()) {
            String type = entry.getKey();
            logger.info("found mapping for {}", type);
            createIndexRequestBuilder.addMapping(type, entry.getValue());
        }
    }
    createIndexRequestBuilder.execute().actionGet();
    logger.info("index {} created", index);
    return this;
}
 

import org.elasticsearch.action.admin.indices.create.CreateIndexRequestBuilder; //导入方法依赖的package包/类
/**
 * Check if index is created. if not it will created it
 *
 * @param index The index
 * @return returns true if it just created the index. False if the index already existed
 */
private boolean createIndex(String index, Map<String, Object> defaultSettings) {
    IndicesExistsResponse res = client.admin().indices().prepareExists(index).execute().actionGet();
    boolean created = false;
    if (!res.isExists()) {
        CreateIndexRequestBuilder req = client.admin().indices().prepareCreate(index);
        req.setSettings(defaultSettings);
        created = req.execute().actionGet().isAcknowledged();
        if (!created) {
            throw new RuntimeException("Could not create index [" + index + "]");
        }
    }

    return created;
}
 

import org.elasticsearch.action.admin.indices.create.CreateIndexRequestBuilder; //导入方法依赖的package包/类
public void createIndex(String index, String settings) throws Exception {
  CreateIndexRequestBuilder builder = client.admin().indices().prepareCreate(index);
  if (settings != null) {
    builder.setSettings(settings);
  }
  CreateIndexResponse response = builder.execute().actionGet();
}
 

import org.elasticsearch.action.admin.indices.create.CreateIndexRequestBuilder; //导入方法依赖的package包/类
public void createIndexWith(String settings, String mapping) throws Exception {
  CreateIndexRequestBuilder req = esclient.client.admin().indices().prepareCreate(index);
  if (settings != null) {
    req.setSettings(settings);
  }
  if (mapping != null) {
    req.addMapping(mappingType.getSimpleName(), mapping);
  }
  CreateIndexResponse response = req.execute().actionGet();
}
 

import org.elasticsearch.action.admin.indices.create.CreateIndexRequestBuilder; //导入方法依赖的package包/类
private void createIndex(String index, Map<String, XContentBuilder> mappings) throws IOException {
    CreateIndexRequestBuilder builder = client.admin().indices().prepareCreate(index);
    builder.setSettings(createSettings("-1"));
    for (String configName: mappings.keySet())
        builder.addMapping(configName, mappings.get(configName));
    builder.execute().actionGet();
    getClient().admin().indices().prepareRefresh(index).execute().actionGet();
}
 

import org.elasticsearch.action.admin.indices.create.CreateIndexRequestBuilder; //导入方法依赖的package包/类
@Override
public BulkNodeClient newIndex(String index, Settings settings, Map<String, String> mappings) {
    if (closed) {
        throw new ElasticsearchException("client is closed");
    }
    if (client == null) {
        logger.warn("no client for create index");
        return this;
    }
    if (index == null) {
        logger.warn("no index name given to create index");
        return this;
    }
    CreateIndexRequestBuilder createIndexRequestBuilder =
            new CreateIndexRequestBuilder(client(), CreateIndexAction.INSTANCE).setIndex(index);
    if (settings != null) {
        logger.info("settings = {}", settings.getAsStructuredMap());
        createIndexRequestBuilder.setSettings(settings);
    }
    if (mappings != null) {
        for (String type : mappings.keySet()) {
            logger.info("found mapping for {}", type);
            createIndexRequestBuilder.addMapping(type, mappings.get(type));
        }
    }
    createIndexRequestBuilder.execute().actionGet();
    logger.info("index {} created", index);
    return this;
}